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