DOOM-3-BFG/doomclassic/doom/wi_stuff.cpp

/*
===========================================================================

Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  

Doom 3 BFG Edition 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 3 of the License, or
(at your option) any later version.

Doom 3 BFG Edition 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 Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "Precompiled.h"
#include "globaldata.h"
#include "Main.h"
#include "sys/sys_session.h"
#include "sys/sys_signin.h"
#include "DoomLeaderboards.h"
#include "d3xp/Game_Local.h"


#include <stdio.h>

#include "z_zone.h"

#include "m_random.h"
#include "m_swap.h"

#include "i_system.h"

#include "w_wad.h"

#include "g_game.h"

#include "r_local.h"
#include "s_sound.h"

#include "doomstat.h"

// Data.
#include "sounds.h"

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

#include "wi_stuff.h"


//
// Data needed to add patches to full screen intermission pics.
// Patches are statistics messages, and animations.
// Loads of by-pixel layout and placement, offsets etc.
//


//
// Different vetween registered DOOM (1994) and
//  Ultimate DOOM - Final edition (retail, 1995?).
// This is supposedly ignored for commercial
//  release (aka DOOM II), which had 34 maps
//  in one episode. So there.


// in tics
//U #define PAUSELEN		(TICRATE*2) 
//U #define SCORESTEP		100
//U #define ANIMPERIOD		32
// pixel distance from "(YOU)" to "PLAYER N"
//U #define STARDIST		10 
//U #define WK 1


// GLOBAL LOCATIONS

// SINGPLE-PLAYER STUFF



// NET GAME STUFF



// DEATHMATCH STUFF










//
// Animation.
// There is another anim_t used in p_spec.
//


const point_t lnodes[NUMEPISODES][NUMMAPS] =
{
    // Episode 0 World Map
    {
	{ 185, 164 },	// location of level 0 (CJ)
	{ 148, 143 },	// location of level 1 (CJ)
	{ 69, 122 },	// location of level 2 (CJ)
	{ 209, 102 },	// location of level 3 (CJ)
	{ 116, 89 },	// location of level 4 (CJ)
	{ 166, 55 },	// location of level 5 (CJ)
	{ 71, 56 },	// location of level 6 (CJ)
	{ 135, 29 },	// location of level 7 (CJ)
	{ 71, 24 }	// location of level 8 (CJ)
    },

    // Episode 1 World Map should go here
    {
	{ 254, 25 },	// location of level 0 (CJ)
	{ 97, 50 },	// location of level 1 (CJ)
	{ 188, 64 },	// location of level 2 (CJ)
	{ 128, 78 },	// location of level 3 (CJ)
	{ 214, 92 },	// location of level 4 (CJ)
	{ 133, 130 },	// location of level 5 (CJ)
	{ 208, 136 },	// location of level 6 (CJ)
	{ 148, 140 },	// location of level 7 (CJ)
	{ 235, 158 }	// location of level 8 (CJ)
    },

    // Episode 2 World Map should go here
    {
	{ 156, 168 },	// location of level 0 (CJ)
	{ 48, 154 },	// location of level 1 (CJ)
	{ 174, 95 },	// location of level 2 (CJ)
	{ 265, 75 },	// location of level 3 (CJ)
	{ 130, 48 },	// location of level 4 (CJ)
	{ 279, 23 },	// location of level 5 (CJ)
	{ 198, 48 },	// location of level 6 (CJ)
	{ 140, 25 },	// location of level 7 (CJ)
	{ 281, 136 }	// location of level 8 (CJ)
    }

};


//
// Animation locations for episode 0 (1).
// Using patches saves a lot of space,
//  as they replace 320x200 full screen frames.
//
extern const anim_t temp_epsd0animinfo[10];
const anim_t temp_epsd0animinfo[10] =
{
    { ANIM_ALWAYS, TICRATE/3, 3, { 224, 104 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 184, 160 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 112, 136 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 72, 112 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 88, 96 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 64, 48 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 192, 40 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 136, 16 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 80, 16 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 64, 24 } }
};

extern const anim_t temp_epsd1animinfo[9];
const anim_t temp_epsd1animinfo[9] =
{
    { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 1 },
    { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 2 },
    { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 3 },
    { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 4 },
    { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 5 },
    { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 6 },
    { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 7 },
    { ANIM_LEVEL, TICRATE/3, 3, { 192, 144 }, 8 },
    { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 8 }
};

extern const anim_t temp_epsd2animinfo[6];
const anim_t temp_epsd2animinfo[6] =
{
    { ANIM_ALWAYS, TICRATE/3, 3, { 104, 168 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 40, 136 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 160, 96 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 104, 80 } },
    { ANIM_ALWAYS, TICRATE/3, 3, { 120, 32 } },
    { ANIM_ALWAYS, TICRATE/4, 3, { 40, 0 } }
};


//
// GENERAL DATA
//

//
// Locally used stuff.
//


// States for single-player


// in seconds
//#define SHOWLASTLOCDELAY	SHOWNEXTLOCDELAY


// used to accelerate or skip a stage

// ::g->wbs->pnum

 // specifies current ::g->state

// contains information passed into intermission

const wbplayerstruct_t* plrs;  // ::g->wbs->plyr[]

// used for general timing

// used for timing of background animation

// signals to refresh everything for one frame


// # of commercial levels


//
//	GRAPHICS
//


//
// CODE
//



void localCalculateAchievements(bool epComplete)
{

	if( !common->IsMultiplayer() ) {

			player_t  *player = &::g->players[::g->consoleplayer];

			// Calculate Any Achievements earned from stat cumulation.
			idAchievementManager::CheckDoomClassicsAchievements( player->killcount, player->itemcount, player->secretcount, ::g->gameskill, ::g->gamemission, ::g->gamemap, ::g->gameepisode, ::g->totalkills, ::g->totalitems, ::g->totalsecret );


	}
}

// slam background
// UNUSED static unsigned char *background=0;


void WI_slamBackground(void)
{
    memcpy(::g->screens[0], ::g->screens[1], SCREENWIDTH * SCREENHEIGHT);
    V_MarkRect (0, 0, SCREENWIDTH, SCREENHEIGHT);
}

// The ticker is used to detect keys
//  because of timing issues in netgames.
qboolean WI_Responder(event_t* ev)
{
    return false;
}

// Draws "<Levelname> Finished!"
void WI_drawLF(void)
{
    int y = WI_TITLEY;

    // draw <LevelName> 
	V_DrawPatch((ORIGINAL_WIDTH - SHORT(::g->lnames[::g->wbs->last]->width))/2,
		y, FB, ::g->lnames[::g->wbs->last]);

    // draw "Finished!"
    y += (5*SHORT(::g->lnames[::g->wbs->last]->height))/4;
    
    V_DrawPatch((ORIGINAL_WIDTH - SHORT(::g->finished->width))/2,
		y, FB, ::g->finished);
}



// Draws "Entering <LevelName>"
void WI_drawEL(void)
{
    int y = WI_TITLEY;

    // draw "Entering"
    V_DrawPatch((ORIGINAL_WIDTH - SHORT(::g->entering->width))/2,
		y, FB, ::g->entering);

    // draw level
    y += (5*SHORT(::g->lnames[::g->wbs->next]->height))/4;

    V_DrawPatch((ORIGINAL_WIDTH - SHORT(::g->lnames[::g->wbs->next]->width))/2,
		y, FB, ::g->lnames[::g->wbs->next]);

}

void
WI_drawOnLnode
( int		n,
  patch_t*	c[] )
{

    int		i;
    int		left;
    int		top;
    int		right;
    int		bottom;
    qboolean	fits = false;

    i = 0;
    do
    {
	left = lnodes[::g->wbs->epsd][n].x - SHORT(c[i]->leftoffset);
	top = lnodes[::g->wbs->epsd][n].y - SHORT(c[i]->topoffset);
	right = left + SHORT(c[i]->width);
	bottom = top + SHORT(c[i]->height);

	if (left >= 0
	    && right < SCREENWIDTH
	    && top >= 0
	    && bottom < SCREENHEIGHT)
	{
	    fits = true;
	}
	else
	{
	    i++;
	}
    } while (!fits && i!=2);

    if (fits && i<2)
    {
	V_DrawPatch(lnodes[::g->wbs->epsd][n].x, lnodes[::g->wbs->epsd][n].y,
		    FB, c[i]);
    }
    else
    {
	// DEBUG
	I_Printf("Could not place patch on level %d", n+1); 
    }
}



void WI_initAnimatedBack(void)
{
    int		i;
    anim_t*	a;

    if (::g->gamemode == commercial)
	return;

    if (::g->wbs->epsd > 2)
	return;

    for (i=0;i < ::g->NUMANIMS[::g->wbs->epsd];i++)
    {
		 a = &::g->wi_stuff_anims[::g->wbs->epsd][i];

	// init variables
	a->ctr = -1;

	// specify the next time to draw it
	if (a->type == ANIM_ALWAYS)
	    a->nexttic = ::g->bcnt + 1 + (M_Random()%a->period);
	else if (a->type == ANIM_RANDOM)
	    a->nexttic = ::g->bcnt + 1 + a->data2+(M_Random()%a->data1);
	else if (a->type == ANIM_LEVEL)
	    a->nexttic = ::g->bcnt + 1;
    }

}


void WI_updateAnimatedBack(void)
{
    int		i;
    anim_t*	a;

    if (::g->gamemode == commercial)
	return;

    if (::g->wbs->epsd > 2)
	return;

    for (i=0;i < ::g->NUMANIMS[::g->wbs->epsd];i++)
    {
		 a = &::g->wi_stuff_anims[::g->wbs->epsd][i];

	if (::g->bcnt == a->nexttic)
	{
	    switch (a->type)
	    {
	      case ANIM_ALWAYS:
		if (++a->ctr >= a->nanims) a->ctr = 0;
		a->nexttic = ::g->bcnt + a->period;
		break;

	      case ANIM_RANDOM:
		a->ctr++;
		if (a->ctr == a->nanims)
		{
		    a->ctr = -1;
		    a->nexttic = ::g->bcnt+a->data2+(M_Random()%a->data1);
		}
		else a->nexttic = ::g->bcnt + a->period;
		break;
		
	      case ANIM_LEVEL:
		// gawd-awful hack for level anims
		if (!(::g->state == StatCount && i == 7)
		    && ::g->wbs->next == a->data1)
		{
		    a->ctr++;
		    if (a->ctr == a->nanims) a->ctr--;
		    a->nexttic = ::g->bcnt + a->period;
		}
		break;
	    }
	}

    }

}

void WI_drawAnimatedBack(void)
{
    int			i;
    anim_t*		a;

    if (commercial)
	return;

    if (::g->wbs->epsd > 2)
	return;

    for (i=0 ; i < ::g->NUMANIMS[::g->wbs->epsd] ; i++)
    {
		 a = &::g->wi_stuff_anims[::g->wbs->epsd][i];

	if (a->ctr >= 0)
	    V_DrawPatch(a->loc.x, a->loc.y, FB, a->p[a->ctr]);
    }

}

//
// Draws a number.
// If digits > 0, then use that many digits minimum,
//  otherwise only use as many as necessary.
// Returns new x position.
//

int
WI_drawNum
( int		x,
  int		y,
  int		n,
  int		digits )
{

    int		fontwidth = SHORT(::g->num[0]->width);
    int		neg;
    int		temp;

    if (digits < 0)
    {
	if (!n)
	{
	    // make variable-length zeros 1 digit long
	    digits = 1;
	}
	else
	{
	    // figure out # of digits in #
	    digits = 0;
	    temp = n;

	    while (temp)
	    {
		temp /= 10;
		digits++;
	    }
	}
    }

    neg = n < 0;
    if (neg)
	n = -n;

    // if non-number, do not draw it
    if (n == 1994)
	return 0;

    // draw the new number
    while (digits--)
    {
	x -= fontwidth;
	V_DrawPatch(x, y, FB, ::g->num[ n % 10 ]);
	n /= 10;
    }

    // draw a minus sign if necessary
    if (neg)
	V_DrawPatch(x-=8, y, FB, ::g->wiminus);

    return x;

}

void
WI_drawPercent
( int		x,
  int		y,
  int		p )
{
    if (p < 0)
	return;

    V_DrawPatch(x, y, FB, ::g->percent);
    WI_drawNum(x, y, p, -1);
}



//
// Display level completion time and par,
//  or "sucks" message if overflow.
//
void
WI_drawTime
( int		x,
  int		y,
  int		t )
{

    int		div;
    int		n;

    if (t<0)
	return;

    if (t <= 61*59)
    {
	div = 1;

	do
	{
	    n = (t / div) % 60;
	    x = WI_drawNum(x, y, n, 2) - SHORT(::g->colon->width);
	    div *= 60;

	    // draw
	    if (div==60 || t / div)
		V_DrawPatch(x, y, FB, ::g->colon);
	    
	} while (t / div);
    }
    else
    {
	// "sucks"
	V_DrawPatch(x - SHORT(::g->sucks->width), y, FB, ::g->sucks); 
    }
}


void WI_End(void)
{
    void WI_unloadData(void);
    WI_unloadData();
}

void WI_initNoState(void)
{
    ::g->state = NoState;
    ::g->acceleratestage = 0;
    ::g->cnt = 10;
}

void WI_updateNoState(void) {

    WI_updateAnimatedBack();

    if (!--::g->cnt) {
		// Unload data
		WI_End();
		G_WorldDone();
    }

	DoomLib::ActivateGame();
}



void WI_initShowNextLoc(void)
{
    ::g->state = ShowNextLoc;
    ::g->acceleratestage = 0;
    ::g->cnt = SHOWNEXTLOCDELAY * TICRATE;

    WI_initAnimatedBack();

	DoomLib::ActivateGame();
}

void WI_updateShowNextLoc(void)
{
    WI_updateAnimatedBack();

    if (!--::g->cnt || ::g->acceleratestage) {
		WI_initNoState();
		DoomLib::ShowXToContinue( false );
	} else {
		::g->snl_pointeron = (::g->cnt & 31) < 20;
	}
}

void WI_drawShowNextLoc(void)
{

    int		i;
    int		last;

    WI_slamBackground();

    // draw animated background
    WI_drawAnimatedBack(); 

    if ( ::g->gamemode != commercial)
    {
  	if (::g->wbs->epsd > 2)
	{
	    WI_drawEL();
	    return;
	}
	
	last = (::g->wbs->last == 8) ? ::g->wbs->next - 1 : ::g->wbs->last;

	// don't draw any splats for extra secret levels
	if( last == 9 ) {
		for (i=0 ; i<MAXPLAYERS ; i++) {
				::g->players[i].didsecret = false; 
		}
		::g->wbs->didsecret = false;
		last = -1;
	}

	// draw a splat on taken cities.
	for (i=0 ; i<=last ; i++)
	    WI_drawOnLnode(i, &::g->splat);

	// splat the secret level?
	if (::g->wbs->didsecret)
	    WI_drawOnLnode(8, &::g->splat);

	// draw flashing ptr
	if (::g->snl_pointeron)
	    WI_drawOnLnode(::g->wbs->next, ::g->yah); 
    }

    // draws which level you are entering..
    if ( (::g->gamemode != commercial)
	 || ::g->wbs->next != 30)
	WI_drawEL();  

}

void WI_drawNoState(void)
{
    ::g->snl_pointeron = true;
    WI_drawShowNextLoc();
}

int WI_fragSum(int playernum)
{
    int		i;
    int		frags = 0;
    
	for (i=0 ; i<MAXPLAYERS ; i++)
	{
		if (/*::g->playeringame[i] &&*/ i!=playernum)
		{
			frags += plrs[playernum].frags[i];
		}
	}

	
    // JDC hack - negative frags.
    frags -= plrs[playernum].frags[playernum];
    // UNUSED if (frags < 0)
    // 	frags = 0;

    return frags;
}

int WI_fragOnlySum(int playernum)
{
	int		i;
	int		frags = 0;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
		if (/*::g->playeringame[i] &&*/ i!=playernum)
		{
			frags += plrs[playernum].frags[i];
		}
	}

	return frags;
}

int WI_deathSum(int playernum)
{
	int		i;
	int		deaths = 0;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
		if ( 1 /*::g->playeringame[i]*/)
		{
			deaths += plrs[i].frags[playernum];
		}
	}

	return deaths;
}






void WI_initDeathmatchStats(void)
{

    int		i;
    int		j;

    ::g->state = StatCount;
    ::g->acceleratestage = 0;
    ::g->dm_state = 1;

    ::g->cnt_pause = TICRATE;

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	if (::g->playeringame[i])
	{
	    for (j=0 ; j<MAXPLAYERS ; j++)
		if (::g->playeringame[j])
		    ::g->dm_frags[i][j] = 0;

	    ::g->dm_totals[i] = 0;
	}
    }
    
    WI_initAnimatedBack();

	if ( common->IsMultiplayer() ) {
		localCalculateAchievements(false);

		/* JAF PS3 
		gameLocal->liveSession.GetDMSession().SetEndOfMatchStats();
		gameLocal->liveSession.GetDMSession().WriteTrueskill();

		// Write stats
		if ( gameLocal->liveSession.IsHost( ::g->consoleplayer ) ) {
			gameLocal->liveSession.GetDMSession().BeginEndLevel();
		}
		*/
	}

	DoomLib::ShowXToContinue( true );
}



void WI_updateDeathmatchStats(void)
{

    int		i;
    int		j;
    
    qboolean	stillticking;

    WI_updateAnimatedBack();

    if (::g->acceleratestage && ::g->dm_state != 4)
    {
	::g->acceleratestage = 0;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (::g->playeringame[i])
	    {
		for (j=0 ; j<MAXPLAYERS ; j++)
		    if (::g->playeringame[j])
			::g->dm_frags[i][j] = plrs[i].frags[j];

		::g->dm_totals[i] = WI_fragSum(i);
	    }
	}
	

	S_StartSound(0, sfx_barexp);
	::g->dm_state = 4;
    }

    
    if (::g->dm_state == 2)
    {
	if (!(::g->bcnt&3))
	    S_StartSound(0, sfx_pistol);
	
	stillticking = false;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (::g->playeringame[i])
	    {
		for (j=0 ; j<MAXPLAYERS ; j++)
		{
		    if (::g->playeringame[j]
			&& ::g->dm_frags[i][j] != plrs[i].frags[j])
		    {
			if (plrs[i].frags[j] < 0)
			    ::g->dm_frags[i][j]--;
			else
			    ::g->dm_frags[i][j]++;

			if (::g->dm_frags[i][j] > 99)
			    ::g->dm_frags[i][j] = 99;

			if (::g->dm_frags[i][j] < -99)
			    ::g->dm_frags[i][j] = -99;
			
			stillticking = true;
		    }
		}
		::g->dm_totals[i] = WI_fragSum(i);

		if (::g->dm_totals[i] > 99)
		    ::g->dm_totals[i] = 99;
		
		if (::g->dm_totals[i] < -99)
		    ::g->dm_totals[i] = -99;
	    }
	    
	}
	if (!stillticking)
	{
	    S_StartSound(0, sfx_barexp);
	    ::g->dm_state++;
	}

    }
    else if (::g->dm_state == 4)
    {
		if (::g->acceleratestage)
		{
			if ( !::g->demoplayback && ( ::g->usergame || ::g->netgame ) ) {
					// This sound plays repeatedly after a player continues at the end of a deathmatch,
					// and sounds bad. Quick fix is to just not play it.
					//S_StartSound(0, sfx_slop);

					DoomLib::HandleEndMatch();
			}
		}
    }
    else if (::g->dm_state & 1)
    {
		if (!--::g->cnt_pause)
		{
			::g->dm_state++;
			::g->cnt_pause = TICRATE;
		}
    }
}



void WI_drawDeathmatchStats(void)
{

    int		i;
    int		j;
    int		x;
    int		y;
    int		w;
    
    int		lh;	// line height

    lh = WI_SPACINGY;

    WI_slamBackground();
    
    // draw animated background
    WI_drawAnimatedBack(); 
    WI_drawLF();

    // draw stat titles (top line)
    V_DrawPatch(DM_TOTALSX-SHORT(::g->total->width)/2,
		DM_MATRIXY-WI_SPACINGY+10,
		FB,
		::g->total);
    
    V_DrawPatch(DM_KILLERSX, DM_KILLERSY, FB, ::g->killers);
    V_DrawPatch(DM_VICTIMSX, DM_VICTIMSY, FB, ::g->victims);

    // draw P?
    x = DM_MATRIXX + DM_SPACINGX;
    y = DM_MATRIXY;

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	if (::g->playeringame[i])
	{
	    V_DrawPatch(x-SHORT(::g->wistuff_p[i]->width)/2,
			DM_MATRIXY - WI_SPACINGY,
			FB,
			::g->wistuff_p[i]);
	    
	    V_DrawPatch(DM_MATRIXX-SHORT(::g->wistuff_p[i]->width)/2,
			y,
			FB,
			::g->wistuff_p[i]);

		// No splitscreen on PC currently
	    if (i == ::g->me /* && !gameLocal->IsSplitscreen() */ )
	    {
		V_DrawPatch(x-SHORT(::g->wistuff_p[i]->width)/2,
			    DM_MATRIXY - WI_SPACINGY,
			    FB,
			    ::g->bstar);

		V_DrawPatch(DM_MATRIXX-SHORT(::g->wistuff_p[i]->width)/2,
			    y,
			    FB,
			    ::g->star);
	    }
	}
	else
	{
		//V_DrawPatch(x-SHORT(::g->wistuff_bp[i]->width)/2,
	    //  DM_MATRIXY - WI_SPACINGY, FB, ::g->wistuff_bp[i]);
		//V_DrawPatch(DM_MATRIXX-SHORT(::g->wistuff_bp[i]->width)/2,
		// y, FB, ::g->wistuff_bp[i]);
	}
	x += DM_SPACINGX;
	y += WI_SPACINGY;
    }

    // draw stats
    y = DM_MATRIXY+10;
    w = SHORT(::g->num[0]->width);

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	x = DM_MATRIXX + DM_SPACINGX;

	if (::g->playeringame[i])
	{
	    for (j=0 ; j<MAXPLAYERS ; j++)
	    {
		if (::g->playeringame[j])
		    WI_drawNum(x+w, y, ::g->dm_frags[i][j], 2);

		x += DM_SPACINGX;
	    }
	    WI_drawNum(DM_TOTALSX+w, y, ::g->dm_totals[i], 2);
	}
	y += WI_SPACINGY;
    }
}


void WI_initNetgameStats(void)
{

    int i;

    ::g->state = StatCount;
    ::g->acceleratestage = 0;
    ::g->ng_state = 1;

    ::g->cnt_pause = TICRATE;

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	if (!::g->playeringame[i])
	    continue;

	::g->cnt_kills[i] = ::g->cnt_items[i] = ::g->cnt_secret[i] = ::g->cnt_frags[i] = 0;

	::g->dofrags += WI_fragSum(i);
    }

    ::g->dofrags = !!::g->dofrags;

    WI_initAnimatedBack();

	// JAF PS3 
	/*
	if ( gameLocal->IsMultiplayer() ) {
		if(gameLocal->IsFullVersion() && gameLocal->liveSession.IsHost( ::g->consoleplayer )) {
			bool endOfMission = false;

			if ( ::g->gamemission == 0 && ::g->gamemap == 30 ) {
				endOfMission = true;
			}
			else if ( ::g->gamemission > 0 && ::g->gamemap == 8 ) {
				endOfMission = true;
			}

			gameLocal->liveSession.GetCoopSession().BeginEndLevel( endOfMission );
		}
	}
	*/

	DoomLib::ShowXToContinue( true );
	
}



void WI_updateNetgameStats(void)
{

    int		i;
    int		fsum;
    
    qboolean	stillticking;

    WI_updateAnimatedBack();

    if (::g->acceleratestage && ::g->ng_state != 10)
    {
	::g->acceleratestage = 0;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (!::g->playeringame[i])
		continue;

	    ::g->cnt_kills[i] = (plrs[i].skills * 100) / ::g->wbs->maxkills;
	    ::g->cnt_items[i] = (plrs[i].sitems * 100) / ::g->wbs->maxitems;
	    ::g->cnt_secret[i] = (plrs[i].ssecret * 100) / ::g->wbs->maxsecret;

	    if (::g->dofrags)
		::g->cnt_frags[i] = WI_fragSum(i);
	}
	S_StartSound(0, sfx_barexp);
	::g->ng_state = 10;
    }

    if (::g->ng_state == 2)
    {
	if (!(::g->bcnt&3))
	    S_StartSound(0, sfx_pistol);

	stillticking = false;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (!::g->playeringame[i])
		continue;

	    ::g->cnt_kills[i] += 2;

	    if (::g->cnt_kills[i] >= (plrs[i].skills * 100) / ::g->wbs->maxkills)
		::g->cnt_kills[i] = (plrs[i].skills * 100) / ::g->wbs->maxkills;
	    else
		stillticking = true;
	}
	
	if (!stillticking)
	{
	    S_StartSound(0, sfx_barexp);
	    ::g->ng_state++;
	}
    }
    else if (::g->ng_state == 4)
    {
	if (!(::g->bcnt&3))
	    S_StartSound(0, sfx_pistol);

	stillticking = false;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (!::g->playeringame[i])
		continue;

	    ::g->cnt_items[i] += 2;
	    if (::g->cnt_items[i] >= (plrs[i].sitems * 100) / ::g->wbs->maxitems)
		::g->cnt_items[i] = (plrs[i].sitems * 100) / ::g->wbs->maxitems;
	    else
		stillticking = true;
	}
	if (!stillticking)
	{
	    S_StartSound(0, sfx_barexp);
	    ::g->ng_state++;
	}
    }
    else if (::g->ng_state == 6)
    {
	if (!(::g->bcnt&3))
	    S_StartSound(0, sfx_pistol);

	stillticking = false;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (!::g->playeringame[i])
		continue;

	    ::g->cnt_secret[i] += 2;

	    if (::g->cnt_secret[i] >= (plrs[i].ssecret * 100) / ::g->wbs->maxsecret)
		::g->cnt_secret[i] = (plrs[i].ssecret * 100) / ::g->wbs->maxsecret;
	    else
		stillticking = true;
	}
	
	if (!stillticking)
	{
	    S_StartSound(0, sfx_barexp);
	    ::g->ng_state += 1 + 2*!::g->dofrags;
	}
    }
    else if (::g->ng_state == 8)
    {
	if (!(::g->bcnt&3))
	    S_StartSound(0, sfx_pistol);

	stillticking = false;

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
	    if (!::g->playeringame[i])
		continue;

	    ::g->cnt_frags[i] += 1;

	    if (::g->cnt_frags[i] >= (fsum = WI_fragSum(i)))
		::g->cnt_frags[i] = fsum;
	    else
		stillticking = true;
	}
	
	if (!stillticking)
	{
	    S_StartSound(0, sfx_pldeth);
	    ::g->ng_state++;
	}
    }
    else if (::g->ng_state == 10)
    {
	if (::g->acceleratestage)
	{
		if ( !::g->demoplayback && ( ::g->usergame || ::g->netgame ) ) {
			S_StartSound(0, sfx_sgcock);

			// need to do this again if they buy it
			localCalculateAchievements(false);
			if (::g->gamemode == commercial){
				WI_initNoState();
				DoomLib::ShowXToContinue( false );
			}
			else{
				WI_initShowNextLoc();
			}
		}
	}
    }
    else if (::g->ng_state & 1)
    {
	if (!--::g->cnt_pause)
	{
	    ::g->ng_state++;
	    ::g->cnt_pause = TICRATE;
	}
    }
}



void WI_drawNetgameStats(void)
{
    int		i;
    int		x;
    int		y;
    int		pwidth = SHORT(::g->percent->width);

    WI_slamBackground();
    
    // draw animated background
    WI_drawAnimatedBack(); 

    WI_drawLF();

    // draw stat titles (top line)
    V_DrawPatch(NG_STATSX+NG_SPACINGX-SHORT(::g->kills->width),
		NG_STATSY, FB, ::g->kills);

    V_DrawPatch(NG_STATSX+2*NG_SPACINGX-SHORT(::g->items->width),
		NG_STATSY, FB, ::g->items);

    V_DrawPatch(NG_STATSX+3*NG_SPACINGX-SHORT(::g->secret->width),
		NG_STATSY, FB, ::g->secret);
    
    if (::g->dofrags)
	V_DrawPatch(NG_STATSX+4*NG_SPACINGX-SHORT(::g->wistuff_frags->width),
		    NG_STATSY, FB, ::g->wistuff_frags);

    // draw stats
    y = NG_STATSY + SHORT(::g->kills->height);

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	if (!::g->playeringame[i])
	    continue;

	x = NG_STATSX;
	V_DrawPatch(x-SHORT(::g->wistuff_p[i]->width), y, FB, ::g->wistuff_p[i]);

	// No splitscreen on PC
	if (i == ::g->me /* && !gameLocal->IsSplitscreen() */ )
	    V_DrawPatch(x-SHORT(::g->wistuff_p[i]->width), y, FB, ::g->star);

	x += NG_SPACINGX;
	WI_drawPercent(x-pwidth, y+10, ::g->cnt_kills[i]);	x += NG_SPACINGX;
	WI_drawPercent(x-pwidth, y+10, ::g->cnt_items[i]);	x += NG_SPACINGX;
	WI_drawPercent(x-pwidth, y+10, ::g->cnt_secret[i]);	x += NG_SPACINGX;

	if (::g->dofrags)
	    WI_drawNum(x, y+10, ::g->cnt_frags[i], -1);

	y += WI_SPACINGY;
    }

}


void WI_initStats(void)
{
    ::g->state = StatCount;
    ::g->acceleratestage = 0;
    ::g->sp_state = 1;
    ::g->cnt_kills[0] = ::g->cnt_items[0] = ::g->cnt_secret[0] = -1;
    ::g->cnt_time = ::g->cnt_par = -1;
    ::g->cnt_pause = TICRATE;

    WI_initAnimatedBack();

	DoomLib::ShowXToContinue( true );
}

void WI_updateStats(void)
{

    WI_updateAnimatedBack();

    if (::g->acceleratestage && ::g->sp_state != 10)
    {
		::g->acceleratestage = 0;
		::g->cnt_kills[0] = (plrs[::g->me].skills * 100) / ::g->wbs->maxkills;
		::g->cnt_items[0] = (plrs[::g->me].sitems * 100) / ::g->wbs->maxitems;
		::g->cnt_secret[0] = (plrs[::g->me].ssecret * 100) / ::g->wbs->maxsecret;
		::g->cnt_time = plrs[::g->me].stime / TICRATE;
		::g->cnt_par = ::g->wbs->partime / TICRATE;
		S_StartSound(0, sfx_barexp);
		::g->sp_state = 10;
    }

    if (::g->sp_state == 2)
    {
		::g->cnt_kills[0] += 2;

		if (!(::g->bcnt&3))
			S_StartSound(0, sfx_pistol);

		if (::g->cnt_kills[0] >= (plrs[::g->me].skills * 100) / ::g->wbs->maxkills)
		{
			::g->cnt_kills[0] = (plrs[::g->me].skills * 100) / ::g->wbs->maxkills;
			S_StartSound(0, sfx_barexp);
			::g->sp_state++;
		}
    }
    else if (::g->sp_state == 4)
    {
		::g->cnt_items[0] += 2;

		if (!(::g->bcnt&3))
			S_StartSound(0, sfx_pistol);

		if (::g->cnt_items[0] >= (plrs[::g->me].sitems * 100) / ::g->wbs->maxitems)
		{
			::g->cnt_items[0] = (plrs[::g->me].sitems * 100) / ::g->wbs->maxitems;
			S_StartSound(0, sfx_barexp);
			::g->sp_state++;
		}
    }
    else if (::g->sp_state == 6)
    {
		::g->cnt_secret[0] += 2;

		if (!(::g->bcnt&3))
			S_StartSound(0, sfx_pistol);

		if (::g->cnt_secret[0] >= (plrs[::g->me].ssecret * 100) / ::g->wbs->maxsecret)
		{
			::g->cnt_secret[0] = (plrs[::g->me].ssecret * 100) / ::g->wbs->maxsecret;
			S_StartSound(0, sfx_barexp);
			::g->sp_state++;
		}
    }

    else if (::g->sp_state == 8)
    {
		if (!(::g->bcnt&3))
			S_StartSound(0, sfx_pistol);

		::g->cnt_time += 3;

		if (::g->cnt_time >= plrs[::g->me].stime / TICRATE)
			::g->cnt_time = plrs[::g->me].stime / TICRATE;

		::g->cnt_par += 3;

		if (::g->cnt_par >= ::g->wbs->partime / TICRATE)
		{
			::g->cnt_par = ::g->wbs->partime / TICRATE;

			if (::g->cnt_time >= plrs[::g->me].stime / TICRATE)
			{
				S_StartSound(0, sfx_barexp);
				::g->sp_state++;
			}
		}
    }
    else if (::g->sp_state == 10)
    {
        if (::g->acceleratestage)
		{
			if ( !::g->demoplayback && ( ::g->usergame || ::g->netgame ) ) {

				S_StartSound(0, sfx_sgcock);

				// need to do this again if they buy it
				localCalculateAchievements(false);

				if (::g->gamemode == commercial) {
					WI_initNoState();
				}
				else{
					WI_initShowNextLoc();
				}
			}
		}
    }
    else if (::g->sp_state & 1)
    {
		if (!--::g->cnt_pause)
		{
			::g->sp_state++;
			::g->cnt_pause = TICRATE;
		}
    }

}

void WI_drawStats(void)
{
    // line height
    int lh;	

    lh = (3*SHORT(::g->num[0]->height))/2;

    WI_slamBackground();

    // draw animated background
    WI_drawAnimatedBack();
    
    WI_drawLF();

    V_DrawPatch(SP_STATSX, SP_STATSY, FB, ::g->kills);
    WI_drawPercent(ORIGINAL_WIDTH - SP_STATSX, SP_STATSY, ::g->cnt_kills[0]);

    V_DrawPatch(SP_STATSX, SP_STATSY+lh, FB, ::g->items);
    WI_drawPercent(ORIGINAL_WIDTH - SP_STATSX, SP_STATSY+lh, ::g->cnt_items[0]);

    V_DrawPatch(SP_STATSX, SP_STATSY+2*lh, FB, ::g->sp_secret);
    WI_drawPercent(ORIGINAL_WIDTH - SP_STATSX, SP_STATSY+2*lh, ::g->cnt_secret[0]);

    V_DrawPatch(SP_TIMEX, SP_TIMEY, FB, ::g->time);
    WI_drawTime(ORIGINAL_WIDTH/2 - SP_TIMEX, SP_TIMEY, ::g->cnt_time);

	// DHM - Nerve :: Added episode 4 par times
    //if (::g->wbs->epsd < 3)
    //{
	V_DrawPatch(ORIGINAL_WIDTH/2 + SP_TIMEX, SP_TIMEY, FB, ::g->par);
	WI_drawTime(ORIGINAL_WIDTH - SP_TIMEX, SP_TIMEY, ::g->cnt_par);
    //}

}

void WI_checkForAccelerate(void)
{
    int   i;
    player_t  *player;

    // check for button presses to skip delays
    for (i=0, player = ::g->players ; i<MAXPLAYERS ; i++, player++)
    {
		if (::g->playeringame[i])
		{
			if (player->cmd.buttons & BT_ATTACK)
			{
				if (!player->attackdown) {
					::g->acceleratestage = 1;
				}
				player->attackdown = true;
			} else {
				player->attackdown = false;
			}
			if (player->cmd.buttons & BT_USE)
			{
				if (!player->usedown) {
					::g->acceleratestage = 1;
				}
				player->usedown = true;
				
			} else {
				player->usedown = false;
			}
		}
    }
}



// Updates stuff each tick
void WI_Ticker(void)
{
    // counter for general background animation
    ::g->bcnt++;  

    if (::g->bcnt == 1)
    {
	// intermission music
  	if ( ::g->gamemode == commercial )
	  S_ChangeMusic(mus_dm2int, true);
	else
	  S_ChangeMusic(mus_inter, true); 
    }

    WI_checkForAccelerate();

    switch (::g->state)
    {
      case StatCount:
	if (::g->deathmatch) WI_updateDeathmatchStats();
	else if (::g->netgame) WI_updateNetgameStats();
	else WI_updateStats();
	break;
	
      case ShowNextLoc:
	WI_updateShowNextLoc();
	break;
	
      case NoState:
	WI_updateNoState();
	break;
    }

}

void WI_loadData(void)
{	
	int		i;
	int		j;
	char	name[9];
	anim_t*	a;

	if (::g->gamemode == commercial)
		strcpy(name, "INTERPIC");
		// DHM - Nerve :: Use our background image
		//strcpy(name, "DMENUPIC");
	else 
		sprintf(name, "WIMAP%d", ::g->wbs->epsd);

	if ( ::g->gamemode == retail )
	{
		if (::g->wbs->epsd == 3)
			strcpy(name,"INTERPIC");
	}

	// background
	::g->bg = (patch_t*)W_CacheLumpName(name, PU_LEVEL_SHARED);    

	V_DrawPatch(0, 0, 1, ::g->bg);


    // UNUSED unsigned char *pic = ::g->screens[1];
    // if (::g->gamemode == commercial)
    // {
    // darken the background image
    // while (pic != ::g->screens[1] + SCREENHEIGHT*SCREENWIDTH)
    // {
    //   *pic = ::g->colormaps[256*25 + *pic];
    //   pic++;
    // }
    //}

	if (::g->gamemode == commercial)
	{
		::g->NUMCMAPS = 32;
		::g->lnames = (patch_t **) DoomLib::Z_Malloc(sizeof(patch_t*) * ::g->NUMCMAPS, PU_LEVEL_SHARED, 0);
		for (i=0 ; i < ::g->NUMCMAPS ; i++)
		{								
			sprintf(name, "CWILV%2.2d", i);
			::g->lnames[i] = (patch_t*)W_CacheLumpName(name, PU_LEVEL_SHARED);
		}					
	}
	else
	{
		::g->lnames = (patch_t **) DoomLib::Z_Malloc(sizeof(patch_t*) * ( NUMMAPS ), PU_LEVEL_SHARED, 0);
		for (i=0 ; i<NUMMAPS ; i++)
		{
			sprintf(name, "WILV%d%d", ::g->wbs->epsd, i);
			::g->lnames[i] = (patch_t*)W_CacheLumpName(name, PU_LEVEL_SHARED);
		}

		// you are here
		::g->yah[0] = (patch_t*)W_CacheLumpName("WIURH0", PU_LEVEL_SHARED);

		// you are here (alt.)
		::g->yah[1] = (patch_t*)W_CacheLumpName("WIURH1", PU_LEVEL_SHARED);

		// splat
		::g->splat = (patch_t*)W_CacheLumpName("WISPLAT", PU_LEVEL_SHARED); 
	
		if (::g->wbs->epsd < 3)
		{
			for (j=0;j < ::g->NUMANIMS[::g->wbs->epsd];j++)
			{
				a = &::g->wi_stuff_anims[::g->wbs->epsd][j];
				for (i=0;i<a->nanims;i++)
				{
					// MONDO HACK!
					if (::g->wbs->epsd != 1 || j != 8) 
					{
						// animations
						sprintf(name, "WIA%d%.2d%.2d", ::g->wbs->epsd, j, i);  
						a->p[i] = (patch_t*)W_CacheLumpName(name, PU_LEVEL_SHARED);
					}
					else
					{
						// HACK ALERT!
						a->p[i] = ::g->wi_stuff_anims[1][4].p[i]; 
					}
				}
			}
		}
	}

	// More hacks on minus sign.
	::g->wiminus = (patch_t*)W_CacheLumpName("WIMINUS", PU_LEVEL_SHARED); 

	for (i=0;i<10;i++)
	{
		// numbers 0-9
		sprintf(name, "WINUM%d", i);     
		::g->num[i] = (patch_t*)W_CacheLumpName(name, PU_LEVEL_SHARED);
	}

	// percent sign
	::g->percent = (patch_t*)W_CacheLumpName("WIPCNT", PU_LEVEL_SHARED);

	// "finished"
	::g->finished = (patch_t*)W_CacheLumpName("WIF", PU_LEVEL_SHARED);

	// "entering"
	::g->entering = (patch_t*)W_CacheLumpName("WIENTER", PU_LEVEL_SHARED);

	// "kills"
	::g->kills = (patch_t*)W_CacheLumpName("WIOSTK", PU_LEVEL_SHARED);   

	// "scrt"
	::g->secret = (patch_t*)W_CacheLumpName("WIOSTS", PU_LEVEL_SHARED);

	 // "secret"
	::g->sp_secret = (patch_t*)W_CacheLumpName("WISCRT2", PU_LEVEL_SHARED);

	::g->items = (patch_t*)W_CacheLumpName("WIOSTI", PU_LEVEL_SHARED);

	// "frgs"
	::g->wistuff_frags = (patch_t*)W_CacheLumpName("WIFRGS", PU_LEVEL_SHARED);    

	// ":"
	::g->colon = (patch_t*)W_CacheLumpName("WICOLON", PU_LEVEL_SHARED); 

	// "time"
	::g->time = (patch_t*)W_CacheLumpName("WITIME", PU_LEVEL_SHARED);   

	// "sucks"
	::g->sucks = (patch_t*)W_CacheLumpName("WISUCKS", PU_LEVEL_SHARED);  

	// "par"
	::g->par = (patch_t*)W_CacheLumpName("WIPAR", PU_LEVEL_SHARED);   

	// "killers" (vertical)
	::g->killers = (patch_t*)W_CacheLumpName("WIKILRS", PU_LEVEL_SHARED);

	// "victims" (horiz)
	::g->victims = (patch_t*)W_CacheLumpName("WIVCTMS", PU_LEVEL_SHARED);

	// "total"
	::g->total = (patch_t*)W_CacheLumpName("WIMSTT", PU_LEVEL_SHARED);   

	// your face
	::g->star = (patch_t*)W_CacheLumpName("STFST01", PU_STATIC_SHARED); // ALAN: this is statically in the game...

	// dead face
	::g->bstar = (patch_t*)W_CacheLumpName("STFDEAD0", PU_STATIC_SHARED);    

	for (i=0 ; i<MAXPLAYERS ; i++)
	{
		// "1,2,3,4"
		sprintf(name, "STPB%d", i);      
		::g->wistuff_p[i] = (patch_t*)W_CacheLumpName(name, PU_LEVEL_SHARED);

		// "1,2,3,4"
		sprintf(name, "WIBP%d", i+1);     
		::g->wistuff_bp[i] = (patch_t*)W_CacheLumpName(name, PU_LEVEL_SHARED);
	}

}

void WI_unloadData(void)
{
	Z_FreeTags( PU_LEVEL_SHARED, PU_LEVEL_SHARED );
	// HACK ALERT - reset these to help stability? they are used for consistency checking
	for (int i=0 ; i<MAXPLAYERS ; i++)
	{
		if (::g->playeringame[i]) 
		{ 
			::g->players[i].mo = NULL;
		}
	}
	::g->bg = NULL;	
}

void WI_Drawer (void)
{
    switch (::g->state)
    {
      case StatCount:
	if (::g->deathmatch)
	    WI_drawDeathmatchStats();
	else if (::g->netgame)
	    WI_drawNetgameStats();
	else
	    WI_drawStats();
	break;
	
      case ShowNextLoc:
	WI_drawShowNextLoc();
	break;
	
      case NoState:
	WI_drawNoState();
	break;
    }
}


void WI_initVariables(wbstartstruct_t* wbstartstruct)
{

    ::g->wbs = wbstartstruct;

#ifdef RANGECHECKING
    if (::g->gamemode != commercial)
    {
      if ( ::g->gamemode == retail )
	RNGCHECK(::g->wbs->epsd, 0, 3);
      else
	RNGCHECK(::g->wbs->epsd, 0, 2);
    }
    else
    {
	RNGCHECK(::g->wbs->last, 0, 8);
	RNGCHECK(::g->wbs->next, 0, 8);
    }
    RNGCHECK(::g->wbs->pnum, 0, MAXPLAYERS);
    RNGCHECK(::g->wbs->pnum, 0, MAXPLAYERS);
#endif

    ::g->acceleratestage = 0;
    ::g->cnt = ::g->bcnt = 0;
    ::g->firstrefresh = 1;
    ::g->me = ::g->wbs->pnum;
    plrs = ::g->wbs->plyr;

    if (!::g->wbs->maxkills)
	::g->wbs->maxkills = 1;

    if (!::g->wbs->maxitems)
	::g->wbs->maxitems = 1;

    if (!::g->wbs->maxsecret)
	::g->wbs->maxsecret = 1;

    if ( ::g->gamemode != retail )
      if (::g->wbs->epsd > 2)
	::g->wbs->epsd -= 3;
}

void WI_Start(wbstartstruct_t* wbstartstruct)
{

    WI_initVariables(wbstartstruct);
    WI_loadData();

    if (::g->deathmatch)
	WI_initDeathmatchStats();
    else if (::g->netgame)
	WI_initNetgameStats();
    else
	WI_initStats();
}