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