src/soft/render.c

   1 #include <string.h>
   2 #include <stdarg.h>
   3 #include <stdlib.h> // abs()
   4 #include <assert.h>
   5 #include "glob.h"
   6 #include "render.h"
   7 #include "view.h"
   8 #include "player.h"
   9 #include "switch.h"
  10 #include "vga.h"
  11 #include "menu.h"
  12 #include "misc.h"
  13 #include "dots.h"
  14 #include "items.h"
  15 #include "monster.h"
  16 #include "weapons.h"
  17 #include "smoke.h"
  18 #include "fx.h"
  19 #include "memory.h"
  20 #include "files.h"
  21 #include "error.h"
  22 #include "game.h"
  23 #include "sound.h"
  24 #include "music.h"
  25 #include "system.h"
  26
  27 #include "cp866.h"
  28
  29 // game
  30 static vgaimg *scrnh[3]; // TITLEPIC INTERPIC ENDPIC
  31 static vgaimg *ltn[2][2];
  32 static void *cd_scr;
  33 // smoke
  34 static vgaimg *smk_spr[SMSN];
  35 static vgaimg *smk_fspr[FLSN];
  36 // fx
  37 static vgaimg *fx_spr[15];
  38 static char fx_sprd[15];
  39 // weapons
  40 static vgaimg *wp_spr[49*2];
  41 static char wp_sprd[49*2];
  42 // items
  43 static vgaimg *item_spr[58];
  44 static char item_sprd[58];
  45 // player
  46 static vgaimg *plr_spr[27*2];
  47 static char plr_sprd[27*2];
  48 static vgaimg *plr_wpn[11][6];
  49 // monsters
  50 static vgaimg *pl_spr[2];
  51 static vgaimg *mn_spr[MN_TN][29*2];
  52 static char mn_sprd[MN_TN][29*2];
  53 static vgaimg *mn_fspr[8];
  54 static vgaimg *mn_sgun[2];
  55 // misc
  56 #define MAXAIR 1091
  57 static vgaimg *sth[22], *bfh[160 - '!'], *sfh[160 - '!'], *stone, *stone2, *keys[3];
  58 static int prx = 0, pry = 0;
  59 // menu
  60 static vgaimg *msklh[2], *mbarl, *mbarm, *mbarr, *mbaro, *mslotl, *mslotm, *mslotr;
  61 // low level
  62 static int gammaa = 0;
  63 static char main_pal[256][3];
  64 static char std_pal[256][3];
  65 static byte gamcor[5][64]={
  66   #include "gamma.dat"
  67 };
  68 // walls
  69 #define ANIT 5
  70 static int WD, HT;
  71 static int w_o, w_x, w_y;
  72 static vgaimg *walp[256];
  73 static int walh[256];
  74 static byte walani[256];
  75 static byte walswp[256];
  76 static int anih[ANIT][5];
  77 static byte anic[ANIT];
  78 static int max_textures;
  79 static byte w_horiz = 1;
  80 static vgaimg *horiz;
  81
  82 static int init_screen_width = 0;
  83 static int init_screen_height = 0;
  84 static byte init_screen_full = 0xFF;
  85 static int init_screen_gammaa = -1;
  86
  87 /* --- misc --- */
  88
  89 static void *Z_getspr (char n[4], int s, int d, char *dir) {
  90   int h = F_getsprid(n, s, d, dir);
  91   return V_getvgaimg(h);
  92 }
  93
  94 static vgaimg *Z_get_char_image (vgaimg **img, int ch) {
  95   ch = cp866_toupper(ch);
  96   return ch > 32 && ch < 160 ? img[ch - '!'] : NULL;
  97 }
  98
  99 static int Z_get_char_width_generic (vgaimg **img, int off, int ch) {
 100   vgaimg *p = Z_get_char_image(img, ch);
 101   return p == NULL ? off : p->w - 1;
 102 }
 103
 104 static int Z_putch_generic (vgaimg **img, int off, int ch) {
 105   vgaimg *p = Z_get_char_image(img, ch);
 106   int w = p == NULL ? off : p->w - 1;
 107   if (p != NULL) {
 108     V_spr(prx, pry, p);
 109   }
 110   prx += w;
 111   return w;
 112 }
 113
 114 static int Z_get_string_width_generic (vgaimg **img, int off, const char *fmt, va_list ap) {
 115   int i, w, ww;
 116   char buf[80];
 117   vsprintf(buf, fmt, ap);
 118   for (i = w = ww = 0; buf[i]; ++i) {
 119     switch (buf[i]) {
 120       case '\n':
 121       case '\r':
 122         ww = max(w, ww);
 123         w = 0;
 124         break;
 125       default:
 126         w += Z_get_char_width_generic(img, off, (byte)buf[i]);
 127     }
 128   }
 129   return max(w, ww);
 130 }
 131
 132 static int Z_printf_generic (vgaimg **img, int off, const char *fmt, va_list ap) {
 133   int i, w, ww;
 134   char buf[80];
 135   vsprintf(buf, fmt, ap);
 136   for (i = w = ww = 0; buf[i]; ++i) {
 137     switch (buf[i]) {
 138       case '\n':
 139         pry += off + 1;
 140       case '\r':
 141         w = max(w, ww);
 142         prx = 0;
 143         w = 0;
 144         break;
 145       default:
 146         w += Z_putch_generic(img, off, (byte)buf[i]);
 147     }
 148   }
 149   return w;
 150 }
 151
 152 static void Z_gotoxy (int x, int y) {
 153   prx = x;
 154   pry = y;
 155 }
 156
 157 static int Z_get_big_string_width (const char *fmt, ...) {
 158   va_list a;
 159   va_start(a, fmt);
 160   int w = Z_get_string_width_generic(bfh, 12, fmt, a);
 161   va_end(a);
 162   return w;
 163 }
 164
 165 static int Z_printbf (const char *fmt, ...) {
 166   va_list a;
 167   va_start(a, fmt);
 168   int w = Z_printf_generic(bfh, 12, fmt, a);
 169   va_end(a);
 170   return w;
 171 }
 172
 173 static int Z_get_small_string_width (const char *fmt, ...) {
 174   va_list a;
 175   va_start(a, fmt);
 176   int w = Z_get_string_width_generic(sfh, 7, fmt, a);
 177   va_end(a);
 178   return w;
 179 }
 180
 181 static int Z_printsf (const char *fmt, ...) {
 182   va_list a;
 183   va_start(a, fmt);
 184   int w =Z_printf_generic(sfh, 7, fmt, a);
 185   va_end(a);
 186   return w;
 187 }
 188
 189 static void Z_drawspr (int x, int y, void *p, char d) {
 190   if (d) {
 191     V_spr2(x - w_x + WD / 2, y - w_y + HT / 2 + 1 + w_o, p);
 192   } else {
 193     V_spr(x - w_x + WD / 2, y - w_y + HT / 2 + 1 + w_o, p);
 194   }
 195 }
 196
 197 static void Z_clrst (void) {
 198   V_pic(SCRW - 120, w_o, stone);
 199   int y = ((vgaimg*)stone)->h;
 200   while (y < HT) {
 201     V_pic(SCRW - 120, w_o + y, stone2);
 202     y += ((vgaimg*)stone)->h;
 203   }
 204 }
 205
 206 static void Z_drawstlives (char n) {
 207   V_setrect(SCRW - 40, 30, w_o, 40);
 208   V_spr(SCRW - 35, w_o + 17, sth[n]);
 209 }
 210
 211 static void Z_drawstkeys (byte k) {
 212   int x, n;
 213   V_setrect(SCRW - 120, 70, w_o + 77, 23);
 214   for (k >>= 4, n = 0, x = SCRW - 75; n < 3; ++n, k >>= 1, x += 9) {
 215     if (k & 1) {
 216       V_spr(x, w_o + 91, keys[n]);
 217     }
 218   }
 219 }
 220
 221 static void Z_drawstair (int a) {
 222   V_setrect(SCRW - 120, 120, w_o + 49, 2);
 223   if (a > 0) {
 224     if (a > MAXAIR) {
 225       a = MAXAIR;
 226     }
 227     a = a * 100 / MAXAIR;
 228     V_clr(SCRW - 110, a, w_o + 49, 2, 0xC8);
 229   }
 230 }
 231
 232 static void Z_drawstprcnt (int y, int n) {
 233   char s[20];
 234   int l, i, x, c;
 235   V_setrect(SCRW - 120, 70, y * 19 + 7 + w_o, 19);
 236   sprintf(s, "%3d%%", n);
 237   l = strlen(s);
 238   x = SCRW - 110;
 239   for (i = 0; i < l; ++i, x += 14) {
 240     if (s[i] >='0' && s[i] <= '9') {
 241       c = s[i] - '0';
 242     } else if (s[i] == '-') {
 243       c = 10;
 244     } else if (s[i] == '%') {
 245       c = 11;
 246     } else {
 247       c = -1;
 248     }
 249     if (c >= 0) {
 250       V_spr(x, y * 19 + 7 + w_o, sth[c]);
 251     }
 252   }
 253 }
 254
 255 static void Z_drawstnum (int n) {
 256   char s[20];
 257   int l, i, x, c;
 258   V_setrect(SCRW - 50, 50, w_o + 77, 23);
 259   if (g_dm) {
 260     sprintf(s, "%d", n);
 261     l = strlen(s);
 262     x = (115 - l * 14) + SCRW - 120;
 263     for (i = 0; i < l; ++i, x += 14) {
 264       if (s[i] >= '0' && s[i] <= '9') {
 265         c = s[i] - '0';
 266       } else if (s[i] == '-') {
 267         c = 10;
 268       } else if(s[i] == '%') {
 269         c = 11;
 270       } else {
 271         c =- 1;
 272       }
 273       if (c >= 0) {
 274         V_spr(x, w_o + 77 + 5, sth[c]);
 275       }
 276     }
 277   }
 278 }
 279
 280 static void Z_drawstwpn (int n, int a) {
 281   char s[20];
 282   int l, i, x, c;
 283   i = n;
 284   V_setrect(SCRW - 120, 120, w_o + 58, 23);
 285   if (i >= 0) {
 286     V_spr(SCRW - 88, w_o + 58 + 19, sth[i + 12]);
 287   }
 288   if (n >= 2) {
 289     sprintf(s, "%d", a);
 290     l = strlen(s);
 291     x = SCRW - 10 - l * 14;
 292     for (i = 0; i < l; ++i, x += 14) {
 293       if (s[i] >= '0' && s[i] <= '9') {
 294         c = s[i] - '0';
 295       } else if (s[i] == '-') {
 296         c = 10;
 297       } else if (s[i] == '%') {
 298         c = 11;
 299       } else {
 300         c = -1;
 301       }
 302       if (c >= 0) {
 303         V_spr(x, w_o + 58 + 2, sth[c]);
 304       }
 305     }
 306   }
 307 }
 308
 309 static void Z_drawmanspr (int x, int y, void *p, char d, byte color) {
 310   if (d) {
 311     V_manspr2(x - w_x + WD / 2, y - w_y + HT / 2 + 1 + w_o, p, color);
 312   } else {
 313     V_manspr(x - w_x + WD / 2, y - w_y + HT / 2 + 1 + w_o, p, color);
 314   }
 315 }
 316
 317 static void Z_drawfld (byte *fld, int bg) {
 318     byte *p = fld;
 319     int x, y;
 320     for (y = 0; y < FLDH; y++) {
 321         for (x = 0; x < FLDW; x++) {
 322             int sx = x * CELW - w_x + WD / 2;
 323             int sy = y * CELH - w_y + HT / 2 + 1 + w_o;
 324             int id = *p;
 325             if (id) {
 326               //intptr_t spc = (intptr_t) walp[id];
 327               int spc = R_get_special_id(id);
 328               if (spc >= 0 && spc <= 3) {
 329                 if (!bg) {
 330                   byte *cmap = clrmap + (spc + 7) * 256;
 331                   V_remap_rect(sx, sy, CELW, CELH, cmap);
 332                 }
 333               } else {
 334                 V_pic(sx, sy, walp[id]);
 335               }
 336             }
 337             p++;
 338         }
 339     }
 340 }
 341
 342 /* --- menu --- */
 343
 344 static int gm_tm = 0; // ???
 345
 346 #define SCROLLER_MIDDLE 10
 347 #define TEXTFIELD_MIDDLE 2
 348
 349 static void get_entry_size (const menu_t *m, int i, int *w, int *h) {
 350   assert(m != NULL);
 351   assert(i >= 0);
 352   assert(w != NULL);
 353   assert(h != NULL);
 354   int x = 0;
 355   int y = 0;
 356   int type = 0;
 357   menu_msg_t msg;
 358   msg.type = GM_GETENTRY;
 359   if (GM_send(m, i, &msg)) {
 360     type = msg.integer.i;
 361     switch (type) {
 362       case GM_BUTTON:
 363       case GM_SCROLLER:
 364       case GM_TEXTFIELD:
 365       case GM_TEXTFIELD_BUTTON:
 366         msg.type = GM_GETCAPTION;
 367         if (GM_send(m, i, &msg)) {
 368           x = Z_get_big_string_width("%.*s", msg.string.maxlen, msg.string.s);
 369         }
 370         break;
 371       case GM_SMALL_BUTTON:
 372         msg.type = GM_GETCAPTION;
 373         if (GM_send(m, i, &msg)) {
 374           x = Z_get_small_string_width("%.*s", msg.string.maxlen, msg.string.s);
 375         }
 376         break;
 377       default:
 378         assert(0);
 379     }
 380     switch (type) {
 381       case GM_BUTTON:
 382         msg.type = GM_GETSTR;
 383         if (GM_send(m, i, &msg)) {
 384           x += Z_get_big_string_width("%.*s", msg.string.maxlen, msg.string.s);
 385         }
 386         y = 16;
 387         break;
 388       case GM_SMALL_BUTTON:
 389         msg.type = GM_GETSTR;
 390         if (GM_send(m, i, &msg)) {
 391           x += Z_get_big_string_width("%.*s", msg.string.maxlen, msg.string.s);
 392         }
 393         y = 12;
 394         break;
 395       case GM_SCROLLER:
 396         x += (SCROLLER_MIDDLE + 2) * 8;
 397         y = 16;
 398         break;
 399       case GM_TEXTFIELD:
 400       case GM_TEXTFIELD_BUTTON:
 401         msg.type = GM_GETSTR;
 402         if (GM_send(m, i, &msg)) {
 403           x += (msg.string.maxlen + 2) * 8;
 404         } else {
 405           x += (TEXTFIELD_MIDDLE + 2) * 8;
 406         }
 407         y = 16;
 408         break;
 409       default:
 410         assert(0);
 411     }
 412   }
 413   *w = x;
 414   *h = y;
 415 }
 416
 417 static void get_menu_size (const menu_t *m, int *w, int *h) {
 418   assert(m != NULL);
 419   assert(w != NULL);
 420   assert(h != NULL);
 421   int i, n, x, y, xx, yy, type;
 422   menu_msg_t msg;
 423   msg.type = GM_QUERY;
 424   if (GM_send_this(m, &msg)) {
 425     n = msg.integer.b;
 426     type = msg.integer.s;
 427     x = 0;
 428     y = 0;
 429     msg.type = GM_GETTITLE;
 430     if (GM_send_this(m, &msg)) {
 431       switch (type) {
 432         case GM_BIG: x = Z_get_big_string_width("%.*s", msg.string.maxlen, msg.string.s); break;
 433         case GM_SMALL: x = Z_get_small_string_width("%.*s", msg.string.maxlen, msg.string.s); break;
 434         default: assert(0);
 435       }
 436     }
 437     for (i = 0; i < n; i++) {
 438       get_entry_size(m, i, &xx, &yy);
 439       x = max(x, xx);
 440       y += yy;
 441     }
 442     *w = x;
 443     *h = y;
 444   } else {
 445     *w = 0;
 446     *h = 0;
 447   }
 448 }
 449
 450 static int GM_draw (void) {
 451   int i, j, n, x, y, xoff, yoff, cur, w, type, recv;
 452   const menu_t *m = GM_get();
 453   menu_msg_t msg;
 454   if (m != NULL) {
 455     get_menu_size(m, &x, &y);
 456     x = SCRW / 2 - x / 2;
 457     y = SCRH / 2 - y / 2;
 458     // --- title ---
 459     msg.type = GM_QUERY;
 460     if (GM_send_this(m, &msg)) {
 461       cur = msg.integer.i;
 462       n = msg.integer.a;
 463       type = msg.integer.s;
 464       msg.type = GM_GETTITLE;
 465       if (GM_send_this(m, &msg)) {
 466         Z_gotoxy(x, y - 10);
 467         switch (type) {
 468           case GM_SMALL: yoff = 8; Z_printsf("%.*s", msg.string.maxlen, msg.string.s); break;
 469           case GM_BIG: yoff = 20; Z_printbf("%.*s", msg.string.maxlen, msg.string.s); break;
 470           default: assert(0);
 471         }
 472       } else {
 473         yoff = 0;
 474       }
 475       for (i = 0; i < n; i++) {
 476         msg.type = GM_GETENTRY;
 477         if (GM_send(m, i, &msg)) {
 478           type = msg.integer.i;
 479           if (i == cur) {
 480             if (type == GM_SMALL_BUTTON) {
 481               Z_gotoxy(x - 8, y + yoff);
 482               Z_printsf(">");
 483             } else {
 484               V_spr(x - 25, y + yoff - 8, msklh[(gm_tm / 6) & 1]);
 485             }
 486           }
 487           msg.type = GM_GETCAPTION;
 488           if (GM_send(m, i, &msg)) {
 489             Z_gotoxy(x, y + yoff);
 490             if (type == GM_SMALL_BUTTON) {
 491               xoff = Z_printsf("%.*s", msg.string.maxlen, msg.string.s);
 492             } else {
 493               xoff = Z_printbf("%.*s", msg.string.maxlen, msg.string.s);
 494             }
 495           } else {
 496             xoff = 0;
 497           }
 498           switch (type) {
 499             case GM_BUTTON:
 500             case GM_SMALL_BUTTON:
 501               msg.type = GM_GETSTR;
 502               if (GM_send(m, i, &msg)) {
 503                 Z_gotoxy(x + xoff, y + yoff);
 504                 if (type == GM_SMALL_BUTTON) {
 505                   Z_printsf("%.*s", msg.string.maxlen, msg.string.s);
 506                 } else {
 507                   Z_printbf("%.*s", msg.string.maxlen, msg.string.s);
 508                 }
 509               }
 510               yoff += type == GM_BUTTON ? 16 : 12;
 511               break;
 512             case GM_TEXTFIELD:
 513             case GM_TEXTFIELD_BUTTON:
 514               yoff += 9;
 515               msg.type = GM_GETSTR;
 516               recv = GM_send(m, i, &msg);
 517               w = recv ? msg.string.maxlen : TEXTFIELD_MIDDLE;
 518               V_spr(x + xoff, y + yoff, mslotl);
 519               for (j = 1; j <= w; j++) {
 520                 V_spr(x + xoff + j * 8, y + yoff, mslotm);
 521               }
 522               V_spr(x + xoff + j * 8, y + yoff, mslotr);
 523               Z_gotoxy(x + xoff + 4, y + yoff - 7);
 524               if (input && i == cur) {
 525                 Z_printsf("%.*s_", imax, ibuf);
 526               } else if (recv) {
 527                 Z_printsf("%.*s", msg.string.maxlen, msg.string.s);
 528               }
 529               yoff += 7;
 530               break;
 531             case GM_SCROLLER:
 532               V_spr(x + xoff, y + yoff, mbarl);
 533               for (j = 1; j < SCROLLER_MIDDLE; j++) {
 534                 V_spr(x + xoff + j * 8, y + yoff, mbarm);
 535               }
 536               V_spr(x + xoff + j * 8, y + yoff, mbarr);
 537               msg.type = GM_GETINT;
 538               if (GM_send(m, i, &msg)) {
 539                 int lev = (msg.integer.i - msg.integer.a) * ((SCROLLER_MIDDLE - 2) * 8) / msg.integer.b;
 540                 V_spr(x + xoff + lev + 8, y + yoff, mbaro);
 541               }
 542               yoff += 16;
 543               break;
 544             default:
 545               assert(0);
 546           }
 547         }
 548       }
 549     }
 550   }
 551   return m != NULL;
 552 }
 553
 554 /* --- dots --- */
 555
 556 static void DOT_draw (void) {
 557   int i;
 558   for (i = 0; i < MAXDOT; i++) {
 559     if (dot[i].t) {
 560       V_dot(dot[i].o.x - w_x + WD / 2, dot[i].o.y - w_y + HT / 2 + 1 + w_o, dot[i].c);
 561     }
 562   }
 563 }
 564
 565 /* --- items --- */
 566
 567 static void IT_draw (void) {
 568   int i, s;
 569   for (i = 0; i < MAXITEM; ++i) {
 570     s = -1;
 571     if (it[i].t && it[i].s >= 0) {
 572       switch(it[i].t & 0x7FFF) {
 573         case I_ARM1:
 574           s = it[i].s / 9 + 18;
 575           break;
 576         case I_ARM2:
 577           s = it[i].s / 9 + 20;
 578           break;
 579         case I_MEGA:
 580           s = it[i].s / 2 + 22;
 581           break;
 582         case I_INVL:
 583           s = it[i].s / 2 + 26;
 584           break;
 585         case I_SUPER:
 586         case I_RTORCH:
 587         case I_GTORCH:
 588         case I_BTORCH:
 589           s = it[i].s / 2 + (it[i].t - I_SUPER) * 4 + 35;
 590           break;
 591         case I_GOR1: case I_FCAN:
 592           s = it[i].s / 2 + (it[i].t - I_GOR1) * 3 + 51;
 593           break;
 594         case I_AQUA:
 595           s = 30;
 596           break;
 597         case I_SUIT:
 598           s = 34;
 599           break;
 600         case I_KEYR:
 601         case I_KEYG:
 602         case I_KEYB:
 603           s = (it[i].t & 0x7FFF) - I_KEYR + 31;
 604           break;
 605         case I_GUN2:
 606           s = 57;
 607           break;
 608         default:
 609           s = (it[i].t & 0x7FFF) - 1;
 610       }
 611     }
 612     if (s >= 0) {
 613       Z_drawspr(it[i].o.x, it[i].o.y, item_spr[s], item_sprd[s]);
 614     }
 615   }
 616 }
 617
 618 /* --- player --- */
 619
 620 static int standspr (player_t *p) {
 621   if (p->f & PLF_UP) {
 622     return 'X';
 623   } else if (p->f & PLF_DOWN) {
 624     return 'Z';
 625   } else {
 626     return 'E';
 627   }
 628 }
 629
 630 static int wpnspr (player_t *p) {
 631   if (p->f & PLF_UP) {
 632     return 'C';
 633   } else if(p->f & PLF_DOWN) {
 634     return 'E';
 635   } else {
 636     return 'A';
 637   }
 638 }
 639
 640 static void PL_draw (player_t *p) {
 641   enum {STAND, GO, DIE, SLOP, DEAD, MESS, OUT, FALL}; // copypasted from player.c!
 642   static int wytab[] = {-1, -2, -1, 0};
 643   int s = 'A';
 644   int w = 0;
 645   int wx = 0;
 646   int wy = 0;
 647   switch (p->st) {
 648     case STAND:
 649       if (p->f & PLF_FIRE) {
 650         s = standspr(p) + 1;
 651         w = wpnspr(p) + 1;
 652       } else if (p->pain) {
 653         s = 'G';
 654         w = 'A';
 655         wx = p->d ? 2 : -2;
 656         wy = 1;
 657       } else {
 658         s = standspr(p);
 659         w = wpnspr(p);
 660       }
 661       break;
 662     case DEAD:
 663       s = 'N';
 664       break;
 665     case MESS:
 666       s = 'W';
 667       break;
 668     case GO:
 669       if (p->pain) {
 670         s = 'G';
 671         w = 'A';
 672         wx = p->d ? 2 : -2;
 673         wy = 1;
 674       } else {
 675         s = plr_goanim[p->s / 8];
 676         w = (p->f & PLF_FIRE) ? 'B' : 'A';
 677         wx = p->d ? 2 : -2;
 678         wy = 1 + wytab[s - 'A'];
 679       }
 680       break;
 681     case DIE:
 682       s = plr_dieanim[p->s];
 683       break;
 684     case SLOP:
 685       s = plr_slopanim[p->s];
 686       break;
 687     case OUT:
 688       s = 0;
 689       break;
 690   }
 691   if (p->wpn == 0) {
 692     w = 0;
 693   }
 694   if (w) {
 695     Z_drawspr(p->o.x + wx, p->o.y + wy, plr_wpn[p->wpn][w - 'A'], p->d);
 696   }
 697   if (s) {
 698     Z_drawmanspr(p->o.x, p->o.y, plr_spr[(s - 'A') * 2 + p->d], plr_sprd[(s - 'A') * 2 + p->d], p->color);
 699   }
 700 }
 701
 702 static void PL_drawst (player_t *p) {
 703   int i;
 704   V_setrect(WD, 120, w_o, HT);
 705   Z_clrst();
 706   if (p->drawst & PL_DRAWAIR) {
 707       if (p->air < PL_AIR) {
 708         Z_drawstair(p->air);
 709       }
 710   }
 711   if (p->drawst & PL_DRAWLIFE) {
 712     Z_drawstprcnt(0, p->life);
 713   }
 714   if (p->drawst & PL_DRAWARMOR) {
 715     Z_drawstprcnt(1, p->armor);
 716   }
 717   if (p->drawst & PL_DRAWWPN) {
 718     switch(p->wpn) {
 719       case 2:
 720       case 5:
 721         i = p->ammo;
 722         break;
 723       case 3:
 724       case 4:
 725       case 9:
 726         i = p->shel;
 727         break;
 728       case 6:
 729         i = p->rock;
 730         break;
 731       case 10:
 732         i = p->fuel;
 733         break;
 734       case 7:
 735       case 8:
 736         i = p->cell;
 737         break;
 738     }
 739     Z_drawstwpn(p->wpn, i);
 740   }
 741   if (p->drawst & PL_DRAWFRAG) {
 742     Z_drawstnum(p->frag);
 743   }
 744   if (p->drawst & PL_DRAWKEYS) {
 745     Z_drawstkeys(p->keys);
 746   }
 747   if (!_2pl) {
 748     if (p->drawst & PL_DRAWLIVES) {
 749       Z_drawstlives(p->lives);
 750     }
 751   }
 752 }
 753
 754 /* --- monster --- */
 755
 756 #define MANCOLOR 0xD0
 757
 758 static void MN_draw (void) {
 759   enum {SLEEP, GO, RUN, CLIMB, DIE, DEAD, ATTACK, SHOOT, PAIN, WAIT, REVIVE, RUNOUT}; // copypasted from monster.c!
 760   int i;
 761   for (i = 0; i < MAXMN; i++) {
 762     if (mn[i].t) {
 763       if (mn[i].t >= MN_PL_DEAD) {
 764         Z_drawmanspr(mn[i].o.x, mn[i].o.y, pl_spr[mn[i].t - MN_PL_DEAD], 0, mn[i].d);
 765         continue;
 766       }
 767       if ((mn[i].t != MN_SOUL && mn[i].t != MN_PAIN) || mn[i].st != DEAD) {
 768         if (mn[i].t != MN_MAN) {
 769           Z_drawspr(mn[i].o.x, mn[i].o.y, mn_spr[mn[i].t - 1][(mn[i].ap[mn[i].ac] - 'A') * 2 + mn[i].d], mn_sprd[mn[i].t - 1][(mn[i].ap[mn[i].ac] - 'A') * 2 + mn[i].d]);
 770         } else {
 771           if (mn[i].ap[mn[i].ac] == 'E' || mn[i].ap[mn[i].ac] == 'F') {
 772             Z_drawspr(mn[i].o.x, mn[i].o.y, mn_sgun[mn[i].ap[mn[i].ac] - 'E'], mn[i].d);
 773           }
 774           Z_drawmanspr(mn[i].o.x, mn[i].o.y, mn_spr[mn[i].t - 1][(mn[i].ap[mn[i].ac] - 'A') * 2 + mn[i].d], mn_sprd[mn[i].t - 1][(mn[i].ap[mn[i].ac] - 'A') * 2 + mn[i].d], MANCOLOR);
 775         }
 776       }
 777       if (mn[i].t == MN_VILE && mn[i].st == SHOOT) {
 778         Z_drawspr(mn[i].tx, mn[i].ty, mn_fspr[mn[i].ac / 3], 0);
 779       }
 780     }
 781   }
 782 }
 783
 784 /* --- weapon --- */
 785
 786 static void WP_draw (void) {
 787   enum {NONE, ROCKET, PLASMA, APLASMA, BALL1, BALL2, BALL7, BFGBALL, BFGHIT, MANF, REVF, FIRE}; // copypasted from weapons.c!
 788   int i, s, d, x, y;
 789   for (i = 0; i < MAXWPN; ++i) {
 790     s = -1;
 791     d = 0;
 792     switch (wp[i].t) {
 793       case NONE:
 794       default:
 795         break;
 796       case REVF:
 797       case ROCKET:
 798         d = wp[i].s;
 799         if (d < 2) {
 800           d = wp[i].o.xv > 0 ? 1 : 0;
 801           x = abs(wp[i].o.xv);
 802           y = wp[i].o.yv;
 803           s = 0;
 804           if (y < 0) {
 805             if (-y >= x) {
 806               s = 30;
 807             }
 808           } else if (y > 0) {
 809             if (y >= x / 2) {
 810               s = 31;
 811             }
 812           }
 813         } else {
 814           s = (d - 2) / 2 + 1;
 815           d = 0;
 816         }
 817         break;
 818       case MANF:
 819         s=wp[i].s;
 820         if (s >= 2) {
 821           s /= 2;
 822           break;
 823         }
 824       case PLASMA:
 825       case APLASMA:
 826       case BALL1:
 827       case BALL7:
 828       case BALL2:
 829         s = wp[i].s;
 830         if (s >= 2) {
 831           s = s / 2 + 1;
 832         }
 833         switch (wp[i].t) {
 834           case PLASMA:
 835             s += 4;
 836             break;
 837           case APLASMA:
 838             s += 11;
 839             break;
 840           case BALL1:
 841             s += 32;
 842             break;
 843           case BALL2:
 844             s += 42;
 845             break;
 846           case BALL7:
 847             s += 37;
 848             d = wp[i].o.xv >= 0 ? 1 : 0;
 849             break;
 850           case MANF:
 851             s += 47;
 852             d= wp[i].o.xv>=0 ? 1 : 0;
 853             break;
 854         }
 855         break;
 856       case BFGBALL:
 857         s = wp[i].s;
 858         if (s >= 2) {
 859           s = s / 2 + 1;
 860         }
 861         s += 18;
 862         break;
 863       case BFGHIT:
 864         s = wp[i].s / 2 + 26;
 865         break;
 866     }
 867     if (s >= 0) {
 868       Z_drawspr(wp[i].o.x, wp[i].o.y, wp_spr[s * 2 + d], wp_sprd[s * 2 + d]);
 869     }
 870   }
 871 }
 872
 873 /* --- smoke --- */
 874
 875 static void SMK_draw (void) {
 876   int i, s;
 877   for (i = 0; i < MAXSMOK; ++i) {
 878     if (sm[i].t) {
 879       switch (sm[i].s) {
 880         case 0:
 881           s = sm[i].t;
 882           if (s >= (SMSN - 1) * 3) {
 883             s = 0;
 884           } else {
 885             s = SMSN - 1 - s / 3;
 886           }
 887           V_sprf((sm[i].x >> 8) - w_x + WD / 2, (sm[i].y >> 8) - w_y + HT / 2 + 1 + w_o, smk_spr[s], &smoke_sprf);
 888           break;
 889         case 1:
 890           s = sm[i].t;
 891           if (s >= FLSN - 1) {
 892             s = 0;
 893           } else {
 894             s = FLSN - 1 - s;
 895           }
 896           V_sprf((sm[i].x >> 8) - w_x + WD / 2, (sm[i].y >> 8) - w_y + HT / 2 + 1 + w_o, smk_fspr[s], &flame_sprf);
 897           break;
 898       }
 899     }
 900   }
 901 }
 902
 903 /* --- fx --- */
 904
 905 static void FX_draw (void) {
 906   enum {NONE, TFOG, IFOG, BUBL}; // copypasted from fx.c
 907   int i, s;
 908   for (i = 0; i < MAXFX; ++i) {
 909     s = -1;
 910     switch (fx[i].t) {
 911       case TFOG:
 912         s = fx[i].s / 2;
 913         break;
 914       case IFOG:
 915         s = fx[i].s / 2 + 10;
 916         break;
 917       case BUBL:
 918         V_dot((fx[i].x >> 8) - w_x + WD / 2, (fx[i].y >> 8) - w_y + HT / 2 + 1 + w_o, 0xC0 + fx[i].s);
 919         continue;
 920     }
 921     if (s >= 0) {
 922       Z_drawspr(fx[i].x, fx[i].y, fx_spr[s], fx_sprd[s]);
 923     }
 924   }
 925 }
 926
 927 /* --- view --- */
 928
 929 static void W_adjust (void) {
 930   int MAXX = FLDW * CELW - WD / 2;
 931   int MAXY = FLDH * CELH - HT / 2;
 932   if (w_x < WD / 2) w_x = WD / 2;
 933   if (w_y < HT / 2) w_y = HT / 2;
 934   if (w_x > MAXX) w_x = MAXX;
 935   if (w_y > MAXY) w_y = MAXY;
 936 }
 937
 938 static void W_draw(void) {
 939   W_adjust();
 940   V_setrect(0, WD, w_o + 1, HT);
 941   if (w_horiz) {
 942     vgaimg *img = (vgaimg*)horiz;
 943     int x = 0;
 944     int d = 0;
 945     do {
 946       int y = w_o;
 947       d &= ~2;
 948       do {
 949         V_rotspr(x, y, img, d);
 950         y += img->h;
 951         d ^= 2;
 952       } while (y < HT + w_o);
 953       x += img->w;
 954       d ^= 1;
 955     } while (x < WD);
 956     if (sky_type == 2) {
 957       if (lt_time < 0) {
 958         if (!lt_side) {
 959           V_spr(0, w_o + lt_ypos, ltn[lt_type][lt_time < -5 ? 0 : 1]);
 960         } else {
 961           V_spr2(WD - 1, w_o + lt_ypos, ltn[lt_type][lt_time < -5 ? 0 : 1]);
 962         }
 963       }
 964     }
 965   } else {
 966     V_clr(0, WD, w_o + 1, HT, 0x97);
 967   }
 968   Z_drawfld((byte*)fldb, 1);
 969   DOT_draw();
 970   IT_draw();
 971   PL_draw(&pl1);
 972   if (_2pl) {
 973     PL_draw(&pl2);
 974   }
 975   MN_draw();
 976   WP_draw();
 977   SMK_draw();
 978   FX_draw();
 979   Z_drawfld((byte*)fldf, 0);
 980   if (sky_type == 2) {
 981     if (lt_time == -4 || lt_time == -2) {
 982       V_remap_rect(0, WD, w_o + 1, HT, clrmap + 256 * 11);
 983     }
 984   }
 985 }
 986
 987 /* --- game --- */
 988
 989 #define PL_FLASH 90
 990
 991 static void drawview (player_t *p) {
 992   if (p->looky < -SCRH / 4) {
 993     p->looky = -SCRH / 4;
 994   } else if (p->looky > SCRH / 4) {
 995     p->looky = SCRH / 4;
 996   }
 997   w_x = p->o.x;
 998   w_y = p->o.y - 12 + p->looky;
 999   W_draw();
1000   PL_drawst(p);
1001 }
1002
1003 static int get_pu_st (int t) {
1004   if (t >= PL_FLASH) {
1005     return 1;
1006   } else if((t / 9) & 1) {
1007     return 0;
1008   } else {
1009     return 1;
1010   }
1011 }
1012
1013 static void pl_info (player_t *p, int y) {
1014   dword t = p->kills * 10920 / g_time;
1015   Z_gotoxy(25, y); Z_printbf("KILLS");
1016   Z_gotoxy(25, y + 15); Z_printbf("KPM");
1017   Z_gotoxy(25, y + 30); Z_printbf("SECRETS %u / %u", p->secrets, sw_secrets);
1018   Z_gotoxy(255, y); Z_printbf("%u", p->kills);
1019   Z_gotoxy(255, y + 15); Z_printbf("%u.%u", t / 10, t % 10);
1020 }
1021
1022 static void W_act (void) {
1023   int i, a;
1024   if (g_time % 3 == 0) {
1025     for (i = 1; i < 256; i++) {
1026       a = walani[i];
1027       if (a != 0) {
1028         anic[a]++;
1029         if (anih[a][anic[a]] == -1) {
1030           anic[a] = 0;
1031         }
1032         walp[i] = V_getvgaimg(anih[a][anic[a]]);
1033       }
1034     }
1035   }
1036 }
1037
1038 void R_draw (void) {
1039   int h;
1040   word hr, mn, sc;
1041   W_act();
1042   switch (g_st) {
1043     case GS_ENDANIM:
1044     case GS_END2ANIM:
1045     case GS_DARKEN:
1046     case GS_BVIDEO:
1047     case GS_EVIDEO:
1048     case GS_END3ANIM:
1049       return;
1050     case GS_TITLE:
1051       V_center(1);
1052       V_pic(0, 0, scrnh[0]);
1053       V_center(0);
1054       break;
1055     case GS_ENDSCR:
1056       V_center(1);
1057       V_clr(0, SCRW, 0, SCRH, 0);
1058       V_pic(0, 0, scrnh[2]);
1059       V_center(0);
1060       break;
1061     case GS_INTER:
1062       V_center(1);
1063       V_clr(0, SCRW, 0, SCRH, 0);
1064       V_pic(0, 0, scrnh[1]);
1065       Z_gotoxy(60, 20);
1066       Z_printbf("LEVEL COMPLETE");
1067       Z_calc_time(g_time, &hr, &mn, &sc);
1068       Z_gotoxy(115, 40);
1069       Z_printbf("TIME %u:%02u:%02u", hr, mn, sc);
1070       h = 60;
1071       if (_2pl) {
1072         Z_gotoxy(80, h);
1073         Z_printbf("PLAYER ONE");
1074         Z_gotoxy(80, h + 70);
1075         Z_printbf("PLAYER TWO");
1076         h += SCRH / 10;
1077       }
1078       pl_info(&pl1, h);
1079       if (_2pl) {
1080         pl_info(&pl2, h + 70);
1081       }
1082       V_center(0);
1083       break;
1084   }
1085   V_center(0);
1086   if (g_st == GS_GAME) {
1087     if (_2pl) {
1088       w_o = 0;
1089       WD = SCRW - 120;
1090       HT = SCRH / 2 - 2;
1091       drawview(&pl1);
1092       w_o = SCRH / 2;
1093       WD = SCRW - 120;
1094       HT = SCRH / 2 - 2;
1095       drawview(&pl2);
1096     } else{
1097       w_o = 0;
1098       WD = SCRW - 120;
1099       HT = SCRH - 2;
1100       drawview(&pl1);
1101     }
1102     if (pl1.invl) {
1103       h = get_pu_st(pl1.invl) * 6;
1104     } else if (pl1.pain < 15) {
1105       h = 0;
1106     } else if (pl1.pain < 35) {
1107       h = 1;
1108     } else if (pl1.pain < 55) {
1109       h = 2;
1110     } else if (pl1.pain < 75) {
1111       h=3;
1112     } else if (pl1.pain < 95) {
1113       h=4;
1114     } else {
1115       h = 5;
1116     }
1117     if (h != 0) {
1118       V_maptoscr(0, SCRW - 120, 1, _2pl ? SCRH / 2 - 2 : SCRH - 2, clrmap + h * 256);
1119     }
1120     if (_2pl) {
1121       if (pl2.invl) {
1122         h = get_pu_st(pl2.invl) * 6;
1123       } else if (pl2.pain < 15) {
1124         h = 0;
1125       } else if (pl2.pain < 35) {
1126         h = 1;
1127       } else if (pl2.pain < 55) {
1128         h = 2;
1129       } else if (pl2.pain < 75) {
1130         h = 3;
1131       } else if (pl2.pain < 95) {
1132         h = 4;
1133       } else {
1134         h = 5;
1135       }
1136       if (h) {
1137         V_maptoscr(0, SCRW - 120, SCRH / 2 + 1, SCRH / 2 - 2, clrmap + h * 256);
1138       }
1139     }
1140   }
1141   V_center(0);
1142   V_setrect(0, SCRW, 0, SCRH);
1143   GM_draw();
1144   V_copytoscr(0, SCRW, 0, SCRH);
1145 }
1146
1147 void R_alloc (void) {
1148   int i, j, n;
1149   char s[10];
1150   logo("R_alloc: загрузка графики\n");
1151   // game
1152   scrnh[0] = V_loadvgaimg("TITLEPIC");
1153   scrnh[1] = V_loadvgaimg("INTERPIC");
1154   scrnh[2] = V_loadvgaimg("ENDPIC");
1155   cd_scr = M_lock(F_getresid("CD1PIC"));
1156   for (i = 0; i < 2; ++i) {
1157     sprintf(s, "LTN%c", i + '1');
1158     for (j = 0; j < 2; ++j) {
1159       ltn[i][j] = Z_getspr(s, j, 0, NULL);
1160     }
1161   }
1162   // smoke
1163   for (i = 0; i < SMSN; ++i) {
1164     smk_spr[i] = Z_getspr("SMOK", i, 0, NULL);
1165   }
1166   for (i = 0; i < FLSN; ++i) {
1167     smk_fspr[i] = Z_getspr("FLAM", i, 0, NULL);
1168   }
1169   // fx
1170   for (i = 0; i < 10; ++i) {
1171     fx_spr[i] = Z_getspr("TFOG", i, 0, fx_sprd + i);
1172   }
1173   for (; i < 15; ++i) {
1174     fx_spr[i] = Z_getspr("IFOG", i - 10, 0, fx_sprd + i);
1175   }
1176   // weapons
1177   for (i = 0; i < 4; ++i) {
1178     wp_spr[i * 2] = Z_getspr("MISL", i, 1, wp_sprd + i * 2);
1179     wp_spr[i * 2 + 1] = Z_getspr("MISL", i, 2, wp_sprd + i * 2 + 1);
1180   }
1181   for (; i < 6; ++i) {
1182     wp_spr[i * 2] = Z_getspr("PLSS", i - 4, 1, wp_sprd + i * 2);
1183     wp_spr[i * 2 + 1] = Z_getspr("PLSS", i - 4, 2, wp_sprd + i * 2 + 1);
1184   }
1185   for (; i < 11; ++i) {
1186     wp_spr[i * 2] = Z_getspr("PLSE", i - 6, 1, wp_sprd + i * 2);
1187     wp_spr[i * 2 + 1] = Z_getspr("PLSE", i - 6, 2, wp_sprd + i * 2 + 1);
1188   }
1189   for (; i < 13; ++i) {
1190     wp_spr[i * 2] = Z_getspr("APLS", i - 11, 1, wp_sprd + i * 2);
1191     wp_spr[i * 2 + 1] = Z_getspr("APLS", i - 11, 2, wp_sprd + i * 2 + 1);
1192   }
1193   for (; i < 18; ++i) {
1194     wp_spr[i * 2] = Z_getspr("APBX", i - 13, 1, wp_sprd + i * 2);
1195     wp_spr[i * 2 + 1] = Z_getspr("APBX", i - 13, 2, wp_sprd + i * 2 + 1);
1196   }
1197   for(; i < 20; ++i) {
1198     wp_spr[i * 2] = Z_getspr("BFS1", i - 18, 1, wp_sprd + i * 2);
1199     wp_spr[i * 2 + 1] = Z_getspr("BFS1", i - 18, 2, wp_sprd + i * 2 + 1);
1200   }
1201   for (; i < 26; ++i) {
1202     wp_spr[i * 2] = Z_getspr("BFE1", i - 20, 1, wp_sprd + i * 2);
1203     wp_spr[i * 2 + 1] = Z_getspr("BFE1", i - 20, 2, wp_sprd + i * 2 + 1);
1204   }
1205   for (; i < 30; ++i) {
1206     wp_spr[i * 2] = Z_getspr("BFE2", i - 26, 1, wp_sprd + i * 2);
1207     wp_spr[i * 2 + 1] = Z_getspr("BFE2", i - 26, 2, wp_sprd + i * 2 + 1);
1208   }
1209   for (; i < 32; ++i) {
1210     wp_spr[i * 2] = Z_getspr("MISL", i - 30 + 4, 1, wp_sprd + i * 2);
1211     wp_spr[i * 2 + 1] = Z_getspr("MISL", i - 30 + 4, 2, wp_sprd + i * 2 + 1);
1212   }
1213   for (; i < 37; ++i) {
1214     wp_spr[i * 2] = Z_getspr("BAL1", i - 32, 1, wp_sprd + i * 2);
1215     wp_spr[i * 2 + 1] = Z_getspr("BAL1", i - 32, 2, wp_sprd + i * 2 + 1);
1216   }
1217   for (; i < 42; ++i) {
1218     wp_spr[i * 2] = Z_getspr("BAL7", i - 37, 1, wp_sprd + i * 2);
1219     wp_spr[i * 2 + 1] = Z_getspr("BAL7", i - 37, 2, wp_sprd + i * 2 + 1);
1220   }
1221   for (; i < 47; ++i) {
1222     wp_spr[i * 2] = Z_getspr("BAL2", i - 42, 1, wp_sprd + i * 2);
1223     wp_spr[i * 2 + 1] = Z_getspr("BAL2", i - 42, 2, wp_sprd + i * 2 + 1);
1224   }
1225   for (; i < 49; ++i) {
1226     wp_spr[i * 2] = Z_getspr("MANF", i - 47, 1, wp_sprd + i * 2);
1227     wp_spr[i * 2 + 1] = Z_getspr("MANF", i - 47, 2, wp_sprd + i * 2 + 1);
1228   }
1229   // items
1230   static char snm[18][4] = {
1231     "CLIP", "SHEL", "ROCK", "CELL", "AMMO", "SBOX", "BROK", "CELP",
1232     "STIM", "MEDI", "BPAK",
1233     "CSAW", "SHOT", "SGN2", "MGUN", "LAUN", "PLAS", "BFUG"
1234   };
1235   static char n4[4][4] = {
1236     "SOUL", "SMRT", "SMGT", "SMBT"
1237   };
1238   static char n3[2][4] = {
1239     "GOR1", "FCAN"
1240   };
1241   for (i = 0; i < 18; ++i) {
1242     item_spr[i] = Z_getspr(snm[i], 0, 0, item_sprd + i);
1243   }
1244   for (; i < 20; ++i) {
1245     item_spr[i] = Z_getspr("ARM1", i - 18, 0, item_sprd + i);
1246     item_spr[i + 2] = Z_getspr("ARM2", i - 18, 0, item_sprd + i);
1247   }
1248   i+=2;
1249   for (; i < 26; ++i) {
1250     item_spr[i] = Z_getspr("MEGA", i - 22, 0, item_sprd + i);
1251   }
1252   for (; i < 30; ++i) {
1253     item_spr[i] = Z_getspr("PINV", i - 26, 0, item_sprd + i);
1254   }
1255   item_spr[30] = Z_getspr("AQUA", 0, 0, item_sprd + 30);
1256   item_spr[31] = Z_getspr("KEYR", 0, 0, item_sprd + 31);
1257   item_spr[32] = Z_getspr("KEYG", 0, 0, item_sprd + 32);
1258   item_spr[33] = Z_getspr("KEYB", 0, 0, item_sprd + 33);
1259   item_spr[34] = Z_getspr("SUIT", 0, 0, item_sprd + 34);
1260   for (n = 35, j = 0; j < 4; ++j) {
1261     for (i = 0; i < 4; ++i, ++n) {
1262       item_spr[n] = Z_getspr(n4[j], i, 0, item_sprd + n);
1263     }
1264   }
1265   for (j = 0; j < 2; ++j) {
1266     for (i = 0; i < 3; ++i, ++n) {
1267       item_spr[n] = Z_getspr(n3[j], i, 0, item_sprd + n);
1268     }
1269   }
1270   item_spr[57] = Z_getspr("GUN2", 0, 0, item_sprd + 57);
1271   // player
1272   for (i = 0; i < 27; ++i) {
1273     plr_spr[i * 2] = Z_getspr("PLAY", i, 1, plr_sprd + i * 2);
1274     plr_spr[i * 2 + 1] = Z_getspr("PLAY", i, 2, plr_sprd + i * 2 + 1);
1275   }
1276   strncpy(s, "PWPx", 4);
1277   for (i = 1; i < 11; ++i) {
1278     s[3] = (i < 10 ? '0' : 'A' - 10) + i;
1279     for (j = 0; j < 6; ++j) {
1280       plr_wpn[i][j] = Z_getspr(s, j, 1, NULL);
1281     }
1282   }
1283   // monsters
1284   static char msn[MN_TN][4] = {
1285     "SARG", "TROO", "POSS", "SPOS", "CYBR", "CPOS", "BOSS", "BOS2", "HEAD", "SKUL",
1286     "PAIN", "SPID", "BSPI", "FATT", "SKEL", "VILE", "FISH", "BAR1", "ROBO", "PLAY"
1287   };
1288   static int mms[MN_TN] = {
1289     14*2, 21*2, 21*2, 21*2, 16*2, 20*2, 15*2, 15*2, 12*2, 11*2, 13*2, 19*2, 16*2,
1290     20*2, 17*2, 29*2, 6*2, 2*2, 17*2, 23*2
1291   };
1292   mn_sgun[0] = Z_getspr("PWP4", 0, 1, NULL);
1293   mn_sgun[1] = Z_getspr("PWP4", 1, 1, NULL);
1294   for (j = 0; j < MN_TN; ++j) {
1295     for (i = 0; i < mms[j]; ++i) {
1296       mn_spr[j][i] = Z_getspr(msn[j], i / 2, (i & 1) + 1, &mn_sprd[j][i]);
1297     }
1298     if (j == MN_BARREL - 1) {
1299       for (i = 4; i < 14; ++i) {
1300         mn_spr[j][i] = Z_getspr("BEXP", i / 2 - 2, (i & 1) + 1, &mn_sprd[j][i]);
1301       }
1302     }
1303   }
1304   for (i = 0; i < 8; ++i) {
1305     mn_fspr[i] = Z_getspr("FIRE", i, 0, NULL);
1306   }
1307   pl_spr[0] = Z_getspr("PLAY", 'N' - 'A', 0, NULL);
1308   pl_spr[1] = Z_getspr("PLAY", 'W' - 'A', 0, NULL);
1309   // misc
1310   static char mnm[22][8]={
1311         "STTNUM0","STTNUM1","STTNUM2","STTNUM3","STTNUM4",
1312         "STTNUM5","STTNUM6","STTNUM7","STTNUM8","STTNUM9",
1313         "STTMINUS","STTPRCNT",
1314         "FISTA0","CSAWA0","PISTA0","SHOTA0","SGN2A0","MGUNA0","LAUNA0",
1315         "PLASA0","BFUGA0","GUN2A0"
1316   };
1317   stone=V_loadvgaimg("STONE");
1318   stone2=V_loadvgaimg("STONE2");
1319   keys[0]=V_loadvgaimg("KEYRA0");
1320   keys[1]=V_loadvgaimg("KEYGA0");
1321   keys[2]=V_loadvgaimg("KEYBA0");
1322   for (i = 0; i < 22; ++i) {
1323     sth[i] = V_loadvgaimg(mnm[i]);
1324   }
1325   strcpy(s, "STBF_*");
1326   for (i = '!'; i < 160; ++i) {
1327     s[5] = i;
1328     bfh[i - '!'] = V_getvgaimg(F_findres(s));
1329   }
1330   for (i = '!'; i < 160; ++i) {
1331     sprintf(s, "STCFN%03d", i);
1332     sfh[i - '!'] = V_getvgaimg(F_findres(s));
1333   }
1334   strcpy(s, "WINUM*");
1335   for (i = '0'; i <= '9'; ++i) {
1336     s[5] = i;
1337     bfh[i - '!'] = V_loadvgaimg(s);
1338   }
1339   bfh[':' - '!'] = V_loadvgaimg("WICOLON");
1340   // menu
1341   msklh[0] = V_loadvgaimg("M_SKULL1");
1342   msklh[1] = V_loadvgaimg("M_SKULL2");
1343   mbarl = V_loadvgaimg("M_THERML");
1344   mbarm = V_loadvgaimg("M_THERMM");
1345   mbarr = V_loadvgaimg("M_THERMR");
1346   mbaro = V_loadvgaimg("M_THERMO");
1347   mslotl = V_loadvgaimg("M_LSLEFT");
1348   mslotm = V_loadvgaimg("M_LSCNTR");
1349   mslotr = V_loadvgaimg("M_LSRGHT");
1350   // walls
1351   static char *anm[ANIT - 1][5] = {
1352     {"WALL22_1", "WALL23_1", "WALL23_2", NULL,    NULL},
1353     {"WALL58_1", "WALL58_2", "WALL58_3", NULL,    NULL},
1354     {"W73A_1",   "W73A_2",   NULL,       NULL,    NULL},
1355     {"RP2_1",    "RP2_2",    "RP2_3",    "RP2_4", NULL}
1356   };
1357   for (i = 1; i < ANIT; i++) {
1358     for (j = 0; anm[i - 1][j]; j++) {
1359       anih[i][j] = F_getresid(anm[i - 1][j]);
1360     }
1361     for(; j < 5; j++) {
1362       anih[i][j] = -1;
1363     }
1364   }
1365 }
1366
1367 void R_get_name (int n, char s[8]) {
1368   if (walh[n] == -1) {
1369     memset(s, 0, 8);
1370   } else if (walh[n] == -2) {
1371     memcpy(s, "_WATER_", 8);
1372     s[7] = (char)((intptr_t)walp[n] - 1 + '0');
1373   } else {
1374     F_getresname(s, walh[n] & 0x7FFF);
1375   }
1376 }
1377
1378 static short getani (char n[8]) {
1379   if (strncasecmp(n, "WALL22_1", 8) == 0) {
1380     return 1;
1381   } else if (strncasecmp(n, "WALL58_1", 8) == 0) {
1382     return 2;
1383   } else if (strncasecmp(n, "W73A_1", 8) == 0) {
1384     return 3;
1385   } else if (strncasecmp(n, "RP2_1", 8) == 0) {
1386     return 4;
1387   } else {
1388     return 0;
1389   }
1390 }
1391
1392 int R_get_special_id (int n) {
1393   assert(n >= 0 && n < 256);
1394   intptr_t x = (intptr_t)walp[n];
1395   return x >= 0 && x <= 3 ? x : -1;
1396 }
1397
1398 void R_begin_load (void) {
1399   int i;
1400   for (i = 0; i < 256; i++) {
1401     if (walp[i] != NULL && walh[i] >= 0) {
1402       M_unlock(walp[i]);
1403     }
1404     walh[i] = -1;
1405     walp[i] = NULL;
1406     walswp[i] = i;
1407     walani[i] = 0;
1408   }
1409   memset(anic, 0, sizeof(anic));
1410   max_textures = 1;
1411 }
1412
1413 void R_load (char s[8]) {
1414   assert(max_textures < 256);
1415   if (!s[0]) {
1416     walh[max_textures] = -1;
1417     walp[max_textures] = NULL;
1418   } else {
1419     if (strncasecmp(s, "_WATER_", 7) == 0) {
1420       walh[max_textures] = -2;
1421       walp[max_textures] = (void*)((intptr_t)s[7] - '0' + 1);
1422     } else {
1423       walh[max_textures] = F_getresid(s);
1424       walp[max_textures] = V_getvgaimg(walh[max_textures]);
1425       if (s[0] == 'S' && s[1] == 'W' && s[4] == '_') {
1426         walswp[max_textures] = 0;
1427       }
1428     }
1429     walani[max_textures] = getani(s);
1430   }
1431   max_textures++;
1432 }
1433
1434 void R_end_load (void) {
1435   int i, j, k, g;
1436   char s[8];
1437   j = max_textures;
1438   for (i = 1; i < 256 && j < 256; i++) {
1439     if (walswp[i] == 0) {
1440       R_get_name(i, s);
1441       s[5] ^= 1;
1442       g = F_getresid(s);
1443       k = 1;
1444       while (k < 256 && walh[k] != g) {
1445         k += 1;
1446       }
1447       if (k >= 256) {
1448         k = j;
1449         j += 1;
1450         walh[k] = g;
1451         walp[k] = V_getvgaimg(g);
1452         walf[k] = walf[i];
1453       }
1454       walswp[i] = k;
1455       walswp[k] = i;
1456     }
1457   }
1458 }
1459
1460 void R_loadsky (int sky) {
1461   char s[6];
1462   strcpy(s, "RSKY1");
1463   s[4] = '0' + sky;
1464   M_unlock(horiz);
1465   horiz = V_loadvgaimg(s);
1466 }
1467
1468 void R_setgamma(int g) {
1469   int t;
1470   g = g < 0 ? 0 : (g > 4 ? 4 : g);
1471   gammaa = g;
1472   for (t = 0; t < 256; ++t) {
1473     std_pal[t][0]=gamcor[gammaa][main_pal[t][0]];
1474     std_pal[t][1]=gamcor[gammaa][main_pal[t][1]];
1475     std_pal[t][2]=gamcor[gammaa][main_pal[t][2]];
1476   }
1477   Y_set_vga_palette(std_pal);
1478 }
1479
1480 int R_getgamma (void) {
1481   return gammaa;
1482 }
1483
1484 void R_set_videomode (int w, int h, int fullscreen) {
1485   assert(w > 0);
1486   assert(h > 0);
1487   int was = Y_videomode_setted();
1488   int res = Y_set_videomode_software(w, h, fullscreen);
1489   if (res == 0) {
1490     if (was == 0) {
1491       ERR_failinit("Unable to set video mode");
1492     }
1493   } else {
1494     Y_get_videomode(&SCRW, &SCRH);
1495     V_update_buffer();
1496     R_setgamma(gammaa);
1497   }
1498 }
1499
1500 void R_toggle_fullscreen (void) {
1501   Y_set_fullscreen(!Y_get_fullscreen());
1502   fullscreen = Y_get_fullscreen();
1503   Y_get_videomode(&SCRW, &SCRH);
1504   V_update_buffer();
1505   R_setgamma(gammaa);
1506 }
1507
1508 static int video_menu_handler (menu_msg_t *msg, const menu_t *m, void *data, int i) {
1509   static int cur;
1510   static int w, h, fullscreen;
1511   static char buf[16];
1512   static int buflen;
1513   static int vmode;
1514   const videomode_t *v;
1515   enum { VIDEOMODE, FULLSCREEN, APPLY, __NUM__ };
1516   static const simple_menu_t sm = {
1517     GM_BIG, "Video", NULL,
1518     {
1519       { "Mode: ", NULL },
1520       { "Fullscreen: ", NULL },
1521       { "Apply ", NULL },
1522     }
1523   };
1524   if (msg->type == GM_ENTER) {
1525     Y_get_videomode(&w, &h);
1526     fullscreen = Y_get_fullscreen();
1527     v = Y_get_videomode_list_opengl(fullscreen);
1528     vmode = 0;
1529     while (vmode < v->n && v->modes[vmode].w != w && v->modes[vmode].h != h) {
1530       vmode += 1;
1531     }
1532     if (vmode < v->n) {
1533       w = v->modes[vmode].w;
1534       h = v->modes[vmode].h;
1535     }
1536     snprintf(buf, 16, "%ix%i", w, h);
1537     buflen = strlen(buf);
1538     return 1;
1539   }
1540   if (i == VIDEOMODE) {
1541     switch (msg->type) {
1542       case GM_GETSTR: return GM_init_str(msg, buf, buflen);
1543       case GM_SELECT:
1544         v = Y_get_videomode_list_opengl(fullscreen);
1545         vmode = vmode + 1 >= v->n ? 0 : vmode + 1;
1546         if (v->n > 0) {
1547           w = v->modes[vmode].w;
1548           h = v->modes[vmode].h;
1549         } else {
1550           Y_get_videomode(&w, &h);
1551         }
1552         snprintf(buf, 16, "%ix%i", w, h);
1553         buflen = strlen(buf);
1554         return 1;
1555     }
1556   } else if (i == FULLSCREEN) {
1557     switch (msg->type) {
1558       case GM_GETSTR: return GM_init_str(msg, fullscreen ? "Yes" : "No ", 3);
1559       case GM_SELECT: fullscreen = !fullscreen; return 1;
1560     }
1561   } else if (i == APPLY) {
1562     switch (msg->type) {
1563       case GM_SELECT: R_set_videomode(w, h, fullscreen); return 1;
1564     }
1565   }
1566   return simple_menu_handler(msg, i, __NUM__, &sm, &cur);
1567 }
1568
1569 static const menu_t video_menu = {
1570   NULL, &video_menu_handler
1571 };
1572
1573 const menu_t *R_menu (void) {
1574   return &video_menu;
1575 }
1576
1577 const cfg_t *R_args (void) {
1578   static const cfg_t args[] = {
1579     { "fullscr", &init_screen_full, Y_SW_ON },
1580     { "window", &init_screen_full, Y_SW_OFF },
1581     { "width", &init_screen_width, Y_DWORD },
1582     { "height", &init_screen_height, Y_DWORD },
1583     { "gamma", &init_screen_gammaa, Y_DWORD },
1584     { NULL, NULL, 0 } // end
1585   };
1586   return args;
1587 }
1588
1589 const cfg_t *R_conf (void) {
1590   static const cfg_t conf[] = {
1591     { "sky", &w_horiz, Y_SW_ON },
1592     { "fullscreen", &fullscreen, Y_SW_ON },
1593     { "screen_width", &SCRW, Y_DWORD },
1594     { "screen_height", &SCRH, Y_DWORD },
1595     { "gamma", &gammaa, Y_DWORD },
1596     { NULL, NULL, 0 } // end
1597   };
1598   return conf;
1599 }
1600
1601 void R_init () {
1602   int i;
1603   logo("R_init: initialize software render\n");
1604   F_loadres(F_getresid("PLAYPAL"), main_pal, 0, 768);
1605   for (i = 0; i < 256; ++i) {
1606     bright[i] = ((int) main_pal[i][0] + main_pal[i][1] + main_pal[i][2]) * 8 / (63 * 3);
1607   }
1608   F_loadres(F_getresid("MIXMAP"), mixmap, 0, 0x10000);
1609   F_loadres(F_getresid("COLORMAP"), clrmap, 0, 256*12);
1610   SCRW = init_screen_width > 0 ? init_screen_width : SCRW;
1611   SCRH = init_screen_height > 0 ? init_screen_height : SCRH;
1612   fullscreen = init_screen_full != 0xFF ? init_screen_full : fullscreen;
1613   gammaa = init_screen_gammaa >= 0 ? init_screen_gammaa : gammaa;
1614   R_set_videomode(SCRW, SCRH, fullscreen);
1615   V_setrect(0, SCRW, 0, SCRH);
1616   V_clr(0, SCRW, 0, SCRH, 0);
1617   R_alloc();
1618 }
1619
1620 void R_done (void) {
1621   buffer = NULL;
1622   buf_w = 0;
1623   buf_h = 0;
1624   pitch = 0;
1625   Y_unset_videomode();
1626 }
1627
1628 void R_switch_texture (int x, int y) {
1629   assert(x >= 0 && x < FLDW);
1630   assert(y >= 0 && y < FLDH);
1631   fldb[y][x] = walswp[fldb[y][x]];
1632 }
1633
1634 int R_get_swp (int n) {
1635   assert(n >= 0 && n < 256);
1636   return walswp[n];
1637 }