16/ted5/TED5-4.C

   1 ////////////////////////////////////////////////////
   2 ////////////////////////////////////////////////////
   3 //
   4 // TED5-4
   5 //
   6 ////////////////////////////////////////////////////
   7 ////////////////////////////////////////////////////
   8 #include "ted5.h"
   9 #pragma hdrstop
  10
  11
  12 void SignalSound(void)
  13 {
  14  int i;
  15
  16  for(i=0;i<10;i++)
  17  {
  18   sound(500+i*500);
  19   delay(5);
  20   nosound();
  21  }
  22 }
  23
  24
  25 ////////////////////////////////////////////////////
  26 //
  27 // Create an OBJ linkable file from any type of datafile
  28 //
  29 // Exit:
  30 //  0 = everything's a-ok!
  31 // -1 = file not found
  32 // -2 = file >64K
  33 //
  34 ////////////////////////////////////////////////////
  35 int MakeOBJ(char *filename,char *destfilename,char *public,segtype whichseg,char *farname)
  36 {
  37  char THEADR[17]={0x80,14,0,12,32,32,32,32,32,32,32,32,32,32,32,32,0},
  38       COMENT[18]={0x88,0,0,0,0,'M','a','k','e','O','B','J',' ','v','1','.','1',0},
  39       LNAMES[42]={0x96,0,0,
  40                   6,'D','G','R','O','U','P',
  41                   5,'_','D','A','T','A',
  42                   4,'D','A','T','A',
  43                   0,
  44                   5,'_','T','E','X','T',
  45                   4,'C','O','D','E',
  46                   8,'F','A','R','_','D','A','T','A'},
  47       SEGDEF[9]={0x98,7,0,0x48,0,0,2,3,4},      // for .DATA
  48       SEGDEF1[9]={0x98,7,0,0x48,0,0,5,6,4},     // for .CODE
  49       SEGDEF2[9]={0x98,7,0,0x60,0,0,8,7,4},     // for .FARDATA
  50       GRPDEF[7]={0x9a,4,0,1,0xff,1,0x61},
  51       MODEND[5]={0x8a,2,0,0,0x74};
  52
  53  unsigned i,j,flag,handle;
  54  long fsize,offset,loffset,temp,amtleft,amount,offset1;
  55  char _seg *dblock,*block;
  56
  57
  58  //
  59  // Need to compute the CHECKSUM in the COMENT field
  60  // (so if the "MakeOBJ..." string is modified, the CHECKSUM
  61  //  will be correct).
  62  //
  63  COMENT[1]=sizeof(COMENT)-3;
  64  for (flag=i=0;i<sizeof(COMENT);i++)
  65     flag+=COMENT[i];
  66  COMENT[sizeof(COMENT)-1]=(flag^0xff)+1;
  67
  68  if ((handle=open(filename,O_BINARY))==NULL)
  69    return -1;
  70
  71  fsize=filelength(handle);
  72  close(handle);
  73  if (fsize>0x10000L)            // BIGGER THAN 1 SEG = ERROR!
  74    return -2;
  75
  76  LoadIn(filename,(memptr *)&block);     // LOAD FILE IN
  77  offset=0;
  78
  79  MMAllocate((memptr *)&dblock,0x10000L);
  80
  81  ////////////////////////////////////////////////////
  82  //
  83  // INSERT HEADER RECORD
  84  //
  85  movedata(_DS,FP_OFF(&THEADR),(unsigned)dblock,offset,sizeof(THEADR));
  86  movedata(FP_SEG(filename),FP_OFF(filename),
  87           (unsigned)dblock,offset+4,strlen(filename));
  88  offset+=sizeof(THEADR);
  89
  90
  91  ////////////////////////////////////////////////////
  92  //
  93  // INSERT COMMENT RECORD
  94  //
  95  movedata(_DS,FP_OFF(COMENT),(unsigned)dblock,offset,sizeof(COMENT));
  96  offset+=sizeof(COMENT);
  97
  98
  99  ////////////////////////////////////////////////////
 100  //
 101  // INSERT START OF LIST-OF-NAMES RECORD
 102  //
 103  loffset=offset;
 104  movedata(_DS,FP_OFF(LNAMES),(unsigned)dblock,offset,sizeof(LNAMES));
 105  offset+=sizeof(LNAMES);
 106
 107  // If it's a .FARDATA segment, we need to insert the segment name!
 108  if (whichseg==FARDATA)
 109    {
 110     *(dblock+offset)=strlen(farname);
 111     movedata(FP_SEG(farname),FP_OFF(farname),
 112         (unsigned)dblock,offset+1,strlen(farname));
 113     offset+=strlen(farname)+1;
 114    }
 115
 116  // Now, finish the List-Of-Names record by creating
 117  // the CHECKSUM and LENGTH
 118  temp=offset;
 119  offset=offset-loffset-2;
 120  *(int huge *)(dblock+loffset+1)=offset;
 121  offset=temp;
 122
 123  // Now, figure out the CHECKSUM of the record
 124  for (flag=i=0;i<(offset-loffset);i++)
 125    flag+=*(dblock+i+loffset);
 126  *(dblock+offset)=(flag^0xff)+1;
 127  offset++;
 128
 129
 130  ////////////////////////////////////////////////////
 131  //
 132  // CREATE SEGMENT DEFINITION RECORD
 133  //
 134  loffset=offset;
 135  temp=fsize;
 136  switch(whichseg)
 137  {
 138   case DATA:
 139     movedata(FP_SEG(&SEGDEF),FP_OFF(&SEGDEF),
 140              (unsigned)dblock,offset,sizeof(SEGDEF));
 141     *(int huge *)(dblock+offset+4)=temp;
 142     offset+=sizeof(SEGDEF);
 143     break;
 144   case CODE:
 145     movedata(FP_SEG(&SEGDEF1),FP_OFF(&SEGDEF1),
 146              (unsigned)dblock,offset,sizeof(SEGDEF1));
 147     *(int huge *)(dblock+offset+4)=temp;
 148     offset+=sizeof(SEGDEF1);
 149     break;
 150   case FARDATA:
 151     movedata(FP_SEG(&SEGDEF2),FP_OFF(&SEGDEF2),
 152              (unsigned)dblock,offset,sizeof(SEGDEF2));
 153     *(int huge *)(dblock+offset+4)=temp;
 154     offset+=sizeof(SEGDEF2);
 155     break;
 156  }
 157
 158  // CHECKSUM
 159  for (flag=0,i=loffset;i<offset;i++)
 160    flag+=*(dblock+i);
 161  *(dblock+offset)=(flag^0xff)+1;
 162  offset++;
 163
 164
 165  ////////////////////////////////////////////////////
 166  //
 167  // CREATE GROUP DEFINITION RECORD
 168  //
 169  switch(whichseg)
 170  {
 171   case DATA:
 172   case CODE:
 173     movedata(FP_SEG(&GRPDEF),FP_OFF(&GRPDEF),
 174              (unsigned)dblock,offset,sizeof(GRPDEF));
 175     offset+=sizeof(GRPDEF);
 176  }
 177
 178
 179  ////////////////////////////////////////////////////
 180  //
 181  // CREATE PUBLIC DEFINITION RECORD
 182  //
 183  loffset=offset;
 184  *(dblock+offset)=0x90;         // PUBDEF ID
 185  offset+=3;                     // point to public base, skip length
 186  *(dblock+offset)=1;            // group index=1
 187  *(dblock+offset+1)=1;          // segment index=1
 188  offset+=2;                     // point to public name
 189
 190  temp=0;
 191  movedata(FP_SEG(public),FP_OFF(public),
 192           (unsigned)dblock,offset+1,strlen(public));
 193  *(dblock+offset)=strlen(public);
 194  offset+=strlen(public)+1;
 195  *(int huge *)(dblock+offset)=0;        // public offset within segment
 196  offset+=2;
 197  *(dblock+offset)=0;            // type index
 198  offset++;
 199
 200  // LENGTH
 201  temp=offset-loffset-2;
 202  *(int huge *)(dblock+loffset+1)=temp;
 203  offset++;
 204
 205  // CHECKSUM
 206  for (flag=0,i=loffset;i<offset;i++)
 207    flag+=*(dblock+i);
 208  *(dblock+offset)=(flag^0xff)+1;
 209
 210
 211  ////////////////////////////////////////////////////
 212  //
 213  // DATA RECORD(S). YUCK.
 214  //
 215
 216  amtleft=fsize;
 217  amount=1024;
 218  for (i=0;i<(fsize+1023)/1024;i++)
 219    {
 220     offset1=offset;
 221     if (amtleft<1024)
 222       amount=amtleft;
 223     //
 224     // RECORD HEADER
 225     //
 226     *(dblock+offset)=0xa0;                      // LEDATA ID
 227     *(int huge *)(dblock+offset+1)=amount+4;    // length of record
 228     offset+=3;
 229     *(dblock+offset)=1;                         // segment index
 230     *(int huge *)(dblock+offset+1)=i*1024;      // index into segment
 231     offset+=3;
 232     //
 233     // LOAD DATA IN
 234     //
 235     LoadFile(filename,(char huge *)dblock+offset,i*1024,amount);
 236     offset+=amount;
 237     //
 238     // CHECKSUM!
 239     //
 240     for (flag=0,j=offset1;j<offset;j++)
 241       flag+=*(dblock+j);
 242     *(dblock+offset)=(flag^0xff)+1;
 243     offset++;
 244
 245     amtleft-=1024;
 246    }
 247
 248  ////////////////////////////////////////////////////
 249  //
 250  // MODULE END! YES!
 251  //
 252  movedata(FP_SEG(&MODEND),FP_OFF(&MODEND),(unsigned)dblock,offset,sizeof(MODEND));
 253  offset+=sizeof(MODEND);
 254
 255  //
 256  // Save the little puppy out!
 257  //
 258  SaveFile(destfilename,(char huge *)dblock,0,offset);
 259  MMFreePtr((memptr *)&dblock);
 260  MMFreePtr((memptr *)&block);
 261  return 0;
 262 }
 263
 264
 265 ////////////////////////////////////////////////////
 266 //
 267 // DUMP THE PASTE BUFFER OUT TO EITHER AN
 268 // "APPLE PREFERRED" OR "ILBM" GRAPHICS FORMAT FILE
 269 //
 270 // NOTE: THIS IS ONLY AVAILABLE IN EGA, BECAUSE I
 271 // DON'T FEEL LIKE WRITING A CGA ILBM PIXEL-SPLICER --
 272 // AND APPLE PREFERRED ONLY HANDLES 4-BIT COLOR ANYWAY!
 273 // (YES, I KNOW, I COULD ONLY USE 4 OUT OF 16 COLORS...SHUT UP!)
 274 //
 275 ////////////////////////////////////////////////////
 276 btype dumpB[]={{" DeluxePaint II ILBM ",4,2,2},
 277                {"   Apple Preferred   ",4,5,1}},
 278       fnameB={"         ",4,3,1};
 279 DialogDef dumpD={" Which format do you require?",30,7,2,&dumpB[0],NULL},
 280           fnameD={"Enter filename to\nsave (no suffix)",17,5,1,&fnameB,NULL};
 281
 282 void Item_GraphicDump(void)
 283 {
 284  char filename[14],ext[5],_seg *block,_seg *block1;
 285  ApPrefStr PrefHeader;
 286  int which,i,j,k,m,n,pwidth,lwidth,dx,dy;
 287  long tilelen,fsize=0,bufsize;
 288
 289  if (!PasteOK)
 290    {
 291     ErrDialog("You need to use the Copy command\n"
 292               "to copy part of the map or tiles\n"
 293               "so I know what I need to dump!"," OK ");
 294     return;
 295    }
 296
 297  switch(videomode)
 298  {
 299   case CGA:
 300   case VGA:
 301     ErrDialog("Sorry, but this function is only\n"
 302               "available for EGA mode.  If you\n"
 303               "have a REAL NEED for this to work\n"
 304               "in CGA or VGA, talk to Id Software!"," OK ");
 305     return;
 306  }
 307
 308  if (!(which=DoDialog(&dumpD)))
 309    return;
 310
 311  //
 312  // SET TILE LENGTH
 313  //
 314  switch(tsize)
 315  {
 316   case 1: tilelen=32L; break;
 317   case 2: tilelen=128L; break;
 318   case 3: tilelen=512L;
 319  }
 320
 321  //
 322  // GET FILENAME TO SAVE UNDER
 323  //
 324  DrawDialog(&fnameD,1);
 325  MouseHide();
 326  GetButtonXY(&fnameD,0,&sx,&sy);
 327  if (!input(filename,8))
 328    {
 329     RestoreBackground();
 330     MouseShow();
 331     return;
 332    }
 333  for (i=0;i<strlen(filename);i++)
 334    if (filename[i]=='.')
 335      {
 336       filename[i]=0;
 337       break;
 338      }
 339  RestoreBackground();
 340  MouseShow();
 341
 342  //
 343  // SETUP FOR EACH TYPE
 344  //
 345  switch(which)
 346  {
 347   case 1:       // ILBM
 348     {
 349      long size;
 350      char form[5]="FORM",ilbm[9]="ILBMBMHD",body[5]="BODY";
 351
 352
 353      size=48L;
 354      MMAllocate((memptr *)&block,size);
 355
 356      movedata(FP_SEG(form),FP_OFF(form),(unsigned)block,fsize,4);
 357      fsize+=4;
 358      size=40L+tilelen*TileCopy.w*TileCopy.h;
 359      *(block+fsize)=(size>>24)&0xff;
 360      *(block+fsize+1)=(size>>16)&0xff;
 361      *(block+fsize+2)=(size>>8)&0xff;
 362      *(block+fsize+3)=size&0xff;
 363      fsize+=4;
 364      movedata(FP_SEG(ilbm),FP_OFF(ilbm),(unsigned)block,fsize,8);
 365      fsize+=8;
 366      *(block+fsize)=0;
 367      *(block+fsize+1)=0;
 368      *(block+fsize+2)=0;
 369      *(block+fsize+3)=20;
 370      fsize+=4;
 371      *(block+fsize)=(TileCopy.w<<(tsize+2))/256;   // pixel width
 372      *(block+fsize+1)=(TileCopy.w<<(tsize+2))&0xff;
 373      *(block+fsize+2)=(TileCopy.h<<(tsize+2))/256; // pixel height
 374      *(block+fsize+3)=(TileCopy.h<<(tsize+2))&0xff;
 375      *(int huge *)(block+fsize+4)=0;            // Xorg
 376      *(int huge *)(block+fsize+6)=0;            // Yorg
 377      *(block+fsize+8)=4;                        // planes
 378      *(block+fsize+9)=0;                        // mask (stencil!)
 379      *(block+fsize+10)=0;                       // compression (none)
 380      *(block+fsize+11)=0;                       // pad (?)
 381      *(int huge *)(block+fsize+12)=0;           // trans (?)
 382      *(int huge *)(block+fsize+14)=0x101;       // aspt (aspect?)
 383      *(int huge *)(block+fsize+16)=0x4001;      // page width
 384      *(int huge *)(block+fsize+18)=0xc800;      // page height
 385      fsize+=20;
 386      movedata(FP_SEG(body),FP_OFF(body),(unsigned)block,fsize,4);
 387      fsize+=4;
 388      size=tilelen*TileCopy.w*TileCopy.h;
 389      *(block+fsize)=(size>>24)&0xff;
 390      *(block+fsize+1)=(size>>16)&0xff;
 391      *(block+fsize+2)=(size>>8)&0xff;
 392      *(block+fsize+3)=size&0xff;
 393      fsize+=4;
 394
 395      strcpy(ext,".LBM");
 396     }
 397     break;
 398
 399   case 2:       // APPLE PREFERRED
 400     {
 401      int Ctable[16]={0x0000,0x000a,0x00a0,0x00aa,0x0a00,0x0a0a,0x0a50,0x0aaa,
 402                      0x0555,0x055f,0x05f5,0x05ff,0x0f55,0x0f5f,0x0ff5,0x0fff};
 403      long size,pixwid;
 404
 405
 406      PrefHeader.length=sizeof(ApPrefStr)+4L*(TileCopy.h<<(tsize+2))+
 407         TileCopy.w*TileCopy.h*tilelen+(((TileCopy.w*TileCopy.h*tilelen)+63)/64);
 408      strncpy(PrefHeader.Kind,"\x4MAIN",5);
 409      PrefHeader.MasterMode=0;
 410      PrefHeader.PixelsPerLine=TileCopy.w<<(tsize+2);
 411      PrefHeader.NumColorTables=1;
 412      for (i=0;i<16;i++)
 413        PrefHeader.ColorTable[i]=Ctable[i];
 414      PrefHeader.NumScanLines=TileCopy.h<<(tsize+2);
 415
 416      size=sizeof(ApPrefStr)+4L*(TileCopy.h<<(tsize+2));
 417      MMAllocate((memptr *)&block,size);
 418      movedata(FP_SEG(&PrefHeader),FP_OFF(&PrefHeader),(unsigned)block,fsize,sizeof(ApPrefStr));
 419      fsize+=sizeof(ApPrefStr);
 420
 421      pixwid=TileCopy.w*(2<<tsize);
 422      for (i=0;i<(TileCopy.h<<(tsize+2));i++)
 423        {
 424         *(int huge *)(block+fsize)=pixwid+(pixwid+63)/64;
 425         *(int huge *)(block+fsize+2)=0;
 426         fsize+=4;
 427        }
 428
 429      strcpy(ext,".APP");
 430      MMAllocate((memptr *)&block1,tilelen*TileCopy.w);
 431     }
 432  }
 433
 434  //
 435  // SAVE HEADER OUT
 436  //
 437  strcat(filename,ext);
 438  SaveFile(filename,(char huge *)block,0,fsize);
 439  MMFreePtr((memptr *)&block);
 440
 441  //
 442  // NOW, WRITE THE DATA OUT! EEEE!
 443  //
 444  bufsize=tilelen*TileCopy.w;
 445  MMAllocate((memptr *)&block,bufsize);
 446
 447  pwidth=(1<<(tsize-1))*TileCopy.w;
 448  lwidth=pwidth*4;
 449
 450  ErrDialog("One moment. I am busy.\n     Countdown:","");
 451  dx=sx;
 452  dy=sy;
 453
 454  for (j=0;j<TileCopy.h;j++)
 455    {
 456     sx=dx;
 457     sy=dy;
 458     printint(TileCopy.h-j);
 459     print(" ");
 460
 461     for (i=0;i<TileCopy.w;i++)
 462       {
 463        unsigned tilet,tilem,tilei,loc;
 464
 465        //
 466        // ESC out?
 467        //
 468        if (keydown[1])
 469          {
 470           RestoreBackground();
 471           while(keydown[1]);
 472           ErrDialog("You aborted out of the\n"
 473                     "graphic dump conversion!"," Yes, I know ");
 474
 475           if (which==2)
 476             MMFreePtr((memptr *)&block1);
 477           return;
 478          }
 479        //
 480        // GET THE CORRECT TILE MOVED INTO "TDATA"
 481        //
 482        switch(TileCopy.MapOrTileSelect)
 483        {
 484         case 0: // MAP COPY
 485           loc=(j+TileCopy.y)*mapwidth+TileCopy.x+i;
 486           tilet=(TileCopy.PlanesCopied&BPLANE)?CutBkgnd[loc]:-BkgndColor;
 487           tilem=(TileCopy.PlanesCopied&FPLANE)?CutFrgnd[loc]+tilenum:0;
 488           tilei=(TileCopy.PlanesCopied&IPLANE)?CutInfoPl[loc]+tilenum:0;
 489           CombineTiles(tilet,tilem,tilei,tsize);
 490           break;
 491         case 1: // BKGND TILE COPY
 492           loc=(TileCopy.y+j)*selectcols+TileCopy.x+i;
 493           CombineTiles(loc,0,0,tsize);
 494           break;
 495         case 2: // FRGND TILE COPY
 496           loc=(TileCopy.y+j)*selectcols+TileCopy.x+i+tilenum;
 497           CombineTiles(-BkgndColor,loc,0,tsize);
 498        }
 499
 500        //
 501        // NOW, MUNGE "TDATA" INTO BIT-PLANES!
 502        //
 503        // INTERNAL:             P0      P1      P2      P3
 504        //       SCANLINE x      ......  ......  ......  ......
 505        //
 506        for (k=0;k<8<<(tsize-1);k++)
 507          for (m=0;m<4;m++)
 508            movedata(FP_SEG(&tdata),FP_OFF(&tdata)+(m*tsize*(8<<(tsize-1)))+k*(1<<(tsize-1)),
 509                 (unsigned)block,k*lwidth+m*pwidth+i*(1<<(tsize-1)),1<<(tsize-1));
 510       }
 511     //
 512     // ALRIGHT. NOW SAVE THIS CHUNK OUT IN THE CORRECT FORMAT
 513     //
 514     switch(which)
 515     {
 516      case 1:    // ILBM
 517        SaveFile(filename,MK_FP(block,0),fsize,bufsize);
 518        fsize+=bufsize;
 519        break;
 520      case 2:    // APPLE PREFERRED
 521        {
 522         int len,clen;
 523
 524         //
 525         // FIRST, I NEED TO CONVERT THE ILBM PLANAR FORMAT
 526         // TO SUPER-RES NIBBLES
 527         //
 528         for (k=0;k<8<<(tsize-1);k++)
 529           for (m=0;m<(1<<(tsize-1))*TileCopy.w;m++)
 530             {
 531              unsigned char src[4],dest[4]={0,0,0,0};
 532
 533              for (n=0;n<4;n++)
 534                src[n]=block[k*lwidth+pwidth*n+m];
 535
 536              asm        mov     al,[BYTE PTR src+0]
 537              asm        mov     ah,[BYTE PTR src+1]
 538              asm        mov     bl,[BYTE PTR src+2]
 539              asm        mov     bh,[BYTE PTR src+3]
 540
 541              // dest[0]
 542              asm        shl     bh,1
 543              asm        rcl     cl,1
 544              asm        shl     bl,1
 545              asm        rcl     cl,1
 546              asm        shl     ah,1
 547              asm        rcl     cl,1
 548              asm        shl     al,1
 549              asm        rcl     cl,1
 550
 551              asm        shl     bh,1
 552              asm        rcl     cl,1
 553              asm        shl     bl,1
 554              asm        rcl     cl,1
 555              asm        shl     ah,1
 556              asm        rcl     cl,1
 557              asm        shl     al,1
 558              asm        rcl     cl,1
 559
 560              // dest[1]
 561              asm        shl     bh,1
 562              asm        rcl     ch,1
 563              asm        shl     bl,1
 564              asm        rcl     ch,1
 565              asm        shl     ah,1
 566              asm        rcl     ch,1
 567              asm        shl     al,1
 568              asm        rcl     ch,1
 569
 570              asm        shl     bh,1
 571              asm        rcl     ch,1
 572              asm        shl     bl,1
 573              asm        rcl     ch,1
 574              asm        shl     ah,1
 575              asm        rcl     ch,1
 576              asm        shl     al,1
 577              asm        rcl     ch,1
 578
 579              // dest[2]
 580              asm        shl     bh,1
 581              asm        rcl     dl,1
 582              asm        shl     bl,1
 583              asm        rcl     dl,1
 584              asm        shl     ah,1
 585              asm        rcl     dl,1
 586              asm        shl     al,1
 587              asm        rcl     dl,1
 588
 589              asm        shl     bh,1
 590              asm        rcl     dl,1
 591              asm        shl     bl,1
 592              asm        rcl     dl,1
 593              asm        shl     ah,1
 594              asm        rcl     dl,1
 595              asm        shl     al,1
 596              asm        rcl     dl,1
 597
 598              // dest[3]
 599              asm        shl     bh,1
 600              asm        rcl     dh,1
 601              asm        shl     bl,1
 602              asm        rcl     dh,1
 603              asm        shl     ah,1
 604              asm        rcl     dh,1
 605              asm        shl     al,1
 606              asm        rcl     dh,1
 607
 608              asm        shl     bh,1
 609              asm        rcl     dh,1
 610              asm        shl     bl,1
 611              asm        rcl     dh,1
 612              asm        shl     ah,1
 613              asm        rcl     dh,1
 614              asm        shl     al,1
 615              asm        rcl     dh,1
 616
 617              asm        mov     [BYTE PTR dest+0],cl
 618              asm        mov     [BYTE PTR dest+1],ch
 619              asm        mov     [BYTE PTR dest+2],dl
 620              asm        mov     [BYTE PTR dest+3],dh
 621
 622              movedata(FP_SEG(&dest),FP_OFF(&dest),
 623                 (unsigned)block1,k*lwidth+m*4,4);
 624             }
 625
 626         //
 627         // NOW, TIME TO WRITE THE DATA OUT IN 64-BYTE CHUNKS! YUCK!
 628         //
 629         for (k=0;k<8<<(tsize-1);k++)
 630           {
 631            char clen;
 632            int off=k*lwidth;;
 633
 634            len=4*pwidth;
 635            while(len>0)
 636            {
 637             if (len>64)
 638               clen=64;
 639             else
 640               clen=len;
 641
 642             clen--;
 643             SaveFile(filename,(char huge *)&clen,fsize++,1);
 644             clen++;
 645
 646             SaveFile(filename,MK_FP(block1,off),fsize,clen);
 647             fsize+=clen;
 648             off+=clen;
 649             len-=clen;
 650            }
 651           }
 652        }
 653     }
 654    }
 655
 656  if (which==2)
 657    MMFreePtr((memptr *)&block1);
 658
 659  MMFreePtr((memptr *)&block);
 660  RestoreBackground();
 661
 662  ErrDialog("Graphic successfully dumped!"," Yeah! ");
 663 }
 664
 665
 666 ////////////////////////////////////////////////////
 667 //
 668 // Item - Edit TILEINFO/M values
 669 //
 670 ////////////////////////////////////////////////////
 671 btype ETVb[]={{" Tileinfo ",2,21,1},
 672               {" TileinfoM ",16,21,1},
 673               {" Exit ",30,21,2}};
 674 DialogDef ETVd={"       Edit TILEINFO/M values",38,23,3,&ETVb[0],NULL};
 675 int CurTIvalue;
 676
 677 void Item_EditTinfoValues(void)
 678 {
 679  int max,i,which,exitok=0,mx,my,b0,b1,CTRLdown;
 680  static int whichtinfo=0;
 681
 682  //
 683  // IS THE "CTRL" KEY DOWN?
 684  //
 685  CTRLdown=keydown[0x1d];
 686  if (CTRLdown)
 687    {
 688     if (planeton)
 689       whichtinfo=0;
 690     else
 691       whichtinfo=1;
 692    }
 693
 694  switch(whichtinfo)
 695  {
 696   case 0: max=tilenum; break;
 697   case 1: max=tilemnum;
 698  }
 699
 700  switch(videomode)
 701  {
 702   case CGA:
 703   case EGA1:
 704   case VGA:
 705     ETVd.height=23;
 706     for(i=0;i<3;i++)
 707       ETVb[i].yoff=21;
 708     break;
 709   case EGA2:
 710     ETVd.height=58;
 711     for(i=0;i<3;i++)
 712       ETVb[i].yoff=56;
 713  }
 714
 715  //
 716  // DRAW THE SCREEN
 717  //
 718  DrawDialog(&ETVd,1);
 719  if (CTRLdown)
 720    {
 721     DrawTinfoScreen(whichtinfo,0,-max); // ALIGN TO TOP
 722     switch(whichtinfo)
 723     {
 724      case 0: DrawTinfoScreen(whichtinfo,0,whicht); break;
 725      case 1: DrawTinfoScreen(whichtinfo,0,whichtm-tilenum);
 726     }
 727    }
 728  else
 729    DrawTinfoScreen(whichtinfo,0,0);
 730
 731
 732  do
 733  {
 734   which=CheckButtonsRet(&ETVd);
 735   if (which>=0)
 736     switch(which)
 737     {
 738      case 0:
 739        RestoreBackground();
 740        return;
 741      case 1:
 742        if (whichtinfo)
 743          {
 744           max=tilenum;
 745           whichtinfo=0;
 746           DrawDialog(&ETVd,0);
 747           DrawTinfoScreen(whichtinfo,0,0);
 748          }
 749        else
 750          {
 751           GetButtonXY(&ETVd,0,&sx,&sy);
 752           MouseHide();
 753           print(ETVb[0].text);
 754           MouseShow();
 755           errsound();
 756          }
 757        break;
 758      case 2:
 759        if (!tilemnum)
 760          {
 761           GetButtonXY(&ETVd,1,&sx,&sy);
 762           MouseHide();
 763           print(ETVb[1].text);
 764           MouseShow();
 765           errsound();
 766           break;
 767          }
 768
 769        if (!whichtinfo)
 770          {
 771           max=tilemnum;
 772           whichtinfo=1;
 773           DrawDialog(&ETVd,0);
 774           DrawTinfoScreen(whichtinfo,0,0);
 775          }
 776        else
 777          {
 778           GetButtonXY(&ETVd,1,&sx,&sy);
 779           MouseHide();
 780           print(ETVb[1].text);
 781           MouseShow();
 782           errsound();
 783          }
 784        break;
 785
 786      case 3:
 787        exitok=1;
 788     }
 789   else
 790     {
 791      MouseCoords(&mx,&my);
 792      mx/=8;
 793      my/=8;
 794      b0=MouseButton()&1;
 795      b1=MouseButton()&2;
 796
 797      //
 798      // CHECK FOR BUTTON PRESSES
 799      //
 800      if (b0)
 801        UseTinfoValue(whichtinfo,mx,my,1);
 802      else
 803      if (b1)
 804        UseTinfoValue(whichtinfo,mx,my,0);
 805
 806      //
 807      // SPACE = ENTER VALUES HORIZONTALLY
 808      //
 809      if (keydown[0x39])
 810      {
 811       while(keydown[0x39]);
 812       clearkeys();
 813       EnterTinfoValue(whichtinfo,mx,my,0);
 814      }
 815
 816      //
 817      // CHECK FOR SCROLLING
 818      //
 819      if (keydown[0x48])         // UP
 820        {
 821         DrawTinfoScreen(whichtinfo,0,-1);
 822         if (keydown[0x1d])
 823           while(keydown[0x48]);
 824        }
 825      else
 826      if (keydown[0x50])         // DOWN
 827        {
 828         DrawTinfoScreen(whichtinfo,0,1);
 829         if (keydown[0x1d])
 830           while(keydown[0x50]);
 831        }
 832      else
 833      if (keydown[0x49])         // PGUP
 834        {
 835         DrawTinfoScreen(whichtinfo,0,-8);
 836         if (!keydown[0x1d])
 837           while(keydown[0x49]);
 838        }
 839      else
 840      if (keydown[0x51])         // PGDN
 841        {
 842         DrawTinfoScreen(whichtinfo,0,8);
 843         if (!keydown[0x1d])
 844           while(keydown[0x51]);
 845        }
 846      else
 847      if (keydown[0x47])         // HOME
 848        {
 849         DrawTinfoScreen(whichtinfo,0,-max);
 850         while(keydown[0x47]);
 851        }
 852      else
 853      if (keydown[0x4f])         // END
 854        {
 855         DrawTinfoScreen(whichtinfo,0,max);
 856         while(keydown[0x4f]);
 857        }
 858      else
 859      if (keydown[0x4d])         // RIGHT
 860        {
 861         DrawTinfoScreen(whichtinfo,1,0);
 862         if (!keydown[0x1d])
 863           while(keydown[0x4d]);
 864        }
 865      else
 866      if (keydown[0x4b])         // LEFT
 867        {
 868         DrawTinfoScreen(whichtinfo,-1,0);
 869         if (!keydown[0x1d])
 870           while(keydown[0x4b]);
 871        }
 872
 873     }
 874
 875  } while(!exitok);
 876
 877  RestoreBackground();
 878 }
 879
 880
 881 //
 882 // PICKUP/DROP TILEINFO VALUE AT CURSOR
 883 //
 884 void UseTinfoValue(int whichtinfo,int mx,int my,int PickupOrDrop)
 885 {
 886  int whichx=-1,whichy=-1;
 887  unsigned dialogx,dialogy;
 888
 889
 890  GetDialogXY(&ETVd,&dialogx,&dialogy);
 891
 892  if (mx>=dialogx+10 && mx<=dialogx+45)
 893    whichx=(mx-(dialogx+10))/7;
 894
 895  if (my>=4 && my<=((videomode==EGA2)?55:19))
 896    whichy=(my-4)>>(tsize-1);
 897
 898  switch(whichtinfo)
 899  {
 900   case 0:
 901     if (whichx>=numtplanes)
 902       whichx=-1;
 903     if (whichy>=tilenum)
 904       whichy=-1;
 905     break;
 906
 907   case 1:
 908     if (whichx>=numtmplanes)
 909       whichx=-1;
 910     if (whichy>=tilemnum)
 911       whichy=-1;
 912  }
 913
 914  if (whichx>=0 && whichy>=0)
 915  {
 916   if (!PickupOrDrop)
 917     switch(whichtinfo)
 918     {
 919      case 0:    // TILE
 920        CurTIvalue=*(Tinfo[whichx+TIxbase]+whichy+TIybase);
 921        break;
 922      case 1:    // MASKED
 923        CurTIvalue=*(TMinfo[whichx+TIxmbase]+whichy+TIymbase);
 924     }
 925   else
 926     switch(whichtinfo)
 927     {
 928      case 0:    // TILE
 929        *(Tinfo[whichx+TIxbase]+whichy+TIybase)=CurTIvalue;
 930        DirtyFlag=1;
 931        break;
 932      case 1:    // MASKED
 933        *(TMinfo[whichx+TIxmbase]+whichy+TIymbase)=CurTIvalue;
 934        DirtyFlag=1;
 935     }
 936
 937   DrawTinfoScreen(whichtinfo,0,0);
 938  }
 939  while(MouseButton());
 940 }
 941
 942
 943 //
 944 // ENTER TILEINFO/M CELL VALUES
 945 //
 946 void EnterTinfoValue(int whichtinfo,int mx,int my,int H_or_V)
 947 {
 948  int whichx=-1,whichy=-1,val,outok=0,tempx,tempy,maxx,maxy;
 949  unsigned dialogx,dialogy;
 950
 951
 952  GetDialogXY(&ETVd,&dialogx,&dialogy);
 953
 954  if (mx>=dialogx+10 && mx<=dialogx+45)
 955    whichx=(mx-(dialogx+10))/7;
 956
 957  if (my>=4 && my<=((videomode==EGA2)?55:19))
 958    whichy=(my-4)>>(tsize-1);
 959
 960  switch(whichtinfo)
 961  {
 962   case 0:
 963     if (whichx>=numtplanes)
 964       whichx=-1;
 965     if (whichy>=tilenum)
 966       whichy=-1;
 967     break;
 968
 969   case 1:
 970     if (whichx>=numtmplanes)
 971       whichx=-1;
 972     if (whichy>=tilemnum)
 973       whichy=-1;
 974  }
 975
 976  MouseHide();
 977
 978  if (whichx>=0 && whichy>=0)
 979    do
 980    {
 981     //
 982     // INPUT VALUE
 983     //
 984     sx=whichx*7+dialogx+10;
 985     sy=(whichy<<(tsize-1))+4;
 986     print("    ");
 987     sx-=4;
 988     if ((val=inputint(3))!=(int)ESCOUT)
 989       switch(whichtinfo)
 990       {
 991        case 0:  // TILE
 992          *(Tinfo[whichx+TIxbase]+whichy+TIybase)=val&0xff;
 993          DirtyFlag=1;
 994          break;
 995        case 1:  // MASKED
 996          *(TMinfo[whichx+TIxmbase]+whichy+TIymbase)=val&0xff;
 997          DirtyFlag=1;
 998       }
 999     else
1000       outok=1;
1001
1002     //
1003     // INPUT INTO THE NEXT FIELD!
1004     //
1005     if (!outok)
1006       {
1007        tempx=(whichtinfo?TIxmbase:TIxbase);
1008        tempy=(whichtinfo?TIymbase:TIybase);
1009        maxx=(whichtinfo?numtmplanes:numtplanes);
1010        maxy=(whichtinfo?tilemnum:tilenum);
1011
1012        switch(H_or_V)
1013        {
1014         case 0: // HORIZONTAL
1015           whichx++;
1016           if (tempx+whichx>=maxx)
1017             outok=1;
1018           else
1019           if (whichx>TINFOWIDTH)
1020             {
1021              whichx=TINFOWIDTH;
1022              tempx++;
1023              if (tempx>=maxx)
1024                outok=1;
1025             }
1026
1027           switch(whichtinfo)
1028           {
1029            case 0: TIxbase=tempx; break;
1030            case 1: TIxmbase=tempx;
1031           }
1032           break;
1033
1034         case 1: // VERTICAL
1035           whichy++;
1036           if (tempy+whichy>=maxy)
1037             outok=1;
1038           else
1039           if (whichy>(videomode==EGA2?TINFOHEIGHTEGA2:TINFOHEIGHT))
1040             {
1041              whichy=(videomode==EGA2?TINFOHEIGHTEGA2:TINFOHEIGHT);
1042              tempy++;
1043              if (tempy>=maxy)
1044                outok=1;
1045             }
1046
1047           switch(whichtinfo)
1048           {
1049            case 0: TIybase=tempy; break;
1050            case 1: TIymbase=tempy;
1051           }
1052        }
1053       }
1054
1055     DrawTinfoScreen(whichtinfo,0,0);
1056
1057    } while (!outok);
1058
1059  MouseShow();
1060 }
1061
1062
1063
1064 //
1065 // Draw the Tileinfo screen
1066 //
1067 void DrawTinfoScreen(int thescreen,int deltax,int deltay)
1068 {
1069  int temp,temp1,i,j,width,height,dialogx;
1070  char _seg *Values[10];
1071
1072
1073  MouseHide();
1074  switch(videomode)
1075  {
1076   case CGA:
1077   case EGA1:
1078   case VGA:
1079     dialogx=1;
1080     height=16>>(tsize-1); break;
1081   case EGA2:
1082     dialogx=21;
1083     height=52>>(tsize-1);
1084  }
1085
1086  switch(thescreen)
1087  {
1088   case 0:       // TILEINFO
1089     if (height>tilenum)
1090       height=tilenum;
1091     else
1092       {
1093        TIybase+=deltay;
1094        if (TIybase<0)
1095          TIybase=0;
1096        else
1097        if (TIybase+height>tilenum)
1098          TIybase=tilenum-height;
1099       }
1100     temp=TIybase;
1101     break;
1102
1103   case 1:       // TILEINFOM
1104     if (height>tilemnum)
1105       height=tilemnum;
1106     else
1107       {
1108        TIymbase+=deltay;
1109        if (TIymbase<0)
1110          TIymbase=0;
1111        else
1112        if (TIymbase+height>tilemnum)
1113          TIymbase=tilemnum-height;
1114       }
1115     temp=TIymbase;
1116  }
1117
1118  //
1119  // DRAW TILES AND THEIR VALUES
1120  //
1121  for (i=0;i<height;i++)
1122    {
1123     sx=dialogx;
1124     sy=(i<<(tsize-1))+4;
1125     printhex(i+temp);
1126     sx=dialogx;
1127     sy++;
1128     print("    ");
1129     sx-=4;
1130     printint(i+temp);
1131
1132     switch(thescreen)
1133     {
1134      case 0:
1135        CombineTiles(temp+i,0,0,tsize);
1136        break;
1137      case 1:
1138        CombineTiles(-BkgndColor,temp+i+tilenum,0,tsize);
1139     }
1140
1141     DrawTile(dialogx+5,(i+2)<<(3+(tsize-1)),tsize);
1142    }
1143
1144  //
1145  // DRAW TILEINFO ARRAYS
1146  //
1147  width=4;
1148
1149  switch(thescreen)
1150  {
1151   case 0:
1152     if (width>numtplanes)
1153       width=numtplanes;
1154     else
1155       {
1156        TIxbase+=deltax;
1157        if (TIxbase<0)
1158          TIxbase=0;
1159        else
1160        if (TIxbase+width>numtplanes)
1161          TIxbase=numtplanes-width;
1162       }
1163     temp1=TIxbase;
1164     for (i=0;i<10;i++)
1165       Values[i]=Tinfo[i];
1166
1167     break;
1168
1169   case 1:
1170     if (width>numtmplanes)
1171       width=numtmplanes;
1172     else
1173       {
1174        TIxmbase+=deltax;
1175        if (TIxmbase<0)
1176          TIxmbase=0;
1177        else
1178        if (TIxmbase+width>numtmplanes)
1179          TIxmbase=numtmplanes-width;
1180       }
1181     temp1=TIxmbase;
1182     for (i=0;i<10;i++)
1183       Values[i]=TMinfo[i];
1184  }
1185
1186  for (j=0;j<width;j++)
1187    {
1188     sx=(dialogx+10)+j*7;
1189     sy=3;
1190     switch(thescreen)
1191     {
1192      case 0:
1193        print("       ");
1194        sx-=7;
1195        fprint(MapFileHeader->tnames[j+TIxbase]);
1196        break;
1197      case 1:
1198        print("       ");
1199        sx-=7;
1200        fprint(MapFileHeader->tmnames[j+TIxmbase]);
1201     }
1202     for (i=0;i<height;i++)
1203       {
1204        sx=(dialogx+10)+j*7;
1205        sy=(i<<(tsize-1))+4;
1206        print("$");
1207        printhexb(Values[j+temp1][i+temp]);
1208        sx=(dialogx+10)+j*7;
1209        sy++;
1210        print("   ");
1211        sx-=3;
1212        printint(Values[j+temp1][i+temp]&0xff);
1213       }
1214    }
1215  MouseShow();
1216 }
1217
1218
1219
1220 ////////////////////////////////////////////////////
1221 //
1222 // Item - Add or Delete TILEINFO/M planes
1223 //
1224 ////////////////////////////////////////////////////
1225 btype AODb[]={{" Add ",1,3,1},
1226               {" Delete ",8,3,1},
1227               {" Exit ",18,3,2}},
1228       TOMb[]={{" Tileinfo  ",1,2,1},
1229               {" TileinfoM ",1,5,1}},
1230       AreSureB2[]={{" Yes ",1,2,1},
1231                    {" No ",8,2,2}},
1232       TINb2={" Done ",8,15,1};;
1233 DialogDef AODd={"       TILEINFO/M\n     Pick a function",25,5,3,&AODb[0],NULL},
1234           TOMd={"Add to what?",13,7,2,&TOMb[0],NULL},
1235           NId={"Gimme a name!",13,4,0,NULL,NULL},
1236           AreSureD2={"Are you sure?",13,4,2,&AreSureB2[0],NULL},
1237           TINd2={"   Which to delete?\n"
1238                 " TILEINFO   TILEINFOM",
1239                 22,17,1,&TINb2,NULL};
1240
1241 void Item_AddDelTinfo(void)
1242 {
1243  char temp[16];
1244  int which,i;
1245  unsigned dx,dy;
1246
1247  while(1)
1248  {
1249   which=DoDialog(&AODd);
1250   switch(which)
1251   {
1252    case 0:      // ESC or EXIT
1253    case 3:
1254      return;
1255    //
1256    // ADD
1257    //
1258    case 1:
1259      which=DoDialog(&TOMd);
1260      if (!which)
1261        break;
1262
1263      switch(which)
1264      {
1265       case 1:
1266         if (numtplanes==10)
1267           {
1268            ErrDialog("You already have 10 TILEINFO\n"
1269                      "planes defined!"," OK ");
1270            return;
1271           }
1272         break;
1273
1274       case 2:
1275         if (!tilemnum)
1276           {
1277            ErrDialog("You crazy shit! You don't\n"
1278                      "have any masked tiles!"," Duh! ");
1279            return;
1280           }
1281
1282         if (numtmplanes==10)
1283           {
1284            ErrDialog("You already have 10 TILEINFOM\n"
1285                      "planes defined!"," OK ");
1286            return;
1287           }
1288         break;
1289      }
1290
1291      DrawDialog(&NId,1);
1292      MouseHide();
1293      GetDialogXY(&NId,&dx,&dy);
1294      sx=dx+1;
1295      sy=dy+1;
1296      DrawBorder(sx,sy,9,2,1);
1297      sx=dx+2;
1298      sy=dy+2;
1299      if (!input(temp,7))
1300        {
1301         RestoreBackground();
1302         MouseShow();
1303         break;
1304        }
1305
1306      //
1307      // MOVE THE NAME AND ALLOCATE THE MEMORY!
1308      //
1309      switch(which)
1310      {
1311       case 1:
1312         movedata(FP_SEG(temp),FP_OFF(temp),
1313                  (unsigned)MapFileHeader,FP_OFF(MapFileHeader->tnames[numtplanes]),8);
1314         MMAllocate((memptr *)&Tinfo[numtplanes],tilenum);
1315         for (i=0;i<tilenum;i++)
1316           *(Tinfo[numtplanes]+i)=0;
1317         MapFileHeader->numtplanes=++numtplanes;
1318         writeH=DirtyFlag=1;
1319         break;
1320
1321       case 2:
1322         movedata(FP_SEG(temp),FP_OFF(temp),
1323                  (unsigned)MapFileHeader,FP_OFF(MapFileHeader->tmnames[numtmplanes]),8);
1324         MMAllocate((memptr *)&TMinfo[numtmplanes],tilemnum);
1325         for (i=0;i<tilemnum;i++)
1326           *(TMinfo[numtmplanes]+i)=0;
1327         MapFileHeader->numtmplanes=++numtmplanes;
1328         writeH=DirtyFlag=1;
1329      }
1330
1331      RestoreBackground();
1332      MouseShow();
1333      break;
1334
1335    //
1336    // DELETE
1337    //
1338    case 2:
1339      {
1340       unsigned ox,oy,i,oktoexit=0;
1341       int which;
1342
1343       redo:
1344
1345       MouseHide();
1346       DrawDialog(&TINd2,1);
1347       GetDialogXY(&TINd2,&sx,&sy);
1348       ox=sx;
1349       oy=sy;
1350       DrawBorder(sx,sy+2,10,11,1);
1351       sx=ox;
1352       sy=oy;
1353       DrawBorder(sx+11,sy+2,10,11,1);
1354
1355       for (i=0;i<10;i++)
1356       {
1357        sx=ox+1;
1358        sy=oy+i+3;
1359        fprint(MapFileHeader->tnames[i]);
1360        sx=ox+12;
1361        sy=oy+i+3;
1362        fprint(MapFileHeader->tmnames[i]);
1363       }
1364       MouseShow();
1365
1366       do
1367       {
1368        if ((which=CheckList(ox+1,oy+3,8,numtplanes,TInfoNon,TInfoNoff,0))>=0)
1369          {
1370           int reply;
1371
1372           RestoreBackground();
1373           reply=DoDialog(&AreSureD2);
1374           switch(reply)
1375           {
1376            case 0:
1377            case 2:
1378              goto redo;
1379           }
1380
1381           if (which!=numtplanes-1)
1382             {
1383              for (i=0;i<8;i++)
1384                {
1385                 MapFileHeader->tnames[which][i]=MapFileHeader->tnames[numtplanes-1][i];
1386                 MapFileHeader->tnames[numtplanes-1][i]=0;
1387                }
1388              for (i=0;i<tilenum;i++)
1389                *(Tinfo[which]+i)=*(Tinfo[numtplanes-1]+i);
1390              MMFreePtr((memptr *)&Tinfo[numtplanes-1]);
1391             }
1392           else
1393             {
1394              MMFreePtr((memptr *)&Tinfo[which]);
1395              for (i=0;i<8;i++)
1396                MapFileHeader->tnames[which][i]=0;
1397             }
1398           writeH=DirtyFlag=1;
1399           MapFileHeader->numtplanes=--numtplanes;
1400           goto redo;
1401          }
1402
1403        if ((which=CheckList(ox+12,oy+3,8,numtmplanes,TInfoMNon,TInfoMNoff,0))>=0)
1404          {
1405           int reply;
1406
1407           RestoreBackground();
1408           reply=DoDialog(&AreSureD2);
1409           switch(reply)
1410           {
1411            case 0:
1412            case 2:
1413              goto redo;
1414           }
1415
1416           if (which!=numtmplanes-1)
1417             {
1418              for (i=0;i<8;i++)
1419                {
1420                 MapFileHeader->tmnames[which][i]=MapFileHeader->tmnames[numtplanes-1][i];
1421                 MapFileHeader->tmnames[numtmplanes-1][i]=0;
1422                }
1423              for (i=0;i<tilemnum;i++)
1424                *(TMinfo[which]+i)=*(TMinfo[numtmplanes-1]+i);
1425              MMFreePtr((memptr *)&TMinfo[numtmplanes-1]);
1426             }
1427           else
1428             {
1429              MMFreePtr((memptr *)&TMinfo[which]);
1430              for (i=0;i<8;i++)
1431                MapFileHeader->tmnames[which][i]=0;
1432             }
1433           writeH=DirtyFlag=1;
1434           MapFileHeader->numtmplanes=--numtmplanes;
1435           goto redo;
1436          }
1437
1438        GetButtonXY(&TINd2,0,&sx,&sy);
1439        if (!CheckList(sx,sy,6,1,TIDoneOn,TIDoneOff,1))
1440          oktoexit++;
1441
1442        if (keydown[1])
1443          {
1444           while(keydown[1]);
1445           oktoexit++;
1446          }
1447       }while(!oktoexit);
1448
1449       RestoreBackground();
1450      }
1451   }
1452  }
1453 }
1454
1455
1456
1457 ////////////////////////////////////////////////////
1458 //
1459 // Item - Project Re-Select
1460 //
1461 ////////////////////////////////////////////////////
1462 btype NGBb[]={{" Do It! ",1,4,2},
1463               {" No! Help! ",16,4,1}};
1464 DialogDef NGBd={"Are you sure you want to\n"
1465                 "switch projects? Abort now\n"
1466                 "or forever hold your peace!",
1467                 28,6,2,&NGBb[0],NULL};
1468
1469 void Item_ProjectReSelect(void)
1470 {
1471  int i,which;
1472
1473  //
1474  // ARE YOU SURE?!
1475  //
1476  which=DoDialog(&NGBd);
1477  if (!which || which==2)
1478    return;
1479
1480
1481  TEDInfo->lastvid=videomode;
1482  TEDInfo->level=whichmap;
1483  SaveTEDInfo();
1484  SaveOutputHeader();
1485
1486  if (!CheckForMapSave())
1487    return;
1488
1489  //
1490  // RELEASE ALL MEMORY
1491  //         ---
1492  if (MapBkgnd)
1493    {
1494     MMFreePtr((memptr *)&MapBkgnd);
1495     MMFreePtr((memptr *)&CutBkgnd);
1496    }
1497  if (MapFrgnd)
1498    {
1499     MMFreePtr((memptr *)&MapFrgnd);
1500     MMFreePtr((memptr *)&CutFrgnd);
1501    }
1502  if (MapInfoPl)
1503    {
1504     MMFreePtr((memptr *)&MapInfoPl);
1505     MMFreePtr((memptr *)&CutInfoPl);
1506    }
1507
1508  MMFreePtr((memptr *)&TEDInfo);
1509  MMFreePtr((memptr *)&MapFileHeader);
1510
1511  if (CgaXMS)
1512    {
1513     MMFreePtr((memptr *)&CgaXMSlookup);
1514     XMSFreeMem(CgaXMS);
1515    }
1516  if (EgaXMS)
1517    {
1518     MMFreePtr((memptr *)&EgaXMSlookup);
1519     XMSFreeMem(EgaXMS);
1520    }
1521  if (VgaXMS)
1522    {
1523     MMFreePtr((memptr *)&VgaXMSlookup);
1524     XMSFreeMem(VgaXMS);
1525    }
1526  if (XMSmaps)
1527    XMSFreeMem(XMSmaps);
1528
1529  XMSmaps=CgaXMS=EgaXMS=VgaXMS=xmshandle=0;
1530
1531
1532  for (i=0;i<numtplanes;i++)
1533    if (Tinfo[i])
1534      MMFreePtr((memptr *)&Tinfo[i]);
1535  for (i=0;i<numtmplanes;i++)
1536    if (TMinfo[i])
1537      MMFreePtr((memptr *)&TMinfo[i]);
1538
1539  //
1540  // FORCE RE-INIT
1541  //
1542  writeH=TIxbase=TIxmbase=TIybase=TIymbase=PasteOK=DirtyFlag=ext[0]=0;
1543  lastmap=-1;
1544
1545  FindGraphFile();
1546  LoadInfoFile();
1547  LoadMapHeader();
1548  LoadGraphStuff(0,videomode);
1549  MouseHide();
1550  RedrawDesktop();
1551  MouseShow();
1552  DrawInfoBar();
1553  DrawMap();
1554 }
1555
1556
1557 ////////////////////////////////////////////////////
1558 //
1559 // Item - Toggle GRIDMODE on/off
1560 //
1561 ////////////////////////////////////////////////////
1562 void Item_GridMode(void)
1563 {
1564  GridMode^=1;
1565
1566  if (PasteMode)
1567    DrawFloatPaste();
1568
1569  DrawMap();
1570  DrawInfoBar();
1571 }
1572
1573
1574 ////////////////////////////////////////////////////
1575 //
1576 // Item - Toggle SNAP-PASTE on/off
1577 //
1578 ////////////////////////////////////////////////////
1579 void Item_SnapTog(void)
1580 {
1581  if (!PasteMode)
1582    return;
1583
1584  EraseFloatPaste();
1585  SnapMode^=1;
1586
1587  snapx=(pixelx>>(tsize+2))+xbase;
1588  snapy=((pixely-8)>>(tsize+2))+ybase;
1589  snapxsize=TileCopy.w;
1590  snapysize=TileCopy.h;
1591
1592  snapx=snapx-(snapx/snapxsize)*snapxsize;
1593  snapy=snapy-(snapy/snapysize)*snapysize;
1594
1595  DrawInfoBar();
1596  DrawFloatPaste();
1597 }
1598
1599
1600 ////////////////////////////////////////////////////
1601 //
1602 // Item - View Map & Goto
1603 //
1604 ////////////////////////////////////////////////////
1605 void Item_ViewMap(void)
1606 {
1607  Do_ViewMap(0);
1608 }
1609
1610
1611 ////////////////////////////////////////////////////
1612 //
1613 // Item - Review Map & Goto
1614 //
1615 ////////////////////////////////////////////////////
1616 void Item_ReviewMap(void)
1617 {
1618  Do_ViewMap(1);
1619 }
1620
1621
1622 ////////////////////////////////////////////////////
1623 //
1624 // Code to actually do the ViewMap (and save it in
1625 // EGA memory when finished).
1626 // Entry:
1627 // 0 = ViewMap, as normal & save when done (but only
1628 //      if a full map was viewed)
1629 // 1 = RestoreMap for GOTO
1630 //
1631 ////////////////////////////////////////////////////
1632 void Do_ViewMap(int how)
1633 {
1634  int _seg *a_bg,_seg *a_fg,_seg *a_in,CopyArea,bl_width,bl_height,bl_x,bl_y,p_info;
1635
1636  char huge *EGA=MK_FP(0xa000,0);
1637  char _seg *block,_seg *gblock[4];
1638  int i,j,k,m,n,pwidth,lwidth,maptype,step,pixnum[4]={0,8,16,32},curpix,
1639           maxpack,curline,lybase,t8=8<<(tsize-1),t1=1<<(tsize-1),scrn_h,scrn_w;
1640  long tilelen,bufsize;
1641  int savevideo;
1642
1643
1644
1645  savevideo=videomode;
1646  MouseHide();
1647  setvideo(EGA1);
1648  MouseShow();
1649  if (videomode!=EGA1 && videomode!=EGA2)
1650  {
1651   ErrDialog("This function is currently\n"
1652                  "only usable in EGA mode!"," OK ");
1653   return;
1654  }
1655
1656  //
1657  // SCREEN DIMENSIONS
1658  //
1659  scrn_w=320;
1660  scrn_h=200;
1661
1662
1663  bl_x=bl_y=0;
1664  bl_width=mapwidth;
1665  bl_height=mapheight;
1666  a_bg=MapBkgnd;
1667  a_fg=MapFrgnd;
1668  a_in=MapInfoPl;
1669  p_info=MapFileHeader->maptype;
1670  CopyArea=0;
1671
1672  if ((TileCopy.w>screenw || TileCopy.h>screenh) && !how)
1673         if (Message("\"Yes\" to display full map,\n"
1674                          "\"No\" to display COPY buffer.")==1)
1675         {
1676          bl_x=TileCopy.x;
1677          bl_y=TileCopy.y;
1678          bl_width=TileCopy.w;
1679          bl_height=TileCopy.h;
1680          a_bg=CutBkgnd;
1681          a_fg=CutFrgnd;
1682          a_in=CutInfoPl;
1683          p_info=TileCopy.PlanesCopied;
1684          CopyArea=1;
1685         }
1686
1687  //
1688  // VALIDATE WIDTH & HEIGHT
1689  //
1690  if (bl_height<screenh && bl_width<screenw)
1691  {
1692   ErrDialog("The area fits within the\n"
1693                  "screen! Forget it!"," Wah! ");
1694   return;
1695  }
1696
1697
1698  //
1699  // FIGURE OUT THE BEST RATIO FOR CONVERSION
1700  //
1701  if (!how)
1702         switch(bl_width>=bl_height)
1703         {
1704          case 1: // WIDTH > HEIGHT
1705                 step=(float)(pixnum[tsize]*bl_width)/scrn_w+.5;
1706                 if (pixnum[tsize]*bl_width/step>scrn_w)
1707         step++;
1708                 if ((float)(pixnum[tsize]*bl_height)/step+.5<scrn_h)
1709         break;
1710
1711          case 0: // HEIGHT > WIDTH
1712                 step=(float)(pixnum[tsize]*bl_height)/scrn_h+.5;
1713                 if (pixnum[tsize]*bl_height/step>scrn_h)
1714         step++;
1715         }
1716  else
1717         step=VMapData.step;
1718
1719
1720  //
1721  // POP LAST MAP ON SCREEN
1722  //
1723  if (how)
1724  {
1725   unsigned EGAseg=VMapData.EGAseg;
1726
1727   if (!VMapData.built_flag)
1728   {
1729         ErrDialog("You haven't previously\n"
1730                   "VIEWed a map!"," OK ");
1731         return;
1732   }
1733
1734   //
1735   // RESTORE MAP IN MEMORY!
1736   //
1737   MouseHide();
1738   outport(GCindex,GCmode | 0x100);
1739   outport(SCindex,SCmapmask | 0xf00);
1740   asm   push    ds
1741   asm   mov     ax,[EGAseg]
1742   asm   mov     ds,ax
1743   asm   mov     ax,0xa000
1744   asm   mov     es,ax
1745   asm   xor     si,si
1746   asm   xor     di,di
1747   asm   mov     cx,0x2000
1748   asm   rep movsb
1749   asm   pop     ds
1750   step=VMapData.step;
1751   maxpack=VMapData.maxpack;
1752   MouseShow();
1753  }
1754  //
1755  // BUILD MAP
1756  //
1757  else
1758  {
1759   //
1760   // CLEAR EGA SCREEN
1761   //
1762   outport(GCindex,GCmode);
1763   outport(SCindex,SCmapmask | 0xf00);
1764   _fmemset(MK_FP(0xa000,0),0,0x2000);
1765
1766   //
1767   // SET TILE LENGTH
1768   //
1769   switch(tsize)
1770   {
1771         case 1: tilelen=32L; break;
1772         case 2: tilelen=128L; break;
1773         case 3: tilelen=512L;
1774   }
1775
1776   //
1777   // ALLOCATE TEMP BUFFERS & BEGIN!
1778   //
1779   bufsize=tilelen*bl_width;
1780   pwidth=t1*bl_width;
1781   lwidth=pwidth*4;
1782   MMAllocate((memptr *)&block,bufsize);
1783   maxpack=pwidth/step+1;
1784   for (i=0;i<4;i++)
1785          MMAllocate((memptr *)&gblock[i],maxpack);
1786
1787   outport(GCindex,GCmode);
1788   curline=0;
1789   for (j=bl_y;j<bl_y+bl_height;j++)
1790   {
1791         lybase=j*t8;
1792         for (i=bl_x;i<bl_x+bl_width;i++)
1793         {
1794          unsigned tilet,tilem,tilei,loc;
1795
1796          //
1797          // ESC out?
1798          //
1799          if (keydown[1])
1800          {
1801           while(keydown[1]);
1802           setvideo(savevideo);
1803           RedrawDesktop();
1804           DrawMap();
1805           DrawInfoBar();
1806           return;
1807          }
1808          //
1809          // GET THE CORRECT TILE MOVED INTO "TDATA"
1810          //
1811          loc=j*mapwidth+i;
1812          tilet=viewton?((p_info&BPLANE)?a_bg[loc]:-BkgndColor):-BkgndColor;
1813          tilem=viewmon?((p_info&FPLANE)?a_fg[loc]+tilenum:0):0;
1814          tilei=viewion?((p_info&IPLANE)?a_in[loc]+tilenum:0):0;
1815          CombineTiles(tilet,tilem,tilei,tsize);
1816
1817          //
1818          // NOW, MUNGE "TDATA" INTO BIT-PLANES!
1819          //
1820          // INTERNAL:           P0      P1      P2      P3
1821          //     SCANLINE x      ......  ......  ......  ......
1822          //
1823          for (k=0;k<t8;k++)
1824                 if (!((lybase+k)%step))
1825         for (m=0;m<4;m++)
1826           movedata(FP_SEG(&tdata),FP_OFF(&tdata)+(m*tsize*t8)+k*t1,
1827                          (unsigned)block,k*lwidth+m*pwidth+(i-bl_x)*t1,t1);
1828         }
1829
1830         //
1831         // CONVERT BIT-PLANE LINES TO COMPRESSED FORM...
1832         //
1833         for (k=0;k<8<<(tsize-1);k++)
1834         {
1835          if (!((lybase+k)%step))
1836          {
1837           int midx=k*lwidth;
1838
1839
1840           curpix=0;
1841           _fmemset(gblock[0],0,maxpack);
1842           _fmemset(gblock[1],0,maxpack);
1843           _fmemset(gblock[2],0,maxpack);
1844           _fmemset(gblock[3],0,maxpack);
1845           for (m=0;m<pwidth*8;m++)
1846           {
1847                 if (!(m%step))
1848                 {
1849                  int temp=curpix/8,
1850                 temp1=7-(curpix%8),
1851                 temp2=7-(m%8),
1852                 idx;
1853
1854
1855                  idx=midx+m/8;
1856
1857                  #if 1
1858                  asm    push    ds
1859
1860                  asm    mov     ds,[block]
1861                  asm    mov     si,[idx]
1862                  asm    mov     cl,[BYTE PTR temp2]
1863                  asm    mov     ch,[BYTE PTR temp1]
1864                  asm    mov     di,[temp]
1865                  asm    mov     dx,[pwidth]
1866                  asm    dec     dx
1867
1868                  asm    mov     es,[WORD PTR gblock]
1869
1870                  asm    lodsb
1871                  asm    shr     al,cl
1872                  asm    and     al,1
1873                  asm    xchg    ch,cl
1874                  asm    shl     al,cl
1875                  asm    xchg    ch,cl
1876                  asm    or      [es:di],al
1877
1878                  asm    add     si,dx
1879
1880                  asm    mov     es,[WORD PTR gblock+2]
1881
1882                  asm    lodsb
1883                  asm    shr     al,cl
1884                  asm    and     al,1
1885                  asm    xchg    ch,cl
1886                  asm    shl     al,cl
1887                  asm    xchg    ch,cl
1888                  asm    or      [es:di],al
1889
1890                  asm    add     si,dx
1891
1892                  asm    mov     es,[WORD PTR gblock+4]
1893
1894                  asm    lodsb
1895                  asm    shr     al,cl
1896                  asm    and     al,1
1897                  asm    xchg    ch,cl
1898                  asm    shl     al,cl
1899                  asm    xchg    ch,cl
1900                  asm    or      [es:di],al
1901
1902                  asm    add     si,dx
1903
1904                  asm    mov     es,[WORD PTR gblock+6]
1905
1906                  asm    lodsb
1907                  asm    shr     al,cl
1908                  asm    and     al,1
1909                  asm    xchg    ch,cl
1910                  asm    shl     al,cl
1911                  asm    xchg    ch,cl
1912                  asm    or      [es:di],al
1913
1914                  asm    add     si,dx
1915
1916                  asm    pop     ds
1917
1918                  #else
1919                  *(gblock[0]+temp)|=((block[idx]>>temp2)&1)<<temp1;
1920                  *(gblock[1]+temp)|=((block[idx+pwidth]>>temp2)&1)<<temp1;
1921                  *(gblock[2]+temp)|=((block[idx+pwidth*2]>>temp2)&1)<<temp1;
1922                  *(gblock[3]+temp)|=((block[idx+pwidth*3]>>temp2)&1)<<temp1;
1923                  #endif
1924
1925                  curpix++;
1926                 }
1927           }
1928
1929           //
1930           // BLAST ONTO THE SCREEN
1931           //
1932
1933           MouseHide();
1934           for (n=0;n<4;n++)
1935           {
1936                 outport(SCindex,SCmapmask | (0x100<<n));
1937                 for (m=0;m<maxpack;m++)
1938         *(EGA+EGA1lookup[curline]+m)=*(gblock[n]+m);
1939      }
1940      MouseShow();
1941
1942      curline++;
1943     }
1944    }
1945   }
1946
1947   MMFreePtr((memptr *)&block);
1948   for(m=0;m<4;m++)
1949     MMFreePtr((memptr *)&gblock[m]);
1950
1951
1952   //
1953   // SAVE MAP IN MEMORY!
1954   //
1955   if (!CopyArea)
1956   {
1957    unsigned EGAseg=0xa800;
1958
1959
1960    MouseHide();
1961    outport(GCindex,GCmode | 0x100);
1962    outport(SCindex,SCmapmask | 0xf00);
1963    asm  push    ds
1964    asm  mov     ax,[EGAseg]
1965    asm  mov     es,ax
1966    asm  mov     ax,0xa000
1967    asm  mov     ds,ax
1968    asm  xor     si,si
1969    asm  xor     di,di
1970    asm  mov     cx,0x2000
1971    asm  rep movsb
1972    asm  pop     ds
1973    VMapData.step=step;
1974    VMapData.built_flag=1;
1975    VMapData.EGAseg=EGAseg;
1976    VMapData.maxpack=maxpack;
1977    MouseShow();
1978   }
1979  }
1980
1981
1982  //
1983  // DONE WITH MAP BUILD-N-DISPLAY
1984  //
1985  SignalSound();
1986  clearkeys();
1987
1988  //
1989  // IF MOUSE BUTTON PRESSED WITHIN REGION, GO THERE!
1990  //
1991  while(!bioskey(1))
1992    if (MouseButton())
1993    {
1994     int x,y;
1995
1996     MouseCoords(&x,&y);
1997     if (x<maxpack*8 && y<(mapheight*t8/step) && !CopyArea)
1998     {
1999      xbase=(x*step)/t8-screenw/2;
2000      ybase=(y*step)/t8-screenh/2;
2001      if (xbase+screenw>mapwidth)
2002        xbase=mapwidth-screenw;
2003      if (ybase+screenh>mapheight)
2004        ybase=mapheight-screenh;
2005      if (xbase<0)
2006        xbase=0;
2007      if (ybase<0)
2008        ybase=0;
2009     }
2010     while(MouseButton());
2011     break;
2012    }
2013
2014  clearkeys();
2015  MouseHide();
2016  setvideo(savevideo);
2017  RedrawDesktop();
2018  DrawMap();
2019  DrawInfoBar();
2020  MouseShow();
2021 }
2022
2023
2024 ////////////////////////////////////////////////////
2025 //
2026 // MAP IMPORTING FUNCTIONS FOLLOW:
2027 //
2028 ////////////////////////////////////////////////////
2029 char _seg *oldnames,oldmapname[64],oldmapheadname[64],
2030         oldSM_name[64],oldSM_loadname[64];
2031
2032 int IM_swapin(void)
2033 {
2034  int i;
2035
2036
2037  _fstrcpy(mapheadname,TEDInfo->ImportPath);
2038  strcat(mapheadname,oldmapheadname);
2039  if (access(mapheadname,0))
2040    {
2041     strcpy(mapheadname,oldmapheadname);
2042     return 0;
2043    }
2044
2045  _fstrcpy(mapname,TEDInfo->ImportPath);
2046  strcat(mapname,oldmapname);
2047
2048
2049  _fstrcpy(SM_name,TEDInfo->ImportPath);
2050  strcat(SM_name,oldSM_name);
2051
2052  _fstrcpy(SM_loadname,TEDInfo->ImportPath);
2053  strcat(SM_loadname,oldSM_loadname);
2054
2055  MMAllocate((memptr *)&oldnames,100*16);
2056  movedata(FP_SEG(MapNames),FP_OFF(MapNames),(unsigned)oldnames,0,100*16);
2057
2058  MMFreePtr((memptr *)&MapFileHeader);
2059
2060  LoadIn(mapheadname,(memptr *)&MapFileHeader);
2061
2062  for (i=0;i<100;i++)
2063    if (MapFileHeader->dataoffsets[i]>=0)
2064    {
2065     MapHeaderStr TempHead;
2066
2067     LoadFile(mapname,(char huge *)&TempHead,MapFileHeader->dataoffsets[i],sizeof(MapHeaderStr));
2068     strcpy(MapNames[i],TempHead.name);
2069    }
2070  return 1;
2071 }
2072
2073
2074 void IM_swapout(void)
2075 {
2076  if (oldnames)          // GET RID OF MAPNAMES
2077  {
2078   strcpy(mapname,oldmapname);
2079   strcpy(mapheadname,oldmapheadname);
2080   strcpy(SM_name,oldSM_name);
2081   strcpy(SM_loadname,oldSM_loadname);
2082
2083   movedata((unsigned)oldnames,0,FP_SEG(MapNames),FP_OFF(MapNames),100*16);
2084   MMFreePtr((memptr *)&oldnames);
2085   MMFreePtr((memptr *)&MapFileHeader);
2086   LoadIn(mapheadname,(memptr *)&MapFileHeader);
2087
2088  }
2089 }
2090
2091 void IM_LoadMap(void)
2092 {
2093  unsigned long csize,size=0;
2094  memptr block;
2095
2096  //
2097  // DEALLOCATE ALL CURRENT MAP MEMORY
2098  //
2099  if (MapBkgnd)
2100    {
2101     MMFreePtr((memptr *)&MapBkgnd);
2102     MMFreePtr((memptr *)&CutBkgnd);
2103    }
2104  if (MapFrgnd)
2105    {
2106     MMFreePtr((memptr *)&MapFrgnd);
2107     MMFreePtr((memptr *)&CutFrgnd);
2108    }
2109  if (MapInfoPl)
2110    {
2111     MMFreePtr((memptr *)&MapInfoPl);
2112     MMFreePtr((memptr *)&CutInfoPl);
2113    }
2114
2115  //
2116  // LOAD MAP HEADER
2117  //
2118  LoadFile(mapname,(char huge *)&MapHeader,MapFileHeader->dataoffsets[whichmap],sizeof(MapHeaderStr));
2119
2120  //
2121  // LOAD & DECOMPRESS MAP PLANES
2122  //
2123  if (MapFileHeader->maptype & BPLANE)
2124    {
2125     LoadFile(mapname,(char huge *)&size,MapHeader.mapbkgndpl,2);
2126
2127     MMAllocate((memptr *)&MapBkgnd,size);
2128     MMAllocate((memptr *)&CutBkgnd,size);
2129     csize=MapHeader.mapbkgndlen-2;
2130     MMAllocate(&block,csize);
2131
2132     LoadFile(mapname,MK_FP(block,0),MapHeader.mapbkgndpl+2,csize);
2133
2134     RLEWExpand(MK_FP(block,0),MK_FP(MapBkgnd,0),size,MapFileHeader->RLEWtag);
2135     MMFreePtr(&block);
2136    }
2137  if (MapFileHeader->maptype & FPLANE)
2138    {
2139     LoadFile(mapname,(char huge *)&size,MapHeader.mapfrgndpl,2);
2140
2141     MMAllocate((memptr *)&MapFrgnd,size);
2142     MMAllocate((memptr *)&CutFrgnd,size);
2143     csize=MapHeader.mapfrgndlen-2;
2144     MMAllocate(&block,csize);
2145
2146     LoadFile(mapname,MK_FP(block,0),MapHeader.mapfrgndpl+2,csize);
2147
2148     RLEWExpand(MK_FP(block,0),MK_FP(MapFrgnd,0),size,MapFileHeader->RLEWtag);
2149     MMFreePtr(&block);
2150    }
2151  if (MapFileHeader->maptype & IPLANE)
2152    {
2153     LoadFile(mapname,(char huge *)&size,MapHeader.mapinfopl,2);
2154
2155     MMAllocate((memptr *)&MapInfoPl,size);
2156     MMAllocate((memptr *)&CutInfoPl,size);
2157     csize=MapHeader.mapinfolen-2;
2158     MMAllocate(&block,csize);
2159
2160     LoadFile(mapname,MK_FP(block,0),MapHeader.mapinfopl+2,csize);
2161
2162     RLEWExpand(MK_FP(block,0),MK_FP(MapInfoPl,0),size,MapFileHeader->RLEWtag);
2163     MMFreePtr(&block);
2164    }
2165 }
2166
2167
2168 void IM_SaveMap(void)
2169 {
2170  memptr block;
2171  long fsize,size,nsize,change;
2172  MapHeaderStr TempHeader;
2173  int i,XMStemp;
2174  char string[100],TEDid[]=IDSTRING;
2175
2176
2177
2178  strcpy(string,"Saving Map, '");
2179  strcat(string,MapHeader.name);
2180
2181  strcat(string,"'.");
2182  ErrDialog(string,"");
2183
2184  //
2185  // SAVE MAP FILE HEADER
2186  //
2187  SaveFile(mapheadname,MK_FP(MapFileHeader,0),0,sizeof(MapFileHeaderStr));
2188  fsize=sizeof(MapFileHeaderStr);
2189
2190  //
2191  // COMPRESS & SAVE TILEINFOS
2192  //
2193  for (i=0;i<numtplanes;i++)
2194    {
2195     MMAllocate(&block,tilenum);
2196     MapFileHeader->tileinfooff[i]=fsize;
2197     nsize=RLEBCompress(MK_FP(Tinfo[i],0),tilenum,MK_FP(block,0),MapFileHeader->RLEWtag);
2198     MapFileHeader->tileinfolen[i]=nsize;
2199     SaveFile(mapheadname,MK_FP(block,0),fsize,nsize);
2200     fsize+=nsize;
2201     MMFreePtr(&block);
2202    }
2203
2204  for (i=0;i<numtmplanes;i++)
2205    {
2206     MMAllocate(&block,tilemnum);
2207     MapFileHeader->tileinfomoff[i]=fsize;
2208     nsize=RLEBCompress(MK_FP(TMinfo[i],0),tilemnum,MK_FP(block,0),MapFileHeader->RLEWtag);
2209     MapFileHeader->tileinfomlen[i]=nsize;
2210     SaveFile(mapheadname,MK_FP(block,0),fsize,nsize);
2211     fsize+=nsize;
2212     MMFreePtr(&block);
2213    }
2214
2215  MapFileHeader->oldtilenum=tilenum;
2216  MapFileHeader->oldtilemnum=tilemnum;
2217
2218  SaveFile(mapheadname,MK_FP(MapFileHeader,2),2,sizeof(MapFileHeaderStr)-2);
2219  //
2220  // SAVE ALREADY COMPRESSED MAPS
2221  //
2222
2223  //
2224  // NOTE: I AM STORING "TED5" AT THE START OF THE FILE BECAUSE
2225  // SAVING THE FILE AT OFFSET 0 WILL TRASH IT (I HAVE TO RE-SAVE THE HEADER!)
2226  //
2227  SaveFile(SM_name,(char huge *)TEDid,0,strlen(TEDid));
2228  fsize=strlen(TEDid);
2229
2230  for (i=0;i<100;i++)
2231  {
2232   long oldoff;
2233
2234   if (MapFileHeader->dataoffsets[i]==-1 || i==whichmap)
2235     continue;
2236
2237   oldoff=MapFileHeader->dataoffsets[i];
2238
2239   LoadFile(SM_loadname,(char huge *)&TempHeader,oldoff,sizeof(MapHeaderStr));
2240
2241   strcpy(TempHeader.name,MapNames[i]);
2242   MapFileHeader->dataoffsets[i]=fsize;
2243   size=TempHeader.mapbkgndlen+TempHeader.mapfrgndlen+TempHeader.mapinfolen;
2244   change=TempHeader.mapbkgndpl-fsize-sizeof(MapHeaderStr);
2245   TempHeader.mapbkgndpl-=change;
2246   TempHeader.mapfrgndpl-=change;
2247   TempHeader.mapinfopl-=change;
2248
2249   SaveFile(SM_name,(char huge *)&TempHeader,fsize,sizeof(MapHeaderStr));
2250   fsize+=sizeof(MapHeaderStr);
2251
2252   MMAllocate(&block,size);
2253   LoadFile(SM_loadname,MK_FP(block,0),oldoff+sizeof(MapHeaderStr),size);
2254   SaveFile(SM_name,MK_FP(block,0),fsize,size);
2255   fsize+=size;
2256   SaveFile(SM_name,"!ID!",fsize,4);
2257   fsize+=4;
2258   MMFreePtr(&block);
2259  }
2260
2261  //
2262  // SAVE CURRENT MAP AT END OF FILE
2263  //
2264  MapFileHeader->dataoffsets[whichmap]=fsize;
2265  MapFileHeader->datalengths[whichmap]=sizeof(MapHeaderStr);
2266  SaveFile(SM_name,(char huge *)&MapHeader,fsize,sizeof(MapHeaderStr));
2267  fsize+=sizeof(MapHeaderStr);
2268
2269  size=MapHeader.width*MapHeader.height*sizeof(int);
2270  MMAllocate(&block,size);
2271  if (MapFileHeader->maptype & BPLANE)
2272    {
2273     MapHeader.mapbkgndpl=fsize;
2274     nsize=RLEWCompress(MK_FP(MapBkgnd,0),size,MK_FP(block,0),MapFileHeader->RLEWtag);
2275     MapHeader.mapbkgndlen=nsize+2;
2276
2277     SaveFile(SM_name,(char huge *)&size,fsize,2);
2278     fsize+=2;
2279     SaveFile(SM_name,MK_FP(block,0),fsize,nsize);
2280     fsize+=nsize;
2281    }
2282  else
2283    MapHeader.mapbkgndlen=0;
2284
2285  if (MapFileHeader->maptype & FPLANE)
2286    {
2287     MapHeader.mapfrgndpl=fsize;
2288     nsize=RLEWCompress(MK_FP(MapFrgnd,0),size,MK_FP(block,0),MapFileHeader->RLEWtag);
2289     MapHeader.mapfrgndlen=nsize+2;
2290
2291     SaveFile(SM_name,(char huge *)&size,fsize,2);
2292     fsize+=2;
2293     SaveFile(SM_name,MK_FP(block,0),fsize,nsize);
2294     fsize+=nsize;
2295    }
2296  else
2297    MapHeader.mapfrgndlen=0;
2298
2299  if (MapFileHeader->maptype & IPLANE)
2300    {
2301     MapHeader.mapinfopl=fsize;
2302     nsize=RLEWCompress(MK_FP(MapInfoPl,0),size,MK_FP(block,0),MapFileHeader->RLEWtag);
2303     MapHeader.mapinfolen=nsize+2;
2304
2305     SaveFile(SM_name,(char huge *)&size,fsize,2);
2306     fsize+=2;
2307     SaveFile(SM_name,MK_FP(block,0),fsize,nsize);
2308     fsize+=nsize;
2309    }
2310  else
2311    MapHeader.mapinfolen=0;
2312
2313  SaveFile(SM_name,"!ID!",fsize,4);
2314
2315  fsize+=4;
2316
2317  MMFreePtr(&block);
2318
2319  // RE-SAVE HEADER
2320  SaveFile(SM_name,(char huge *)&MapHeader,
2321      MapFileHeader->dataoffsets[whichmap],sizeof(MapHeaderStr));
2322
2323  //
2324  // RE-SAVE FILE HEADER
2325  // NOTE: The "2" is so MSDOS doesn't truncate the fucking file!
2326  //
2327  SaveFile(mapheadname,MK_FP(MapFileHeader,2),2,sizeof(MapFileHeaderStr)-2);
2328
2329  unlink(SM_loadname);
2330  rename(SM_name,SM_loadname);
2331
2332  RestoreBackground();
2333 }
2334
2335
2336 ////////////////////////////////////////////////////
2337 //
2338 // Item - Import Maps
2339 //
2340 ////////////////////////////////////////////////////
2341 btype IMPMb[]={{"New Path",3,2,1},
2342                {" Import ",3,5,1},
2343                {"  Exit  ",3,8,2}};
2344 DialogDef IMPMd={"Map Importing",13,11,3,&IMPMb[0],NULL};
2345 btype NPb={"                                    ",1,3,1};
2346 DialogDef NPd={"Current Path:",38,5,1,&NPb,NULL};
2347
2348
2349 void Item_ImportMaps(void)
2350 {
2351  char imfile[64],tempstr[40],impath[64];
2352  int oldwhichmap,which,mapnum,i;
2353  int oldxb,oldyb;
2354
2355
2356  CheckForMapSave();
2357
2358  //
2359  // THE IMPORT FUNCTION WILL RID THE SYSTEM OF XMSMAPS
2360  //
2361  if (XMSmaps)
2362  {
2363   XMSFreeMem(XMSmaps);
2364   XMSmaps=0;
2365  }
2366
2367  //
2368  // SAVE PATHS
2369  //
2370  _fstrcpy(impath,TEDInfo->ImportPath);
2371
2372  strcpy(oldmapname,mapname);
2373  strcpy(oldmapheadname,mapheadname);
2374  strcpy(oldSM_name,SM_name);
2375  strcpy(oldSM_loadname,SM_loadname);
2376
2377  oldxb=xbase;
2378  oldyb=ybase;
2379  #pragma warn -sus
2380  oldnames=0;
2381  #pragma warn +sus
2382  oldwhichmap=whichmap;
2383
2384  DrawDialog(&IMPMd,1);
2385  while(1)
2386  {
2387   which=CheckButtons(&IMPMd);
2388   switch(which)
2389   {
2390    //
2391    // NEW PATH
2392    //
2393    case 1:
2394      MouseHide();
2395      DrawDialog(&NPd,1);
2396      GetDialogXY(&NPd,&sx,&sy);
2397      sy++;
2398      sx++;
2399      if (!impath[0])
2400        print("- current dir -");
2401      else
2402        print(impath);
2403      GetButtonXY(&NPd,0,&sx,&sy);
2404      if (input(tempstr,36))
2405        {
2406         strcpy(impath,tempstr);
2407         if (impath[strlen(impath)-1]!='\\')
2408           strcat(impath,"\\");
2409
2410         MouseShow();
2411         if (access(mapheadname,0))
2412         {
2413          ErrDialog("Can't find any TED5\n"
2414                    "map files at that path."," OK ");
2415         }
2416         else
2417         {
2418          RestoreBackground();
2419          ErrDialog("Verifying path...","");
2420          _fstrcpy(TEDInfo->ImportPath,impath);
2421          DirtyFlag=1;
2422         }
2423
2424         MouseHide();
2425        }
2426      MouseShow();
2427      RestoreBackground();
2428      break;
2429
2430    //
2431    // IMPORT
2432    //
2433    case 2:
2434      if (!oldnames)
2435      {
2436       ErrDialog("Loading File Info...","");
2437       if (!IM_swapin())
2438       {
2439        RestoreBackground();
2440        ErrDialog("Having problems with your path!"," OK ");
2441        break;
2442       }
2443       RestoreBackground();
2444      }
2445
2446      mapnum=SelectMap(1,CREATED,"TO IMPORT");
2447      if (mapnum>=0)
2448      {
2449       char check[100]="Are you SURE you want to\n"
2450                       "Import ";
2451
2452       strcat(check,MapNames[mapnum]);
2453       strcat(check,"?");
2454       if (Message(check)<2)
2455         break;
2456
2457       whichmap=mapnum;
2458       ErrDialog("Importing. One moment.","");
2459       IM_LoadMap();
2460       IM_swapout();
2461       IM_SaveMap();
2462       IM_swapin();
2463       RestoreBackground();
2464      }
2465      break;
2466
2467    //
2468    // EXIT
2469    //
2470    case 0:
2471    case 3:
2472      RestoreBackground();
2473      whichmap=oldwhichmap;
2474      IM_swapout();
2475
2476      LoadMap(whichmap);
2477      xbase=oldxb;
2478      ybase=oldyb;
2479      DrawMap();
2480
2481      return;
2482   }
2483  }
2484 }
2485
2486
2487 ////////////////////////////////////////////////////
2488 //
2489 // Item - Visit DOS
2490 //
2491 ////////////////////////////////////////////////////
2492 int olddisk;
2493 char oldpath[64]="\\";
2494
2495 void Item_VisitDOS(void)
2496 {
2497  TempStruct LaunchInfo;
2498  char ename[64],temp[40],tiname[14]="TEDINFO.TMP";
2499
2500  long size;
2501
2502
2503  //
2504  // Save the handles for all XMS memory so we don't
2505  // have to re-install this shit!
2506  //
2507  TEDInfo->OldCgaXMS=CgaXMS;
2508  TEDInfo->OldEgaXMS=EgaXMS;
2509  TEDInfo->OldVgaXMS=VgaXMS;
2510
2511  TEDInfo->OldCgaXMSsize=CgaXMSsize;
2512  TEDInfo->OldEgaXMSsize=EgaXMSsize;
2513  TEDInfo->OldVgaXMSsize=VgaXMSsize;
2514
2515  size=4L*(tilenum+tilemnum);
2516  if (CgaXMS)
2517    {
2518     if (1024L*XMSTotalFree()<size)
2519       {
2520        XMSFreeMem(CgaXMS);
2521        TEDInfo->OldCgaXMS=TEDInfo->OldCgaXMSsize=0;
2522       }
2523     else
2524       {
2525        TEDInfo->CgaXMSlook=XMSAllocate(size);
2526        XMSmove(0,(long)MK_FP(CgaXMSlookup,0),TEDInfo->CgaXMSlook,0,size);
2527       }
2528    }
2529
2530  if (EgaXMS)
2531    {
2532     if (1024L*XMSTotalFree()<size)
2533       {
2534        XMSFreeMem(EgaXMS);
2535        TEDInfo->OldEgaXMS=TEDInfo->OldEgaXMSsize=0;
2536       }
2537     else
2538       {
2539        TEDInfo->EgaXMSlook=XMSAllocate(size);
2540        XMSmove(0,(long)MK_FP(EgaXMSlookup,0),TEDInfo->EgaXMSlook,0,size);
2541       }
2542    }
2543
2544  if (VgaXMS)
2545    {
2546     if (1024L*XMSTotalFree()<size)
2547       {
2548        XMSFreeMem(VgaXMS);
2549        TEDInfo->OldVgaXMS=TEDInfo->OldVgaXMSsize=0;
2550       }
2551     else
2552       {
2553        TEDInfo->VgaXMSlook=XMSAllocate(size);
2554        XMSmove(0,(long)MK_FP(VgaXMSlookup,0),TEDInfo->VgaXMSlook,0,size);
2555       }
2556    }
2557
2558  //
2559  // SAVE CURRENT VIDEOMODE FOR LAUNCH RETURN
2560  //
2561  LaunchInfo.lastmode=videomode;
2562  strcpy(LaunchInfo.ext,ext);
2563  SaveFile(tiname,(char huge *)&LaunchInfo,0,sizeof(TempStruct));
2564
2565  TEDInfo->oscrx=xbase;
2566  TEDInfo->oscry=ybase;
2567  _fmemcpy((void far *)TEDInfo->parmstring,(void far *)parmstring,64);
2568
2569  Item_SaveMap();
2570  SaveTEDInfo();
2571  SaveOutputHeader();
2572
2573  if (XMSmaps)
2574    XMSFreeMem(XMSmaps);
2575
2576  strcpy(temp,"Launching ");
2577  _fstrcat((char far *)temp,(char far *)TEDInfo->launchname);
2578  strcat(temp,"...");
2579  ErrDialog(temp,"");
2580  clearkeys();
2581  nosound();
2582  MouseHide();
2583
2584  _fmemcpy((char far *)ename,(char far *)TEDInfo->launchname,14);
2585
2586  RemoveUndoBuffers();
2587  ShutdownKBD();
2588
2589  //
2590  // ARE WE EXITING WITH A BATCH FILE?
2591  //
2592
2593  setvideo(TEXT);
2594  printf("The TED5 DOS shell. Type 'EXIT' to return to TED5.");
2595
2596  //
2597  // SAVE CURRENT DRIVE & PATH
2598  //
2599  olddisk=getdisk();
2600  getcurdir(0,oldpath+1);
2601
2602  MMShutdown();
2603  fcloseall();
2604  spawnlp(P_WAIT,"COMMAND",NULL);
2605
2606  //
2607  // RESET OLD PATH
2608  //
2609  setdisk(olddisk);
2610  chdir(oldpath);
2611
2612  execlp("TED5.EXE","TED5.EXE","/LAUNCH",NULL);
2613
2614  printf("Can't find TED5 for some reason!");
2615  exit(1);
2616 }
2617
2618
2619 ////////////////////////////////////////////////////
2620 //
2621 // Item - Paste Overlay toggle
2622 //
2623 ////////////////////////////////////////////////////
2624 void Item_POtog(void)
2625 {
2626  F3_flag^=1;
2627
2628  if (PasteMode)
2629  {
2630   EraseFloatPaste();
2631   DrawFloatPaste();
2632  }
2633 }