开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 射击游戏 > 查看源码
wi_stuff.c
资源名称：21.rar　[点击查看]
上传用户：xuyinpeng
上传日期：2021-05-12
资源大小：455k
文件大小：36k
源码类别：

射击游戏

开发平台：

Visual C++

wi_stuff.c：源码内容
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. // Intermission screens.
  21. //
  22. //-----------------------------------------------------------------------------
  24. static const char
  25. rcsid[] = "$Id: wi_stuff.c,v 1.7 1997/02/03 22:45:13 b1 Exp $";
  27. #include <stdio.h>
  29. #include "z_zone.h"
  31. #include "m_random.h"
  32. #include "m_swap.h"
  34. #include "i_system.h"
  36. #include "w_wad.h"
  38. #include "g_game.h"
  40. #include "r_local.h"
  41. #include "s_sound.h"
  43. #include "doomstat.h"
  45. // Data.
  46. #include "sounds.h"
  48. // Needs access to LFB.
  49. #include "v_video.h"
  51. #include "wi_stuff.h"
  53. //
  54. // Data needed to add patches to full screen intermission pics.
  55. // Patches are statistics messages, and animations.
  56. // Loads of by-pixel layout and placement, offsets etc.
  57. //
  60. //
  61. // Different vetween registered DOOM (1994) and
  62. //  Ultimate DOOM - Final edition (retail, 1995?).
  63. // This is supposedly ignored for commercial
  64. //  release (aka DOOM II), which had 34 maps
  65. //  in one episode. So there.
  66. #define NUMEPISODES 4
  67. #define NUMMAPS 9
  70. // in tics
  71. //U #define PAUSELEN (TICRATE*2) 
  72. //U #define SCORESTEP 100
  73. //U #define ANIMPERIOD 32
  74. // pixel distance from "(YOU)" to "PLAYER N"
  75. //U #define STARDIST 10 
  76. //U #define WK 1
  79. // GLOBAL LOCATIONS
  80. #define WI_TITLEY 2
  81. #define WI_SPACINGY     33
  83. // SINGPLE-PLAYER STUFF
  84. #define SP_STATSX 50
  85. #define SP_STATSY (((SCREENHEIGHT-200)/2)+50)
  87. #define SP_TIMEX 16
  88. #define SP_TIMEY (((SCREENHEIGHT-200)/2)+168)
  91. // NET GAME STUFF
  92. #define NG_STATSY 50
  93. #define NG_STATSX (32 + SHORT(star->width)/2 + 32*!dofrags)
  95. #define NG_SPACINGX     64
  98. // DEATHMATCH STUFF
  99. #define DM_MATRIXX 42
  100. #define DM_MATRIXY 68
  102. #define DM_SPACINGX 40
  104. #define DM_TOTALSX 269
  106. #define DM_KILLERSX 10
  107. #define DM_KILLERSY 100
  108. #define DM_VICTIMSX     5
  109. #define DM_VICTIMSY 50
  114. typedef enum
  115. {
  116.     ANIM_ALWAYS,
  117.     ANIM_RANDOM,
  118.     ANIM_LEVEL
  120. } animenum_t;
  122. typedef struct
  123. {
  124.     int x;
  125.     int y;
  126.     
  127. } point_t;
  130. //
  131. // Animation.
  132. // There is another anim_t used in p_spec.
  133. //
  134. typedef struct
  135. {
  136.     animenum_t type;
  138.     // period in tics between animations
  139.     int period;
  141.     // number of animation frames
  142.     int nanims;
  144.     // location of animation
  145.     point_t loc;
  147.     // ALWAYS: n/a,
  148.     // RANDOM: period deviation (<256),
  149.     // LEVEL: level
  150.     int data1;
  152.     // ALWAYS: n/a,
  153.     // RANDOM: random base period,
  154.     // LEVEL: n/a
  155.     int data2; 
  157.     // actual graphics for frames of animations
  158.     patch_t* p[3]; 
  160.     // following must be initialized to zero before use!
  162.     // next value of bcnt (used in conjunction with period)
  163.     int nexttic;
  165.     // last drawn animation frame
  166.     int lastdrawn;
  168.     // next frame number to animate
  169.     int ctr;
  170.     
  171.     // used by RANDOM and LEVEL when animating
  172.     int state;  
  174. } anim_t;
  177. static point_t lnodes[NUMEPISODES][NUMMAPS] =
  178. {
  179.     // Episode 0 World Map
  180.     {
  181. { 185, 164 }, // location of level 0 (CJ)
  182. { 148, 143 }, // location of level 1 (CJ)
  183. { 69, 122 }, // location of level 2 (CJ)
  184. { 209, 102 }, // location of level 3 (CJ)
  185. { 116, 89 }, // location of level 4 (CJ)
  186. { 166, 55 }, // location of level 5 (CJ)
  187. { 71, 56 }, // location of level 6 (CJ)
  188. { 135, 29 }, // location of level 7 (CJ)
  189. { 71, 24 } // location of level 8 (CJ)
  190.     },
  192.     // Episode 1 World Map should go here
  193.     {
  194. { 254, 25 }, // location of level 0 (CJ)
  195. { 97, 50 }, // location of level 1 (CJ)
  196. { 188, 64 }, // location of level 2 (CJ)
  197. { 128, 78 }, // location of level 3 (CJ)
  198. { 214, 92 }, // location of level 4 (CJ)
  199. { 133, 130 }, // location of level 5 (CJ)
  200. { 208, 136 }, // location of level 6 (CJ)
  201. { 148, 140 }, // location of level 7 (CJ)
  202. { 235, 158 } // location of level 8 (CJ)
  203.     },
  205.     // Episode 2 World Map should go here
  206.     {
  207. { 156, 168 }, // location of level 0 (CJ)
  208. { 48, 154 }, // location of level 1 (CJ)
  209. { 174, 95 }, // location of level 2 (CJ)
  210. { 265, 75 }, // location of level 3 (CJ)
  211. { 130, 48 }, // location of level 4 (CJ)
  212. { 279, 23 }, // location of level 5 (CJ)
  213. { 198, 48 }, // location of level 6 (CJ)
  214. { 140, 25 }, // location of level 7 (CJ)
  215. { 281, 136 } // location of level 8 (CJ)
  216.     }
  218. };
  221. //
  222. // Animation locations for episode 0 (1).
  223. // Using patches saves a lot of space,
  224. //  as they replace 320x200 full screen frames.
  225. //
  226. static anim_t epsd0animinfo[] =
  227. {
  228.     { ANIM_ALWAYS, TICRATE/3, 3, { 224, 104 } },
  229.     { ANIM_ALWAYS, TICRATE/3, 3, { 184, 160 } },
  230.     { ANIM_ALWAYS, TICRATE/3, 3, { 112, 136 } },
  231.     { ANIM_ALWAYS, TICRATE/3, 3, { 72, 112 } },
  232.     { ANIM_ALWAYS, TICRATE/3, 3, { 88, 96 } },
  233.     { ANIM_ALWAYS, TICRATE/3, 3, { 64, 48 } },
  234.     { ANIM_ALWAYS, TICRATE/3, 3, { 192, 40 } },
  235.     { ANIM_ALWAYS, TICRATE/3, 3, { 136, 16 } },
  236.     { ANIM_ALWAYS, TICRATE/3, 3, { 80, 16 } },
  237.     { ANIM_ALWAYS, TICRATE/3, 3, { 64, 24 } }
  238. };
  240. static anim_t epsd1animinfo[] =
  241. {
  242.     { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 1 },
  243.     { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 2 },
  244.     { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 3 },
  245.     { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 4 },
  246.     { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 5 },
  247.     { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 6 },
  248.     { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 7 },
  249.     { ANIM_LEVEL, TICRATE/3, 3, { 192, 144 }, 8 },
  250.     { ANIM_LEVEL, TICRATE/3, 1, { 128, 136 }, 8 }
  251. };
  253. static anim_t epsd2animinfo[] =
  254. {
  255.     { ANIM_ALWAYS, TICRATE/3, 3, { 104, 168 } },
  256.     { ANIM_ALWAYS, TICRATE/3, 3, { 40, 136 } },
  257.     { ANIM_ALWAYS, TICRATE/3, 3, { 160, 96 } },
  258.     { ANIM_ALWAYS, TICRATE/3, 3, { 104, 80 } },
  259.     { ANIM_ALWAYS, TICRATE/3, 3, { 120, 32 } },
  260.     { ANIM_ALWAYS, TICRATE/4, 3, { 40, 0 } }
  261. };
  263. static int NUMANIMS[NUMEPISODES] =
  264. {
  265.     sizeof(epsd0animinfo)/sizeof(anim_t),
  266.     sizeof(epsd1animinfo)/sizeof(anim_t),
  267.     sizeof(epsd2animinfo)/sizeof(anim_t)
  268. };
  270. static anim_t *anims[NUMEPISODES] =
  271. {
  272.     epsd0animinfo,
  273.     epsd1animinfo,
  274.     epsd2animinfo
  275. };
  278. //
  279. // GENERAL DATA
  280. //
  282. //
  283. // Locally used stuff.
  284. //
  285. #define FB 0
  288. // States for single-player
  289. #define SP_KILLS 0
  290. #define SP_ITEMS 2
  291. #define SP_SECRET 4
  292. #define SP_FRAGS 6 
  293. #define SP_TIME 8 
  294. #define SP_PAR ST_TIME
  296. #define SP_PAUSE 1
  298. // in seconds
  299. #define SHOWNEXTLOCDELAY 4
  300. //#define SHOWLASTLOCDELAY SHOWNEXTLOCDELAY
  303. // used to accelerate or skip a stage
  304. static int acceleratestage;
  306. // wbs->pnum
  307. static int me;
  309.  // specifies current state
  310. static stateenum_t state;
  312. // contains information passed into intermission
  313. static wbstartstruct_t* wbs;
  315. static wbplayerstruct_t* plrs;  // wbs->plyr[]
  317. // used for general timing
  318. static int  cnt;  
  320. // used for timing of background animation
  321. static int  bcnt;
  323. // signals to refresh everything for one frame
  324. static int  firstrefresh; 
  326. static int cnt_kills[MAXPLAYERS];
  327. static int cnt_items[MAXPLAYERS];
  328. static int cnt_secret[MAXPLAYERS];
  329. static int cnt_time;
  330. static int cnt_par;
  331. static int cnt_pause;
  333. // # of commercial levels
  334. static int NUMCMAPS; 
  337. //
  338. // GRAPHICS
  339. //
  341. // background (map of levels).
  342. static patch_t* bg;
  344. // You Are Here graphic
  345. static patch_t* yah[2]; 
  347. // splat
  348. static patch_t* splat;
  350. // %, : graphics
  351. static patch_t* percent;
  352. static patch_t* colon;
  354. // 0-9 graphic
  355. static patch_t* num[10];
  357. // minus sign
  358. static patch_t* wiminus;
  360. // "Finished!" graphics
  361. static patch_t* finished;
  363. // "Entering" graphic
  364. static patch_t* entering; 
  366. // "secret"
  367. static patch_t* sp_secret;
  369.  // "Kills", "Scrt", "Items", "Frags"
  370. static patch_t* kills;
  371. static patch_t* secret;
  372. static patch_t* items;
  373. static patch_t* frags;
  375. // Time sucks.
  376. static patch_t* time;
  377. static patch_t* par;
  378. static patch_t* sucks;
  380. // "killers", "victims"
  381. static patch_t* killers;
  382. static patch_t* victims; 
  384. // "Total", your face, your dead face
  385. static patch_t* total;
  386. static patch_t* star;
  387. static patch_t* bstar;
  389. // "red P[1..MAXPLAYERS]"
  390. static patch_t* p[MAXPLAYERS];
  392. // "gray P[1..MAXPLAYERS]"
  393. static patch_t* bp[MAXPLAYERS];
  395.  // Name graphics of each level (centered)
  396. static patch_t** lnames;
  398. //
  399. // CODE
  400. //
  402. // slam background
  403. // UNUSED static unsigned char *background=0;
  406. void WI_slamBackground(void)
  407. {
  408.     memcpy(screens[0], screens[1], SCREENWIDTH * SCREENHEIGHT);
  409.     V_MarkRect (0, 0, SCREENWIDTH, SCREENHEIGHT);
  410. }
  412. // The ticker is used to detect keys
  413. //  because of timing issues in netgames.
  414. boolean WI_Responder(event_t* ev)
  415. {
  416.     return false;
  417. }
  420. // Draws "<Levelname> Finished!"
  421. void WI_drawLF(void)
  422. {
  423.     int y = WI_TITLEY+((SCREENHEIGHT-200)/2);
  425.     // draw <LevelName> 
  426.     V_DrawPatch((SCREENWIDTH - SHORT(lnames[wbs->last]->width))/2,
  427. y, FB, lnames[wbs->last]);
  429.     // draw "Finished!"
  430.     y += (5*SHORT(lnames[wbs->last]->height))/4;
  431.     
  432.     V_DrawPatch((SCREENWIDTH - SHORT(finished->width))/2,
  433. y, FB, finished);
  434. }
  438. // Draws "Entering <LevelName>"
  439. void WI_drawEL(void)
  440. {
  441.     int y = WI_TITLEY+((SCREENHEIGHT-200)/2);
  443.     // draw "Entering"
  444.     V_DrawPatch((SCREENWIDTH - SHORT(entering->width))/2,y, FB, entering);
  446.     // draw level
  447.     y += (5*SHORT(lnames[wbs->next]->height))/4;
  449.     V_DrawPatch((SCREENWIDTH - SHORT(lnames[wbs->next]->width))/2,y, FB, lnames[wbs->next]);
  451. }
  453. void
  454. WI_drawOnLnode
  455. ( int n,
  456.   patch_t* c[] )
  457. {
  459.     int i;
  460.     int left;
  461.     int top;
  462.     int right;
  463.     int bottom;
  464.     boolean fits = false;
  466.     i = 0;
  467.     do
  468.     {
  469. left = ((SCREENWIDTH-320)/2)+lnodes[wbs->epsd][n].x - SHORT(c[i]->leftoffset);
  470. top = ((SCREENHEIGHT-200)/2)+lnodes[wbs->epsd][n].y - SHORT(c[i]->topoffset);
  471. right = left + SHORT(c[i]->width);
  472. bottom = top + SHORT(c[i]->height);
  474. if (left >= 0
  475.     && right < SCREENWIDTH
  476.     && top >= 0
  477.     && bottom < SCREENHEIGHT)
  478. {
  479.     fits = true;
  480. }
  481. else
  482. {
  483.     i++;
  484. }
  485.     } while (!fits && i!=2);
  487.     if (fits && i<2)
  488.     {
  489. V_DrawPatch(((SCREENWIDTH-320)/2)+lnodes[wbs->epsd][n].x, ((SCREENHEIGHT-200)/2)+lnodes[wbs->epsd][n].y,
  490.     FB, c[i]);
  491.     }
  492.     else
  493.     {
  494. // DEBUG
  495. printf("Could not place patch on level %d", n+1); 
  496.     }
  497. }
  501. void WI_initAnimatedBack(void)
  502. {
  503.     int i;
  504.     anim_t* a;
  506.     if (gamemode == commercial)
  507. return;
  509.     if (wbs->epsd > 2)
  510. return;
  512.     for (i=0;i<NUMANIMS[wbs->epsd];i++)
  513.     {
  514. a = &anims[wbs->epsd][i];
  516. // init variables
  517. a->ctr = -1;
  519. // specify the next time to draw it
  520. if (a->type == ANIM_ALWAYS)
  521.     a->nexttic = bcnt + 1 + (M_Random()%a->period);
  522. else if (a->type == ANIM_RANDOM)
  523.     a->nexttic = bcnt + 1 + a->data2+(M_Random()%a->data1);
  524. else if (a->type == ANIM_LEVEL)
  525.     a->nexttic = bcnt + 1;
  526.     }
  528. }
  530. void WI_updateAnimatedBack(void)
  531. {
  532.     int i;
  533.     anim_t* a;
  535.     if (gamemode == commercial)
  536. return;
  538.     if (wbs->epsd > 2)
  539. return;
  541.     for (i=0;i<NUMANIMS[wbs->epsd];i++)
  542.     {
  543. a = &anims[wbs->epsd][i];
  545. if (bcnt == a->nexttic)
  546. {
  547.     switch (a->type)
  548.     {
  549.       case ANIM_ALWAYS:
  550. if (++a->ctr >= a->nanims) a->ctr = 0;
  551. a->nexttic = bcnt + a->period;
  552. break;
  554.       case ANIM_RANDOM:
  555. a->ctr++;
  556. if (a->ctr == a->nanims)
  557. {
  558.     a->ctr = -1;
  559.     a->nexttic = bcnt+a->data2+(M_Random()%a->data1);
  560. }
  561. else a->nexttic = bcnt + a->period;
  562. break;
  564.       case ANIM_LEVEL:
  565. // gawd-awful hack for level anims
  566. if (!(state == StatCount && i == 7)
  567.     && wbs->next == a->data1)
  568. {
  569.     a->ctr++;
  570.     if (a->ctr == a->nanims) a->ctr--;
  571.     a->nexttic = bcnt + a->period;
  572. }
  573. break;
  574.     }
  575. }
  577.     }
  579. }
  581. void WI_drawAnimatedBack(void)
  582. {
  583.     int i;
  584.     anim_t* a;
  586.     if (commercial)
  587. return;
  589.     if (wbs->epsd > 2)
  590. return;
  592.     for (i=0 ; i<NUMANIMS[wbs->epsd] ; i++)
  593.     {
  594. a = &anims[wbs->epsd][i];
  596. if (a->ctr >= 0)
  597.     V_DrawPatch(((SCREENWIDTH-320)/2)+a->loc.x, ((SCREENHEIGHT-200)/2)+a->loc.y, FB, a->p[a->ctr]);
  598.     }
  600. }
  602. //
  603. // Draws a number.
  604. // If digits > 0, then use that many digits minimum,
  605. //  otherwise only use as many as necessary.
  606. // Returns new x position.
  607. //
  609. int
  610. WI_drawNum
  611. ( int x,
  612.   int y,
  613.   int n,
  614.   int digits )
  615. {
  617.     int fontwidth = SHORT(num[0]->width);
  618.     int neg;
  619.     int temp;
  621.     if (digits < 0)
  622.     {
  623. if (!n)
  624. {
  625.     // make variable-length zeros 1 digit long
  626.     digits = 1;
  627. }
  628. else
  629. {
  630.     // figure out # of digits in #
  631.     digits = 0;
  632.     temp = n;
  634.     while (temp)
  635.     {
  636. temp /= 10;
  637. digits++;
  638.     }
  639. }
  640.     }
  642.     neg = n < 0;
  643.     if (neg)
  644. n = -n;
  646.     // if non-number, do not draw it
  647.     if (n == 1994)
  648. return 0;
  650.     // draw the new number
  651.     while (digits--)
  652.     {
  653. x -= fontwidth;
  654. V_DrawPatch(x, y, FB, num[ n % 10 ]);
  655. n /= 10;
  656.     }
  658.     // draw a minus sign if necessary
  659.     if (neg)
  660. V_DrawPatch(x-=8, y, FB, wiminus);
  662.     return x;
  664. }
  666. void
  667. WI_drawPercent
  668. ( int x,
  669.   int y,
  670.   int p )
  671. {
  672.     if (p < 0)
  673. return;
  675.     V_DrawPatch(x, y, FB, percent);
  676.     WI_drawNum(x, y, p, -1);
  677. }
  681. //
  682. // Display level completion time and par,
  683. //  or "sucks" message if overflow.
  684. //
  685. void
  686. WI_drawTime
  687. ( int x,
  688.   int y,
  689.   int t )
  690. {
  692.     int div;
  693.     int n;
  695.     if (t<0)
  696. return;
  698.     if (t <= 61*59)
  699.     {
  700. div = 1;
  702. do
  703. {
  704.     n = (t / div) % 60;
  705.     x = WI_drawNum(x, y, n, 2) - SHORT(colon->width);
  706.     div *= 60;
  708.     // draw
  709.     if (div==60 || t / div)
  710. V_DrawPatch(x, y, FB, colon);
  711.     
  712. } while (t / div);
  713.     }
  714.     else
  715.     {
  716. // "sucks"
  717. V_DrawPatch(x - SHORT(sucks->width), y, FB, sucks); 
  718.     }
  719. }
  722. void WI_End(void)
  723. {
  724.     void WI_unloadData(void);
  725.     WI_unloadData();
  726. }
  728. void WI_initNoState(void)
  729. {
  730.     state = NoState;
  731.     acceleratestage = 0;
  732.     cnt = 10;
  733. }
  735. void WI_updateNoState(void) {
  737.     WI_updateAnimatedBack();
  739.     if (!--cnt)
  740.     {
  741. WI_End();
  742. G_WorldDone();
  743.     }
  745. }
  747. static boolean snl_pointeron = false;
  750. void WI_initShowNextLoc(void)
  751. {
  752.     state = ShowNextLoc;
  753.     acceleratestage = 0;
  754.     cnt = SHOWNEXTLOCDELAY * TICRATE;
  756.     WI_initAnimatedBack();
  757. }
  759. void WI_updateShowNextLoc(void)
  760. {
  761.     WI_updateAnimatedBack();
  763.     if (!--cnt || acceleratestage)
  764. WI_initNoState();
  765.     else
  766. snl_pointeron = (cnt & 31) < 20;
  767. }
  769. void WI_drawShowNextLoc(void)
  770. {
  772.     int i;
  773.     int last;
  775.     WI_slamBackground();
  777.     // draw animated background
  778.     WI_drawAnimatedBack(); 
  780.     if ( gamemode != commercial)
  781.     {
  782.    if (wbs->epsd > 2)
  783. {
  784.     WI_drawEL();
  785.     return;
  786. }
  788. last = (wbs->last == 8) ? wbs->next - 1 : wbs->last;
  790. // draw a splat on taken cities.
  791. for (i=0 ; i<=last ; i++)
  792.     WI_drawOnLnode(i, &splat);
  794. // splat the secret level?
  795. if (wbs->didsecret)
  796.     WI_drawOnLnode(8, &splat);
  798. // draw flashing ptr
  799. if (snl_pointeron)
  800.     WI_drawOnLnode(wbs->next, yah); 
  801.     }
  803.     // draws which level you are entering..
  804.     if ( (gamemode != commercial)
  805.  || wbs->next != 30)
  806. WI_drawEL();  
  808. }
  810. void WI_drawNoState(void)
  811. {
  812.     snl_pointeron = true;
  813.     WI_drawShowNextLoc();
  814. }
  816. int WI_fragSum(int playernum)
  817. {
  818.     int i;
  819.     int frags = 0;
  820.     
  821.     for (i=0 ; i<MAXPLAYERS ; i++)
  822.     {
  823. if (playeringame[i]
  824.     && i!=playernum)
  825. {
  826.     frags += plrs[playernum].frags[i];
  827. }
  828.     }
  831.     // JDC hack - negative frags.
  832.     frags -= plrs[playernum].frags[playernum];
  833.     // UNUSED if (frags < 0)
  834.     //  frags = 0;
  836.     return frags;
  837. }
  841. static int dm_state;
  842. static int dm_frags[MAXPLAYERS][MAXPLAYERS];
  843. static int dm_totals[MAXPLAYERS];
  847. void WI_initDeathmatchStats(void)
  848. {
  850.     int i;
  851.     int j;
  853.     state = StatCount;
  854.     acceleratestage = 0;
  855.     dm_state = 1;
  857.     cnt_pause = TICRATE;
  859.     for (i=0 ; i<MAXPLAYERS ; i++)
  860.     {
  861. if (playeringame[i])
  862. {
  863.     for (j=0 ; j<MAXPLAYERS ; j++)
  864. if (playeringame[j])
  865.     dm_frags[i][j] = 0;
  867.     dm_totals[i] = 0;
  868. }
  869.     }
  870.     
  871.     WI_initAnimatedBack();
  872. }
  876. void WI_updateDeathmatchStats(void)
  877. {
  879.     int i;
  880.     int j;
  881.     
  882.     boolean stillticking;
  884.     WI_updateAnimatedBack();
  886.     if (acceleratestage && dm_state != 4)
  887.     {
  888. acceleratestage = 0;
  890. for (i=0 ; i<MAXPLAYERS ; i++)
  891. {
  892.     if (playeringame[i])
  893.     {
  894. for (j=0 ; j<MAXPLAYERS ; j++)
  895.     if (playeringame[j])
  896. dm_frags[i][j] = plrs[i].frags[j];
  898. dm_totals[i] = WI_fragSum(i);
  899.     }
  900. }
  903. S_StartSound(0, sfx_barexp);
  904. dm_state = 4;
  905.     }
  907.     
  908.     if (dm_state == 2)
  909.     {
  910. if (!(bcnt&3))
  911.     S_StartSound(0, sfx_pistol);
  913. stillticking = false;
  915. for (i=0 ; i<MAXPLAYERS ; i++)
  916. {
  917.     if (playeringame[i])
  918.     {
  919. for (j=0 ; j<MAXPLAYERS ; j++)
  920. {
  921.     if (playeringame[j]
  922. && dm_frags[i][j] != plrs[i].frags[j])
  923.     {
  924. if (plrs[i].frags[j] < 0)
  925.     dm_frags[i][j]--;
  926. else
  927.     dm_frags[i][j]++;
  929. if (dm_frags[i][j] > 99)
  930.     dm_frags[i][j] = 99;
  932. if (dm_frags[i][j] < -99)
  933.     dm_frags[i][j] = -99;
  935. stillticking = true;
  936.     }
  937. }
  938. dm_totals[i] = WI_fragSum(i);
  940. if (dm_totals[i] > 99)
  941.     dm_totals[i] = 99;
  943. if (dm_totals[i] < -99)
  944.     dm_totals[i] = -99;
  945.     }
  946.     
  947. }
  948. if (!stillticking)
  949. {
  950.     S_StartSound(0, sfx_barexp);
  951.     dm_state++;
  952. }
  954.     }
  955.     else if (dm_state == 4)
  956.     {
  957. if (acceleratestage)
  958. {
  959.     S_StartSound(0, sfx_slop);
  961.     if ( gamemode == commercial)
  962. WI_initNoState();
  963.     else
  964. WI_initShowNextLoc();
  965. }
  966.     }
  967.     else if (dm_state & 1)
  968.     {
  969. if (!--cnt_pause)
  970. {
  971.     dm_state++;
  972.     cnt_pause = TICRATE;
  973. }
  974.     }
  975. }
  979. void WI_drawDeathmatchStats(void)
  980. {
  982.     int i;
  983.     int j;
  984.     int x;
  985.     int y;
  986.     int w;
  987.     
  988.     int lh; // line height
  990.     lh = WI_SPACINGY;
  992.     WI_slamBackground();
  993.     
  994.     // draw animated background
  995.     WI_drawAnimatedBack(); 
  996.     WI_drawLF();
  998.     // draw stat titles (top line)
  999.     V_DrawPatch(((SCREENWIDTH-320)/2)+DM_TOTALSX-SHORT(total->width)/2,
  1000. ((SCREENHEIGHT-200)/2)+DM_MATRIXY-WI_SPACINGY+10,
  1001. FB,
  1002. total);
  1003.     
  1004.     V_DrawPatch(((SCREENWIDTH-320)/2)+DM_KILLERSX, ((SCREENHEIGHT-200)/2)+DM_KILLERSY, FB, killers);
  1005.     V_DrawPatch(((SCREENWIDTH-320)/2)+DM_VICTIMSX, ((SCREENHEIGHT-200)/2)+DM_VICTIMSY, FB, victims);
  1007.     // draw P?
  1008.     x = DM_MATRIXX + DM_SPACINGX;
  1009.     y = DM_MATRIXY;
  1011.     for (i=0 ; i<MAXPLAYERS ; i++)
  1012.     {
  1013. if (playeringame[i])
  1014. {
  1015.     V_DrawPatch(((SCREENWIDTH-320)/2)+x-SHORT(p[i]->width)/2,
  1016. ((SCREENHEIGHT-200)/2)+DM_MATRIXY - WI_SPACINGY,
  1017. FB,
  1018. p[i]);
  1019.     
  1020.     V_DrawPatch(((SCREENWIDTH-320)/2)+DM_MATRIXX-SHORT(p[i]->width)/2,
  1021. ((SCREENHEIGHT-200)/2)+y,
  1022. FB,
  1023. p[i]);
  1025.     if (i == me)
  1026.     {
  1027. V_DrawPatch(((SCREENWIDTH-320)/2)+x-SHORT(p[i]->width)/2,
  1028.     ((SCREENHEIGHT-200)/2)+DM_MATRIXY - WI_SPACINGY,
  1029.     FB,
  1030.     bstar);
  1032. V_DrawPatch(((SCREENWIDTH-320)/2)+DM_MATRIXX-SHORT(p[i]->width)/2,
  1033.     ((SCREENHEIGHT-200)/2)+y,
  1034.     FB,
  1035.     star);
  1036.     }
  1037. }
  1038. else
  1039. {
  1040.     // V_DrawPatch(x-SHORT(bp[i]->width)/2,
  1041.     //   DM_MATRIXY - WI_SPACINGY, FB, bp[i]);
  1042.     // V_DrawPatch(DM_MATRIXX-SHORT(bp[i]->width)/2,
  1043.     //   y, FB, bp[i]);
  1044. }
  1045. x += DM_SPACINGX;
  1046. y += WI_SPACINGY;
  1047.     }
  1049.     // draw stats
  1050.     y = DM_MATRIXY+10;
  1051.     w = SHORT(num[0]->width);
  1053.     for (i=0 ; i<MAXPLAYERS ; i++)
  1054.     {
  1055. x = DM_MATRIXX + DM_SPACINGX;
  1057. if (playeringame[i])
  1058. {
  1059.     for (j=0 ; j<MAXPLAYERS ; j++)
  1060.     {
  1061. if (playeringame[j])
  1062.     WI_drawNum(((SCREENWIDTH-320)/2)+x+w, ((SCREENHEIGHT-200)/2)+y, dm_frags[i][j], 2);
  1064. x += DM_SPACINGX;
  1065.     }
  1066.     WI_drawNum(((SCREENWIDTH-320)/2)+DM_TOTALSX+w, ((SCREENHEIGHT-200)/2)+y, dm_totals[i], 2);
  1067. }
  1068. y += WI_SPACINGY;
  1069.     }
  1070. }
  1072. static int cnt_frags[MAXPLAYERS];
  1073. static int dofrags;
  1074. static int ng_state;
  1076. void WI_initNetgameStats(void)
  1077. {
  1079.     int i;
  1081.     state = StatCount;
  1082.     acceleratestage = 0;
  1083.     ng_state = 1;
  1085.     cnt_pause = TICRATE;
  1087.     for (i=0 ; i<MAXPLAYERS ; i++)
  1088.     {
  1089. if (!playeringame[i])
  1090.     continue;
  1092. cnt_kills[i] = cnt_items[i] = cnt_secret[i] = cnt_frags[i] = 0;
  1094. dofrags += WI_fragSum(i);
  1095.     }
  1097.     dofrags = !!dofrags;
  1099.     WI_initAnimatedBack();
  1100. }
  1104. void WI_updateNetgameStats(void)
  1105. {
  1107.     int i;
  1108.     int fsum;
  1109.     
  1110.     boolean stillticking;
  1112.     WI_updateAnimatedBack();
  1114.     if (acceleratestage && ng_state != 10)
  1115.     {
  1116. acceleratestage = 0;
  1118. for (i=0 ; i<MAXPLAYERS ; i++)
  1119. {
  1120.     if (!playeringame[i])
  1121. continue;
  1123.     cnt_kills[i] = (plrs[i].skills * 100) / wbs->maxkills;
  1124.     cnt_items[i] = (plrs[i].sitems * 100) / wbs->maxitems;
  1125.     cnt_secret[i] = (plrs[i].ssecret * 100) / wbs->maxsecret;
  1127.     if (dofrags)
  1128. cnt_frags[i] = WI_fragSum(i);
  1129. }
  1130. S_StartSound(0, sfx_barexp);
  1131. ng_state = 10;
  1132.     }
  1134.     if (ng_state == 2)
  1135.     {
  1136. if (!(bcnt&3))
  1137.     S_StartSound(0, sfx_pistol);
  1139. stillticking = false;
  1141. for (i=0 ; i<MAXPLAYERS ; i++)
  1142. {
  1143.     if (!playeringame[i])
  1144. continue;
  1146.     cnt_kills[i] += 2;
  1148.     if (cnt_kills[i] >= (plrs[i].skills * 100) / wbs->maxkills)
  1149. cnt_kills[i] = (plrs[i].skills * 100) / wbs->maxkills;
  1150.     else
  1151. stillticking = true;
  1152. }
  1154. if (!stillticking)
  1155. {
  1156.     S_StartSound(0, sfx_barexp);
  1157.     ng_state++;
  1158. }
  1159.     }
  1160.     else if (ng_state == 4)
  1161.     {
  1162. if (!(bcnt&3))
  1163.     S_StartSound(0, sfx_pistol);
  1165. stillticking = false;
  1167. for (i=0 ; i<MAXPLAYERS ; i++)
  1168. {
  1169.     if (!playeringame[i])
  1170. continue;
  1172.     cnt_items[i] += 2;
  1173.     if (cnt_items[i] >= (plrs[i].sitems * 100) / wbs->maxitems)
  1174. cnt_items[i] = (plrs[i].sitems * 100) / wbs->maxitems;
  1175.     else
  1176. stillticking = true;
  1177. }
  1178. if (!stillticking)
  1179. {
  1180.     S_StartSound(0, sfx_barexp);
  1181.     ng_state++;
  1182. }
  1183.     }
  1184.     else if (ng_state == 6)
  1185.     {
  1186. if (!(bcnt&3))
  1187.     S_StartSound(0, sfx_pistol);
  1189. stillticking = false;
  1191. for (i=0 ; i<MAXPLAYERS ; i++)
  1192. {
  1193.     if (!playeringame[i])
  1194. continue;
  1196.     cnt_secret[i] += 2;
  1198.     if (cnt_secret[i] >= (plrs[i].ssecret * 100) / wbs->maxsecret)
  1199. cnt_secret[i] = (plrs[i].ssecret * 100) / wbs->maxsecret;
  1200.     else
  1201. stillticking = true;
  1202. }
  1204. if (!stillticking)
  1205. {
  1206.     S_StartSound(0, sfx_barexp);
  1207.     ng_state += 1 + 2*!dofrags;
  1208. }
  1209.     }
  1210.     else if (ng_state == 8)
  1211.     {
  1212. if (!(bcnt&3))
  1213.     S_StartSound(0, sfx_pistol);
  1215. stillticking = false;
  1217. for (i=0 ; i<MAXPLAYERS ; i++)
  1218. {
  1219.     if (!playeringame[i])
  1220. continue;
  1222.     cnt_frags[i] += 1;
  1224.     if (cnt_frags[i] >= (fsum = WI_fragSum(i)))
  1225. cnt_frags[i] = fsum;
  1226.     else
  1227. stillticking = true;
  1228. }
  1230. if (!stillticking)
  1231. {
  1232.     S_StartSound(0, sfx_pldeth);
  1233.     ng_state++;
  1234. }
  1235.     }
  1236.     else if (ng_state == 10)
  1237.     {
  1238. if (acceleratestage)
  1239. {
  1240.     S_StartSound(0, sfx_sgcock);
  1241.     if ( gamemode == commercial )
  1242. WI_initNoState();
  1243.     else
  1244. WI_initShowNextLoc();
  1245. }
  1246.     }
  1247.     else if (ng_state & 1)
  1248.     {
  1249. if (!--cnt_pause)
  1250. {
  1251.     ng_state++;
  1252.     cnt_pause = TICRATE;
  1253. }
  1254.     }
  1255. }
  1259. void WI_drawNetgameStats(void)
  1260. {
  1261.     int i;
  1262.     int x;
  1263.     int y;
  1264.     int pwidth = SHORT(percent->width);
  1266.     WI_slamBackground();
  1267.     
  1268.     // draw animated background
  1269.     WI_drawAnimatedBack(); 
  1271.     WI_drawLF();
  1273.     // draw stat titles (top line)
  1274.     V_DrawPatch(((SCREENWIDTH-320)/2)+NG_STATSX+NG_SPACINGX-SHORT(kills->width),
  1275. ((SCREENHEIGHT-200)/2)+NG_STATSY, FB, kills);
  1277.     V_DrawPatch(((SCREENWIDTH-320)/2)+NG_STATSX+2*NG_SPACINGX-SHORT(items->width),
  1278. ((SCREENHEIGHT-200)/2)+NG_STATSY, FB, items);
  1280.     V_DrawPatch(((SCREENWIDTH-320)/2)+NG_STATSX+3*NG_SPACINGX-SHORT(secret->width),
  1281. ((SCREENHEIGHT-200)/2)+NG_STATSY, FB, secret);
  1282.     
  1283.     if (dofrags)
  1284. V_DrawPatch(((SCREENWIDTH-320)/2)+NG_STATSX+4*NG_SPACINGX-SHORT(frags->width),
  1285.     ((SCREENHEIGHT-200)/2)+NG_STATSY, FB, frags);
  1287.     // draw stats
  1288.     y = ((SCREENHEIGHT-200)/2)+NG_STATSY + SHORT(kills->height);
  1290.     for (i=0 ; i<MAXPLAYERS ; i++)
  1291.     {
  1292. if (!playeringame[i])
  1293.     continue;
  1295. x = ((SCREENWIDTH-320)/2)+NG_STATSX;
  1296. V_DrawPatch(x-SHORT(p[i]->width), y, FB, p[i]);
  1298. if (i == me)
  1299.     V_DrawPatch(x-SHORT(p[i]->width), y, FB, star);
  1301. x += NG_SPACINGX;
  1302. WI_drawPercent(x-pwidth, y+10, cnt_kills[i]); x += NG_SPACINGX;
  1303. WI_drawPercent(x-pwidth, y+10, cnt_items[i]); x += NG_SPACINGX;
  1304. WI_drawPercent(x-pwidth, y+10, cnt_secret[i]); x += NG_SPACINGX;
  1306. if (dofrags)
  1307.     WI_drawNum(x, y+10, cnt_frags[i], -1);
  1309. y += WI_SPACINGY;
  1310.     }
  1312. }
  1314. static int sp_state;
  1316. void WI_initStats(void)
  1317. {
  1318.     state = StatCount;
  1319.     acceleratestage = 0;
  1320.     sp_state = 1;
  1321.     cnt_kills[0] = cnt_items[0] = cnt_secret[0] = -1;
  1322.     cnt_time = cnt_par = -1;
  1323.     cnt_pause = TICRATE;
  1325.     WI_initAnimatedBack();
  1326. }
  1328. void WI_updateStats(void)
  1329. {
  1331.     WI_updateAnimatedBack();
  1333.     if (acceleratestage && sp_state != 10)
  1334.     {
  1335. acceleratestage = 0;
  1336. cnt_kills[0] = (plrs[me].skills * 100) / wbs->maxkills;
  1337. cnt_items[0] = (plrs[me].sitems * 100) / wbs->maxitems;
  1338. cnt_secret[0] = (plrs[me].ssecret * 100) / wbs->maxsecret;
  1339. cnt_time = plrs[me].stime / TICRATE;
  1340. cnt_par = wbs->partime / TICRATE;
  1341. S_StartSound(0, sfx_barexp);
  1342. sp_state = 10;
  1343.     }
  1345.     if (sp_state == 2)
  1346.     {
  1347. cnt_kills[0] += 2;
  1349. if (!(bcnt&3))
  1350.     S_StartSound(0, sfx_pistol);
  1352. if (cnt_kills[0] >= (plrs[me].skills * 100) / wbs->maxkills)
  1353. {
  1354.     cnt_kills[0] = (plrs[me].skills * 100) / wbs->maxkills;
  1355.     S_StartSound(0, sfx_barexp);
  1356.     sp_state++;
  1357. }
  1358.     }
  1359.     else if (sp_state == 4)
  1360.     {
  1361. cnt_items[0] += 2;
  1363. if (!(bcnt&3))
  1364.     S_StartSound(0, sfx_pistol);
  1366. if (cnt_items[0] >= (plrs[me].sitems * 100) / wbs->maxitems)
  1367. {
  1368.     cnt_items[0] = (plrs[me].sitems * 100) / wbs->maxitems;
  1369.     S_StartSound(0, sfx_barexp);
  1370.     sp_state++;
  1371. }
  1372.     }
  1373.     else if (sp_state == 6)
  1374.     {
  1375. cnt_secret[0] += 2;
  1377. if (!(bcnt&3))
  1378.     S_StartSound(0, sfx_pistol);
  1380. if (cnt_secret[0] >= (plrs[me].ssecret * 100) / wbs->maxsecret)
  1381. {
  1382.     cnt_secret[0] = (plrs[me].ssecret * 100) / wbs->maxsecret;
  1383.     S_StartSound(0, sfx_barexp);
  1384.     sp_state++;
  1385. }
  1386.     }
  1388.     else if (sp_state == 8)
  1389.     {
  1390. if (!(bcnt&3))
  1391.     S_StartSound(0, sfx_pistol);
  1393. cnt_time += 3;
  1395. if (cnt_time >= plrs[me].stime / TICRATE)
  1396.     cnt_time = plrs[me].stime / TICRATE;
  1398. cnt_par += 3;
  1400. if (cnt_par >= wbs->partime / TICRATE)
  1401. {
  1402.     cnt_par = wbs->partime / TICRATE;
  1404.     if (cnt_time >= plrs[me].stime / TICRATE)
  1405.     {
  1406. S_StartSound(0, sfx_barexp);
  1407. sp_state++;
  1408.     }
  1409. }
  1410.     }
  1411.     else if (sp_state == 10)
  1412.     {
  1413. if (acceleratestage)
  1414. {
  1415.     S_StartSound(0, sfx_sgcock);
  1417.     if (gamemode == commercial)
  1418. WI_initNoState();
  1419.     else
  1420. WI_initShowNextLoc();
  1421. }
  1422.     }
  1423.     else if (sp_state & 1)
  1424.     {
  1425. if (!--cnt_pause)
  1426. {
  1427.     sp_state++;
  1428.     cnt_pause = TICRATE;
  1429. }
  1430.     }
  1432. }
  1434. void WI_drawStats(void)
  1435. {
  1436.     // line height
  1437.     int lh;
  1439.     lh = (3*SHORT(num[0]->height))/2;
  1441.     WI_slamBackground();
  1443.     // draw animated background
  1444.     WI_drawAnimatedBack();
  1445.     
  1446.     WI_drawLF();
  1448.     V_DrawPatch(((SCREENWIDTH-320)/2)+SP_STATSX, SP_STATSY, FB, kills);
  1449.     WI_drawPercent((SCREENWIDTH-((SCREENWIDTH-320)/2))-SP_STATSX, SP_STATSY, cnt_kills[0]);
  1451.     V_DrawPatch(((SCREENWIDTH-320)/2)+SP_STATSX, SP_STATSY+lh, FB, items);
  1452.     WI_drawPercent((SCREENWIDTH-((SCREENWIDTH-320)/2))-SP_STATSX, SP_STATSY+lh, cnt_items[0]);
  1454.     V_DrawPatch(((SCREENWIDTH-320)/2)+SP_STATSX, SP_STATSY+2*lh, FB, sp_secret);
  1455.     WI_drawPercent((SCREENWIDTH-((SCREENWIDTH-320)/2))-SP_STATSX, SP_STATSY+2*lh, cnt_secret[0]);
  1457.     V_DrawPatch(((SCREENWIDTH-320)/2)+SP_TIMEX, SP_TIMEY, FB, time);
  1458.     WI_drawTime(((SCREENWIDTH-320)/2)+160-SP_TIMEX, SP_TIMEY, cnt_time);
  1460.     if (wbs->epsd < 3)
  1461.     {
  1462. V_DrawPatch(((SCREENWIDTH-320)/2)+160+SP_TIMEX, SP_TIMEY, FB, par);
  1463. WI_drawTime((SCREENWIDTH-((SCREENWIDTH-320)/2))-SP_TIMEX, SP_TIMEY, cnt_par);
  1464.     }
  1466. }
  1468. void WI_checkForAccelerate(void)
  1469. {
  1470.     int   i;
  1471.     player_t  *player;
  1473.     // check for button presses to skip delays
  1474.     for (i=0, player = players ; i<MAXPLAYERS ; i++, player++)
  1475.     {
  1476. if (playeringame[i])
  1477. {
  1478.     if (player->cmd.buttons & BT_ATTACK)
  1479.     {
  1480. if (!player->attackdown)
  1481.     acceleratestage = 1;
  1482. player->attackdown = true;
  1483.     }
  1484.     else
  1485. player->attackdown = false;
  1486.     if (player->cmd.buttons & BT_USE)
  1487.     {
  1488. if (!player->usedown)
  1489.     acceleratestage = 1;
  1490. player->usedown = true;
  1491.     }
  1492.     else
  1493. player->usedown = false;
  1494. }
  1495.     }
  1496. }
  1500. // Updates stuff each tick
  1501. void WI_Ticker(void)
  1502. {
  1503.     // counter for general background animation
  1504.     bcnt++;  
  1506.     if (bcnt == 1)
  1507.     {
  1508. // intermission music
  1509.    if ( gamemode == commercial )
  1510.   S_ChangeMusic(mus_dm2int, true);
  1511. else
  1512.   S_ChangeMusic(mus_inter, true); 
  1513.     }
  1515.     WI_checkForAccelerate();
  1517.     switch (state)
  1518.     {
  1519.       case StatCount:
  1520. if (deathmatch) WI_updateDeathmatchStats();
  1521. else if (netgame) WI_updateNetgameStats();
  1522. else WI_updateStats();
  1523. break;
  1525.       case ShowNextLoc:
  1526. WI_updateShowNextLoc();
  1527. break;
  1529.       case NoState:
  1530. WI_updateNoState();
  1531. break;
  1532.     }
  1534. }
  1536. void WI_loadData(void)
  1537. {
  1538.     int i;
  1539.     int j;
  1540.     char name[9];
  1541.     anim_t* a;
  1543.     if (gamemode == commercial)
  1544. strcpy(name, "INTERPIC");
  1545.     else 
  1546. sprintf(name, "WIMAP%d", wbs->epsd);
  1547.     
  1548.     if ( gamemode == retail )
  1549.     {
  1550.       if (wbs->epsd == 3)
  1551. strcpy(name,"INTERPIC");
  1552.     }
  1554.     // background
  1555.     bg = W_CacheLumpName(name, PU_CACHE);    
  1556.     V_DrawPatch(((SCREENWIDTH-320)/2)+0, ((SCREENHEIGHT-200)/2)+0, 1, bg);
  1559.     // UNUSED unsigned char *pic = screens[1];
  1560.     // if (gamemode == commercial)
  1561.     // {
  1562.     // darken the background image
  1563.     // while (pic != screens[1] + SCREENHEIGHT*SCREENWIDTH)
  1564.     // {
  1565.     //   *pic = colormaps[256*25 + *pic];
  1566.     //   pic++;
  1567.     // }
  1568.     //}
  1570.     if (gamemode == commercial)
  1571.     {
  1572. NUMCMAPS = 32;
  1573. lnames = (patch_t **) Z_Malloc(sizeof(patch_t*) * NUMCMAPS,
  1574.        PU_STATIC, 0);
  1575. for (i=0 ; i<NUMCMAPS ; i++)
  1576. {
  1577.     sprintf(name, "CWILV%2.2d", i);
  1578.     lnames[i] = W_CacheLumpName(name, PU_STATIC);
  1579. }
  1580.     }
  1581.     else
  1582.     {
  1583. lnames = (patch_t **) Z_Malloc(sizeof(patch_t*) * NUMMAPS,
  1584.        PU_STATIC, 0);
  1585. for (i=0 ; i<NUMMAPS ; i++)
  1586. {
  1587.     sprintf(name, "WILV%d%d", wbs->epsd, i);
  1588.     lnames[i] = W_CacheLumpName(name, PU_STATIC);
  1589. }
  1591. // you are here
  1592. yah[0] = W_CacheLumpName("WIURH0", PU_STATIC);
  1594. // you are here (alt.)
  1595. yah[1] = W_CacheLumpName("WIURH1", PU_STATIC);
  1597. // splat
  1598. splat = W_CacheLumpName("WISPLAT", PU_STATIC); 
  1600. if (wbs->epsd < 3)
  1601. {
  1602.     for (j=0;j<NUMANIMS[wbs->epsd];j++)
  1603.     {
  1604. a = &anims[wbs->epsd][j];
  1605. for (i=0;i<a->nanims;i++)
  1606. {
  1607.     // MONDO HACK!
  1608.     if (wbs->epsd != 1 || j != 8) 
  1609.     {
  1610. // animations
  1611. sprintf(name, "WIA%d%.2d%.2d", wbs->epsd, j, i);  
  1612. a->p[i] = W_CacheLumpName(name, PU_STATIC);
  1613.     }
  1614.     else
  1615.     {
  1616. // HACK ALERT!
  1617. a->p[i] = anims[1][4].p[i]; 
  1618.     }
  1619. }
  1620.     }
  1621. }
  1622.     }
  1624.     // More hacks on minus sign.
  1625.     wiminus = W_CacheLumpName("WIMINUS", PU_STATIC); 
  1627.     for (i=0;i<10;i++)
  1628.     {
  1629.  // numbers 0-9
  1630. sprintf(name, "WINUM%d", i);     
  1631. num[i] = W_CacheLumpName(name, PU_STATIC);
  1632.     }
  1634.     // percent sign
  1635.     percent = W_CacheLumpName("WIPCNT", PU_STATIC);
  1637.     // "finished"
  1638.     finished = W_CacheLumpName("WIF", PU_STATIC);
  1640.     // "entering"
  1641.     entering = W_CacheLumpName("WIENTER", PU_STATIC);
  1643.     // "kills"
  1644.     kills = W_CacheLumpName("WIOSTK", PU_STATIC);   
  1646.     // "scrt"
  1647.     secret = W_CacheLumpName("WIOSTS", PU_STATIC);
  1649.      // "secret"
  1650.     sp_secret = W_CacheLumpName("WISCRT2", PU_STATIC);
  1652.     // Yuck. 
  1653.     if (language == french)
  1654.     {
  1655. // "items"
  1656. if (netgame && !deathmatch)
  1657.     items = W_CacheLumpName("WIOBJ", PU_STATIC);    
  1658.    else
  1659.     items = W_CacheLumpName("WIOSTI", PU_STATIC);
  1660.     } else
  1661. items = W_CacheLumpName("WIOSTI", PU_STATIC);
  1663.     // "frgs"
  1664.     frags = W_CacheLumpName("WIFRGS", PU_STATIC);    
  1666.     // ":"
  1667.     colon = W_CacheLumpName("WICOLON", PU_STATIC); 
  1669.     // "time"
  1670.     time = W_CacheLumpName("WITIME", PU_STATIC);   
  1672.     // "sucks"
  1673.     sucks = W_CacheLumpName("WISUCKS", PU_STATIC);  
  1675.     // "par"
  1676.     par = W_CacheLumpName("WIPAR", PU_STATIC);   
  1678.     // "killers" (vertical)
  1679.     killers = W_CacheLumpName("WIKILRS", PU_STATIC);
  1681.     // "victims" (horiz)
  1682.     victims = W_CacheLumpName("WIVCTMS", PU_STATIC);
  1684.     // "total"
  1685.     total = W_CacheLumpName("WIMSTT", PU_STATIC);   
  1687.     // your face
  1688.     star = W_CacheLumpName("STFST01", PU_STATIC);
  1690.     // dead face
  1691.     bstar = W_CacheLumpName("STFDEAD0", PU_STATIC);    
  1693.     for (i=0 ; i<MAXPLAYERS ; i++)
  1694.     {
  1695. // "1,2,3,4"
  1696. sprintf(name, "STPB%d", i);      
  1697. p[i] = W_CacheLumpName(name, PU_STATIC);
  1699. // "1,2,3,4"
  1700. sprintf(name, "WIBP%d", i+1);     
  1701. bp[i] = W_CacheLumpName(name, PU_STATIC);
  1702.     }
  1704. }
  1706. void WI_unloadData(void)
  1707. {
  1708.     int i;
  1709.     int j;
  1711.     Z_ChangeTag(wiminus, PU_CACHE);
  1713.     for (i=0 ; i<10 ; i++)
  1714. Z_ChangeTag(num[i], PU_CACHE);
  1715.     
  1716.     if (gamemode == commercial)
  1717.     {
  1718.    for (i=0 ; i<NUMCMAPS ; i++)
  1719.     Z_ChangeTag(lnames[i], PU_CACHE);
  1720.     }
  1721.     else
  1722.     {
  1723. Z_ChangeTag(yah[0], PU_CACHE);
  1724. Z_ChangeTag(yah[1], PU_CACHE);
  1726. Z_ChangeTag(splat, PU_CACHE);
  1728. for (i=0 ; i<NUMMAPS ; i++)
  1729.     Z_ChangeTag(lnames[i], PU_CACHE);
  1731. if (wbs->epsd < 3)
  1732. {
  1733.     for (j=0;j<NUMANIMS[wbs->epsd];j++)
  1734.     {
  1735. if (wbs->epsd != 1 || j != 8)
  1736.     for (i=0;i<anims[wbs->epsd][j].nanims;i++)
  1737. Z_ChangeTag(anims[wbs->epsd][j].p[i], PU_CACHE);
  1738.     }
  1739. }
  1740.     }
  1741.     
  1742.     Z_Free(lnames);
  1744.     Z_ChangeTag(percent, PU_CACHE);
  1745.     Z_ChangeTag(colon, PU_CACHE);
  1746.     Z_ChangeTag(finished, PU_CACHE);
  1747.     Z_ChangeTag(entering, PU_CACHE);
  1748.     Z_ChangeTag(kills, PU_CACHE);
  1749.     Z_ChangeTag(secret, PU_CACHE);
  1750.     Z_ChangeTag(sp_secret, PU_CACHE);
  1751.     Z_ChangeTag(items, PU_CACHE);
  1752.     Z_ChangeTag(frags, PU_CACHE);
  1753.     Z_ChangeTag(time, PU_CACHE);
  1754.     Z_ChangeTag(sucks, PU_CACHE);
  1755.     Z_ChangeTag(par, PU_CACHE);
  1757.     Z_ChangeTag(victims, PU_CACHE);
  1758.     Z_ChangeTag(killers, PU_CACHE);
  1759.     Z_ChangeTag(total, PU_CACHE);
  1760.     //  Z_ChangeTag(star, PU_CACHE);
  1761.     //  Z_ChangeTag(bstar, PU_CACHE);
  1762.     
  1763.     for (i=0 ; i<MAXPLAYERS ; i++)
  1764. Z_ChangeTag(p[i], PU_CACHE);
  1766.     for (i=0 ; i<MAXPLAYERS ; i++)
  1767. Z_ChangeTag(bp[i], PU_CACHE);
  1768. }
  1770. void WI_Drawer (void)
  1771. {
  1772.     switch (state)
  1773.     {
  1774.       case StatCount:
  1775. if (deathmatch)
  1776.     WI_drawDeathmatchStats();
  1777. else if (netgame)
  1778.     WI_drawNetgameStats();
  1779. else
  1780.     WI_drawStats();
  1781. break;
  1783.       case ShowNextLoc:
  1784. WI_drawShowNextLoc();
  1785. break;
  1787.       case NoState:
  1788. WI_drawNoState();
  1789. break;
  1790.     }
  1791. }
  1794. void WI_initVariables(wbstartstruct_t* wbstartstruct)
  1795. {
  1797.     wbs = wbstartstruct;
  1799. #ifdef RANGECHECKING
  1800.     if (gamemode != commercial)
  1801.     {
  1802.       if ( gamemode == retail )
  1803. RNGCHECK(wbs->epsd, 0, 3);
  1804.       else
  1805. RNGCHECK(wbs->epsd, 0, 2);
  1806.     }
  1807.     else
  1808.     {
  1809. RNGCHECK(wbs->last, 0, 8);
  1810. RNGCHECK(wbs->next, 0, 8);
  1811.     }
  1812.     RNGCHECK(wbs->pnum, 0, MAXPLAYERS);
  1813.     RNGCHECK(wbs->pnum, 0, MAXPLAYERS);
  1814. #endif
  1816.     acceleratestage = 0;
  1817.     cnt = bcnt = 0;
  1818.     firstrefresh = 1;
  1819.     me = wbs->pnum;
  1820.     plrs = wbs->plyr;
  1822.     if (!wbs->maxkills)
  1823. wbs->maxkills = 1;
  1825.     if (!wbs->maxitems)
  1826. wbs->maxitems = 1;
  1828.     if (!wbs->maxsecret)
  1829. wbs->maxsecret = 1;
  1831.     if ( gamemode != retail )
  1832.       if (wbs->epsd > 2)
  1833. wbs->epsd -= 3;
  1834. }
  1836. void WI_Start(wbstartstruct_t* wbstartstruct)
  1837. {
  1839.     WI_initVariables(wbstartstruct);
  1840.     WI_loadData();
  1842.     if (deathmatch)
  1843. WI_initDeathmatchStats();
  1844.     else if (netgame)
  1845. WI_initNetgameStats();
  1846.     else
  1847. WI_initStats();
  1848. }