id-software/TED5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ded6b82878517e30c8ba6285a2c7f13a1d89f382
TED5/TED5-4.C
T
Ben N ded6b82878 Initial put
2014-06-14 13:53:43 -05:00

2634 lines
52 KiB
C++
Raw Blame History

////////////////////////////////////////////////////
////////////////////////////////////////////////////
//
// TED5-4
//
////////////////////////////////////////////////////
////////////////////////////////////////////////////
#include "ted5.h"
#pragma hdrstop
void SignalSound(void)
{
int i;
for(i=0;i<10;i++)
{
sound(500+i*500);
delay(5);
nosound();
}
}
////////////////////////////////////////////////////
//
// Create an OBJ linkable file from any type of datafile
//
// Exit:
// 0 = everything's a-ok!
// -1 = file not found
// -2 = file >64K
//
////////////////////////////////////////////////////
int MakeOBJ(char *filename,char *destfilename,char *public,segtype whichseg,char *farname)
{
char THEADR[17]={0x80,14,0,12,32,32,32,32,32,32,32,32,32,32,32,32,0},
COMENT[18]={0x88,0,0,0,0,'M','a','k','e','O','B','J',' ','v','1','.','1',0},
LNAMES[42]={0x96,0,0,
6,'D','G','R','O','U','P',
5,'_','D','A','T','A',
4,'D','A','T','A',
0,
5,'_','T','E','X','T',
4,'C','O','D','E',
8,'F','A','R','_','D','A','T','A'},
SEGDEF[9]={0x98,7,0,0x48,0,0,2,3,4}, // for .DATA
SEGDEF1[9]={0x98,7,0,0x48,0,0,5,6,4}, // for .CODE
SEGDEF2[9]={0x98,7,0,0x60,0,0,8,7,4}, // for .FARDATA
GRPDEF[7]={0x9a,4,0,1,0xff,1,0x61},
MODEND[5]={0x8a,2,0,0,0x74};
unsigned i,j,flag,handle;
long fsize,offset,loffset,temp,amtleft,amount,offset1;
char _seg *dblock,*block;
//
// Need to compute the CHECKSUM in the COMENT field
// (so if the "MakeOBJ..." string is modified, the CHECKSUM
// will be correct).
//
COMENT[1]=sizeof(COMENT)-3;
for (flag=i=0;i<sizeof(COMENT);i++)
flag+=COMENT[i];
COMENT[sizeof(COMENT)-1]=(flag^0xff)+1;
if ((handle=open(filename,O_BINARY))==NULL)
return -1;
fsize=filelength(handle);
close(handle);
if (fsize>0x10000L) // BIGGER THAN 1 SEG = ERROR!
return -2;
LoadIn(filename,(memptr *)&block); // LOAD FILE IN
offset=0;
MMAllocate((memptr *)&dblock,0x10000L);
////////////////////////////////////////////////////
//
// INSERT HEADER RECORD
//
movedata(_DS,FP_OFF(&THEADR),(unsigned)dblock,offset,sizeof(THEADR));
movedata(FP_SEG(filename),FP_OFF(filename),
(unsigned)dblock,offset+4,strlen(filename));
offset+=sizeof(THEADR);
////////////////////////////////////////////////////
//
// INSERT COMMENT RECORD
//
movedata(_DS,FP_OFF(COMENT),(unsigned)dblock,offset,sizeof(COMENT));
offset+=sizeof(COMENT);
////////////////////////////////////////////////////
//
// INSERT START OF LIST-OF-NAMES RECORD
//
loffset=offset;
movedata(_DS,FP_OFF(LNAMES),(unsigned)dblock,offset,sizeof(LNAMES));
offset+=sizeof(LNAMES);
// If it's a .FARDATA segment, we need to insert the segment name!
if (whichseg==FARDATA)
{
*(dblock+offset)=strlen(farname);
movedata(FP_SEG(farname),FP_OFF(farname),
(unsigned)dblock,offset+1,strlen(farname));
offset+=strlen(farname)+1;
}
// Now, finish the List-Of-Names record by creating
// the CHECKSUM and LENGTH
temp=offset;
offset=offset-loffset-2;
*(int huge *)(dblock+loffset+1)=offset;
offset=temp;
// Now, figure out the CHECKSUM of the record
for (flag=i=0;i<(offset-loffset);i++)
flag+=*(dblock+i+loffset);
*(dblock+offset)=(flag^0xff)+1;
offset++;
////////////////////////////////////////////////////
//
// CREATE SEGMENT DEFINITION RECORD
//
loffset=offset;
temp=fsize;
switch(whichseg)
{
case DATA:
movedata(FP_SEG(&SEGDEF),FP_OFF(&SEGDEF),
(unsigned)dblock,offset,sizeof(SEGDEF));
*(int huge *)(dblock+offset+4)=temp;
offset+=sizeof(SEGDEF);
break;
case CODE:
movedata(FP_SEG(&SEGDEF1),FP_OFF(&SEGDEF1),
(unsigned)dblock,offset,sizeof(SEGDEF1));
*(int huge *)(dblock+offset+4)=temp;
offset+=sizeof(SEGDEF1);
break;
case FARDATA:
movedata(FP_SEG(&SEGDEF2),FP_OFF(&SEGDEF2),
(unsigned)dblock,offset,sizeof(SEGDEF2));
*(int huge *)(dblock+offset+4)=temp;
offset+=sizeof(SEGDEF2);
break;
}
// CHECKSUM
for (flag=0,i=loffset;i<offset;i++)
flag+=*(dblock+i);
*(dblock+offset)=(flag^0xff)+1;
offset++;
////////////////////////////////////////////////////
//
// CREATE GROUP DEFINITION RECORD
//
switch(whichseg)
{
case DATA:
case CODE:
movedata(FP_SEG(&GRPDEF),FP_OFF(&GRPDEF),
(unsigned)dblock,offset,sizeof(GRPDEF));
offset+=sizeof(GRPDEF);
}
////////////////////////////////////////////////////
//
// CREATE PUBLIC DEFINITION RECORD
//
loffset=offset;
*(dblock+offset)=0x90; // PUBDEF ID
offset+=3; // point to public base, skip length
*(dblock+offset)=1; // group index=1
*(dblock+offset+1)=1; // segment index=1
offset+=2; // point to public name
temp=0;
movedata(FP_SEG(public),FP_OFF(public),
(unsigned)dblock,offset+1,strlen(public));
*(dblock+offset)=strlen(public);
offset+=strlen(public)+1;
*(int huge *)(dblock+offset)=0; // public offset within segment
offset+=2;
*(dblock+offset)=0; // type index
offset++;
// LENGTH
temp=offset-loffset-2;
*(int huge *)(dblock+loffset+1)=temp;
offset++;
// CHECKSUM
for (flag=0,i=loffset;i<offset;i++)
flag+=*(dblock+i);
*(dblock+offset)=(flag^0xff)+1;
////////////////////////////////////////////////////
//
// DATA RECORD(S). YUCK.
//
amtleft=fsize;
amount=1024;
for (i=0;i<(fsize+1023)/1024;i++)
{
offset1=offset;
if (amtleft<1024)
amount=amtleft;
//
// RECORD HEADER
//
*(dblock+offset)=0xa0; // LEDATA ID
*(int huge *)(dblock+offset+1)=amount+4; // length of record
offset+=3;
*(dblock+offset)=1; // segment index
*(int huge *)(dblock+offset+1)=i*1024; // index into segment
offset+=3;
//
// LOAD DATA IN
//
LoadFile(filename,(char huge *)dblock+offset,i*1024,amount);
offset+=amount;
//
// CHECKSUM!
//
for (flag=0,j=offset1;j<offset;j++)
flag+=*(dblock+j);
*(dblock+offset)=(flag^0xff)+1;
offset++;
amtleft-=1024;
}
////////////////////////////////////////////////////
//
// MODULE END! YES!
//
movedata(FP_SEG(&MODEND),FP_OFF(&MODEND),(unsigned)dblock,offset,sizeof(MODEND));
offset+=sizeof(MODEND);
//
// Save the little puppy out!
//
SaveFile(destfilename,(char huge *)dblock,0,offset);
MMFreePtr((memptr *)&dblock);
MMFreePtr((memptr *)&block);
return 0;
}
////////////////////////////////////////////////////
//
// DUMP THE PASTE BUFFER OUT TO EITHER AN
// "APPLE PREFERRED" OR "ILBM" GRAPHICS FORMAT FILE
//
// NOTE: THIS IS ONLY AVAILABLE IN EGA, BECAUSE I
// DON'T FEEL LIKE WRITING A CGA ILBM PIXEL-SPLICER --
// AND APPLE PREFERRED ONLY HANDLES 4-BIT COLOR ANYWAY!
// (YES, I KNOW, I COULD ONLY USE 4 OUT OF 16 COLORS...SHUT UP!)
//
////////////////////////////////////////////////////
btype dumpB[]={{" DeluxePaint II ILBM ",4,2,2},
{" Apple Preferred ",4,5,1}},
fnameB={" ",4,3,1};
DialogDef dumpD={" Which format do you require?",30,7,2,&dumpB[0],NULL},
fnameD={"Enter filename to\nsave (no suffix)",17,5,1,&fnameB,NULL};
void Item_GraphicDump(void)
{
char filename[14],ext[5],_seg *block,_seg *block1;
ApPrefStr PrefHeader;
int which,i,j,k,m,n,pwidth,lwidth,dx,dy;
long tilelen,fsize=0,bufsize;
if (!PasteOK)
{
ErrDialog("You need to use the Copy command\n"
"to copy part of the map or tiles\n"
"so I know what I need to dump!"," OK ");
return;
}
switch(videomode)
{
case CGA:
case VGA:
ErrDialog("Sorry, but this function is only\n"
"available for EGA mode. If you\n"
"have a REAL NEED for this to work\n"
"in CGA or VGA, talk to Id Software!"," OK ");
return;
}
if (!(which=DoDialog(&dumpD)))
return;
//
// SET TILE LENGTH
//
switch(tsize)
{
case 1: tilelen=32L; break;
case 2: tilelen=128L; break;
case 3: tilelen=512L;
}
//
// GET FILENAME TO SAVE UNDER
//
DrawDialog(&fnameD,1);
MouseHide();
GetButtonXY(&fnameD,0,&sx,&sy);
if (!input(filename,8))
{
RestoreBackground();
MouseShow();
return;
}
for (i=0;i<strlen(filename);i++)
if (filename[i]=='.')
{
filename[i]=0;
break;
}
RestoreBackground();
MouseShow();
//
// SETUP FOR EACH TYPE
//
switch(which)
{
case 1: // ILBM
{
long size;
char form[5]="FORM",ilbm[9]="ILBMBMHD",body[5]="BODY";
size=48L;
MMAllocate((memptr *)&block,size);
movedata(FP_SEG(form),FP_OFF(form),(unsigned)block,fsize,4);
fsize+=4;
size=40L+tilelen*TileCopy.w*TileCopy.h;
*(block+fsize)=(size>>24)&0xff;
*(block+fsize+1)=(size>>16)&0xff;
*(block+fsize+2)=(size>>8)&0xff;
*(block+fsize+3)=size&0xff;
fsize+=4;
movedata(FP_SEG(ilbm),FP_OFF(ilbm),(unsigned)block,fsize,8);
fsize+=8;
*(block+fsize)=0;
*(block+fsize+1)=0;
*(block+fsize+2)=0;
*(block+fsize+3)=20;
fsize+=4;
*(block+fsize)=(TileCopy.w<<(tsize+2))/256; // pixel width
*(block+fsize+1)=(TileCopy.w<<(tsize+2))&0xff;
*(block+fsize+2)=(TileCopy.h<<(tsize+2))/256; // pixel height
*(block+fsize+3)=(TileCopy.h<<(tsize+2))&0xff;
*(int huge *)(block+fsize+4)=0; // Xorg
*(int huge *)(block+fsize+6)=0; // Yorg
*(block+fsize+8)=4; // planes
*(block+fsize+9)=0; // mask (stencil!)
*(block+fsize+10)=0; // compression (none)
*(block+fsize+11)=0; // pad (?)
*(int huge *)(block+fsize+12)=0; // trans (?)
*(int huge *)(block+fsize+14)=0x101; // aspt (aspect?)
*(int huge *)(block+fsize+16)=0x4001; // page width
*(int huge *)(block+fsize+18)=0xc800; // page height
fsize+=20;
movedata(FP_SEG(body),FP_OFF(body),(unsigned)block,fsize,4);
fsize+=4;
size=tilelen*TileCopy.w*TileCopy.h;
*(block+fsize)=(size>>24)&0xff;
*(block+fsize+1)=(size>>16)&0xff;
*(block+fsize+2)=(size>>8)&0xff;
*(block+fsize+3)=size&0xff;
fsize+=4;
strcpy(ext,".LBM");
}
break;
case 2: // APPLE PREFERRED
{
int Ctable[16]={0x0000,0x000a,0x00a0,0x00aa,0x0a00,0x0a0a,0x0a50,0x0aaa,
0x0555,0x055f,0x05f5,0x05ff,0x0f55,0x0f5f,0x0ff5,0x0fff};
long size,pixwid;
PrefHeader.length=sizeof(ApPrefStr)+4L*(TileCopy.h<<(tsize+2))+
TileCopy.w*TileCopy.h*tilelen+(((TileCopy.w*TileCopy.h*tilelen)+63)/64);
strncpy(PrefHeader.Kind,"\x4MAIN",5);
PrefHeader.MasterMode=0;
PrefHeader.PixelsPerLine=TileCopy.w<<(tsize+2);
PrefHeader.NumColorTables=1;
for (i=0;i<16;i++)
PrefHeader.ColorTable[i]=Ctable[i];
PrefHeader.NumScanLines=TileCopy.h<<(tsize+2);
size=sizeof(ApPrefStr)+4L*(TileCopy.h<<(tsize+2));
MMAllocate((memptr *)&block,size);
movedata(FP_SEG(&PrefHeader),FP_OFF(&PrefHeader),(unsigned)block,fsize,sizeof(ApPrefStr));
fsize+=sizeof(ApPrefStr);
pixwid=TileCopy.w*(2<<tsize);
for (i=0;i<(TileCopy.h<<(tsize+2));i++)
{
*(int huge *)(block+fsize)=pixwid+(pixwid+63)/64;
*(int huge *)(block+fsize+2)=0;
fsize+=4;
}
strcpy(ext,".APP");
MMAllocate((memptr *)&block1,tilelen*TileCopy.w);
}
}
//
// SAVE HEADER OUT
//
strcat(filename,ext);
SaveFile(filename,(char huge *)block,0,fsize);
MMFreePtr((memptr *)&block);
//
// NOW, WRITE THE DATA OUT! EEEE!
//
bufsize=tilelen*TileCopy.w;
MMAllocate((memptr *)&block,bufsize);
pwidth=(1<<(tsize-1))*TileCopy.w;
lwidth=pwidth*4;
ErrDialog("One moment. I am busy.\n Countdown:","");
dx=sx;
dy=sy;
for (j=0;j<TileCopy.h;j++)
{
sx=dx;
sy=dy;
printint(TileCopy.h-j);
print(" ");
for (i=0;i<TileCopy.w;i++)
{
unsigned tilet,tilem,tilei,loc;
//
// ESC out?
//
if (keydown[1])
{
RestoreBackground();
while(keydown[1]);
ErrDialog("You aborted out of the\n"
"graphic dump conversion!"," Yes, I know ");
if (which==2)
MMFreePtr((memptr *)&block1);
return;
}
//
// GET THE CORRECT TILE MOVED INTO "TDATA"
//
switch(TileCopy.MapOrTileSelect)
{
case 0: // MAP COPY
loc=(j+TileCopy.y)*mapwidth+TileCopy.x+i;
tilet=(TileCopy.PlanesCopied&BPLANE)?CutBkgnd[loc]:-BkgndColor;
tilem=(TileCopy.PlanesCopied&FPLANE)?CutFrgnd[loc]+tilenum:0;
tilei=(TileCopy.PlanesCopied&IPLANE)?CutInfoPl[loc]+tilenum:0;
CombineTiles(tilet,tilem,tilei,tsize);
break;
case 1: // BKGND TILE COPY
loc=(TileCopy.y+j)*selectcols+TileCopy.x+i;
CombineTiles(loc,0,0,tsize);
break;
case 2: // FRGND TILE COPY
loc=(TileCopy.y+j)*selectcols+TileCopy.x+i+tilenum;
CombineTiles(-BkgndColor,loc,0,tsize);
}
//
// NOW, MUNGE "TDATA" INTO BIT-PLANES!
//
// INTERNAL: P0 P1 P2 P3
// SCANLINE x ...... ...... ...... ......
//
for (k=0;k<8<<(tsize-1);k++)
for (m=0;m<4;m++)
movedata(FP_SEG(&tdata),FP_OFF(&tdata)+(m*tsize*(8<<(tsize-1)))+k*(1<<(tsize-1)),
(unsigned)block,k*lwidth+m*pwidth+i*(1<<(tsize-1)),1<<(tsize-1));
}
//
// ALRIGHT. NOW SAVE THIS CHUNK OUT IN THE CORRECT FORMAT
//
switch(which)
{
case 1: // ILBM
SaveFile(filename,MK_FP(block,0),fsize,bufsize);
fsize+=bufsize;
break;
case 2: // APPLE PREFERRED
{
int len,clen;
//
// FIRST, I NEED TO CONVERT THE ILBM PLANAR FORMAT
// TO SUPER-RES NIBBLES
//
for (k=0;k<8<<(tsize-1);k++)
for (m=0;m<(1<<(tsize-1))*TileCopy.w;m++)
{
unsigned char src[4],dest[4]={0,0,0,0};
for (n=0;n<4;n++)
src[n]=block[k*lwidth+pwidth*n+m];
asm mov al,[BYTE PTR src+0]
asm mov ah,[BYTE PTR src+1]
asm mov bl,[BYTE PTR src+2]
asm mov bh,[BYTE PTR src+3]
// dest[0]
asm shl bh,1
asm rcl cl,1
asm shl bl,1
asm rcl cl,1
asm shl ah,1
asm rcl cl,1
asm shl al,1
asm rcl cl,1
asm shl bh,1
asm rcl cl,1
asm shl bl,1
asm rcl cl,1
asm shl ah,1
asm rcl cl,1
asm shl al,1
asm rcl cl,1
// dest[1]
asm shl bh,1
asm rcl ch,1
asm shl bl,1
asm rcl ch,1
asm shl ah,1
asm rcl ch,1
asm shl al,1
asm rcl ch,1
asm shl bh,1
asm rcl ch,1
asm shl bl,1
asm rcl ch,1
asm shl ah,1
asm rcl ch,1
asm shl al,1
asm rcl ch,1
// dest[2]
asm shl bh,1
asm rcl dl,1
asm shl bl,1
asm rcl dl,1
asm shl ah,1
asm rcl dl,1
asm shl al,1
asm rcl dl,1
asm shl bh,1
asm rcl dl,1
asm shl bl,1
asm rcl dl,1
asm shl ah,1
asm rcl dl,1
asm shl al,1
asm rcl dl,1
// dest[3]
asm shl bh,1
asm rcl dh,1
asm shl bl,1
asm rcl dh,1
asm shl ah,1
asm rcl dh,1
asm shl al,1
asm rcl dh,1
asm shl bh,1
asm rcl dh,1
asm shl bl,1
asm rcl dh,1
asm shl ah,1
asm rcl dh,1
asm shl al,1
asm rcl dh,1
asm mov [BYTE PTR dest+0],cl
asm mov [BYTE PTR dest+1],ch
asm mov [BYTE PTR dest+2],dl
asm mov [BYTE PTR dest+3],dh
movedata(FP_SEG(&dest),FP_OFF(&dest),
(unsigned)block1,k*lwidth+m*4,4);
}
//
// NOW, TIME TO WRITE THE DATA OUT IN 64-BYTE CHUNKS! YUCK!
//
for (k=0;k<8<<(tsize-1);k++)
{
char clen;
int off=k*lwidth;;
len=4*pwidth;
while(len>0)
{
if (len>64)
clen=64;
else
clen=len;
clen--;
SaveFile(filename,(char huge *)&clen,fsize++,1);
clen++;
SaveFile(filename,MK_FP(block1,off),fsize,clen);
fsize+=clen;
off+=clen;
len-=clen;
}
}
}
}
}
if (which==2)
MMFreePtr((memptr *)&block1);
MMFreePtr((memptr *)&block);
RestoreBackground();
ErrDialog("Graphic successfully dumped!"," Yeah! ");
}
////////////////////////////////////////////////////
//
// Item - Edit TILEINFO/M values
//
////////////////////////////////////////////////////
btype ETVb[]={{" Tileinfo ",2,21,1},
{" TileinfoM ",16,21,1},
{" Exit ",30,21,2}};
DialogDef ETVd={" Edit TILEINFO/M values",38,23,3,&ETVb[0],NULL};
int CurTIvalue;
void Item_EditTinfoValues(void)
{
int max,i,which,exitok=0,mx,my,b0,b1,CTRLdown;
static int whichtinfo=0;
//
// IS THE "CTRL" KEY DOWN?
//
CTRLdown=keydown[0x1d];
if (CTRLdown)
{
if (planeton)
whichtinfo=0;
else
whichtinfo=1;
}
switch(whichtinfo)
{
case 0: max=tilenum; break;
case 1: max=tilemnum;
}
switch(videomode)
{
case CGA:
case EGA1:
case VGA:
ETVd.height=23;
for(i=0;i<3;i++)
ETVb[i].yoff=21;
break;
case EGA2:
ETVd.height=58;
for(i=0;i<3;i++)
ETVb[i].yoff=56;
}
//
// DRAW THE SCREEN
//
DrawDialog(&ETVd,1);
if (CTRLdown)
{
DrawTinfoScreen(whichtinfo,0,-max); // ALIGN TO TOP
switch(whichtinfo)
{
case 0: DrawTinfoScreen(whichtinfo,0,whicht); break;
case 1: DrawTinfoScreen(whichtinfo,0,whichtm-tilenum);
}
}
else
DrawTinfoScreen(whichtinfo,0,0);
do
{
which=CheckButtonsRet(&ETVd);
if (which>=0)
switch(which)
{
case 0:
RestoreBackground();
return;
case 1:
if (whichtinfo)
{
max=tilenum;
whichtinfo=0;
DrawDialog(&ETVd,0);
DrawTinfoScreen(whichtinfo,0,0);
}
else
{
GetButtonXY(&ETVd,0,&sx,&sy);
MouseHide();
print(ETVb[0].text);
MouseShow();
errsound();
}
break;
case 2:
if (!tilemnum)
{
GetButtonXY(&ETVd,1,&sx,&sy);
MouseHide();
print(ETVb[1].text);
MouseShow();
errsound();
break;
}
if (!whichtinfo)
{
max=tilemnum;
whichtinfo=1;
DrawDialog(&ETVd,0);
DrawTinfoScreen(whichtinfo,0,0);
}
else
{
GetButtonXY(&ETVd,1,&sx,&sy);
MouseHide();
print(ETVb[1].text);
MouseShow();
errsound();
}
break;
case 3:
exitok=1;
}
else
{
MouseCoords(&mx,&my);
mx/=8;
my/=8;
b0=MouseButton()&1;
b1=MouseButton()&2;
//
// CHECK FOR BUTTON PRESSES
//
if (b0)
UseTinfoValue(whichtinfo,mx,my,1);
else
if (b1)
UseTinfoValue(whichtinfo,mx,my,0);
//
// SPACE = ENTER VALUES HORIZONTALLY
//
if (keydown[0x39])
{
while(keydown[0x39]);
clearkeys();
EnterTinfoValue(whichtinfo,mx,my,0);
}
//
// CHECK FOR SCROLLING
//
if (keydown[0x48]) // UP
{
DrawTinfoScreen(whichtinfo,0,-1);
if (keydown[0x1d])
while(keydown[0x48]);
}
else
if (keydown[0x50]) // DOWN
{
DrawTinfoScreen(whichtinfo,0,1);
if (keydown[0x1d])
while(keydown[0x50]);
}
else
if (keydown[0x49]) // PGUP
{
DrawTinfoScreen(whichtinfo,0,-8);
if (!keydown[0x1d])
while(keydown[0x49]);
}
else
if (keydown[0x51]) // PGDN
{
DrawTinfoScreen(whichtinfo,0,8);
if (!keydown[0x1d])
while(keydown[0x51]);
}
else
if (keydown[0x47]) // HOME
{
DrawTinfoScreen(whichtinfo,0,-max);
while(keydown[0x47]);
}
else
if (keydown[0x4f]) // END
{
DrawTinfoScreen(whichtinfo,0,max);
while(keydown[0x4f]);
}
else
if (keydown[0x4d]) // RIGHT
{
DrawTinfoScreen(whichtinfo,1,0);
if (!keydown[0x1d])
while(keydown[0x4d]);
}
else
if (keydown[0x4b]) // LEFT
{
DrawTinfoScreen(whichtinfo,-1,0);
if (!keydown[0x1d])
while(keydown[0x4b]);
}
}
} while(!exitok);
RestoreBackground();
}
//
// PICKUP/DROP TILEINFO VALUE AT CURSOR
//
void UseTinfoValue(int whichtinfo,int mx,int my,int PickupOrDrop)
{
int whichx=-1,whichy=-1;
unsigned dialogx,dialogy;
GetDialogXY(&ETVd,&dialogx,&dialogy);
if (mx>=dialogx+10 && mx<=dialogx+45)
whichx=(mx-(dialogx+10))/7;
if (my>=4 && my<=((videomode==EGA2)?55:19))
whichy=(my-4)>>(tsize-1);
switch(whichtinfo)
{
case 0:
if (whichx>=numtplanes)
whichx=-1;
if (whichy>=tilenum)
whichy=-1;
break;
case 1:
if (whichx>=numtmplanes)
whichx=-1;
if (whichy>=tilemnum)
whichy=-1;
}
if (whichx>=0 && whichy>=0)
{
if (!PickupOrDrop)
switch(whichtinfo)
{
case 0: // TILE
CurTIvalue=*(Tinfo[whichx+TIxbase]+whichy+TIybase);
break;
case 1: // MASKED
CurTIvalue=*(TMinfo[whichx+TIxmbase]+whichy+TIymbase);
}
else
switch(whichtinfo)
{
case 0: // TILE
*(Tinfo[whichx+TIxbase]+whichy+TIybase)=CurTIvalue;
DirtyFlag=1;
break;
case 1: // MASKED
*(TMinfo[whichx+TIxmbase]+whichy+TIymbase)=CurTIvalue;
DirtyFlag=1;
}
DrawTinfoScreen(whichtinfo,0,0);
}
while(MouseButton());
}
//
// ENTER TILEINFO/M CELL VALUES
//
void EnterTinfoValue(int whichtinfo,int mx,int my,int H_or_V)
{
int whichx=-1,whichy=-1,val,outok=0,tempx,tempy,maxx,maxy;
unsigned dialogx,dialogy;
GetDialogXY(&ETVd,&dialogx,&dialogy);
if (mx>=dialogx+10 && mx<=dialogx+45)
whichx=(mx-(dialogx+10))/7;
if (my>=4 && my<=((videomode==EGA2)?55:19))
whichy=(my-4)>>(tsize-1);
switch(whichtinfo)
{
case 0:
if (whichx>=numtplanes)
whichx=-1;
if (whichy>=tilenum)
whichy=-1;
break;
case 1:
if (whichx>=numtmplanes)
whichx=-1;
if (whichy>=tilemnum)
whichy=-1;
}
MouseHide();
if (whichx>=0 && whichy>=0)
do
{
//
// INPUT VALUE
//
sx=whichx*7+dialogx+10;
sy=(whichy<<(tsize-1))+4;
print(" ");
sx-=4;
if ((val=inputint(3))!=(int)ESCOUT)
switch(whichtinfo)
{
case 0: // TILE
*(Tinfo[whichx+TIxbase]+whichy+TIybase)=val&0xff;
DirtyFlag=1;
break;
case 1: // MASKED
*(TMinfo[whichx+TIxmbase]+whichy+TIymbase)=val&0xff;
DirtyFlag=1;
}
else
outok=1;
//
// INPUT INTO THE NEXT FIELD!
//
if (!outok)
{
tempx=(whichtinfo?TIxmbase:TIxbase);
tempy=(whichtinfo?TIymbase:TIybase);
maxx=(whichtinfo?numtmplanes:numtplanes);
maxy=(whichtinfo?tilemnum:tilenum);
switch(H_or_V)
{
case 0: // HORIZONTAL
whichx++;
if (tempx+whichx>=maxx)
outok=1;
else
if (whichx>TINFOWIDTH)
{
whichx=TINFOWIDTH;
tempx++;
if (tempx>=maxx)
outok=1;
}
switch(whichtinfo)
{
case 0: TIxbase=tempx; break;
case 1: TIxmbase=tempx;
}
break;
case 1: // VERTICAL
whichy++;
if (tempy+whichy>=maxy)
outok=1;
else
if (whichy>(videomode==EGA2?TINFOHEIGHTEGA2:TINFOHEIGHT))
{
whichy=(videomode==EGA2?TINFOHEIGHTEGA2:TINFOHEIGHT);
tempy++;
if (tempy>=maxy)
outok=1;
}
switch(whichtinfo)
{
case 0: TIybase=tempy; break;
case 1: TIymbase=tempy;
}
}
}
DrawTinfoScreen(whichtinfo,0,0);
} while (!outok);
MouseShow();
}
//
// Draw the Tileinfo screen
//
void DrawTinfoScreen(int thescreen,int deltax,int deltay)
{
int temp,temp1,i,j,width,height,dialogx;
char _seg *Values[10];
MouseHide();
switch(videomode)
{
case CGA:
case EGA1:
case VGA:
dialogx=1;
height=16>>(tsize-1); break;
case EGA2:
dialogx=21;
height=52>>(tsize-1);
}
switch(thescreen)
{
case 0: // TILEINFO
if (height>tilenum)
height=tilenum;
else
{
TIybase+=deltay;
if (TIybase<0)
TIybase=0;
else
if (TIybase+height>tilenum)
TIybase=tilenum-height;
}
temp=TIybase;
break;
case 1: // TILEINFOM
if (height>tilemnum)
height=tilemnum;
else
{
TIymbase+=deltay;
if (TIymbase<0)
TIymbase=0;
else
if (TIymbase+height>tilemnum)
TIymbase=tilemnum-height;
}
temp=TIymbase;
}
//
// DRAW TILES AND THEIR VALUES
//
for (i=0;i<height;i++)
{
sx=dialogx;
sy=(i<<(tsize-1))+4;
printhex(i+temp);
sx=dialogx;
sy++;
print(" ");
sx-=4;
printint(i+temp);
switch(thescreen)
{
case 0:
CombineTiles(temp+i,0,0,tsize);
break;
case 1:
CombineTiles(-BkgndColor,temp+i+tilenum,0,tsize);
}
DrawTile(dialogx+5,(i+2)<<(3+(tsize-1)),tsize);
}
//
// DRAW TILEINFO ARRAYS
//
width=4;
switch(thescreen)
{
case 0:
if (width>numtplanes)
width=numtplanes;
else
{
TIxbase+=deltax;
if (TIxbase<0)
TIxbase=0;
else
if (TIxbase+width>numtplanes)
TIxbase=numtplanes-width;
}
temp1=TIxbase;
for (i=0;i<10;i++)
Values[i]=Tinfo[i];
break;
case 1:
if (width>numtmplanes)
width=numtmplanes;
else
{
TIxmbase+=deltax;
if (TIxmbase<0)
TIxmbase=0;
else
if (TIxmbase+width>numtmplanes)
TIxmbase=numtmplanes-width;
}
temp1=TIxmbase;
for (i=0;i<10;i++)
Values[i]=TMinfo[i];
}
for (j=0;j<width;j++)
{
sx=(dialogx+10)+j*7;
sy=3;
switch(thescreen)
{
case 0:
print(" ");
sx-=7;
fprint(MapFileHeader->tnames[j+TIxbase]);
break;
case 1:
print(" ");
sx-=7;
fprint(MapFileHeader->tmnames[j+TIxmbase]);
}
for (i=0;i<height;i++)
{
sx=(dialogx+10)+j*7;
sy=(i<<(tsize-1))+4;
print("$");
printhexb(Values[j+temp1][i+temp]);
sx=(dialogx+10)+j*7;
sy++;
print(" ");
sx-=3;
printint(Values[j+temp1][i+temp]&0xff);
}
}
MouseShow();
}
////////////////////////////////////////////////////
//
// Item - Add or Delete TILEINFO/M planes
//
////////////////////////////////////////////////////
btype AODb[]={{" Add ",1,3,1},
{" Delete ",8,3,1},
{" Exit ",18,3,2}},
TOMb[]={{" Tileinfo ",1,2,1},
{" TileinfoM ",1,5,1}},
AreSureB2[]={{" Yes ",1,2,1},
{" No ",8,2,2}},
TINb2={" Done ",8,15,1};;
DialogDef AODd={" TILEINFO/M\n Pick a function",25,5,3,&AODb[0],NULL},
TOMd={"Add to what?",13,7,2,&TOMb[0],NULL},
NId={"Gimme a name!",13,4,0,NULL,NULL},
AreSureD2={"Are you sure?",13,4,2,&AreSureB2[0],NULL},
TINd2={" Which to delete?\n"
" TILEINFO TILEINFOM",
22,17,1,&TINb2,NULL};
void Item_AddDelTinfo(void)
{
char temp[16];
int which,i;
unsigned dx,dy;
while(1)
{
which=DoDialog(&AODd);
switch(which)
{
case 0: // ESC or EXIT
case 3:
return;
//
// ADD
//
case 1:
which=DoDialog(&TOMd);
if (!which)
break;
switch(which)
{
case 1:
if (numtplanes==10)
{
ErrDialog("You already have 10 TILEINFO\n"
"planes defined!"," OK ");
return;
}
break;
case 2:
if (!tilemnum)
{
ErrDialog("You crazy shit! You don't\n"
"have any masked tiles!"," Duh! ");
return;
}
if (numtmplanes==10)
{
ErrDialog("You already have 10 TILEINFOM\n"
"planes defined!"," OK ");
return;
}
break;
}
DrawDialog(&NId,1);
MouseHide();
GetDialogXY(&NId,&dx,&dy);
sx=dx+1;
sy=dy+1;
DrawBorder(sx,sy,9,2,1);
sx=dx+2;
sy=dy+2;
if (!input(temp,7))
{
RestoreBackground();
MouseShow();
break;
}
//
// MOVE THE NAME AND ALLOCATE THE MEMORY!
//
switch(which)
{
case 1:
movedata(FP_SEG(temp),FP_OFF(temp),
(unsigned)MapFileHeader,FP_OFF(MapFileHeader->tnames[numtplanes]),8);
MMAllocate((memptr *)&Tinfo[numtplanes],tilenum);
for (i=0;i<tilenum;i++)
*(Tinfo[numtplanes]+i)=0;
MapFileHeader->numtplanes=++numtplanes;
writeH=DirtyFlag=1;
break;
case 2:
movedata(FP_SEG(temp),FP_OFF(temp),
(unsigned)MapFileHeader,FP_OFF(MapFileHeader->tmnames[numtmplanes]),8);
MMAllocate((memptr *)&TMinfo[numtmplanes],tilemnum);
for (i=0;i<tilemnum;i++)
*(TMinfo[numtmplanes]+i)=0;
MapFileHeader->numtmplanes=++numtmplanes;
writeH=DirtyFlag=1;
}
RestoreBackground();
MouseShow();
break;
//
// DELETE
//
case 2:
{
unsigned ox,oy,i,oktoexit=0;
int which;
redo:
MouseHide();
DrawDialog(&TINd2,1);
GetDialogXY(&TINd2,&sx,&sy);
ox=sx;
oy=sy;
DrawBorder(sx,sy+2,10,11,1);
sx=ox;
sy=oy;
DrawBorder(sx+11,sy+2,10,11,1);
for (i=0;i<10;i++)
{
sx=ox+1;
sy=oy+i+3;
fprint(MapFileHeader->tnames[i]);
sx=ox+12;
sy=oy+i+3;
fprint(MapFileHeader->tmnames[i]);
}
MouseShow();
do
{
if ((which=CheckList(ox+1,oy+3,8,numtplanes,TInfoNon,TInfoNoff,0))>=0)
{
int reply;
RestoreBackground();
reply=DoDialog(&AreSureD2);
switch(reply)
{
case 0:
case 2:
goto redo;
}
if (which!=numtplanes-1)
{
for (i=0;i<8;i++)
{
MapFileHeader->tnames[which][i]=MapFileHeader->tnames[numtplanes-1][i];
MapFileHeader->tnames[numtplanes-1][i]=0;
}
for (i=0;i<tilenum;i++)
*(Tinfo[which]+i)=*(Tinfo[numtplanes-1]+i);
MMFreePtr((memptr *)&Tinfo[numtplanes-1]);
}
else
{
MMFreePtr((memptr *)&Tinfo[which]);
for (i=0;i<8;i++)
MapFileHeader->tnames[which][i]=0;
}
writeH=DirtyFlag=1;
MapFileHeader->numtplanes=--numtplanes;
goto redo;
}
if ((which=CheckList(ox+12,oy+3,8,numtmplanes,TInfoMNon,TInfoMNoff,0))>=0)
{
int reply;
RestoreBackground();
reply=DoDialog(&AreSureD2);
switch(reply)
{
case 0:
case 2:
goto redo;
}
if (which!=numtmplanes-1)
{
for (i=0;i<8;i++)
{
MapFileHeader->tmnames[which][i]=MapFileHeader->tmnames[numtplanes-1][i];
MapFileHeader->tmnames[numtmplanes-1][i]=0;
}
for (i=0;i<tilemnum;i++)
*(TMinfo[which]+i)=*(TMinfo[numtmplanes-1]+i);
MMFreePtr((memptr *)&TMinfo[numtmplanes-1]);
}
else
{
MMFreePtr((memptr *)&TMinfo[which]);
for (i=0;i<8;i++)
MapFileHeader->tmnames[which][i]=0;
}
writeH=DirtyFlag=1;
MapFileHeader->numtmplanes=--numtmplanes;
goto redo;
}
GetButtonXY(&TINd2,0,&sx,&sy);
if (!CheckList(sx,sy,6,1,TIDoneOn,TIDoneOff,1))
oktoexit++;
if (keydown[1])
{
while(keydown[1]);
oktoexit++;
}
}while(!oktoexit);
RestoreBackground();
}
}
}
}
////////////////////////////////////////////////////
//
// Item - Project Re-Select
//
////////////////////////////////////////////////////
btype NGBb[]={{" Do It! ",1,4,2},
{" No! Help! ",16,4,1}};
DialogDef NGBd={"Are you sure you want to\n"
"switch projects? Abort now\n"
"or forever hold your peace!",
28,6,2,&NGBb[0],NULL};
void Item_ProjectReSelect(void)
{
int i,which;
//
// ARE YOU SURE?!
//
which=DoDialog(&NGBd);
if (!which || which==2)
return;
TEDInfo->lastvid=videomode;
TEDInfo->level=whichmap;
SaveTEDInfo();
SaveOutputHeader();
if (!CheckForMapSave())
return;
//
// RELEASE ALL MEMORY
// ---
if (MapBkgnd)
{
MMFreePtr((memptr *)&MapBkgnd);
MMFreePtr((memptr *)&CutBkgnd);
}
if (MapFrgnd)
{
MMFreePtr((memptr *)&MapFrgnd);
MMFreePtr((memptr *)&CutFrgnd);
}
if (MapInfoPl)
{
MMFreePtr((memptr *)&MapInfoPl);
MMFreePtr((memptr *)&CutInfoPl);
}
MMFreePtr((memptr *)&TEDInfo);
MMFreePtr((memptr *)&MapFileHeader);
if (CgaXMS)
{
MMFreePtr((memptr *)&CgaXMSlookup);
XMSFreeMem(CgaXMS);
}
if (EgaXMS)
{
MMFreePtr((memptr *)&EgaXMSlookup);
XMSFreeMem(EgaXMS);
}
if (VgaXMS)
{
MMFreePtr((memptr *)&VgaXMSlookup);
XMSFreeMem(VgaXMS);
}
if (XMSmaps)
XMSFreeMem(XMSmaps);
XMSmaps=CgaXMS=EgaXMS=VgaXMS=xmshandle=0;
for (i=0;i<numtplanes;i++)
if (Tinfo[i])
MMFreePtr((memptr *)&Tinfo[i]);
for (i=0;i<numtmplanes;i++)
if (TMinfo[i])
MMFreePtr((memptr *)&TMinfo[i]);
//
// FORCE RE-INIT
//
writeH=TIxbase=TIxmbase=TIybase=TIymbase=PasteOK=DirtyFlag=ext[0]=0;
lastmap=-1;
FindGraphFile();
LoadInfoFile();
LoadMapHeader();
LoadGraphStuff(0,videomode);
MouseHide();
RedrawDesktop();
MouseShow();
DrawInfoBar();
DrawMap();
}
////////////////////////////////////////////////////
//
// Item - Toggle GRIDMODE on/off
//
////////////////////////////////////////////////////
void Item_GridMode(void)
{
GridMode^=1;
if (PasteMode)
DrawFloatPaste();
DrawMap();
DrawInfoBar();
}
////////////////////////////////////////////////////
//
// Item - Toggle SNAP-PASTE on/off
//
////////////////////////////////////////////////////
void Item_SnapTog(void)
{
if (!PasteMode)
return;
EraseFloatPaste();
SnapMode^=1;
snapx=(pixelx>>(tsize+2))+xbase;
snapy=((pixely-8)>>(tsize+2))+ybase;
snapxsize=TileCopy.w;
snapysize=TileCopy.h;
snapx=snapx-(snapx/snapxsize)*snapxsize;
snapy=snapy-(snapy/snapysize)*snapysize;
DrawInfoBar();
DrawFloatPaste();
}
////////////////////////////////////////////////////
//
// Item - View Map & Goto
//
////////////////////////////////////////////////////
void Item_ViewMap(void)
{
Do_ViewMap(0);
}
////////////////////////////////////////////////////
//
// Item - Review Map & Goto
//
////////////////////////////////////////////////////
void Item_ReviewMap(void)
{
Do_ViewMap(1);
}
////////////////////////////////////////////////////
//
// Code to actually do the ViewMap (and save it in
// EGA memory when finished).
// Entry:
// 0 = ViewMap, as normal & save when done (but only
// if a full map was viewed)
// 1 = RestoreMap for GOTO
//
////////////////////////////////////////////////////
void Do_ViewMap(int how)
{
int _seg *a_bg,_seg *a_fg,_seg *a_in,CopyArea,bl_width,bl_height,bl_x,bl_y,p_info;
char huge *EGA=MK_FP(0xa000,0);
char _seg *block,_seg *gblock[4];
int i,j,k,m,n,pwidth,lwidth,maptype,step,pixnum[4]={0,8,16,32},curpix,
maxpack,curline,lybase,t8=8<<(tsize-1),t1=1<<(tsize-1),scrn_h,scrn_w;
long tilelen,bufsize;
int savevideo;
savevideo=videomode;
MouseHide();
setvideo(EGA1);
MouseShow();
if (videomode!=EGA1 && videomode!=EGA2)
{
ErrDialog("This function is currently\n"
"only usable in EGA mode!"," OK ");
return;
}
//
// SCREEN DIMENSIONS
//
scrn_w=320;
scrn_h=200;
bl_x=bl_y=0;
bl_width=mapwidth;
bl_height=mapheight;
a_bg=MapBkgnd;
a_fg=MapFrgnd;
a_in=MapInfoPl;
p_info=MapFileHeader->maptype;
CopyArea=0;
if ((TileCopy.w>screenw || TileCopy.h>screenh) && !how)
if (Message("\"Yes\" to display full map,\n"
"\"No\" to display COPY buffer.")==1)
{
bl_x=TileCopy.x;
bl_y=TileCopy.y;
bl_width=TileCopy.w;
bl_height=TileCopy.h;
a_bg=CutBkgnd;
a_fg=CutFrgnd;
a_in=CutInfoPl;
p_info=TileCopy.PlanesCopied;
CopyArea=1;
}
//
// VALIDATE WIDTH & HEIGHT
//
if (bl_height<screenh && bl_width<screenw)
{
ErrDialog("The area fits within the\n"
"screen! Forget it!"," Wah! ");
return;
}
//
// FIGURE OUT THE BEST RATIO FOR CONVERSION
//
if (!how)
switch(bl_width>=bl_height)
{
case 1: // WIDTH > HEIGHT
step=(float)(pixnum[tsize]*bl_width)/scrn_w+.5;
if (pixnum[tsize]*bl_width/step>scrn_w)
step++;
if ((float)(pixnum[tsize]*bl_height)/step+.5<scrn_h)
break;
case 0: // HEIGHT > WIDTH
step=(float)(pixnum[tsize]*bl_height)/scrn_h+.5;
if (pixnum[tsize]*bl_height/step>scrn_h)
step++;
}
else
step=VMapData.step;
//
// POP LAST MAP ON SCREEN
//
if (how)
{
unsigned EGAseg=VMapData.EGAseg;
if (!VMapData.built_flag)
{
ErrDialog("You haven't previously\n"
"VIEWed a map!"," OK ");
return;
}
//
// RESTORE MAP IN MEMORY!
//
MouseHide();
outport(GCindex,GCmode | 0x100);
outport(SCindex,SCmapmask | 0xf00);
asm push ds
asm mov ax,[EGAseg]
asm mov ds,ax
asm mov ax,0xa000
asm mov es,ax
asm xor si,si
asm xor di,di
asm mov cx,0x2000
asm rep movsb
asm pop ds
step=VMapData.step;
maxpack=VMapData.maxpack;
MouseShow();
}
//
// BUILD MAP
//
else
{
//
// CLEAR EGA SCREEN
//
outport(GCindex,GCmode);
outport(SCindex,SCmapmask | 0xf00);
_fmemset(MK_FP(0xa000,0),0,0x2000);
//
// SET TILE LENGTH
//
switch(tsize)
{
case 1: tilelen=32L; break;
case 2: tilelen=128L; break;
case 3: tilelen=512L;
}
//
// ALLOCATE TEMP BUFFERS & BEGIN!
//
bufsize=tilelen*bl_width;
pwidth=t1*bl_width;
lwidth=pwidth*4;
MMAllocate((memptr *)&block,bufsize);
maxpack=pwidth/step+1;
for (i=0;i<4;i++)
MMAllocate((memptr *)&gblock[i],maxpack);
outport(GCindex,GCmode);
curline=0;
for (j=bl_y;j<bl_y+bl_height;j++)
{
lybase=j*t8;
for (i=bl_x;i<bl_x+bl_width;i++)
{
unsigned tilet,tilem,tilei,loc;
//
// ESC out?
//
if (keydown[1])
{
while(keydown[1]);
setvideo(savevideo);
RedrawDesktop();
DrawMap();
DrawInfoBar();
return;
}
//
// GET THE CORRECT TILE MOVED INTO "TDATA"
//
loc=j*mapwidth+i;
tilet=viewton?((p_info&BPLANE)?a_bg[loc]:-BkgndColor):-BkgndColor;
tilem=viewmon?((p_info&FPLANE)?a_fg[loc]+tilenum:0):0;
tilei=viewion?((p_info&IPLANE)?a_in[loc]+tilenum:0):0;
CombineTiles(tilet,tilem,tilei,tsize);
//
// NOW, MUNGE "TDATA" INTO BIT-PLANES!
//
// INTERNAL: P0 P1 P2 P3
// SCANLINE x ...... ...... ...... ......
//
for (k=0;k<t8;k++)
if (!((lybase+k)%step))
for (m=0;m<4;m++)
movedata(FP_SEG(&tdata),FP_OFF(&tdata)+(m*tsize*t8)+k*t1,
(unsigned)block,k*lwidth+m*pwidth+(i-bl_x)*t1,t1);
}
//
// CONVERT BIT-PLANE LINES TO COMPRESSED FORM...
//
for (k=0;k<8<<(tsize-1);k++)
{
if (!((lybase+k)%step))
{
int midx=k*lwidth;
curpix=0;
_fmemset(gblock[0],0,maxpack);
_fmemset(gblock[1],0,maxpack);
_fmemset(gblock[2],0,maxpack);
_fmemset(gblock[3],0,maxpack);
for (m=0;m<pwidth*8;m++)
{
if (!(m%step))
{
int temp=curpix/8,
temp1=7-(curpix%8),
temp2=7-(m%8),
idx;
idx=midx+m/8;
#if 1
asm push ds
asm mov ds,[block]
asm mov si,[idx]
asm mov cl,[BYTE PTR temp2]
asm mov ch,[BYTE PTR temp1]
asm mov di,[temp]
asm mov dx,[pwidth]
asm dec dx
asm mov es,[WORD PTR gblock]
asm lodsb
asm shr al,cl
asm and al,1
asm xchg ch,cl
asm shl al,cl
asm xchg ch,cl
asm or [es:di],al
asm add si,dx
asm mov es,[WORD PTR gblock+2]
asm lodsb
asm shr al,cl
asm and al,1
asm xchg ch,cl
asm shl al,cl
asm xchg ch,cl
asm or [es:di],al
asm add si,dx
asm mov es,[WORD PTR gblock+4]
asm lodsb
asm shr al,cl
asm and al,1
asm xchg ch,cl
asm shl al,cl
asm xchg ch,cl
asm or [es:di],al
asm add si,dx
asm mov es,[WORD PTR gblock+6]
asm lodsb
asm shr al,cl
asm and al,1
asm xchg ch,cl
asm shl al,cl
asm xchg ch,cl
asm or [es:di],al
asm add si,dx
asm pop ds
#else
*(gblock[0]+temp)|=((block[idx]>>temp2)&1)<<temp1;
*(gblock[1]+temp)|=((block[idx+pwidth]>>temp2)&1)<<temp1;
*(gblock[2]+temp)|=((block[idx+pwidth*2]>>temp2)&1)<<temp1;
*(gblock[3]+temp)|=((block[idx+pwidth*3]>>temp2)&1)<<temp1;
#endif
curpix++;
}
}
//
// BLAST ONTO THE SCREEN
//
MouseHide();
for (n=0;n<4;n++)
{
outport(SCindex,SCmapmask | (0x100<<n));
for (m=0;m<maxpack;m++)
*(EGA+EGA1lookup[curline]+m)=*(gblock[n]+m);
}
MouseShow();
curline++;
}
}
}
MMFreePtr((memptr *)&block);
for(m=0;m<4;m++)
MMFreePtr((memptr *)&gblock[m]);
//
// SAVE MAP IN MEMORY!
//
if (!CopyArea)
{
unsigned EGAseg=0xa800;
MouseHide();
outport(GCindex,GCmode | 0x100);
outport(SCindex,SCmapmask | 0xf00);
asm push ds
asm mov ax,[EGAseg]
asm mov es,ax
asm mov ax,0xa000
asm mov ds,ax
asm xor si,si
asm xor di,di
asm mov cx,0x2000
asm rep movsb
asm pop ds
VMapData.step=step;
VMapData.built_flag=1;
VMapData.EGAseg=EGAseg;
VMapData.maxpack=maxpack;
MouseShow();
}
}
//
// DONE WITH MAP BUILD-N-DISPLAY
//
SignalSound();
clearkeys();
//
// IF MOUSE BUTTON PRESSED WITHIN REGION, GO THERE!
//
while(!bioskey(1))
if (MouseButton())
{
int x,y;
MouseCoords(&x,&y);
if (x<maxpack*8 && y<(mapheight*t8/step) && !CopyArea)
{
xbase=(x*step)/t8-screenw/2;
ybase=(y*step)/t8-screenh/2;
if (xbase+screenw>mapwidth)
xbase=mapwidth-screenw;
if (ybase+screenh>mapheight)
ybase=mapheight-screenh;
if (xbase<0)
xbase=0;
if (ybase<0)
ybase=0;
}
while(MouseButton());
break;
}
clearkeys();
MouseHide();
setvideo(savevideo);
RedrawDesktop();
DrawMap();
DrawInfoBar();
MouseShow();
}
////////////////////////////////////////////////////
//
// MAP IMPORTING FUNCTIONS FOLLOW:
//
////////////////////////////////////////////////////
char _seg *oldnames,oldmapname[64],oldmapheadname[64],
oldSM_name[64],oldSM_loadname[64];
int IM_swapin(void)
{
int i;
_fstrcpy(mapheadname,TEDInfo->ImportPath);
strcat(mapheadname,oldmapheadname);
if (access(mapheadname,0))
{
strcpy(mapheadname,oldmapheadname);
return 0;
}
_fstrcpy(mapname,TEDInfo->ImportPath);
strcat(mapname,oldmapname);
_fstrcpy(SM_name,TEDInfo->ImportPath);
strcat(SM_name,oldSM_name);
_fstrcpy(SM_loadname,TEDInfo->ImportPath);
strcat(SM_loadname,oldSM_loadname);
MMAllocate((memptr *)&oldnames,100*16);
movedata(FP_SEG(MapNames),FP_OFF(MapNames),(unsigned)oldnames,0,100*16);
MMFreePtr((memptr *)&MapFileHeader);
LoadIn(mapheadname,(memptr *)&MapFileHeader);
for (i=0;i<100;i++)
if (MapFileHeader->dataoffsets[i]>=0)
{
MapHeaderStr TempHead;
LoadFile(mapname,(char huge *)&TempHead,MapFileHeader->dataoffsets[i],sizeof(MapHeaderStr));
strcpy(MapNames[i],TempHead.name);
}
return 1;
}
void IM_swapout(void)
{
if (oldnames) // GET RID OF MAPNAMES
{
strcpy(mapname,oldmapname);
strcpy(mapheadname,oldmapheadname);
strcpy(SM_name,oldSM_name);
strcpy(SM_loadname,oldSM_loadname);
movedata((unsigned)oldnames,0,FP_SEG(MapNames),FP_OFF(MapNames),100*16);
MMFreePtr((memptr *)&oldnames);
MMFreePtr((memptr *)&MapFileHeader);
LoadIn(mapheadname,(memptr *)&MapFileHeader);
}
}
void IM_LoadMap(void)
{
unsigned long csize,size=0;
memptr block;
//
// DEALLOCATE ALL CURRENT MAP MEMORY
//
if (MapBkgnd)
{
MMFreePtr((memptr *)&MapBkgnd);
MMFreePtr((memptr *)&CutBkgnd);
}
if (MapFrgnd)
{
MMFreePtr((memptr *)&MapFrgnd);
MMFreePtr((memptr *)&CutFrgnd);
}
if (MapInfoPl)
{
MMFreePtr((memptr *)&MapInfoPl);
MMFreePtr((memptr *)&CutInfoPl);
}
//
// LOAD MAP HEADER
//
LoadFile(mapname,(char huge *)&MapHeader,MapFileHeader->dataoffsets[whichmap],sizeof(MapHeaderStr));
//
// LOAD & DECOMPRESS MAP PLANES
//
if (MapFileHeader->maptype & BPLANE)
{
LoadFile(mapname,(char huge *)&size,MapHeader.mapbkgndpl,2);
MMAllocate((memptr *)&MapBkgnd,size);
MMAllocate((memptr *)&CutBkgnd,size);
csize=MapHeader.mapbkgndlen-2;
MMAllocate(&block,csize);
LoadFile(mapname,MK_FP(block,0),MapHeader.mapbkgndpl+2,csize);
RLEWExpand(MK_FP(block,0),MK_FP(MapBkgnd,0),size,MapFileHeader->RLEWtag);
MMFreePtr(&block);
}
if (MapFileHeader->maptype & FPLANE)
{
LoadFile(mapname,(char huge *)&size,MapHeader.mapfrgndpl,2);
MMAllocate((memptr *)&MapFrgnd,size);
MMAllocate((memptr *)&CutFrgnd,size);
csize=MapHeader.mapfrgndlen-2;
MMAllocate(&block,csize);
LoadFile(mapname,MK_FP(block,0),MapHeader.mapfrgndpl+2,csize);
RLEWExpand(MK_FP(block,0),MK_FP(MapFrgnd,0),size,MapFileHeader->RLEWtag);
MMFreePtr(&block);
}
if (MapFileHeader->maptype & IPLANE)
{
LoadFile(mapname,(char huge *)&size,MapHeader.mapinfopl,2);
MMAllocate((memptr *)&MapInfoPl,size);
MMAllocate((memptr *)&CutInfoPl,size);
csize=MapHeader.mapinfolen-2;
MMAllocate(&block,csize);
LoadFile(mapname,MK_FP(block,0),MapHeader.mapinfopl+2,csize);
RLEWExpand(MK_FP(block,0),MK_FP(MapInfoPl,0),size,MapFileHeader->RLEWtag);
MMFreePtr(&block);
}
}
void IM_SaveMap(void)
{
memptr block;
long fsize,size,nsize,change;
MapHeaderStr TempHeader;
int i,XMStemp;
char string[100],TEDid[]=IDSTRING;
strcpy(string,"Saving Map, '");
strcat(string,MapHeader.name);
strcat(string,"'.");
ErrDialog(string,"");
//
// SAVE MAP FILE HEADER
//
SaveFile(mapheadname,MK_FP(MapFileHeader,0),0,sizeof(MapFileHeaderStr));
fsize=sizeof(MapFileHeaderStr);
//
// COMPRESS & SAVE TILEINFOS
//
for (i=0;i<numtplanes;i++)
{
MMAllocate(&block,tilenum);
MapFileHeader->tileinfooff[i]=fsize;
nsize=RLEBCompress(MK_FP(Tinfo[i],0),tilenum,MK_FP(block,0),MapFileHeader->RLEWtag);
MapFileHeader->tileinfolen[i]=nsize;
SaveFile(mapheadname,MK_FP(block,0),fsize,nsize);
fsize+=nsize;
MMFreePtr(&block);
}
for (i=0;i<numtmplanes;i++)
{
MMAllocate(&block,tilemnum);
MapFileHeader->tileinfomoff[i]=fsize;
nsize=RLEBCompress(MK_FP(TMinfo[i],0),tilemnum,MK_FP(block,0),MapFileHeader->RLEWtag);
MapFileHeader->tileinfomlen[i]=nsize;
SaveFile(mapheadname,MK_FP(block,0),fsize,nsize);
fsize+=nsize;
MMFreePtr(&block);
}
MapFileHeader->oldtilenum=tilenum;
MapFileHeader->oldtilemnum=tilemnum;
SaveFile(mapheadname,MK_FP(MapFileHeader,2),2,sizeof(MapFileHeaderStr)-2);
//
// SAVE ALREADY COMPRESSED MAPS
//
//
// NOTE: I AM STORING "TED5" AT THE START OF THE FILE BECAUSE
// SAVING THE FILE AT OFFSET 0 WILL TRASH IT (I HAVE TO RE-SAVE THE HEADER!)
//
SaveFile(SM_name,(char huge *)TEDid,0,strlen(TEDid));
fsize=strlen(TEDid);
for (i=0;i<100;i++)
{
long oldoff;
if (MapFileHeader->dataoffsets[i]==-1 || i==whichmap)
continue;
oldoff=MapFileHeader->dataoffsets[i];
LoadFile(SM_loadname,(char huge *)&TempHeader,oldoff,sizeof(MapHeaderStr));
strcpy(TempHeader.name,MapNames[i]);
MapFileHeader->dataoffsets[i]=fsize;
size=TempHeader.mapbkgndlen+TempHeader.mapfrgndlen+TempHeader.mapinfolen;
change=TempHeader.mapbkgndpl-fsize-sizeof(MapHeaderStr);
TempHeader.mapbkgndpl-=change;
TempHeader.mapfrgndpl-=change;
TempHeader.mapinfopl-=change;
SaveFile(SM_name,(char huge *)&TempHeader,fsize,sizeof(MapHeaderStr));
fsize+=sizeof(MapHeaderStr);
MMAllocate(&block,size);
LoadFile(SM_loadname,MK_FP(block,0),oldoff+sizeof(MapHeaderStr),size);
SaveFile(SM_name,MK_FP(block,0),fsize,size);
fsize+=size;
SaveFile(SM_name,"!ID!",fsize,4);
fsize+=4;
MMFreePtr(&block);
}
//
// SAVE CURRENT MAP AT END OF FILE
//
MapFileHeader->dataoffsets[whichmap]=fsize;
MapFileHeader->datalengths[whichmap]=sizeof(MapHeaderStr);
SaveFile(SM_name,(char huge *)&MapHeader,fsize,sizeof(MapHeaderStr));
fsize+=sizeof(MapHeaderStr);
size=MapHeader.width*MapHeader.height*sizeof(int);
MMAllocate(&block,size);
if (MapFileHeader->maptype & BPLANE)
{
MapHeader.mapbkgndpl=fsize;
nsize=RLEWCompress(MK_FP(MapBkgnd,0),size,MK_FP(block,0),MapFileHeader->RLEWtag);
MapHeader.mapbkgndlen=nsize+2;
SaveFile(SM_name,(char huge *)&size,fsize,2);
fsize+=2;
SaveFile(SM_name,MK_FP(block,0),fsize,nsize);
fsize+=nsize;
}
else
MapHeader.mapbkgndlen=0;
if (MapFileHeader->maptype & FPLANE)
{
MapHeader.mapfrgndpl=fsize;
nsize=RLEWCompress(MK_FP(MapFrgnd,0),size,MK_FP(block,0),MapFileHeader->RLEWtag);
MapHeader.mapfrgndlen=nsize+2;
SaveFile(SM_name,(char huge *)&size,fsize,2);
fsize+=2;
SaveFile(SM_name,MK_FP(block,0),fsize,nsize);
fsize+=nsize;
}
else
MapHeader.mapfrgndlen=0;
if (MapFileHeader->maptype & IPLANE)
{
MapHeader.mapinfopl=fsize;
nsize=RLEWCompress(MK_FP(MapInfoPl,0),size,MK_FP(block,0),MapFileHeader->RLEWtag);
MapHeader.mapinfolen=nsize+2;
SaveFile(SM_name,(char huge *)&size,fsize,2);
fsize+=2;
SaveFile(SM_name,MK_FP(block,0),fsize,nsize);
fsize+=nsize;
}
else
MapHeader.mapinfolen=0;
SaveFile(SM_name,"!ID!",fsize,4);
fsize+=4;
MMFreePtr(&block);
// RE-SAVE HEADER
SaveFile(SM_name,(char huge *)&MapHeader,
MapFileHeader->dataoffsets[whichmap],sizeof(MapHeaderStr));
//
// RE-SAVE FILE HEADER
// NOTE: The "2" is so MSDOS doesn't truncate the fucking file!
//
SaveFile(mapheadname,MK_FP(MapFileHeader,2),2,sizeof(MapFileHeaderStr)-2);
unlink(SM_loadname);
rename(SM_name,SM_loadname);
RestoreBackground();
}
////////////////////////////////////////////////////
//
// Item - Import Maps
//
////////////////////////////////////////////////////
btype IMPMb[]={{"New Path",3,2,1},
{" Import ",3,5,1},
{" Exit ",3,8,2}};
DialogDef IMPMd={"Map Importing",13,11,3,&IMPMb[0],NULL};
btype NPb={" ",1,3,1};
DialogDef NPd={"Current Path:",38,5,1,&NPb,NULL};
void Item_ImportMaps(void)
{
char imfile[64],tempstr[40],impath[64];
int oldwhichmap,which,mapnum,i;
int oldxb,oldyb;
CheckForMapSave();
//
// THE IMPORT FUNCTION WILL RID THE SYSTEM OF XMSMAPS
//
if (XMSmaps)
{
XMSFreeMem(XMSmaps);
XMSmaps=0;
}
//
// SAVE PATHS
//
_fstrcpy(impath,TEDInfo->ImportPath);
strcpy(oldmapname,mapname);
strcpy(oldmapheadname,mapheadname);
strcpy(oldSM_name,SM_name);
strcpy(oldSM_loadname,SM_loadname);
oldxb=xbase;
oldyb=ybase;
#pragma warn -sus
oldnames=0;
#pragma warn +sus
oldwhichmap=whichmap;
DrawDialog(&IMPMd,1);
while(1)
{
which=CheckButtons(&IMPMd);
switch(which)
{
//
// NEW PATH
//
case 1:
MouseHide();
DrawDialog(&NPd,1);
GetDialogXY(&NPd,&sx,&sy);
sy++;
sx++;
if (!impath[0])
print("- current dir -");
else
print(impath);
GetButtonXY(&NPd,0,&sx,&sy);
if (input(tempstr,36))
{
strcpy(impath,tempstr);
if (impath[strlen(impath)-1]!='\\')
strcat(impath,"\\");
MouseShow();
if (access(mapheadname,0))
{
ErrDialog("Can't find any TED5\n"
"map files at that path."," OK ");
}
else
{
RestoreBackground();
ErrDialog("Verifying path...","");
_fstrcpy(TEDInfo->ImportPath,impath);
DirtyFlag=1;
}
MouseHide();
}
MouseShow();
RestoreBackground();
break;
//
// IMPORT
//
case 2:
if (!oldnames)
{
ErrDialog("Loading File Info...","");
if (!IM_swapin())
{
RestoreBackground();
ErrDialog("Having problems with your path!"," OK ");
break;
}
RestoreBackground();
}
mapnum=SelectMap(1,CREATED,"TO IMPORT");
if (mapnum>=0)
{
char check[100]="Are you SURE you want to\n"
"Import ";
strcat(check,MapNames[mapnum]);
strcat(check,"?");
if (Message(check)<2)
break;
whichmap=mapnum;
ErrDialog("Importing. One moment.","");
IM_LoadMap();
IM_swapout();
IM_SaveMap();
IM_swapin();
RestoreBackground();
}
break;
//
// EXIT
//
case 0:
case 3:
RestoreBackground();
whichmap=oldwhichmap;
IM_swapout();
LoadMap(whichmap);
xbase=oldxb;
ybase=oldyb;
DrawMap();
return;
}
}
}
////////////////////////////////////////////////////
//
// Item - Visit DOS
//
////////////////////////////////////////////////////
int olddisk;
char oldpath[64]="\\";
void Item_VisitDOS(void)
{
TempStruct LaunchInfo;
char ename[64],temp[40],tiname[14]="TEDINFO.TMP";
long size;
//
// Save the handles for all XMS memory so we don't
// have to re-install this shit!
//
TEDInfo->OldCgaXMS=CgaXMS;
TEDInfo->OldEgaXMS=EgaXMS;
TEDInfo->OldVgaXMS=VgaXMS;
TEDInfo->OldCgaXMSsize=CgaXMSsize;
TEDInfo->OldEgaXMSsize=EgaXMSsize;
TEDInfo->OldVgaXMSsize=VgaXMSsize;
size=4L*(tilenum+tilemnum);
if (CgaXMS)
{
if (1024L*XMSTotalFree()<size)
{
XMSFreeMem(CgaXMS);
TEDInfo->OldCgaXMS=TEDInfo->OldCgaXMSsize=0;
}
else
{
TEDInfo->CgaXMSlook=XMSAllocate(size);
XMSmove(0,(long)MK_FP(CgaXMSlookup,0),TEDInfo->CgaXMSlook,0,size);
}
}
if (EgaXMS)
{
if (1024L*XMSTotalFree()<size)
{
XMSFreeMem(EgaXMS);
TEDInfo->OldEgaXMS=TEDInfo->OldEgaXMSsize=0;
}
else
{
TEDInfo->EgaXMSlook=XMSAllocate(size);
XMSmove(0,(long)MK_FP(EgaXMSlookup,0),TEDInfo->EgaXMSlook,0,size);
}
}
if (VgaXMS)
{
if (1024L*XMSTotalFree()<size)
{
XMSFreeMem(VgaXMS);
TEDInfo->OldVgaXMS=TEDInfo->OldVgaXMSsize=0;
}
else
{
TEDInfo->VgaXMSlook=XMSAllocate(size);
XMSmove(0,(long)MK_FP(VgaXMSlookup,0),TEDInfo->VgaXMSlook,0,size);
}
}
//
// SAVE CURRENT VIDEOMODE FOR LAUNCH RETURN
//
LaunchInfo.lastmode=videomode;
strcpy(LaunchInfo.ext,ext);
SaveFile(tiname,(char huge *)&LaunchInfo,0,sizeof(TempStruct));
TEDInfo->oscrx=xbase;
TEDInfo->oscry=ybase;
_fmemcpy((void far *)TEDInfo->parmstring,(void far *)parmstring,64);
Item_SaveMap();
SaveTEDInfo();
SaveOutputHeader();
if (XMSmaps)
XMSFreeMem(XMSmaps);
strcpy(temp,"Launching ");
_fstrcat((char far *)temp,(char far *)TEDInfo->launchname);
strcat(temp,"...");
ErrDialog(temp,"");
clearkeys();
nosound();
MouseHide();
_fmemcpy((char far *)ename,(char far *)TEDInfo->launchname,14);
RemoveUndoBuffers();
ShutdownKBD();
//
// ARE WE EXITING WITH A BATCH FILE?
//
setvideo(TEXT);
printf("The TED5 DOS shell. Type 'EXIT' to return to TED5.");
//
// SAVE CURRENT DRIVE & PATH
//
olddisk=getdisk();
getcurdir(0,oldpath+1);
MMShutdown();
fcloseall();
spawnlp(P_WAIT,"COMMAND",NULL);
//
// RESET OLD PATH
//
setdisk(olddisk);
chdir(oldpath);
execlp("TED5.EXE","TED5.EXE","/LAUNCH",NULL);
printf("Can't find TED5 for some reason!");
exit(1);
}
////////////////////////////////////////////////////
//
// Item - Paste Overlay toggle
//
////////////////////////////////////////////////////
void Item_POtog(void)
{
F3_flag^=1;
if (PasteMode)
{
EraseFloatPaste();
DrawFloatPaste();
}
}
Reference in New Issue View Git Blame Copy Permalink