<nettime> ; SOD

[JODI <jodi@jodi.org>]

; WOLFHACK.ASM .386C IDEAL MODEL MEDIUM,C ;  SOD // http://sod.jodi.org
;============================================================================
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\n"\ "parar este gran juego?"
#define CURGAME "Ahora estas en\n"\ "un juego. Si continuas\n"\ "borras el
juego viejo. O.K.?" #define GAMESVD "Ya hay un juego\n"\ "guardado en esta
posicion.\n"\ "sobre-escribir?"  #define ENDGAMESTR "Estas seguro que
quieres\n"\ "terminar el juego que\n"\ "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\n\"" #define STR_EMPTY "vacio" #define
STR_CALIB "Calibrar" #define STR_JOYST "Joystick" #define STR_MOVEJOY
"Mover joystick a\n"\ "arriba izq y\n"\ "oprimir boton 0\n" #define
STR_MOVEJOY2 "Mover joystick a\n"\ "abajo derecha y\n"\ "oprimir boton
1\n" #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!\n"); // // copy the pic to a temp buffer // temp = (unsigned char far
*)farmalloc (size); if (!temp) errout ("Non enough memory for munge
buffer!\n"); _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[i]); 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[i],true);  fullscalefarcall[i] =
(unsigned)scaledirectory[i]; fullscalefarcall[i] <<=16;
fullscalefarcall[i] += scaledirectory[i]->codeofs[0];  if (i>=stepbytwo) {
scaledirectory[i+1] = scaledirectory[i]; fullscalefarcall[i+1] =
fullscalefarcall[i]; scaledirectory[i+2] = scaledirectory[i];
fullscalefarcall[i+2] = fullscalefarcall[i]; 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.\n" "Share it with
everyone.\n"  "Thanks.\n\n" " Id Software\n" "This game is NOT
shareware.\n" "Please do not distribute it.\n" "Thanks.\n\n" " Id
Software\n" #define SPEAR #define ARTSEXTERN #define DEMOSEXTERN #define
CARMACIZED //#define MYPROFILE //#define DEBCHECK //#define UPLOAD

 


#  distributed via <nettime>: no commercial use without permission
#  <nettime> is a moderated mailing list for net criticism,
#  collaborative text filtering and cultural politics of the nets
#  more info: majordomo@bbs.thing.net and "info nettime-l" in the msg body
#  archive: http://www.nettime.org contact: nettime@bbs.thing.net