16/ted5/TED5.C

   1 ////////////////////////////////////////////////////
   2 //
   3 // TED 5
   4 // MultiVideo mode, MultiTile size, MultiMap editor
   5 // by John Romero (C) 1991 Id Software
   6 //
   7 // Development Log:
   8 // -------------------------------------------------
   9 // Mar 19 91 - Starting this thing! Getting it to
  10 //      compile with the JHUFF and MEM stuff.
  11 //
  12 // Mar 20 91 - Got the whole deal compiling and wrote
  13 //      the EGA drawchar routine and got most of
  14 //      Dialogs written!
  15 //
  16 // Mar 25 91 - Forgot some days in there! Got the XMS
  17 //      stuff going and started the big initialization
  18 //      part. Past init will be lots easier!
  19 //
  20 // Mar 30 91 - Got map selection and dimensioning and
  21 //      allocation done. Added more MENU abilities to
  22 //      allow more flexible dialogs.
  23 //
  24 // Apr  7 91 - Got project initialization done. Got
  25 //      tiles into XMS. Wrote XMS routines for all
  26 //      memory functions needed.
  27 //
  28 // Apr 12 91 - FINALLY got the maps loading and saving
  29 //      correctly - NO THANKS TO MR.C OVER THERE! You
  30 //      see, he can't remember whether his expansion
  31 //      routines use the compressed or expanded length
  32 //      and that was causing me quite a problem. Got
  33 //      it solved and the map shuffling shit works
  34 //      PERFECTLY now!  Got tile select in, map stats,
  35 //      and other stuff...
  36 //
  37 // Apr 19 91 - Got all 3 planes working (drawing,etc.)
  38 //      TileSelect screens jam...lots of little options
  39 //      thrown in... !!! I got my '75 Cougar !!!
  40 //
  41 // Apr 25 91 - Got map dimension changing done! Fixed
  42 //      some small bugs...had a WHOPPER of a fucking
  43 //      bug today ... I was overwriting the stack
  44 //      when the first background save happened. I'm SURE
  45 //      I allocated enough memory -- I don't know...
  46 //
  47 // Apr 27 91 - Map Edge Select works (for Copy) & now I
  48 //      draw a frame around the entire region.
  49 //
  50 // May 01 91 - Added a nice feature - retaining the Copy
  51 //      buffer wherever it may get toasted. Used XMS so
  52 //      I didn't chew mainmem. Also made it so you can
  53 //      turn the plane READ/WRITEs ON/OFF (obvious advantage).
  54 //      Got Copy/Paste from everywhere with FloatingPaste!
  55 //
  56 // May 03 91 - Got entering values for infoplane stuff & all
  57 //      that shit encompasses. Trying to get a cursor drawn
  58 //      (with backgrnd save/restore) in CGA & EGA3 modes.
  59 //      Wish me luck! ... FUCK IT! I removed EGA3 mode -- it
  60 //      was too much shit & kludgery to get a cursor going.
  61 //
  62 // May 08 91 - Well! Let's see...I got Huffman map compression
  63 //      done; wrote a MakeOBJ function that can be used within
  64 //      the Memory Manager or Standard Borland C. Added .OBJ
  65 //      generation to IGRAB. Started the function to generate
  66 //      graphic map dumps. Modified the MapHeader stuff more
  67 //      when John needed "extras".
  68 //
  69 // May 09 91 - Finished ILBM & Apple Preferred map dumps!
  70 //      Fixed a couple hidden bugs, made some things nicer,
  71 //      started on Flood Fill...
  72 //
  73 // May 11 91 - Got the TILEINFO/M stuff structured and loading
  74 //      and saving (with compression). Putting all the "hidden"
  75 //      commands in the menus...
  76 //
  77 // May 13 91 - Stuck in a PROJECT SELECT option (for the Keen2
  78 //      trilogy, it'll be nice).
  79 //
  80 // May 16 91 - Got all of TILEINFO stuff finished. Tom and
  81 //      Jason's first day! Tom BETAed IGRAB & TED5 big time.
  82 //      Had to basically dump the GraphHeaderStr and just
  83 //      make the ?GAHEAD.ext file all dataoffsets! (The simpler,
  84 //      the better!)
  85 //
  86 // May 19 91 - Almost got the Flood Fill mode working...Tom
  87 //      started drawing maps a little early & now I need to add
  88 //      a little kludge-fix to reformat his old maps...
  89 //
  90 // May 22 91 - Got AWESOME UNDO working ... fixed the nagging little
  91 //      paste/scrolling bug fixed (separated the PasteErase
  92 //      & PasteDraw routines) ... finished Block Fill ... fixed
  93 //      the floating paste/tile showthru bug ...
  94 //
  95 // May 27 91 - Basically finished up. Tom is BETAing now. I need
  96 //      to make SelectMap accept the arrows & make an array for
  97 //      the map names instead of the sorry way I'm doing it now.
  98 //
  99 // Jun 2  91 - Got level launching working!  Been working on
 100 //      TED5 and IGRAB docs and MUSE most of the time.
 101 //
 102 // Jun 18 91 - v0.13 because John C.'s system didn't have
 103 //      the SCmapmask set to 15 in CopyEGA!
 104 //
 105 // Jun 20 91 - v0.14: It's annoying to LAUNCH the game and come
 106 //      back at the top-left corner!
 107 //
 108 // Jun 26 91 - v0.17: Made LAUNCH with ICON CHANGE ctrl-alt-L
 109 //      because Tomshit was having problems...adding Unused Tile
 110 //      Scan...fixing a couple minor Tom-irritants...
 111 //
 112 // Jul 12 91 - v0.23: Made VGA & CGA work! Fixed a small
 113 //      bug with plane-on starting...added a GridMode for the
 114 //      FloatingPaste...XMS Map-Cache...now saves the Launchname
 115 //      in TEDINFO? so user program doesn't need to send anything
 116 //      back but /LAUNCHED...finally fixed nagging FloatingPaste
 117 //      multi-plane viewing bug...
 118 //
 119 // Jul 19 91 - v0.24: Changed TEDINFO structure and added GFXINFO
 120 //      to IGRAB. Got most all bugs out...lowercase input now...
 121 //
 122 // Jul 23 91 - v0.26: Only write out .H if it needs to...got the
 123 //      SnapPaste feature in that Tom wanted...
 124 //
 125 // Aug 08 91 - v0.28: I can't believe this shit! Mr. Tom decided
 126 //      to enter the value "0xF00D" into the map, which was my secret
 127 //      value for passing an ESC press back from "inputint". I made
 128 //      it a #define now!
 129 //
 130 // Aug 09 91 - v0.29: I FUCKING FRIED THE LIB_A.ASM & LIB.C FILES!
 131 //      THESE USED TO HOLD TED5'S TILE-DRAWING AND CGA/VGA ROUTINES!
 132 //      AAAARRRRGGGG!!!! Trying to recontruct the program. It'll
 133 //      take a bit (I was trying to fix a bug in EditMapNames).
 134 //
 135 // Aug 14 91 - v0.30: Just got finished fixing the FRIED SOURCE HELL!
 136 //
 137 // Aug 16 91 - v0.31: Heh heh, I added the ViewMap function!
 138 //
 139 // Aug 19 91 - v0.32: Added the MapImport function and it works! YES!
 140 //
 141 // Aug 22-23 - v0.35: Fixed a WHOLE BUNCH of little things and added
 142 //      some cool features like easier TILEINFO entering, default
 143 //      Import drive, F3 to toggle Paste Overlay, etc. Very nice now.
 144 //
 145 // Aug 24 91 - v0.38: Fixed a bug in passing multiple command-line
 146 //      parameters to LAUNCHed program. Let user enter new parms and
 147 //      a new launch name while in TED5.  Added the CarmackCompression
 148 //      and trashed the Huffman shit.
 149 //
 150 // Sep 07 91 - v0.40: Only ViewMap planes viewable instead of all; flag
 151 //      currently loaded map in SelectMap dialog; check NumIconRows for
 152 //      a bogus value for old TED5 compatibility; show map dimensions in
 153 //      ChangeMapEdges dialog; CTRL-ALT-arrows will go to map edges.
 154 //
 155 // Sep 12 91 - v0.41: Let user PERMANENTLY change the Launch icon. Also,
 156 //      the plane flags are always saved!
 157 //
 158 // Sep 27 91 - v0.43: Added REVIEW_MAP function. Fixed a hard-to-find bug
 159 //      in the BlockFill-with-pattern function.
 160 //
 161 // Sep 29 91 - v0.44: Fixed small annoying bug w/Flood-fill w/pattern.
 162 //
 163 // Oct 12 91 - v0.45: Added the PrintReport feature after Carmacizing
 164 //      all the maps.
 165 //
 166 // Nov 24 91 - v0.48: Saving the Import Path, added TILEINFOM copying
 167 //      from one area to another, getting rid of the "turning the plane
 168 //      viewing ON automatically sets it for writing."
 169 //
 170 // May 22 92 - v0.49: Added graphics-select switch to get rid of a dialog.
 171 //
 172 // Oct 20 95 - v0.50: Fixed EGA scrolling bug, added screensaver which comes
 173 //                    on automatically after 2 minutes.  Timelimit adjustable
 174 //                    through TIMELIMIT command line MED
 175 //
 176 ////////////////////////////////////////////////////
 177 #include "ted5.h"
 178 #pragma hdrstop
 179
 180 extern unsigned _stklen=0x2000;
 181
 182 ////////////////////////////////////////////////////
 183 //
 184 // Variables
 185 //
 186 ////////////////////////////////////////////////////
 187 extern char far TEDCHAR,far VGAPAL,tdata;
 188 extern unsigned doubled[256];
 189
 190 UndoStr UndoRegion;
 191 CopyStr TileCopy;
 192 MapFileHeaderStr _seg *MapFileHeader;
 193 char _seg *Tinfo[10],_seg *TMinfo[10],_seg *GraphHeader;
 194 long _seg *XMSlookup,_seg *EgaXMSlookup,_seg *CgaXMSlookup,_seg *VgaXMSlookup;
 195 int _seg *MapBkgnd,_seg *MapFrgnd,_seg *MapInfoPl,
 196     _seg *CutBkgnd,_seg *CutFrgnd,_seg *CutInfoPl;
 197 MapHeaderStr MapHeader;
 198
 199 TempStruct LaunchInfo;
 200 InfoStruct _seg *TEDInfo;
 201 GfxStruct _seg *GFXInfo;
 202 video lastvideo,videomode;
 203 screentype whichscreen=TILES;
 204 VMapStr VMapData;
 205
 206 char launchname[64],ext[4],format[2],projname[64],mapname[64],planes,
 207         infoname[64],mapheadname[64],MapNames[100][16],parmstring[64];
 208 char SM_name[64],SM_loadname[64],BkgndColor,GfxToUse;
 209
 210 unsigned temp,whichmap,numtplanes,tilenum,tilemnum,numtmplanes,left,
 211         DirtyFlag,tilelen,tilemlen,whicht,whichtm,whichi,
 212         tsize,infoy,infomaxw,mapwidth,mapheight,screenw,usingbat,
 213         screenh,planeton,planemon,planeion,maxiconrows,lasticon,firsticon,
 214         viewton,viewmon,viewion,XMSundoB,XMSundoF,XMSundoI,launched,
 215         XMSmaps,EgaXMS,CgaXMS,VgaXMS,xmshandle,GridMode,SnapMode,snapx,
 216         snapy,snapxsize,snapysize,writeH,NoAbout,F3_flag;
 217 int tilebase=0,tilembase=0,infobaron=1,xbase,ybase,scrnbot,scrnrgt,
 218         FillMode=0,PasteMode=0,SelectMode=0,SelX1=-1,SelY1=-1,PasteOK=0,SelX2=-1,
 219         SelY2=-1,pixelx,pixely,selectcols,px,py,lastmap=-1,TIybase,TIymbase,TIxbase,
 220         TIxmbase,BfillMode,Plotting,TsearchMode,NoXMSFlag;
 221 long CgaXMSsize,EgaXMSsize,VgaXMSsize;
 222 long tics, tictime=1092L*2L;
 223
 224
 225 //
 226 // harderr-called routine
 227 //
 228 int ignore(void)
 229 {
 230  hardresume(0);
 231  return 0;
 232 }
 233
 234 ////////////////////////////////////////////////////
 235 //
 236 // Start of The Beast From Hell
 237 //
 238 ////////////////////////////////////////////////////
 239 void main(void)
 240 {
 241  ParseCmdline();
 242  SetupKBD();
 243  MMStartup();
 244  setvideo(EGA1);
 245  lastvideo=EGA1;
 246  InitTed5();
 247  harderr(ignore);
 248  tics=biostime(0,0);
 249  DeskEventLoop(HandleEvent,Continuous);
 250 }
 251
 252 ////////////////////////////////////////////////////
 253 //
 254 // Parse the commandline
 255 //
 256 ////////////////////////////////////////////////////
 257 void ParseCmdline(void)
 258 {
 259  int i;
 260
 261  for (i=1;i<_argc;i++)
 262  {
 263   _argv[i]=strupr(_argv[i]);
 264
 265   if (_argv[i][0]=='-' || _argv[i][0]=='/')
 266         _argv[i]++;
 267
 268   if (!strcmp(_argv[i],"?"))
 269         {
 270          printf(TITLESTR" by John Romero (C) 1991 Id Software, Inc.\n\n");
 271          printf("Command Line parameters:\n");
 272          printf("/?              : gets this stuff\n");
 273          printf("/EXT=???        : set the project extension\n");
 274          printf("<filename>      : set the Launch filename\n");
 275          printf("/PARMS=<string> : set parms to Launch with\n");
 276          printf("/NOXMSMAPS      : don't cache maps in XMS\n");
 277     printf("/GFX=???        : set gfx to use - E,C,V\n");
 278          printf("/TIME=???       : half-minutes until screenblanker (default 2 minutes)\n");
 279     exit(0);
 280         }
 281   else
 282   if (!strncmp(_argv[i],"EXT=",4))
 283         strcpy(ext,&_argv[i][4]);
 284   else
 285   if (!strncmp(_argv[i],"GFX=",4))
 286         GfxToUse = _argv[i][4];
 287   else
 288   if (!strcmp(_argv[i],"LAUNCH"))
 289         launched=1;
 290   else
 291   if (!strcmp(_argv[i],"BAT"))
 292         usingbat=1;
 293   else
 294   if (!strncmp(_argv[i],"PARMS=",6))
 295         strcpy(parmstring,&_argv[i][6]);
 296   else
 297   if (!strncmp(_argv[i],"TIME=",5))
 298           tictime=(atol(&_argv[i][5]))*546L;
 299   else
 300   if (!strcmp(_argv[i],"NOXMSMAPS"))
 301         NoXMSFlag=1;
 302   else
 303   if (!strcmp(_argv[i],"NOABOUT"))
 304         NoAbout=1;
 305   else
 306         strcpy(launchname,_argv[i]);
 307  }
 308 }
 309
 310
 311 ////////////////////////////////////////////////////
 312 //
 313 // Event handler - called when button is pressed
 314 // outside menu bar
 315 //
 316 ////////////////////////////////////////////////////
 317 void HandleEvent(void)
 318 {
 319  int pixelx,pixely,mx,my,b0,b1;
 320  unsigned loc;
 321
 322  b0=MouseButton()&1;
 323  b1=(MouseButton()>>1)&1;
 324
 325  MouseCoords(&mx,&my);
 326  pixely=my;
 327  pixelx=mx;
 328
 329  //
 330  // PLOT OR PICK-UP TILE
 331  //
 332  if (my>=8 && my<infoy*8 && (b0 || b1))
 333    {
 334         mx=xbase+(mx>>(tsize+2));
 335     my=ybase+((my-8)>>(tsize+2));
 336
 337     loc=my*mapwidth+mx;
 338
 339     if (mx>=mapwidth || my>=mapheight)
 340       errsound();
 341     else
 342       {
 343        if (b1)
 344          {
 345           //
 346           // SELECT BOTTOM-RIGHT EDGE
 347           //
 348           if (SelectMode || BfillMode)
 349             {
 350              SelX2=mx;
 351              SelY2=my;
 352              if ((SelX1==-1 && SelY1==-1) ||
 353                  (SelX2<SelX1 || SelY2<SelY1))
 354                {
 355                 SelX1=mx;
 356                 SelY1=my;
 357                }
 358              DrawMap();
 359              sound(2000);
 360             }
 361           //
 362           // FLOOD FILL!
 363           //
 364           else
 365           if (FillMode)
 366             {
 367              while(MouseButton());
 368              DoFloodFill(mx,my,1);
 369             }
 370           //
 371           // PICK UP TILE(S)
 372           //
 373           else
 374             {
 375              if (planeton)
 376                whicht=*(MapBkgnd+loc);
 377              if (planemon)
 378                whichtm=*(MapFrgnd+loc)+tilenum;
 379                  if (planeion)
 380                whichi=*(MapInfoPl+loc)+tilenum;
 381              DrawInfoBar();
 382
 383              //
 384              // IF WE'RE IN TILESEARCH MODE, SHOW IT!
 385              //
 386              if (TsearchMode)
 387                DrawMap();
 388             }
 389           while(MouseButton()>>1);
 390           nosound();
 391          }
 392        if (b0)
 393          {
 394           //
 395           // SELECT TOP-LEFT EDGE
 396           //
 397           if (SelectMode || BfillMode)
 398             {
 399              SelX1=mx;
 400              SelY1=my;
 401              if ((SelX2==-1 && SelY2==-1) ||
 402                  (SelX1>SelX2 || SelY1>SelY2))
 403                {
 404                 SelX2=mx;
 405                 SelY2=my;
 406                }
 407
 408              DrawMap();
 409              sound(2000);
 410              while(MouseButton());
 411             }
 412           //
 413           // FLOOD FILL!
 414           //
 415           else
 416           if (FillMode)
 417             {
 418              while(MouseButton());
 419              DoFloodFill(mx,my,0);
 420             }
 421           //
 422           // PASTE A CHUNK O' TILES/MAP
 423           //
 424           else
 425           if (PasteMode)
 426             {
 427              if (TileCopy.MapOrTileSelect)      // TILE-SELECT AREA?
 428                {
 429                 int i,j;
 430
 431                 if (SnapMode)
 432                   {
 433                    mx=(mx/snapxsize)*snapxsize+snapx;
 434                    my=(my/snapysize)*snapysize+snapy;
 435                   }
 436
 437                 if (mx+TileCopy.w>mapwidth ||
 438                     my+TileCopy.h>mapheight)
 439                 sound(500);
 440                 else
 441                   {
 442                    CopyUndoRegion();
 443                    UndoRegion.x=mx;
 444                    UndoRegion.y=my;
 445                    UndoRegion.w=TileCopy.w;
 446                    UndoRegion.h=TileCopy.h;
 447
 448                    sound(500);
 449                    switch(TileCopy.MapOrTileSelect)
 450                    {
 451                     case 1: // TILES
 452                       for (j=0;j<TileCopy.h;j++)
 453                         for (i=0;i<TileCopy.w;i++)
 454                           {
 455                            int val=(j+TileCopy.y)*selectcols+TileCopy.x+i;
 456                            if (XMSlookup[val]!=-1)
 457                              MapBkgnd[(my+j)*mapwidth+mx+i]=val;
 458                           }
 459                       break;
 460                     case 2: // MASKED
 461                       for (j=0;j<TileCopy.h;j++)
 462                         for (i=0;i<TileCopy.w;i++)
 463                           {
 464                            int val=(j+TileCopy.y)*selectcols+TileCopy.x+i+tilenum+maxiconrows*selectcols;
 465                            if (XMSlookup[val]!=-1)
 466                              MapFrgnd[(my+j)*mapwidth+mx+i]=val-tilenum;
 467                           }
 468                    }
 469                    nosound();
 470                    DrawMap();
 471                    DirtyFlag=1;
 472                   }
 473                 while(MouseButton());
 474                 nosound();
 475                }
 476              else
 477                {
 478                 int i,j;
 479
 480                 if (SnapMode)
 481                   {
 482                    mx=(mx/snapxsize)*snapxsize+snapx;
 483                    my=(my/snapysize)*snapysize+snapy;
 484                   }
 485
 486                 if (mx+TileCopy.w-1<mapwidth && my+TileCopy.h-1<mapheight)
 487                   {
 488                    sound(500);
 489                    CopyUndoRegion();
 490                    UndoRegion.x=mx;
 491                    UndoRegion.y=my;
 492                    UndoRegion.w=TileCopy.w;
 493                    UndoRegion.h=TileCopy.h;
 494
 495                    for (j=0;j<TileCopy.h;j++)
 496                      for (i=0;i<TileCopy.w;i++)
 497                        {
 498                         int theM,theI;
 499
 500
 501                         if (TileCopy.PlanesCopied&BPLANE)
 502                           MapBkgnd[(j+my)*mapwidth+mx+i]=
 503                             CutBkgnd[(j+TileCopy.y)*mapwidth+TileCopy.x+i];
 504                         if (TileCopy.PlanesCopied&FPLANE)
 505                           {
 506                            theM=CutFrgnd[(j+TileCopy.y)*mapwidth+TileCopy.x+i];
 507                            if (theM || F3_flag)
 508                              MapFrgnd[(j+my)*mapwidth+mx+i]=theM;
 509                           }
 510                         if (TileCopy.PlanesCopied&IPLANE)
 511                           {
 512                            theI=CutInfoPl[(j+TileCopy.y)*mapwidth+TileCopy.x+i];
 513                            if (theI || F3_flag)
 514                                  MapInfoPl[(j+my)*mapwidth+mx+i]=theI;
 515                           }
 516                        }
 517                    nosound();
 518                    DrawMap();
 519                    DirtyFlag=1;
 520                   }
 521                 else
 522                   sound(500);
 523
 524                 while(MouseButton());
 525                }
 526             }
 527           //
 528           // PLOT TILE(S)
 529           //
 530           else
 531             {
 532              unsigned oldt,oldm,oldi;
 533
 534              //
 535              // ARE WE STARTING THE PLOTTING REGION?
 536              //
 537              if (!Plotting)
 538                {
 539                 CopyUndoRegion();
 540                 UndoRegion.x=mx;
 541                 UndoRegion.y=my;
 542                 UndoRegion.w=UndoRegion.h=1;
 543                 Plotting=1;
 544                }
 545
 546              //
 547              // FLOAT THE PLOTTING REGION
 548              //
 549              if (mx<UndoRegion.x)
 550                UndoRegion.x=mx;
 551              if (my<UndoRegion.y)
 552                UndoRegion.y=my;
 553              if (mx+1>UndoRegion.x+UndoRegion.w)
 554                UndoRegion.w=mx-UndoRegion.x+1;
 555              if (my+1>UndoRegion.y+UndoRegion.h)
 556                UndoRegion.h=my-UndoRegion.y+1;
 557
 558              if (planeton)
 559                    *(MapBkgnd+loc)=whicht;
 560              if (planemon)
 561                *(MapFrgnd+loc)=whichtm-tilenum;
 562              if (planeion)
 563                *(MapInfoPl+loc)=whichi-tilenum;
 564
 565              oldt=MapBkgnd[loc];
 566              oldm=MapFrgnd[loc]+tilenum;
 567              oldi=MapInfoPl[loc]+tilenum;
 568
 569              CombineTiles(viewton?oldt:-BkgndColor,viewmon*oldm,oldi*viewion,tsize);
 570              if (GridMode)
 571                Overlay(tsize);
 572              MouseHide();
 573              DrawTile((mx-xbase)<<(tsize-1),(my-ybase)*(4<<tsize)+8,tsize);
 574              CheckInfoValues(mx-xbase,my-ybase,oldi);
 575              MouseShow();
 576              DirtyFlag=1;
 577             }
 578          }
 579        nosound();
 580       }
 581    }
 582
 583  //
 584  // CLICK ON TILES
 585  //
 586  if (b0 && pixely>infoy*8)
 587    {
 588     if (pixelx<7*8)
 589       SelectTiles(1);
 590     else
 591     if (pixelx<8*14 && tilemnum)
 592       SelectTiles(2);
 593     else
 594     if (pixelx<8*20 && tilemnum)
 595       SelectTiles(3);
 596    }
 597
 598 }
 599
 600 #define PEL_WRITE_ADR   0x3c8
 601 #define PEL_READ_ADR    0x3c7
 602 #define PEL_DATA        0x3c9
 603 #define PEL_MASK        0x3c6
 604
 605 void ScreenBlank ( void )
 606 {
 607   int done;
 608   int x;
 609   int y;
 610   int r;
 611   int g;
 612   int b;
 613   int c;
 614   int oldx,oldy;
 615   int i, j;
 616   int xdir,ydir;
 617   int cury;
 618   int size;
 619   int type;
 620   struct {
 621           int x,y;
 622           } snake[256];
 623
 624   unsigned char far * screen=(unsigned char far *)0xa0000000l;
 625
 626
 627   randomize();
 628   _AX=0x13;
 629   asm int 10h
 630   done=0;
 631   size=random(10)+2;
 632   clearkeys();
 633
 634   for (i=255;i>=0;i--)
 635           {
 636           snake[i].x=160;
 637           snake[i].y=100;
 638           }
 639   type=random(11);
 640   r=random(200)+56;
 641   g=random(200)+56;
 642   b=random(200)+56;
 643   outp (PEL_WRITE_ADR,0);
 644   for (i=0;i<=255;i++)
 645                 {
 646                 outp (PEL_DATA, (unsigned char)((i*r)>>10));
 647                 outp (PEL_DATA, (unsigned char)((i*g)>>10));
 648                 outp (PEL_DATA, (unsigned char)((i*b)>>10));
 649                 }
 650   xdir=0;
 651   while (!xdir)
 652           xdir=random(size<<1)-size;
 653   ydir=0;
 654   while (!ydir)
 655           ydir=random(size<<1)-size;
 656   while (!done)
 657           {
 658           if ((random(100)-80)>0)
 659                   {
 660                   xdir+=random(3)-1;
 661                   ydir+=random(3)-1;
 662                   }
 663           for (i=255;i>0;i--)
 664                   snake[i]=snake[i-1];
 665           snake[0].x+=xdir;
 666           snake[0].y+=ydir;
 667           if ((snake[0].x<size+1) || (snake[0].x>320-(size+1)))
 668                   {
 669                   xdir=-xdir;
 670                   snake[0].x+=xdir<<1;
 671                   }
 672           else if (abs(xdir)>size-1)
 673                   xdir=-(xdir>>1);
 674           if ((snake[0].y<size+1) || (snake[0].y>200-(size+1)))
 675                   {
 676                   ydir=-ydir;
 677                   snake[0].y+=ydir<<1;
 678                   }
 679           else if (abs(ydir)>size-1)
 680                   ydir=-(ydir>>1);
 681           for (x=255;x>=0;x--)
 682                   {
 683                   if (type<7)
 684                           {
 685                           for (j=snake[x].y,cury=320*snake[x].y;j<snake[x].y+size;j++,cury+=320)
 686                                   _fmemset((screen+cury+snake[x].x),255-x,size);
 687                           }
 688                   else
 689                           {
 690                           _fmemset((screen+(320*snake[x].y)+snake[x].x),255-x,size);
 691                           }
 692                   }
 693           oldx=pixelx;
 694           oldy=pixely;
 695           MouseCoords(&pixelx,&pixely);
 696           if ((oldx!=pixelx) || (oldy!=pixely))
 697                   done=1;
 698           for (x=0;x<127;x++)
 699                   if (keydown[x])
 700                           done=1;
 701           }
 702 }
 703
 704 ////////////////////////////////////////////////////
 705 //
 706 // Routine called continuously by DeskEventLoop
 707 //
 708 ////////////////////////////////////////////////////
 709 void Continuous(void)
 710 {
 711  static int oldx, oldy;
 712  if (biostime(0,0)-tics>tictime)
 713          {
 714          MouseHide();
 715          ScreenBlank();
 716          clearkeys();
 717          videomode=lastvideo;
 718          Item_ModeSwitch();
 719          RedrawDesktop();
 720          DrawMap();
 721          DrawInfoBar();
 722          MouseShow();
 723          tics=biostime(0,0);
 724          }
 725  oldx=pixelx;
 726  oldy=pixely;
 727  MouseCoords(&pixelx,&pixely);
 728  if ((oldx!=pixelx) || (oldy!=pixely))
 729          {
 730          tics=biostime(0,0);
 731          PrintCoords();
 732          }
 733
 734  if (!MouseButton())
 735    Plotting=0;
 736
 737  //
 738  // PLANE "WRITE" SELECTION
 739  //
 740  if (keydown[2] && viewton)
 741    {
 742     planeton^=1;
 743     DrawInfoBar();
 744     DrawMap();
 745     PrintCoords();
 746     tics=biostime(0,0);
 747     while(keydown[2]);
 748    }
 749  if (keydown[3] && tilemnum && (MapFileHeader->maptype&FPLANE) && viewmon)
 750    {
 751     planemon^=1;
 752     DrawInfoBar();
 753     DrawMap();
 754     PrintCoords();
 755     tics=biostime(0,0);
 756     while(keydown[3]);
 757    }
 758  if (keydown[4] && (MapFileHeader->maptype&IPLANE) && viewion)
 759    {
 760     planeion^=1;
 761     DrawInfoBar();
 762     DrawMap();
 763     PrintCoords();
 764     tics=biostime(0,0);
 765     while(keydown[4]);
 766    }
 767
 768  //
 769  // PLANE "VIEW" SELECTION
 770  //
 771  if (keydown[5])
 772    {
 773     viewton^=1;
 774     if (!viewton)
 775           planeton=0;
 776     DrawInfoBar();
 777     DrawMap();
 778     PrintCoords();
 779     tics=biostime(0,0);
 780     while(keydown[5]);
 781    }
 782  if (keydown[6] && tilemnum && (MapFileHeader->maptype&FPLANE))
 783    {
 784     viewmon^=1;
 785     if (!viewmon)
 786       planemon=0;
 787     DrawInfoBar();
 788     DrawMap();
 789     PrintCoords();
 790     tics=biostime(0,0);
 791     while(keydown[6]);
 792    }
 793  if (keydown[7] && (MapFileHeader->maptype&IPLANE))
 794    {
 795     viewion^=1;
 796     if (!viewion)
 797       planeion=0;
 798     DrawInfoBar();
 799     DrawMap();
 800     PrintCoords();
 801     tics=biostime(0,0);
 802     while(keydown[7]);
 803    }
 804
 805  //
 806  // Cancel COPY or PASTE or FLOOD FILL or BLOCK FILL
 807  //
 808  if (keydown[1] && (PasteMode || SelectMode || FillMode ||
 809          BfillMode || TsearchMode))
 810    {
 811     while(keydown[1]);
 812
 813     if (PasteMode)
 814       {
 815        EraseFloatPaste();
 816        px=py=-1;
 817       }
 818
 819     SnapMode=TsearchMode=BfillMode=FillMode=PasteMode=SelectMode=0;
 820     SelX1=SelX2=SelY1=SelY2=-1;
 821     DrawMap();
 822     DrawInfoBar();
 823     tics=biostime(0,0);
 824    }
 825
 826  //
 827  // END OF COPY || BLOCK FILL
 828  //
 829  if (keydown[0x1c] && (SelectMode || BfillMode))
 830    {
 831     int temp,j,i;
 832
 833     tics=biostime(0,0);
 834     while(keydown[0x1c]);
 835
 836     if (SelX2<SelX1)
 837       {
 838        temp=SelX1;
 839        SelX1=SelX2;
 840        SelX2=temp;
 841       }
 842     if (SelY2<SelY1)
 843       {
 844        temp=SelY1;
 845        SelY1=SelY2;
 846        SelY2=temp;
 847       }
 848
 849     //
 850     // BLOCK FILL?
 851     //
 852     if (BfillMode)
 853       {
 854        BfillMode=0;
 855        DrawInfoBar();
 856        DoBlockFill();
 857        SelX1=SelX2=SelY1=SelY2=-1;
 858       }
 859     else
 860     //
 861     // COPY MODE?
 862     //
 863     if (SelectMode)
 864       {
 865        SelectMode=0;
 866
 867        TileCopy.x=SelX1;
 868        TileCopy.y=SelY1;
 869        TileCopy.w=SelX2-SelX1+1;
 870            TileCopy.h=SelY2-SelY1+1;
 871        TileCopy.MapOrTileSelect=0;
 872        TileCopy.PlanesCopied=planeton*BPLANE | planemon*FPLANE | planeion*IPLANE;
 873
 874        //
 875        // DO THE COPY!
 876        //
 877        sound(600);
 878        for (j=SelY1;j<=SelY2;j++)
 879          for (i=SelX1;i<=SelX2;i++)
 880            {
 881             if (planeton)
 882               CutBkgnd[j*mapwidth+i]=MapBkgnd[j*mapwidth+i];
 883             if (planemon)
 884               CutFrgnd[j*mapwidth+i]=MapFrgnd[j*mapwidth+i];
 885             if (planeion)
 886               CutInfoPl[j*mapwidth+i]=MapInfoPl[j*mapwidth+i];
 887            }
 888
 889        DrawInfoBar();
 890        SelX1=SelX2=SelY1=SelY2=-1;
 891        PasteOK=1;
 892        px=py=-1;
 893        nosound();
 894        DrawMap();
 895       }
 896     clearkeys();
 897    }
 898
 899  //
 900  // See if we want to scroll the map!
 901  //
 902  CheckMapScroll();
 903  CheckFloatPaste((pixelx>>(tsize+2))+xbase,((pixely-8)>>(tsize+2))+ybase);
 904 }
 905
 906 ////////////////////////////////////////////////////
 907 //
 908 // Draw the current map on the screen at xbase,ybase
 909 //
 910 ////////////////////////////////////////////////////
 911 void DrawMap(void)
 912 {
 913  int i,j,imax,jmax;
 914
 915
 916  EraseFloatPaste();
 917  jmax=screenh;
 918  if (jmax>mapheight)
 919    jmax=mapheight;
 920
 921  imax=screenw;
 922  if (imax>mapwidth)
 923    imax=mapwidth;
 924
 925  MouseHide();
 926  for(j=0;j<jmax;j++)
 927    for(i=0;i<imax;i++)
 928      {
 929       unsigned tilet,tilem,tilei,loc;
 930
 931       loc=(ybase+j)*mapwidth+xbase+i;
 932
 933       tilet=*(MapBkgnd+loc);
 934       tilem=*(MapFrgnd+loc)+tilenum;
 935       tilei=*(MapInfoPl+loc)+tilenum;
 936
 937       CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
 938       if (GridMode)
 939         Overlay(tsize);
 940       DrawTile(i<<(tsize-1),j*(4<<tsize)+8,tsize);
 941       CheckInfoValues(i,j,tilei);
 942       CheckSelectEdges(i+xbase,j+ybase,i,j);
 943      }
 944  MouseShow();
 945  DrawFloatPaste();
 946 }
 947
 948
 949 ////////////////////////////////////////////////////
 950 //
 951 // Figure out SCREENW,SCREENH from videomode & tsize
 952 //
 953 ////////////////////////////////////////////////////
 954 void FigureScreenEdges(void)
 955 {
 956  switch(videomode)
 957  {
 958   case CGA:
 959   case EGA1:
 960   case VGA:
 961     screenw=40>>(tsize-1);
 962     screenh=22>>(tsize-1);
 963     break;
 964   case EGA2:
 965     screenw=80>>(tsize-1);
 966     screenh=57>>(tsize-1);
 967     break;
 968  }
 969  if (!infobaron)
 970    {
 971     infoy=100;  // WAY OFF THE BOTTOM!
 972     screenh+=2*(tsize==1)+(tsize==2);
 973    }
 974 }
 975
 976
 977 ////////////////////////////////////////////////////
 978 //
 979 // Print the coords on the INFOBAR
 980 //
 981 ////////////////////////////////////////////////////
 982 void PrintCoords(void)
 983 {
 984  static zeroed=0;
 985  int mx,my;
 986
 987  if (!infobaron)
 988    return;
 989
 990  xormask=0;
 991  MouseCoords(&mx,&my);
 992  if (my<8 || my>=infoy*8)
 993    {
 994     if (zeroed)
 995       return;
 996     sx=infomaxw-9;
 997     sy=infoy;
 998     print("??? ?????");
 999     sx=infomaxw-9;
1000     sy=infoy+1;
1001     print("??? ?????");
1002     zeroed=1;
1003     return;
1004    }
1005
1006  zeroed=0;
1007  mx=mx>>(tsize+2);
1008  sx=infomaxw-9;
1009  sy=infoy;
1010  printint(mx+xbase);
1011  print("  ");
1012  sx=infomaxw-5;
1013  printhex(mx+xbase);
1014
1015  my=(my-8)>>(tsize+2);
1016  sx=infomaxw-9;
1017  sy=infoy+1;
1018  printint(my+ybase);
1019  print("  ");
1020  sx=infomaxw-5;
1021  printhex(my+ybase);
1022 }
1023
1024
1025 ////////////////////////////////////////////////////
1026 //
1027 // Draw the INFOBAR
1028 //
1029 ////////////////////////////////////////////////////
1030 void DrawInfoBar(void)
1031 {
1032  int ox,oy;
1033
1034
1035  if (PasteMode)
1036    {
1037     px=py=-1;
1038     CheckFloatPaste((pixelx>>(tsize+2))+xbase,((pixely-8)>>(tsize+2))+ybase);
1039    }
1040
1041  if (!infobaron)
1042    return;
1043
1044  EraseFloatPaste();
1045
1046  ox=sx=0;
1047  switch(videomode)
1048  {
1049   case CGA:
1050   case EGA1:
1051   case VGA:
1052     oy=sy=23-2*(tsize==3);
1053     infomaxw=40;
1054     break;
1055   case EGA2:
1056     oy=sy=58-2*(tsize==3)-1*(tsize==2);
1057     infomaxw=80;
1058  }
1059
1060  MouseHide();
1061  infoy=oy;
1062  bar(0,infoy,infomaxw-1,infoy+1,' ');
1063
1064  if (SelectMode)
1065    {
1066     sx=leftedge=1;
1067     sy=infoy;
1068     print("Copy Mode\nESC to exit");
1069    }
1070  else
1071  if (TsearchMode)
1072    {
1073     sx=leftedge=1;
1074     sy=infoy;
1075     print("Tile Search Mode\nESC to exit");
1076    }
1077  else
1078  if (BfillMode)
1079    {
1080     sx=leftedge=1;
1081     sy=infoy;
1082     print("Block Fill Mode\nESC to exit");
1083    }
1084  else
1085  if (PasteMode)
1086    {
1087     sx=leftedge=1;
1088     sy=infoy;
1089     print("Paste Mode\nESC to exit");
1090    }
1091  else
1092  if (FillMode)
1093    {
1094     sx=leftedge=1;
1095         sy=infoy;
1096     print("Flood Fill Mode\nESC to exit");
1097    }
1098  else
1099    {
1100     CombineTiles(whicht,0,0,tsize);
1101     DrawTile(ox,oy*8+8*(tsize==1),tsize);
1102     sx=ox+2+2*(tsize==3);
1103     sy=oy;
1104     printhex(whicht);
1105     sx-=5;
1106     sy++;
1107     printint(whicht);
1108     print("    ");
1109
1110     if (tilemnum)
1111       {
1112        ox+=7;
1113        CombineTiles(-BkgndColor,whichtm,0,tsize);
1114        DrawTile(ox,oy*8+8*(tsize==1),tsize);
1115        sx=ox+2+2*(tsize==3);
1116        sy=oy;
1117        (whichtm==tilenum)?print(" No  "):printhex(whichtm-tilenum);
1118        sx-=5;
1119        sy++;
1120        (whichtm==tilenum)?print("Tile"):printint(whichtm-tilenum);
1121        print("    ");
1122
1123        ox+=7;
1124        CombineTiles(-ICONBACK,(whichi>lasticon)?firsticon:whichi,0,tsize);
1125        DrawTile(ox,oy*8+8*(tsize==1),tsize);
1126        sx=ox+2+2*(tsize==3);
1127        sy=oy;
1128        (whichi==tilenum)?print(" No  "):printhex(whichi-tilenum);
1129        sx-=5;
1130        sy++;
1131        (whichi==tilenum)?print("Icon"):printint(whichi-tilenum);
1132        print("    ");
1133       }
1134    }
1135
1136
1137  sx=infomaxw-11;
1138  sy=infoy;
1139  print("X=");
1140  sy++;
1141  sx-=2;
1142  print("Y=");
1143
1144  sx=infomaxw-((videomode==EGA2)?19:18);
1145  sy=infoy+1;
1146  print("123");
1147  if (SnapMode)
1148    {
1149     sx=infomaxw-((videomode==EGA2)?21:20);
1150     sy=infoy+1;
1151     print("S");
1152    }
1153  if (GridMode)
1154    {
1155     sx=infomaxw-((videomode==EGA2)?20:19);
1156     sy=infoy+1;
1157     print("G");
1158    }
1159  sx=infomaxw-((videomode==EGA2)?19:18);
1160  sy=infoy;
1161  (planeton)?print("B"):print(" ");
1162  (planemon)?print("F"):print(" ");
1163  (planeion)?print("I"):print(" ");
1164
1165  sx=infomaxw-15;
1166  sy=infoy+1;
1167  print("456");
1168  sx=infomaxw-15;
1169  sy=infoy;
1170  (viewton)?print("b"):print(" ");
1171  (viewmon)?print("f"):print(" ");
1172  (viewion)?print("i"):print(" ");
1173
1174  if (videomode==EGA2)
1175    {
1176     sx=screencenterx-strlen(MapHeader.name)/2;
1177     sy=infoy;
1178     print(MapHeader.name);
1179    }
1180
1181  DrawFloatPaste();
1182  MouseShow();
1183 }
1184
1185
1186 ////////////////////////////////////////////////////
1187 ////////////////////////////////////////////////////
1188 ////////////////////////////////////////////////////
1189 //
1190 // Initialize TED5:
1191 //
1192 // * Project Select if multiple projects
1193 // * If Project has NO LEVELS:
1194 //   * Init Level 1
1195 //   * Init TILEINFO
1196 //   * Init TEDINFO file
1197 // * Load TILES into XMS
1198 //
1199 ////////////////////////////////////////////////////
1200 ////////////////////////////////////////////////////
1201 ////////////////////////////////////////////////////
1202 char bstrings[10][15];
1203 btype ProjButns[10];
1204 DialogDef ProjSelect={"Select the project to work on:",
1205                       30,0,0,&ProjButns[0],DrawProjBord};
1206
1207 void InitTed5(void)
1208 {
1209  char pname[15];
1210  unsigned i,loop,which;
1211
1212  MouseInit();
1213  MouseShow();
1214  if (!MouseStatus)
1215    {
1216         ErrDialog("Sorry, but TED5 will NOT\n"
1217                   "operate without a mouse!\n"," Press ENTER ");
1218         Quit("Only REAL developers have a mouse!");
1219    }
1220  MouseOrigin(0,0);
1221
1222  ErrDialog("Initializing. One moment.","");
1223  //
1224  // Create bit-doubling lookup table
1225  // for CGA font creation
1226  //
1227  for (loop=0;loop<256;loop++)
1228    {
1229         unsigned result,temp=loop;
1230
1231         asm         mov     ax,temp
1232         asm         mov     ah,al
1233         asm         mov     cx,8
1234         LOOP0:
1235         asm         shl     al,1
1236         asm         rcl     bx,1
1237         asm         shl     ah,1
1238         asm         rcl     bx,1
1239         asm         loop    LOOP0
1240
1241         asm         xchg    bh,bl
1242         asm         mov     result,bx
1243
1244         doubled[loop]=result;
1245    }
1246
1247  //
1248  // Init everything!
1249  //
1250  InitXMS();
1251  FindGraphFile();
1252  LoadInfoFile();
1253  LoadMapHeader();
1254
1255  RestoreBackground();
1256
1257  LoadGraphStuff(0,TEDInfo->lastvid);
1258  DrawInfoBar();
1259  DrawMap();
1260  if (!launched && !NoAbout)
1261    Item_About();
1262  launched=0;
1263 }
1264
1265
1266 ////////////////////////////////////////////////////
1267 ////////////////////////////////////////////////////
1268 //
1269 // Load the MAPTEMP.ext header in...
1270 //
1271 ////////////////////////////////////////////////////
1272 ////////////////////////////////////////////////////
1273 btype SelectTsizeb[]={{"  8x8  ",1,2,1},
1274                       {" 16x16 ",1,5,1},
1275                           {" 32x32 ",1,8,1}};
1276 DialogDef SelectTsize={" Which tile size to use?"
1277                        ,26,10,3,&SelectTsizeb[0],STnot};
1278
1279 void LoadMapHeader(void)
1280 {
1281  unsigned size,i,j,pflag;
1282  char types=0;
1283
1284
1285  strcpy(mapheadname,"MAPTHEAD.");
1286  strcat(mapheadname,ext);
1287  strcpy(mapname,"MAPTEMP.");
1288  strcat(mapname,ext);
1289  strcpy(SM_name,"MAPTEMP1.");
1290  strcat(SM_name,ext);
1291  strcpy(SM_loadname,"MAPTEMP.");
1292  strcat(SM_loadname,ext);
1293
1294  if (access(mapheadname,0))
1295    {
1296     int i;
1297     //
1298     // Gotta create a new map file!
1299     //
1300     MMAllocate((memptr *)&MapFileHeader,sizeof(MapFileHeaderStr));
1301     for (i=0;i<sizeof(MapFileHeaderStr);i++)
1302       *((char _seg *)MapFileHeader+i)=0;
1303
1304     MapFileHeader->RLEWtag=0xabcd;
1305     for (i=0;i<100;i++)
1306       {
1307        MapFileHeader->dataoffsets[i]=-1;
1308        MapFileHeader->datalengths[i]=0;
1309        memset(MapNames[i],0,16);
1310       }
1311
1312     if (!GFXInfo->num8 &&
1313         !GFXInfo->num8m &&
1314         !GFXInfo->num16 &&
1315         !GFXInfo->num16m &&
1316         !GFXInfo->num32 &&
1317         !GFXInfo->num32m)
1318       {
1319        ErrDialog("Uhh...you 'neglected' to\n"
1320                  "grab tiles to use. Running\n"
1321                  "TED5 is quite useless at\n"
1322                  "this point, I'm afraid.","Duh!");
1323        Quit("Get some tiles ... quick! Me hungry!");
1324       }
1325
1326     if (!GFXInfo->num8 &&
1327         !GFXInfo->num16 &&
1328         !GFXInfo->num32)
1329       {
1330        ErrDialog("You may have grabbed some\n"
1331                  "MASKED tiles, but I require\n"
1332                  "NON-MASKED tiles as a\n"
1333                  "minimum requirement!","Geez...");
1334        Quit("Please grab some normal tiles!");
1335       }
1336
1337     types+=(GFXInfo->num8>0)+(GFXInfo->num16>0)+(GFXInfo->num32>0);
1338
1339     redo:
1340
1341     if (types>1)
1342       {
1343        int which;
1344
1345        which=DoDialog(&SelectTsize);
1346        switch(which)
1347        {
1348         case 0:
1349           Quit("");
1350         case 1:
1351           if (!GFXInfo->num8)
1352             which=0;
1353           break;
1354         case 2:
1355           if (!GFXInfo->num16)
1356             which=0;
1357           break;
1358         case 3:
1359           if (!GFXInfo->num32)
1360             which=0;
1361           break;
1362        }
1363
1364        MapFileHeader->tsize=TEDInfo->tsize=tsize=which;
1365           }
1366     else
1367       {
1368        if (GFXInfo->num8)
1369          TEDInfo->tsize=1;
1370        else
1371        if (GFXInfo->num16)
1372          TEDInfo->tsize=2;
1373        else
1374        if (GFXInfo->num32)
1375          TEDInfo->tsize=3;
1376
1377        MapFileHeader->tsize=tsize=TEDInfo->tsize;
1378       }
1379
1380     //
1381     // pick the planes that all maps will use
1382     //
1383     if (PickMorePlanes())
1384       goto redo;
1385
1386     //
1387     // initialize TILEINFO/TILEINFOM
1388     //
1389     switch(tsize)
1390     {
1391      case 1:
1392        tilenum=GFXInfo->num8;
1393        tilemnum=GFXInfo->num8m;
1394        break;
1395      case 2:
1396        tilenum=GFXInfo->num16;
1397        tilemnum=GFXInfo->num16m;
1398        break;
1399      case 3:
1400        tilenum=GFXInfo->num32;
1401        tilemnum=GFXInfo->num32m;
1402     }
1403     InitTileinfo();
1404     if (numtplanes || numtmplanes)      // only input if applicable
1405       Item_EditTinfoNames();            // void where prohibited
1406     //
1407     // now create a map!
1408     //
1409     CreateMap(0);
1410         FigureScreenEdges();
1411     MapFileHeader->NumIconRows=maxiconrows=InputIconAmount();
1412    }
1413  //
1414  // MAP FILE ALREADY IN PLACE. LOAD STUFF IN...
1415  //
1416  else
1417    {
1418     memptr block,tempblock;
1419
1420     LoadIn(mapheadname,(memptr *)&MapFileHeader);
1421
1422     //
1423     // See if the NumIconRows is toasty (old TED5 compatibility)
1424     //
1425     if (MapFileHeader->NumIconRows>50)
1426       MapFileHeader->NumIconRows=4;
1427
1428     //
1429     // has the TEDINFO?.ext file been changed?
1430     // if so, reconstruct pertinent data...
1431     //
1432     if (!TEDInfo->tsize)
1433       {
1434        tsize=TEDInfo->tsize=MapFileHeader->tsize;
1435        switch(tsize)
1436        {
1437         case 1:
1438           tilenum=GFXInfo->num8;
1439           tilemnum=GFXInfo->num8m;
1440           break;
1441         case 2:
1442           tilenum=GFXInfo->num16;
1443           tilemnum=GFXInfo->num16m;
1444           break;
1445         case 3:
1446           tilenum=GFXInfo->num32;
1447           tilemnum=GFXInfo->num32m;
1448        }
1449       }
1450
1451     maxiconrows=MapFileHeader->NumIconRows;
1452
1453     //
1454     // Read-in all the Map Names
1455         //
1456     for (i=0;i<100;i++)
1457       if (MapFileHeader->dataoffsets[i]!=-1)
1458         {
1459          MapHeaderStr TempHead;
1460
1461          LoadFile(mapname,(char huge *)&TempHead,
1462            MapFileHeader->dataoffsets[i],sizeof(MapHeaderStr));
1463          strcpy(MapNames[i],TempHead.name);
1464         }
1465
1466     FigureScreenEdges();
1467
1468     if (!TEDInfo->level)
1469       {
1470        for(i=0;i<100;i++)
1471          if (MapFileHeader->dataoffsets[i]!=-1)
1472            {
1473             whichmap=TEDInfo->level=i;
1474             break;
1475            }
1476       }
1477     else
1478       whichmap=TEDInfo->level;
1479
1480     LoadMap(TEDInfo->level);
1481
1482     //
1483     // IF WE WERE LAUNCHED AND CHARACTER POSITION WAS CHANGED,
1484     // PUT IT BACK!
1485     //
1486     if (launched && (TEDInfo->lastx || TEDInfo->lasty))
1487       {
1488        int i;
1489
1490        for (i=0;i<mapwidth*mapheight;i++)
1491          if (MapInfoPl[i]==TEDInfo->permicon)
1492            {
1493             MapInfoPl[i]=0;
1494             MapInfoPl[TEDInfo->lasty*mapwidth+TEDInfo->lastx]=TEDInfo->permicon;
1495             TEDInfo->lastx=TEDInfo->lasty=0;
1496             DirtyFlag=1;
1497             break;
1498            }
1499       }
1500
1501     //
1502     // POSITION SCREEN
1503     //
1504     xbase=TEDInfo->oscrx;
1505     ybase=TEDInfo->oscry;
1506     if (xbase+screenw>mapwidth)
1507       xbase=mapwidth-screenw;
1508     if (ybase+screenh>mapheight)
1509       ybase=mapheight-screenh;
1510
1511     if (launched)
1512       _fmemcpy((void far *)parmstring,(void far *)TEDInfo->parmstring,64);
1513
1514     //
1515     // LOAD TILEINFO/M AND ADJUST IF IT CHANGED
1516     //
1517     numtplanes=MapFileHeader->numtplanes;
1518     numtmplanes=MapFileHeader->numtmplanes;
1519
1520     pflag=0;
1521     for (i=0;i<numtplanes;i++)
1522       {
1523        //
1524        // SPACE FOR OLD TILEINFO TO DECOMPRESS INTO
1525        //
1526        MMAllocate(&tempblock,MapFileHeader->oldtilenum);
1527        //
1528        // SPACE FOR OLD TILEINFO TO LOAD INTO
1529        //
1530        MMAllocate(&block,MapFileHeader->tileinfolen[i]);
1531        LoadFile(mapheadname,MK_FP(block,0),MapFileHeader->tileinfooff[i],MapFileHeader->tileinfolen[i]);
1532        //
1533        // DECOMPRESS FROM "BLOCK" TO "TEMPBLOCK"
1534        //
1535        RLEBExpand(MK_FP(block,0),MK_FP(tempblock,0),
1536            MapFileHeader->oldtilenum,MapFileHeader->RLEWtag);
1537        MMFreePtr(&block);
1538        //
1539        // ALLOCATE TINFO ARRAY
1540        //
1541        MMAllocate((memptr *)&Tinfo[i],tilenum);
1542        //
1543        // MOVE FROM "TEMPBLOCK" TO "TINFO[I]" ARRAY
1544        //
1545            if (MapFileHeader->oldtilenum<tilenum)
1546          {
1547           movedata((unsigned)tempblock,0,(unsigned)Tinfo[i],0,MapFileHeader->oldtilenum);
1548           //
1549           // IF NEW TILEINFO IS MORE, FILL END WITH 0s
1550           //
1551           for (j=MapFileHeader->oldtilenum;j<tilenum;j++)
1552             *(Tinfo[i]+j)=0;
1553           DirtyFlag=pflag=1;
1554          }
1555        else
1556          {
1557           movedata((unsigned)tempblock,0,(unsigned)Tinfo[i],0,tilenum);
1558           if (MapFileHeader->oldtilenum>tilenum)
1559             DirtyFlag=pflag=2;
1560          }
1561
1562        MMFreePtr(&tempblock);
1563       }
1564
1565     switch(pflag)
1566     {
1567      case 1:
1568        ErrDialog("The new TILEINFO data has\n"
1569                  "been expanded to accomodate\n"
1570                  "the newly grabbed tiles."," OK ");
1571        break;
1572      case 2:
1573        ErrDialog("The new TILEINFO data has\n"
1574                  "been shrunk due to a reduced\n"
1575                  "amount of tiles."," OK ");
1576     }
1577
1578     pflag=0;
1579     if (tilemnum && (MapFileHeader->maptype&FPLANE))
1580       for (i=0;i<numtmplanes;i++)
1581         {
1582          MMAllocate(&tempblock,MapFileHeader->oldtilemnum);
1583          MMAllocate(&block,MapFileHeader->tileinfomlen[i]);
1584          LoadFile(mapheadname,MK_FP(block,0),MapFileHeader->tileinfomoff[i],MapFileHeader->tileinfomlen[i]);
1585          RLEBExpand(MK_FP(block,0),MK_FP(tempblock,0),
1586              MapFileHeader->oldtilemnum,MapFileHeader->RLEWtag);
1587          MMFreePtr(&block);
1588          MMAllocate((memptr *)&TMinfo[i],tilemnum);
1589          if (MapFileHeader->oldtilemnum<tilemnum)
1590            {
1591             movedata((unsigned)tempblock,0,(unsigned)TMinfo[i],0,MapFileHeader->oldtilemnum);
1592             for (j=MapFileHeader->oldtilemnum;j<tilemnum;j++)
1593               *(TMinfo[i]+j)=0;
1594             DirtyFlag=pflag=1;
1595            }
1596          else
1597            {
1598             movedata((unsigned)tempblock,0,(unsigned)TMinfo[i],0,tilemnum);
1599             if (MapFileHeader->oldtilemnum>tilemnum)
1600               DirtyFlag=pflag=2;
1601            }
1602
1603          MMFreePtr(&tempblock);
1604         }
1605
1606     switch(pflag)
1607     {
1608      case 1:
1609        ErrDialog("The new TILEINFOM data has\n"
1610                  "been expanded to accomodate\n"
1611                  "the newly grabbed masked tiles."," OK ");
1612        break;
1613      case 2:
1614        ErrDialog("The new TILEINFOM data has\n"
1615                  "been shrunk due to a reduced\n"
1616                  "amount of tiles."," OK ");
1617     }
1618
1619     #if 0
1620     //
1621     // TURN ON PLANES
1622     //
1623     viewton=planeton=1;
1624     if (MapFileHeader->maptype&FPLANE)
1625       viewmon=1;
1626     if (MapFileHeader->maptype&IPLANE)
1627       viewion=1;
1628     planemon=planeion=0;
1629     #endif
1630
1631    }
1632
1633  //
1634  // LOAD THE MAPFILE INTO XMS IF ENOUGH ROOM
1635  //
1636  if (1024L*XMSTotalFree()>2L*filelen(mapname) && !NoXMSFlag)
1637    {
1638     #define LBCSIZE     0x4000
1639     memptr block;
1640     long size,clen,coff;
1641
1642
1643     size=filelen(mapname);
1644     MMAllocate(&block,LBCSIZE);
1645     XMSmaps=XMSAllocate(size);
1646
1647     //
1648     // LOAD ENTIRE MAPFILE FROM DISK TO XMS!
1649     //
1650     coff=0;
1651     do
1652     {
1653      clen=LBCSIZE;
1654      if (size<LBCSIZE)
1655        clen=size;
1656
1657      LoadFile(mapname,MK_FP(block,0),coff,clen);
1658      XMSmove(0,(long)MK_FP(block,0),XMSmaps,coff,clen);
1659      size-=LBCSIZE;
1660      coff+=clen;
1661     } while(size>0);
1662
1663     MMFreePtr(&block);
1664    }
1665
1666 }
1667
1668 void STnot(int x,int y)
1669 {
1670  sx=x+10;
1671  sy=y+2;
1672  if (!GFXInfo->num8)
1673    print("<-Not available");
1674  else
1675    {
1676     printint(GFXInfo->num8);
1677     print(" total tiles");
1678    }
1679  sx=x+10;
1680  sy=y+5;
1681  if (!GFXInfo->num16)
1682    print("<-Not available");
1683  else
1684    {
1685     printint(GFXInfo->num16);
1686     print(" total tiles");
1687    }
1688  sx=x+10;
1689  sy=y+8;
1690  if (!GFXInfo->num32)
1691    print("<-Not available");
1692  else
1693    {
1694     printint(GFXInfo->num32);
1695     print(" total tiles");
1696    }
1697 }
1698
1699
1700 ////////////////////////////////////////////////////
1701 ////////////////////////////////////////////////////
1702 //
1703 // Load the graphheader file & ?GAGRAPH.ext file and stick it in XMS!
1704 //
1705 ////////////////////////////////////////////////////
1706 ////////////////////////////////////////////////////
1707 int LoadGraphStuff(int rtn,video newvid)
1708 {
1709  #define NUMFASTDECOMP  100     // # of tiles in fast decompress buffer
1710
1711  char gname[14]="?GAHEAD.",gname1[14]="?GAGRAPH.",_seg *packed,_seg *unpack,
1712       dictname[14]="?GADICT.",hufftable[1020],_seg *CacheBlock;
1713  unsigned index,indexm,num,numm,i,realnum,realnumm,ox,oy,cacheon=0,_seg *tile_len,
1714       _seg *tilem_len,cacheon_h;
1715  long expsize,expmsize,xmsoff=0,unpackoff,unpackmax,unpacksize,
1716       unpackxms;
1717  video tempvid,pickedvid;
1718
1719  char huge *offsets;
1720
1721
1722
1723  strcat(gname,ext);
1724  strcat(gname1,ext);
1725  strcat(dictname,ext);
1726  gname[0]=format[0];
1727  gname1[0]=format[0];
1728  dictname[0]=format[0];
1729
1730  if (!launched)
1731    switch(format[0])
1732    {
1733         case 'C': pickedvid=CGA; break;
1734         case 'E': pickedvid=EGA1; break;
1735         case 'V': pickedvid=VGA;
1736    }
1737  else
1738    pickedvid=TEDInfo->lastvid;
1739
1740  //
1741  // VALIDATE GRAPHICS MODE
1742  //
1743  tempvid=rtn?newvid:pickedvid;
1744  switch(tempvid)
1745  {
1746   case CGA:
1747         gname[0]='C';
1748         if (access(gname,0))
1749           {
1750            if (rtn)
1751                  return 0;
1752           }
1753         else
1754           {
1755            TEDInfo->lastvid=CGA;
1756            dictname[0]=format[0]=gname1[0]='C';
1757            setvideo(CGA);
1758            InitDesktop(TED5MenuBar,1);
1759            MouseShow();
1760            break;
1761           }
1762   case EGA1:
1763   case EGA2:
1764         gname[0]='E';
1765         if (access(gname,0))
1766           {
1767            if (rtn)
1768          return 0;
1769           }
1770         else
1771           {
1772            TEDInfo->lastvid=tempvid;
1773            dictname[0]=format[0]=gname1[0]='E';
1774            setvideo(tempvid);
1775            InitDesktop(TED5MenuBar,1);
1776            MouseShow();
1777            break;
1778           }
1779   case VGA:
1780         gname[0]='V';
1781         if (access(gname,0))
1782           {
1783            if (rtn)
1784          return 0;
1785
1786        gname[0]=format[0];
1787       }
1788     else
1789       {
1790        TEDInfo->lastvid=VGA;
1791        dictname[0]=format[0]=gname1[0]='V';
1792        setvideo(VGA);
1793        InitDesktop(TED5MenuBar,1);
1794        MouseShow();
1795        break;
1796       }
1797  }
1798
1799
1800  //
1801  // FIND HEADER & LOAD IT
1802  //
1803  if (access(gname,0))
1804    {
1805     char errstr[100]="Can't find the ";
1806
1807     strcat(errstr,format);
1808     strcat(errstr,"GAHEAD.");
1809     strcat(errstr,ext);
1810     strcat(errstr,"\nfile! Maybe you didn't\n"
1811                   "copy it from the graphics\n"
1812                   "subdirectory?");
1813
1814     ErrDialog(errstr," OK ");
1815     if (rtn)
1816       return 0;
1817     Quit("You're stupid! Copy the damn file!");
1818    }
1819
1820  LoadIn(gname,(memptr *)&GraphHeader);
1821
1822  switch(MapFileHeader->tsize)
1823  {
1824   case 1:
1825     index=GFXInfo->off8;
1826     indexm=GFXInfo->off8m;
1827     num=GFXInfo->num8;
1828     numm=GFXInfo->num8m;
1829     if (indexm==index+1)
1830       {
1831        ErrDialog("I'm sorry, but you need to\n"
1832                  "capture your 8x8 tiles\n"
1833                  "individually, and not in a\n"
1834                  "big chunk."," Alright ");
1835        if (rtn)
1836          return 0;
1837        Quit("Regrab-time, bag o' shit!");
1838       }
1839
1840     switch(tempvid)
1841     {
1842      case CGA: expsize=16; expmsize=32; break;
1843      case EGA1:
1844      case EGA2: expsize=32; expmsize=40; break;
1845          case VGA: expsize=64; expmsize=128;
1846     }
1847     break;
1848   case 2:
1849     index=GFXInfo->off16;
1850     indexm=GFXInfo->off16m;
1851     num=GFXInfo->num16;
1852     numm=GFXInfo->num16m;
1853     switch(tempvid)
1854     {
1855      case CGA: expsize=64; expmsize=128; break;
1856      case EGA1:
1857      case EGA2: expsize=128; expmsize=128+32; break;
1858      case VGA: expsize=256; expmsize=512;
1859     }
1860     break;
1861   case 3:
1862     index=GFXInfo->off32;
1863     indexm=GFXInfo->off32m;
1864     num=GFXInfo->num32;
1865     numm=GFXInfo->num32m;
1866     switch(tempvid)
1867         {
1868      case CGA: expsize=256; expmsize=512; break;
1869      case EGA1:
1870      case EGA2: expsize=512; expsize=512+4*32; break;
1871      case VGA: expsize=1024; expmsize=2048;
1872     }
1873  }
1874
1875  //
1876  // MOVE TILES INTO XMS MEMORY!
1877  //
1878
1879  MMAllocate((memptr *)&packed,expmsize);
1880  unpackmax=expmsize*NUMFASTDECOMP;
1881  MMAllocate((memptr *)&unpack,unpackmax);
1882
1883
1884  tilelen=expsize;
1885  tilemlen=expmsize;
1886  offsets=MK_FP(GraphHeader,0);
1887
1888  //
1889  // LOAD DICTIONARY IN & INITIALIZE IT
1890  //
1891  if (!launched)
1892    {
1893     char _seg *block;
1894
1895     if (access(dictname,0))
1896       {
1897        char errst[200]="I can't find the \n";
1898
1899        strcat(errst,dictname);
1900        strcat(errst," file!");
1901
1902        ErrDialog(errst," OK ");
1903        if (rtn)
1904          return 0;
1905        Quit("Look in the graphics grab directory!");
1906       }
1907
1908     LoadIn(dictname,(memptr *)&block);
1909     movedata((unsigned)block,0,FP_SEG(hufftable),FP_OFF(hufftable),1020);
1910     MMFreePtr((memptr *)&block);
1911     OptimizeNodes((huffnode *)hufftable);
1912    }
1913
1914  //
1915  // Count up the REAL number of tiles there are!
1916  // Build tables for tile lengths
1917  //
1918  MMAllocate((memptr *)&tile_len,num*2);
1919  for (realnum=i=0;i<num;i++)
1920  {
1921   int j;
1922
1923
1924
1925   if (OFF3(offsets,i+index)!=0xffffff)
1926   {
1927    realnum++;
1928    if (OFF3(offsets,i+index+1)!=0xffffff)
1929      tile_len[i]=OFF3(offsets,i+index+1)-OFF3(offsets,i+index);
1930    else
1931      for (j=i+1;j<num+numm;j++)
1932        if (OFF3(offsets,j+index)!=0xffffff)
1933        {
1934         tile_len[i]=OFF3(offsets,j+index)-OFF3(offsets,i+index);
1935         break;
1936        }
1937   }
1938   else
1939     tile_len[i]=0;
1940
1941  }
1942  MMAllocate((memptr *)&tilem_len,numm*2);
1943  for (realnumm=i=0;i<numm;i++)
1944  {
1945   int j;
1946
1947
1948   if (OFF3(offsets,i+indexm)!=0xffffff)
1949   {
1950    realnumm++;
1951    if (OFF3(offsets,i+indexm+1)!=0xffffff)
1952      tilem_len[i]=OFF3(offsets,i+indexm+1)-OFF3(offsets,i+indexm);
1953    else
1954      for (j=i+1;j<numm+1;j++)
1955        if (OFF3(offsets,j+indexm)!=0xffffff)
1956        {
1957         tilem_len[i]=OFF3(offsets,j+indexm)-OFF3(offsets,i+indexm);
1958         break;
1959        }
1960   }
1961   else
1962     tilem_len[i]=0;
1963  }
1964
1965  //
1966  // DON'T REALLOCATE THIS IF WE'RE COMING BACK FROM A LAUNCH!
1967  //
1968  if (!launched)
1969    {
1970     long size=expsize*realnum+expmsize*realnumm,savings=0;
1971
1972
1973     if (1024L*XMSTotalFree()<size)
1974       {
1975        savings=CgaXMSsize+EgaXMSsize+VgaXMSsize;
1976        if (1024L*XMSTotalFree()<size-savings)
1977          {
1978           MouseShow();
1979           ErrDialog("Not enough memory to load\n"
1980                     "requested graphics.\n"," OK ");
1981
1982           MMFreePtr((memptr *)&GraphHeader);
1983           MMFreePtr((memptr *)&packed);
1984           MMFreePtr((memptr *)&unpack);
1985
1986           if (rtn)
1987             return -1;
1988           else
1989             Quit("Get more Extended memory!");
1990          }
1991
1992        if (CgaXMS)
1993          {
1994           XMSFreeMem(CgaXMS);
1995           MMFreePtr((memptr *)&CgaXMSlookup);
1996          }
1997        if (EgaXMS)
1998          {
1999           XMSFreeMem(EgaXMS);
2000           MMFreePtr((memptr *)&EgaXMSlookup);
2001          }
2002            if (VgaXMS)
2003          {
2004           XMSFreeMem(VgaXMS);
2005           MMFreePtr((memptr *)&VgaXMSlookup);
2006          }
2007        CgaXMSsize=EgaXMSsize=VgaXMSsize=CgaXMS=EgaXMS=VgaXMS=0;
2008       }
2009
2010     switch(tempvid)
2011     {
2012      case CGA:
2013        xmshandle=CgaXMS=XMSAllocate(size);
2014        CgaXMSsize=size;
2015        break;
2016      case EGA1:
2017      case EGA2:
2018        xmshandle=EgaXMS=XMSAllocate(size);
2019        EgaXMSsize=size;
2020        break;
2021      case VGA:
2022        xmshandle=VgaXMS=XMSAllocate(size);
2023        VgaXMSsize=size;
2024     }
2025
2026     ErrDialog("GRAPHICS INSTALLATION\n"
2027               "Decompressing and\n"
2028               "moving tiles into\n"
2029               "Extended memory:","");
2030    }
2031  else
2032    {
2033     long size;
2034
2035
2036     CgaXMS=TEDInfo->OldCgaXMS;
2037     EgaXMS=TEDInfo->OldEgaXMS;
2038     VgaXMS=TEDInfo->OldVgaXMS;
2039
2040     CgaXMSsize=TEDInfo->OldCgaXMSsize;
2041     EgaXMSsize=TEDInfo->OldEgaXMSsize;
2042     VgaXMSsize=TEDInfo->OldVgaXMSsize;
2043
2044     size=(num+numm)*4;
2045     if (CgaXMS)
2046       {
2047            MMAllocate((memptr *)&CgaXMSlookup,size);
2048        XMSmove(TEDInfo->CgaXMSlook,0,0,(long)MK_FP(CgaXMSlookup,0),size);
2049        XMSFreeMem(TEDInfo->CgaXMSlook);
2050        TEDInfo->CgaXMSlook=0;
2051       }
2052     if (EgaXMS)
2053       {
2054        MMAllocate((memptr *)&EgaXMSlookup,size);
2055        XMSmove(TEDInfo->EgaXMSlook,0,0,(long)MK_FP(EgaXMSlookup,0),size);
2056        XMSFreeMem(TEDInfo->EgaXMSlook);
2057        TEDInfo->EgaXMSlook=0;
2058       }
2059     if (VgaXMS)
2060       {
2061        MMAllocate((memptr *)&VgaXMSlookup,size);
2062        XMSmove(TEDInfo->VgaXMSlook,0,0,(long)MK_FP(VgaXMSlookup,0),size);
2063        XMSFreeMem(TEDInfo->VgaXMSlook);
2064        TEDInfo->VgaXMSlook=0;
2065       }
2066
2067     switch(tempvid)
2068     {
2069      case CGA:
2070        xmshandle=CgaXMS;
2071        XMSlookup=CgaXMSlookup;
2072        break;
2073      case EGA1:
2074      case EGA2:
2075        xmshandle=EgaXMS;
2076        XMSlookup=EgaXMSlookup;
2077        break;
2078      case VGA:
2079        xmshandle=VgaXMS;
2080        XMSlookup=VgaXMSlookup;
2081     }
2082
2083     ErrDialog("RE-INITIALIZING...","");
2084    }
2085
2086  ox=sx;
2087  oy=sy;
2088
2089  //
2090  // INSTALL GRAPHICS IF NOT A LAUNCH...
2091  //
2092  if (!launched)
2093  {
2094   switch(tempvid)
2095   {
2096    case CGA:
2097      MMAllocate((memptr *)&CgaXMSlookup,(num+numm)*4);
2098      XMSlookup=CgaXMSlookup;
2099      break;
2100    case EGA1:
2101    case EGA2:
2102      MMAllocate((memptr *)&EgaXMSlookup,(num+numm)*4);
2103      XMSlookup=EgaXMSlookup;
2104      break;
2105    case VGA:
2106      MMAllocate((memptr *)&VgaXMSlookup,(num+numm)*4);
2107      XMSlookup=VgaXMSlookup;
2108   }
2109
2110
2111   //
2112   // SET UP MEMORY CACHE IF ENOUGH IS AVAILABLE...
2113   //
2114   cacheon_h=0;
2115   if (filelen(gname1)<16L*MMTotalFree())
2116   {
2117    LoadIn(gname1,(memptr *)&CacheBlock);
2118    cacheon=1;
2119   }
2120   else
2121   //
2122   // DAMN! TRY XMS AS A LAST RESORT...
2123   //
2124   if (filelen(gname1)<1024l*XMSTotalFree())
2125   {
2126    #define TMPBUFSIZE 32000l
2127    long amtleft,tmpoff=0,tmpsize;
2128    memptr tblock;
2129
2130
2131    amtleft=filelen(gname1);
2132    MMAllocate(&tblock,TMPBUFSIZE);
2133    cacheon_h=XMSAllocate(amtleft);
2134    tmpsize=TMPBUFSIZE;
2135    while(amtleft>0)
2136    {
2137         LoadFile(gname1,MK_FP(tblock,0),tmpoff,tmpsize);
2138     XMSmove(0,(long)MK_FP(tblock,0),cacheon_h,tmpoff,tmpsize);
2139     amtleft-=TMPBUFSIZE;
2140     tmpoff+=TMPBUFSIZE;
2141     tmpsize=(amtleft>TMPBUFSIZE)?TMPBUFSIZE:amtleft;
2142    }
2143
2144    MMFreePtr(&tblock);
2145    cacheon=2;
2146   }
2147
2148   clearkeys();
2149
2150   //
2151   // MOVE NONMASKED TILES INTO XMS MEMORY!
2152   //      ---------
2153   unpacksize=unpackoff=0;
2154   unpackxms=xmsoff;
2155   for (i=0;i<num;i++)
2156   {
2157    long size,off;
2158
2159
2160    off=OFF3(offsets,index+i);
2161    if (off==0xffffff)   // SPARSE TILE?
2162      {
2163       *(XMSlookup+i)=-1;
2164       continue;
2165      }
2166
2167    size=tile_len[i];
2168
2169    //
2170    // GET COMPRESSED TILE DATA FROM CACHE OR DISK
2171    //
2172    if (cacheon==1)
2173    {
2174     //
2175     // HUFFMAN DECOMPRESS
2176     //
2177     HuffExpand((unsigned char huge *)CacheBlock+off,(unsigned char huge *)unpack+unpackoff,
2178           expsize,(huffnode *)hufftable);
2179    }
2180    else
2181    if (cacheon==2)
2182    {
2183     XMSmove(cacheon_h,off,0,(long)packed,size);
2184     //
2185     // HUFFMAN DECOMPRESS
2186     //
2187     HuffExpand((unsigned char huge *)packed,(unsigned char huge *)unpack+unpackoff,
2188           expsize,(huffnode *)hufftable);
2189    }
2190    else
2191    {
2192     LoadFile(gname1,(char huge *)packed,off,size);
2193     //
2194     // HUFFMAN DECOMPRESS
2195     //
2196     HuffExpand((unsigned char huge *)packed,(unsigned char huge *)unpack+unpackoff,
2197           expsize,(huffnode *)hufftable);
2198    }
2199
2200    unpacksize+=expsize;
2201    unpackoff+=expsize;
2202
2203    *(XMSlookup+i)=xmsoff;
2204    xmsoff+=expsize;
2205
2206    if (unpacksize>unpackmax-expsize)
2207    {
2208     XMSmove(0,(long)MK_FP(unpack,0),xmshandle,unpackxms,unpacksize);
2209     unpacksize=unpackoff=0;
2210     unpackxms=xmsoff;
2211
2212     sx=ox;
2213     sy=oy;
2214     printint(num+numm-i);
2215     print(" ");
2216    }
2217
2218    //
2219    // ESC will exit!
2220    //
2221    if (keydown[1])
2222      if (rtn)
2223      {
2224       switch(tempvid)
2225       {
2226        case CGA:
2227          XMSFreeMem(CgaXMS);
2228          MMFreePtr((memptr *)&CgaXMSlookup);
2229          CgaXMS=0;
2230          break;
2231        case EGA1:
2232        case EGA2:
2233          XMSFreeMem(EgaXMS);
2234          MMFreePtr((memptr *)&EgaXMSlookup);
2235          EgaXMS=0;
2236          break;
2237        case VGA:
2238          XMSFreeMem(VgaXMS);
2239          MMFreePtr((memptr *)&VgaXMSlookup);
2240          VgaXMS=0;
2241       }
2242
2243       switch(videomode)
2244       {
2245        case CGA:
2246          xmshandle=CgaXMS;
2247          XMSlookup=CgaXMSlookup;
2248          break;
2249        case EGA1:
2250        case EGA2:
2251          xmshandle=EgaXMS;
2252          XMSlookup=EgaXMSlookup;
2253          break;
2254        case VGA:
2255          xmshandle=VgaXMS;
2256          XMSlookup=VgaXMSlookup;
2257       }
2258
2259       MMFreePtr((memptr *)&GraphHeader);
2260       MMFreePtr((memptr *)&packed);
2261       MMFreePtr((memptr *)&unpack);
2262
2263       if (cacheon)
2264         MMFreePtr((memptr *)&CacheBlock);
2265
2266       return 0;
2267      }
2268      else
2269        Quit("XMS LOADING ABORTED!");
2270   }
2271
2272   //
2273   // FLUSH THE FAST(?)-CACHE
2274   //
2275   if (unpacksize)
2276   {
2277    XMSmove(0,(long)MK_FP(unpack,0),xmshandle,unpackxms,unpacksize);
2278    unpacksize=unpackoff=0;
2279    unpackxms=xmsoff;
2280   }
2281
2282   //
2283   // MOVE MASKED TILES INTO XMS MEMORY!
2284   //      ------
2285   for (i=0;i<numm;i++)
2286   {
2287    long size,off;
2288
2289    off=OFF3(offsets,indexm+i);
2290    if (off==0xffffff)   // SPARSE TILE?
2291          {
2292           *(XMSlookup+i+num)=-1;
2293           continue;
2294      }
2295
2296    size=tilem_len[i];
2297
2298    //
2299    // GET COMPRESSED TILE DATA FROM CACHE OR DISK
2300    //
2301    if (cacheon==1)
2302    {
2303     //
2304     // HUFFMAN DECOMPRESS
2305     //
2306     HuffExpand((unsigned char huge *)CacheBlock+off,(unsigned char huge *)unpack+unpackoff,
2307           expmsize,(huffnode *)hufftable);
2308    }
2309    else
2310    if (cacheon==2)
2311    {
2312     XMSmove(cacheon_h,off,0,(long)packed,size);
2313     //
2314     // HUFFMAN DECOMPRESS
2315     //
2316     HuffExpand((unsigned char huge *)packed,(unsigned char huge *)unpack+unpackoff,
2317           expmsize,(huffnode *)hufftable);
2318    }
2319    else
2320    {
2321     LoadFile(gname1,(char huge *)packed,off,size);
2322     //
2323     // HUFFMAN DECOMPRESS
2324     //
2325     HuffExpand((unsigned char huge *)packed,(unsigned char huge *)unpack+unpackoff,
2326           expmsize,(huffnode *)hufftable);
2327    }
2328
2329    unpacksize+=expmsize;
2330    unpackoff+=expmsize;
2331
2332    *(XMSlookup+i+num)=xmsoff;
2333    xmsoff+=expmsize;
2334
2335    if (unpacksize>unpackmax-expmsize)
2336    {
2337     XMSmove(0,(long)MK_FP(unpack,0),xmshandle,unpackxms,unpacksize);
2338         unpacksize=unpackoff=0;
2339     unpackxms=xmsoff;
2340
2341     sx=ox;
2342     sy=oy;
2343     printint(numm-i);
2344     print(" ");
2345    }
2346
2347
2348    //
2349    // ESC will exit!
2350    //
2351    if (keydown[1])
2352      if (rtn)
2353      {
2354       switch(tempvid)
2355       {
2356        case CGA:
2357          XMSFreeMem(CgaXMS);
2358          MMFreePtr((memptr *)&CgaXMSlookup);
2359          CgaXMS=0;
2360          break;
2361        case EGA1:
2362        case EGA2:
2363          XMSFreeMem(EgaXMS);
2364          MMFreePtr((memptr *)&EgaXMSlookup);
2365          EgaXMS=0;
2366          break;
2367        case VGA:
2368          XMSFreeMem(VgaXMS);
2369          MMFreePtr((memptr *)&VgaXMSlookup);
2370          VgaXMS=0;
2371       }
2372
2373       switch(videomode)
2374       {
2375        case CGA:
2376          xmshandle=CgaXMS;
2377          XMSlookup=CgaXMSlookup;
2378          break;
2379        case EGA1:
2380        case EGA2:
2381          xmshandle=EgaXMS;
2382          XMSlookup=EgaXMSlookup;
2383          break;
2384        case VGA:
2385          xmshandle=VgaXMS;
2386          XMSlookup=VgaXMSlookup;
2387       }
2388
2389       MMFreePtr((memptr *)&GraphHeader);
2390       MMFreePtr((memptr *)&packed);
2391       MMFreePtr((memptr *)&unpack);
2392
2393       if (cacheon)
2394         MMFreePtr((memptr *)&CacheBlock);
2395
2396       return 0;
2397      }
2398      else
2399        Quit("XMS LOADING ABORTED!");
2400   }
2401   //
2402   // FLUSH THE FAST-CACHE
2403   //
2404   if (unpacksize)
2405   {
2406    XMSmove(0,(long)MK_FP(unpack,0),xmshandle,unpackxms,unpacksize);
2407    unpacksize=unpackoff=0;
2408    unpackxms=xmsoff;
2409   }
2410
2411   if (cacheon==1)
2412     MMFreePtr((memptr *)&CacheBlock);
2413   else
2414   if (cacheon==2)
2415     XMSFreeMem(cacheon_h);
2416  }
2417
2418  //
2419  // GET RID OF TILE-FILE CACHE MEMORY (OR WE'RE TOASTY)
2420  //
2421  MMFreePtr((memptr *)&GraphHeader);
2422  MMFreePtr((memptr *)&packed);
2423  MMFreePtr((memptr *)&unpack);
2424
2425  MMFreePtr((memptr *)&tile_len);
2426  MMFreePtr((memptr *)&tilem_len);
2427
2428  whicht=0;
2429  whichi=tilenum;
2430  whichtm=tilenum;
2431
2432  switch(tsize)
2433  {
2434   case 1: lasticon=tilenum+36*maxiconrows;
2435           break;
2436   case 2: lasticon=tilenum+18*maxiconrows;
2437           break;
2438   case 3: lasticon=tilenum+7*maxiconrows;
2439  }
2440  firsticon=tilenum;
2441
2442  RestoreBackground();
2443  return 1;
2444 }
2445
2446
2447 ////////////////////////////////////////////////////
2448 ////////////////////////////////////////////////////
2449 //
2450 // Load TEDINFO.ext file
2451 //
2452 ////////////////////////////////////////////////////
2453 ////////////////////////////////////////////////////
2454 void LoadInfoFile(void)
2455 {
2456  char pname[14]="TEDINFO.",gfxname[14]="GFXINFO";
2457
2458
2459  //
2460  // Load the TEDINFO.ext file!
2461  //
2462  strcat(pname,ext);
2463  strcpy(infoname,pname);
2464
2465  if (access(pname,0))
2466    {
2467     MMAllocate((memptr *)&TEDInfo,sizeof(InfoStruct));
2468     _fmemset(TEDInfo,0,sizeof(InfoStruct));
2469                                 //  BFI  BFI
2470     TEDInfo->pflags=0x27;       // 0010 0111
2471    }
2472  else
2473    LoadIn(pname,(memptr *)&TEDInfo);
2474
2475  tsize=TEDInfo->tsize;
2476  if (launchname[0])
2477    _fmemcpy((char far *)TEDInfo->launchname,(char far *)launchname,14);
2478
2479  //
2480  // LOAD THE "GFXINFO?.EXT" FILE
2481  //
2482  strcat(gfxname,format);
2483  strcat(gfxname,".");
2484  strcat(gfxname,ext);
2485  LoadIn(gfxname,(memptr *)&GFXInfo);
2486
2487  switch(tsize)
2488  {
2489   case 1:
2490     tilenum=GFXInfo->num8;
2491     tilemnum=GFXInfo->num8m;
2492     break;
2493   case 2:
2494     tilenum=GFXInfo->num16;
2495     tilemnum=GFXInfo->num16m;
2496     break;
2497   case 3:
2498     tilenum=GFXInfo->num32;
2499     tilemnum=GFXInfo->num32m;
2500  }
2501
2502  _fstrcpy((char far *)launchname,(char far *)TEDInfo->launchname);
2503
2504  if (launched)
2505    TEDInfo->lastvid=LaunchInfo.lastmode;
2506
2507  //
2508  // SET PLANE FLAGS BACK TO NORMAL
2509  //
2510  planeton=(TEDInfo->pflags>>6)&1;
2511  planemon=(TEDInfo->pflags>>5)&1;
2512  planeion=(TEDInfo->pflags>>4)&1;
2513  viewton=(TEDInfo->pflags>>2)&1;
2514  viewmon=(TEDInfo->pflags>>1)&1;
2515  viewion=(TEDInfo->pflags)&1;
2516
2517  //
2518  // SET BACKGROUND COLOR
2519  //
2520  BkgndColor=TEDInfo->BackgndColor;
2521  if (BkgndColor>16)
2522    TEDInfo->BackgndColor=BkgndColor=O_FGNDBACK;
2523 }
2524
2525
2526 ////////////////////////////////////////////////////
2527 ////////////////////////////////////////////////////
2528 //
2529 // Find ?GAGRAPH.ext file
2530 //
2531 ////////////////////////////////////////////////////
2532 ////////////////////////////////////////////////////
2533 void FindGraphFile(void)
2534 {
2535  struct ffblk ffblk;
2536  char pname[15]="?GAGRAPH.*",*tempstr,tiname[13]="TEDINFO.TMP";
2537  int i,which;
2538
2539
2540  //
2541  // RETURNING FROM LAUNCH...GET INFO BACK
2542  //
2543  if (launched)
2544    {
2545         LoadFile(tiname,(char huge *)&LaunchInfo,0,0);
2546         unlink(tiname);
2547         videomode=LaunchInfo.lastmode;
2548         switch(videomode)
2549         {
2550          case CGA:
2551            format[0]='C';
2552            break;
2553          case EGA1:
2554          case EGA2:
2555            format[0]='E';
2556            break;
2557          case VGA:
2558            format[0]='V';
2559         }
2560
2561         strcpy(ext,LaunchInfo.ext);
2562         projname[0]=format[0];
2563         strcat(projname,"GAGRAPH.");
2564         strcat(projname,ext);
2565         return;
2566    }
2567
2568  //
2569  // Find ?GAGRAPH.ext
2570  //
2571  if (ext[0])
2572    {
2573         strcpy(pname,"?GAGRAPH.");
2574         strcat(pname,ext);
2575    }
2576
2577  if (findfirst(pname,&ffblk,FA_ARCH))
2578    {
2579         ErrDialog("I can't find a graphics\nfile! (ex:?GAGRAPH.ext)"," Alright ");
2580         Quit("Can't work without graphics ya know!");
2581    }
2582
2583
2584  if (GfxToUse)
2585    format[0] = GfxToUse;
2586  else
2587  {
2588   // setup the dialog
2589
2590   strcpy(bstrings[0],ffblk.ff_name);
2591   ProjButns[0].xoff=9;
2592   ProjButns[0].yoff=2;
2593   ProjButns[0].border=0;
2594   ProjButns[0].text=bstrings[0];
2595   for (i=1;i<10;i++)
2596         {
2597          if (findnext(&ffblk))
2598            break;
2599          strcpy(bstrings[i],ffblk.ff_name);
2600          ProjButns[i].xoff=9;
2601          ProjButns[i].yoff=2+i;
2602          ProjButns[i].border=0;
2603          ProjButns[i].text=bstrings[i];
2604         }
2605   ProjSelect.numbuttons=i;
2606   ProjSelect.height=i+3;
2607
2608   which=1;
2609   if (i>1)
2610         do
2611         {
2612          which=DoDialog(&ProjSelect);
2613         } while(!which);
2614   which--;
2615
2616   tempstr=strpbrk(bstrings[which],".")+1;
2617   strcpy(ext,tempstr);
2618   format[0]=bstrings[which][0];
2619  }
2620
2621  strcpy(projname,bstrings[which]);
2622 }
2623
2624 //
2625 // draw border for project window
2626 //
2627 void DrawProjBord(int x,int y)
2628 {
2629  DrawBorder(x+8,y+1,13,ProjSelect.height-2,1);
2630 }
2631
2632
2633 ////////////////////////////////////////////////////
2634 //
2635 // Input amount of icons to reserve
2636 // Returns maximum # of icon rows to reserve
2637 //
2638 ////////////////////////////////////////////////////
2639 btype ICb={"    ",8,3,1};
2640 DialogDef ICd={"Enter maximum amount\nof icons to reserve:",20,5,1,&ICb,NULL};
2641
2642 int InputIconAmount(void)
2643 {
2644  char tempstr[4];
2645  int value;
2646
2647
2648  if (!(MapFileHeader->maptype&IPLANE))
2649    return 4;
2650
2651  MouseHide();
2652  DrawDialog(&ICd,1);
2653  while(1)
2654  {
2655   GetDialogXY(&ICd,&sx,&sy);
2656   GetButtonXY(&ICd,0,&sx,&sy);
2657   if (input(tempstr,3))
2658   {
2659    value=atoi(tempstr);
2660    if (value>0)
2661    {
2662     MouseShow();
2663     RestoreBackground();
2664     return (value+17)/18;
2665    }
2666   }
2667  }
2668 }
2669
2670
2671 ////////////////////////////////////////////////////
2672 ////////////////////////////////////////////////////
2673 //
2674 // Unhook everything
2675 //
2676 ////////////////////////////////////////////////////
2677 ////////////////////////////////////////////////////
2678 void Unhook(void)
2679 {
2680  ShutdownKBD();
2681  if (CgaXMS)
2682    XMSFreeMem(CgaXMS);
2683  if (EgaXMS)
2684    XMSFreeMem(EgaXMS);
2685  if (VgaXMS)
2686    XMSFreeMem(VgaXMS);
2687  if (XMSundoB)
2688    XMSFreeMem(XMSundoB);
2689  if (XMSundoF)
2690    XMSFreeMem(XMSundoF);
2691  if (XMSundoI)
2692    XMSFreeMem(XMSundoI);
2693  if (XMSmaps)
2694    XMSFreeMem(XMSmaps);
2695 }
2696
2697 void PatchPointers(void)
2698 {
2699 }
2700
2701
2702 ////////////////////////////////////////////////////
2703 ////////////////////////////////////////////////////
2704 //
2705 // Menu Definitions
2706 //
2707 ////////////////////////////////////////////////////
2708 ////////////////////////////////////////////////////
2709 MenuDef AboutMenu[]=
2710   {{"About...",Item_About,0,0},
2711    {"Video Mode Switch",Item_ModeSwitch,0,0x43},
2712    {"Last Video Mode",Item_LastVideo,ALT,0x2c},
2713    {"Memory Available",Item_PrintMem,0,0x44},
2714    {"Launch Project",Item_Launch,ALT,0x26},
2715    {"--------------------",NULL,0,0},
2716 //   {"Display Unused Tiles",Item_CountTiles,0,0},
2717    {"Project Re-Select",Item_ProjectReSelect,0,0},
2718    {"Visit DOS",Item_VisitDOS,0,0}
2719   };
2720
2721 MenuDef FileMenu[]=
2722   {{"Edit New Map",Item_EditMap,ALT,0x18},
2723    {"Save Map",Item_SaveMap,ALT,0x1f},
2724    {"Create Map",Item_CreateMap,ALT,0x2e},
2725    {"Delete Map",Item_DeleteMap,ALT,0x20},
2726    {"Switch Map",Item_SwitchMap,ALT,0x11},
2727    {"Amputate Maps",Item_Amputate},
2728    {"---------------",NULL,0,0},
2729    {"Import Maps",Item_ImportMaps,0,0},
2730    {"Change ICON Rows",Item_ChangeIconRows,0,0},
2731    {"Carmacize Maps",Item_Huffman,0,0},
2732    {"Quit TED5",Item_Quit,ALT,0x2d}};
2733
2734 MenuDef EditMenu[]=
2735   {{"Switch to Last Map",Item_LastMap,ALT,0x32},
2736    {"Edit TILEINFO/M Values",Item_EditTinfoValues,ALT,0x14},
2737    {"Change LAUNCH name",Item_LAUNCHname,0,0},
2738    {"Change PARM string",Item_PARMstring,0,0},
2739    {"Edit TILEINFO/M Names",Item_EditTinfoNames,0,0},
2740    {"Add/Del TILEINFO/M Planes",Item_AddDelTinfo,0,0},
2741    {"Edit MAP Names",Item_EditMapNames,0,0},
2742    {"Change MAP Edges",Item_EditMapEdges,0,0}};
2743
2744 MenuDef ModeMenu[]=
2745 {
2746  {"Copy Mode",Item_Copy,0,0x2e},
2747  {"Paste Mode",Item_Paste,0,0x19},
2748  {"Block Fill",Item_BlockFill,0,0x30},
2749  {"Flood Fill",Item_FloodFill,0,0x21},
2750  {"Undo last action",Item_Undo,0,0x16},
2751  {"Tile Search",Item_TileSearch,0,0x14},
2752  {"GridMode toggle",Item_GridMode,0,0x22},
2753  {"Snap-Paste toggle",Item_SnapTog,0,0x1f},
2754  {"Paste Overlay toggle",Item_POtog,0,0x3d}
2755 };
2756
2757
2758 MenuDef MiscMenu[]=
2759 {
2760  {"Select Tile",Item_SelectTile,0,0x39},
2761  {"Map Stats",Item_MapStats,0,0x17},
2762  {"Toggle INFOBAR",Item_ToggleInfo,0,0x42},
2763  {"New INFOPLANE value",Item_InputInfoplane,0,0x1c},
2764  {"View Map & Goto",Item_ViewMap,ALT,0x2f},
2765  {"ReView Map & Goto",Item_ReviewMap,0,0xe},
2766  {"Change LAUNCH icon",Item_ChangeLaunchIcon,0,0},
2767  {"Change bkgnd color",Item_ChangeBkgndColor,0,0},
2768  {"TILEINFOM Copy",Item_TINFOCopy,0,0},
2769  {"Graphic Map Dump",Item_GraphicDump,0,0}
2770 };
2771
2772
2773 MBarDef TED5MenuBar[]=
2774   {{9,AboutMenu," ? "},
2775    {11,FileMenu,"File"},
2776    {8,EditMenu,"Edit"},
2777    {9,ModeMenu,"Modes"},
2778    {10,MiscMenu,"Misc"},
2779    {0,0,""}};