#include "g_local.h"

Functions
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)

game_export_t *	GetGameAPI (game_import_t *import)

void	Sys_Error (char *error,...)

void	Com_Printf (char *msg,...)

void	ClientEndServerFrames (void)

edict_t *	CreateTargetChangeLevel (char *map)

void	EndDMLevel (void)

void	CheckNeedPass (void)

void	CheckDMRules (void)

void	ExitLevel (void)

Variables
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

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 *	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 *	gib_on

Function Documentation

◆ CheckDMRules()

void CheckDMRules ( void )

Definition at line 306 of file g_main.c.

 {
     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;
             }
         }
     }
 }

Referenced by G_RunFrame().

◆ CheckNeedPass()

void CheckNeedPass ( void )

Definition at line 280 of file g_main.c.

 {
     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));
     }
 }

Referenced by G_RunFrame().

◆ ClientBegin()

void ClientBegin ( edict_t * ent )

Definition at line 1305 of file p_client.c.

 {
     int     i;
  
     ent->client = game.clients + (ent - g_edicts - 1);
  
     if (deathmatch->value)
     {
         ClientBeginDeathmatch (ent);
         return;
     }
  
     // if there is already a body waiting for us (a loadgame), just
     // take it, otherwise spawn one from scratch
     if (ent->inuse == true)
     {
         // the client has cleared the client side viewangles upon
         // connecting to the server, which is different than the
         // state when the game is saved, so we need to compensate
         // with deltaangles
         for (i=0 ; i<3 ; i++)
             ent->client->ps.pmove.delta_angles[i] = ANGLE2SHORT(ent->client->ps.viewangles[i]);
     }
     else
     {
         // a spawn point will completely reinitialize the entity
         // except for the persistant data that was initialized at
         // ClientConnect() time
         G_InitEdict (ent);
         ent->classname = "player";
         InitClientResp (ent->client);
         PutClientInServer (ent);
     }
  
     if (level.intermissiontime)
     {
         MoveClientToIntermission (ent);
     }
     else
     {
         // send effect if in a multiplayer game
         if (game.maxclients > 1)
         {
             gi.WriteByte (svc_muzzleflash);
             gi.WriteShort (ent-g_edicts);
             gi.WriteByte (MZ_LOGIN);
             gi.multicast (ent->s.origin, MULTICAST_PVS);
  
             gi.bprintf (PRINT_HIGH, "%s entered the game\n", ent->client->pers.netname);
         }
     }
  
     // make sure all view stuff is valid
     ClientEndServerFrame (ent);
 }

Referenced by GetGameAPI().

◆ ClientCommand()

void ClientCommand ( edict_t * ent )

Definition at line 909 of file g_cmds.c.

 {
     char    *cmd;
  
     if (!ent->client)
         return;     // not fully in game yet
  
     cmd = gi.argv(0);
  
     if (Q_stricmp (cmd, "players") == 0)
     {
         Cmd_Players_f (ent);
         return;
     }
     if (Q_stricmp (cmd, "say") == 0)
     {
         Cmd_Say_f (ent, false, false);
         return;
     }
     if (Q_stricmp (cmd, "say_team") == 0)
     {
         Cmd_Say_f (ent, true, false);
         return;
     }
     if (Q_stricmp (cmd, "score") == 0)
     {
         Cmd_Score_f (ent);
         return;
     }
     if (Q_stricmp (cmd, "help") == 0)
     {
         Cmd_Help_f (ent);
         return;
     }
  
     if (level.intermissiontime)
         return;
  
     if (Q_stricmp (cmd, "use") == 0)
         Cmd_Use_f (ent);
     else if (Q_stricmp (cmd, "drop") == 0)
         Cmd_Drop_f (ent);
     else 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, "notarget") == 0)
         Cmd_Notarget_f (ent);
     else if (Q_stricmp (cmd, "noclip") == 0)
         Cmd_Noclip_f (ent);
     else if (Q_stricmp (cmd, "inven") == 0)
         Cmd_Inven_f (ent);
     else if (Q_stricmp (cmd, "invnext") == 0)
         SelectNextItem (ent, -1);
     else if (Q_stricmp (cmd, "invprev") == 0)
         SelectPrevItem (ent, -1);
     else if (Q_stricmp (cmd, "invnextw") == 0)
         SelectNextItem (ent, IT_WEAPON);
     else if (Q_stricmp (cmd, "invprevw") == 0)
         SelectPrevItem (ent, IT_WEAPON);
     else if (Q_stricmp (cmd, "invnextp") == 0)
         SelectNextItem (ent, IT_POWERUP);
     else if (Q_stricmp (cmd, "invprevp") == 0)
         SelectPrevItem (ent, IT_POWERUP);
     else if (Q_stricmp (cmd, "invuse") == 0)
         Cmd_InvUse_f (ent);
     else if (Q_stricmp (cmd, "invdrop") == 0)
         Cmd_InvDrop_f (ent);
     else if (Q_stricmp (cmd, "weapprev") == 0)
         Cmd_WeapPrev_f (ent);
     else if (Q_stricmp (cmd, "weapnext") == 0)
         Cmd_WeapNext_f (ent);
     else if (Q_stricmp (cmd, "weaplast") == 0)
         Cmd_WeapLast_f (ent);
     else if (Q_stricmp (cmd, "kill") == 0)
         Cmd_Kill_f (ent);
     else if (Q_stricmp (cmd, "putaway") == 0)
         Cmd_PutAway_f (ent);
     else if (Q_stricmp (cmd, "wave") == 0)
         Cmd_Wave_f (ent);
     else if (Q_stricmp(cmd, "playerlist") == 0)
         Cmd_PlayerList_f(ent);
     else    // anything that doesn't match a command will be a chat
         Cmd_Say_f (ent, false, true);
 }

Referenced by GetGameAPI().

◆ ClientConnect()

qboolean ClientConnect	(	edict_t *	ent,
		char *	userinfo
	)

Definition at line 1440 of file p_client.c.

 {
     char    *value;
  
     // check to see if they are on the banned IP list
     value = Info_ValueForKey (userinfo, "ip");
     if (SV_FilterPacket(value)) {
         Info_SetValueForKey(userinfo, "rejmsg", "Banned.");
         return false;
     }
  
     // check for a spectator
     value = Info_ValueForKey (userinfo, "spectator");
     if (deathmatch->value && *value && strcmp(value, "0")) {
         int i, numspec;
  
         if (*spectator_password->string && 
             strcmp(spectator_password->string, "none") && 
             strcmp(spectator_password->string, value)) {
             Info_SetValueForKey(userinfo, "rejmsg", "Spectator password required or incorrect.");
             return false;
         }
  
         // count spectators
         for (i = numspec = 0; i < maxclients->value; i++)
             if (g_edicts[i+1].inuse && g_edicts[i+1].client->pers.spectator)
                 numspec++;
  
         if (numspec >= maxspectators->value) {
             Info_SetValueForKey(userinfo, "rejmsg", "Server spectator limit is full.");
             return false;
         }
     } else {
         // check for a password
         value = Info_ValueForKey (userinfo, "password");
         if (*password->string && strcmp(password->string, "none") && 
             strcmp(password->string, value)) {
             Info_SetValueForKey(userinfo, "rejmsg", "Password required or incorrect.");
             return false;
         }
     }
  
  
     // they can connect
     ent->client = game.clients + (ent - g_edicts - 1);
  
     // if there is already a body waiting for us (a loadgame), just
     // take it, otherwise spawn one from scratch
     if (ent->inuse == false)
     {
         // clear the respawning variables
         InitClientResp (ent->client);
         if (!game.autosaved || !ent->client->pers.weapon)
             InitClientPersistant (ent->client);
     }
  
     ClientUserinfoChanged (ent, userinfo);
  
     if (game.maxclients > 1)
         gi.dprintf ("%s connected\n", ent->client->pers.netname);
  
     ent->svflags = 0; // make sure we start with known default
     ent->client->pers.connected = true;
     return true;
 }

Referenced by GetGameAPI().

◆ ClientDisconnect()

void ClientDisconnect ( edict_t * ent )

Definition at line 1514 of file p_client.c.

 {
     int     playernum;
  
     if (!ent->client)
         return;
  
     gi.bprintf (PRINT_HIGH, "%s disconnected\n", ent->client->pers.netname);
  
     // send effect
     gi.WriteByte (svc_muzzleflash);
     gi.WriteShort (ent-g_edicts);
     gi.WriteByte (MZ_LOGOUT);
     gi.multicast (ent->s.origin, MULTICAST_PVS);
  
     gi.unlinkentity (ent);
     ent->s.modelindex = 0;
     ent->solid = SOLID_NOT;
     ent->inuse = false;
     ent->classname = "disconnected";
     ent->client->pers.connected = false;
  
     playernum = ent-g_edicts-1;
     gi.configstring (CS_PLAYERSKINS+playernum, "");
 }

Referenced by GetGameAPI().

◆ ClientEndServerFrames()

void ClientEndServerFrames ( void )

Definition at line 179 of file g_main.c.

 {
     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);
     }
  
 }

Referenced by ExitLevel(), and G_RunFrame().

◆ ClientThink()

void ClientThink	(	edict_t *	ent,
		usercmd_t *	cmd
	)

Definition at line 1580 of file p_client.c.

 {
     gclient_t   *client;
     edict_t *other;
     int     i, j;
     pmove_t pm;
  
     level.current_entity = ent;
     client = ent->client;
  
     if (level.intermissiontime)
     {
         client->ps.pmove.pm_type = PM_FREEZE;
         // can exit intermission after five seconds
         if (level.time > level.intermissiontime + 5.0 
             && (ucmd->buttons & BUTTON_ANY) )
             level.exitintermission = true;
         return;
     }
  
     pm_passent = ent;
  
     if (ent->client->chase_target) {
  
         client->resp.cmd_angles[0] = SHORT2ANGLE(ucmd->angles[0]);
         client->resp.cmd_angles[1] = SHORT2ANGLE(ucmd->angles[1]);
         client->resp.cmd_angles[2] = SHORT2ANGLE(ucmd->angles[2]);
  
     } else {
  
         // set up for pmove
         memset (&pm, 0, sizeof(pm));
  
         if (ent->movetype == MOVETYPE_NOCLIP)
             client->ps.pmove.pm_type = PM_SPECTATOR;
         else if (ent->s.modelindex != 255)
             client->ps.pmove.pm_type = PM_GIB;
         else if (ent->deadflag)
             client->ps.pmove.pm_type = PM_DEAD;
         else
             client->ps.pmove.pm_type = PM_NORMAL;
  
         client->ps.pmove.gravity = sv_gravity->value;
         pm.s = client->ps.pmove;
  
         for (i=0 ; i<3 ; i++)
         {
             pm.s.origin[i] = ent->s.origin[i]*8;
             pm.s.velocity[i] = ent->velocity[i]*8;
         }
  
         if (memcmp(&client->old_pmove, &pm.s, sizeof(pm.s)))
         {
             pm.snapinitial = true;
     //      gi.dprintf ("pmove changed!\n");
         }
  
         pm.cmd = *ucmd;
  
         pm.trace = PM_trace;    // adds default parms
         pm.pointcontents = gi.pointcontents;
  
         // perform a pmove
         gi.Pmove (&pm);
  
         // save results of pmove
         client->ps.pmove = pm.s;
         client->old_pmove = pm.s;
  
         for (i=0 ; i<3 ; i++)
         {
             ent->s.origin[i] = pm.s.origin[i]*0.125;
             ent->velocity[i] = pm.s.velocity[i]*0.125;
         }
  
         VectorCopy (pm.mins, ent->mins);
         VectorCopy (pm.maxs, ent->maxs);
  
         client->resp.cmd_angles[0] = SHORT2ANGLE(ucmd->angles[0]);
         client->resp.cmd_angles[1] = SHORT2ANGLE(ucmd->angles[1]);
         client->resp.cmd_angles[2] = SHORT2ANGLE(ucmd->angles[2]);
  
         if (ent->groundentity && !pm.groundentity && (pm.cmd.upmove >= 10) && (pm.waterlevel == 0))
         {
             gi.sound(ent, CHAN_VOICE, gi.soundindex("*jump1.wav"), 1, ATTN_NORM, 0);
             PlayerNoise(ent, ent->s.origin, PNOISE_SELF);
         }
  
         ent->viewheight = pm.viewheight;
         ent->waterlevel = pm.waterlevel;
         ent->watertype = pm.watertype;
         ent->groundentity = pm.groundentity;
         if (pm.groundentity)
             ent->groundentity_linkcount = pm.groundentity->linkcount;
  
         if (ent->deadflag)
         {
             client->ps.viewangles[ROLL] = 40;
             client->ps.viewangles[PITCH] = -15;
             client->ps.viewangles[YAW] = client->killer_yaw;
         }
         else
         {
             VectorCopy (pm.viewangles, client->v_angle);
             VectorCopy (pm.viewangles, client->ps.viewangles);
         }
  
         gi.linkentity (ent);
  
         if (ent->movetype != MOVETYPE_NOCLIP)
             G_TouchTriggers (ent);
  
         // touch other objects
         for (i=0 ; i<pm.numtouch ; i++)
         {
             other = pm.touchents[i];
             for (j=0 ; j<i ; j++)
                 if (pm.touchents[j] == other)
                     break;
             if (j != i)
                 continue;   // duplicated
             if (!other->touch)
                 continue;
             other->touch (other, ent, NULL, NULL);
         }
  
     }
  
     client->oldbuttons = client->buttons;
     client->buttons = ucmd->buttons;
     client->latched_buttons |= client->buttons & ~client->oldbuttons;
  
     // save light level the player is standing on for
     // monster sighting AI
     ent->light_level = ucmd->lightlevel;
  
     // fire weapon from final position if needed
     if (client->latched_buttons & BUTTON_ATTACK)
     {
         if (client->resp.spectator) {
  
             client->latched_buttons = 0;
  
             if (client->chase_target) {
                 client->chase_target = NULL;
                 client->ps.pmove.pm_flags &= ~PMF_NO_PREDICTION;
             } else
                 GetChaseTarget(ent);
  
         } else if (!client->weapon_thunk) {
             client->weapon_thunk = true;
             Think_Weapon (ent);
         }
     }
  
     if (client->resp.spectator) {
         if (ucmd->upmove >= 10) {
             if (!(client->ps.pmove.pm_flags & PMF_JUMP_HELD)) {
                 client->ps.pmove.pm_flags |= PMF_JUMP_HELD;
                 if (client->chase_target)
                     ChaseNext(ent);
                 else
                     GetChaseTarget(ent);
             }
         } else
             client->ps.pmove.pm_flags &= ~PMF_JUMP_HELD;
     }
  
     // update chase cam if being followed
     for (i = 1; i <= maxclients->value; i++) {
         other = g_edicts + i;
         if (other->inuse && other->client->chase_target == ent)
             UpdateChaseCam(other);
     }
 }

Referenced by GetGameAPI().

◆ ClientUserinfoChanged()

void ClientUserinfoChanged	(	edict_t *	ent,
		char *	userinfo
	)

Definition at line 1371 of file p_client.c.

 {
     char    *s;
     int     playernum;
  
     // check for malformed or illegal info strings
     if (!Info_Validate(userinfo))
     {
         strcpy (userinfo, "\\name\\badinfo\\skin\\male/grunt");
     }
  
     // set name
     s = Info_ValueForKey (userinfo, "name");
     strncpy (ent->client->pers.netname, s, sizeof(ent->client->pers.netname)-1);
  
     // set spectator
     s = Info_ValueForKey (userinfo, "spectator");
     // spectators are only supported in deathmatch
     if (deathmatch->value && *s && strcmp(s, "0"))
         ent->client->pers.spectator = true;
     else
         ent->client->pers.spectator = false;
  
     // set skin
     s = Info_ValueForKey (userinfo, "skin");
  
     playernum = ent-g_edicts-1;
  
     // combine name and skin into a configstring
     gi.configstring (CS_PLAYERSKINS+playernum, va("%s\\%s", ent->client->pers.netname, s) );
  
     // fov
     if (deathmatch->value && ((int)dmflags->value & DF_FIXED_FOV))
     {
         ent->client->ps.fov = 90;
     }
     else
     {
         ent->client->ps.fov = atoi(Info_ValueForKey(userinfo, "fov"));
         if (ent->client->ps.fov < 1)
             ent->client->ps.fov = 90;
         else if (ent->client->ps.fov > 160)
             ent->client->ps.fov = 160;
     }
  
     // handedness
     s = Info_ValueForKey (userinfo, "hand");
     if (strlen(s))
     {
         ent->client->pers.hand = atoi(s);
     }
  
     // save off the userinfo in case we want to check something later
     strncpy (ent->client->pers.userinfo, userinfo, sizeof(ent->client->pers.userinfo)-1);
 }

Referenced by ClientConnect(), GetGameAPI(), and PutClientInServer().

◆ Com_Printf()

void Com_Printf	(	char *	msg,
			...
	)

Definition at line 157 of file g_main.c.

 {
     va_list     argptr;
     char        text[1024];
  
     va_start (argptr, msg);
     vsprintf (text, msg, argptr);
     va_end (argptr);
  
     gi.dprintf ("%s", text);
 }

◆ CreateTargetChangeLevel()

edict_t* CreateTargetChangeLevel ( char * map )

Definition at line 203 of file g_main.c.

 {
     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;
 }

Referenced by EndDMLevel().

◆ EndDMLevel()

void EndDMLevel ( void )

Definition at line 221 of file g_main.c.

 {
     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 = strdup(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) );
                 free(s);
                 return;
             }
             if (!f)
                 f = t;
             t = strtok(NULL, seps);
         }
         free(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);
     }
 }

Referenced by CheckDMRules().

◆ ExitLevel()

void ExitLevel ( void )

Definition at line 351 of file g_main.c.

 {
     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;
     }
  
 }

Referenced by G_RunFrame().

◆ G_RunFrame()

void G_RunFrame ( void )

Definition at line 383 of file g_main.c.

 {
     int     i;
     edict_t *ent;
  
     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;
     }
  
     //
     // treat each object in turn
     // even the world gets a chance to think
     //
     ent = &g_edicts[0];
     for (i=0 ; i<globals.num_edicts ; i++, ent++)
     {
         if (!ent->inuse)
             continue;
  
         level.current_entity = ent;
  
         VectorCopy (ent->s.origin, ent->s.old_origin);
  
         // 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 ();
 }

Referenced by GetGameAPI().

◆ GetGameAPI()

game_export_t* GetGameAPI ( game_import_t * import )

Definition at line 113 of file g_main.c.

 {
     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;
 }

Referenced by Sys_GetGameAPI().

◆ InitGame()

void InitGame ( void )

Definition at line 152 of file g_save.c.

 {
     gi.dprintf ("==== InitGame ====\n");
  
     gun_x = gi.cvar ("gun_x", "0", 0);
     gun_y = gi.cvar ("gun_y", "0", 0);
     gun_z = gi.cvar ("gun_z", "0", 0);
  
     //FIXME: sv_ prefix is wrong for these
     sv_rollspeed = gi.cvar ("sv_rollspeed", "200", 0);
     sv_rollangle = gi.cvar ("sv_rollangle", "2", 0);
     sv_maxvelocity = gi.cvar ("sv_maxvelocity", "2000", 0);
     sv_gravity = gi.cvar ("sv_gravity", "800", 0);
  
     // noset vars
     dedicated = gi.cvar ("dedicated", "0", CVAR_NOSET);
  
     // latched vars
     sv_cheats = gi.cvar ("cheats", "0", CVAR_SERVERINFO|CVAR_LATCH);
     gi.cvar ("gamename", GAMEVERSION , CVAR_SERVERINFO | CVAR_LATCH);
     gi.cvar ("gamedate", __DATE__ , CVAR_SERVERINFO | CVAR_LATCH);
  
     maxclients = gi.cvar ("maxclients", "4", CVAR_SERVERINFO | CVAR_LATCH);
     maxspectators = gi.cvar ("maxspectators", "4", CVAR_SERVERINFO);
     deathmatch = gi.cvar ("deathmatch", "0", CVAR_LATCH);
     coop = gi.cvar ("coop", "0", CVAR_LATCH);
     skill = gi.cvar ("skill", "1", CVAR_LATCH);
     maxentities = gi.cvar ("maxentities", "1024", CVAR_LATCH);
  
     // change anytime vars
     dmflags = gi.cvar ("dmflags", "0", CVAR_SERVERINFO);
     fraglimit = gi.cvar ("fraglimit", "0", CVAR_SERVERINFO);
     timelimit = gi.cvar ("timelimit", "0", CVAR_SERVERINFO);
     password = gi.cvar ("password", "", CVAR_USERINFO);
     spectator_password = gi.cvar ("spectator_password", "", CVAR_USERINFO);
     needpass = gi.cvar ("needpass", "0", CVAR_SERVERINFO);
     filterban = gi.cvar ("filterban", "1", 0);
  
     g_select_empty = gi.cvar ("g_select_empty", "0", CVAR_ARCHIVE);
  
     run_pitch = gi.cvar ("run_pitch", "0.002", 0);
     run_roll = gi.cvar ("run_roll", "0.005", 0);
     bob_up  = gi.cvar ("bob_up", "0.005", 0);
     bob_pitch = gi.cvar ("bob_pitch", "0.002", 0);
     bob_roll = gi.cvar ("bob_roll", "0.002", 0);
  
     // flood control
     flood_msgs = gi.cvar ("flood_msgs", "4", 0);
     flood_persecond = gi.cvar ("flood_persecond", "4", 0);
     flood_waitdelay = gi.cvar ("flood_waitdelay", "10", 0);
  
     // dm map list
     sv_maplist = gi.cvar ("sv_maplist", "", 0);
  
     // items
     InitItems ();
  
     Com_sprintf (game.helpmessage1, sizeof(game.helpmessage1), "");
  
     Com_sprintf (game.helpmessage2, sizeof(game.helpmessage2), "");
  
     // initialize all entities for this game
     game.maxentities = maxentities->value;
     g_edicts =  gi.TagMalloc (game.maxentities * sizeof(g_edicts[0]), TAG_GAME);
     globals.edicts = g_edicts;
     globals.max_edicts = game.maxentities;
  
     // initialize all clients for this game
     game.maxclients = maxclients->value;
     game.clients = gi.TagMalloc (game.maxclients * sizeof(game.clients[0]), TAG_GAME);
     globals.num_edicts = game.maxclients+1;
 }

Referenced by GetGameAPI(), ReadField(), ReadLevel(), WriteField1(), and WriteLevel().

◆ ReadGame()

void ReadGame ( char * filename )

Definition at line 494 of file g_save.c.

 {
     FILE    *f;
     int     i;
     char    str[16];
  
     gi.FreeTags (TAG_GAME);
  
     f = fopen (filename, "rb");
     if (!f)
         gi.error ("Couldn't open %s", filename);
  
     fread (str, sizeof(str), 1, f);
     if (strcmp (str, __DATE__))
     {
         fclose (f);
         gi.error ("Savegame from an older version.\n");
     }
  
     g_edicts =  gi.TagMalloc (game.maxentities * sizeof(g_edicts[0]), TAG_GAME);
     globals.edicts = g_edicts;
  
     fread (&game, sizeof(game), 1, f);
     game.clients = gi.TagMalloc (game.maxclients * sizeof(game.clients[0]), TAG_GAME);
     for (i=0 ; i<game.maxclients ; i++)
         ReadClient (f, &game.clients[i]);
  
     fclose (f);
 }

Referenced by GetGameAPI().

◆ ReadLevel()

void ReadLevel ( char * filename )

Definition at line 689 of file g_save.c.

 {
     int     entnum;
     FILE    *f;
     int     i;
     void    *base;
     edict_t *ent;
  
     f = fopen (filename, "rb");
     if (!f)
         gi.error ("Couldn't open %s", filename);
  
     // free any dynamic memory allocated by loading the level
     // base state
     gi.FreeTags (TAG_LEVEL);
  
     // wipe all the entities
     memset (g_edicts, 0, game.maxentities*sizeof(g_edicts[0]));
     globals.num_edicts = maxclients->value+1;
  
     // check edict size
     fread (&i, sizeof(i), 1, f);
     if (i != sizeof(edict_t))
     {
         fclose (f);
         gi.error ("ReadLevel: mismatched edict size");
     }
  
     // check function pointer base address
     fread (&base, sizeof(base), 1, f);
 #ifdef _WIN32
     if (base != (void *)InitGame)
     {
         fclose (f);
         gi.error ("ReadLevel: function pointers have moved");
     }
 #else
     gi.dprintf("Function offsets %d\n", ((byte *)base) - ((byte *)InitGame));
 #endif
  
     // load the level locals
     ReadLevelLocals (f);
  
     // load all the entities
     while (1)
     {
         if (fread (&entnum, sizeof(entnum), 1, f) != 1)
         {
             fclose (f);
             gi.error ("ReadLevel: failed to read entnum");
         }
         if (entnum == -1)
             break;
         if (entnum >= globals.num_edicts)
             globals.num_edicts = entnum+1;
  
         ent = &g_edicts[entnum];
         ReadEdict (f, ent);
  
         // let the server rebuild world links for this ent
         memset (&ent->area, 0, sizeof(ent->area));
         gi.linkentity (ent);
     }
  
     fclose (f);
  
     // mark all clients as unconnected
     for (i=0 ; i<maxclients->value ; i++)
     {
         ent = &g_edicts[i+1];
         ent->client = game.clients + i;
         ent->client->pers.connected = false;
     }
  
     // do any load time things at this point
     for (i=0 ; i<globals.num_edicts ; i++)
     {
         ent = &g_edicts[i];
  
         if (!ent->inuse)
             continue;
  
         // fire any cross-level triggers
         if (ent->classname)
             if (strcmp(ent->classname, "target_crosslevel_target") == 0)
                 ent->nextthink = level.time + ent->delay;
     }
 }

Referenced by GetGameAPI().

◆ RunEntity()

void RunEntity ( edict_t * ent )

◆ ShutdownGame()

void ShutdownGame ( void )

Definition at line 96 of file g_main.c.

 {
     gi.dprintf ("==== ShutdownGame ====\n");
  
     gi.FreeTags (TAG_LEVEL);
     gi.FreeTags (TAG_GAME);
 }

Referenced by GetGameAPI().

◆ SpawnEntities()

void SpawnEntities	(	char *	mapname,
		char *	entities,
		char *	spawnpoint
	)

Definition at line 522 of file g_spawn.c.

 {
     edict_t     *ent;
     int         inhibit;
     char        *com_token;
     int         i;
     float       skill_level;
  
     skill_level = floor (skill->value);
     if (skill_level < 0)
         skill_level = 0;
     if (skill_level > 3)
         skill_level = 3;
     if (skill->value != skill_level)
         gi.cvar_forceset("skill", va("%f", skill_level));
  
     SaveClientData ();
  
     gi.FreeTags (TAG_LEVEL);
  
     memset (&level, 0, sizeof(level));
     memset (g_edicts, 0, game.maxentities * sizeof (g_edicts[0]));
  
     strncpy (level.mapname, mapname, sizeof(level.mapname)-1);
     strncpy (game.spawnpoint, spawnpoint, sizeof(game.spawnpoint)-1);
  
     // set client fields on player ents
     for (i=0 ; i<game.maxclients ; i++)
         g_edicts[i+1].client = game.clients + i;
  
     ent = NULL;
     inhibit = 0;
  
 // parse ents
     while (1)
     {
         // parse the opening brace  
         com_token = COM_Parse (&entities);
         if (!entities)
             break;
         if (com_token[0] != '{')
             gi.error ("ED_LoadFromFile: found %s when expecting {",com_token);
  
         if (!ent)
             ent = g_edicts;
         else
             ent = G_Spawn ();
         entities = ED_ParseEdict (entities, ent);
  
         // yet another map hack
         if (!Q_stricmp(level.mapname, "command") && !Q_stricmp(ent->classname, "trigger_once") && !Q_stricmp(ent->model, "*27"))
             ent->spawnflags &= ~SPAWNFLAG_NOT_HARD;
  
         // remove things (except the world) from different skill levels or deathmatch
         if (ent != g_edicts)
         {
             if (deathmatch->value)
             {
                 if ( ent->spawnflags & SPAWNFLAG_NOT_DEATHMATCH )
                 {
                     G_FreeEdict (ent);  
                     inhibit++;
                     continue;
                 }
             }
             else
             {
                 if ( /* ((coop->value) && (ent->spawnflags & SPAWNFLAG_NOT_COOP)) || */
                     ((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) ||
                     ((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) ||
                     (((skill->value == 2) || (skill->value == 3)) && (ent->spawnflags & SPAWNFLAG_NOT_HARD))
                     )
                     {
                         G_FreeEdict (ent);  
                         inhibit++;
                         continue;
                     }
             }
  
             ent->spawnflags &= ~(SPAWNFLAG_NOT_EASY|SPAWNFLAG_NOT_MEDIUM|SPAWNFLAG_NOT_HARD|SPAWNFLAG_NOT_COOP|SPAWNFLAG_NOT_DEATHMATCH);
         }
  
         ED_CallSpawn (ent);
     }   
  
     gi.dprintf ("%i entities inhibited\n", inhibit);
  
 #ifdef DEBUG
     i = 1;
     ent = EDICT_NUM(i);
     while (i < globals.num_edicts) {
         if (ent->inuse != 0 || ent->inuse != 1)
             Com_DPrintf("Invalid entity %d\n", i);
         i++, ent++;
     }
 #endif
  
     G_FindTeams ();
  
     PlayerTrail_Init ();
 }

Referenced by GetGameAPI().

◆ Sys_Error()

void Sys_Error	(	char *	error,
			...
	)

Definition at line 145 of file g_main.c.

 {
     va_list     argptr;
     char        text[1024];
  
     va_start (argptr, error);
     vsprintf (text, error, argptr);
     va_end (argptr);
  
     gi.error (ERR_FATAL, "%s", text);
 }

◆ WriteGame()

void WriteGame	(	char *	filename,
		qboolean	autosave
	)

Definition at line 467 of file g_save.c.

 {
     FILE    *f;
     int     i;
     char    str[16];
  
     if (!autosave)
         SaveClientData ();
  
     f = fopen (filename, "wb");
     if (!f)
         gi.error ("Couldn't open %s", filename);
  
     memset (str, 0, sizeof(str));
     strcpy (str, __DATE__);
     fwrite (str, sizeof(str), 1, f);
  
     game.autosaved = autosave;
     fwrite (&game, sizeof(game), 1, f);
     game.autosaved = false;
  
     for (i=0 ; i<game.maxclients ; i++)
         WriteClient (f, &game.clients[i]);
  
     fclose (f);
 }

Referenced by GetGameAPI().

◆ WriteLevel()

void WriteLevel ( char * filename )

Definition at line 635 of file g_save.c.

 {
     int     i;
     edict_t *ent;
     FILE    *f;
     void    *base;
  
     f = fopen (filename, "wb");
     if (!f)
         gi.error ("Couldn't open %s", filename);
  
     // write out edict size for checking
     i = sizeof(edict_t);
     fwrite (&i, sizeof(i), 1, f);
  
     // write out a function pointer for checking
     base = (void *)InitGame;
     fwrite (&base, sizeof(base), 1, f);
  
     // write out level_locals_t
     WriteLevelLocals (f);
  
     // write out all the entities
     for (i=0 ; i<globals.num_edicts ; i++)
     {
         ent = &g_edicts[i];
         if (!ent->inuse)
             continue;
         fwrite (&i, sizeof(i), 1, f);
         WriteEdict (f, ent);
     }
     i = -1;
     fwrite (&i, sizeof(i), 1, f);
  
     fclose (f);
 }