2006-03-28 15:44:01 +00:00
|
|
|
/* Emacs style mode select -*- C++ -*-
|
|
|
|
|
*-----------------------------------------------------------------------------
|
|
|
|
|
*
|
|
|
|
|
*
|
|
|
|
|
* PrBoom a Doom port merged with LxDoom and LSDLDoom
|
|
|
|
|
* based on BOOM, a modified and improved DOOM engine
|
|
|
|
|
* Copyright (C) 1999 by
|
|
|
|
|
* id Software, Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman
|
|
|
|
|
* Copyright (C) 1999-2000 by
|
|
|
|
|
* Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
|
|
|
|
* 02111-1307, USA.
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION:
|
|
|
|
|
* Intermission screens.
|
|
|
|
|
*
|
|
|
|
|
*-----------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "doomstat.h"
|
|
|
|
|
#include "m_random.h"
|
|
|
|
|
#include "w_wad.h"
|
|
|
|
|
#include "g_game.h"
|
|
|
|
|
#include "r_main.h"
|
|
|
|
|
#include "v_video.h"
|
|
|
|
|
#include "wi_stuff.h"
|
|
|
|
|
#include "s_sound.h"
|
|
|
|
|
#include "sounds.h"
|
|
|
|
|
#include "m_swap.h"
|
|
|
|
|
#include "r_draw.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
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Not used
|
|
|
|
|
// 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
|
|
|
|
|
#define WI_TITLEY 2
|
|
|
|
|
#define WI_SPACINGY 33
|
|
|
|
|
|
|
|
|
|
// SINGLE-PLAYER STUFF
|
|
|
|
|
#define SP_STATSX 50
|
|
|
|
|
#define SP_STATSY 50
|
|
|
|
|
|
|
|
|
|
#define SP_TIMEX 8
|
|
|
|
|
// proff/nicolas 09/20/98 -- changed for hi-res
|
|
|
|
|
#define SP_TIMEY 160
|
|
|
|
|
//#define SP_TIMEY (SCREENHEIGHT-32)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// NET GAME STUFF
|
|
|
|
|
#define NG_STATSY 50
|
|
|
|
|
#define NG_STATSX (32 + V_NamePatchWidth(star)/2 + 32*!dofrags)
|
|
|
|
|
|
|
|
|
|
#define NG_SPACINGX 64
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Used to display the frags matrix at endgame
|
|
|
|
|
// 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
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// These animation variables, structures, etc. are used for the
|
|
|
|
|
// DOOM/Ultimate DOOM intermission screen animations. This is
|
|
|
|
|
// totally different from any sprite or texture/flat animations
|
2010-05-29 08:12:39 +00:00
|
|
|
enum
|
2006-03-28 15:44:01 +00:00
|
|
|
{
|
|
|
|
|
ANIM_ALWAYS, // determined by patch entry
|
|
|
|
|
ANIM_RANDOM, // occasional
|
|
|
|
|
ANIM_LEVEL // continuous
|
2010-05-29 08:12:39 +00:00
|
|
|
};
|
|
|
|
|
typedef unsigned animenum_t;
|
2006-03-28 15:44:01 +00:00
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
|
{
|
|
|
|
|
int x; // x/y coordinate pair structure
|
|
|
|
|
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
|
|
|
|
|
* cphipps - const
|
|
|
|
|
*/
|
|
|
|
|
const 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 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 184, 160 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 112, 136 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 72, 112 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 88, 96 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 64, 48 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 192, 40 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 136, 16 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 80, 16 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 64, 24 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static anim_t epsd1animinfo[] =
|
|
|
|
|
{
|
|
|
|
|
{ ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 1, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 2, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 3, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 4, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 5, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 6, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 7, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_LEVEL, TICRATE/3, 3, { 192, 144 }, 8, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 8, 0, { 0, 0, 0 }, 0, 0, 0, 0 }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static anim_t epsd2animinfo[] =
|
|
|
|
|
{
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 104, 168 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 40, 136 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 160, 96 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 104, 80 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/3, 3, { 120, 32 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 0 },
|
|
|
|
|
{ ANIM_ALWAYS, TICRATE/4, 3, { 40, 0 }, 0, 0, { 0, 0, 0 }, 0, 0, 0, 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
|
|
|
|
|
int acceleratestage; // killough 3/28/98: made global
|
|
|
|
|
|
|
|
|
|
// wbs->pnum
|
|
|
|
|
static int me;
|
|
|
|
|
|
|
|
|
|
// specifies current state
|
|
|
|
|
static stateenum_t state;
|
|
|
|
|
|
|
|
|
|
// contains information passed into intermission
|
|
|
|
|
static wbstartstruct_t* wbs;
|
|
|
|
|
|
|
|
|
|
static wbplayerstruct_t* plrs; // 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_time;
|
|
|
|
|
static int cnt_total_time;
|
|
|
|
|
static int cnt_par;
|
|
|
|
|
static int cnt_pause;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
|
// GRAPHICS
|
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
// You Are Here graphic
|
|
|
|
|
static const char* yah[2] = { "WIURH0", "WIURH1" };
|
|
|
|
|
|
|
|
|
|
// splat
|
|
|
|
|
static const char* splat = "WISPLAT";
|
|
|
|
|
|
|
|
|
|
// %, : graphics
|
|
|
|
|
static const char percent[] = {"WIPCNT"};
|
|
|
|
|
static const char colon[] = {"WICOLON"};
|
|
|
|
|
|
|
|
|
|
// 0-9 graphic
|
|
|
|
|
static const patch_t * num[10];
|
|
|
|
|
|
|
|
|
|
// minus sign
|
|
|
|
|
static const char wiminus[] = {"WIMINUS"};
|
|
|
|
|
|
|
|
|
|
// "Finished!" graphics
|
|
|
|
|
static const char finished[] = {"WIF"};
|
|
|
|
|
|
|
|
|
|
// "Entering" graphic
|
|
|
|
|
static const char entering[] = {"WIENTER"};
|
|
|
|
|
|
|
|
|
|
// "secret"
|
|
|
|
|
static const char sp_secret[] = {"WISCRT2"};
|
|
|
|
|
|
|
|
|
|
// "Kills", "Scrt", "Items", "Frags"
|
|
|
|
|
static const char kills[] = {"WIOSTK"};
|
|
|
|
|
static const char secret[] = {"WIOSTS"};
|
|
|
|
|
static const char items[] = {"WIOSTI"};
|
|
|
|
|
static const char frags[] = {"WIFRGS"};
|
|
|
|
|
|
|
|
|
|
// Time sucks.
|
|
|
|
|
static const char time1[] = {"WITIME"};
|
|
|
|
|
static const char par[] = {"WIPAR"};
|
|
|
|
|
static const char sucks[] = {"WISUCKS"};
|
|
|
|
|
|
|
|
|
|
// "killers", "victims"
|
|
|
|
|
static const char killers[] = {"WIKILRS"};
|
|
|
|
|
static const char victims[] = {"WIVCTMS"};
|
|
|
|
|
|
|
|
|
|
// "Total", your face, your dead face
|
|
|
|
|
static const char total[] = {"WIMSTT"};
|
|
|
|
|
static const char star[] = {"STFST01"};
|
|
|
|
|
static const char bstar[] = {"STFDEAD0"};
|
|
|
|
|
|
|
|
|
|
// "red P[1..MAXPLAYERS]"
|
|
|
|
|
static const char facebackp[] = {"STPB0"};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
|
// CODE
|
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
static void WI_endDeathmatchStats(void);
|
|
|
|
|
static void WI_endNetgameStats(void);
|
|
|
|
|
void WI_unloadData(void);
|
|
|
|
|
#define WI_endStats WI_endNetgameStats
|
|
|
|
|
|
|
|
|
|
/* ====================================================================
|
|
|
|
|
* WI_levelNameLump
|
|
|
|
|
* Purpore: Returns the name of the graphic lump containing the name of
|
|
|
|
|
* the given level.
|
|
|
|
|
* Args: Episode and level, and buffer (must by 9 chars) to write to
|
|
|
|
|
* Returns: void
|
|
|
|
|
*/
|
|
|
|
|
void WI_levelNameLump(int epis, int map, char* buf, int bsize)
|
|
|
|
|
{
|
|
|
|
|
if (gamemode == commercial) {
|
|
|
|
|
snprintf(buf, bsize,"CWILV%s%d",(map/10>0?"":"0"), map); //ANOTHER ROCKHACK "CWILV%2.2d"
|
|
|
|
|
//snprintf(buf,bsize, "CWILV%2.2d", map);
|
|
|
|
|
} else {
|
|
|
|
|
snprintf(buf,bsize, "WILV%d%d", epis, map);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_slamBackground
|
|
|
|
|
// Purpose: Put the full-screen background up prior to patches
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
static void WI_slamBackground(void)
|
|
|
|
|
{
|
|
|
|
|
char name[9]; // limited to 8 characters
|
|
|
|
|
|
|
|
|
|
if (gamemode == commercial || (gamemode == retail && wbs->epsd == 3))
|
|
|
|
|
strcpy(name, "INTERPIC");
|
|
|
|
|
else
|
|
|
|
|
snprintf(name, sizeof(name), "WIMAP%d", wbs->epsd);
|
|
|
|
|
|
|
|
|
|
// background
|
|
|
|
|
V_DrawNamePatch(0, 0, FB, name, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_Responder
|
|
|
|
|
// Purpose: Draw animations on intermission background screen
|
|
|
|
|
// Args: ev -- event pointer, not actually used here.
|
|
|
|
|
// Returns: False -- dummy routine
|
|
|
|
|
//
|
|
|
|
|
// The ticker is used to detect keys
|
|
|
|
|
// because of timing issues in netgames.
|
|
|
|
|
boolean WI_Responder(event_t* ev)
|
|
|
|
|
{
|
|
|
|
|
(void)ev;
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_drawLF
|
|
|
|
|
// Purpose: Draw the "Finished" level name before showing stats
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_drawLF(void)
|
|
|
|
|
{
|
|
|
|
|
int y = WI_TITLEY;
|
|
|
|
|
char lname[9];
|
|
|
|
|
|
|
|
|
|
// draw <LevelName>
|
|
|
|
|
/* cph - get the graphic lump name and use it */
|
|
|
|
|
WI_levelNameLump(wbs->epsd, wbs->last, lname, sizeof(lname));
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
V_DrawNamePatch((320 - V_NamePatchWidth(lname))/2, y,
|
|
|
|
|
FB, lname, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
|
|
|
|
|
// draw "Finished!"
|
|
|
|
|
y += (5*V_NamePatchHeight(lname))/4;
|
|
|
|
|
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
V_DrawNamePatch((320 - V_NamePatchWidth(finished))/2, y,
|
|
|
|
|
FB, finished, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_drawEL
|
|
|
|
|
// Purpose: Draw introductory "Entering" and level name
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_drawEL(void)
|
|
|
|
|
{
|
|
|
|
|
int y = WI_TITLEY;
|
|
|
|
|
char lname[9];
|
|
|
|
|
|
|
|
|
|
/* cph - get the graphic lump name */
|
|
|
|
|
WI_levelNameLump(wbs->epsd, wbs->next, lname, sizeof(lname));
|
|
|
|
|
|
|
|
|
|
// draw "Entering"
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
V_DrawNamePatch((320 - V_NamePatchWidth(entering))/2,
|
|
|
|
|
y, FB, entering, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
|
|
|
|
|
// draw level
|
|
|
|
|
y += (5*V_NamePatchHeight(lname))/4;
|
|
|
|
|
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
V_DrawNamePatch((320 - V_NamePatchWidth(lname))/2, y, FB,
|
|
|
|
|
lname, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* ====================================================================
|
|
|
|
|
* WI_drawOnLnode
|
|
|
|
|
* Purpose: Draw patches at a location based on episode/map
|
|
|
|
|
* Args: n -- index to map# within episode
|
|
|
|
|
* c[] -- array of names of patches to be drawn
|
|
|
|
|
* Returns: void
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
WI_drawOnLnode // draw stuff at a location by episode/map#
|
|
|
|
|
( int n,
|
|
|
|
|
const char* const c[] )
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
boolean fits = false;
|
|
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
int left;
|
|
|
|
|
int top;
|
|
|
|
|
int right;
|
|
|
|
|
int bottom;
|
|
|
|
|
int lump = W_GetNumForName(c[i]);
|
|
|
|
|
const patch_t* p = W_CacheLumpNum(lump);
|
|
|
|
|
|
|
|
|
|
left = lnodes[wbs->epsd][n].x - SHORT(p->leftoffset);
|
|
|
|
|
top = lnodes[wbs->epsd][n].y - SHORT(p->topoffset);
|
|
|
|
|
right = left + SHORT(p->width);
|
|
|
|
|
bottom = top + SHORT(p->height);
|
|
|
|
|
W_UnlockLumpNum(lump);
|
|
|
|
|
|
|
|
|
|
if (left >= 0
|
|
|
|
|
&& right < 320
|
|
|
|
|
&& top >= 0
|
|
|
|
|
&& bottom < 200)
|
|
|
|
|
{
|
|
|
|
|
fits = true;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
i++;
|
|
|
|
|
}
|
|
|
|
|
} while (!fits && i!=2);
|
|
|
|
|
|
|
|
|
|
if (fits && i<2)
|
|
|
|
|
{
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
V_DrawNamePatch(lnodes[wbs->epsd][n].x, lnodes[wbs->epsd][n].y,
|
|
|
|
|
FB, c[i], CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// DEBUG
|
|
|
|
|
//jff 8/3/98 use logical output routine
|
|
|
|
|
printf("Could not place patch on level %d", n+1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_initAnimatedBack
|
|
|
|
|
// Purpose: Initialize pointers and styles for background animation
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_initAnimatedBack(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
anim_t* a;
|
|
|
|
|
|
|
|
|
|
if (gamemode == commercial) // no animation for DOOM2
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_updateAnimatedBack
|
|
|
|
|
// Purpose: Figure out what animation we do on this iteration
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_drawAnimatedBack
|
|
|
|
|
// Purpose: Actually do the animation (whew!)
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_drawAnimatedBack(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
anim_t* a;
|
|
|
|
|
|
|
|
|
|
if (gamemode==commercial) //jff 4/25/98 Someone forgot commercial an enum
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (wbs->epsd > 2)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
for (i=0 ; i<NUMANIMS[wbs->epsd] ; i++)
|
|
|
|
|
{
|
|
|
|
|
a = &anims[wbs->epsd][i];
|
|
|
|
|
|
|
|
|
|
if (a->ctr >= 0)
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
V_DrawMemPatch(a->loc.x, a->loc.y, FB, a->p[a->ctr], CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_drawNum
|
|
|
|
|
// Purpose: Draws a number. If digits > 0, then use that many digits
|
|
|
|
|
// minimum, otherwise only use as many as necessary
|
|
|
|
|
// Args: x, y -- location
|
|
|
|
|
// n -- the number to be drawn
|
|
|
|
|
// digits -- number of digits minimum or zero
|
|
|
|
|
// Returns: new x position after drawing (note we are going to the left)
|
|
|
|
|
// CPhipps - static
|
|
|
|
|
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;
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
V_DrawMemPatch(x, y, FB, num[ n % 10 ], CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
n /= 10;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// draw a minus sign if necessary
|
|
|
|
|
if (neg)
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
V_DrawNamePatch(x-=8, y, FB, wiminus, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
|
|
|
|
|
return x;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_drawPercent
|
|
|
|
|
// Purpose: Draws a percentage, really just a call to WI_drawNum
|
|
|
|
|
// after putting a percent sign out there
|
|
|
|
|
// Args: x, y -- location
|
|
|
|
|
// p -- the percentage value to be drawn, no negatives
|
|
|
|
|
// Returns: void
|
|
|
|
|
// CPhipps - static
|
|
|
|
|
static void WI_drawPercent(int x, int y, int p)
|
|
|
|
|
{
|
|
|
|
|
if (p < 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
V_DrawNamePatch(x, y, FB, percent, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
WI_drawNum(x, y, p, -1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_drawTime
|
|
|
|
|
// Purpose: Draws the level completion time or par time, or "Sucks"
|
|
|
|
|
// if 1 hour or more
|
|
|
|
|
// Args: x, y -- location
|
|
|
|
|
// t -- the time value to be drawn
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
// CPhipps - static
|
|
|
|
|
// - largely rewritten to display hours and use slightly better algorithm
|
|
|
|
|
|
|
|
|
|
static void WI_drawTime(int x, int y, int t)
|
|
|
|
|
{
|
|
|
|
|
int n;
|
|
|
|
|
|
|
|
|
|
if (t<0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (t < 100*60*60)
|
|
|
|
|
for(;;) {
|
|
|
|
|
n = t % 60;
|
|
|
|
|
t /= 60;
|
|
|
|
|
x = WI_drawNum(x, y, n, (t || n>9) ? 2 : 1) - V_NamePatchWidth(colon);
|
|
|
|
|
|
|
|
|
|
// draw
|
|
|
|
|
if (t)
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
V_DrawNamePatch(x, y, FB, colon, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
else break;
|
|
|
|
|
}
|
|
|
|
|
else // "sucks" (maybe should be "addicted", even I've never had a 100 hour game ;)
|
|
|
|
|
V_DrawNamePatch(x - V_NamePatchWidth(sucks),
|
|
|
|
|
y, FB, sucks, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_End
|
|
|
|
|
// Purpose: Unloads data structures (inverse of WI_Start)
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_End(void)
|
|
|
|
|
{
|
|
|
|
|
WI_unloadData();
|
|
|
|
|
|
|
|
|
|
if (deathmatch)
|
|
|
|
|
WI_endDeathmatchStats();
|
|
|
|
|
else if (netgame)
|
|
|
|
|
WI_endNetgameStats();
|
|
|
|
|
else
|
|
|
|
|
WI_endStats();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_initNoState
|
|
|
|
|
// Purpose: Clear state, ready for end of level activity
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_initNoState(void)
|
|
|
|
|
{
|
|
|
|
|
state = NoState;
|
|
|
|
|
acceleratestage = 0;
|
|
|
|
|
cnt = 10;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_drawTimeStats
|
|
|
|
|
// Purpose: Put the times on the screen
|
|
|
|
|
// Args: time, total time, par time, in seconds
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
// cph - pulled from WI_drawStats below
|
|
|
|
|
|
|
|
|
|
static void WI_drawTimeStats(int cnt_time, int cnt_total_time, int cnt_par)
|
|
|
|
|
{
|
|
|
|
|
V_DrawNamePatch(SP_TIMEX, SP_TIMEY, FB, time1, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
WI_drawTime(320/2 - SP_TIMEX, SP_TIMEY, cnt_time);
|
|
|
|
|
|
|
|
|
|
V_DrawNamePatch(SP_TIMEX, (SP_TIMEY+200)/2, FB, total, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
WI_drawTime(320/2 - SP_TIMEX, (SP_TIMEY+200)/2, cnt_total_time);
|
|
|
|
|
|
|
|
|
|
// Ty 04/11/98: redid logic: should skip only if with pwad but
|
|
|
|
|
// without deh patch
|
|
|
|
|
// killough 2/22/98: skip drawing par times on pwads
|
|
|
|
|
// Ty 03/17/98: unless pars changed with deh patch
|
|
|
|
|
|
|
|
|
|
if (!(modifiedgame)) //&& !deh_pars))
|
|
|
|
|
{
|
|
|
|
|
if (wbs->epsd < 3)
|
|
|
|
|
{
|
|
|
|
|
V_DrawNamePatch(320/2 + SP_TIMEX, SP_TIMEY, FB, par, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
WI_drawTime(320 - SP_TIMEX, SP_TIMEY, cnt_par);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_updateNoState
|
|
|
|
|
// Purpose: Cycle until end of level activity is done
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_updateNoState(void)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
WI_updateAnimatedBack();
|
|
|
|
|
|
|
|
|
|
if (!--cnt)
|
|
|
|
|
G_WorldDone();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static boolean snl_pointeron = false;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_initShowNextLoc
|
|
|
|
|
// Purpose: Prepare to show the next level's location
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_initShowNextLoc(void)
|
|
|
|
|
{
|
|
|
|
|
if ((gamemode != commercial) && (gamemap == 8)) {
|
|
|
|
|
G_WorldDone();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
state = ShowNextLoc;
|
|
|
|
|
acceleratestage = 0;
|
|
|
|
|
cnt = SHOWNEXTLOCDELAY * TICRATE;
|
|
|
|
|
|
|
|
|
|
WI_initAnimatedBack();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_updateShowNextLoc
|
|
|
|
|
// Purpose: Prepare to show the next level's location
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_updateShowNextLoc(void)
|
|
|
|
|
{
|
|
|
|
|
WI_updateAnimatedBack();
|
|
|
|
|
|
|
|
|
|
if (!--cnt || acceleratestage)
|
|
|
|
|
WI_initNoState();
|
|
|
|
|
else
|
|
|
|
|
snl_pointeron = (cnt & 31) < 20;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_drawShowNextLoc
|
|
|
|
|
// Purpose: Show the next level's location on animated backgrounds
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_drawShowNextLoc(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
int last;
|
|
|
|
|
|
|
|
|
|
WI_slamBackground();
|
|
|
|
|
|
|
|
|
|
// draw animated background
|
|
|
|
|
WI_drawAnimatedBack();
|
|
|
|
|
|
|
|
|
|
if ( gamemode != commercial)
|
|
|
|
|
{
|
|
|
|
|
if (wbs->epsd > 2)
|
|
|
|
|
{
|
|
|
|
|
WI_drawEL(); // "Entering..." if not E1 or E2
|
|
|
|
|
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, &splat);
|
|
|
|
|
|
|
|
|
|
// splat the secret level?
|
|
|
|
|
if (wbs->didsecret)
|
|
|
|
|
WI_drawOnLnode(8, &splat);
|
|
|
|
|
|
|
|
|
|
// draw flashing ptr
|
|
|
|
|
if (snl_pointeron)
|
|
|
|
|
WI_drawOnLnode(wbs->next, yah);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// draws which level you are entering..
|
|
|
|
|
if ( (gamemode != commercial)
|
|
|
|
|
|| wbs->next != 30) // check for MAP30 end game
|
|
|
|
|
WI_drawEL();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_drawNoState
|
|
|
|
|
// Purpose: Draw the pointer and next location
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_drawNoState(void)
|
|
|
|
|
{
|
|
|
|
|
snl_pointeron = true;
|
|
|
|
|
WI_drawShowNextLoc();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_fragSum
|
|
|
|
|
// Purpose: Calculate frags for this player based on the current totals
|
|
|
|
|
// of all the other players. Subtract self-frags.
|
|
|
|
|
// Args: playernum -- the player to be calculated
|
|
|
|
|
// Returns: the total frags for this player
|
|
|
|
|
//
|
|
|
|
|
int WI_fragSum(int playernum)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
int frags = 0;
|
|
|
|
|
|
|
|
|
|
for (i=0 ; i<MAXPLAYERS ; i++)
|
|
|
|
|
{
|
|
|
|
|
if (playeringame[i] // is this player playing?
|
|
|
|
|
&& i!=playernum) // and it's not the player we're calculating
|
|
|
|
|
{
|
|
|
|
|
frags += plrs[playernum].frags[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// JDC hack - negative frags.
|
|
|
|
|
frags -= plrs[playernum].frags[playernum];
|
|
|
|
|
|
|
|
|
|
return frags;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int dm_state;
|
|
|
|
|
// CPhipps - short, dynamically allocated
|
|
|
|
|
static short int **dm_frags; // frags matrix
|
|
|
|
|
static short int *dm_totals; // totals by player
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_initDeathmatchStats
|
|
|
|
|
// Purpose: Set up to display DM stats at end of level. Calculate
|
|
|
|
|
// frags for all players.
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_initDeathmatchStats(void)
|
|
|
|
|
{
|
|
|
|
|
int i; // looping variables
|
|
|
|
|
|
|
|
|
|
// CPhipps - allocate data structures needed
|
|
|
|
|
dm_frags = calloc(MAXPLAYERS, sizeof(*dm_frags));
|
|
|
|
|
dm_totals = calloc(MAXPLAYERS, sizeof(*dm_totals));
|
|
|
|
|
|
|
|
|
|
state = StatCount; // We're doing stats
|
|
|
|
|
acceleratestage = 0;
|
|
|
|
|
dm_state = 1; // count how many times we've done a complete stat
|
|
|
|
|
|
|
|
|
|
cnt_pause = TICRATE;
|
|
|
|
|
|
|
|
|
|
for (i=0 ; i<MAXPLAYERS ; i++)
|
|
|
|
|
{
|
|
|
|
|
if (playeringame[i])
|
|
|
|
|
{
|
|
|
|
|
// CPhipps - allocate frags line
|
|
|
|
|
dm_frags[i] = calloc(MAXPLAYERS, sizeof(**dm_frags)); // set all counts to zero
|
|
|
|
|
|
|
|
|
|
dm_totals[i] = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
WI_initAnimatedBack();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// CPhipps - WI_endDeathmatchStats
|
|
|
|
|
// Purpose: Deallocate dynamically allocated DM stats data
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
void WI_endDeathmatchStats(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
for (i=0; i<MAXPLAYERS; i++)
|
|
|
|
|
free(dm_frags[i]);
|
|
|
|
|
|
|
|
|
|
free(dm_frags); free(dm_totals);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_updateDeathmatchStats
|
|
|
|
|
// Purpose: Advance Deathmatch stats screen animation. Calculate
|
|
|
|
|
// frags for all players. Lots of noise and drama around
|
|
|
|
|
// the presentation.
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_updateDeathmatchStats(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
int j;
|
|
|
|
|
|
|
|
|
|
boolean stillticking;
|
|
|
|
|
|
|
|
|
|
WI_updateAnimatedBack();
|
|
|
|
|
|
|
|
|
|
if (acceleratestage && dm_state != 4) // still ticking
|
|
|
|
|
{
|
|
|
|
|
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); // bang
|
|
|
|
|
dm_state = 4; // we're done with all 4 (or all we have to do)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (dm_state == 2)
|
|
|
|
|
{
|
|
|
|
|
if (!(bcnt&3))
|
|
|
|
|
S_StartSound(0, sfx_pistol); // noise while counting
|
|
|
|
|
|
|
|
|
|
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] > 999) // Ty 03/17/98 3-digit frag count
|
|
|
|
|
dm_frags[i][j] = 999;
|
|
|
|
|
|
|
|
|
|
if (dm_frags[i][j] < -999)
|
|
|
|
|
dm_frags[i][j] = -999;
|
|
|
|
|
|
|
|
|
|
stillticking = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
dm_totals[i] = WI_fragSum(i);
|
|
|
|
|
|
|
|
|
|
if (dm_totals[i] > 999)
|
|
|
|
|
dm_totals[i] = 999;
|
|
|
|
|
|
|
|
|
|
if (dm_totals[i] < -999)
|
|
|
|
|
dm_totals[i] = -999; // Ty 03/17/98 end 3-digit frag count
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_drawDeathmatchStats
|
|
|
|
|
// Purpose: Draw the stats on the screen in a matrix
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
// proff/nicolas 09/20/98 -- changed for hi-res
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
void WI_drawDeathmatchStats(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
int j;
|
|
|
|
|
int x;
|
|
|
|
|
int y;
|
|
|
|
|
int w;
|
|
|
|
|
|
|
|
|
|
int halfface = V_NamePatchWidth(facebackp)/2;
|
|
|
|
|
|
|
|
|
|
WI_slamBackground();
|
|
|
|
|
|
|
|
|
|
// draw animated background
|
|
|
|
|
WI_drawAnimatedBack();
|
|
|
|
|
WI_drawLF();
|
|
|
|
|
|
|
|
|
|
// draw stat titles (top line)
|
|
|
|
|
V_DrawNamePatch(DM_TOTALSX-V_NamePatchWidth(total)/2,
|
|
|
|
|
DM_MATRIXY-WI_SPACINGY+10, FB, total, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
|
|
|
|
|
V_DrawNamePatch(DM_KILLERSX, DM_KILLERSY, FB, killers, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
V_DrawNamePatch(DM_VICTIMSX, DM_VICTIMSY, FB, victims, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
|
|
|
|
|
// draw P?
|
|
|
|
|
x = DM_MATRIXX + DM_SPACINGX;
|
|
|
|
|
y = DM_MATRIXY;
|
|
|
|
|
|
|
|
|
|
for (i=0 ; i<MAXPLAYERS ; i++)
|
|
|
|
|
{
|
|
|
|
|
if (playeringame[i]) {
|
|
|
|
|
//int trans = playernumtotrans[i];
|
|
|
|
|
V_DrawNamePatch(x-halfface, DM_MATRIXY - WI_SPACINGY,
|
|
|
|
|
FB, facebackp, i ? CR_LIMIT+i : CR_DEFAULT,
|
|
|
|
|
VPT_STRETCH | (i ? VPT_TRANS : 0));
|
|
|
|
|
V_DrawNamePatch(DM_MATRIXX-halfface, y,
|
|
|
|
|
FB, facebackp, i ? CR_LIMIT+i : CR_DEFAULT,
|
|
|
|
|
VPT_STRETCH | (i ? VPT_TRANS : 0));
|
|
|
|
|
|
|
|
|
|
if (i == me)
|
|
|
|
|
{
|
|
|
|
|
V_DrawNamePatch(x-halfface, DM_MATRIXY - WI_SPACINGY,
|
|
|
|
|
FB, bstar, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
V_DrawNamePatch(DM_MATRIXX-halfface, y,
|
|
|
|
|
FB, star, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
|
// Note: The term "Netgame" means a coop game
|
|
|
|
|
//
|
|
|
|
|
static short *cnt_kills;
|
|
|
|
|
static short *cnt_items;
|
|
|
|
|
static short *cnt_secret;
|
|
|
|
|
static short *cnt_frags;
|
|
|
|
|
static int dofrags;
|
|
|
|
|
static int ng_state;
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// CPhipps - WI_endNetgameStats
|
|
|
|
|
// Purpose: Clean up coop game stats
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
static void WI_endNetgameStats(void)
|
|
|
|
|
{
|
|
|
|
|
free(cnt_frags);
|
|
|
|
|
free(cnt_secret);
|
|
|
|
|
free(cnt_items);
|
|
|
|
|
free(cnt_kills);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_initNetgameStats
|
|
|
|
|
// Purpose: Prepare for coop game stats
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_initNetgameStats(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
state = StatCount;
|
|
|
|
|
acceleratestage = 0;
|
|
|
|
|
ng_state = 1;
|
|
|
|
|
|
|
|
|
|
cnt_pause = TICRATE;
|
|
|
|
|
|
|
|
|
|
// CPhipps - allocate these dynamically, blank with calloc
|
|
|
|
|
cnt_kills = calloc(MAXPLAYERS, sizeof(*cnt_kills));
|
|
|
|
|
cnt_items = calloc(MAXPLAYERS, sizeof(*cnt_items));
|
|
|
|
|
cnt_secret= calloc(MAXPLAYERS, sizeof(*cnt_secret));
|
|
|
|
|
cnt_frags = calloc(MAXPLAYERS, sizeof(*cnt_frags));
|
|
|
|
|
|
|
|
|
|
for (i=0 ; i<MAXPLAYERS ; i++)
|
|
|
|
|
if (playeringame[i])
|
|
|
|
|
dofrags += WI_fragSum(i);
|
|
|
|
|
|
|
|
|
|
dofrags = !!dofrags; // set to true or false - did we have frags?
|
|
|
|
|
|
|
|
|
|
WI_initAnimatedBack();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_updateNetgameStats
|
|
|
|
|
// Purpose: Calculate coop stats as we display them with noise and fury
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
// Comment: This stuff sure is complicated for what it does
|
|
|
|
|
//
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
// killough 2/22/98: Make secrets = 100% if maxsecret = 0:
|
|
|
|
|
cnt_secret[i] = wbs->maxsecret ?
|
|
|
|
|
(plrs[i].ssecret * 100) / wbs->maxsecret : 100;
|
|
|
|
|
if (dofrags)
|
|
|
|
|
cnt_frags[i] = WI_fragSum(i); // we had frags
|
|
|
|
|
}
|
|
|
|
|
S_StartSound(0, sfx_barexp); // bang
|
|
|
|
|
ng_state = 10;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ng_state == 2)
|
|
|
|
|
{
|
|
|
|
|
if (!(bcnt&3))
|
|
|
|
|
S_StartSound(0, sfx_pistol); // pop
|
|
|
|
|
|
|
|
|
|
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; // still got stuff to tally
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
// killough 2/22/98: Make secrets = 100% if maxsecret = 0:
|
|
|
|
|
|
|
|
|
|
if (cnt_secret[i] >= (wbs->maxsecret ? (plrs[i].ssecret * 100) / wbs->maxsecret : compatibility_level < lxdoom_1_compatibility ? 0 : 100))
|
|
|
|
|
cnt_secret[i] = wbs->maxsecret ? (plrs[i].ssecret * 100) / wbs->maxsecret : 100;
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_drawNetgameStats
|
|
|
|
|
// Purpose: Put the coop stats on the screen
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
// proff/nicolas 09/20/98 -- changed for hi-res
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
void WI_drawNetgameStats(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
int x;
|
|
|
|
|
int y;
|
|
|
|
|
int pwidth = V_NamePatchWidth(percent);
|
|
|
|
|
int fwidth = V_NamePatchWidth(facebackp);
|
|
|
|
|
|
|
|
|
|
WI_slamBackground();
|
|
|
|
|
|
|
|
|
|
// draw animated background
|
|
|
|
|
WI_drawAnimatedBack();
|
|
|
|
|
|
|
|
|
|
WI_drawLF();
|
|
|
|
|
|
|
|
|
|
// draw stat titles (top line)
|
|
|
|
|
V_DrawNamePatch(NG_STATSX+NG_SPACINGX-V_NamePatchWidth(kills),
|
|
|
|
|
NG_STATSY, FB, kills, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
|
|
|
|
|
V_DrawNamePatch(NG_STATSX+2*NG_SPACINGX-V_NamePatchWidth(items),
|
|
|
|
|
NG_STATSY, FB, items, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
|
|
|
|
|
V_DrawNamePatch(NG_STATSX+3*NG_SPACINGX-V_NamePatchWidth(secret),
|
|
|
|
|
NG_STATSY, FB, secret, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
|
|
|
|
|
if (dofrags)
|
|
|
|
|
V_DrawNamePatch(NG_STATSX+4*NG_SPACINGX-V_NamePatchWidth(frags),
|
|
|
|
|
NG_STATSY, FB, frags, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
|
|
|
|
|
// draw stats
|
|
|
|
|
y = NG_STATSY + V_NamePatchHeight(kills);
|
|
|
|
|
|
|
|
|
|
for (i=0 ; i<MAXPLAYERS ; i++)
|
|
|
|
|
{
|
|
|
|
|
//int trans = playernumtotrans[i];
|
|
|
|
|
if (!playeringame[i])
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
x = NG_STATSX;
|
|
|
|
|
V_DrawNamePatch(x-fwidth, y, FB, facebackp,
|
|
|
|
|
i ? CR_LIMIT+i : CR_DEFAULT,
|
|
|
|
|
VPT_STRETCH | (i ? VPT_TRANS : 0));
|
|
|
|
|
|
|
|
|
|
if (i == me)
|
|
|
|
|
V_DrawNamePatch(x-fwidth, y, FB, star, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (y <= SP_TIMEY)
|
|
|
|
|
// cph - show times in coop on the entering screen
|
|
|
|
|
WI_drawTimeStats(plrs[me].stime / TICRATE, wbs->totaltimes / TICRATE, wbs->partime / TICRATE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int sp_state;
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_initStats
|
|
|
|
|
// Purpose: Get ready for single player stats
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
// Comment: Seems like we could do all these stats in a more generic
|
|
|
|
|
// set of routines that weren't duplicated for dm, coop, sp
|
|
|
|
|
//
|
|
|
|
|
void WI_initStats(void)
|
|
|
|
|
{
|
|
|
|
|
state = StatCount;
|
|
|
|
|
acceleratestage = 0;
|
|
|
|
|
sp_state = 1;
|
|
|
|
|
|
|
|
|
|
// CPhipps - allocate (awful code, I know, but saves changing it all) and initialise
|
|
|
|
|
*(cnt_kills = malloc(sizeof(*cnt_kills))) =
|
|
|
|
|
*(cnt_items = malloc(sizeof(*cnt_items))) =
|
|
|
|
|
*(cnt_secret= malloc(sizeof(*cnt_secret))) = -1;
|
|
|
|
|
cnt_time = cnt_par = cnt_total_time = -1;
|
|
|
|
|
cnt_pause = TICRATE;
|
|
|
|
|
|
|
|
|
|
WI_initAnimatedBack();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_updateStats
|
|
|
|
|
// Purpose: Calculate solo stats
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
// killough 2/22/98: Make secrets = 100% if maxsecret = 0:
|
|
|
|
|
cnt_secret[0] = (wbs->maxsecret ?
|
|
|
|
|
(plrs[me].ssecret * 100) / wbs->maxsecret : 100);
|
|
|
|
|
|
|
|
|
|
cnt_total_time = wbs->totaltimes / TICRATE;
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
// killough 2/22/98: Make secrets = 100% if maxsecret = 0:
|
|
|
|
|
if ((!wbs->maxsecret && compatibility_level < lxdoom_1_compatibility) ||
|
|
|
|
|
cnt_secret[0] >= (wbs->maxsecret ?
|
|
|
|
|
(plrs[me].ssecret * 100) / wbs->maxsecret : 100))
|
|
|
|
|
{
|
|
|
|
|
cnt_secret[0] = (wbs->maxsecret ?
|
|
|
|
|
(plrs[me].ssecret * 100) / wbs->maxsecret : 100);
|
|
|
|
|
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_total_time += 3;
|
|
|
|
|
|
|
|
|
|
if (cnt_total_time >= wbs->totaltimes / TICRATE)
|
|
|
|
|
cnt_total_time = wbs->totaltimes / TICRATE;
|
|
|
|
|
|
|
|
|
|
cnt_par += 3;
|
|
|
|
|
|
|
|
|
|
if (cnt_par >= wbs->partime / TICRATE)
|
|
|
|
|
{
|
|
|
|
|
cnt_par = wbs->partime / TICRATE;
|
|
|
|
|
|
|
|
|
|
if ((cnt_time >= plrs[me].stime / TICRATE) && (compatibility_level < lxdoom_1_compatibility || cnt_total_time >= wbs->totaltimes / 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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_drawStats
|
|
|
|
|
// Purpose: Put the solo stats on the screen
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
// proff/nicolas 09/20/98 -- changed for hi-res
|
|
|
|
|
// CPhipps - patch drawing updated
|
|
|
|
|
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_DrawNamePatch(SP_STATSX, SP_STATSY, FB, kills, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
WI_drawPercent(320 - SP_STATSX, SP_STATSY, cnt_kills[0]);
|
|
|
|
|
|
|
|
|
|
V_DrawNamePatch(SP_STATSX, SP_STATSY+lh, FB, items, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
WI_drawPercent(320 - SP_STATSX, SP_STATSY+lh, cnt_items[0]);
|
|
|
|
|
|
|
|
|
|
V_DrawNamePatch(SP_STATSX, SP_STATSY+2*lh, FB, sp_secret, CR_DEFAULT, VPT_STRETCH);
|
|
|
|
|
WI_drawPercent(320 - SP_STATSX, SP_STATSY+2*lh, cnt_secret[0]);
|
|
|
|
|
|
|
|
|
|
WI_drawTimeStats(cnt_time, cnt_total_time, cnt_par);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_checkForAccelerate
|
|
|
|
|
// Purpose: See if the player has hit either the attack or use key
|
|
|
|
|
// or mouse button. If so we set acceleratestage to 1 and
|
|
|
|
|
// all those display routines above jump right to the end.
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_Ticker
|
|
|
|
|
// Purpose: Do various updates every gametic, for stats, animation,
|
|
|
|
|
// checking that intermission music is running, etc.
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* ====================================================================
|
|
|
|
|
* WI_loadData
|
|
|
|
|
* Purpose: Initialize intermission data such as background graphics,
|
|
|
|
|
* patches, map names, etc.
|
|
|
|
|
* Args: none
|
|
|
|
|
* Returns: void
|
|
|
|
|
*
|
|
|
|
|
* CPhipps - modified for new wad lump handling.
|
|
|
|
|
* - no longer preload most graphics, other funcs can use
|
|
|
|
|
* them by name
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void WI_loadData(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
int j;
|
|
|
|
|
char name[9]; // limited to 8 characters
|
|
|
|
|
anim_t* a;
|
|
|
|
|
|
|
|
|
|
if (gamemode != commercial)
|
|
|
|
|
{
|
|
|
|
|
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
|
|
|
|
|
snprintf(name, sizeof(name),"WIA%d%s%d%s%d", wbs->epsd, (j/10>0?"":"0"), j,(i/10>0?"":"0"), i); //ANOTHER ROCKHACK
|
|
|
|
|
//snprintf(name, sizeof(name),"WIA%d%.2d%.2d", wbs->epsd, j, i);
|
|
|
|
|
a->p[i] = W_CacheLumpName(name);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// HACK ALERT!
|
|
|
|
|
a->p[i] = anims[1][4].p[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i=0;i<10;i++)
|
|
|
|
|
{
|
|
|
|
|
// numbers 0-9
|
|
|
|
|
snprintf(name,sizeof(name),"WINUM%d", i);
|
|
|
|
|
num[i] = W_CacheLumpName(name);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_unloadData
|
|
|
|
|
// Purpose: Free up the space allocated during WI_loadData
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
// CPhipps - reverse of WI_loadData, goes through the same lumps, but unlocking
|
|
|
|
|
void WI_unloadData(void)
|
|
|
|
|
{
|
|
|
|
|
int i,j;
|
|
|
|
|
char name[9]; // limited to 8 characters
|
|
|
|
|
|
|
|
|
|
// cph - unlock gamemode dependent stuff here
|
|
|
|
|
if (gamemode != commercial) {
|
|
|
|
|
if (wbs->epsd < 3) {
|
|
|
|
|
for (j=0;j<NUMANIMS[wbs->epsd];j++) {
|
|
|
|
|
anim_t* a = &anims[wbs->epsd][j];
|
|
|
|
|
for (i=0; i<a->nanims; i++) {
|
|
|
|
|
// MONDO HACK!
|
|
|
|
|
if (wbs->epsd != 1 || j != 8) {
|
|
|
|
|
// animations
|
|
|
|
|
snprintf(name, sizeof(name),"WIA%d%s%d%s%d", wbs->epsd, (j/10>0?"":"0"), j,(i/10>0?"":"0"), i); //ANOTHER ROCKHACK
|
|
|
|
|
//snprintf(name,sizeof(name), "WIA%d%.2d%.2d", wbs->epsd, j, i);
|
|
|
|
|
W_UnlockLumpName(name);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i=0;i<10;i++) {
|
|
|
|
|
// numbers 0-9
|
|
|
|
|
snprintf(name, sizeof(name),"WINUM%d", i);
|
|
|
|
|
W_UnlockLumpName(name);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_Drawer
|
|
|
|
|
// Purpose: Call the appropriate stats drawing routine depending on
|
|
|
|
|
// what kind of game is being played (DM, coop, solo)
|
|
|
|
|
// Args: none
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_initVariables
|
|
|
|
|
// Purpose: Initialize the intermission information structure
|
|
|
|
|
// Note: wbstartstruct_t is defined in d_player.h
|
|
|
|
|
// Args: wbstartstruct -- pointer to the structure with the data
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
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; // probably only useful in MAP30
|
|
|
|
|
|
|
|
|
|
if (!wbs->maxitems)
|
|
|
|
|
wbs->maxitems = 1;
|
|
|
|
|
|
|
|
|
|
if ( gamemode != retail )
|
|
|
|
|
if (wbs->epsd > 2)
|
|
|
|
|
wbs->epsd -= 3;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ====================================================================
|
|
|
|
|
// WI_Start
|
|
|
|
|
// Purpose: Call the various init routines
|
|
|
|
|
// Note: wbstartstruct_t is defined in d_player.h
|
|
|
|
|
// Args: wbstartstruct -- pointer to the structure with the
|
|
|
|
|
// intermission data
|
|
|
|
|
// Returns: void
|
|
|
|
|
//
|
|
|
|
|
void WI_Start(wbstartstruct_t* wbstartstruct)
|
|
|
|
|
{
|
|
|
|
|
WI_initVariables(wbstartstruct);
|
|
|
|
|
WI_loadData();
|
|
|
|
|
|
|
|
|
|
if (deathmatch)
|
|
|
|
|
WI_initDeathmatchStats();
|
|
|
|
|
else if (netgame)
|
|
|
|
|
WI_initNetgameStats();
|
|
|
|
|
else
|
|
|
|
|
WI_initStats();
|
|
|
|
|
}
|
