Quake-III-Arena

QE3.CPP (14574B)

---

 /*
 ===========================================================================
 Copyright (C) 1999-2005 Id Software, Inc.
 
 This file is part of Quake III Arena source code.
 
 Quake III Arena source code 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.
 
 Quake III Arena source code 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 Foobar; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 #include "stdafx.h"
 #include "qe3.h"
 #include "PrefsDlg.h"
 #include <direct.h>  
 #include <sys\stat.h> 
 
 QEGlobals_t  g_qeglobals;
 
 void WINAPI QE_CheckOpenGLForErrors(void)
 {
   CString strMsg;
   int i = qglGetError();
   if (i != GL_NO_ERROR)
   {
     if (i == GL_OUT_OF_MEMORY)
     {
       //strMsg.Format("OpenGL out of memory error %s\nDo you wish to save before exiting?", qgluErrorString((GLenum)i));
       if (MessageBox(g_qeglobals.d_hwndMain, strMsg, "Q3Radiant Error", MB_YESNO) == IDYES)
       {
         Map_SaveFile(NULL, false);
       }
 		  exit(1);
     }
     else
     {
       //strMsg.Format("Warning: OpenGL Error %s\n ", qgluErrorString((GLenum)i));
 		  Sys_Printf (strMsg.GetBuffer(0));
     }
   }
 }
 
 
 char *ExpandReletivePath (char *p)
 {
 	static char	temp[1024];
 	char	*base;
 
 	if (!p || !p[0])
 		return NULL;
 	if (p[0] == '/' || p[0] == '\\')
 		return p;
 
 	base = ValueForKey(g_qeglobals.d_project_entity, "basepath");
 	sprintf (temp, "%s/%s", base, p);
 	return temp;
 }
 
 char *copystring (char *s)
 {
 	char	*b;
 	b = (char*)malloc(strlen(s)+1);
 	strcpy (b,s);
 	return b;
 }
 
 
 bool DoesFileExist(const char* pBuff, long& lSize)
 {
   CFile file;
   if (file.Open(pBuff, CFile::modeRead | CFile::shareDenyNone))
   {
     lSize += file.GetLength();
     file.Close();
     return true;
   }
   return false;
 }
 
 
 void Map_Snapshot()
 {
   CString strMsg;
   // we need to do the following
   // 1. make sure the snapshot directory exists (create it if it doesn't)
   // 2. find out what the lastest save is based on number
   // 3. inc that and save the map
   CString strOrgPath, strOrgFile;
   ExtractPath_and_Filename(currentmap, strOrgPath, strOrgFile);
   AddSlash(strOrgPath);
   strOrgPath += "snapshots";
   bool bGo = true;
   struct _stat Stat;
   if (_stat(strOrgPath, &Stat) == -1)
   {
     bGo = (_mkdir(strOrgPath) != -1);
   }
   AddSlash(strOrgPath);
   if (bGo)
   {
     int nCount = 0;
     long lSize = 0;
     CString strNewPath = strOrgPath;
     strNewPath += strOrgFile;
     CString strFile;
     while (bGo)
     {
       strFile.Format("%s.%i", strNewPath, nCount);
       bGo = DoesFileExist(strFile, lSize);
       nCount++;
     }
     // strFile has the next available slot
     Map_SaveFile(strFile.GetBuffer(0), false);
 		Sys_SetTitle (currentmap);
     if (lSize > 12 * 1024 * 1024) // total size of saves > 4 mb
     {
       Sys_Printf("The snapshot files in the [%s] directory total more than 4 megabytes. You might consider cleaning the directory up.", strOrgPath);
     }
   }
   else
   {
     strMsg.Format("Snapshot save failed.. unabled to create directory\n%s", strOrgPath);
     g_pParentWnd->MessageBox(strMsg);
   }
 }
 /*
 ===============
 QE_CheckAutoSave
 
 If five minutes have passed since making a change
 and the map hasn't been saved, save it out.
 ===============
 */
 
 
 void QE_CheckAutoSave( void )
 {
 	static clock_t s_start;
 	clock_t        now;
 
 	now = clock();
 
 	if ( modified != 1 || !s_start)
 	{
 		s_start = now;
 		return;
 	}
 
 	if ( now - s_start > ( CLOCKS_PER_SEC * 60 * g_PrefsDlg.m_nAutoSave))
 	{
 
     if (g_PrefsDlg.m_bAutoSave)
     {
       CString strMsg = g_PrefsDlg.m_bSnapShots ? "Autosaving snapshot..." : "Autosaving...";
 		  Sys_Printf(strMsg.GetBuffer(0));
       Sys_Printf("\n");
 		  Sys_Status (strMsg.GetBuffer(0),0);
 
       // only snapshot if not working on a default map
       if (g_PrefsDlg.m_bSnapShots && stricmp(currentmap, "unnamed.map") != 0)
       {
         Map_Snapshot();
       }
       else
       {
 		    Map_SaveFile (ValueForKey(g_qeglobals.d_project_entity, "autosave"), false);
       }
 
 		  Sys_Status ("Autosaving...Saved.", 0 );
 		  modified = 2;
     }
     else
     {
 		  Sys_Printf ("Autosave skipped...\n");
 		  Sys_Status ("Autosave skipped...", 0 );
     }
 		s_start = now;
 	}
 }
 
 
 int BuildShortPathName(const char* pPath, char* pBuffer, int nBufferLen)
 {
   char *pFile = NULL;
   int nResult = GetFullPathName(pPath, nBufferLen, pBuffer, &pFile); 
   nResult = GetShortPathName(pPath, pBuffer, nBufferLen);
   if (nResult == 0)
     strcpy(pBuffer, pPath);                     // Use long filename
   return nResult;
 }
 
 
 
 const char *g_pPathFixups[]=
 {
   "basepath",
   "remotebasepath",
   "entitypath",
   "texturepath",
   "autosave",
   "mapspath"
 };
 
 const int g_nPathFixupCount = sizeof(g_pPathFixups) / sizeof(const char*);
 
 /*
 ===========
 QE_LoadProject
 ===========
 */
 qboolean QE_LoadProject (char *projectfile)
 {
 	char	*data;
 
 	Sys_Printf ("QE_LoadProject (%s)\n", projectfile);
 	
 	if ( LoadFileNoCrash (projectfile, (void **)&data) == -1)
 		return false;
 	
 	g_strProject = projectfile;
 	
 	CString strData = data;
 	free(data);
 	
 	CString strQ2Path = g_PrefsDlg.m_strQuake2;
 	CString strQ2File;
 	ExtractPath_and_Filename(g_PrefsDlg.m_strQuake2, strQ2Path, strQ2File);
 	AddSlash(strQ2Path);
 	
 	
 	char* pBuff = new char[1024];
 	
 	BuildShortPathName(strQ2Path, pBuff, 1024);
 	FindReplace(strData, "__Q2PATH", pBuff);
 	BuildShortPathName(g_strAppPath, pBuff, 1024);
 	FindReplace(strData, "__QERPATH", pBuff);
 	
 	char* pFile;
 	if (GetFullPathName(projectfile, 1024, pBuff, &pFile))
 	{
 		g_PrefsDlg.m_strLastProject = pBuff;
 		BuildShortPathName(g_PrefsDlg.m_strLastProject, pBuff, 1024);
 		g_PrefsDlg.m_strLastProject = pBuff;
 		g_PrefsDlg.SavePrefs();
 		
 		ExtractPath_and_Filename(pBuff, strQ2Path, strQ2File);
 		int nLen = strQ2Path.GetLength();
 		if (nLen > 0)
 		{
 			if (strQ2Path[nLen - 1] == '\\')
 				strQ2Path.SetAt(nLen-1,'\0');
 			char* pBuffer = strQ2Path.GetBufferSetLength(_MAX_PATH + 1);
 			int n = strQ2Path.ReverseFind('\\');
 			if (n >=0 )
 				pBuffer[n + 1] = '\0';
 			strQ2Path.ReleaseBuffer();
 			FindReplace(strData, "__QEPROJPATH", strQ2Path);
 		}
 	}
 	
 	
 	StartTokenParsing (strData.GetBuffer(0));
 	g_qeglobals.d_project_entity = Entity_Parse (true);
 	if (!g_qeglobals.d_project_entity)
 		Error ("Couldn't parse %s", projectfile);
 
   for (int i = 0; i < g_nPathFixupCount; i++)
   {
     char *pPath = ValueForKey (g_qeglobals.d_project_entity, g_pPathFixups[i]);
     if (pPath[0] != '\\' && pPath[0] != '/')
     {
 	    if (GetFullPathName(pPath, 1024, pBuff, &pFile))
       {
         SetKeyValue(g_qeglobals.d_project_entity, g_pPathFixups[i], pBuff);
       }
     }
   }
 
 	delete []pBuff;
 
 	// set here some default project settings you need
 	if ( strlen( ValueForKey( g_qeglobals.d_project_entity, "brush_primit" ) ) == 0 )
 	{
 		SetKeyValue( g_qeglobals.d_project_entity, "brush_primit", "0" );
 	}
 
 	g_qeglobals.m_bBrushPrimitMode = IntForKey( g_qeglobals.d_project_entity, "brush_primit" );
 
 
 	Eclass_InitForSourceDirectory (ValueForKey (g_qeglobals.d_project_entity, "entitypath"));
 	FillClassList();		// list in entity window
 	
 	Map_New();
 	
 	
 	FillTextureMenu();
 	FillBSPMenu();
 	
 	return true;
 }
 
 /*
 ===========
 QE_SaveProject
 ===========
 */
 //extern char	*bsp_commands[256];
 
 qboolean QE_SaveProject (const char* pProjectFile)
 {
 	//char	filename[1024];
 	FILE	*fp;
 	epair_t	*ep;
 
 	//sprintf (filename, "%s\\%s.prj", g_projectdir, g_username);
 
 	if (!(fp = fopen (pProjectFile, "w+")))
 		Error ("Could not open project file!");
 	
 	fprintf (fp, "{\n");
 	for (ep = g_qeglobals.d_project_entity->epairs; ep; ep=ep->next)
 		fprintf (fp, "\"%s\" \"%s\"\n", ep->key, ep->value);
 	fprintf (fp, "}\n");
 
 	fclose (fp);
 	
 	return TRUE;
 }
 
 
 
 /*
 ===========
 QE_KeyDown
 ===========
 */
 #define	SPEED_MOVE	32
 #define	SPEED_TURN	22.5
 
 
 /*
 ===============
 ConnectEntities
 
 Sets target / targetname on the two entities selected
 from the first selected to the secon
 ===============
 */
 void ConnectEntities (void)
 {
 	entity_t	*e1, *e2, *e;
 	char		*target, *tn;
 	int			maxtarg, targetnum;
 	char		newtarg[32];
 
 	if (g_qeglobals.d_select_count != 2)
 	{
 		Sys_Status ("Must have two brushes selected.", 0);
 		Sys_Beep ();
 		return;
 	}
 
 	e1 = g_qeglobals.d_select_order[0]->owner;
 	e2 = g_qeglobals.d_select_order[1]->owner;
 
 	if (e1 == world_entity || e2 == world_entity)
 	{
 		Sys_Status ("Can't connect to the world.", 0);
 		Sys_Beep ();
 		return;
 	}
 
 	if (e1 == e2)
 	{
 		Sys_Status ("Brushes are from same entity.", 0);
 		Sys_Beep ();
 		return;
 	}
 
 	target = ValueForKey (e1, "target");
 	if (target && target[0])
 		strcpy (newtarg, target);
 	else
 	{
 		target = ValueForKey (e2, "targetname");
 		if (target && target[0])
 			strcpy (newtarg, target);
 		else
 		{
 			// make a unique target value
 			maxtarg = 0;
 			for (e=entities.next ; e != &entities ; e=e->next)
 			{
 				tn = ValueForKey (e, "targetname");
 				if (tn && tn[0])
 				{
 					targetnum = atoi(tn+1);
 					if (targetnum > maxtarg)
 						maxtarg = targetnum;
 				}
 			}
 			sprintf (newtarg, "t%i", maxtarg+1);
 		}
 	}
 
 	SetKeyValue (e1, "target", newtarg);
 	SetKeyValue (e2, "targetname", newtarg);
 	Sys_UpdateWindows (W_XY | W_CAMERA);
 
 	Select_Deselect();
 	Select_Brush (g_qeglobals.d_select_order[1]);
 }
 
 qboolean QE_SingleBrush (bool bQuiet)
 {
 	if ( (selected_brushes.next == &selected_brushes)
 		|| (selected_brushes.next->next != &selected_brushes) )
 	{
 	  if (!bQuiet)
     {
 	  	Sys_Printf ("Error: you must have a single brush selected\n");
 	  }
 		return false;
 	}
 	if (selected_brushes.next->owner->eclass->fixedsize)
 	{
 	  if (!bQuiet)
 	  {
 		  Sys_Printf ("Error: you cannot manipulate fixed size entities\n");
 	  }
 		return false;
 	}
 
 	return true;
 }
 
 void QE_Init (void)
 {
 	/*
 	** initialize variables
 	*/
 	g_qeglobals.d_gridsize = 8;
 	g_qeglobals.d_showgrid = true;
 
 	/*
 	** other stuff
 	*/
 	Texture_Init (true);
 	//Cam_Init ();
 	//XY_Init ();
 	Z_Init ();
 	Terrain_Init();
 }
 
 void WINAPI QE_ConvertDOSToUnixName( char *dst, const char *src )
 {
 	while ( *src )
 	{
 		if ( *src == '\\' )
 			*dst = '/';
 		else
 			*dst = *src;
 		dst++; src++;
 	}
 	*dst = 0;
 }
 
 int g_numbrushes, g_numentities;
 
 void QE_CountBrushesAndUpdateStatusBar( void )
 {
 	static int      s_lastbrushcount, s_lastentitycount;
 	static qboolean s_didonce;
 	
 	//entity_t   *e;
 	brush_t	   *b, *next;
 
 	g_numbrushes = 0;
 	g_numentities = 0;
 	
 	if ( active_brushes.next != NULL )
 	{
 		for ( b = active_brushes.next ; b != NULL && b != &active_brushes ; b=next)
 		{
 			next = b->next;
 			if (b->brush_faces )
 			{
 				if ( !b->owner->eclass->fixedsize)
 					g_numbrushes++;
 				else
 					g_numentities++;
 			}
 		}
 	}
 /*
 	if ( entities.next != NULL )
 	{
 		for ( e = entities.next ; e != &entities && g_numentities != MAX_MAP_ENTITIES ; e = e->next)
 		{
 			g_numentities++;
 		}
 	}
 */
 	if ( ( ( g_numbrushes != s_lastbrushcount ) || ( g_numentities != s_lastentitycount ) ) || ( !s_didonce ) )
 	{
 		Sys_UpdateStatusBar();
 
 		s_lastbrushcount = g_numbrushes;
 		s_lastentitycount = g_numentities;
 		s_didonce = true;
 	}
 }
 
 char		com_token[1024];
 qboolean	com_eof;
 
 /*
 ================
 I_FloatTime
 ================
 */
 double I_FloatTime (void)
 {
 	time_t	t;
 	
 	time (&t);
 	
 	return t;
 #if 0
 // more precise, less portable
 	struct timeval tp;
 	struct timezone tzp;
 	static int		secbase;
 
 	gettimeofday(&tp, &tzp);
 	
 	if (!secbase)
 	{
 		secbase = tp.tv_sec;
 		return tp.tv_usec/1000000.0;
 	}
 	
 	return (tp.tv_sec - secbase) + tp.tv_usec/1000000.0;
 #endif
 }
 
 
 /*
 ==============
 COM_Parse
 
 Parse a token out of a string
 ==============
 */
 char *COM_Parse (char *data)
 {
 	int		c;
 	int		len;
 	
 	len = 0;
 	com_token[0] = 0;
 	
 	if (!data)
 		return NULL;
 		
 // skip whitespace
 skipwhite:
 	while ( (c = *data) <= ' ')
 	{
 		if (c == 0)
 		{
 			com_eof = true;
 			return NULL;			// end of file;
 		}
 		data++;
 	}
 	
 // skip // comments
 	if (c=='/' && data[1] == '/')
 	{
 		while (*data && *data != '\n')
 			data++;
 		goto skipwhite;
 	}
 	
 
 // handle quoted strings specially
 	if (c == '\"')
 	{
 		data++;
 		do
 		{
 			c = *data++;
 			if (c=='\"')
 			{
 				com_token[len] = 0;
 				return data;
 			}
 			com_token[len] = c;
 			len++;
 		} while (1);
 	}
 
 // parse single characters
 	if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
 	{
 		com_token[len] = c;
 		len++;
 		com_token[len] = 0;
 		return data+1;
 	}
 
 // parse a regular word
 	do
 	{
 		com_token[len] = c;
 		data++;
 		len++;
 		c = *data;
 	if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
 			break;
 	} while (c>32);
 	
 	com_token[len] = 0;
 	return data;
 }
 
 
 
 /*
 =============================================================================
 
 						MISC FUNCTIONS
 
 =============================================================================
 */
 
 
 int		argc;
 char	*argv[MAX_NUM_ARGVS];
 
 /*
 ============
 ParseCommandLine
 ============
 */
 void ParseCommandLine (char *lpCmdLine)
 {
 	argc = 1;
 	argv[0] = "programname";
 
 	while (*lpCmdLine && (argc < MAX_NUM_ARGVS))
 	{
 		while (*lpCmdLine && ((*lpCmdLine <= 32) || (*lpCmdLine > 126)))
 			lpCmdLine++;
 
 		if (*lpCmdLine)
 		{
 			argv[argc] = lpCmdLine;
 			argc++;
 
 			while (*lpCmdLine && ((*lpCmdLine > 32) && (*lpCmdLine <= 126)))
 				lpCmdLine++;
 
 			if (*lpCmdLine)
 			{
 				*lpCmdLine = 0;
 				lpCmdLine++;
 			}
 			
 		}
 	}
 }
 
 
 
 /*
 =================
 CheckParm
 
 Checks for the given parameter in the program's command line arguments
 Returns the argument number (1 to argc-1) or 0 if not present
 =================
 */
 int CheckParm (char *check)
 {
 	int             i;
 
 	for (i = 1;i<argc;i++)
 	{
 		if ( stricmp(check, argv[i]) )
 			return i;
 	}
 
 	return 0;
 }
 
 
 
 
 /*
 ==============
 ParseNum / ParseHex
 ==============
 */
 int ParseHex (char *hex)
 {
 	char    *str;
 	int    num;
 
 	num = 0;
 	str = hex;
 
 	while (*str)
 	{
 		num <<= 4;
 		if (*str >= '0' && *str <= '9')
 			num += *str-'0';
 		else if (*str >= 'a' && *str <= 'f')
 			num += 10 + *str-'a';
 		else if (*str >= 'A' && *str <= 'F')
 			num += 10 + *str-'A';
 		else
 			Error ("Bad hex number: %s",hex);
 		str++;
 	}
 
 	return num;
 }
 
 
 int ParseNum (char *str)
 {
 	if (str[0] == '$')
 		return ParseHex (str+1);
 	if (str[0] == '0' && str[1] == 'x')
 		return ParseHex (str+2);
 	return atol (str);
 }