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

2090 lines
40 KiB
C++
Raw Blame History

////////////////////////////////////////////////////
////////////////////////////////////////////////////
//
// TED5-1
//
////////////////////////////////////////////////////
////////////////////////////////////////////////////
#include "ted5.h"
#pragma hdrstop
void InputMap(char *lvlname,unsigned *levelw,unsigned *levelh,int exitok);
void MNameOn(int x,int y,int i);
void MNameOff(int x,int y,int i);
void DnarOn(int x,int y);
void DnarOff(int x,int y);
void UparOn(int x,int y);
void UparOff(int x,int y);
void ExitOn(int x,int y);
void ExitOff(int x,int y);
void TInfoNon(int x,int y,int b);
void TInfoNoff(int x,int y,int b);
void TInfoMNon(int x,int y,int b);
void TInfoMNoff(int x,int y,int b);
void TIDoneOn(int x,int y);
void TIDoneOff(int x,int y);
////////////////////////////////////////////////////
//
// SAVE the current map
//
////////////////////////////////////////////////////
void SaveMap(int delmap)
{
memptr block;
long fsize,size,nsize,change;
MapHeaderStr TempHeader;
int i,XMStemp;
char string[100],TEDid[]=IDSTRING;
RemoveUndoBuffers();
if (delmap)
{
LoadFile(mapname,(char huge *)&TempHeader,
MapFileHeader->dataoffsets[whichmap],sizeof(MapHeaderStr));
strcpy(string,"Deleting Map, '");
strcat(string,TempHeader.name);
}
else
{
strcpy(string,"Saving Map, '");
strcat(string,MapHeader.name);
}
strcat(string,"'.");
ErrDialog(string,"");
BackupFile(mapheadname);
BackupFile(SM_loadname);
if (delmap || DirtyFlag)
{
//
// SAVE MAP FILE HEADER
//
if (delmap)
MapFileHeader->dataoffsets[whichmap]=-1;
SaveFile(mapheadname,MK_FP(MapFileHeader,0),0,sizeof(MapFileHeaderStr));
fsize=sizeof(MapFileHeaderStr);
//
// COMPRESS & SAVE TILEINFOS
//
MMAllocate(&block,tilenum);
for (i=0;i<numtplanes;i++)
{
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);
MMAllocate(&block,tilemnum);
for (i=0;i<numtmplanes;i++)
{
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
//
//
// IF MAPS ARE IN XMS ALREADY, ALLOCATE A NEW BUFFER
// TO SHUFFLE ALREADY-COMPRESSED MAPS INTO
//
if (XMSmaps)
{
int planes;
long len=filelen(SM_loadname);
planes=(MapFileHeader->maptype&BPLANE>0)+
(MapFileHeader->maptype&FPLANE>0)+
(MapFileHeader->maptype&IPLANE>0);
len+=2L*mapwidth*mapheight*planes;
if (1024L*XMSTotalFree()<len)
{
XMSFreeMem(XMSmaps);
XMSmaps=0;
}
else
XMStemp=XMSAllocate(len);
}
//
// 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!)
//
if (XMSmaps)
XMSmove(0,(long)&TEDid,XMStemp,0,strlen(TEDid));
else
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];
if (XMSmaps)
XMSmove(XMSmaps,oldoff,0,(long)&TempHeader,sizeof(MapHeaderStr));
else
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;
if (XMSmaps)
XMSmove(0,(long)&TempHeader,XMStemp,fsize,sizeof(MapHeaderStr));
else
SaveFile(SM_name,(char huge *)&TempHeader,fsize,sizeof(MapHeaderStr));
fsize+=sizeof(MapHeaderStr);
if (XMSmaps)
{
XMSmove(XMSmaps,oldoff+sizeof(MapHeaderStr),XMStemp,fsize,size);
fsize+=size;
XMSmove(0,(long)"!ID!",XMStemp,fsize,4);
fsize+=4;
}
else
{
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
//
if (!delmap)
{
MapFileHeader->dataoffsets[whichmap]=fsize;
MapFileHeader->datalengths[whichmap]=sizeof(MapHeaderStr);
if (XMSmaps)
XMSmove(0,(long)&MapHeader,XMStemp,fsize,sizeof(MapHeaderStr));
else
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;
if (XMSmaps)
XMSmove(0,(long)&size,XMStemp,fsize,2);
else
SaveFile(SM_name,(char huge *)&size,fsize,2);
fsize+=2;
if (XMSmaps)
XMSmove(0,(long)MK_FP(block,0),XMStemp,fsize,nsize);
else
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;
if (XMSmaps)
XMSmove(0,(long)&size,XMStemp,fsize,2);
else
SaveFile(SM_name,(char huge *)&size,fsize,2);
fsize+=2;
if (XMSmaps)
XMSmove(0,(long)MK_FP(block,0),XMStemp,fsize,nsize);
else
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;
if (XMSmaps)
XMSmove(0,(long)&size,XMStemp,fsize,2);
else
SaveFile(SM_name,(char huge *)&size,fsize,2);
fsize+=2;
if (XMSmaps)
XMSmove(0,(long)MK_FP(block,0),XMStemp,fsize,nsize);
else
SaveFile(SM_name,MK_FP(block,0),fsize,nsize);
fsize+=nsize;
}
else
MapHeader.mapinfolen=0;
if (XMSmaps)
XMSmove(0,(long)"!ID!",XMStemp,fsize,4);
else
SaveFile(SM_name,"!ID!",fsize,4);
fsize+=4;
MMFreePtr(&block);
// RE-SAVE HEADER
if (XMSmaps)
XMSmove(0,(long)&MapHeader,XMStemp,
MapFileHeader->dataoffsets[whichmap],sizeof(MapHeaderStr));
else
SaveFile(SM_name,(char huge *)&MapHeader,
MapFileHeader->dataoffsets[whichmap],sizeof(MapHeaderStr));
//
// RE-SAVE FILE HEADER
// NOTE: The "2" is so SaveFile doesn't truncate the fucking file!
//
SaveFile(mapheadname,MK_FP(MapFileHeader,2),2,sizeof(MapFileHeaderStr)-2);
}
if (XMSmaps)
{
#define BCSIZE 0x4000
long size=fsize,clen,coff;
//
// SAVE ENTIRE MAPFILE IN XMS TO DISK!
//
XMSFreeMem(XMSmaps);
XMSmaps=XMStemp;
MMAllocate(&block,BCSIZE);
coff=0;
do
{
clen=BCSIZE;
if (size<BCSIZE)
clen=size;
XMSmove(XMSmaps,coff,0,(long)MK_FP(block,0),clen);
SaveFile(SM_loadname,MK_FP(block,0),coff,clen);
size-=BCSIZE;
coff+=clen;
} while(size>0);
MMFreePtr(&block);
}
else
{
unlink(SM_loadname);
rename(SM_name,SM_loadname);
}
}
AllocateUndoBuffers();
UndoRegion.x=-1;
SaveUndo(0,0,mapwidth,mapheight);
RestoreBackground();
}
////////////////////////////////////////////////////
//
// BACKUP FILES!
//
////////////////////////////////////////////////////
void BackupFile(char *filename)
{
#define BUFSIZE 0x8000
memptr block;
long size,clen,coff;
int i;
char backupname[14];
size = filelen(filename);
if (!size)
return;
strcpy(backupname,filename);
for (i=strlen(backupname);i;i--)
if (backupname[i] == '.')
backupname[i+1] = 0;
strcat(backupname,"BAK");
MMAllocate(&block,BUFSIZE);
coff=0;
do
{
clen=BUFSIZE;
if (size<BUFSIZE)
clen=size;
LoadFile(filename,(char far *)block,coff,clen);
SaveFile(backupname,MK_FP(block,0),coff,clen);
size-=BUFSIZE;
coff+=clen;
} while(size>0);
MMFreePtr(&block);
}
////////////////////////////////////////////////////
//
// SAVE OUT TEDINFO FILE
//
////////////////////////////////////////////////////
void SaveTEDInfo(void)
{
BackupFile(infoname);
TEDInfo->oscrx=xbase;
TEDInfo->oscry=ybase;
_fstrcpy(TEDInfo->launchname,(char far *)launchname);
SaveFile(infoname,MK_FP(TEDInfo,0),0,sizeof(InfoStruct));
}
////////////////////////////////////////////////////
//
// WRITE OUT THE OUTPUT HEADER FILE
//
////////////////////////////////////////////////////
char * _nfstrcpy(char *dest,char far *source)
{
int i;
for (i=0;i<_fstrlen(source);i++)
*(dest+i)=*(source+i);
return dest;
}
void SaveOutputHeader(void)
{
char outhead[14]="MAPHEAD.",dot_h[14]="MAPS",t[15],tm[15],temp[40],temp1[40];
FILE *fp;
OutputHeadStr OutHead;
int i,Thelast;
long fsize;
ErrDialog("Saving header...","");
strcat(outhead,ext);
BackupFile(outhead);
memset(&OutHead,0,sizeof(OutputHeadStr));
OutHead.RLEWtag=MapFileHeader->RLEWtag;
for (i=0;i<100;i++)
OutHead.dataoffsets[i]=MapFileHeader->dataoffsets[i];
fsize=sizeof(OutputHeadStr);
SaveFile(outhead,(char huge *)&OutHead,0,fsize);
for (i=0;i<numtplanes;i++)
{
SaveFile(outhead,MK_FP(Tinfo[i],0),fsize,tilenum);
fsize+=tilenum;
}
for (i=0;i<numtmplanes;i++)
{
SaveFile(outhead,MK_FP(TMinfo[i],0),fsize,tilemnum);
fsize+=tilemnum;
}
RestoreBackground();
//
// DUMP OUT A MAPSext.H HEADER FILE
//
if (writeH)
{
ErrDialog("Saving .h file...","");
strcat(dot_h,ext);
strcat(dot_h,".H");
unlink(dot_h);
if ((fp=fopen(dot_h,"wt"))==NULL)
return;
fprintf(fp,"///////////////////////////////////////\n");
fprintf(fp,"//\n");
fprintf(fp,"// TED5 Map Header for %s\n",ext);
fprintf(fp,"//\n");
fprintf(fp,"///////////////////////////////////////\n");
Thelast=99;
for (i=99;i>=0;i--)
if (MapFileHeader->dataoffsets[i]>=0)
{
Thelast=i;
break;
}
fprintf(fp,"\n");
fprintf(fp,"//\n");
fprintf(fp,"// Map Names\n");
fprintf(fp,"//\n");
fprintf(fp,"typedef enum {\n");
for (i=0;i<100;i++)
if (MapFileHeader->dataoffsets[i]>=0)
{
char temp[28];
int j;
strcpy(temp,&MapNames[i][0]);
strcat(temp,"_MAP");
for (j=0;j<strlen(temp);j++)
if (temp[j]==' ')
temp[j]='_';
strcat(temp,",");
while(strlen(temp)<25)
strcat(temp," ");
fprintf(fp,"\t\t%s// %d\n",strupr(temp),i);
}
else
if (i<Thelast)
fprintf(fp,"\t\tEMPTYMAP%d,\n",i);
fprintf(fp,"\t\tLASTMAP\n\t } mapnames;\n");
switch(tsize)
{
case 1:
strcpy(t,"NUMTILE8");
strcpy(tm,"NUMTILE8M");
break;
case 2:
strcpy(t,"NUMTILE16");
strcpy(tm,"NUMTILE16M");
break;
case 3:
strcpy(t,"NUMTILE32");
strcpy(tm,"NUMTILE32M");
}
if (numtplanes)
{
fprintf(fp,"\n");
fprintf(fp,"//\n");
fprintf(fp,"// TILEINFO offsets\n");
fprintf(fp,"//\n");
memset(temp,0,sizeof(temp));
memset(temp1,0,sizeof(temp1));
fprintf(fp,"#define %s\x9\x9%d\n",
strupr(_nfstrcpy(temp,MapFileHeader->tnames[0])),
sizeof(OutputHeadStr));
for (i=1;i<numtplanes;i++)
{
memset(temp,0,sizeof(temp));
memset(temp1,0,sizeof(temp1));
fprintf(fp,"#define %s\x9\x9(%s+%s)\n",
strupr(_nfstrcpy(temp,MapFileHeader->tnames[i])),
strupr(_nfstrcpy(temp1,MapFileHeader->tnames[i-1])),
t);
}
}
if (numtmplanes)
{
fprintf(fp,"\n");
fprintf(fp,"//\n");
fprintf(fp,"// TILEINFOM offsets\n");
fprintf(fp,"//\n");
memset(temp,0,sizeof(temp));
memset(temp1,0,sizeof(temp1));
fprintf(fp,"#define %s\x9\x9(%s+%s)\n",
strupr(_nfstrcpy(temp,MapFileHeader->tmnames[0])),
strupr(_nfstrcpy(temp1,MapFileHeader->tnames[numtplanes-1])),
t);
for (i=1;i<numtmplanes;i++)
{
memset(temp,0,sizeof(temp));
memset(temp1,0,sizeof(temp1));
fprintf(fp,"#define %s\x9\x9(%s+%s)\n",
strupr(_nfstrcpy(temp,MapFileHeader->tmnames[i])),
strupr(_nfstrcpy(temp1,MapFileHeader->tmnames[i-1])),
tm);
}
}
fclose(fp);
writeH=0;
RestoreBackground();
}
}
////////////////////////////////////////////////////
//
// Initialize the TILEINFO/M arrays
//
////////////////////////////////////////////////////
btype TIb[]={{" ",1,2,1},
{" ",1,6,1},
{" Done ",12,9,2}};
DialogDef TId={" How many TILEINFO planes?\n\n\n\n"
" How many TILEINFOM planes?",
27,11,3,&TIb[0],NULL};
void InitTileinfo(void)
{
unsigned temp,which,oktoexit=0,ox,oy,i,j;
long fsize;
numtplanes=numtmplanes=0;
DrawDialog(&TId,1);
GetButtonXY(&TId,0,&sx,&sy);
printint(numtplanes);
if (MapFileHeader->maptype&FPLANE)
{
GetButtonXY(&TId,1,&sx,&sy);
printint(numtmplanes);
}
do
{
which=CheckButtons(&TId);
switch(which)
{
case 1:
MouseHide();
GetButtonXY(&TId,0,&sx,&sy);
ox=sx;
oy=sy;
print(TIb[0].text);
sx=ox;
sy=oy;
if ((temp=inputint(9))!=ESCOUT && temp<11 && temp)
numtplanes=temp;
sx=ox;
sy=oy;
print(TIb[0].text);
sx=ox;
sy=oy;
printint(numtplanes);
MouseShow();
case 2:
MouseHide();
GetButtonXY(&TId,1,&sx,&sy);
ox=sx;
oy=sy;
print(TIb[1].text);
sx=ox;
sy=oy;
if (MapFileHeader->maptype&FPLANE)
{
if ((temp=inputint(9))!=ESCOUT && temp<11 && temp)
numtmplanes=temp;
sx=ox;
sy=oy;
print(TIb[1].text);
sx=ox;
sy=oy;
printint(numtmplanes);
}
MouseShow();
break;
case 3:
MouseHide();
oktoexit=1;
GetButtonXY(&TId,2,&sx,&sy);
print(TIb[2].text);
MouseShow();
}
} while(!oktoexit);
RestoreBackground();
//
// allocate arrays
//
fsize=sizeof(MapFileHeaderStr);
for (i=0;i<numtplanes;i++)
{
MMAllocate((memptr *)&Tinfo[i],tilenum);
MapFileHeader->tileinfooff[i]=fsize; // THIS DOESN'T REALLY MATTER
fsize+=tilenum; // ....YET!
for(j=0;j<tilenum;j++)
*(Tinfo[i]+j)=0;
}
for (i=0;i<numtmplanes;i++)
{
MMAllocate((memptr *)&TMinfo[i],tilemnum);
MapFileHeader->tileinfomoff[i]=fsize;
fsize+=tilemnum;
for(j=0;j<tilemnum;j++)
*(TMinfo[i]+j)=0;
}
MapFileHeader->numtplanes=numtplanes;
MapFileHeader->numtmplanes=numtmplanes;
MapFileHeader->oldtilenum=tilenum;
MapFileHeader->oldtilemnum=tilemnum;
writeH=1;
}
////////////////////////////////////////////////////
//
// Item - Edit the TILEINFO names
//
////////////////////////////////////////////////////
btype TINb={" Done ",8,15,1};
DialogDef TINd={" Enter plane names:\n"
" TILEINFO TILEINFOM",
22,17,1,&TINb,NULL};
void Item_EditTinfoNames(void)
{
unsigned ox,oy,i,oktoexit=0;
int which;
MouseHide();
DrawDialog(&TINd,1);
GetDialogXY(&TINd,&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)
{
char temp[8];
MouseHide();
redo:
sx=ox+1;
sy=oy+which+3;
print(" ");
sx=ox+1;
sy=oy+which+3;
if (input(temp,7))
{
for(i=0;i<8;i++)
MapFileHeader->tnames[which][i]=temp[i];
which++;
writeH=DirtyFlag=1;
if (which<numtplanes)
goto redo;
}
else
TInfoNoff(ox+1,oy+3+which,which);
MouseShow();
}
if ((which=CheckList(ox+12,oy+3,8,numtmplanes,TInfoMNon,TInfoMNoff,0))>=0)
{
char temp[8];
MouseHide();
redo1:
sx=ox+12;
sy=oy+which+3;
print(" ");
sx=ox+12;
sy=oy+which+3;
if (input(temp,7))
{
for(i=0;i<8;i++)
MapFileHeader->tmnames[which][i]=temp[i];
which++;
writeH=DirtyFlag=1;
if (which<numtmplanes)
goto redo1;
}
else
TInfoMNoff(ox+12,oy+3+which,which);
MouseShow();
}
GetButtonXY(&TINd,0,&sx,&sy);
if (!CheckList(sx,sy,6,1,TIDoneOn,TIDoneOff,1))
oktoexit++;
if (keydown[1])
{
while(keydown[1]);
oktoexit++;
}
}while(!oktoexit);
RestoreBackground();
}
void TInfoNon(int x,int y,int b)
{
xormask=1;
sx=x;
sy=y;
if (!MapFileHeader->tnames[b][0])
print(" ");
else
fprint(MapFileHeader->tnames[b]);
xormask=0;
}
void TInfoNoff(int x,int y,int b)
{
sx=x;
sy=y;
if (!MapFileHeader->tnames[b][0])
print(" ");
else
fprint(MapFileHeader->tnames[b]);
}
void TInfoMNon(int x,int y,int b)
{
xormask=1;
sx=x;
sy=y;
if (!MapFileHeader->tmnames[b][0])
print(" ");
else
fprint(MapFileHeader->tmnames[b]);
xormask=0;
}
void TInfoMNoff(int x,int y,int b)
{
sx=x;
sy=y;
if (!MapFileHeader->tmnames[b][0])
print(" ");
else
fprint(MapFileHeader->tmnames[b]);
}
void TIDoneOn(int x,int y)
{
xormask=1;
sx=x;
sy=y;
print(" Done ");
xormask=0;
}
void TIDoneOff(int x,int y)
{
sx=x;
sy=y;
print(" Done ");
}
////////////////////////////////////////////////////
//
// Create a new map!
//
////////////////////////////////////////////////////
void CreateMap(int exitok)
{
unsigned lwidth,lheight,i;
int mapnum;
long size;
char lname[16];
if ((mapnum=SelectMap(exitok,NOTCREATED,"TO CREATE"))==-1)
return;
InputMap(lname,&lwidth,&lheight,exitok);
if (!lname[0])
return;
RemoveUndoBuffers();
SaveCutBuffers();
if (MapBkgnd)
{
MMFreePtr((memptr *)&MapBkgnd);
MMFreePtr((memptr *)&CutBkgnd);
}
if (MapFrgnd)
{
MMFreePtr((memptr *)&MapFrgnd);
MMFreePtr((memptr *)&CutFrgnd);
}
if (MapInfoPl)
{
MMFreePtr((memptr *)&MapInfoPl);
MMFreePtr((memptr *)&CutInfoPl);
}
size=2L*(lwidth*lheight);
if (MapFileHeader->maptype&BPLANE)
{
MMAllocate((memptr *)&MapBkgnd,size);
MMAllocate((memptr *)&CutBkgnd,size);
for(i=0;i<lwidth*lheight;i++)
*(MapBkgnd+i)=*(CutBkgnd+i)=0;
}
if (MapFileHeader->maptype&FPLANE)
{
MMAllocate((memptr *)&MapFrgnd,size);
MMAllocate((memptr *)&CutFrgnd,size);
for(i=0;i<lwidth*lheight;i++)
*(MapFrgnd+i)=*(CutFrgnd+i)=0;
}
if (MapFileHeader->maptype&IPLANE)
{
MMAllocate((memptr *)&MapInfoPl,size);
MMAllocate((memptr *)&CutInfoPl,size);
for(i=0;i<lwidth*lheight;i++)
*(MapInfoPl+i)=*(CutInfoPl+i)=0;
}
whichmap=mapnum;
strcpy(MapHeader.name,lname);
MapHeader.width=mapwidth=lwidth;
MapHeader.height=mapheight=lheight;
strcpy(MapNames[mapnum],MapHeader.name);
AllocateUndoBuffers();
DirtyFlag=1;
SaveMap(0);
DirtyFlag=0;
RestoreCutBuffers();
SelectMode=PasteMode=xbase=ybase=0;
SelX1=SelX2=SelY1=SelY2=-1;
writeH=1;
}
////////////////////////////////////////////////////
//
// Load a map
//
////////////////////////////////////////////////////
void LoadMap(int mapnum)
{
unsigned long csize,size=0;
memptr block;
SaveCutBuffers();
//
// DEALLOCATE ALL CURRENT MAP MEMORY
//
RemoveUndoBuffers();
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
//
if (XMSmaps)
XMSmove(XMSmaps,MapFileHeader->dataoffsets[mapnum],0,(long)&MapHeader,sizeof(MapHeaderStr));
else
LoadFile(mapname,(char huge *)&MapHeader,MapFileHeader->dataoffsets[mapnum],sizeof(MapHeaderStr));
//
// LOAD & DECOMPRESS MAP PLANES
//
if (MapFileHeader->maptype & BPLANE)
{
if (XMSmaps)
XMSmove(XMSmaps,MapHeader.mapbkgndpl,0,(long)&size,2);
else
LoadFile(mapname,(char huge *)&size,MapHeader.mapbkgndpl,2);
MMAllocate((memptr *)&MapBkgnd,size);
MMAllocate((memptr *)&CutBkgnd,size);
csize=MapHeader.mapbkgndlen-2;
MMAllocate(&block,csize);
if (XMSmaps)
XMSmove(XMSmaps,MapHeader.mapbkgndpl+2,0,(long)MK_FP(block,0),csize);
else
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)
{
if (XMSmaps)
XMSmove(XMSmaps,MapHeader.mapfrgndpl,0,(long)&size,2);
else
LoadFile(mapname,(char huge *)&size,MapHeader.mapfrgndpl,2);
MMAllocate((memptr *)&MapFrgnd,size);
MMAllocate((memptr *)&CutFrgnd,size);
csize=MapHeader.mapfrgndlen-2;
MMAllocate(&block,csize);
if (XMSmaps)
XMSmove(XMSmaps,MapHeader.mapfrgndpl+2,0,(long)MK_FP(block,0),csize);
else
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)
{
if (XMSmaps)
XMSmove(XMSmaps,MapHeader.mapinfopl,0,(long)&size,2);
else
LoadFile(mapname,(char huge *)&size,MapHeader.mapinfopl,2);
MMAllocate((memptr *)&MapInfoPl,size);
MMAllocate((memptr *)&CutInfoPl,size);
csize=MapHeader.mapinfolen-2;
MMAllocate(&block,csize);
if (XMSmaps)
XMSmove(XMSmaps,MapHeader.mapinfopl+2,0,(long)MK_FP(block,0),csize);
else
LoadFile(mapname,MK_FP(block,0),MapHeader.mapinfopl+2,csize);
RLEWExpand(MK_FP(block,0),MK_FP(MapInfoPl,0),size,MapFileHeader->RLEWtag);
MMFreePtr(&block);
}
mapwidth=MapHeader.width;
mapheight=MapHeader.height;
strcpy(MapNames[mapnum],MapHeader.name);
AllocateUndoBuffers();
UndoRegion.x=-1;
SaveUndo(0,0,mapwidth,mapheight);
RestoreCutBuffers();
SelectMode=PasteMode=xbase=ybase=0;
SelX1=SelX2=SelY1=SelY2=-1;
}
////////////////////////////////////////////////////
//
// Select a new map!
//
////////////////////////////////////////////////////
btype ClvlB[]={{"\xb",28,5,1},
{"\xc",28,14,1},
{" Exit ",12,17,1}};
DialogDef ClvlD={" SELECT MAP",
30,19,2,&ClvlB[0],NULL};
int smbase=0;
int SelectMap(int exitok,int createflg,char *title)
{
MapHeaderStr TempMapHeader;
unsigned ox,oy,i,dx,dy;
int select=-1,redraw;
if (exitok)
{
ClvlD.numbuttons=3;
ClvlD.height=19;
}
else
{
ClvlD.numbuttons=2;
ClvlD.height=16;
}
DrawDialog(&ClvlD,1);
GetDialogXY(&ClvlD,&dx,&dy);
sy=dy+1;
sx=screencenterx-strlen(title)/2;
print(title);
dx+=3;
dy+=5;
MouseHide();
GetButtonXY(&ClvlD,0,&sx,&sy);
sx-=27;
sy-=2;
print("Map Name\n");
ox=sx+1;
oy=sy+1;
DrawBorder(sx,sy,26,11,2);
MouseShow();
do
{
int mx,my;
//
// DRAW MAP NAMES
//
MouseHide();
for (i=0;i<10;i++)
{
sy=oy+i;
sx=ox;
if (i+smbase==whichmap)
print("*");
else
print(" ");
printint(i+smbase);
print(" ");
sx=ox+5;
MNameOff(sx,sy,i);
}
MouseShow();
redraw=0;
do
{
GetButtonXY(&ClvlD,0,&(unsigned)mx,&(unsigned)my);
if (!CheckList(mx,my,1,1,UparOn,UparOff,0) || keydown[0x48])
{
MouseHide();
GetButtonXY(&ClvlD,0,&sx,&sy);
print(ClvlB[0].text);
smbase-=10;
if (smbase<0)
smbase=0;
redraw=1;
MouseShow();
while(keydown[0x48]);
continue;
}
GetButtonXY(&ClvlD,1,&(unsigned)mx,&(unsigned)my);
if (!CheckList(mx,my,1,1,DnarOn,DnarOff,0) || keydown[0x50])
{
MouseHide();
GetButtonXY(&ClvlD,1,&sx,&sy);
print(ClvlB[1].text);
smbase+=10;
if (smbase>90)
smbase=90;
redraw=1;
MouseShow();
while(keydown[0x50]);
continue;
}
if (exitok)
{
GetButtonXY(&ClvlD,2,&(unsigned)mx,&(unsigned)my);
if (!CheckList(mx,my,6,1,ExitOn,ExitOff,0))
{
RestoreBackground();
return -1;
}
}
if (exitok && keydown[1])
{
RestoreBackground();
return -1;
}
select=CheckList(ox+5,oy,20,10,MNameOn,MNameOff,0);
if (select>=0)
{
MouseHide();
sy=select+oy;
sx=ox+5;
MNameOff(sx,sy,select);
MouseShow();
if ((MapFileHeader->dataoffsets[select+smbase]!=-1 && createflg==NOTCREATED)||
(MapFileHeader->dataoffsets[select+smbase]==-1 && createflg==CREATED))
select=-1;
}
} while(!redraw && select<0);
} while(select<0);
RestoreBackground();
return select+smbase;
}
//
// Print arrows
//
void DnarOn(int x,int y)
{
sx=x;
sy=y;
xormask=1;
drawchar(sx,sy,0xc);
xormask=0;
}
void DnarOff(int x,int y)
{
sx=x;
sy=y;
drawchar(sx,sy,0xc);
}
void UparOn(int x,int y)
{
sx=x;
sy=y;
xormask=1;
drawchar(sx,sy,0xb);
xormask=0;
}
void UparOff(int x,int y)
{
sx=x;
sy=y;
drawchar(sx,sy,0xb);
}
void ExitOn(int x,int y)
{
sx=x;
sy=y;
xormask=1;
print(" Exit ");
xormask=0;
}
void ExitOff(int x,int y)
{
sx=x;
sy=y;
print(" Exit ");
}
//
// Highlight Map Name
//
void MNameOn(int x,int y,int i)
{
xormask=1;
MNameOff(x,y,i);
xormask=0;
}
//
// De-Highlight Map Name
//
void MNameOff(int x,int y,int i)
{
MapHeaderStr TempMapHeader;
sx=x;
sy=y;
if (MapFileHeader->dataoffsets[i+smbase]!=-1)
{
print(" ");
sx=x;
print(MapNames[i+smbase]);
}
else
print("--not created yet--");
}
////////////////////////////////////////////////////
//
// Pick more planes for the map set
//
////////////////////////////////////////////////////
btype PickPlaneb[]={{"X",1,3,1},
{"X",1,6,1},
{" Done ",1,9,2}};
DialogDef PickPlaneD={"Which other planes\n"
"to enable?\n\n"
" Foreground\n\n\n"
" Information"
,18,11,3,&PickPlaneb[0],NULL};
int PickMorePlanes(void)
{
int which;
char planes=7; // 1=bkgnd/2=frgnd/4=info
DrawDialog(&PickPlaneD,1);
do
{
which=CheckButtons(&PickPlaneD);
switch(which)
{
case 0:
RestoreBackground();
return 1;
case 1:
GetButtonXY(&PickPlaneD,0,&sx,&sy);
planes^=2;
MouseHide();
if (planes&2)
print("X");
else
print(" ");
MouseShow();
break;
case 2:
GetButtonXY(&PickPlaneD,1,&sx,&sy);
planes^=4;
MouseHide();
if (planes&4)
print("X");
else
print(" ");
MouseShow();
}
} while(which!=3);
RestoreBackground();
MapFileHeader->maptype=planes;
return 0;
}
////////////////////////////////////////////////////
//
// Get map dimensions
//
////////////////////////////////////////////////////
btype LvlSpecb[]={{" ",1,3,1},
{" ",1,7,1},
{" ",1,11,1},
{" Done ",7,14,2}};
DialogDef LvlSpec={" MAP DIMENSIONS\n"
" Map Name:\n\n\n\n"
" Map Width:\n\n\n\n"
" Map Height:\n",
20,16,4,&LvlSpecb[0],NULL};
void InputMap(char *lvlname,unsigned *levelw,unsigned *levelh,int exitok)
{
unsigned butn,ok=0,nameok=0,widok=0,heightok=0,
ox,oy,width=0,height=0,oldwidth=0,oldheight=0;
char oldname[16]="",name[16]="";
MouseHide();
DrawDialog(&LvlSpec,1);
GetButtonXY(&LvlSpec,1,&sx,&sy);
printint(width);
GetButtonXY(&LvlSpec,2,&sx,&sy);
printint(height);
MouseShow();
//
// START INPUT IMMEDIATELY
//
butn=1;
goto firsttime;
#pragma warn -rch
while (!ok)
#pragma warn +rch
{
butn=CheckButtons(&LvlSpec);
if (!butn)
if (exitok)
{
RestoreBackground();
lvlname[0]=0;
return;
}
else
continue;
firsttime:
xormask=0;
GetButtonXY(&LvlSpec,butn-1,&sx,&sy);
MouseHide();
ox=sx;
oy=sy;
print(LvlSpecb[butn-1].text);
sx=ox;
sy=oy;
switch(butn)
{
case 1:
name[0]=0;
if (!input(name,15))
{
strcpy(name,oldname);
sx=ox;
sy=oy;
print(LvlSpecb[butn-1].text);
}
strcpy(oldname,name);
sx=ox;
sy=oy;
if (name[0])
{
print(name);
nameok=1;
}
else
nameok=0;
if (nameok)
{
butn=2;
GetButtonXY(&LvlSpec,butn-1,&sx,&sy);
ox=sx;
oy=sy;
print(LvlSpecb[butn-1].text);
sx=ox;
sy=oy;
}
else
break;
case 2:
width=0;
if ((width=inputint(9))==ESCOUT)
{
widok=0;
width=oldwidth;
}
if (width)
widok=1;
oldwidth=width;
sx=ox;
sy=oy;
print(LvlSpecb[butn-1].text);
sx=ox;
sy=oy;
printint(width);
if (widok)
{
butn=3;
GetButtonXY(&LvlSpec,butn-1,&sx,&sy);
ox=sx;
oy=sy;
print(LvlSpecb[butn-1].text);
sx=ox;
sy=oy;
}
else
break;
case 3:
height=0;
if ((height=inputint(9))==ESCOUT)
{
heightok=0;
height=oldheight;
}
if (height)
heightok=1;
oldheight=height;
sx=ox;
sy=oy;
print(LvlSpecb[butn-1].text);
sx=ox;
sy=oy;
printint(height);
break;
case 4:
if (2L*height*width>0x10000) // TOO BIG! TRIM IT!
{
errsound();
errsound();
widok=heightok=0;
break;
}
if (nameok && widok && heightok)
ok=1;
}
MouseShow();
}
RestoreBackground();
*levelw=width;
*levelh=height;
strcpy(lvlname,name);
}
////////////////////////////////////////////////////
//
// Item - Input INFOPLANE value
//
////////////////////////////////////////////////////
btype EnterIVb={" ",1,3,1};
DialogDef EnterIV={"Enter a value for\nthe INFO plane:\n\n\n",18,5,1,&EnterIVb,NULL};
void Item_InputInfoplane(void)
{
unsigned val;
if (TsearchMode || BfillMode || FillMode || PasteMode || SelectMode)
return;
clearkeys();
DrawDialog(&EnterIV,1);
MouseHide();
GetButtonXY(&EnterIV,0,&sx,&sy);
if ((val=inputint(9))!=ESCOUT)
whichi=val+tilenum;
RestoreBackground();
DrawInfoBar();
MouseShow();
}
////////////////////////////////////////////////////
//
// Item - Select Tile
//
////////////////////////////////////////////////////
void Item_SelectTile(void)
{
SelectTiles(0);
}
////////////////////////////////////////////////////
//
// Item - Block Fill
//
////////////////////////////////////////////////////
void Item_BlockFill(void)
{
ZeroModes();
BfillMode=1;
DrawInfoBar();
}
//
// DO THE ACTUAL BLOCK FILL
//
void DoBlockFill(void)
{
unsigned loc,i,j,ctrl=0,newt,newm,newi,tton,tmon,tion,from;
if (keydown[0x1d])
ctrl++;
MouseHide();
CopyUndoRegion();
UndoRegion.x=SelX1;
UndoRegion.y=SelY1;
UndoRegion.w=SelX2-SelX1+1;
UndoRegion.h=SelY2-SelY1+1;
if (ctrl)
{
for (j=SelY1;j<=SelY2;j++)
for (i=SelX1;i<=SelX2;i++)
{
loc=j*mapwidth+i;
from=(TileCopy.y+((j-SelY1)%TileCopy.h))*mapwidth+
TileCopy.x+((i-SelX1)%TileCopy.w);
switch(TileCopy.MapOrTileSelect)
{
case 0: // COPY BUFFER
tton=TileCopy.PlanesCopied&BPLANE;
tmon=TileCopy.PlanesCopied&FPLANE;
tion=TileCopy.PlanesCopied&IPLANE;
newt=CutBkgnd[from];
newm=CutFrgnd[from];
newi=CutInfoPl[from];
break;
case 1: // TILES
tton=1;
tmon=tion=0;
newt=((j%TileCopy.h)+TileCopy.y)*selectcols+
TileCopy.x+(i%TileCopy.w);
if (XMSlookup[newt]<0)
tton=0;
break;
case 2: // MASKED
tton=tion=0;
tmon=1;
newm=((j%TileCopy.h)+TileCopy.y)*selectcols+
TileCopy.x+(i%TileCopy.w)+tilenum+maxiconrows*selectcols;
if (XMSlookup[newm]<0)
tmon=0;
else
newm-=tilenum;
}
if (tton)
*(MapBkgnd+loc)=newt;
if (tmon)
*(MapFrgnd+loc)=newm;
if (tion)
*(MapInfoPl+loc)=newi;
if (j>=ybase && j<ybase+screenh &&
i>=xbase && i<xbase+screenw)
{
int tempt,tempm,tempi;
tempt=*(MapBkgnd+loc);
tempm=*(MapFrgnd+loc)+tilenum;
tempi=*(MapInfoPl+loc)+tilenum;
CombineTiles(viewton?tempt:-BkgndColor,viewmon*tempm,viewion*tempi,tsize);
if (GridMode)
Overlay(tsize);
DrawTile((i-xbase)<<(tsize-1),((j-ybase)<<(tsize+2))+8,tsize);
}
}
}
else
for (j=SelY1;j<=SelY2;j++)
for (i=SelX1;i<=SelX2;i++)
{
loc=j*mapwidth+i;
if (planeton)
*(MapBkgnd+loc)=whicht;
if (planemon)
*(MapFrgnd+loc)=whichtm-tilenum;
if (planeion)
*(MapInfoPl+loc)=whichi-tilenum;
if (j>=ybase && j<ybase+screenh &&
i>=xbase && i<xbase+screenw)
{
int tempt,tempm,tempi;
tempt=*(MapBkgnd+loc);
tempm=*(MapFrgnd+loc)+tilenum;
tempi=*(MapInfoPl+loc)+tilenum;
CombineTiles(viewton?tempt:-BkgndColor,viewmon*tempm,viewion*tempi,tsize);
if (GridMode)
Overlay(tsize);
DrawTile((i-xbase)<<(tsize-1),((j-ybase)<<(tsize+2))+8,tsize);
}
}
DirtyFlag=1;
MouseShow();
}
////////////////////////////////////////////////////
//
// Remove the XMS undo buffers
//
////////////////////////////////////////////////////
void RemoveUndoBuffers(void)
{
if (XMSundoB)
XMSFreeMem(XMSundoB);
if (XMSundoF)
XMSFreeMem(XMSundoF);
if (XMSundoI)
XMSFreeMem(XMSundoI);
XMSundoB=XMSundoF=XMSundoI=0;
}
////////////////////////////////////////////////////
//
// Allocate XMS undo buffers
// NOTE: uses "mapwidth" & "mapheight"
//
////////////////////////////////////////////////////
void AllocateUndoBuffers(void)
{
long size=2L*mapwidth*mapheight;
if (MapFileHeader->maptype&BPLANE)
XMSundoB=XMSAllocate(size);
if (MapFileHeader->maptype&FPLANE)
XMSundoF=XMSAllocate(size);
if (MapFileHeader->maptype&IPLANE)
XMSundoI=XMSAllocate(size);
}
////////////////////////////////////////////////////
//
// Save Undo buffers
//
////////////////////////////////////////////////////
void SaveUndo(int x,int y,int w,int h)
{
unsigned hsize=w*2,j;
for (j=y;j<y+h;j++)
{
unsigned off=2*(j*mapwidth+x);
if (MapFileHeader->maptype&BPLANE)
XMSmove(0,(long)MK_FP(MapBkgnd,off),XMSundoB,off,hsize);
if (MapFileHeader->maptype&FPLANE)
XMSmove(0,(long)MK_FP(MapFrgnd,off),XMSundoF,off,hsize);
if (MapFileHeader->maptype&IPLANE)
XMSmove(0,(long)MK_FP(MapInfoPl,off),XMSundoI,off,hsize);
}
}
////////////////////////////////////////////////////
//
// Restore Undo buffers
//
////////////////////////////////////////////////////
void RestoreUndo(void)
{
long size=2L*UndoRegion.w;
unsigned j;
sound(2000);
for (j=UndoRegion.y;j<UndoRegion.y+UndoRegion.h;j++)
{
unsigned loc=2*(j*mapwidth+UndoRegion.x);
if (MapFileHeader->maptype&BPLANE)
XMSmove(XMSundoB,loc,0,(long)MK_FP(MapBkgnd,loc),size);
if (MapFileHeader->maptype&FPLANE)
XMSmove(XMSundoF,loc,0,(long)MK_FP(MapFrgnd,loc),size);
if (MapFileHeader->maptype&IPLANE)
XMSmove(XMSundoI,loc,0,(long)MK_FP(MapInfoPl,loc),size);
}
nosound();
}
////////////////////////////////////////////////////
//
// Copy the current UNDO region to the undo buffers
//
////////////////////////////////////////////////////
void CopyUndoRegion(void)
{
if (UndoRegion.x==-1)
return;
SaveUndo(UndoRegion.x,UndoRegion.y,UndoRegion.w,UndoRegion.h);
}
////////////////////////////////////////////////////
//
// Item - Undo
//
////////////////////////////////////////////////////
void Item_Undo(void)
{
if (UndoRegion.x==-1)
{
ErrDialog("You don't have anything to UNDO!"," Oh, yeah. ");
return;
}
RestoreUndo();
DrawMap();
}
////////////////////////////////////////////////////
//
// Item - Tile Search!
//
////////////////////////////////////////////////////
void Item_TileSearch(void)
{
int num=planeton+planemon+planeion;
ZeroModes();
if (num>1)
{
ErrDialog("TILE SEARCH will only work\n"
"with ONE active plane! Make\n"
"sure that the tile you're\n"
"searching for is selected!"," OK ");
return;
}
TsearchMode=1;
DrawInfoBar();
DrawMap();
}
////////////////////////////////////////////////////
//
// Item - Launch
//
////////////////////////////////////////////////////
char tempparm[40];
void Item_Launch(void)
{
TempStruct LaunchInfo;
char ename[64],*envstr[15],temp[40],temp1[40],temp2[40],tiname[14]="TEDINFO.TMP",i,j;
long size;
int rottlaunch;
int startp;
unsigned mx,my;
rottlaunch=0;
if (!TEDInfo->launchname[0])
{
ErrDialog("You didn't specify a launching\n"
"name on the command line? What\n"
"do I launch, Einstein? Geez!"," What a goober. ");
return;
}
//
// 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));
//
// ICON CHANGE ON LAUNCH?
//
if (keydown[0x2A])
{
rottlaunch=1;
startp=5;
mx=xbase+(pixelx>>(tsize+2));
my=ybase+((pixely-8)>>(tsize+2));
}
else
startp=3;
if (pixely>=8 && pixely<infoy*8 && TEDInfo->permicon
&& MapFileHeader->maptype&IPLANE && !usingbat && keydown[0x1d])
{
unsigned i,j;
mx=xbase+(pixelx>>(tsize+2));
my=ybase+((pixely-8)>>(tsize+2));
for (j=0;j<mapheight;j++)
for (i=0;i<mapwidth;i++)
if (MapInfoPl[j*mapwidth+i]==TEDInfo->permicon)
{
MapInfoPl[j*mapwidth+i]=0;
TEDInfo->lastx=i;
TEDInfo->lasty=j;
break;
}
MapInfoPl[my*mapwidth+mx]=TEDInfo->permicon;
DrawMap();
DirtyFlag=1;
}
TEDInfo->oscrx=xbase;
TEDInfo->oscry=ybase;
TEDInfo->pflags=((planeton&1)<<6)|
((planemon&1)<<5)|
((planeion&1)<<4)|
((viewton&1)<<2)|
((viewmon&1)<<1)|
(viewion&1);
_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);
envstr[0] = ename;
envstr[1] = "/TEDLEVEL";
itoa(whichmap,temp,10);
envstr[2] = temp;
if (rottlaunch)
{
itoa(mx,temp1,10);
envstr[3] = temp1;
itoa(my,temp2,10);
envstr[4] = temp2;
}
//
// CHOP UP THE PARMSTRING FOR 'EXECV'
//
strcpy(tempparm,parmstring);
envstr[startp]=&tempparm[0];
for(j=startp+1,i=0;i<strlen(tempparm);i++)
if (tempparm[i]==' ')
{
envstr[j]=&tempparm[i+1];
tempparm[i]=0;
j++;
}
envstr[j]=0;
RemoveUndoBuffers();
ShutdownKBD();
//
// ARE WE EXITING WITH A BATCH FILE?
//
if (usingbat)
{
setvideo(TEXT);
exit(whichmap+2);
}
fcloseall();
MMShutdown();
execv(ename,envstr);
SetupKBD();
RestoreBackground();
MouseShow();
ErrDialog("LAUNCHing failed. TED5 will\n"
"now restart."," I have gubs ");
ShutdownKBD();
execlp("TED5.EXE","TED5.EXE","/LAUNCH",NULL);
printf("Couldn't find TED5 for some reason!");
exit(1);
}
////////////////////////////////////////////////////
//
// Item - TILEINFO Copy
//
////////////////////////////////////////////////////
DialogDef TICd=
{"TILEINFOM Copy Kludge\n\n"
"From:\n"
" To:\n"
"Rows:",22,6};
void Item_TINFOCopy(void)
{
unsigned dx,dy,i,from,to,amt;
memptr block;
MouseHide();
DrawDialog(&TICd,1);
GetDialogXY(&TICd,&dx,&dy);
sx=dx+5;
sy=dy+2;
from=inputint(9);
if (from==ESCOUT)
{
RestoreBackground();
MouseShow();
return;
}
sx=dx+5;
sy=dy+3;
to=inputint(9);
if (to==ESCOUT)
{
RestoreBackground();
MouseShow();
return;
}
sx=dx+5;
sy=dy+4;
amt=inputint(9);
if (amt==ESCOUT)
{
RestoreBackground();
MouseShow();
return;
}
amt*=18;
MMAllocate(&block,amt);
for (i=0;i<numtmplanes;i++)
{
movedata((unsigned)TMinfo[i],from,(unsigned)block,0,amt);
movedata((unsigned)block,0,(unsigned)TMinfo[i],to,amt);
}
MMFreePtr(&block);
RestoreBackground();
DirtyFlag=writeH=1;
MouseShow();
}
Reference in New Issue View Git Blame Copy Permalink