; WOLFHACK.ASM .386C IDEAL MODEL MEDIUM,C ; SOD <A href="http://sod.jodi.org" target="_window">http://sod.jodi.org</a>
;=========================================================================== = DATASEG
EXTRN mr_rowofs:WORD EXTRN mr_count:WORD EXTRN mr_xstep:WORD EXTRN mr_ystep:WORD EXTRN
mr_xfrac:WORD EXTRN mr_yfrac:WORD EXTRN mr_dest:WORD FARDATA planepics db 8192 dup(?) ; // 4k of
ceiling, 4k of floor PUBLIC planepics
;=========================================================================== = CODESEG
;============================ ; ; MapRow ; ; ;============================ PROC MapRow PUBLIC
MapRow push esi push edi push ebp push ds mov bp,[mr_rowofs] mov cx,[mr_count] mov dx,[mr_ystep] shl edx,16 mov
dx,[mr_xstep] mov si,[mr_yfrac] shl esi,16 mov si,[mr_xfrac] mov di,[mr_dest] mov ax,SEG planepics mov ds,ax mov
ax,0a000h mov es,ax mov ax,1111111111110b ; eax color lookup ; ebx scratch offset and pixel values ; ecx loop counter ;
edx packed x / y step values ; esi packed x / y fractional values ; edi write pointer ; ebp toprow to bottomrow delta ; es:
screenseg ; ds: pictures ; mov al,[esi] ; mov al,[eax] ; mov [edi],al ; mov ax,[_variable+ebx+2] pixelloop: shld ebx,esi,22 ;
shift y units in shld ebx,esi,7 ; shift x units in and one extra bit and bx,63*65*2 ; mask off extra top bits and 0 low bit add
esi,edx ; position += step mov al,[bx] mov al,[eax] mov [es:di],al ; write ceiling pixel mov al,[bx+1] mov al,[eax] mov
[es:di+bp],al ; write floor pixel inc di loop pixelloop pop ds pop ebp pop edi pop esi retf ENDP END #define QUITSUR
"Estas seguro que quieres
" "parar este gran juego?" #define CURGAME "Ahora estas en
" "un juego. Si continuas
"
"borras el juego viejo. O.K.?" #define GAMESVD "Ya hay un juego
" "guardado en esta posicion.
" "sobre-escribir?"
#define ENDGAMESTR "Estas seguro que quieres
" "terminar el juego que
" "estas jugando? (S o N):" #define
STR_NG "Juego nuevo" #define STR_SD "Sonido" #define STR_CL "Control" #define STR_LG "Cargar juego" #define
STR_SG "Guardar juego" #define STR_CV "Cambiar vista" #define STR_VS "Ver anotacion" #define STR_EG
"Abandonar" #define STR_BD "Regresar al demo" #define STR_QT "Parar" #define STR_LOADING "Cargando" #define
STR_SAVING "Guardando" #define STR_GAME "Regresar, jugar" #define STR_DEMO "Regresar al Demo" #define
STR_LGC "Cargar juego llamado
"" #define STR_EMPTY "vacio" #define STR_CALIB "Calibrar" #define
STR_JOYST "Joystick" #define STR_MOVEJOY "Mover joystick a
" "arriba izq y
" "oprimir boton 0
" #define
STR_MOVEJOY2 "Mover joystick a
" "abajo derecha y
" "oprimir boton 1
" #define STR_ESCEXIT "ESC para
salir" #define STR_NONE "Ninguno" #define STR_PC "P.C. bocina" #define STR_ALSB "AdLib/Sound Blaster" #define
STR_DISNEY "Disney Sound Source" #define STR_SB "Sound Blaster" #define STR_MOUSEEN "Raton activado"
#define STR_JOYEN "Joystick activado" #define STR_PORT2 "Use joystick puerto 2" #define STR_GAMEPAD "Gravis
Gamepad Activada" #define STR_SENS "Raton Sensibilidad" #define STR_CUSTOM "Modificar controles" #define
STR_DADDY "Papi puedo jugar?" #define STR_HURTME "No me hieras." #define STR_BRINGEM "-Echamelos!"
#define STR_DEATH "La muerte encarnada" #define STR_MOUSEADJ "Raton ajustar sensibilidad" #define STR_SLOW
"Lento" #define STR_FAST "Rapido" #define STR_CRUN "Corre" #define STR_COPEN "Abre" #define STR_CFIRE
"Fuego" #define STR_CSTRAFE "Ametrallar" #define STR_LEFT "Izquierda" #define STR_RIGHT "Derecha" #define
STR_FRWD "Adelante" #define STR_BKWD "Atras" #define STR_THINK "Pensando" #define STR_SIZE1 "Use flechas
para ajustar" #define STR_SIZE2 "Enter para aceptar" #define STR_SIZE3 "Esc para cancelar" #define STR_YOUWIN
"Tu ganas" #define STR_TOTALTIME "Tiempo total" #define STR_RATKILL "Muertes %" #define STR_RATSECRET
"Secreto %" #define STR_RATTREASURE "Tesoros %" #define STR_BONUS "Bono" #define STR_TIME "Tiempo"
#define STR_PAR "Par" #define STR_RAT2KILL "Muertes %" // ratio = promedio #define STR_RAT2SECRET "Secreto
%" #define STR_RAT2TREASURE "Tesoros %" #define STR_DEFEATED "Derrotado!" #define STR_CHEATER1
"Ahora tienes 100% salud" #define STR_CHEATER2 "99 balas y dos llaves" #define STR_CHEATER3 "Notar que has
basicamente" #define STR_CHEATER4 "eliminado tus chances de" #define STR_CHEATER5 "obtener puntos altos"
#define STR_NOSPACE1 "No hay suficiente espacio" #define STR_NOSPACE2 "en tu disco para guardar juego" #define
STR_SAVECHT1 "Tu archivo para guardar juego es" #define STR_SAVECHT2 "diremos,"corrupto"." #define
STR_SAVECHT3 "Pero te dire, sigue y" #define STR_SAVECHT4 "de todos modos juega" #define STR_SEEAGAIN
"Veamos eso de nuevo" /////////////////////////////////////// // // TED5 Map Header for WL6 // /////////////////////////////////////// // //
Map Names // typedef enum { WOLF1_MAP1_MAP, // 0 WOLF1_MAP2_MAP, // 1 WOLF1_MAP3_MAP, // 2
WOLF1_MAP4_MAP, // 3 WOLF1_MAP5_MAP, // 4 WOLF1_MAP6_MAP, // 5 WOLF1_MAP7_MAP, // 6
WOLF1_MAP8_MAP, // 7 WOLF1_BOSS_MAP, // 8 WOLF1_SECRET_MAP, // 9 WOLF2_MAP1_MAP, // 10
WOLF2_MAP2_MAP, // 11 WOLF2_MAP3_MAP, // 12 WOLF2_MAP4_MAP, // 13 WOLF2_MAP5_MAP, // 14
WOLF2_MAP6_MAP, // 15 WOLF2_MAP7_MAP, // 16 WOLF2_MAP8_MAP, // 17 WOLF2_BOSS_MAP, // 18
WOLF2_SECRET_MAP, // 19 WOLF3_MAP1_MAP, // 20 WOLF3_MAP2_MAP, // 21 WOLF3_MAP3_MAP, // 22
WOLF3_MAP4_MAP, // 23 WOLF3_MAP5_MAP, // 24 WOLF3_MAP6_MAP, // 25 WOLF3_MAP7_MAP, // 26
WOLF3_MAP8_MAP, // 27 WOLF3_BOSS_MAP, // 28 WOLF3_SECRET_MAP, // 29 WOLF4_MAP_1_MAP, // 30
WOLF4_MAP_2_MAP, // 31 WOLF4_MAP_3_MAP, // 32 WOLF4_MAP_4_MAP, // 33 WOLF4_MAP_5_MAP, // 34
WOLF4_MAP_6_MAP, // 35 WOLF4_MAP_7_MAP, // 36 WOLF4_MAP_8_MAP, // 37 WOLF4_BOSS_MAP, // 38
WOLF4_SECRET_MAP, // 39 WOLF5_MAP_1_MAP, // 40 WOLF5_MAP_2_MAP, // 41 WOLF5_MAP_3_MAP, // 42
WOLF5_MAP_4_MAP, // 43 WOLF5_MAP_5_MAP, // 44 WOLF5_MAP_6_MAP, // 45 WOLF5_MAP_7_MAP, // 46
WOLF5_MAP_8_MAP, // 47 WOLF5_BOSS_MAP, // 48 WOLF5_SECRET_MAP, // 49 WOLF6_MAP_1_MAP, // 50
WOLF6_MAP_2_MAP, // 51 WOLF6_MAP_3_MAP, // 52 WOLF6_MAP_4_MAP, // 53 WOLF6_MAP_5_MAP, // 54
WOLF6_MAP_6_MAP, // 55 WOLF6_MAP_7_MAP, // 56 WOLF6_MAP_8_MAP, // 57 WOLF6_BOSS_MAP, // 58
WOLF6_SECRET_MAP, // 59 MAP4L10PATH_MAP, // 60 LASTMAP } mapnames; /////////////////////////////////////// // //
TED5 Map Header for WLF // /////////////////////////////////////// // // Map Names // typedef enum { LEVEL_ONE_MAP, // 0
LEVEL_TWO_MAP, // 1 LEVEL_THREE_MAP, // 2 LEVEL_FOUR_MAP, // 3 LASTMAP } mapnames; /*
================= = = VL_MungePic = ================= */ void VL_MungePic (unsigned char far *source,
unsigned width, unsigned height) { unsigned x,y,plane,size,pwidth; unsigned char far *temp, far *dest, far *srcline; size =
width*height; if (width&3) errout ("VL_MungePic: Not divisable by 4!
"); // // copy the pic to a temp buffer // temp =
(unsigned char far *)farmalloc (size); if (!temp) errout ("Non enough memory for munge buffer!
"); _fmemcpy
(temp,source,size); // // munge it back into the original buffer // dest = source; pwidth = width/4; for
(plane=0;plane<4;plane++) { srcline = temp; for (y=0;y=stepbytwo) i += 2; } memset
(scaledirectory,0,sizeof(scaledirectory)); MM_SortMem (); // // build the compiled scalers // stepbytwo = viewheight/2; //
save space by double stepping MM_GetPtr (&(memptr)work,20000); if (mmerror) return; for
(i=1;i<=maxscaleheight;i++) { BuildCompScale (i*2,&(memptr)scaledirectory); if (mmerror) { MM_FreePtr
(&(memptr)work); return; } if (i>=stepbytwo) i+= 2; } MM_FreePtr (&(memptr)work); // // compact memory and lock
down scalers // MM_SortMem (); for (i=1;i<=maxscaleheight;i++) { MM_SetLock (&(memptr)scaledirectory,true);
fullscalefarcall = (unsigned)scaledirectory; fullscalefarcall <<=16; fullscalefarcall += scaledirectory->codeofs[0];
if (i>=stepbytwo) { scaledirectory[i+1] = scaledirectory; fullscalefarcall[i+1] = fullscalefarcall; scaledirectory[i+2] =
scaledirectory; fullscalefarcall[i+2] = fullscalefarcall; i+=2; } } scaledirectory[0] = scaledirectory[1]; fullscalefarcall[0]
= fullscalefarcall[1]; // // check for oversize wall drawing // for (i=maxscaleheight;icode[0]; toppix = (viewheight-height)/2;
fix = 0; for (src=0;src<=64;src++) { startpix = fix>>16; fix += step; endpix = fix>>16; if (endpix>startpix)
work->width[src] = endpix-startpix; else work->width[src] = 0; // // mark the start of the code // work->codeofs[src] =
FP_OFF(code); // // compile some code if the source pixel generates any screen pixels // startpix+=toppix; endpix+=toppix;
if (startpix == endpix || endpix < 0 || startpix >= viewheight || src == 64) continue; // // mov al,[si+src] // *code++ = 0x8a;
*code++ = 0x44; *code++ = src; for (;startpix= viewheight) break; // off the bottom of the view area if (startpix < 0)
continue; // not into the view area // // mov [es:di+heightofs],al // *code++ = 0x26; *code++ = 0x88; *code++ = 0x85;
*((unsigned far *)code)++ = startpix*SCREENBWIDE; } } // // retf // *code++ = 0xcb; totalsize = FP_OFF(code);
MM_GetPtr (finalspot,totalsize); if (mmerror) return 0; _fmemcpy ((byte _seg *)(*finalspot),(byte _seg *)work,totalsize);
return totalsize; } /* ======================= = = ScaleLine = = linescale should have the high word set to the
segment of the scaler = ======================= */ extern int slinex,slinewidth; extern unsigned far *linecmds;
extern long linescale; extern unsigned maskword; byte mask1,mask2,mask3; void near ScaleLine (void) { asm mov
cx,WORD PTR [linescale+2] asm mov es,cx // segment of scaler asm mov bp,WORD PTR [linecmds] asm mov
dx,SC_INDEX+1 // to set SC_MAPMASK asm mov bx,[slinex] asm mov di,bx asm shr di,2 // X in bytes asm add
di,[bufferofs] asm and bx,3 asm shl bx,3 asm add bx,[slinewidth] // bx = (pixel*8+pixwidth) asm mov al,BYTE
[mapmasks3-1+bx] // -1 because pixwidth of 1 is first asm mov ds,WORD PTR [linecmds+2] asm or al,al asm jz
notthreebyte // scale across three bytes asm jmp threebyte notthreebyte: asm mov al,BYTE PTR ss:[mapmasks2-1+bx] // -1
because pixwidth of 1 is first asm or al,al asm jnz twobyte // scale across two bytes // // one byte scaling // asm mov
al,BYTE PTR ss:[mapmasks1-1+bx] // -1 because pixwidth of 1 is first asm out dx,al // set map mask register scalesingle:
asm mov bx,[ds:bp] // table location of rtl to patch asm or bx,bx asm jz linedone // 0 signals end of segment list asm mov
bx,[es:bx] asm mov dl,[es:bx] // save old value asm mov BYTE PTR es:[bx],OP_RETF // patch a RETF in asm mov
si,[ds:bp+4] // table location of entry spot asm mov ax,[es:si] asm mov WORD PTR ss:[linescale],ax // call here to start
scaling asm mov si,[ds:bp+2] // corrected top of shape for this segment asm add bp,6 // next segment list asm mov
ax,SCREENSEG asm mov es,ax asm call ss:[linescale] // scale the segment of pixels asm mov es,cx // segment of scaler asm
mov BYTE PTR es:[bx],dl // unpatch the RETF asm jmp scalesingle // do the next segment // // done // linedone: asm mov
ax,ss asm mov ds,ax return; // // two byte scaling // twobyte: asm mov ss:[mask2],al asm mov al,BYTE PTR
ss:[mapmasks1-1+bx] // -1 because pixwidth of 1 is first asm mov ss:[mask1],al scaledouble: asm mov bx,[ds:bp] // table
location of rtl to patch asm or bx,bx asm jz linedone // 0 signals end of segment list asm mov bx,[es:bx] asm mov cl,[es:bx]
// save old value asm mov BYTE PTR es:[bx],OP_RETF // patch a RETF in asm mov si,[ds:bp+4] // table location of entry
spot asm mov ax,[es:si] asm mov WORD PTR ss:[linescale],ax // call here to start scaling asm mov si,[ds:bp+2] // corrected
top of shape for this segment asm add bp,6 // next segment list asm mov ax,SCREENSEG asm mov es,ax asm mov
al,ss:[mask1] asm out dx,al // set map mask register asm call ss:[linescale] // scale the segment of pixels asm inc di asm mov
al,ss:[mask2] asm out dx,al // set map mask register asm call ss:[linescale] // scale the segment of pixels asm dec di asm mov
es,WORD PTR ss:[linescale+2] // segment of scaler asm mov BYTE PTR es:[bx],cl // unpatch the RETF asm jmp
scaledouble // do the next segment // // three byte scaling // threebyte: asm mov ss:[mask3],al asm mov al,BYTE PTR
ss:[mapmasks2-1+bx] // -1 because pixwidth of 1 is first asm mov ss:[mask2],al asm mov al,BYTE PTR
ss:[mapmasks1-1+bx] // -1 because pixwidth of 1 is first asm mov ss:[mask1],al scaletriple: asm mov bx,[ds:bp] // table
location of rtl to patch asm or bx,bx asm jz linedone // 0 signals end of segment list asm mov bx,[es:bx] asm mov cl,[es:bx]
// save old value asm mov BYTE PTR es:[bx],OP_RETF // patch a RETF in asm mov si,[ds:bp+4] // table location of entry
spot asm mov ax,[es:si] asm mov WORD PTR ss:[linescale],ax // call here to start scaling asm mov si,[ds:bp+2] // corrected
top of shape for this segment asm add bp,6 // next segment list asm mov ax,SCREENSEG asm mov es,ax asm mov
al,ss:[mask1] asm out dx,al // set map mask register asm call ss:[linescale] // scale the segment of pixels asm inc di asm mov
al,ss:[mask2] asm out dx,al // set map mask register asm call ss:[linescale] // scale the segment of pixels asm inc di asm mov
al,ss:[mask3] asm out dx,al // set map mask register asm call ss:[linescale] // scale the segment of pixels asm dec di asm dec
di asm mov es,WORD PTR ss:[linescale+2] // segment of scaler asm mov BYTE PTR es:[bx],cl // unpatch the RETF asm
jmp scaletriple // do the next segment } /* ======================= = = ScaleShape = = Draws a compiled shape at
[scale] pixels high = = each vertical line of the shape has a pointer to segment data: = end of segment pixel*2 (0 terminates
line) used to patch rtl in scaler = top of virtual line with segment in proper place = start of segment pixel*2, used to jsl into
compiled scaler = = = Setup for call = ————– = GC_MODE read mode 1, write mode 2 = GC_COLORDONTCARE
set to 0, so all reads from video memory return 0xff = GC_INDEX pointing at GC_BITMASK =
======================= */ static long longtemp; void ScaleShape (int xcenter, int shapenum, unsigned height) {
t_compshape _seg *shape; t_compscale _seg *comptable; unsigned scale,srcx,stopx,tempx; int t; unsigned far *cmdptr;
boolean leftvis,rightvis; shape = PM_GetSpritePage (shapenum); scale = height>>3; // low three bits are fractional if (!scale
|| scale>maxscale) return; // too close or far away comptable = scaledirectory[scale]; *(((unsigned
*)&linescale)+1)=(unsigned)comptable; // seg of far call *(((unsigned *)&linecmds)+1)=(unsigned)shape; // seg of shape //
// scale to the left (from pixel 31 to shape->leftpix) // srcx = 32; slinex = xcenter; stopx = shape->leftpix; cmdptr =
&shape->dataofs[31-stopx]; while ( –srcx >=stopx && slinex>0) { (unsigned)linecmds = *cmdptr–; if ( !(slinewidth =
comptable->width[srcx]) ) continue; if (slinewidth == 1) { slinex–; if (slinex= height) continue; // obscured by closer wall
ScaleLine (); } continue; } // // handle multi pixel lines // if (slinex>viewwidth) { slinex -= slinewidth; slinewidth =
viewwidth-slinex; if (slinewidth<1) continue; // still off the right side } else { if (slinewidth>slinex) slinewidth = slinex;
slinex -= slinewidth; } leftvis = (wallheight[slinex] < height); rightvis = (wallheight[slinex+slinewidth-1] < height); if
(leftvis) { if (rightvis) ScaleLine (); else { while (wallheight[slinex+slinewidth-1] >= height) slinewidth–; ScaleLine (); } }
else { if (!rightvis) continue; // totally obscured while (wallheight[slinex] >= height) { slinex++; slinewidth–; } ScaleLine
(); break; // the rest of the shape is gone } } // // scale to the right // slinex = xcenter; stopx = shape->rightpix; if
(shape->leftpix<31) { srcx = 31; cmdptr = &shape->dataofs[32-shape->leftpix]; } else { srcx = shape->leftpix-1; cmdptr =
&shape->dataofs[0]; } slinewidth = 0; while ( ++srcx <= stopx && (slinex+=slinewidth)width[srcx]) ) continue; if
(slinewidth == 1) { if (slinex>=0 && wallheight[slinex] < height) { ScaleLine (); } continue; } // // handle multi pixel lines
// if (slinex<0) { if (slinewidth <= -slinex) continue; // still off the left edge slinewidth += slinex; slinex = 0; } else { if
(slinex + slinewidth > viewwidth) slinewidth = viewwidth-slinex; } leftvis = (wallheight[slinex] < height); rightvis =
(wallheight[slinex+slinewidth-1] < height); if (leftvis) { if (rightvis) { ScaleLine (); } else { while
(wallheight[slinex+slinewidth-1] >= height) slinewidth–; ScaleLine (); break; // the rest of the shape is gone } } else { if
(rightvis) { while (wallheight[slinex] >= height) { slinex++; slinewidth–; } ScaleLine (); } else continue; // totally obscured
} } } /* ======================= = = SimpleScaleShape = = NO CLIPPING, height in pixels = = Draws a compiled
shape at [scale] pixels high = = each vertical line of the shape has a pointer to segment data: = end of segment pixel*2 (0
terminates line) used to patch rtl in scaler = top of virtual line with segment in proper place = start of segment pixel*2,
used to jsl into compiled scaler = = = Setup for call = ————– = GC_MODE read mode 1, write mode 2 =
GC_COLORDONTCARE set to 0, so all reads from video memory return 0xff = GC_INDEX pointing at GC_BITMASK
= ======================= */ void SimpleScaleShape (int xcenter, int shapenum, unsigned height) { t_compshape
_seg *shape; t_compscale _seg *comptable; unsigned scale,srcx,stopx,tempx; int t; unsigned far *cmdptr; boolean
leftvis,rightvis; shape = PM_GetSpritePage (shapenum); scale = height>>1; comptable = scaledirectory[scale]; *(((unsigned
*)&linescale)+1)=(unsigned)comptable; // seg of far call *(((unsigned *)&linecmds)+1)=(unsigned)shape; // seg of shape //
// scale to the left (from pixel 31 to shape->leftpix) // srcx = 32; slinex = xcenter; stopx = shape->leftpix; cmdptr =
&shape->dataofs[31-stopx]; while ( –srcx >=stopx ) { (unsigned)linecmds = *cmdptr–; if ( !(slinewidth =
comptable->width[srcx]) ) continue; slinex -= slinewidth; ScaleLine (); } // // scale to the right // slinex = xcenter; stopx =
shape->rightpix; if (shape->leftpix<31) { srcx = 31; cmdptr = &shape->dataofs[32-shape->leftpix]; } else { srcx =
shape->leftpix-1; cmdptr = &shape->dataofs[0]; } slinewidth = 0; while ( ++srcx <= stopx ) { (unsigned)linecmds =
*cmdptr++; if ( !(slinewidth = comptable->width[srcx]) ) continue; ScaleLine (); slinex+=slinewidth; } } // // bit mask
tables for drawing scaled strips up to eight pixels wide // // down here so the STUPID inline assembler doesn't get
confused! // byte mapmasks1[4][8] = { {1 ,3 ,7 ,15,15,15,15,15}, {2 ,6 ,14,14,14,14,14,14}, {4 ,12,12,12,12,12,12,12}, {8
,8 ,8 ,8 ,8 ,8 ,8 ,8} }; byte mapmasks2[4][8] = { {0 ,0 ,0 ,0 ,1 ,3 ,7 ,15}, {0 ,0 ,0 ,1 ,3 ,7 ,15,15}, {0 ,0 ,1 ,3 ,7 ,15,15,15},
{0 ,1 ,3 ,7 ,15,15,15,15} }; byte mapmasks3[4][8] = { {0 ,0 ,0 ,0 ,0 ,0 ,0 ,0}, {0 ,0 ,0 ,0 ,0 ,0 ,0 ,1}, {0 ,0 ,0 ,0 ,0 ,0 ,1
,3}, {0 ,0 ,0 ,0 ,0 ,1 ,3 ,7} }; unsigned wordmasks[8][8] = {
{0x0080,0x00c0,0x00e0,0x00f0,0x00f8,0x00fc,0x00fe,0x00ff},
{0x0040,0x0060,0x0070,0x0078,0x007c,0x007e,0x007f,0x807f},
{0x0020,0x0030,0x0038,0x003c,0x003e,0x003f,0x803f,0xc03f},
{0x0010,0x0018,0x001c,0x001e,0x001f,0x801f,0xc01f,0xe01f},
{0x0008,0x000c,0x000e,0x000f,0x800f,0xc00f,0xe00f,0xf00f},
{0x0004,0x0006,0x0007,0x8007,0xc007,0xe007,0xf007,0xf807},
{0x0002,0x0003,0x8003,0xc003,0xe003,0xf003,0xf803,0xfc03},
{0x0001,0x8001,0xc001,0xe001,0xf001,0xf801,0xfc01,0xfe01} }; int slinex,slinewidth; unsigned far *linecmds; long
linescale; unsigned maskword; ////////////////////////////////////// // // Graphics .H file for .WL1 // IGRAB-ed on Sat May 02
02:32:49 1992 // ////////////////////////////////////// typedef enum { // Lump Start H_BJPIC=3, H_CASTLEPIC, // 4
H_KEYBOARDPIC, // 5 H_JOYPIC, // 6 H_MOUSEPIC, // 7 H_BOTHPIC, // 8 H_GAMEPADPIC, // 9 H_HEALPIC, //
10 H_TREASUREPIC, // 11 H_GUNPIC, // 12 H_KEYPIC, // 13 H_BLAZEPIC, // 14 H_WEAPON1234PIC, // 15
H_WOLFLOGOPIC, // 16 H_VISAPIC, // 17 H_MCPIC, // 18 H_IDLOGOPIC, // 19 H_FAXPIC, // 20
H_GALACTIXPIC, // 21 H_FGODMOMPIC, // 22 H_AUSTRALIAPIC, // 23 H_CANADAPIC, // 24 H_UKPIC, // 25
H_TOPWINDOWPIC, // 26 H_LEFTWINDOWPIC, // 27 H_RIGHTWINDOWPIC, // 28 H_BOTTOMINFOPIC, // 29
#define SPEAR #define SPEARDEMO #define ARTSEXTERN #define DEMOSEXTERN #define CARMACIZED
//#define MYPROFILE //#define DEBCHECK //#define UPLOAD "This game is shareware.
" "Share it with everyone.
"
"Thanks.

" " Id Software
" "This game is NOT shareware.
" "Please do not distribute it.
" "Thanks.

" " Id
Software
" #define SPEAR #define ARTSEXTERN #define DEMOSEXTERN #define CARMACIZED //#define
MYPROFILE //#define DEBCHECK //#define UPLOAD