/* Emacs style mode select   -*- C++ -*- */
/*----------------------------------------------------------------------------- */
/* */
/* $Id:$ */
/* */
/* Copyright (C) 1993-1996 by 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. */
/* */
/* $Log:$ */
/* */
/* DESCRIPTION:  none */
/* */
/*----------------------------------------------------------------------------- */


static const char
        rcsid[] = "$Id: g_game.c,v 1.8 1997/02/03 22:45:09 b1 Exp $";

#include <string.h>
#include <stdlib.h>

#include "doomdef.h"
#include "doomstat.h"

#include "z_zone.h"
#include "f_finale.h"
#include "m_argv.h"
#include "m_misc.h"
#include "m_menu.h"
#include "m_random.h"
#include "i_system.h"

#include "p_setup.h"
#include "p_saveg.h"
#include "p_tick.h"

#include "d_main.h"

#include "wi_stuff.h"
#include "hu_stuff.h"
#include "st_stuff.h"
#include "am_map.h"

/* Needs access to LFB. */
#include "v_video.h"

#include "w_wad.h"

#include "p_local.h"

#include "s_sound.h"

/* Data. */
#include "dstrings.h"
#include "sounds.h"

/* SKY handling - still the wrong place. */
#include "r_data.h"
#include "r_sky.h"



#include "g_game.h"


#define SAVEGAMESIZE    0x2c000
#define SAVESTRINGSIZE  24



boolean G_CheckDemoStatus (void);
void    G_ReadDemoTiccmd (ticcmd_t* cmd);
void    G_WriteDemoTiccmd (ticcmd_t* cmd);
void    G_PlayerReborn (int player);
void    G_InitNew (skill_t skill, int episode, int map);

void    G_DoReborn (int playernum);

void    G_DoLoadLevel (void);
void    G_DoNewGame (void);
void    G_DoLoadGame (void);
void    G_DoPlayDemo (void);
void    G_DoCompleted (void);
void    G_DoVictory (void);
void    G_DoWorldDone (void);
void    G_DoSaveGame (void);


gameaction_t gameaction;
gamestate_t gamestate;
skill_t gameskill;
boolean respawnmonsters;
int gameepisode;
int gamemap;

boolean paused;
boolean sendpause;                      /* send a pause event next tic */
boolean sendsave;                       /* send a save event next tic */
boolean usergame;                       /* ok to save / end game */

boolean timingdemo;                     /* if true, exit with report on completion */
boolean nodrawers;                      /* for comparative timing purposes */
boolean noblit;                         /* for comparative timing purposes */
int starttime;                          /* for comparative timing purposes */

boolean viewactive;

boolean deathmatch;                     /* only if started as net death */
boolean netgame;                        /* only true if packets are broadcast */
boolean playeringame[MAXPLAYERS];
player_t players[MAXPLAYERS];

int consoleplayer;                      /* player taking events and displaying */
int displayplayer;                      /* view being displayed */
int gametic;
int levelstarttic;                      /* gametic at level start */
int totalkills, totalitems, totalsecret;                /* for intermission */

char demoname[32];
boolean demorecording;
boolean demoplayback;
boolean netdemo;
byte*           demobuffer;
byte*           demo_p;
byte*           demoend;
boolean singledemo;                     /* quit after playing a demo from cmdline */

boolean precache = true;                /* if true, load all graphics at start */

wbstartstruct_t wminfo;                 /* parms for world map / intermission */

short consistancy[MAXPLAYERS][BACKUPTICS];

byte*           savebuffer;


/* */
/* controls (have defaults) */
/* */
int key_right;
int key_left;

int key_up;
int key_down;
int key_strafeleft;
int key_straferight;
int key_fire;
int key_use;
int key_strafe;
int key_speed;

int mousebfire;
int mousebstrafe;
int mousebforward;

int joybfire;
int joybstrafe;
int joybuse;
int joybspeed;



#define MAXPLMOVE               (forwardmove[1])

#define TURBOTHRESHOLD  0x32

fixed_t forwardmove[2] = {0x19, 0x32};
fixed_t sidemove[2] = {0x18, 0x28};
fixed_t angleturn[3] = {640, 1280, 320};                /* + slow turn */

#define SLOWTURNTICS    6

#define NUMKEYS         256

boolean gamekeydown[NUMKEYS];
int turnheld;                                           /* for accelerative turning */

boolean mousearray[4];
boolean*        mousebuttons = &mousearray[1];          /* allow [-1] */

/* mouse values are used once */
int mousex;
int mousey;

int dclicktime;
int dclickstate;
int dclicks;
int dclicktime2;
int dclickstate2;
int dclicks2;

/* joystick values are repeated */
int joyxmove;
int joyymove;
boolean joyarray[5];
boolean*        joybuttons = &joyarray[1];              /* allow [-1] */

int savegameslot;
char savedescription[32];


#define BODYQUESIZE     32

mobj_t*         bodyque[BODYQUESIZE];
int bodyqueslot;

void*           statcopy;                               /* for statistics driver */



int G_CmdChecksum (ticcmd_t* cmd)
{
	int i;
	int sum = 0;

	for (i=0; i< sizeof(*cmd)/4 - 1; i++)
		sum += ((int *)cmd)[i];

	return sum;
}


/* */
/* G_BuildTiccmd */
/* Builds a ticcmd from all of the available inputs */
/* or reads it from the demo buffer. */
/* If recording a demo, write it out */
/* */
void G_BuildTiccmd (ticcmd_t* cmd)
{
	int i;
	boolean strafe;
	boolean bstrafe;
	int speed;
	int tspeed;
	int forward;
	int side;

	ticcmd_t*   base;

	base = I_BaseTiccmd ();         /* empty, or external driver */
	memcpy (cmd,base,sizeof(*cmd));

	cmd->consistancy =
		consistancy[consoleplayer][maketic%BACKUPTICS];


	strafe = gamekeydown[key_strafe] || mousebuttons[mousebstrafe]
	         || joybuttons[joybstrafe];
	speed = gamekeydown[key_speed] || joybuttons[joybspeed];

	forward = side = 0;

	/* use two stage accelerative turning */
	/* on the keyboard and joystick */
	if (joyxmove < 0
	    || joyxmove > 0
	    || gamekeydown[key_right]
	    || gamekeydown[key_left])
		turnheld += ticdup;
	else
		turnheld = 0;

	if (turnheld < SLOWTURNTICS)
		tspeed = 2;     /* slow turn */
	else
		tspeed = speed;

	/* let movement keys cancel each other out */
	if (strafe)
	{
		if (gamekeydown[key_right])
		{
			/* fprintf(stderr, "strafe right\n"); */
			side += sidemove[speed];
		}
		if (gamekeydown[key_left])
		{
			/*	fprintf(stderr, "strafe left\n"); */
			side -= sidemove[speed];
		}
		if (joyxmove > 0)
			side += sidemove[speed];
		if (joyxmove < 0)
			side -= sidemove[speed];

	}
	else
	{
		if (gamekeydown[key_right])
			cmd->angleturn -= angleturn[tspeed];
		if (gamekeydown[key_left])
			cmd->angleturn += angleturn[tspeed];
		if (joyxmove > 0)
			cmd->angleturn -= angleturn[tspeed];
		if (joyxmove < 0)
			cmd->angleturn += angleturn[tspeed];
	}

	if (gamekeydown[key_up])
	{
		/* fprintf(stderr, "up\n"); */
		forward += forwardmove[speed];
	}
	if (gamekeydown[key_down])
	{
		/* fprintf(stderr, "down\n"); */
		forward -= forwardmove[speed];
	}
	if (joyymove < 0)
		forward += forwardmove[speed];
	if (joyymove > 0)
		forward -= forwardmove[speed];
	if (gamekeydown[key_straferight])
		side += sidemove[speed];
	if (gamekeydown[key_strafeleft])
		side -= sidemove[speed];

	/* buttons */
	cmd->chatchar = HU_dequeueChatChar();

	if (gamekeydown[key_fire] || mousebuttons[mousebfire]
	    || joybuttons[joybfire])
		cmd->buttons |= BT_ATTACK;

	if (gamekeydown[key_use] || joybuttons[joybuse] )
	{
		cmd->buttons |= BT_USE;
		/* clear double clicks if hit use button */
		dclicks = 0;
	}

	/* chainsaw overrides */
	for (i=0; i<NUMWEAPONS-1; i++)
		if (gamekeydown['1'+i])
		{
			cmd->buttons |= BT_CHANGE;
			cmd->buttons |= i<<BT_WEAPONSHIFT;
			break;
		}

	/* mouse */
	if (mousebuttons[mousebforward])
		forward += forwardmove[speed];

	/* forward double click */
	if (mousebuttons[mousebforward] != dclickstate && dclicktime > 1 )
	{
		dclickstate = mousebuttons[mousebforward];
		if (dclickstate)
			dclicks++;
		if (dclicks == 2)
		{
			cmd->buttons |= BT_USE;
			dclicks = 0;
		}
		else
			dclicktime = 0;
	}
	else
	{
		dclicktime += ticdup;
		if (dclicktime > 20)
		{
			dclicks = 0;
			dclickstate = 0;
		}
	}

	/* strafe double click */
	bstrafe =
		mousebuttons[mousebstrafe]
		|| joybuttons[joybstrafe];
	if (bstrafe != dclickstate2 && dclicktime2 > 1 )
	{
		dclickstate2 = bstrafe;
		if (dclickstate2)
			dclicks2++;
		if (dclicks2 == 2)
		{
			cmd->buttons |= BT_USE;
			dclicks2 = 0;
		}
		else
			dclicktime2 = 0;
	}
	else
	{
		dclicktime2 += ticdup;
		if (dclicktime2 > 20)
		{
			dclicks2 = 0;
			dclickstate2 = 0;
		}
	}

	forward += mousey;
	if (strafe)
		side += mousex*2;
	else
		cmd->angleturn -= mousex*0x8;

	mousex = mousey = 0;

	if (forward > MAXPLMOVE)
		forward = MAXPLMOVE;
	else if (forward < -MAXPLMOVE)
		forward = -MAXPLMOVE;
	if (side > MAXPLMOVE)
		side = MAXPLMOVE;
	else if (side < -MAXPLMOVE)
		side = -MAXPLMOVE;

	cmd->forwardmove += forward;
	cmd->sidemove += side;

	/* special buttons */
	if (sendpause)
	{
		sendpause = false;
		cmd->buttons = BT_SPECIAL | BTS_PAUSE;
	}

	if (sendsave)
	{
		sendsave = false;
		cmd->buttons = BT_SPECIAL | BTS_SAVEGAME | (savegameslot<<BTS_SAVESHIFT);
	}
}


/* */
/* G_DoLoadLevel */
/* */
extern gamestate_t wipegamestate;

void G_DoLoadLevel (void)
{
	int i;

	/* Set the sky map. */
	/* First thing, we have a dummy sky texture name, */
	/*  a flat. The data is in the WAD only because */
	/*  we look for an actual index, instead of simply */
	/*  setting one. */
	skyflatnum = R_FlatNumForName ( SKYFLATNAME );

	/* DOOM determines the sky texture to be used */
	/* depending on the current episode, and the game version. */
	if ( (gamemode == commercial)
	     || ( gamemode == pack_tnt )
	     || ( gamemode == pack_plut ) )
	{
		skytexture = R_TextureNumForName ("SKY3");
		if (gamemap < 12)
			skytexture = R_TextureNumForName ("SKY1");
		else
		if (gamemap < 21)
			skytexture = R_TextureNumForName ("SKY2");
	}

	levelstarttic = gametic;    /* for time calculation */

	if (wipegamestate == GS_LEVEL)
		wipegamestate = -1;     /* force a wipe */

	gamestate = GS_LEVEL;

	for (i=0; i<MAXPLAYERS; i++)
	{
		if (playeringame[i] && players[i].playerstate == PST_DEAD)
			players[i].playerstate = PST_REBORN;
		memset (players[i].frags,0,sizeof(players[i].frags));
	}

	P_SetupLevel (gameepisode, gamemap, 0, gameskill);
	displayplayer = consoleplayer;          /* view the guy you are playing */
	starttime = I_GetTime ();
	gameaction = ga_nothing;
	Z_CheckHeap ();

	/* clear cmd building stuff */
	memset (gamekeydown, 0, sizeof(gamekeydown));
	joyxmove = joyymove = 0;
	mousex = mousey = 0;
	sendpause = sendsave = paused = false;
	memset (mousebuttons, 0, sizeof(mousebuttons));
	memset (joybuttons, 0, sizeof(joybuttons));
}


/* */
/* G_Responder */
/* Get info needed to make ticcmd_ts for the players. */
/* */
boolean G_Responder (event_t* ev)
{
	/* allow spy mode changes even during the demo */
	if (gamestate == GS_LEVEL && ev->type == ev_keydown
	    && ev->data1 == KEY_F12 && (singledemo || !deathmatch) )
	{
		/* spy mode */
		do
		{
			displayplayer++;
			if (displayplayer == MAXPLAYERS)
				displayplayer = 0;
		} while (!playeringame[displayplayer] && displayplayer != consoleplayer);
		return true;
	}

	/* any other key pops up menu if in demos */
	if (gameaction == ga_nothing && !singledemo &&
	    (demoplayback || gamestate == GS_DEMOSCREEN)
	    )
	{
		if (ev->type == ev_keydown ||
		    (ev->type == ev_mouse && ev->data1) ||
		    (ev->type == ev_joystick && ev->data1) )
		{
			M_StartControlPanel ();
			return true;
		}
		return false;
	}

	if (gamestate == GS_LEVEL)
	{
#if 0
		if (devparm && ev->type == ev_keydown && ev->data1 == ';')
		{
			G_DeathMatchSpawnPlayer (0);
			return true;
		}
#endif
		if (HU_Responder (ev))
			return true; /* chat ate the event */
		if (ST_Responder (ev))
			return true; /* status window ate it */
		if (AM_Responder (ev))
			return true; /* automap ate it */
	}

	if (gamestate == GS_FINALE)
	{
		if (F_Responder (ev))
			return true; /* finale ate the event */
	}

	switch (ev->type)
	{
	case ev_keydown:
		if (ev->data1 == KEY_PAUSE)
		{
			sendpause = true;
			return true;
		}
		if (ev->data1 <NUMKEYS)
			gamekeydown[ev->data1] = true;
		return true; /* eat key down events */

	case ev_keyup:
		if (ev->data1 <NUMKEYS)
			gamekeydown[ev->data1] = false;
		return false; /* always let key up events filter down */

	case ev_mouse:
		mousebuttons[0] = ev->data1 & 1;
		mousebuttons[1] = ev->data1 & 2;
		mousebuttons[2] = ev->data1 & 4;
		mousex = ev->data2*(mouseSensitivity+5)/10;
		mousey = ev->data3*(mouseSensitivity+5)/10;
		return true; /* eat events */

	case ev_joystick:
		joybuttons[0] = ev->data1 & 1;
		joybuttons[1] = ev->data1 & 2;
		joybuttons[2] = ev->data1 & 4;
		joybuttons[3] = ev->data1 & 8;
		joyxmove = ev->data2;
		joyymove = ev->data3;
		return true; /* eat events */

	default:
		break;
	}

	return false;
}



/* */
/* G_Ticker */
/* Make ticcmd_ts for the players. */
/* */
void G_Ticker (void)
{
	int i;
	int buf;
	ticcmd_t*   cmd;

	/* do player reborns if needed */
	for (i=0; i<MAXPLAYERS; i++)
		if (playeringame[i] && players[i].playerstate == PST_REBORN)
			G_DoReborn (i);

	/* do things to change the game state */
	while (gameaction != ga_nothing)
	{
		switch (gameaction)
		{
		case ga_loadlevel:
			G_DoLoadLevel ();
			break;
		case ga_newgame:
			G_DoNewGame ();
			break;
		case ga_loadgame:
			G_DoLoadGame ();
			break;
		case ga_savegame:
			G_DoSaveGame ();
			break;
		case ga_playdemo:
			G_DoPlayDemo ();
			break;
		case ga_completed:
			G_DoCompleted ();
			break;
		case ga_victory:
			F_StartFinale ();
			break;
		case ga_worlddone:
			G_DoWorldDone ();
			break;
		case ga_screenshot:
			M_ScreenShot ();
			gameaction = ga_nothing;
			break;
		case ga_nothing:
			break;
		}
	}

	/* get commands, check consistancy, */
	/* and build new consistancy check */
	buf = (gametic/ticdup)%BACKUPTICS;

	for (i=0; i<MAXPLAYERS; i++)
	{
		if (playeringame[i])
		{
			cmd = &players[i].cmd;

			memcpy (cmd, &netcmds[i][buf], sizeof(ticcmd_t));

			if (demoplayback)
				G_ReadDemoTiccmd (cmd);
			if (demorecording)
				G_WriteDemoTiccmd (cmd);

			/* check for turbo cheats */
			if (cmd->forwardmove > TURBOTHRESHOLD
			    && !(gametic&31) && ((gametic>>5)&3) == i )
			{
				static char turbomessage[80];
				extern char *player_names[4];
				sprintf (turbomessage, "%s is turbo!",player_names[i]);
				players[consoleplayer].message = turbomessage;
			}

			if (netgame && !netdemo && !(gametic%ticdup) )
			{
				if (gametic > BACKUPTICS
				    && consistancy[i][buf] != cmd->consistancy)
				{
					I_Error ("consistency failure (%i should be %i)",
					         cmd->consistancy, consistancy[i][buf]);
				}
				if (players[i].mo)
					consistancy[i][buf] = players[i].mo->x;
				else
					consistancy[i][buf] = rndindex;
			}
		}
	}

	/* check for special buttons */
	for (i=0; i<MAXPLAYERS; i++)
	{
		if (playeringame[i])
		{
			if (players[i].cmd.buttons & BT_SPECIAL)
			{
				switch (players[i].cmd.buttons & BT_SPECIALMASK)
				{
				case BTS_PAUSE:
					paused ^= 1;
					if (paused)
						S_PauseSound ();
					else
						S_ResumeSound ();
					break;

				case BTS_SAVEGAME:
					if (!savedescription[0])
						strcpy (savedescription, "NET GAME");
					savegameslot =
						(players[i].cmd.buttons & BTS_SAVEMASK)>>BTS_SAVESHIFT;
					gameaction = ga_savegame;
					break;
				}
			}
		}
	}

	/* do main actions */
	switch (gamestate)
	{
	case GS_LEVEL:
		P_Ticker ();
		ST_Ticker ();
		AM_Ticker ();
		HU_Ticker ();
		break;

	case GS_INTERMISSION:
		WI_Ticker ();
		break;

	case GS_FINALE:
		F_Ticker ();
		break;

	case GS_DEMOSCREEN:
		D_PageTicker ();
		break;
	}
}


/* */
/* PLAYER STRUCTURE FUNCTIONS */
/* also see P_SpawnPlayer in P_Things */
/* */

/* */
/* G_InitPlayer */
/* Called at the start. */
/* Called by the game initialization functions. */
/* */
void G_InitPlayer (int player)
{
	player_t*   p;

	/* set up the saved info */
	p = &players[player];

	/* clear everything else to defaults */
	G_PlayerReborn (player);

}



/* */
/* G_PlayerFinishLevel */
/* Can when a player completes a level. */
/* */
void G_PlayerFinishLevel (int player)
{
	player_t*   p;

	p = &players[player];

	memset (p->powers, 0, sizeof (p->powers));
	memset (p->cards, 0, sizeof (p->cards));
	p->mo->flags &= ~MF_SHADOW;     /* cancel invisibility */
	p->extralight = 0;              /* cancel gun flashes */
	p->fixedcolormap = 0;           /* cancel ir gogles */
	p->damagecount = 0;             /* no palette changes */
	p->bonuscount = 0;
}


/* */
/* G_PlayerReborn */
/* Called after a player dies */
/* almost everything is cleared and initialized */
/* */
void G_PlayerReborn (int player)
{
	player_t*   p;
	int i;
	int frags[MAXPLAYERS];
	int killcount;
	int itemcount;
	int secretcount;

	memcpy (frags,players[player].frags,sizeof(frags));
	killcount = players[player].killcount;
	itemcount = players[player].itemcount;
	secretcount = players[player].secretcount;

	p = &players[player];
	memset (p, 0, sizeof(*p));

	memcpy (players[player].frags, frags, sizeof(players[player].frags));
	players[player].killcount = killcount;
	players[player].itemcount = itemcount;
	players[player].secretcount = secretcount;

	p->usedown = p->attackdown = true; /* don't do anything immediately */
	p->playerstate = PST_LIVE;
	p->health = MAXHEALTH;
	p->readyweapon = p->pendingweapon = wp_pistol;
	p->weaponowned[wp_fist] = true;
	p->weaponowned[wp_pistol] = true;
	p->ammo[am_clip] = 50;

	for (i=0; i<NUMAMMO; i++)
		p->maxammo[i] = maxammo[i];

}

/* */
/* G_CheckSpot */
/* Returns false if the player cannot be respawned */
/* at the given mapthing_t spot */
/* because something is occupying it */
/* */
void P_SpawnPlayer (mapthing_t* mthing);

boolean
G_CheckSpot
        ( int playernum,
        mapthing_t*   mthing )
{
	fixed_t x;
	fixed_t y;
	subsector_t*        ss;
	unsigned an;
	mobj_t*             mo;
	int i;

	if (!players[playernum].mo)
	{
		/* first spawn of level, before corpses */
		for (i=0; i<playernum; i++)
			if (players[i].mo->x == mthing->x << FRACBITS
			        && players[i].mo->y == mthing->y << FRACBITS)
				return false;
		return true;
	}

	x = mthing->x << FRACBITS;
	y = mthing->y << FRACBITS;

	if (!P_CheckPosition (players[playernum].mo, x, y) )
		return false;

	/* flush an old corpse if needed */
	if (bodyqueslot >= BODYQUESIZE)
		P_RemoveMobj (bodyque[bodyqueslot%BODYQUESIZE]);
	bodyque[bodyqueslot%BODYQUESIZE] = players[playernum].mo;
	bodyqueslot++;

	/* spawn a teleport fog */
	ss = R_PointInSubsector (x,y);
	an = ( ANG45 * (mthing->angle/45) ) >> ANGLETOFINESHIFT;

	mo = P_SpawnMobj (x+20*finecosine[an], y+20*finesine[an]
	                  , ss->sector->floorheight
	                  , MT_TFOG);

	if (players[consoleplayer].viewz != 1)
		S_StartSound (mo, sfx_telept); /* don't start sound on first frame */

	return true;
}


/* */
/* G_DeathMatchSpawnPlayer */
/* Spawns a player at one of the random death match spots */
/* called at level load and each death */
/* */
void G_DeathMatchSpawnPlayer (int playernum)
{
	int i,j;
	int selections;

	selections = deathmatch_p - deathmatchstarts;
	if (selections < 4)
		I_Error ("Only %i deathmatch spots, 4 required", selections);

	for (j=0; j<20; j++)
	{
		i = P_Random() % selections;
		if (G_CheckSpot (playernum, &deathmatchstarts[i]) )
		{
			deathmatchstarts[i].type = playernum+1;
			P_SpawnPlayer (&deathmatchstarts[i]);
			return;
		}
	}

	/* no good spot, so the player will probably get stuck */
	P_SpawnPlayer (&playerstarts[playernum]);
}

/* */
/* G_DoReborn */
/* */
void G_DoReborn (int playernum)
{
	int i;

	if (!netgame)
	{
		/* reload the level from scratch */
		gameaction = ga_loadlevel;
	}
	else
	{
		/* respawn at the start */

		/* first dissasociate the corpse */
		players[playernum].mo->player = NULL;

		/* spawn at random spot if in death match */
		if (deathmatch)
		{
			G_DeathMatchSpawnPlayer (playernum);
			return;
		}

		if (G_CheckSpot (playernum, &playerstarts[playernum]) )
		{
			P_SpawnPlayer (&playerstarts[playernum]);
			return;
		}

		/* try to spawn at one of the other players spots */
		for (i=0; i<MAXPLAYERS; i++)
		{
			if (G_CheckSpot (playernum, &playerstarts[i]) )
			{
				playerstarts[i].type = playernum+1; /* fake as other player */
				P_SpawnPlayer (&playerstarts[i]);
				playerstarts[i].type = i+1; /* restore */
				return;
			}
			/* he's going to be inside something.  Too bad. */
		}
		P_SpawnPlayer (&playerstarts[playernum]);
	}
}


void G_ScreenShot (void)
{
	gameaction = ga_screenshot;
}



/* DOOM Par Times */
int pars[4][10] =
{
	{0},
	{0,30,75,120,90,165,180,180,30,165},
	{0,90,90,90,120,90,360,240,30,170},
	{0,90,45,90,150,90,90,165,30,135}
};

/* DOOM II Par Times */
int cpars[32] =
{
        30,90,120,120,90,150,120,120,270,90,    /*  1-10 */
        210,150,150,150,210,150,420,150,210,150, /* 11-20 */
        240,150,180,150,150,300,330,420,300,180, /* 21-30 */
        120,30                                  /* 31-32 */
};


/* */
/* G_DoCompleted */
/* */
boolean secretexit;
extern char*    pagename;

void G_ExitLevel (void)
{
        secretexit = false;
        gameaction = ga_completed;
}

/* Here's for the german edition. */
void G_SecretExitLevel (void)
{
        /* IF NO WOLF3D LEVELS, NO SECRET EXIT! */
        if ( (gamemode == commercial)
             && (W_CheckNumForName("map31")<0))
		secretexit = false;
        else
		secretexit = true;
        gameaction = ga_completed;
}

void G_DoCompleted (void)
{
        int i;

        gameaction = ga_nothing;

        for (i=0; i<MAXPLAYERS; i++)
		if (playeringame[i])
			G_PlayerFinishLevel (i); /* take away cards and stuff */

        if (automapactive)
		AM_Stop ();

        if ( gamemode != commercial)
		switch(gamemap)
		{
		case 8:
			gameaction = ga_victory;
			return;
		case 9:
			for (i=0; i<MAXPLAYERS; i++)
				players[i].didsecret = true;
			break;
		}

/*#if 0  Hmmm - why? */
        if ( (gamemap == 8)
             && (gamemode != commercial) )
        {
                /* victory */
                gameaction = ga_victory;
                return;
	}

        if ( (gamemap == 9)
             && (gamemode != commercial) )
        {
                /* exit secret level */
                for (i=0; i<MAXPLAYERS; i++)
			players[i].didsecret = true;
	}
/*#endif */


        wminfo.didsecret = players[consoleplayer].didsecret;
        wminfo.epsd = gameepisode -1;
        wminfo.last = gamemap -1;

        /* wminfo.next is 0 biased, unlike gamemap */
        if ( gamemode == commercial)
        {
                if (secretexit)
			switch(gamemap)
			{
			case 15: wminfo.next = 30; break;
			case 31: wminfo.next = 31; break;
			}
                else
			switch(gamemap)
			{
			case 31:
			case 32: wminfo.next = 15; break;
			default: wminfo.next = gamemap;
			}
	}
        else
        {
                if (secretexit)
			wminfo.next = 8; /* go to secret level */
                else if (gamemap == 9)
                {
                        /* returning from secret level */
                        switch (gameepisode)
                        {
			case 1:
				wminfo.next = 3;
				break;
			case 2:
				wminfo.next = 5;
				break;
			case 3:
				wminfo.next = 6;
				break;
			case 4:
				wminfo.next = 2;
				break;
			}
		}
                else
			wminfo.next = gamemap; /* go to next level */
	}

        wminfo.maxkills = totalkills;
        wminfo.maxitems = totalitems;
        wminfo.maxsecret = totalsecret;
        wminfo.maxfrags = 0;
        if ( gamemode == commercial )
		wminfo.partime = 35*cpars[gamemap-1];
        else
		wminfo.partime = 35*pars[gameepisode][gamemap];
        wminfo.pnum = consoleplayer;

        for (i=0; i<MAXPLAYERS; i++)
        {
                wminfo.plyr[i].in = playeringame[i];
                wminfo.plyr[i].skills = players[i].killcount;
                wminfo.plyr[i].sitems = players[i].itemcount;
                wminfo.plyr[i].ssecret = players[i].secretcount;
                wminfo.plyr[i].stime = leveltime;
                memcpy (wminfo.plyr[i].frags, players[i].frags
                        , sizeof(wminfo.plyr[i].frags));
	}

        gamestate = GS_INTERMISSION;
        viewactive = false;
        automapactive = false;

        if (statcopy)
		memcpy (statcopy, &wminfo, sizeof(wminfo));

        WI_Start (&wminfo);
}


/* */
/* G_WorldDone */
/* */
void G_WorldDone (void)
{
        gameaction = ga_worlddone;

        if (secretexit)
		players[consoleplayer].didsecret = true;

        if ( gamemode == commercial )
        {
                switch (gamemap)
                {
		case 15:
		case 31:
			if (!secretexit)
				break;
		case 6:
		case 11:
		case 20:
		case 30:
			F_StartFinale ();
			break;
		}
	}
}

void G_DoWorldDone (void)
{
        gamestate = GS_LEVEL;
        gamemap = wminfo.next+1;
        G_DoLoadLevel ();
        gameaction = ga_nothing;
        viewactive = true;
}



/* */
/* G_InitFromSavegame */
/* Can be called by the startup code or the menu task. */
/* */
extern boolean setsizeneeded;
void R_ExecuteSetViewSize (void);

char savename[256];

void G_LoadGame (char* name)
{
        strcpy (savename, name);
        gameaction = ga_loadgame;
}

#define VERSIONSIZE             16


void G_DoLoadGame (void)
{
        int length;
        int i;
        int a,b,c;
        char vcheck[VERSIONSIZE];

        gameaction = ga_nothing;

        length = M_ReadFile (savename, &savebuffer);
        save_p = savebuffer + SAVESTRINGSIZE;

        /* skip the description field */
        memset (vcheck,0,sizeof(vcheck));
        sprintf (vcheck,"version %i",VERSION);
        if (strcmp (save_p, vcheck))
		return;                 /* bad version */
        save_p += VERSIONSIZE;

        gameskill = *save_p++;
        gameepisode = *save_p++;
        gamemap = *save_p++;
        for (i=0; i<MAXPLAYERS; i++)
		playeringame[i] = *save_p++;

        /* load a base level */
        G_InitNew (gameskill, gameepisode, gamemap);

        /* get the times */
        a = *save_p++;
        b = *save_p++;
        c = *save_p++;
        leveltime = (a<<16) + (b<<8) + c;

        /* dearchive all the modifications */
        P_UnArchivePlayers ();
        P_UnArchiveWorld ();
        P_UnArchiveThinkers ();
        P_UnArchiveSpecials ();

        if (*save_p != 0x1d)
		I_Error ("Bad savegame");

        /* done */
        Z_Free (savebuffer);

        if (setsizeneeded)
		R_ExecuteSetViewSize ();

        /* draw the pattern into the back screen */
        R_FillBackScreen ();
}


/* */
/* G_SaveGame */
/* Called by the menu task. */
/* Description is a 24 byte text string */
/* */
void
G_SaveGame
        ( int slot,
        char* description )
{
        savegameslot = slot;
        strcpy (savedescription, description);
        sendsave = true;
}

void G_DoSaveGame (void)
{
        char name[100];
        char name2[VERSIONSIZE];
        char*       description;
        int length;
        int i;

        if (M_CheckParm("-cdrom"))
		sprintf(name,"c:\\doomdata\\"SAVEGAMENAME "%d.dsg",savegameslot);
        else
		sprintf (name,SAVEGAMENAME "%d.dsg",savegameslot);
        description = savedescription;

        save_p = savebuffer = screens[1]+0x4000;

        memcpy (save_p, description, SAVESTRINGSIZE);
        save_p += SAVESTRINGSIZE;
        memset (name2,0,sizeof(name2));
        sprintf (name2,"version %i",VERSION);
        memcpy (save_p, name2, VERSIONSIZE);
        save_p += VERSIONSIZE;

        *save_p++ = gameskill;
        *save_p++ = gameepisode;
        *save_p++ = gamemap;
        for (i=0; i<MAXPLAYERS; i++)
		*save_p++ = playeringame[i];
        *save_p++ = leveltime>>16;
        *save_p++ = leveltime>>8;
        *save_p++ = leveltime;

        P_ArchivePlayers ();
        P_ArchiveWorld ();
        P_ArchiveThinkers ();
        P_ArchiveSpecials ();

        *save_p++ = 0x1d;       /* consistancy marker */

        length = save_p - savebuffer;
        if (length > SAVEGAMESIZE)
		I_Error ("Savegame buffer overrun");
        M_WriteFile (name, savebuffer, length);
        gameaction = ga_nothing;
        savedescription[0] = 0;

        players[consoleplayer].message = GGSAVED;

        /* draw the pattern into the back screen */
        R_FillBackScreen ();
}


/* */
/* G_InitNew */
/* Can be called by the startup code or the menu task, */
/* consoleplayer, displayplayer, playeringame[] should be set. */
/* */
skill_t d_skill;
int d_episode;
int d_map;

void
G_DeferedInitNew
        ( skill_t skill,
        int episode,
        int map)
{
        d_skill = skill;
        d_episode = episode;
        d_map = map;
        gameaction = ga_newgame;
}


void G_DoNewGame (void)
{
        demoplayback = false;
        netdemo = false;
        netgame = false;
        deathmatch = false;
        playeringame[1] = playeringame[2] = playeringame[3] = 0;
        respawnparm = false;
        fastparm = false;
        nomonsters = false;
        consoleplayer = 0;
        G_InitNew (d_skill, d_episode, d_map);
        gameaction = ga_nothing;
}

/* The sky texture to be used instead of the F_SKY1 dummy. */
extern int skytexture;


void
G_InitNew
        ( skill_t skill,
        int episode,
        int map )
{
        int i;

        if (paused)
        {
                paused = false;
                S_ResumeSound ();
	}


        if (skill > sk_nightmare)
		skill = sk_nightmare;


        /* This was quite messy with SPECIAL and commented parts. */
        /* Supposedly hacks to make the latest edition work. */
        /* It might not work properly. */
        if (episode < 1)
		episode = 1;

        if ( gamemode == retail )
        {
                if (episode > 4)
			episode = 4;
	}
        else if ( gamemode == shareware )
        {
                if (episode > 1)
			episode = 1; /* only start episode 1 on shareware */
	}
        else
        {
                if (episode > 3)
			episode = 3;
	}



        if (map < 1)
		map = 1;

        if ( (map > 9)
             && ( gamemode != commercial) )
		map = 9;

        M_ClearRandom ();

        if (skill == sk_nightmare || respawnparm )
		respawnmonsters = true;
        else
		respawnmonsters = false;

        if (fastparm || (skill == sk_nightmare && gameskill != sk_nightmare) )
        {
                for (i=S_SARG_RUN1; i<=S_SARG_PAIN2; i++)
			states[i].tics >>= 1;
                mobjinfo[MT_BRUISERSHOT].speed = 20*FRACUNIT;
                mobjinfo[MT_HEADSHOT].speed = 20*FRACUNIT;
                mobjinfo[MT_TROOPSHOT].speed = 20*FRACUNIT;
	}
        else if (skill != sk_nightmare && gameskill == sk_nightmare)
        {
                for (i=S_SARG_RUN1; i<=S_SARG_PAIN2; i++)
			states[i].tics <<= 1;
                mobjinfo[MT_BRUISERSHOT].speed = 15*FRACUNIT;
                mobjinfo[MT_HEADSHOT].speed = 10*FRACUNIT;
                mobjinfo[MT_TROOPSHOT].speed = 10*FRACUNIT;
	}


        /* force players to be initialized upon first level load */
        for (i=0; i<MAXPLAYERS; i++)
		players[i].playerstate = PST_REBORN;

        usergame = true;            /* will be set false if a demo */
        paused = false;
        demoplayback = false;
        automapactive = false;
        viewactive = true;
        gameepisode = episode;
        gamemap = map;
        gameskill = skill;

        viewactive = true;

        /* set the sky map for the episode */
        if ( gamemode == commercial)
        {
                skytexture = R_TextureNumForName ("SKY3");
                if (gamemap < 12)
			skytexture = R_TextureNumForName ("SKY1");
                else
                if (gamemap < 21)
			skytexture = R_TextureNumForName ("SKY2");
	}
        else
		switch (episode)
		{
		case 1:
			skytexture = R_TextureNumForName ("SKY1");
			break;
		case 2:
			skytexture = R_TextureNumForName ("SKY2");
			break;
		case 3:
			skytexture = R_TextureNumForName ("SKY3");
			break;
		case 4: /* Special Edition sky */
			skytexture = R_TextureNumForName ("SKY4");
			break;
		}

        G_DoLoadLevel ();
}


/* */
/* DEMO RECORDING */
/* */
#define DEMOMARKER              0x80


void G_ReadDemoTiccmd (ticcmd_t* cmd)
{
        if (*demo_p == DEMOMARKER)
        {
                /* end of demo data stream */
                G_CheckDemoStatus ();
                return;
	}
        cmd->forwardmove = ((signed char)*demo_p++);
        cmd->sidemove = ((signed char)*demo_p++);
        cmd->angleturn = ((unsigned char)*demo_p++)<<8;
        cmd->buttons = (unsigned char)*demo_p++;
}


void G_WriteDemoTiccmd (ticcmd_t* cmd)
{
        if (gamekeydown['q'])       /* press q to end demo recording */
		G_CheckDemoStatus ();
        *demo_p++ = cmd->forwardmove;
        *demo_p++ = cmd->sidemove;
        *demo_p++ = (cmd->angleturn+128)>>8;
        *demo_p++ = cmd->buttons;
        demo_p -= 4;
        if (demo_p > demoend - 16)
        {
                /* no more space */
                G_CheckDemoStatus ();
                return;
	}

        G_ReadDemoTiccmd (cmd);     /* make SURE it is exactly the same */
}



/* */
/* G_RecordDemo */
/* */
void G_RecordDemo (char* name)
{
        int i;
        int maxsize;

        usergame = false;
        strcpy (demoname, name);
        strcat (demoname, ".lmp");
        maxsize = 0x20000;
        i = M_CheckParm ("-maxdemo");
        if (i && i<myargc-1)
		maxsize = atoi(myargv[i+1])*1024;
        demobuffer = Z_Malloc (maxsize,PU_STATIC,NULL);
        demoend = demobuffer + maxsize;

        demorecording = true;
}


void G_BeginRecording (void)
{
        int i;

        demo_p = demobuffer;

        *demo_p++ = VERSION;
        *demo_p++ = gameskill;
        *demo_p++ = gameepisode;
        *demo_p++ = gamemap;
        *demo_p++ = deathmatch;
        *demo_p++ = respawnparm;
        *demo_p++ = fastparm;
        *demo_p++ = nomonsters;
        *demo_p++ = consoleplayer;

        for (i=0; i<MAXPLAYERS; i++)
		*demo_p++ = playeringame[i];
}


/* */
/* G_PlayDemo */
/* */

char*   defdemoname;

void G_DeferedPlayDemo (char* name)
{
        defdemoname = name;
        gameaction = ga_playdemo;
}

void G_DoPlayDemo (void)
{
        skill_t skill;
        int i, episode, map;

        gameaction = ga_nothing;
        demobuffer = demo_p = W_CacheLumpName (defdemoname, PU_STATIC);
        if ( *demo_p++ != VERSION)
        {
                fprintf( stderr, "Demo is from a different game version!\n");
                gameaction = ga_nothing;
                return;
	}

        skill = *demo_p++;
        episode = *demo_p++;
        map = *demo_p++;
        deathmatch = *demo_p++;
        respawnparm = *demo_p++;
        fastparm = *demo_p++;
        nomonsters = *demo_p++;
        consoleplayer = *demo_p++;

        for (i=0; i<MAXPLAYERS; i++)
		playeringame[i] = *demo_p++;
        if (playeringame[1])
        {
                netgame = true;
                netdemo = true;
	}

        /* don't spend a lot of time in loadlevel */
        precache = false;
        G_InitNew (skill, episode, map);
        precache = true;

        usergame = false;
        demoplayback = true;
}

/* */
/* G_TimeDemo */
/* */
void G_TimeDemo (char* name)
{
        nodrawers = M_CheckParm ("-nodraw");
        noblit = M_CheckParm ("-noblit");
        timingdemo = true;
        singletics = true;

        defdemoname = name;
        gameaction = ga_playdemo;
}


/*
   ===================
   =
   = G_CheckDemoStatus
   =
   = Called after a death or level completion to allow demos to be cleaned up
   = Returns true if a new demo loop action will take place
   ===================
 */

boolean G_CheckDemoStatus (void)
{
        int endtime;

        if (timingdemo)
        {
                endtime = I_GetTime ();
                I_Error ("timed %i gametics in %i realtics",gametic
                         , endtime-starttime);
	}

        if (demoplayback)
        {
                if (singledemo)
			I_Quit ();

                Z_ChangeTag (demobuffer, PU_CACHE);
                demoplayback = false;
                netdemo = false;
                netgame = false;
                deathmatch = false;
                playeringame[1] = playeringame[2] = playeringame[3] = 0;
                respawnparm = false;
                fastparm = false;
                nomonsters = false;
                consoleplayer = 0;
                D_AdvanceDemo ();
                return true;
	}

        if (demorecording)
        {
                *demo_p++ = DEMOMARKER;
                M_WriteFile (demoname, demobuffer, demo_p - demobuffer);
                Z_Free (demobuffer);
                demorecording = false;
                I_Error ("Demo %s recorded",demoname);
	}

        return false;
}



