/* Emacs style mode select   -*- C++ -*- */
/*-----------------------------------------------------------------------------*/

/* $Id:$*/

/* Copyright (C) 1993-1996 by id Software, Inc.*/

/* This source is available for distribution and/or modification*/
/* only under the terms of the DOOM Source Code License as*/
/* published by id Software. All rights reserved.*/

/* The source is distributed in the hope that it will be useful,*/
/* but WITHOUT ANY WARRANTY; without even the implied warranty of*/
/* FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License*/
/* for more details.*/

/* $Log:$*/

/* DESCRIPTION:*/
/*	Intermission screens.*/

/*-----------------------------------------------------------------------------*/

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

#include <stdio.h>

#include "z_zone.h"

#include "m_random.h"
#include "m_swap.h"
#include "m_fixed.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"

#include "i_video.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.*/
#define NUMEPISODES	4
#define NUMMAPS		9


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


/*
 *  NEW for higher resolutions:
 *  Since the intermission screen is fixed to 320*200 you have
 *  to base everything on these values rather than use the
 *  SCREENWIDTH / SCREENHEIGHT macros. Therefore all references
 *  to those macros have been replaced with the macros
 *  INTERWIDTH, INTERHEIGHT.
 */

#define INTERWIDTH		320
#define INTERHEIGHT		200


/* GLOBAL LOCATIONS*/
#define WI_TITLEY		2
#define WI_SPACINGY    		33

/* SINGPLE-PLAYER STUFF*/
#define SP_STATSX		50
#define SP_STATSY		50

#define SP_TIMEX		16
#define SP_TIMEY		(INTERHEIGHT-32)


/* NET GAME STUFF*/
#define NG_STATSY		50
#define NG_STATSX		(32 + SHORT(star->width)/2 + 32*!dofrags)

#define NG_SPACINGX    		64


/* DEATHMATCH STUFF*/
#define DM_MATRIXX		42
#define DM_MATRIXY		68

#define DM_SPACINGX		40

#define DM_TOTALSX		269

#define DM_KILLERSX		10
#define DM_KILLERSY		100
#define DM_VICTIMSX    		5
#define DM_VICTIMSY		50




typedef enum
{
    ANIM_ALWAYS,
    ANIM_RANDOM,
    ANIM_LEVEL

} animenum_t;

typedef struct
{
    int		x;
    int		y;

} point_t;



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

typedef struct
{
    animenum_t	type;

    /* period in tics between animations*/
    int		period;

    /* number of animation frames*/
    int		nanims;

    /* location of animation*/
    point_t	loc;

    /* ALWAYS: n/a,*/
    /* RANDOM: period deviation (<256),*/
    /* LEVEL: level*/
    int		data1;

    /* ALWAYS: n/a,*/
    /* RANDOM: random base period,*/
    /* LEVEL: n/a*/
    int		data2;

    /* actual graphics for frames of animations*/
    patch_t*	p[3];

    /* following must be initialized to zero before use!*/

    /* next value of bcnt (used in conjunction with period)*/
    int		nexttic;

    /* last drawn animation frame*/
    int		lastdrawn;

    /* next frame number to animate*/
    int		ctr;

    /* used by RANDOM and LEVEL when animating*/
    int		state;

} anim_t;


static 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.*/

static anim_t epsd0animinfo[] =
{
    { 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 } }
};

static anim_t epsd1animinfo[] =
{
    { 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 }
};

static anim_t epsd2animinfo[] =
{
    { 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 } }
};

static int NUMANIMS[NUMEPISODES] =
{
    sizeof(epsd0animinfo)/sizeof(anim_t),
    sizeof(epsd1animinfo)/sizeof(anim_t),
    sizeof(epsd2animinfo)/sizeof(anim_t)
};

static anim_t *anims[NUMEPISODES] =
{
    epsd0animinfo,
    epsd1animinfo,
    epsd2animinfo
};



/* GENERAL DATA*/



/* Locally used stuff.*/

#define FB 0


/* States for single-player*/
#define SP_KILLS		0
#define SP_ITEMS		2
#define SP_SECRET		4
#define SP_FRAGS		6
#define SP_TIME			8
#define SP_PAR			ST_TIME

#define SP_PAUSE		1

/* in seconds*/
#define SHOWNEXTLOCDELAY	4
/*#define SHOWLASTLOCDELAY	SHOWNEXTLOCDELAY*/


/* used to accelerate or skip a stage*/
static int		acceleratestage = 0;

/* wbs->pnum*/
static int		me = 0;

 /* specifies current state*/
static stateenum_t	state = 0;

/* contains information passed into intermission*/
static wbstartstruct_t*	wbs = NULL;

static wbplayerstruct_t* plrs = NULL;  /* wbs->plyr[]*/

/* used for general timing*/
static int 		cnt;

/* used for timing of background animation*/
static int 		bcnt;

/* signals to refresh everything for one frame*/
static int 		firstrefresh;

static int		cnt_kills[MAXPLAYERS];
static int		cnt_items[MAXPLAYERS];
static int		cnt_secret[MAXPLAYERS];
static int		cnt_time;
static int		cnt_par;
static int		cnt_pause;

/* # of commercial levels*/
static int		NUMCMAPS;



/*	GRAPHICS*/


/* background (map of levels).*/
static patch_t*		bg;

/* You Are Here graphic*/
static patch_t*		yah[2];

/* splat*/
static patch_t*		splat;

/* %, : graphics*/
static patch_t*		percent;
static patch_t*		colon;

/* 0-9 graphic*/
static patch_t*		num[10];

/* minus sign*/
static patch_t*		wiminus;

/* "Finished!" graphics*/
static patch_t*		finished;

/* "Entering" graphic*/
static patch_t*		entering;

/* "secret"*/
static patch_t*		sp_secret;

 /* "Kills", "Scrt", "Items", "Frags"*/
static patch_t*		kills;
static patch_t*		secret;
static patch_t*		items;
static patch_t*		frags;

/* Time sucks.*/
static patch_t*		time;
static patch_t*		par;
static patch_t*		sucks;

/* "killers", "victims"*/
static patch_t*		killers;
static patch_t*		victims;

/* "Total", your face, your dead face*/
static patch_t*		total;
static patch_t*		star;
static patch_t*		bstar;

/* "red P[1..MAXPLAYERS]"*/
static patch_t*		p[MAXPLAYERS];

/* "gray P[1..MAXPLAYERS]"*/
static patch_t*		bp[MAXPLAYERS];

 /* Name graphics of each level (centered)*/
static patch_t**	lnames = NULL;


#ifdef STATIC_RESOLUTION
#define INTER_ORGX	((SCREENWIDTH - INTERWIDTH) >> 1)
#define INTER_ORGY	((SCREENHEIGHT - INTERHEIGHT) >> 1)
#else
static int	INTER_ORGX;
static int	INTER_ORGY;
#endif


/* Added for DeHackEd */
#define WILUMP_INTERPIC	0
#define WILUMP_WIURH0	1
#define WILUMP_WIURH1	2
#define WILUMP_WISPLAT	3
#define WILUMP_WIMINUS	4
#define WILUMP_WIPCNT	5
#define WILUMP_WIF	6
#define WILUMP_WIENTER	7
#define WILUMP_WIOSTK	8
#define WILUMP_WIOSTS	9
#define WILUMP_WISCRT2	10
#define WILUMP_WIOBJ	11
#define WILUMP_WIOSTI	12
#define WILUMP_WIFRGS	13
#define WILUMP_WICOLON	14
#define WILUMP_WITIME	15
#define WILUMP_WISUCKS	16
#define WILUMP_WIPAR	17
#define WILUMP_WIKILRS	18
#define WILUMP_WIVCTMS	19
#define WILUMP_WIMSTT	20
#define WILUMP_STFST01	21
#define WILUMP_STFDEAD0	22


char *wistuff_lumps[WILUMP_NUMBER] = {
  "INTERPIC",
  "WIURH0",
  "WIURH1",
  "WISPLAT",
  "WIMINUS",
  "WIPCNT",
  "WIF",
  "WIENTER",
  "WIOSTK",
  "WIOSTS",
  "WISCRT2",
  "WIOBJ",
  "WIOSTI",
  "WIFRGS",
  "WICOLON",
  "WITIME",
  "WISUCKS",
  "WIPAR",
  "WIKILRS",
  "WIVCTMS",
  "WIMSTT",
  "STFST01",
  "STFDEAD0"
};



/* CODE*/


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


static void WI_slamBackground(void)
{
    memcpy(screens[0], screens[1], SCREENWIDTH * SCREENHEIGHT * sizeof(pixel_t));
    V_MarkRect (0, 0, SCREENWIDTH, SCREENHEIGHT);
}

#if 0
/* The ticker is used to detect keys*/
/*  because of timing issues in netgames.*/
static boolean WI_Responder(const event_t* ev)
{
    return false;
}
#endif


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

    /* draw <LevelName> */
    V_DrawPatch(INTER_ORGX + (INTERWIDTH - SHORT(lnames[wbs->last]->width))/2,
		INTER_ORGY + y, FB, lnames[wbs->last]);

    /* draw "Finished!"*/
    y += (5*SHORT(lnames[wbs->last]->height))/4;

    V_DrawPatch(INTER_ORGX + (INTERWIDTH - SHORT(finished->width))/2,
		INTER_ORGY + y, FB, finished);
}



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

    /* draw "Entering"*/
    V_DrawPatch(INTER_ORGX + (INTERWIDTH - SHORT(entering->width))/2,
		INTER_ORGY + y, FB, entering);

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

    V_DrawPatch(INTER_ORGX + (INTERWIDTH - SHORT(lnames[wbs->next]->width))/2,
		INTER_ORGY + y, FB, lnames[wbs->next]);

}

static void
WI_drawOnLnode
( int		n,
  const patch_t** c )
{

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

    i = 0;
    do
    {
	left = lnodes[wbs->epsd][n].x - SHORT(c[i]->leftoffset);
	top = lnodes[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(INTER_ORGX + lnodes[wbs->epsd][n].x, INTER_ORGY + lnodes[wbs->epsd][n].y,
		    FB, c[i]);
    }
    else
    {
	/* DEBUG*/
	fprintf(logfile, "Could not place patch on level %d", n+1);
    }
}



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

    if (gamemode == commercial)
	return;

    if (wbs->epsd > 2)
	return;

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

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

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

}

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

    if (gamemode == commercial)
	return;

    if (wbs->epsd > 2)
	return;

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

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

	      case ANIM_RANDOM:
		a->ctr++;
		if (a->ctr == a->nanims)
		{
		    a->ctr = -1;
		    a->nexttic = bcnt+a->data2+(M_Random()%a->data1);
		}
		else a->nexttic = bcnt + a->period;
		break;

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

    }

}

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

    if (commercial)
	return;

    if (wbs->epsd > 2)
	return;

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

	if (a->ctr >= 0)
	    V_DrawPatch(INTER_ORGX + a->loc.x, INTER_ORGY + 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.*/


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

    int		fontwidth = SHORT(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(INTER_ORGX + x, INTER_ORGY + y, FB, num[ n % 10 ]);
	n /= 10;
    }

    /* draw a minus sign if necessary*/
    if (neg)
    {
	x -= 8;
	V_DrawPatch(INTER_ORGX + x, INTER_ORGY + y, FB, wiminus);
    }
    return x;

}

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

    V_DrawPatch(INTER_ORGX + x, INTER_ORGY + y, FB, percent);
    WI_drawNum(x, y, p, -1);
}




/* Display level completion time and par,*/
/*  or "sucks" message if overflow.*/

static 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(colon->width);
	    div *= 60;

	    /* draw*/
	    if (div==60 || t / div)
		V_DrawPatch(INTER_ORGX + x, INTER_ORGY + y, FB, colon);

	} while (t / div);
    }
    else
    {
	/* "sucks"*/
	V_DrawPatch(INTER_ORGX + x - SHORT(sucks->width), INTER_ORGY + y, FB, sucks);
    }
}


static void WI_unloadData(void);

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

static void WI_initNoState(void)
{
    state = NoState;
    acceleratestage = 0;
    cnt = 10;
}

static void WI_updateNoState(void) {

    WI_updateAnimatedBack();

    if (!--cnt)
    {
	WI_End();
	G_WorldDone();
    }

}

static boolean		snl_pointeron = false;


static void WI_initShowNextLoc(void)
{
    state = ShowNextLoc;
    acceleratestage = 0;
    cnt = SHOWNEXTLOCDELAY * TICRATE;

    WI_initAnimatedBack();
}

static void WI_updateShowNextLoc(void)
{
    WI_updateAnimatedBack();

    if (!--cnt || acceleratestage)
	WI_initNoState();
    else
	snl_pointeron = (cnt & 31) < 20;
}

static void WI_drawShowNextLoc(void)
{

    int		i;
    int		last;

    WI_slamBackground();

    /* draw animated background*/
    WI_drawAnimatedBack();

    if ( gamemode != commercial)
    {
  	if (wbs->epsd > 2)
	{
	    WI_drawEL();
	    return;
	}

	last = (wbs->last == 8) ? wbs->next - 1 : wbs->last;

	/* draw a splat on taken cities.*/
	for (i=0 ; i<=last ; i++)
	    WI_drawOnLnode(i, (const patch_t**)&splat);

	/* splat the secret level?*/
	if (wbs->didsecret)
	    WI_drawOnLnode(8, (const patch_t**)&splat);

	/* draw flashing ptr*/
	if (snl_pointeron)
	    WI_drawOnLnode(wbs->next, (const patch_t**)yah);
    }

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

}

static void WI_drawNoState(void)
{
    snl_pointeron = true;
    WI_drawShowNextLoc();
}

static int WI_fragSum(int playernum)
{
    int		i;
    int		frags = 0;

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	if (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;
}



static int		dm_state = 0;
static int		dm_frags[MAXPLAYERS][MAXPLAYERS];
static int		dm_totals[MAXPLAYERS];



static void WI_initDeathmatchStats(void)
{

    int		i;
    int		j;

    state = StatCount;
    acceleratestage = 0;
    dm_state = 1;

    cnt_pause = TICRATE;

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

	    dm_totals[i] = 0;
	}
    }

    WI_initAnimatedBack();
}



static void WI_updateDeathmatchStats(void)
{

    int		i;
    int		j;

    boolean	stillticking;

    WI_updateAnimatedBack();

    if (acceleratestage && dm_state != 4)
    {
	acceleratestage = 0;

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

		dm_totals[i] = WI_fragSum(i);
	    }
	}


	S_StartSound(0, sfx_barexp);
	dm_state = 4;
    }


    if (dm_state == 2)
    {
	if (!(bcnt&3))
	    S_StartSound(0, sfx_pistol);

	stillticking = false;

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

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

			if (dm_frags[i][j] < -99)
			    dm_frags[i][j] = -99;

			stillticking = true;
		    }
		}
		dm_totals[i] = WI_fragSum(i);

		if (dm_totals[i] > 99)
		    dm_totals[i] = 99;

		if (dm_totals[i] < -99)
		    dm_totals[i] = -99;
	    }

	}
	if (!stillticking)
	{
	    S_StartSound(0, sfx_barexp);
	    dm_state++;
	}

    }
    else if (dm_state == 4)
    {
	if (acceleratestage)
	{
	    S_StartSound(0, sfx_slop);

	    if ( gamemode == commercial)
		WI_initNoState();
	    else
		WI_initShowNextLoc();
	}
    }
    else if (dm_state & 1)
    {
	if (!--cnt_pause)
	{
	    dm_state++;
	    cnt_pause = TICRATE;
	}
    }
}



static 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(INTER_ORGX + DM_TOTALSX-SHORT(total->width)/2,
		INTER_ORGY + DM_MATRIXY-WI_SPACINGY+10,
		FB,
		total);

    V_DrawPatch(INTER_ORGX + DM_KILLERSX, INTER_ORGY + DM_KILLERSY, FB, killers);
    V_DrawPatch(INTER_ORGX + DM_VICTIMSX, INTER_ORGY + DM_VICTIMSY, FB, victims);

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

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	if (playeringame[i])
	{
	    V_DrawPatch(INTER_ORGX + x-SHORT(p[i]->width)/2,
			INTER_ORGY + DM_MATRIXY - WI_SPACINGY,
			FB,
			p[i]);

	    V_DrawPatch(INTER_ORGX + DM_MATRIXX-SHORT(p[i]->width)/2,
			INTER_ORGY + y,
			FB,
			p[i]);

	    if (i == me)
	    {
		V_DrawPatch(INTER_ORGX + x - SHORT(p[i]->width)/2,
			    INTER_ORGY + DM_MATRIXY - WI_SPACINGY,
			    FB,
			    bstar);

		V_DrawPatch(INTER_ORGX + DM_MATRIXX - SHORT(p[i]->width)/2,
			    INTER_ORGY + y,
			    FB,
			    star);
	    }
	}
	else
	{
	    /* V_DrawPatch(INTER_ORGX+x-SHORT(bp[i]->width)/2,*/
	    /*   INTER_ORGY+DM_MATRIXY - WI_SPACINGY, FB, bp[i]);*/
	    /* V_DrawPatch(INTER_ORGX+DM_MATRIXX-SHORT(bp[i]->width)/2,*/
	    /*   INTER_ORGY+y, FB, bp[i]);*/
	}
	x += DM_SPACINGX;
	y += WI_SPACINGY;
    }

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

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

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

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

static int	cnt_frags[MAXPLAYERS];
static int	dofrags = 0;
static int	ng_state = 0;

static void WI_initNetgameStats(void)
{

    int i;

    state = StatCount;
    acceleratestage = 0;
    ng_state = 1;

    cnt_pause = TICRATE;

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

	cnt_kills[i] = cnt_items[i] = cnt_secret[i] = cnt_frags[i] = 0;

	dofrags += WI_fragSum(i);
    }

    dofrags = !!dofrags;

    WI_initAnimatedBack();
}



static void WI_updateNetgameStats(void)
{

    int		i;
    int		fsum;

    boolean	stillticking;

    WI_updateAnimatedBack();

    if (acceleratestage && ng_state != 10)
    {
	acceleratestage = 0;

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

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

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

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

	stillticking = false;

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

	    cnt_kills[i] += 2;

	    if (cnt_kills[i] >= (plrs[i].skills * 100) / wbs->maxkills)
		cnt_kills[i] = (plrs[i].skills * 100) / wbs->maxkills;
	    else
		stillticking = true;
	}

	if (!stillticking)
	{
	    S_StartSound(0, sfx_barexp);
	    ng_state++;
	}
    }
    else if (ng_state == 4)
    {
	if (!(bcnt&3))
	    S_StartSound(0, sfx_pistol);

	stillticking = false;

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

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

	stillticking = false;

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

	    cnt_secret[i] += 2;

	    if (cnt_secret[i] >= (plrs[i].ssecret * 100) / wbs->maxsecret)
		cnt_secret[i] = (plrs[i].ssecret * 100) / wbs->maxsecret;
	    else
		stillticking = true;
	}

	if (!stillticking)
	{
	    S_StartSound(0, sfx_barexp);
	    ng_state += 1 + 2*!dofrags;
	}
    }
    else if (ng_state == 8)
    {
	if (!(bcnt&3))
	    S_StartSound(0, sfx_pistol);

	stillticking = false;

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

	    cnt_frags[i] += 1;

	    if (cnt_frags[i] >= (fsum = WI_fragSum(i)))
		cnt_frags[i] = fsum;
	    else
		stillticking = true;
	}

	if (!stillticking)
	{
	    S_StartSound(0, sfx_pldeth);
	    ng_state++;
	}
    }
    else if (ng_state == 10)
    {
	if (acceleratestage)
	{
	    S_StartSound(0, sfx_sgcock);
	    if ( gamemode == commercial )
		WI_initNoState();
	    else
		WI_initShowNextLoc();
	}
    }
    else if (ng_state & 1)
    {
	if (!--cnt_pause)
	{
	    ng_state++;
	    cnt_pause = TICRATE;
	}
    }
}



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

    WI_slamBackground();

    /* draw animated background*/
    WI_drawAnimatedBack();

    WI_drawLF();

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

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

    V_DrawPatch(INTER_ORGX+NG_STATSX+3*NG_SPACINGX-SHORT(secret->width),
		INTER_ORGY+NG_STATSY, FB, secret);

    if (dofrags)
	V_DrawPatch(INTER_ORGX+NG_STATSX+4*NG_SPACINGX-SHORT(frags->width),
		    INTER_ORGY+NG_STATSY, FB, frags);

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

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

	x = NG_STATSX;
	V_DrawPatch(INTER_ORGX+x-SHORT(p[i]->width), INTER_ORGY+y, FB, p[i]);

	if (i == me)
	    V_DrawPatch(INTER_ORGX+x-SHORT(p[i]->width), INTER_ORGY+y, FB, star);

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

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

	y += WI_SPACINGY;
    }

}

static int	sp_state;

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

    WI_initAnimatedBack();
}

static void WI_updateStats(void)
{

    WI_updateAnimatedBack();

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

    if (sp_state == 2)
    {
	cnt_kills[0] += 2;

	if (!(bcnt&3))
	    S_StartSound(0, sfx_pistol);

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

	if (!(bcnt&3))
	    S_StartSound(0, sfx_pistol);

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

	if (!(bcnt&3))
	    S_StartSound(0, sfx_pistol);

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

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

	cnt_time += 3;

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

	cnt_par += 3;

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

	    if (cnt_time >= plrs[me].stime / TICRATE)
	    {
		S_StartSound(0, sfx_barexp);
		sp_state++;
	    }
	}
    }
    else if (sp_state == 10)
    {
	if (acceleratestage)
	{
	    S_StartSound(0, sfx_sgcock);

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

}

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

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

    WI_slamBackground();

    /* draw animated background*/
    WI_drawAnimatedBack();

    WI_drawLF();

    V_DrawPatch(INTER_ORGX+SP_STATSX, INTER_ORGY+SP_STATSY, FB, kills);
    WI_drawPercent(INTERWIDTH - SP_STATSX, SP_STATSY, cnt_kills[0]);

    V_DrawPatch(INTER_ORGX+SP_STATSX, INTER_ORGY+SP_STATSY+lh, FB, items);
    WI_drawPercent(INTERWIDTH - SP_STATSX, SP_STATSY+lh, cnt_items[0]);

    V_DrawPatch(INTER_ORGX+SP_STATSX, INTER_ORGY+SP_STATSY+2*lh, FB, sp_secret);
    WI_drawPercent(INTERWIDTH - SP_STATSX, SP_STATSY+2*lh, cnt_secret[0]);

    V_DrawPatch(INTER_ORGX+SP_TIMEX, INTER_ORGY+SP_TIMEY, FB, time);
    WI_drawTime(INTERWIDTH/2 - SP_TIMEX, SP_TIMEY, cnt_time);

    if (wbs->epsd < 3)
    {
	V_DrawPatch(INTER_ORGX + INTERWIDTH/2 + SP_TIMEX, INTER_ORGY + SP_TIMEY, FB, par);
	WI_drawTime(INTERWIDTH - SP_TIMEX, SP_TIMEY, cnt_par);
    }

}

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

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



/* Updates stuff each tick*/
void WI_Ticker(void)
{
    /* counter for general background animation*/
    bcnt++;

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

    WI_checkForAccelerate();

    switch (state)
    {
      case StatCount:
	if (deathmatch) WI_updateDeathmatchStats();
	else if (netgame) WI_updateNetgameStats();
	else WI_updateStats();
	break;

      case ShowNextLoc:
	WI_updateShowNextLoc();
	break;

      case NoState:
	WI_updateNoState();
	break;
    }

}

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

    if (gamemode == commercial)
	strcpy(name, wistuff_lumps[WILUMP_INTERPIC]);
    else
	sprintf(name, "WIMAP%d", wbs->epsd);

    if ( gamemode == retail )
    {
      if (wbs->epsd == 3)
	strcpy(name,wistuff_lumps[WILUMP_INTERPIC]);
    }

    /* background*/
    bg = W_CacheLumpName(name, PU_CACHE);
    V_DrawPatch(INTER_ORGX, INTER_ORGY, 1, bg);


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

    if (lnames != NULL) Z_Free(lnames);

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

	/* you are here*/
	yah[0] = W_CacheLumpName(wistuff_lumps[WILUMP_WIURH0], PU_STATIC);

	/* you are here (alt.)*/
	yah[1] = W_CacheLumpName(wistuff_lumps[WILUMP_WIURH1], PU_STATIC);

	/* splat*/
	splat = W_CacheLumpName(wistuff_lumps[WILUMP_WISPLAT], PU_STATIC);

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

    /* More hacks on minus sign.*/
    wiminus = W_CacheLumpName(wistuff_lumps[WILUMP_WIMINUS], PU_STATIC);

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

    /* percent sign*/
    percent = W_CacheLumpName(wistuff_lumps[WILUMP_WIPCNT], PU_STATIC);

    /* "finished"*/
    finished = W_CacheLumpName(wistuff_lumps[WILUMP_WIF], PU_STATIC);

    /* "entering"*/
    entering = W_CacheLumpName(wistuff_lumps[WILUMP_WIENTER], PU_STATIC);

    /* "kills"*/
    kills = W_CacheLumpName(wistuff_lumps[WILUMP_WIOSTK], PU_STATIC);

    /* "scrt"*/
    secret = W_CacheLumpName(wistuff_lumps[WILUMP_WIOSTS], PU_STATIC);

     /* "secret"*/
    sp_secret = W_CacheLumpName(wistuff_lumps[WILUMP_WISCRT2], PU_STATIC);

    /* Yuck. */
    if (language==french)
    {
	/* "items"*/
	if (netgame && !deathmatch)
	    items = W_CacheLumpName(wistuff_lumps[WILUMP_WIOBJ], PU_STATIC);
  	else
	    items = W_CacheLumpName(wistuff_lumps[WILUMP_WIOSTI], PU_STATIC);
    } else
	items = W_CacheLumpName(wistuff_lumps[WILUMP_WIOSTI], PU_STATIC);

    /* "frgs"*/
    frags = W_CacheLumpName(wistuff_lumps[WILUMP_WIFRGS], PU_STATIC);

    /* ":"*/
    colon = W_CacheLumpName(wistuff_lumps[WILUMP_WICOLON], PU_STATIC);

    /* "time"*/
    time = W_CacheLumpName(wistuff_lumps[WILUMP_WITIME], PU_STATIC);

    /* "sucks"*/
    sucks = W_CacheLumpName(wistuff_lumps[WILUMP_WISUCKS], PU_STATIC);

    /* "par"*/
    par = W_CacheLumpName(wistuff_lumps[WILUMP_WIPAR], PU_STATIC);

    /* "killers" (vertical)*/
    killers = W_CacheLumpName(wistuff_lumps[WILUMP_WIKILRS], PU_STATIC);

    /* "victims" (horiz)*/
    victims = W_CacheLumpName(wistuff_lumps[WILUMP_WIVCTMS], PU_STATIC);

    /* "total"*/
    total = W_CacheLumpName(wistuff_lumps[WILUMP_WIMSTT], PU_STATIC);

    /* your face*/
    star = W_CacheLumpName(wistuff_lumps[WILUMP_STFST01], PU_STATIC);

    /* dead face*/
    bstar = W_CacheLumpName(wistuff_lumps[WILUMP_STFDEAD0], PU_STATIC);

    for (i=0 ; i<MAXPLAYERS ; i++)
    {
	/* "1,2,3,4"*/
	sprintf(name, "STPB%d", i);
	p[i] = W_CacheLumpName(name, PU_STATIC);

	/* "1,2,3,4"*/
	sprintf(name, "WIBP%d", i+1);
	bp[i] = W_CacheLumpName(name, PU_STATIC);
    }

}

static void WI_unloadData(void)
{
    int		i;
    int		j;

    Z_ChangeTag(wiminus, PU_CACHE);

    for (i=0 ; i<10 ; i++)
	Z_ChangeTag(num[i], PU_CACHE);

    if (gamemode == commercial)
    {
  	for (i=0 ; i<NUMCMAPS ; i++)
	    Z_ChangeTag(lnames[i], PU_CACHE);
    }
    else
    {
	Z_ChangeTag(yah[0], PU_CACHE);
	Z_ChangeTag(yah[1], PU_CACHE);

	Z_ChangeTag(splat, PU_CACHE);

	for (i=0 ; i<NUMMAPS ; i++)
	    Z_ChangeTag(lnames[i], PU_CACHE);

	if (wbs->epsd < 3)
	{
	    for (j=0;j<NUMANIMS[wbs->epsd];j++)
	    {
		if (wbs->epsd != 1 || j != 8)
		    for (i=0;i<anims[wbs->epsd][j].nanims;i++)
			Z_ChangeTag(anims[wbs->epsd][j].p[i], PU_CACHE);
	    }
	}
    }

    /* This lump is now freed in WI_loadData before a new one is allocated */
    /*Z_Free(lnames);*/

    Z_ChangeTag(percent, PU_CACHE);
    Z_ChangeTag(colon, PU_CACHE);
    Z_ChangeTag(finished, PU_CACHE);
    Z_ChangeTag(entering, PU_CACHE);
    Z_ChangeTag(kills, PU_CACHE);
    Z_ChangeTag(secret, PU_CACHE);
    Z_ChangeTag(sp_secret, PU_CACHE);
    Z_ChangeTag(items, PU_CACHE);
    Z_ChangeTag(frags, PU_CACHE);
    Z_ChangeTag(time, PU_CACHE);
    Z_ChangeTag(sucks, PU_CACHE);
    Z_ChangeTag(par, PU_CACHE);

    Z_ChangeTag(victims, PU_CACHE);
    Z_ChangeTag(killers, PU_CACHE);
    Z_ChangeTag(total, PU_CACHE);
    /*  Z_ChangeTag(star, PU_CACHE);*/
    /*  Z_ChangeTag(bstar, PU_CACHE);*/

    for (i=0 ; i<MAXPLAYERS ; i++)
	Z_ChangeTag(p[i], PU_CACHE);

    for (i=0 ; i<MAXPLAYERS ; i++)
	Z_ChangeTag(bp[i], PU_CACHE);
}

void WI_Drawer (void)
{
    switch (state)
    {
      case StatCount:
	if (deathmatch)
	    WI_drawDeathmatchStats();
	else if (netgame)
	    WI_drawNetgameStats();
	else
	    WI_drawStats();
	break;

      case ShowNextLoc:
	WI_drawShowNextLoc();
	break;

      case NoState:
	WI_drawNoState();
	break;
    }
}


static void WI_initVariables(wbstartstruct_t* wbstartstruct)
{

    wbs = wbstartstruct;

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

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

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

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

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

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

void WI_Start(wbstartstruct_t* wbstartstruct)
{

    WI_initVariables(wbstartstruct);
    WI_loadData();

    if (deathmatch)
	WI_initDeathmatchStats();
    else if (netgame)
	WI_initNetgameStats();
    else
	WI_initStats();
}



#ifndef STATIC_RESOLUTION
void WI_initForResolution(void)
{
  INTER_ORGX = (SCREENWIDTH - INTERWIDTH) >> 1;
  INTER_ORGY = (SCREENHEIGHT - INTERHEIGHT) >> 1;
}
#endif
