--- /dev/null
+////////////////////////////////////////////////////
+////////////////////////////////////////////////////
+//
+// 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();
+}
projects / 16.git / blobdiff