45f2df0eba
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@9511 a1c6a512-1295-4272-9138-f99709370657
682 lines
19 KiB
C
682 lines
19 KiB
C
/* 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:
|
|
* Game completion, final screen animation.
|
|
*
|
|
*-----------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "doomstat.h"
|
|
#include "d_event.h"
|
|
#include "d_englsh.h"
|
|
#include "m_swap.h"
|
|
#include "v_video.h"
|
|
#include "w_wad.h"
|
|
#include "s_sound.h"
|
|
#include "sounds.h"
|
|
//#include "d_deh.h" // Ty 03/22/98 - externalizations
|
|
#include "f_finale.h" // CPhipps - hmm...
|
|
#include "rockmacros.h"
|
|
|
|
// Stage of animation:
|
|
// 0 = text, 1 = art screen, 2 = character cast
|
|
static int finalestage; // cph -
|
|
static int finalecount; // made static
|
|
static const char* finaletext; // cph -
|
|
static const char* finaleflat; // made static const
|
|
|
|
// defines for the end mission display text // phares
|
|
|
|
#define TEXTSPEED 3 // original value // phares
|
|
#define TEXTWAIT 250 // original value // phares
|
|
#define NEWTEXTSPEED 0.01f // new value // phares
|
|
#define NEWTEXTWAIT 1000 // new value // phares
|
|
|
|
// CPhipps - removed the old finale screen text message strings;
|
|
// they were commented out for ages already
|
|
// Ty 03/22/98 - ... the new s_WHATEVER extern variables are used
|
|
// in the code below instead.
|
|
|
|
void F_StartCast (void);
|
|
void F_CastTicker (void);
|
|
boolean F_CastResponder (event_t *ev);
|
|
void F_CastDrawer (void);
|
|
|
|
void WI_checkForAccelerate(void); // killough 3/28/98: used to
|
|
extern int acceleratestage; // accelerate intermission screens
|
|
static int midstage; // whether we're in "mid-stage"
|
|
|
|
//
|
|
// F_StartFinale
|
|
//
|
|
void F_StartFinale (void)
|
|
{
|
|
gameaction = ga_nothing;
|
|
gamestate = GS_FINALE;
|
|
automapmode &= ~am_active;
|
|
|
|
// killough 3/28/98: clear accelerative text flags
|
|
acceleratestage = midstage = 0;
|
|
|
|
// Okay - IWAD dependend stuff.
|
|
// This has been changed severly, and
|
|
// some stuff might have changed in the process.
|
|
switch ( gamemode )
|
|
{
|
|
|
|
// DOOM 1 - E1, E3 or E4, but each nine missions
|
|
case shareware:
|
|
case registered:
|
|
case retail:
|
|
{
|
|
S_ChangeMusic(mus_victor, true);
|
|
|
|
switch (gameepisode)
|
|
{
|
|
case 1:
|
|
finaleflat = "FLOOR4_8";
|
|
finaletext = E1TEXT;
|
|
break;
|
|
case 2:
|
|
finaleflat = "SFLR6_1";
|
|
finaletext = E2TEXT;
|
|
break;
|
|
case 3:
|
|
finaleflat = "MFLR8_4";
|
|
finaletext = E3TEXT;
|
|
break;
|
|
case 4:
|
|
finaleflat = "MFLR8_3";
|
|
finaletext = E4TEXT;
|
|
break;
|
|
default:
|
|
// Ouch.
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// DOOM II and missions packs with E1, M34
|
|
case commercial:
|
|
{
|
|
S_ChangeMusic(mus_read_m, true);
|
|
|
|
// Ty 08/27/98 - added the gamemission logic
|
|
switch (gamemap)
|
|
{
|
|
case 6:
|
|
finaleflat = "SLIME16";
|
|
finaletext = (gamemission==pack_tnt) ? T1TEXT :
|
|
(gamemission==pack_plut) ? P1TEXT : C1TEXT;
|
|
break;
|
|
case 11:
|
|
finaleflat = "RROCK14";
|
|
finaletext = (gamemission==pack_tnt) ? T2TEXT :
|
|
(gamemission==pack_plut) ? P2TEXT : C2TEXT;
|
|
break;
|
|
case 20:
|
|
finaleflat = "RROCK07";
|
|
finaletext = (gamemission==pack_tnt) ? T3TEXT :
|
|
(gamemission==pack_plut) ? P3TEXT : C3TEXT;
|
|
break;
|
|
case 30:
|
|
finaleflat = "RROCK17";
|
|
finaletext = (gamemission==pack_tnt) ? T4TEXT :
|
|
(gamemission==pack_plut) ? P4TEXT : C4TEXT;
|
|
break;
|
|
case 15:
|
|
finaleflat = "RROCK13";
|
|
finaletext = (gamemission==pack_tnt) ? T5TEXT :
|
|
(gamemission==pack_plut) ? P5TEXT : C5TEXT;
|
|
break;
|
|
case 31:
|
|
finaleflat = "RROCK19";
|
|
finaletext = (gamemission==pack_tnt) ? T6TEXT :
|
|
(gamemission==pack_plut) ? P6TEXT : C6TEXT;
|
|
break;
|
|
default:
|
|
// Ouch.
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
// Indeterminate.
|
|
default:
|
|
S_ChangeMusic(mus_read_m, true);
|
|
finaleflat = "F_SKY1"; // Not used anywhere else.
|
|
finaletext = C1TEXT; // FIXME - other text, music?
|
|
break;
|
|
}
|
|
|
|
finalestage = 0;
|
|
finalecount = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
boolean F_Responder (event_t *event)
|
|
{
|
|
if (finalestage == 2)
|
|
return F_CastResponder (event);
|
|
|
|
return false;
|
|
}
|
|
|
|
// Get_TextSpeed() returns the value of the text display speed // phares
|
|
// Rewritten to allow user-directed acceleration -- killough 3/28/98
|
|
|
|
static float Get_TextSpeed(void)
|
|
{
|
|
return midstage ? NEWTEXTSPEED : (midstage=acceleratestage) ?
|
|
acceleratestage=0, NEWTEXTSPEED : TEXTSPEED;
|
|
}
|
|
|
|
//
|
|
// F_Ticker
|
|
//
|
|
// killough 3/28/98: almost totally rewritten, to use
|
|
// player-directed acceleration instead of constant delays.
|
|
// Now the player can accelerate the text display by using
|
|
// the fire/use keys while it is being printed. The delay
|
|
// automatically responds to the user, and gives enough
|
|
// time to read.
|
|
//
|
|
// killough 5/10/98: add back v1.9 demo compatibility
|
|
//
|
|
|
|
void F_Ticker(void)
|
|
{
|
|
int i;
|
|
if (!demo_compatibility)
|
|
WI_checkForAccelerate(); // killough 3/28/98: check for acceleration
|
|
else
|
|
if (gamemode == commercial && finalecount > 50) // check for skipping
|
|
for (i=0; i<MAXPLAYERS; i++)
|
|
if (players[i].cmd.buttons)
|
|
goto next_level; // go on to the next level
|
|
|
|
// advance animation
|
|
finalecount++;
|
|
|
|
if (finalestage == 2)
|
|
F_CastTicker();
|
|
|
|
if (!finalestage)
|
|
{
|
|
float speed = demo_compatibility ? TEXTSPEED : Get_TextSpeed();
|
|
/* killough 2/28/98: changed to allow acceleration */
|
|
if (finalecount > strlen(finaletext)*speed +
|
|
(midstage ? NEWTEXTWAIT : TEXTWAIT) ||
|
|
(midstage && acceleratestage)) {
|
|
if (gamemode != commercial) // Doom 1 / Ultimate Doom episode end
|
|
{ // with enough time, it's automatic
|
|
finalecount = 0;
|
|
finalestage = 1;
|
|
wipegamestate = -1; // force a wipe
|
|
if (gameepisode == 3)
|
|
S_StartMusic(mus_bunny);
|
|
}
|
|
else // you must press a button to continue in Doom 2
|
|
if (!demo_compatibility && midstage)
|
|
{
|
|
next_level:
|
|
if (gamemap == 30)
|
|
F_StartCast(); // cast of Doom 2 characters
|
|
else
|
|
gameaction = ga_worlddone; // next level, e.g. MAP07
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// F_TextWrite
|
|
//
|
|
// This program displays the background and text at end-mission // phares
|
|
// text time. It draws both repeatedly so that other displays, // |
|
|
// like the main menu, can be drawn over it dynamically and // V
|
|
// erased dynamically. The TEXTSPEED constant is changed into
|
|
// the Get_TextSpeed function so that the speed of writing the // ^
|
|
// text can be increased, and there's still time to read what's // |
|
|
// written. // phares
|
|
// CPhipps - reformatted
|
|
|
|
#include "hu_stuff.h"
|
|
extern patchnum_t hu_font[HU_FONTSIZE];
|
|
|
|
|
|
void F_TextWrite (void)
|
|
{
|
|
V_DrawBackground(finaleflat, 0);
|
|
{ // draw some of the text onto the screen
|
|
int cx = 10;
|
|
int cy = 10;
|
|
const char* ch = finaletext; // CPhipps - const
|
|
int count = (int)((float)(finalecount - 10)/Get_TextSpeed()); // phares
|
|
int w;
|
|
|
|
if (count < 0)
|
|
count = 0;
|
|
|
|
for ( ; count ; count-- ) {
|
|
int c = *ch++;
|
|
|
|
if (!c)
|
|
break;
|
|
if (c == '\n') {
|
|
cx = 10;
|
|
cy += 11;
|
|
continue;
|
|
}
|
|
|
|
c = toupper(c) - HU_FONTSTART;
|
|
if (c < 0 || c> HU_FONTSIZE) {
|
|
cx += 4;
|
|
continue;
|
|
}
|
|
|
|
w = SHORT (hu_font[c].width);
|
|
if (cx+w > 320)
|
|
break;
|
|
// CPhipps - patch drawing updated
|
|
V_DrawNumPatch(cx, cy, 0, hu_font[c].lumpnum, CR_DEFAULT, VPT_STRETCH);
|
|
cx+=w;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Final DOOM 2 animation
|
|
// Casting by id Software.
|
|
// in order of appearance
|
|
//
|
|
typedef struct
|
|
{
|
|
const char *name; // CPhipps - const**
|
|
mobjtype_t type;
|
|
} castinfo_t;
|
|
|
|
#define MAX_CASTORDER 18 /* Ty - hard coded for now */
|
|
static const castinfo_t castorder[] = { // CPhipps - static const, initialised here
|
|
{ CC_ZOMBIE, MT_POSSESSED },
|
|
{ CC_SHOTGUN, MT_SHOTGUY },
|
|
{ CC_HEAVY, MT_CHAINGUY },
|
|
{ CC_IMP, MT_TROOP },
|
|
{ CC_DEMON, MT_SERGEANT },
|
|
{ CC_LOST, MT_SKULL },
|
|
{ CC_CACO, MT_HEAD },
|
|
{ CC_HELL, MT_KNIGHT },
|
|
{ CC_BARON, MT_BRUISER },
|
|
{ CC_ARACH, MT_BABY },
|
|
{ CC_PAIN, MT_PAIN },
|
|
{ CC_REVEN, MT_UNDEAD },
|
|
{ CC_MANCU, MT_FATSO },
|
|
{ CC_ARCH, MT_VILE },
|
|
{ CC_SPIDER, MT_SPIDER },
|
|
{ CC_CYBER, MT_CYBORG },
|
|
{ CC_HERO, MT_PLAYER },
|
|
{ NULL, 0}
|
|
};
|
|
|
|
int castnum;
|
|
int casttics;
|
|
state_t* caststate;
|
|
boolean castdeath;
|
|
int castframes;
|
|
int castonmelee;
|
|
boolean castattacking;
|
|
|
|
|
|
//
|
|
// F_StartCast
|
|
//
|
|
extern gamestate_t wipegamestate;
|
|
|
|
void F_StartCast (void)
|
|
{
|
|
wipegamestate = -1; // force a screen wipe
|
|
castnum = 0;
|
|
caststate = &states[mobjinfo[castorder[castnum].type].seestate];
|
|
casttics = caststate->tics;
|
|
castdeath = false;
|
|
finalestage = 2;
|
|
castframes = 0;
|
|
castonmelee = 0;
|
|
castattacking = false;
|
|
S_ChangeMusic(mus_evil, true);
|
|
}
|
|
|
|
|
|
//
|
|
// F_CastTicker
|
|
//
|
|
void F_CastTicker (void)
|
|
{
|
|
int st;
|
|
int sfx;
|
|
|
|
if (--casttics > 0)
|
|
return; // not time to change state yet
|
|
|
|
if (caststate->tics == -1 || caststate->nextstate == S_NULL)
|
|
{
|
|
// switch from deathstate to next monster
|
|
castnum++;
|
|
castdeath = false;
|
|
if (castorder[castnum].name == NULL)
|
|
castnum = 0;
|
|
if (mobjinfo[castorder[castnum].type].seesound)
|
|
S_StartSound (NULL, mobjinfo[castorder[castnum].type].seesound);
|
|
caststate = &states[mobjinfo[castorder[castnum].type].seestate];
|
|
castframes = 0;
|
|
}
|
|
else
|
|
{
|
|
// just advance to next state in animation
|
|
if (caststate == &states[S_PLAY_ATK1])
|
|
goto stopattack; // Oh, gross hack!
|
|
st = caststate->nextstate;
|
|
caststate = &states[st];
|
|
castframes++;
|
|
|
|
// sound hacks....
|
|
switch (st)
|
|
{
|
|
case S_PLAY_ATK1: sfx = sfx_dshtgn; break;
|
|
case S_POSS_ATK2: sfx = sfx_pistol; break;
|
|
case S_SPOS_ATK2: sfx = sfx_shotgn; break;
|
|
case S_VILE_ATK2: sfx = sfx_vilatk; break;
|
|
case S_SKEL_FIST2: sfx = sfx_skeswg; break;
|
|
case S_SKEL_FIST4: sfx = sfx_skepch; break;
|
|
case S_SKEL_MISS2: sfx = sfx_skeatk; break;
|
|
case S_FATT_ATK8:
|
|
case S_FATT_ATK5:
|
|
case S_FATT_ATK2: sfx = sfx_firsht; break;
|
|
case S_CPOS_ATK2:
|
|
case S_CPOS_ATK3:
|
|
case S_CPOS_ATK4: sfx = sfx_shotgn; break;
|
|
case S_TROO_ATK3: sfx = sfx_claw; break;
|
|
case S_SARG_ATK2: sfx = sfx_sgtatk; break;
|
|
case S_BOSS_ATK2:
|
|
case S_BOS2_ATK2:
|
|
case S_HEAD_ATK2: sfx = sfx_firsht; break;
|
|
case S_SKULL_ATK2: sfx = sfx_sklatk; break;
|
|
case S_SPID_ATK2:
|
|
case S_SPID_ATK3: sfx = sfx_shotgn; break;
|
|
case S_BSPI_ATK2: sfx = sfx_plasma; break;
|
|
case S_CYBER_ATK2:
|
|
case S_CYBER_ATK4:
|
|
case S_CYBER_ATK6: sfx = sfx_rlaunc; break;
|
|
case S_PAIN_ATK3: sfx = sfx_sklatk; break;
|
|
default: sfx = 0; break;
|
|
}
|
|
|
|
if (sfx)
|
|
S_StartSound (NULL, sfx);
|
|
}
|
|
|
|
if (castframes == 12)
|
|
{
|
|
// go into attack frame
|
|
castattacking = true;
|
|
if (castonmelee)
|
|
caststate=&states[mobjinfo[castorder[castnum].type].meleestate];
|
|
else
|
|
caststate=&states[mobjinfo[castorder[castnum].type].missilestate];
|
|
castonmelee ^= 1;
|
|
if (caststate == &states[S_NULL])
|
|
{
|
|
if (castonmelee)
|
|
caststate=
|
|
&states[mobjinfo[castorder[castnum].type].meleestate];
|
|
else
|
|
caststate=
|
|
&states[mobjinfo[castorder[castnum].type].missilestate];
|
|
}
|
|
}
|
|
|
|
if (castattacking)
|
|
{
|
|
if (castframes == 24
|
|
|| caststate == &states[mobjinfo[castorder[castnum].type].seestate] )
|
|
{
|
|
stopattack:
|
|
castattacking = false;
|
|
castframes = 0;
|
|
caststate = &states[mobjinfo[castorder[castnum].type].seestate];
|
|
}
|
|
}
|
|
|
|
casttics = caststate->tics;
|
|
if (casttics == -1)
|
|
casttics = 15;
|
|
}
|
|
|
|
|
|
//
|
|
// F_CastResponder
|
|
//
|
|
|
|
boolean F_CastResponder (event_t* ev)
|
|
{
|
|
if (ev->type != ev_keydown)
|
|
return false;
|
|
|
|
if (castdeath)
|
|
return true; // already in dying frames
|
|
|
|
// go into death frame
|
|
castdeath = true;
|
|
caststate = &states[mobjinfo[castorder[castnum].type].deathstate];
|
|
casttics = caststate->tics;
|
|
castframes = 0;
|
|
castattacking = false;
|
|
if (mobjinfo[castorder[castnum].type].deathsound)
|
|
S_StartSound (NULL, mobjinfo[castorder[castnum].type].deathsound);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
static void F_CastPrint (const char* text) // CPhipps - static, const char*
|
|
{
|
|
const char* ch; // CPhipps - const
|
|
int c;
|
|
int cx;
|
|
int w;
|
|
int width;
|
|
|
|
// find width
|
|
ch = text;
|
|
width = 0;
|
|
|
|
while (ch)
|
|
{
|
|
c = *ch++;
|
|
if (!c)
|
|
break;
|
|
c = toupper(c) - HU_FONTSTART;
|
|
if (c < 0 || c> HU_FONTSIZE)
|
|
{
|
|
width += 4;
|
|
continue;
|
|
}
|
|
|
|
w = SHORT (hu_font[c].width);
|
|
width += w;
|
|
}
|
|
|
|
// draw it
|
|
cx = 160-width/2;
|
|
ch = text;
|
|
while (ch)
|
|
{
|
|
c = *ch++;
|
|
if (!c)
|
|
break;
|
|
c = toupper(c) - HU_FONTSTART;
|
|
if (c < 0 || c> HU_FONTSIZE)
|
|
{
|
|
cx += 4;
|
|
continue;
|
|
}
|
|
|
|
w = SHORT (hu_font[c].width);
|
|
// CPhipps - patch drawing updated
|
|
V_DrawNumPatch(cx, 180, 0, hu_font[c].lumpnum, CR_DEFAULT, VPT_STRETCH);
|
|
cx+=w;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// F_CastDrawer
|
|
//
|
|
void V_DrawPatchFlipped (int x, int y, int scrn, patch_t *patch);
|
|
|
|
void F_CastDrawer (void)
|
|
{
|
|
spritedef_t* sprdef;
|
|
spriteframe_t* sprframe;
|
|
int lump;
|
|
boolean flip;
|
|
|
|
// erase the entire screen to a background
|
|
V_DrawNamePatch(0,0,0, "BOSSBACK", CR_DEFAULT, VPT_STRETCH); // Ty 03/30/98 bg texture extern
|
|
|
|
F_CastPrint (castorder[castnum].name);
|
|
|
|
// draw the current frame in the middle of the screen
|
|
sprdef = &sprites[caststate->sprite];
|
|
sprframe = &sprdef->spriteframes[ caststate->frame & FF_FRAMEMASK];
|
|
lump = sprframe->lump[0];
|
|
flip = (boolean)sprframe->flip[0];
|
|
|
|
// CPhipps - patch drawing updated
|
|
V_DrawNumPatch(160, 170, 0, lump+firstspritelump, CR_DEFAULT,
|
|
VPT_STRETCH | (flip ? VPT_FLIP : 0));
|
|
}
|
|
|
|
|
|
//
|
|
// F_BunnyScroll
|
|
//
|
|
static const char pfub2[] = { "PFUB2" };
|
|
static const char pfub1[] = { "PFUB1" };
|
|
|
|
static void F_BunnyScroll (void)
|
|
{
|
|
char name[10];
|
|
int stage;
|
|
static int laststage;
|
|
|
|
V_MarkRect (0, 0, SCREENWIDTH, SCREENHEIGHT);
|
|
{
|
|
int scrolled = 320 - (finalecount-230)/2;
|
|
if (scrolled <= 0) {
|
|
V_DrawNamePatch(0, 0, 0, pfub2, CR_DEFAULT, VPT_STRETCH);
|
|
} else if (scrolled >= 320) {
|
|
V_DrawNamePatch(0, 0, 0, pfub1, CR_DEFAULT, VPT_STRETCH);
|
|
} else {
|
|
#define SCRN 2
|
|
|
|
int realscrolled = (SCREENWIDTH * scrolled) / 320;
|
|
|
|
V_AllocScreen(SCRN);
|
|
V_DrawNamePatch(0, 0, SCRN, pfub2, CR_DEFAULT, VPT_STRETCH);
|
|
V_CopyRect(realscrolled, 0, SCRN, SCREENWIDTH-realscrolled, SCREENHEIGHT, 0, 0, 0, VPT_NONE);
|
|
V_DrawNamePatch(0, 0, SCRN, pfub1, CR_DEFAULT, VPT_STRETCH);
|
|
V_CopyRect(0, 0, SCRN, realscrolled, SCREENHEIGHT, SCREENWIDTH-realscrolled, 0, 0, VPT_NONE);
|
|
V_FreeScreen(SCRN);
|
|
}
|
|
}
|
|
|
|
if (finalecount < 1130)
|
|
return;
|
|
if (finalecount < 1180)
|
|
{
|
|
// CPhipps - patch drawing updated
|
|
V_DrawNamePatch((320-13*8)/2, (200-8*8)/2,0, "END0", CR_DEFAULT, VPT_STRETCH);
|
|
laststage = 0;
|
|
return;
|
|
}
|
|
|
|
stage = (finalecount-1180) / 5;
|
|
if (stage > 6)
|
|
stage = 6;
|
|
if (stage > laststage)
|
|
{
|
|
S_StartSound (NULL, sfx_pistol);
|
|
laststage = stage;
|
|
}
|
|
|
|
snprintf (name,sizeof(name), "END%d",stage);
|
|
// CPhipps - patch drawing updated
|
|
V_DrawNamePatch((320-13*8)/2, (200-8*8)/2, 0, name, CR_DEFAULT, VPT_STRETCH);
|
|
}
|
|
|
|
|
|
//
|
|
// F_Drawer
|
|
//
|
|
void F_Drawer (void)
|
|
{
|
|
if (finalestage == 2)
|
|
{
|
|
F_CastDrawer ();
|
|
return;
|
|
}
|
|
|
|
if (!finalestage)
|
|
F_TextWrite ();
|
|
else
|
|
{
|
|
switch (gameepisode)
|
|
{
|
|
// CPhipps - patch drawing updated
|
|
case 1:
|
|
if ( gamemode == retail )
|
|
V_DrawNamePatch(0, 0, 0, "CREDIT", CR_DEFAULT, VPT_STRETCH);
|
|
else
|
|
V_DrawNamePatch(0, 0, 0, "HELP2", CR_DEFAULT, VPT_STRETCH);
|
|
break;
|
|
case 2:
|
|
V_DrawNamePatch(0, 0, 0, "VICTORY2", CR_DEFAULT, VPT_STRETCH);
|
|
break;
|
|
case 3:
|
|
F_BunnyScroll ();
|
|
break;
|
|
case 4:
|
|
V_DrawNamePatch(0, 0, 0, "ENDPIC", CR_DEFAULT, VPT_STRETCH);
|
|
break;
|
|
}
|
|
}
|
|
}
|