g_main.c

/*
Copyright (C) 1997-2001 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "g_local.h"

vec3_t DEBRIS_VELOCITY;
edict_t* DEBRIS_EDICT;
int DEBRIS_EXIST;
game_locals_t	game;
level_locals_t	level;
game_import_t	gi;
game_export_t	globals;
spawn_temp_t	st;

int	sm_meat_index;
int	snd_fry;
int meansOfDeath;
char* vmodel_backup;
int Sol_death5_start;
int Sol_death5_end;
edict_t* g_edicts;

cvar_t* deathmatch;
cvar_t* coop;
cvar_t* dmflags;
cvar_t* skill;
cvar_t* fraglimit;
cvar_t* timelimit;
cvar_t* password;
cvar_t* spectator_password;

cvar_t* needpass;
cvar_t* maxclients;
cvar_t* maxspectators;
cvar_t* maxentities;
cvar_t* g_select_empty;
cvar_t* dedicated;

cvar_t* filterban;
cvar_t* flashlightmode;
cvar_t* g_allowgrapple;  //QW// allows grapple use

cvar_t* sv_maxvelocity;
cvar_t* sv_gravity;

cvar_t* sv_rollspeed;
cvar_t* sv_rollangle;
cvar_t* gun_x;
cvar_t* gun_y;
cvar_t* gun_z;

cvar_t* run_pitch;
cvar_t* run_roll;
cvar_t* bob_up;
cvar_t* bob_pitch;
cvar_t* bob_roll;

cvar_t* sv_cheats;

cvar_t* flood_msgs;
cvar_t* flood_persecond;
cvar_t* flood_waitdelay;

cvar_t* sv_maplist;
cvar_t* jump_max_charge;
cvar_t* blaster_drop;
cvar_t* dm_items;
cvar_t* item_mod;
cvar_t* skyblend_minimum;
cvar_t* skyblend_maximum;
cvar_t* skyblend_speed;
cvar_t* sunblend;
cvar_t* real_shotgun_spread;
cvar_t* real_gibbing;
cvar_t* paranoia_mode;
void SpawnEntities(char* mapname, char* entities, char* spawnpoint);
void ClientThink(edict_t* ent, usercmd_t* cmd);
qboolean ClientConnect(edict_t* ent, char* userinfo);
void ClientUserinfoChanged(edict_t* ent, char* userinfo);
void ClientDisconnect(edict_t* ent);
void ClientBegin(edict_t* ent);
void ClientCommand(edict_t* ent);
void RunEntity(edict_t* ent);
void WriteGame(char* filename, qboolean autosave);
void ReadGame(char* filename);
void WriteLevel(char* filename);
void ReadLevel(char* filename);
void InitGame(void);
void G_RunFrame(void);


//===================================================================


void ShutdownGame(void)
{
	gi.dprintf("==== ShutdownGame Rampage ====\n");

	gi.FreeTags(TAG_LEVEL);
	gi.FreeTags(TAG_GAME);

#ifdef _WIN32
	OutputDebugString("ShutdownGame() was called.\n");
	OutputDebugString("Memory stats since startup.\n");
	_CrtMemDumpStatistics(&startup1);
	_CrtDumpMemoryLeaks();
#endif
}


/*
=================
GetGameAPI

Returns a pointer to the structure with all entry points
and global variables
=================
*/
game_export_t* GetGameAPI(game_import_t* import)
{
	gi = *import;

	globals.apiversion = GAME_API_VERSION;
	globals.Init = InitGame;
	globals.Shutdown = ShutdownGame;
	globals.SpawnEntities = SpawnEntities;

	globals.WriteGame = WriteGame;
	globals.ReadGame = ReadGame;
	globals.WriteLevel = WriteLevel;
	globals.ReadLevel = ReadLevel;

	globals.ClientThink = ClientThink;
	globals.ClientConnect = ClientConnect;
	globals.ClientUserinfoChanged = ClientUserinfoChanged;
	globals.ClientDisconnect = ClientDisconnect;
	globals.ClientBegin = ClientBegin;
	globals.ClientCommand = ClientCommand;

	globals.RunFrame = G_RunFrame;

	globals.ServerCommand = ServerCommand;

	globals.edict_size = sizeof(edict_t);

	return &globals;
}

#ifndef GAME_HARD_LINKED
// this is only here so the functions in q_shared.c and q_shwin.c can link
void Sys_Error(char* error, ...)
{
	va_list		argptr;
	char		text[1024];

	va_start(argptr, error);
	//	vsprintf (text, error, argptr);
	Q_vsnprintf(text, sizeof(text), error, argptr);	// Knightmare- buffer overflow fix
	va_end(argptr);

	gi.error(ERR_FATAL, "%s", text);
}

void Com_Printf(char* msg, ...)
{
	va_list		argptr;
	char		text[1024];

	va_start(argptr, msg);
	//	vsprintf (text, msg, argptr);
	Q_vsnprintf(text, sizeof(text), msg, argptr);	// Knightmare- buffer overflow fix
	va_end(argptr);

	gi.dprintf("%s", text);
}

#endif

//======================================================================


/*
=================
ClientEndServerFrames
=================
*/
void ClientEndServerFrames(void)
{
	int		i;
	edict_t* ent;

	// calc the player views now that all pushing
	// and damage has been added
	for (i = 0; i < maxclients->value; i++)
	{
		ent = g_edicts + 1 + i;
		if (!ent->inuse || !ent->client)
			continue;
		ClientEndServerFrame(ent);
	}
}

/*
=================
CreateTargetChangeLevel

Returns the created target changelevel
=================
*/
edict_t* CreateTargetChangeLevel(char* map)
{
	edict_t* ent;

	ent = G_Spawn();
	ent->classname = "target_changelevel";
	Com_sprintf(level.nextmap, sizeof(level.nextmap), "%s", map);
	ent->map = level.nextmap;
	return ent;
}

/*
=================
EndDMLevel

The timelimit or fraglimit has been exceeded
=================
*/
void EndDMLevel(void)
{
	edict_t* ent;
	char* s, * t, * f;
	static const char* seps = " ,\n\r";

	// stay on same level flag
	if ((int)dmflags->value & DF_SAME_LEVEL)
	{
		BeginIntermission(CreateTargetChangeLevel(level.mapname));
		return;
	}

	// see if it's in the map list
	if (*sv_maplist->string) {
		s = G_CopyString(sv_maplist->string);
		f = NULL;
		t = strtok(s, seps);
		while (t != NULL) {
			if (Q_stricmp(t, level.mapname) == 0) {
				// it's in the list, go to the next one
				t = strtok(NULL, seps);
				if (t == NULL) { // end of list, go to first one
					if (f == NULL) // there isn't a first one, same level
						BeginIntermission(CreateTargetChangeLevel(level.mapname));
					else
						BeginIntermission(CreateTargetChangeLevel(f));
				}
				else
					BeginIntermission(CreateTargetChangeLevel(t));
				gi.TagFree(s);
				return;
			}
			if (!f)
				f = t;
			t = strtok(NULL, seps);
		}
		gi.TagFree(s);
	}

	if (level.nextmap[0]) // go to a specific map
		BeginIntermission(CreateTargetChangeLevel(level.nextmap));
	else {	// search for a changelevel
		ent = G_Find(NULL, FOFS(classname), "target_changelevel");
		if (!ent)
		{	// the map designer didn't include a changelevel,
			// so create a fake ent that goes back to the same level
			BeginIntermission(CreateTargetChangeLevel(level.mapname));
			return;
		}
		BeginIntermission(ent);
	}
}


/*
=================
CheckNeedPass
=================
*/
void CheckNeedPass(void)
{
	int need;

	// if password or spectator_password has changed, update needpass
	// as needed
	if (password->modified || spectator_password->modified)
	{
		password->modified = spectator_password->modified = false;

		need = 0;

		if (*password->string && Q_stricmp(password->string, "none"))
			need |= 1;
		if (*spectator_password->string && Q_stricmp(spectator_password->string, "none"))
			need |= 2;

		gi.cvar_set("needpass", va("%d", need));
	}
}

/*
=================
CheckDMRules
=================
*/
void CheckDMRules(void)
{
	int			i;
	gclient_t* cl;

	if (level.intermissiontime)
		return;

	if (!deathmatch->value)
		return;

	if (timelimit->value)
	{
		if (level.time >= timelimit->value * 60)
		{
			gi.bprintf(PRINT_HIGH, "Timelimit hit.\n");
			EndDMLevel();
			return;
		}
	}

	if (fraglimit->value)
	{
		for (i = 0; i < maxclients->value; i++)
		{
			cl = game.clients + i;
			if (!g_edicts[i + 1].inuse)
				continue;

			if (cl->resp.score >= fraglimit->value)
			{
				gi.bprintf(PRINT_HIGH, "Fraglimit hit.\n");
				EndDMLevel();
				return;
			}
		}
	}
}


/*
=============
ExitLevel
=============
*/
void ExitLevel(void)
{
	int		i;
	edict_t* ent;
	char	command[256];

	Com_sprintf(command, sizeof(command), "gamemap \"%s\"\n", level.changemap);
	gi.AddCommandString(command);
	level.changemap = NULL;
	level.exitintermission = 0;
	level.intermissiontime = 0;
	ClientEndServerFrames();

	// clear some things before going to next level
	for (i = 0; i < maxclients->value; i++)
	{
		ent = g_edicts + 1 + i;
		if (!ent->inuse)
			continue;
		if (ent->health > ent->client->pers.max_health)
			ent->health = ent->client->pers.max_health;
	}

}

/*
================
G_RunFrame

Advances the world by 0.1 seconds
================
*/
//int GOT_IT;

void search_for_entity()
{

	int			i;
	edict_t* e;

	e = &g_edicts[(int)maxclients->value + 1];

	for (i = maxclients->value + 1; i < globals.num_edicts; i++, e++)
	{
		if (!strcmp(e->classname, "muzzleflash") && e->ctime + 1 < level.time)
			gi.bprintf(PRINT_HIGH, "DEBUG: MUZZLEFLASH EXISTS, frame = %i, count = %i\n", e->s.frame, e->count);
	}
}

void G_RunFrame(void)
{
	int		i;
	edict_t* ent, * old_ent;
	//char* oldclassname;
	level.framenum++;
	level.time = level.framenum * FRAMETIME;

	// choose a client for monsters to target this frame
	AI_SetSightClient();

	// exit intermissions

	if (level.exitintermission)
	{
		ExitLevel();
		return;
	}

	//search_for_entity();
	//
	// treat each object in turn
	// even the world gets a chance to think
	//
	ent = &g_edicts[0];
	old_ent = &g_edicts[0];
	for (i = 0; i < globals.num_edicts; i++, ent++)
	{
		if (!ent->inuse)
			continue;

		//if (DEBRIS_EXISTS == 1 && !VectorCompare(DEBRIS_EDICT->velocity, DEBRIS_VELOCITY) && !GOT_IT)
		//{
		//	gi.bprintf(PRINT_HIGH, "SV PHYSICS TOSS, DEBRIS_EXISTS = %i\n", DEBRIS_EXISTS);
		//	gi.bprintf(PRINT_HIGH, "SV PHYSICS TOSS, DEBRIS: cp = %s, co = %s, cc = %s, vel1 = %s, vel2 = %s\n",
		//		old_ent->classname, oldclassname, ent->classname, vtos(DEBRIS_EDICT->velocity), vtos(DEBRIS_VELOCITY));
		//	GOT_IT = 1;
		//}
		//old_ent = ent;
		//oldclassname = ent->classname;

		level.current_entity = ent;

		if (!ent->client)
			VectorCopy(ent->s.origin, ent->s.old_origin); //this is returning current origin when needed, wtf?
		// if the ground entity moved, make sure we are still on it
		if ((ent->groundentity) && (ent->groundentity->linkcount != ent->groundentity_linkcount))
		{
			ent->groundentity = NULL;
			if (!(ent->flags & (FL_SWIM | FL_FLY)) && (ent->svflags & SVF_MONSTER))
			{
				M_CheckGround(ent);
			}
		}

		if (i > 0 && i <= maxclients->value)
		{
			ClientBeginServerFrame(ent);
			continue;
		}

		G_RunEntity(ent);
	}

	// see if it is time to end a deathmatch
	CheckDMRules();

	// see if needpass needs updated
	CheckNeedPass();

	// build the playerstate_t structures for all players
	ClientEndServerFrames();
}