16/ted5/TED5-3.C

   1 ////////////////////////////////////////////////////
   2 ////////////////////////////////////////////////////
   3 //
   4 // TED5-3
   5 //
   6 ////////////////////////////////////////////////////
   7 ////////////////////////////////////////////////////
   8 #include "ted5.h"
   9 #pragma hdrstop
  10
  11 int xms1;
  12 extern int tics;
  13
  14 ////////////////////////////////////////////////////
  15 //
  16 // MAP SCROLLING
  17 //
  18 ////////////////////////////////////////////////////
  19 void CheckMapScroll(void)
  20 {
  21  //
  22  // LEFT
  23  //
  24  if (keydown[0x4b])     // left arrow
  25    {
  26     int i,j,imax,jmax,tilesmoved;
  27
  28     tics=biostime(0,0);
  29
  30     if (xbase)
  31     {
  32      EraseFloatPaste();
  33
  34      if (keydown[0x1d]) // CTRL-KEY
  35      {
  36       tilesmoved=screenw;
  37       if (keydown[0x38]) // ALT-KEY
  38       {
  39        xbase=0;
  40        DrawMap();
  41        return;
  42       }
  43      }
  44      else
  45        switch(videomode)
  46        {
  47         case CGA:
  48         case EGA1:
  49         case VGA:
  50           tilesmoved=1;
  51           break;
  52         case EGA2:
  53           tilesmoved=2;
  54        }
  55
  56      if (xbase<tilesmoved)
  57        tilesmoved=xbase;
  58      xbase-=tilesmoved;
  59
  60      MouseHide();
  61      if (tilesmoved<screenw)
  62        CopyScreen(0,8,infomaxw-(tilesmoved<<(tsize-1)),screenh<<(tsize+2),tilesmoved<<(tsize-1),8);
  63
  64      jmax=screenh;
  65      if (jmax>mapheight)
  66        jmax=mapheight;
  67
  68      for (i=0;i<tilesmoved;i++)
  69        for (j=0;j<jmax;j++)
  70        {
  71         unsigned tilet,tilem,tilei,loc;
  72
  73         loc=(ybase+j)*mapwidth+xbase+i;
  74
  75         tilet=*(MapBkgnd+loc);
  76         tilem=*(MapFrgnd+loc)+tilenum;
  77         tilei=*(MapInfoPl+loc)+tilenum;
  78
  79         CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
  80         if (GridMode)
  81           Overlay(tsize);
  82         DrawTile(i<<(tsize-1),j*(4<<tsize)+8,tsize);
  83         CheckInfoValues(i,j,tilei);
  84         CheckSelectEdges(i+xbase,j+ybase,i,j);
  85        }
  86
  87      px+=tilesmoved;
  88      DrawFloatPaste();
  89      MouseShow();
  90      if (keydown[0x36] || keydown[0x1d])
  91        while(keydown[0x4b]);
  92     }
  93    }
  94  else
  95  //
  96  // RIGHT
  97  //
  98  if (keydown[0x4d])     // right arrow
  99    {
 100     int i,j,imax,jmax,tilesmoved;
 101
 102     tics=biostime(0,0);
 103
 104     if (xbase+screenw<mapwidth)
 105     {
 106      EraseFloatPaste();
 107
 108      if (keydown[0x1d]) // CTRL-KEY
 109      {
 110       tilesmoved=screenw;
 111       if (keydown[0x38]) // ALT-KEY
 112       {
 113        xbase=mapwidth-screenw;
 114        DrawMap();
 115        return;
 116       }
 117      }
 118      else
 119        switch(videomode)
 120        {
 121         case CGA:
 122         case EGA1:
 123         case VGA:
 124           tilesmoved=1;
 125           break;
 126         case EGA2:
 127           tilesmoved=2;
 128        }
 129
 130
 131      if (xbase+screenw+tilesmoved>=mapwidth)
 132        tilesmoved=mapwidth-screenw-xbase;
 133      xbase+=tilesmoved;
 134
 135      MouseHide();
 136      if (tilesmoved<screenw)
 137        CopyScreen(tilesmoved<<(tsize-1),8,infomaxw-(tilesmoved<<(tsize-1)),screenh<<(tsize+2),0,8);
 138
 139      jmax=screenh;
 140      if (jmax>mapheight)
 141        jmax=mapheight;
 142
 143      for (i=0;i<tilesmoved;i++)
 144        for (j=0;j<jmax;j++)
 145        {
 146         unsigned tilet,tilem,tilei,loc;
 147
 148         loc=(ybase+j)*mapwidth+xbase+screenw-tilesmoved+i;
 149
 150         tilet=*(MapBkgnd+loc);
 151         tilem=*(MapFrgnd+loc)+tilenum;
 152         tilei=*(MapInfoPl+loc)+tilenum;
 153
 154         CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
 155         if (GridMode)
 156           Overlay(tsize);
 157         DrawTile(infomaxw-((tilesmoved-i)<<(tsize-1)),j*(4<<tsize)+8,tsize);
 158         CheckInfoValues(screenw-tilesmoved+i,j,tilei);
 159         CheckSelectEdges(screenw-tilesmoved+i+xbase,j+ybase,i+screenw-tilesmoved,j);
 160        }
 161
 162      px+=tilesmoved;
 163      DrawFloatPaste();
 164      MouseShow();
 165      if (keydown[0x36] || keydown[0x1d])
 166        while(keydown[0x4d]);
 167     }
 168    }
 169
 170  //
 171  // UP
 172  //
 173  if (keydown[0x48])     // up arrow
 174    {
 175     int i,j,imax,jmax,tilesmoved;
 176
 177     tics=biostime(0,0);
 178
 179     if (ybase)
 180     {
 181      EraseFloatPaste();
 182
 183      if (keydown[0x1d]) // CTRL-KEY
 184      {
 185       tilesmoved=screenh;
 186       if (keydown[0x38]) // ALT-KEY
 187       {
 188        ybase=0;
 189        DrawMap();
 190        return;
 191       }
 192      }
 193      else
 194        switch(videomode)
 195        {
 196         case CGA:
 197         case EGA1:
 198         case VGA:
 199           tilesmoved=1;
 200           break;
 201         case EGA2:
 202           tilesmoved=2;
 203        }
 204
 205      if (ybase<tilesmoved)
 206        tilesmoved=ybase;
 207      ybase-=tilesmoved;
 208
 209      MouseHide();
 210      if (tilesmoved<screenh)
 211        CopyScreen(0,8,infomaxw,(screenh-tilesmoved)<<(tsize+2),0,8+(tilesmoved<<(tsize+2)));
 212
 213      imax=screenw;
 214      if (imax>mapwidth)
 215        imax=mapwidth;
 216
 217      for (j=0;j<tilesmoved;j++)
 218        for (i=0;i<imax;i++)
 219        {
 220         unsigned tilet,tilem,tilei,loc;
 221
 222         loc=(ybase+j)*mapwidth+xbase+i;
 223
 224         tilet=*(MapBkgnd+loc);
 225         tilem=*(MapFrgnd+loc)+tilenum;
 226         tilei=*(MapInfoPl+loc)+tilenum;
 227
 228         CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
 229         if (GridMode)
 230           Overlay(tsize);
 231         DrawTile(i<<(tsize-1),8+(j<<(tsize+2)),tsize);
 232         CheckInfoValues(i,j,tilei);
 233         CheckSelectEdges(i+xbase,j+ybase,i,j);
 234        }
 235
 236      py+=tilesmoved;
 237      DrawFloatPaste();
 238      MouseShow();
 239      if (keydown[0x36] || keydown[0x1d])
 240        while(keydown[0x48]);
 241     }
 242    }
 243  else
 244  //
 245  // DOWN
 246  //
 247  if (keydown[0x50])     // down arrow
 248    {
 249     int i,j,imax,jmax,tilesmoved;
 250
 251     tics=biostime(0,0);
 252
 253     if (ybase+screenh<mapheight)
 254     {
 255      EraseFloatPaste();
 256
 257      if (keydown[0x1d]) // CTRL-KEY
 258      {
 259       tilesmoved=screenh;
 260       if (keydown[0x38]) // ALT-KEY
 261       {
 262        ybase=mapheight-screenh;
 263        DrawMap();
 264        return;
 265       }
 266      }
 267      else
 268        switch(videomode)
 269        {
 270         case CGA:
 271         case EGA1:
 272         case VGA:
 273           tilesmoved=1;
 274           break;
 275         case EGA2:
 276           tilesmoved=2;
 277        }
 278
 279      if (ybase+screenh+tilesmoved>=mapheight)
 280        tilesmoved=mapheight-screenh-ybase;
 281      ybase+=tilesmoved;
 282
 283      MouseHide();
 284      if (tilesmoved<screenh)
 285        CopyScreen(0,8+(tilesmoved<<(tsize+2)),infomaxw,(screenh-tilesmoved)<<(tsize+2),0,8);
 286
 287      imax=screenw;
 288      if (imax>mapwidth)
 289        imax=mapwidth;
 290
 291      for (j=0;j<tilesmoved;j++)
 292        for (i=0;i<imax;i++)
 293        {
 294         unsigned tilet,tilem,tilei,loc;
 295
 296         loc=(ybase+j+screenh-tilesmoved)*mapwidth+xbase+i;
 297
 298         tilet=*(MapBkgnd+loc);
 299         tilem=*(MapFrgnd+loc)+tilenum;
 300         tilei=*(MapInfoPl+loc)+tilenum;
 301
 302         CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
 303         if (GridMode)
 304           Overlay(tsize);
 305         DrawTile(i<<(tsize-1),8+((screenh-tilesmoved+j)<<(tsize+2)),tsize);
 306         CheckInfoValues(i,screenh-tilesmoved+j,tilei);
 307         CheckSelectEdges(i+xbase,screenh-tilesmoved+j+ybase,i,j+screenh-tilesmoved);
 308        }
 309
 310
 311      py+=tilesmoved;
 312      DrawFloatPaste();
 313      MouseShow();
 314      if (keydown[0x36] || keydown[0x1d])
 315        while(keydown[0x50]);
 316     }
 317    }
 318 }
 319
 320
 321 ////////////////////////////////////////////////////
 322 //
 323 // Copy a screen section to another, mode independent
 324 //
 325 ////////////////////////////////////////////////////
 326 void CopyScreen(int srcx,int srcy,int width,int height,int destx,int desty)
 327 {
 328  switch(videomode)
 329  {
 330   case CGA: CopyCGA(srcx,srcy,width,height,destx,desty); break;
 331   case EGA1:
 332   case EGA2:outport(SCindex,0x0f00 | SCmapmask);CopyEGA(srcx,srcy,width,height,destx,desty); break;
 333   case VGA: CopyVGA(srcx,srcy,width,height,destx,desty);
 334  }
 335 }
 336
 337
 338 ////////////////////////////////////////////////////
 339 //
 340 // See if either of the Select edges are visible on the map
 341 // Draw them if so
 342 //
 343 ////////////////////////////////////////////////////
 344 void CheckSelectEdges(int x,int y,int i,int j)
 345 {
 346  int temp;
 347
 348  if (SelX2<SelX1)
 349    {
 350     temp=SelX1;
 351     SelX1=SelX2;
 352     SelX2=temp;
 353    }
 354  if (SelY2<SelY1)
 355    {
 356     temp=SelY1;
 357     SelY1=SelY2;
 358     SelY2=temp;
 359    }
 360
 361  if (y==SelY2 && x==SelX2)
 362    {
 363     switch(tsize)
 364     {
 365      case 1: drawchar(i,j+1,8);
 366              break;
 367      case 2: drawchar(i*2+1,j*2+2,8);
 368              drawchar(i*2+1,j*2+1,5);
 369              drawchar(i*2,j*2+2,7);
 370              break;
 371      case 3: drawchar(i*4+3,j*4+4,8);
 372
 373              drawchar(i*4+3,j*4+3,5);
 374              drawchar(i*4+3,j*4+2,5);
 375              drawchar(i*4+3,j*4+1,5);
 376
 377              drawchar(i*4+2,j*4+4,7);
 378              drawchar(i*4+1,j*4+4,7);
 379              drawchar(i*4,j*4+4,7);
 380              break;
 381     }
 382    }
 383
 384  if (y==SelY1 && x==SelX1)
 385    {
 386     switch(tsize)
 387     {
 388      case 1: drawchar(i,j+1,1);
 389              break;
 390      case 2: drawchar(i*2,j*2+1,1);
 391              drawchar(i*2+1,j*2+1,2);
 392              drawchar(i*2,j*2+2,4);
 393              break;
 394      case 3: drawchar(i*4,j*4+1,1);
 395
 396              drawchar(i*4+1,j*4+1,2);
 397              drawchar(i*4+2,j*4+1,2);
 398              drawchar(i*4+3,j*4+1,2);
 399
 400              drawchar(i*4,j*4+2,4);
 401              drawchar(i*4,j*4+3,4);
 402              drawchar(i*4,j*4+4,4);
 403              break;
 404     }
 405    }
 406
 407  if (y==SelY2 && x==SelX1)
 408    {
 409     switch(tsize)
 410     {
 411      case 1: drawchar(i,j+1,6);
 412              break;
 413      case 2: drawchar(i*2  ,j*2+2,6);
 414              drawchar(i*2+1,j*2+2,7);
 415              drawchar(i*2  ,j*2+1,4);
 416              break;
 417      case 3: drawchar(i*4,j*4+4,6);
 418
 419              drawchar(i*4+1,j*4+4,7);
 420              drawchar(i*4+2,j*4+4,7);
 421              drawchar(i*4+3,j*4+4,7);
 422
 423              drawchar(i*4,j*4+1,4);
 424              drawchar(i*4,j*4+2,4);
 425              drawchar(i*4,j*4+3,4);
 426              break;
 427     }
 428    }
 429
 430  if (y==SelY1 && x==SelX2)
 431    {
 432     switch(tsize)
 433     {
 434      case 1: drawchar(i,j+1,3);
 435              break;
 436      case 2: drawchar(i*2+1,j*2+1,3);
 437              drawchar(i*2+1,j*2+2,5);
 438              drawchar(i*2  ,j*2+1,2);
 439              break;
 440      case 3: drawchar(i*4+3,j*4+1,3);
 441
 442              drawchar(i*4+3,j*4+4,5);
 443              drawchar(i*4+3,j*4+3,5);
 444              drawchar(i*4+3,j*4+2,5);
 445
 446              drawchar(i*4+2,j*4+4,7);
 447              drawchar(i*4+1,j*4+4,7);
 448              drawchar(i*4,j*4+4,7);
 449              break;
 450     }
 451    }
 452
 453  if (y==SelY1 && x>SelX1 && x<SelX2)
 454    {
 455     switch(tsize)
 456     {
 457      case 3: drawchar(i*4+2,j*4+1,2);
 458              drawchar(i*4+3,j*4+1,2);
 459              drawchar(i*4+1,j*4+1,2);
 460              drawchar(i*4  ,j*4+1,2);
 461              break;
 462      case 2: drawchar(i*2+1,j*2+1,2);
 463              drawchar(i*2  ,j*2+1,2);
 464              break;
 465      case 1: drawchar(i,j+1,2);
 466              break;
 467     }
 468    }
 469
 470  if (y==SelY2 && x>SelX1 && x<SelX2)
 471    {
 472     switch(tsize)
 473     {
 474      case 1: drawchar(i,j+1,7);
 475              break;
 476      case 2: drawchar(i*2,j*2+2,7);
 477              drawchar(i*2+1,j*2+2,7);
 478              break;
 479      case 3: drawchar(i*4  ,j*4+4,7);
 480              drawchar(i*4+1,j*4+4,7);
 481              drawchar(i*4+2,j*4+4,7);
 482              drawchar(i*4+3,j*4+4,7);
 483              break;
 484     }
 485    }
 486
 487  if (x==SelX1 && y>SelY1 && y<SelY2)
 488    {
 489     switch(tsize)
 490     {
 491      case 3: drawchar(i*4,j*4+3,4);
 492              drawchar(i*4,j*4+4,4);
 493              drawchar(i*4,j*4+2,4);
 494              drawchar(i*4,j*4+1,4);
 495              break;
 496      case 2: drawchar(i*2,j*2+2,4);
 497              drawchar(i*2,j*2+1,4);
 498              break;
 499      case 1: drawchar(i,j+1,4);
 500              break;
 501     }
 502    }
 503
 504  if (x==SelX2 && y>SelY1 && y<SelY2)
 505    {
 506     switch(tsize)
 507     {
 508      case 1: drawchar(i,j+1,5);
 509              break;
 510      case 2: drawchar(i*2+1,j*2+1,5);
 511              drawchar(i*2+1,j*2+2,5);
 512              break;
 513      case 3: drawchar(i*4+3,j*4+1,5);
 514              drawchar(i*4+2,j*4+1,5);
 515              drawchar(i*4+1,j*4+1,5);
 516              drawchar(i*4  ,j*4+1,5);
 517     }
 518    }
 519
 520
 521 }
 522
 523 ////////////////////////////////////////////////////
 524 //
 525 // FLOATING PASTE REGION!
 526 //
 527 ////////////////////////////////////////////////////
 528 void CheckFloatPaste(int mx,int my)
 529 {
 530  int i,j,maxh,maxw;
 531
 532
 533  if (SnapMode && PasteMode && (pixely>=8 || pixely<infoy*8))
 534    {
 535     mx=(mx/snapxsize)*snapxsize+snapx;
 536     my=(my/snapysize)*snapysize+snapy;
 537
 538     if (mx<xbase)
 539       mx+=snapxsize;
 540     if (my<ybase)
 541       my+=snapysize;
 542     if (mx>=xbase+screenw)
 543       mx-=snapxsize;
 544     if (my>=ybase+screenh)
 545       my-=snapysize;
 546    }
 547
 548  if (!PasteMode || (px==mx && py==my) || (pixely<8 || pixely>infoy*8))
 549    return;
 550
 551  if (mx>mapwidth || my>mapheight)
 552    return;
 553
 554  MouseHide();
 555  EraseFloatPaste();
 556
 557  //
 558  // FLOAT IT...
 559  //
 560  px=mx;
 561  py=my;
 562
 563  DrawFloatPaste();
 564  MouseShow();
 565 }
 566
 567
 568 ////////////////////////////////////////////////////
 569 //
 570 // DRAW FLOATING PASTE REGION
 571 //
 572 void DrawFloatPaste(void)
 573 {
 574  int i,j,maxw,maxh;
 575
 576
 577  if (px==-1 || py==-1 || !PasteMode)
 578    return;
 579  //
 580  // NOW, DRAW IT IN A NEW LOCATION!
 581  //
 582  MouseHide();
 583
 584
 585  maxh=TileCopy.h;
 586  if (py+maxh>mapheight)
 587    maxh=mapheight-py;
 588  if (py+maxh-ybase>screenh)
 589    maxh=screenh-(py-ybase);
 590
 591  maxw=TileCopy.w;
 592  if (px+maxw>mapwidth)
 593    maxw=mapwidth-px;
 594  if (px+maxw-xbase>screenw)
 595    maxw=screenw-(px-xbase);
 596
 597  switch(TileCopy.MapOrTileSelect)
 598  {
 599   case 0: // MAP PASTE DRAW
 600     for (j=0;j<maxh;j++)
 601       for (i=0;i<maxw;i++)
 602         {
 603          unsigned tilet,tilem,tilei,loc,loc1,oldt,oldm,oldi;
 604          int theT,theM,theI;
 605
 606          loc=(TileCopy.y+j)*mapwidth+TileCopy.x+i;
 607          loc1=(py+j)*mapwidth+px+i;
 608
 609          tilet=*(CutBkgnd+loc);
 610          oldt=MapBkgnd[loc1];
 611          tilem=*(CutFrgnd+loc)+tilenum;
 612          if (tilem==tilenum)
 613            tilem=0;
 614          oldm=MapFrgnd[loc1]+tilenum;
 615          tilei=*(CutInfoPl+loc)+tilenum;
 616          if (tilei==tilenum)
 617            tilei=0;
 618          oldi=MapInfoPl[loc1]+tilenum;
 619
 620          theT=(TileCopy.PlanesCopied&BPLANE)?tilet:-BkgndColor;
 621          if (theT==-BkgndColor && viewton)
 622            theT=oldt;
 623          theM=(TileCopy.PlanesCopied&FPLANE)?tilem:0;
 624          if (!theM && viewmon && !(TileCopy.PlanesCopied&FPLANE && F3_flag))
 625            theM=oldm;
 626          theI=(TileCopy.PlanesCopied&IPLANE)?tilei:0;
 627          if (!theI && viewion && !(TileCopy.PlanesCopied&IPLANE && F3_flag))
 628            theI=oldi;
 629
 630          CombineTiles(theT,theM,theI,tsize);
 631          if (GridMode)
 632            Overlay(tsize);
 633          DrawTile((px+i-xbase)<<(tsize-1),(py+j-ybase)*(4<<tsize)+8,tsize);
 634         }
 635     break;
 636
 637   case 1: // TILE PASTE DRAW
 638     for (j=0;j<maxh;j++)
 639       for (i=0;i<maxw;i++)
 640         {
 641          int val=(j+TileCopy.y)*selectcols+TileCopy.x+i;
 642          unsigned tilem,tilei,loc;
 643
 644          loc=(py+j)*mapwidth+px+i;
 645
 646          tilem=MapFrgnd[loc]+tilenum;
 647          tilei=MapInfoPl[loc]+tilenum;
 648
 649          if (XMSlookup[val]!=-1)
 650            {
 651             CombineTiles(viewton?val:-BkgndColor,
 652                          viewmon?tilem:0,
 653                          viewion?tilei:0,
 654                          tsize);
 655             if (GridMode)
 656               Overlay(tsize);
 657             DrawTile((px+i-xbase)<<(tsize-1),(py+j-ybase)*(4<<tsize)+8,tsize);
 658            }
 659         }
 660     break;
 661
 662   case 2: // MASKED PASTE DRAW
 663     for (j=0;j<maxh;j++)
 664       for (i=0;i<maxw;i++)
 665         {
 666          int val=(j+TileCopy.y)*selectcols+TileCopy.x+i+tilenum+maxiconrows*selectcols;
 667          unsigned tilet,tilei,loc;
 668
 669          loc=(py+j)*mapwidth+px+i;
 670
 671          tilet=MapBkgnd[loc];
 672          tilei=MapInfoPl[loc]+tilenum;
 673
 674          if (XMSlookup[val]!=-1)
 675            {
 676             CombineTiles(viewton?tilet:-BkgndColor,
 677                          viewmon?val:0,
 678                          viewion?tilei:0,
 679                          tsize);
 680             if (GridMode)
 681               Overlay(tsize);
 682             DrawTile((px+i-xbase)<<(tsize-1),(py+j-ybase)*(4<<tsize)+8,tsize);
 683            }
 684         }
 685  }
 686
 687  MouseShow();
 688 }
 689
 690 ////////////////////////////////////////////////////
 691 //
 692 // ERASE FLOATING PASTE REGION
 693 //
 694 void EraseFloatPaste(void)
 695 {
 696  int maxh,maxw,i,j;
 697
 698
 699  if (px==-1 || py==-1 || !PasteMode)
 700    return;
 701
 702  //
 703  // ERASE THE FLOATING REGION
 704  // (PRECLIPPING REGION)
 705  //
 706  MouseHide();
 707
 708  maxh=TileCopy.h;
 709  if (py+maxh>mapheight)
 710    maxh=mapheight-py;
 711  if (py+maxh-ybase>screenh)
 712    maxh=screenh-(py-ybase);
 713
 714  maxw=TileCopy.w;
 715  if (px+maxw>mapwidth)
 716    maxw=mapwidth-px;
 717  if (px+maxw-xbase>screenw)
 718    maxw=screenw-(px-xbase);
 719
 720  for (j=0;j<maxh;j++)
 721    for (i=0;i<maxw;i++)
 722      {
 723       unsigned tile_t,tile_m,tile_i,loc;
 724
 725       loc=(py+j)*mapwidth+px+i;
 726
 727       tile_t=*(MapBkgnd+loc);
 728       tile_m=*(MapFrgnd+loc)+tilenum;
 729       tile_i=*(MapInfoPl+loc)+tilenum;
 730
 731       CombineTiles(viewton?tile_t:-BkgndColor,viewmon?tile_m:0,viewion?tile_i:0,tsize);
 732       if (GridMode)
 733         Overlay(tsize);
 734       DrawTile((px+i-xbase)<<(tsize-1),(py+j-ybase)*(4<<tsize)+8,tsize);
 735      }
 736
 737  MouseShow();
 738 }
 739
 740
 741 ////////////////////////////////////////////////////
 742 //
 743 // SAVE CUT BUFFERS TO XMS BEFORE MAP LOAD/CREATE
 744 //
 745 ////////////////////////////////////////////////////
 746 void SaveCutBuffers(void)
 747 {
 748  long size,off;
 749  int j;
 750
 751  //
 752  // IS SOMETHING IN THE COPY BUFFER?
 753  // IF SO, PRESERVE AS MUCH AS POSSIBLE
 754  //
 755  if (!TileCopy.MapOrTileSelect)
 756    {
 757     size=(2L*TileCopy.w*TileCopy.h)*(((TileCopy.PlanesCopied&BPLANE)>0)+
 758       ((TileCopy.PlanesCopied&FPLANE)>0)+((TileCopy.PlanesCopied&IPLANE)>0));
 759
 760     xms1=XMSAllocate(size);
 761
 762     off=0;
 763     if (TileCopy.PlanesCopied&BPLANE)
 764       for (j=0;j<TileCopy.h;j++)
 765         {
 766          XMSmove(0,(long)MK_FP(CutBkgnd,2L*((TileCopy.y+j)*mapwidth)+2L*TileCopy.x),
 767            xms1,off,2L*TileCopy.w);
 768          off+=2L*TileCopy.w;
 769         }
 770
 771     if (TileCopy.PlanesCopied&FPLANE)
 772       for (j=0;j<TileCopy.h;j++)
 773         {
 774          XMSmove(0,(long)MK_FP(CutFrgnd,2L*((TileCopy.y+j)*mapwidth)+2L*TileCopy.x),
 775            xms1,off,2L*TileCopy.w);
 776          off+=2L*TileCopy.w;
 777         }
 778
 779     if (TileCopy.PlanesCopied&IPLANE)
 780       for (j=0;j<TileCopy.h;j++)
 781         {
 782          XMSmove(0,(long)MK_FP(CutInfoPl,2L*((TileCopy.y+j)*mapwidth)+2L*TileCopy.x),
 783            xms1,off,2L*TileCopy.w);
 784          off+=2L*TileCopy.w;
 785         }
 786    }
 787 }
 788
 789
 790 ////////////////////////////////////////////////////
 791 //
 792 // RESTORE CUT BUFFERS FROM XMS AFTER MAP LOAD/CREATE
 793 //
 794 ////////////////////////////////////////////////////
 795 void RestoreCutBuffers(void)
 796 {
 797  //
 798  // COPY BACK STUFF IN XMS
 799  //
 800  if (!TileCopy.MapOrTileSelect)
 801    {
 802     long ToOff,off;
 803     int newwidth,newheight,j;
 804
 805     newwidth=(TileCopy.w>mapwidth)?mapwidth:TileCopy.w;
 806     newheight=(TileCopy.h>mapheight)?mapheight:TileCopy.h;
 807
 808     ToOff=off=0;
 809
 810     if (TileCopy.PlanesCopied&BPLANE)
 811       for (j=0;j<newheight;j++)
 812         {
 813          XMSmove(xms1,off,0,(long)MK_FP(CutBkgnd,2L*(j*mapwidth)),2L*newwidth);
 814          ToOff+=2L*newwidth;
 815          off+=2L*TileCopy.w;
 816         }
 817
 818     if (TileCopy.PlanesCopied&FPLANE)
 819       for (j=0;j<newheight;j++)
 820         {
 821          XMSmove(xms1,off,0,(long)MK_FP(CutFrgnd,2L*(j*mapwidth)),2L*newwidth);
 822          ToOff+=2L*newwidth;
 823          off+=2L*TileCopy.w;
 824         }
 825
 826     if (TileCopy.PlanesCopied&IPLANE)
 827       for (j=0;j<newheight;j++)
 828         {
 829          XMSmove(xms1,off,0,(long)MK_FP(CutInfoPl,2L*(j*mapwidth)),2L*newwidth);
 830          ToOff+=2L*newwidth;
 831          off+=2L*TileCopy.w;
 832         }
 833
 834     TileCopy.x=TileCopy.y=0;
 835     TileCopy.w=newwidth;
 836     TileCopy.h=newheight;
 837
 838     XMSFreeMem(xms1);   // RELEASE THE MEMORY
 839    }
 840 }
 841
 842 ////////////////////////////////////////////////////
 843 //
 844 // SEE IF THERE'S AN INFO VALUES AT THE CURRENT POSITION
 845 // THAT NEEDS TO BE PRINTED
 846 //
 847 ////////////////////////////////////////////////////
 848 void CheckInfoValues(int i,int j,int tilei)
 849 {
 850  sx=i<<(tsize-1);
 851  sy=(j<<(tsize-1))+1;
 852
 853  if (TsearchMode)
 854    {
 855     unsigned loc,temp,p=0;
 856
 857     loc=(j+ybase)*mapwidth+i+xbase;
 858
 859     if (planeton)
 860       {
 861        if (MapBkgnd[loc]==whicht)
 862          {
 863           temp=whicht;
 864           p=1;
 865          }
 866       }
 867     else
 868     if (planemon)
 869       {
 870        if (MapFrgnd[loc]==whichtm-tilenum)
 871          {
 872           temp=whichtm-tilenum;
 873           p=1;
 874          }
 875       }
 876     else
 877     if (planeion)
 878       if ((unsigned)MapInfoPl[loc]==whichi-tilenum)
 879         {
 880          temp=whichi-tilenum;
 881          p=1;
 882         }
 883
 884     if (p)
 885       switch(tsize)
 886       {
 887        case 1:
 888          print("#");
 889          break;
 890        case 2:
 891          printhexb(temp>>8);
 892          sx-=2;
 893          sy++;
 894          printhexb(temp&0xff);
 895          break;
 896        case 3: printhex(temp);
 897       }
 898    }
 899  else
 900  if (viewion && tilei>lasticon)
 901    {
 902     switch(tsize)
 903     {
 904      case 1:
 905        print("#");
 906        break;
 907      case 2:
 908        printhexb(tilei-tilenum>>8);
 909        sx-=2;
 910        sy++;
 911        printhexb(tilei-tilenum&0xff);
 912        break;
 913      case 3: printhex(tilei-tilenum);
 914     }
 915    }
 916 }
 917
 918 ////////////////////////////////////////////////////
 919 //
 920 // Item - Edit Map Edges
 921 //
 922 ////////////////////////////////////////////////////
 923 btype MapEdgeB[]={{"\xb",7,3,1},
 924                   {"\xc",7,7,1},
 925                   {"\xe",4,5,1},
 926                   {"\x1f",10,5,1},
 927                   {" Exit ",5,16,2}};
 928 DialogDef MapEdgeD={"  PICK MAP EDGE\n"
 929                     "    TO CHANGE",
 930                     16,18,5,&MapEdgeB[0],NULL};
 931
 932 void Item_EditMapEdges(void)
 933 {
 934  int which,val,newwidth,newheight,b,f,i,
 935         _seg *tempB,_seg *tempF,_seg *tempI;
 936  unsigned dx,dy,obx,oby,k,j,modified=0;
 937  long size;
 938
 939  b=MapFileHeader->maptype&BPLANE;
 940  f=MapFileHeader->maptype&FPLANE;
 941  i=MapFileHeader->maptype&IPLANE;
 942
 943  DrawDialog(&MapEdgeD,1);
 944  GetDialogXY(&MapEdgeD,&dx,&dy);
 945  do
 946  {
 947   MouseHide();
 948   sx=dx+2;
 949   sy=dy+14;
 950   print("W:");
 951   printint(MapHeader.width);
 952   print(", H:");
 953   printint(MapHeader.height);
 954   print("   ");
 955   MouseShow();
 956
 957
 958   which=CheckButtons(&MapEdgeD);
 959   GetButtonXY(&MapEdgeD,which-1,&obx,&oby);
 960   MouseHide();
 961   if (which>=1 && which<=4)
 962     {
 963      // DRAW INPUT BAR
 964      sx=dx;
 965      sy=dy+9;
 966      print("+ or - value");
 967      DrawBorder(dx,dy+10,15,2,1);
 968
 969      // INPUT VALUE
 970      sx=dx+1;
 971      sy=dy+11;
 972      val=inputint(9);
 973
 974      // ERASE THE ARROW AND INPUT BAR
 975      sx=obx;
 976      sy=oby;
 977      print(MapEdgeB[which-1].text);
 978      bar(dx,dy+9,dx+15,dy+12,' ');
 979
 980      // CHECK FOR ESC
 981      if (val==(int)ESCOUT)
 982        which=6;
 983     }
 984
 985   MouseShow();
 986   switch(which)
 987   {
 988    //
 989    // ADD OR DELETE FROM TOP
 990    //
 991    case 1:
 992      newheight=mapheight+val;
 993      size=2L*newheight*mapwidth;
 994      if (size<=0 || size>0x10000L)
 995        {
 996         RestoreBackground();
 997         ErrDialog("Invalid Map height!"," OK ");
 998         return;
 999        }
1000
1001      // FREE UP SOME MEMORY!
1002      SaveCutBuffers();
1003      RemoveUndoBuffers();
1004
1005      if (b)
1006        {
1007         MMFreePtr((memptr *)&CutBkgnd);
1008         MMAllocate((memptr *)&tempB,size);
1009        }
1010      if (f)
1011        {
1012         MMFreePtr((memptr *)&CutFrgnd);
1013         MMAllocate((memptr *)&tempF,size);
1014        }
1015      if (i)
1016        {
1017         MMFreePtr((memptr *)&CutInfoPl);
1018         MMAllocate((memptr *)&tempI,size);
1019        }
1020
1021      if (val<0)
1022        {
1023         // COPY MAP PLANES INTO TEMP MEMORY (CLIPPED, HERE)
1024         for (j=abs(val);j<mapheight;j++)
1025           for (k=0;k<mapwidth;k++)
1026             {
1027              if (b)
1028                tempB[(j+val)*mapwidth+k]=MapBkgnd[j*mapwidth+k];
1029              if (f)
1030                tempF[(j+val)*mapwidth+k]=MapFrgnd[j*mapwidth+k];
1031              if (i)
1032                tempI[(j+val)*mapwidth+k]=MapInfoPl[j*mapwidth+k];
1033             }
1034        }
1035      else
1036        {
1037         for (j=0;j<mapheight+val;j++)
1038           for (k=0;k<mapwidth;k++)
1039             {
1040              if (j<abs(val))
1041                {
1042                 if (b)
1043                   tempB[j*mapwidth+k]=whicht;
1044                 if (f)
1045                   tempF[j*mapwidth+k]=whichtm-tilenum;
1046                 if (i)
1047                   tempI[j*mapwidth+k]=whichi-tilenum;
1048                }
1049              else
1050                {
1051                 if (b)
1052                   tempB[j*mapwidth+k]=MapBkgnd[(j-val)*mapwidth+k];
1053                 if (f)
1054                   tempF[j*mapwidth+k]=MapFrgnd[(j-val)*mapwidth+k];
1055                 if (i)
1056                   tempI[j*mapwidth+k]=MapInfoPl[(j-val)*mapwidth+k];
1057                }
1058             }
1059        }
1060
1061      // DEALLOCATE & REALLOCATE THE MAP BUFFERS, RESIZED
1062      if (b)
1063        {
1064         MMFreePtr((memptr *)&MapBkgnd);
1065         MMAllocate((memptr *)&MapBkgnd,size);
1066        }
1067      if (f)
1068        {
1069         MMFreePtr((memptr *)&MapFrgnd);
1070         MMAllocate((memptr *)&MapFrgnd,size);
1071        }
1072      if (i)
1073        {
1074         MMFreePtr((memptr *)&MapInfoPl);
1075         MMAllocate((memptr *)&MapInfoPl,size);
1076        }
1077
1078      // COPY THE REGION BACK IN...
1079      for (j=0;j<newheight;j++)
1080        for (k=0;k<mapwidth;k++)
1081          {
1082           if (b)
1083             MapBkgnd[j*mapwidth+k]=tempB[j*mapwidth+k];
1084           if (f)
1085             MapFrgnd[j*mapwidth+k]=tempF[j*mapwidth+k];
1086           if (i)
1087             MapInfoPl[j*mapwidth+k]=tempI[j*mapwidth+k];
1088          }
1089
1090      // TOAST THE 'TEMP' BUFFERS & REALLOCATE THE 'CUT' BUFFERS
1091      if (b)
1092        {
1093         MMFreePtr((memptr *)&tempB);
1094         MMAllocate((memptr *)&CutBkgnd,size);
1095        }
1096      if (f)
1097        {
1098         MMFreePtr((memptr *)&tempF);
1099         MMAllocate((memptr *)&CutFrgnd,size);
1100        }
1101      if (i)
1102        {
1103         MMFreePtr((memptr *)&tempI);
1104         MMAllocate((memptr *)&CutInfoPl,size);
1105        }
1106
1107      mapheight=newheight;
1108      MapHeader.height=newheight;
1109      modified=DirtyFlag=1;
1110      AllocateUndoBuffers();
1111      UndoRegion.x=-1;
1112      SaveUndo(0,0,mapwidth,mapheight);
1113      RestoreCutBuffers();
1114
1115      break;
1116
1117    //
1118    // ADD OR DELETE FROM BOTTOM
1119    //
1120    case 2:
1121      newheight=mapheight+val;
1122      size=2L*newheight*mapwidth;
1123      if (size<=0 || size>0x10000L)
1124        {
1125         RestoreBackground();
1126         ErrDialog("Invalid Map height!"," OK ");
1127         return;
1128        }
1129
1130      // FREE UP SOME MEMORY!
1131      SaveCutBuffers();
1132      RemoveUndoBuffers();
1133      if (b)
1134        {
1135         MMFreePtr((memptr *)&CutBkgnd);
1136         MMAllocate((memptr *)&tempB,size);
1137        }
1138      if (f)
1139        {
1140         MMFreePtr((memptr *)&CutFrgnd);
1141         MMAllocate((memptr *)&tempF,size);
1142        }
1143      if (i)
1144        {
1145         MMFreePtr((memptr *)&CutInfoPl);
1146         MMAllocate((memptr *)&tempI,size);
1147        }
1148
1149      if (val<0)
1150        {
1151         // COPY MAP PLANES INTO TEMP MEMORY (CLIPPED, HERE)
1152         for (j=0;j<mapheight+val;j++)
1153           for (k=0;k<mapwidth;k++)
1154             {
1155              if (b)
1156                tempB[j*mapwidth+k]=MapBkgnd[j*mapwidth+k];
1157              if (f)
1158                tempF[j*mapwidth+k]=MapFrgnd[j*mapwidth+k];
1159              if (i)
1160                tempI[j*mapwidth+k]=MapInfoPl[j*mapwidth+k];
1161             }
1162        }
1163      else
1164        {
1165         for (j=0;j<mapheight+val;j++)
1166           for (k=0;k<mapwidth;k++)
1167             {
1168              if (j>=mapheight)
1169                {
1170                 if (b)
1171                   tempB[j*mapwidth+k]=whicht;
1172                 if (f)
1173                   tempF[j*mapwidth+k]=whichtm-tilenum;
1174                 if (i)
1175                   tempI[j*mapwidth+k]=whichi-tilenum;
1176                }
1177              else
1178                {
1179                 if (b)
1180                   tempB[j*mapwidth+k]=MapBkgnd[j*mapwidth+k];
1181                 if (f)
1182                   tempF[j*mapwidth+k]=MapFrgnd[j*mapwidth+k];
1183                 if (i)
1184                   tempI[j*mapwidth+k]=MapInfoPl[j*mapwidth+k];
1185                }
1186             }
1187        }
1188
1189      // DEALLOCATE & REALLOCATE THE MAP BUFFERS, RESIZED
1190      if (b)
1191        {
1192         MMFreePtr((memptr *)&MapBkgnd);
1193         MMAllocate((memptr *)&MapBkgnd,size);
1194        }
1195      if (f)
1196        {
1197         MMFreePtr((memptr *)&MapFrgnd);
1198         MMAllocate((memptr *)&MapFrgnd,size);
1199        }
1200      if (i)
1201        {
1202         MMFreePtr((memptr *)&MapInfoPl);
1203         MMAllocate((memptr *)&MapInfoPl,size);
1204        }
1205
1206      // COPY THE REGION BACK IN...
1207      for (j=0;j<newheight;j++)
1208        for (k=0;k<mapwidth;k++)
1209          {
1210           if (b)
1211             MapBkgnd[j*mapwidth+k]=tempB[j*mapwidth+k];
1212           if (f)
1213             MapFrgnd[j*mapwidth+k]=tempF[j*mapwidth+k];
1214           if (i)
1215             MapInfoPl[j*mapwidth+k]=tempI[j*mapwidth+k];
1216          }
1217
1218      // TOAST THE 'TEMP' BUFFERS & REALLOCATE THE 'CUT' BUFFERS
1219      if (b)
1220        {
1221         MMFreePtr((memptr *)&tempB);
1222         MMAllocate((memptr *)&CutBkgnd,size);
1223        }
1224      if (f)
1225        {
1226         MMFreePtr((memptr *)&tempF);
1227         MMAllocate((memptr *)&CutFrgnd,size);
1228        }
1229      if (i)
1230        {
1231         MMFreePtr((memptr *)&tempI);
1232         MMAllocate((memptr *)&CutInfoPl,size);
1233        }
1234
1235      mapheight=newheight;
1236      MapHeader.height=newheight;
1237      modified=DirtyFlag=1;
1238      AllocateUndoBuffers();
1239      UndoRegion.x=-1;
1240      SaveUndo(0,0,mapwidth,mapheight);
1241      RestoreCutBuffers();
1242
1243      break;
1244
1245    //
1246    // ADD OR DELETE FROM LEFTEDGE
1247    //
1248    case 3:
1249      newwidth=mapwidth+val;
1250      size=2L*newwidth*mapheight;
1251      if (size<=0 || size>0x10000L)
1252        {
1253         RestoreBackground();
1254         ErrDialog("Invalid Map width!"," OK ");
1255         return;
1256        }
1257
1258      // FREE UP SOME MEMORY!
1259      SaveCutBuffers();
1260      RemoveUndoBuffers();
1261      if (b)
1262        {
1263         MMFreePtr((memptr *)&CutBkgnd);
1264         MMAllocate((memptr *)&tempB,size);
1265        }
1266      if (f)
1267        {
1268         MMFreePtr((memptr *)&CutFrgnd);
1269         MMAllocate((memptr *)&tempF,size);
1270        }
1271      if (i)
1272        {
1273         MMFreePtr((memptr *)&CutInfoPl);
1274         MMAllocate((memptr *)&tempI,size);
1275        }
1276
1277      if (val<0)
1278        {
1279         // COPY MAP PLANES INTO TEMP MEMORY (CLIPPED, HERE)
1280         for (j=0;j<mapheight;j++)
1281           for (k=abs(val);k<mapwidth;k++)
1282             {
1283              if (b)
1284                tempB[j*newwidth+k+val]=MapBkgnd[j*mapwidth+k];
1285              if (f)
1286                tempF[j*newwidth+k+val]=MapFrgnd[j*mapwidth+k];
1287              if (i)
1288                tempI[j*newwidth+k+val]=MapInfoPl[j*mapwidth+k];
1289             }
1290        }
1291      else
1292        {
1293         for (j=0;j<mapheight;j++)
1294           for (k=0;k<mapwidth+val;k++)
1295             {
1296              if (k<abs(val))
1297                {
1298                 if (b)
1299                   tempB[j*newwidth+k]=whicht;
1300                 if (f)
1301                   tempF[j*newwidth+k]=whichtm-tilenum;
1302                 if (i)
1303                   tempI[j*newwidth+k]=whichi-tilenum;
1304                }
1305              else
1306                {
1307                 if (b)
1308                   tempB[j*newwidth+k]=MapBkgnd[j*mapwidth+k-val];
1309                 if (f)
1310                   tempF[j*newwidth+k]=MapFrgnd[j*mapwidth+k-val];
1311                 if (i)
1312                   tempI[j*newwidth+k]=MapInfoPl[j*mapwidth+k-val];
1313                }
1314             }
1315        }
1316
1317      // DEALLOCATE & REALLOCATE THE MAP BUFFERS, RESIZED
1318      if (b)
1319        {
1320         MMFreePtr((memptr *)&MapBkgnd);
1321         MMAllocate((memptr *)&MapBkgnd,size);
1322        }
1323      if (f)
1324        {
1325         MMFreePtr((memptr *)&MapFrgnd);
1326         MMAllocate((memptr *)&MapFrgnd,size);
1327        }
1328      if (i)
1329        {
1330         MMFreePtr((memptr *)&MapInfoPl);
1331         MMAllocate((memptr *)&MapInfoPl,size);
1332        }
1333
1334      // COPY THE REGION BACK IN...
1335      for (j=0;j<mapheight;j++)
1336        for (k=0;k<newwidth;k++)
1337          {
1338           if (b)
1339             MapBkgnd[j*newwidth+k]=tempB[j*newwidth+k];
1340           if (f)
1341             MapFrgnd[j*newwidth+k]=tempF[j*newwidth+k];
1342           if (i)
1343             MapInfoPl[j*newwidth+k]=tempI[j*newwidth+k];
1344          }
1345
1346      // TOAST THE 'TEMP' BUFFERS & REALLOCATE THE 'CUT' BUFFERS
1347      if (b)
1348        {
1349         MMFreePtr((memptr *)&tempB);
1350         MMAllocate((memptr *)&CutBkgnd,size);
1351        }
1352      if (f)
1353        {
1354         MMFreePtr((memptr *)&tempF);
1355         MMAllocate((memptr *)&CutFrgnd,size);
1356        }
1357      if (i)
1358        {
1359         MMFreePtr((memptr *)&tempI);
1360         MMAllocate((memptr *)&CutInfoPl,size);
1361        }
1362
1363      mapwidth=newwidth;
1364      MapHeader.width=newwidth;
1365      modified=DirtyFlag=1;
1366      AllocateUndoBuffers();
1367      UndoRegion.x=-1;
1368      SaveUndo(0,0,mapwidth,mapheight);
1369      RestoreCutBuffers();
1370
1371      break;
1372
1373    //
1374    // ADD OR DELETE FROM RIGHTEDGE
1375    //
1376    case 4:
1377      newwidth=mapwidth+val;
1378      size=2L*newwidth*mapheight;
1379      if (size<=0 || size>0x10000L)
1380        {
1381         RestoreBackground();
1382         ErrDialog("Invalid Map width!"," OK ");
1383         return;
1384        }
1385
1386      // FREE UP SOME MEMORY!
1387      SaveCutBuffers();
1388      RemoveUndoBuffers();
1389      if (b)
1390        {
1391         MMFreePtr((memptr *)&CutBkgnd);
1392         MMAllocate((memptr *)&tempB,size);
1393        }
1394      if (f)
1395        {
1396         MMFreePtr((memptr *)&CutFrgnd);
1397         MMAllocate((memptr *)&tempF,size);
1398        }
1399      if (i)
1400        {
1401         MMFreePtr((memptr *)&CutInfoPl);
1402         MMAllocate((memptr *)&tempI,size);
1403        }
1404
1405      if (val<0)
1406        {
1407         // COPY MAP PLANES INTO TEMP MEMORY (CLIPPED, HERE)
1408         for (j=0;j<mapheight;j++)
1409           for (k=0;k<mapwidth+val;k++)
1410             {
1411              if (b)
1412                tempB[j*newwidth+k]=MapBkgnd[j*mapwidth+k];
1413              if (f)
1414                tempF[j*newwidth+k]=MapFrgnd[j*mapwidth+k];
1415              if (i)
1416                tempI[j*newwidth+k]=MapInfoPl[j*mapwidth+k];
1417             }
1418        }
1419      else
1420        {
1421         for (j=0;j<mapheight;j++)
1422           for (k=0;k<mapwidth+val;k++)
1423             {
1424              if (k>=mapwidth)
1425                {
1426                 if (b)
1427                   tempB[j*newwidth+k]=whicht;
1428                 if (f)
1429                   tempF[j*newwidth+k]=whichtm-tilenum;
1430                 if (i)
1431                   tempI[j*newwidth+k]=whichi-tilenum;
1432                }
1433              else
1434                {
1435                 if (b)
1436                   tempB[j*newwidth+k]=MapBkgnd[j*mapwidth+k];
1437                 if (f)
1438                   tempF[j*newwidth+k]=MapFrgnd[j*mapwidth+k];
1439                 if (i)
1440                   tempI[j*newwidth+k]=MapInfoPl[j*mapwidth+k];
1441                }
1442             }
1443        }
1444
1445      // DEALLOCATE & REALLOCATE THE MAP BUFFERS, RESIZED
1446      if (b)
1447        {
1448         MMFreePtr((memptr *)&MapBkgnd);
1449         MMAllocate((memptr *)&MapBkgnd,size);
1450        }
1451      if (f)
1452        {
1453         MMFreePtr((memptr *)&MapFrgnd);
1454         MMAllocate((memptr *)&MapFrgnd,size);
1455        }
1456      if (i)
1457        {
1458         MMFreePtr((memptr *)&MapInfoPl);
1459         MMAllocate((memptr *)&MapInfoPl,size);
1460        }
1461
1462      // COPY THE REGION BACK IN...
1463      for (j=0;j<mapheight;j++)
1464        for (k=0;k<newwidth;k++)
1465          {
1466           if (b)
1467             MapBkgnd[j*newwidth+k]=tempB[j*newwidth+k];
1468           if (f)
1469             MapFrgnd[j*newwidth+k]=tempF[j*newwidth+k];
1470           if (i)
1471             MapInfoPl[j*newwidth+k]=tempI[j*newwidth+k];
1472          }
1473
1474      // TOAST THE 'TEMP' BUFFERS & REALLOCATE THE 'CUT' BUFFERS
1475      if (b)
1476        {
1477         MMFreePtr((memptr *)&tempB);
1478         MMAllocate((memptr *)&CutBkgnd,size);
1479        }
1480      if (f)
1481        {
1482         MMFreePtr((memptr *)&tempF);
1483         MMAllocate((memptr *)&CutFrgnd,size);
1484        }
1485      if (i)
1486        {
1487         MMFreePtr((memptr *)&tempI);
1488         MMAllocate((memptr *)&CutInfoPl,size);
1489        }
1490
1491      mapwidth=newwidth;
1492      MapHeader.width=newwidth;
1493      modified=DirtyFlag=1;
1494      AllocateUndoBuffers();
1495      UndoRegion.x=-1;
1496      SaveUndo(0,0,mapwidth,mapheight);
1497      RestoreCutBuffers();
1498      break;
1499   }
1500  } while(which && which!=5);
1501  RestoreBackground();
1502  if (modified)
1503    {
1504     xbase=ybase=0;
1505     MouseHide();
1506     InitDesktop(TED5MenuBar,0);
1507     DrawInfoBar();
1508     DrawMap();
1509     MouseShow();
1510    }
1511 }
1512
1513
1514 ////////////////////////////////////////////////////
1515 //
1516 // Display amount of memory available
1517 //
1518 ////////////////////////////////////////////////////
1519 btype     ShowMemb={" OK ",6,11,2};
1520 DialogDef ShowMemd={"Extended Memory \n"
1521                     "Available:\n\n"
1522                     "Main Memory\n"
1523                     "Available:\n\n"
1524                     "In Extended Mem\n"
1525                     "----------------\n"
1526                     "CGA:     EGA:\n"
1527                     "VGA:    Maps:"
1528                     ,16,13,1,&ShowMemb,PrintMem};
1529
1530 void Item_PrintMem(void)
1531 {
1532  DoDialog(&ShowMemd);
1533 }
1534
1535 void PrintMem(int x,int y)
1536 {
1537  long total;
1538  char memstring[10];
1539
1540  sx=x+10;
1541  sy=y+1;
1542  itoa(XMSTotalFree(),memstring,10);
1543  strcat(memstring,"K");
1544  print(memstring);
1545
1546  sx=x+10;
1547  sy=y+4;
1548  total=(MMTotalFree()*16L)/1024;
1549  ltoa(total,memstring,10);
1550  strcat(memstring,"K");
1551  print(memstring);
1552
1553  sx=x+4;
1554  sy=y+8;
1555  if (!CgaXMS)
1556    print("No");
1557  else
1558    print("Yes");
1559
1560  sx=x+13;
1561  sy=y+8;
1562  if (!EgaXMS)
1563    print("No");
1564  else
1565    print("Yes");
1566
1567  sx=x+4;
1568  sy=y+9;
1569  if (!VgaXMS)
1570    print("No");
1571  else
1572    print("Yes");
1573
1574
1575  sx=x+13;
1576  sy=y+9;
1577  if (!XMSmaps)
1578    print("No");
1579  else
1580    print("Yes");
1581 }
1582
1583
1584 ////////////////////////////////////////////////////
1585 //
1586 // CARMACIZE THE MAP FILE!
1587 //
1588 ////////////////////////////////////////////////////
1589 void Item_Huffman(void)
1590 {
1591  OutputHeadStr NewFileHeader;
1592  char huffname[14]="GAMEMAPS.",huffheadname[14]="MAPSHEAD.",tempstr[200],
1593         mapidstr[8]=IDSTRING,objname[14],dictname[14],tempname[14];
1594  int dx,dy,i,oxb,oyb,maplengths[100];
1595  MapHeaderStr TempHeader;
1596  memptr block,block1,block2;
1597  long size,fsize,nsize;
1598
1599
1600  Item_SaveMap();
1601
1602  strcat(huffname,ext);
1603  strcat(huffheadname,ext);
1604  strcpy(tempstr,"This will take a while.\n");
1605  strcat(tempstr,huffname);
1606  strcat(tempstr,". [               ]");
1607  ErrDialog(tempstr,"");
1608  dy=sy;
1609  dx=sx-16;
1610
1611  oxb=xbase;
1612  oyb=ybase;
1613  //
1614  // Free up memory
1615  //
1616  if (MapBkgnd)
1617    {
1618     MMFreePtr((memptr *)&MapBkgnd);
1619     MMFreePtr((memptr *)&CutBkgnd);
1620    }
1621  if (MapFrgnd)
1622    {
1623     MMFreePtr((memptr *)&MapFrgnd);
1624     MMFreePtr((memptr *)&CutFrgnd);
1625    }
1626  if (MapInfoPl)
1627    {
1628     MMFreePtr((memptr *)&MapInfoPl);
1629     MMFreePtr((memptr *)&CutInfoPl);
1630    }
1631
1632  //
1633  // Now, time to Carmacize all the maps
1634  //
1635  sx=dx;
1636  sy=dy;
1637  print("Carmacizing");
1638  dx=sx+1;
1639
1640  fsize=0;
1641  SaveFile(huffname,(char huge *)&mapidstr,fsize,strlen(mapidstr));
1642  fsize+=strlen(mapidstr);
1643
1644  memset(&maplengths,0,sizeof(long)*100);
1645  memset(&NewFileHeader,0,sizeof(OutputHeadStr));
1646  MMAllocate(&block1,sizeof(MapHeaderStr));
1647  for (i=0;i<100;i++)
1648    if (MapFileHeader->dataoffsets[i]!=-1)
1649      {
1650       //
1651       // LOAD MAP HEADER
1652       //
1653       sx=dx;
1654       printint(i);
1655       LoadFile(mapname,(char huge *)&TempHeader,MapFileHeader->dataoffsets[i],sizeof(MapHeaderStr));
1656
1657       //
1658       // COMPRESS EACH MAP PLANE
1659       //
1660       #pragma warn -sus
1661       if (MapFileHeader->maptype&BPLANE)
1662         {
1663          size=TempHeader.mapbkgndlen;
1664          MMAllocate(&block,size);
1665          MMAllocate(&block2,size);
1666          LoadFile(mapname,block,TempHeader.mapbkgndpl,size);
1667          *(int _seg *)block2=TempHeader.mapbkgndlen;
1668          nsize=CarmackCompress((unsigned  char huge *)block,size,(unsigned char huge *)block2+2)+2;
1669          maplengths[i]+=nsize;
1670          if (nsize==2)
1671          {
1672           RestoreBackground();
1673           MMFreePtr(&block2);
1674           MMFreePtr(&block);
1675           MMFreePtr(&block1);
1676           LoadMap(whichmap);
1677           xbase=oxb;
1678           ybase=oyb;
1679           ErrDialog("ESC out of this infernal thing!"," YES! ");
1680           return;
1681          }
1682
1683          SaveFile(huffname,block2,fsize,nsize);
1684          TempHeader.mapbkgndpl=fsize;
1685          TempHeader.mapbkgndlen=nsize;
1686          MMFreePtr(&block2);
1687          MMFreePtr(&block);
1688          fsize+=nsize;
1689         }
1690       if (MapFileHeader->maptype&FPLANE)
1691         {
1692          size=TempHeader.mapfrgndlen;
1693          MMAllocate(&block,size);
1694          MMAllocate(&block2,size);
1695          LoadFile(mapname,block,TempHeader.mapfrgndpl,size);
1696          *(int _seg *)block2=TempHeader.mapfrgndlen;
1697          nsize=CarmackCompress((unsigned  char huge *)block,size,(unsigned  char huge *)block2+2)+2;
1698          maplengths[i]+=nsize;
1699          if (nsize==2)
1700          {
1701           RestoreBackground();
1702           MMFreePtr(&block2);
1703           MMFreePtr(&block);
1704           MMFreePtr(&block1);
1705           LoadMap(whichmap);
1706           xbase=oxb;
1707           ybase=oyb;
1708           ErrDialog("ESC out of this infernal thing!"," YES! ");
1709           return;
1710          }
1711
1712          SaveFile(huffname,block2,fsize,nsize);
1713          TempHeader.mapfrgndpl=fsize;
1714          TempHeader.mapfrgndlen=nsize;
1715          MMFreePtr(&block2);
1716          MMFreePtr(&block);
1717          fsize+=nsize;
1718         }
1719       if (MapFileHeader->maptype&IPLANE)
1720         {
1721          size=TempHeader.mapinfolen;
1722          MMAllocate(&block,size);
1723          MMAllocate(&block2,size);
1724          LoadFile(mapname,block,TempHeader.mapinfopl,size);
1725          *(int _seg *)block2=TempHeader.mapinfolen;
1726          nsize=CarmackCompress((unsigned  char huge *)block,size,(unsigned  char huge *)block2+2)+2;
1727          maplengths[i]+=nsize;
1728          if (nsize==2)
1729          {
1730           RestoreBackground();
1731           MMFreePtr(&block2);
1732           MMFreePtr(&block);
1733           MMFreePtr(&block1);
1734           LoadMap(whichmap);
1735           xbase=oxb;
1736           ybase=oyb;
1737           ErrDialog("ESC out of this infernal thing!"," YES! ");
1738           return;
1739          }
1740
1741          SaveFile(huffname,block2,fsize,nsize);
1742          TempHeader.mapinfopl=fsize;
1743          TempHeader.mapinfolen=nsize;
1744          MMFreePtr(&block2);
1745          MMFreePtr(&block);
1746          fsize+=nsize;
1747         }
1748       #pragma warn +sus
1749
1750       //
1751       // SAVE MAP HEADER
1752       //
1753       nsize=sizeof(TempHeader);
1754       maplengths[i]+=nsize;
1755       SaveFile(huffname,(char huge *)&TempHeader,fsize,nsize);
1756       NewFileHeader.dataoffsets[i]=fsize;
1757       fsize+=nsize;
1758
1759       SaveFile(huffname,"!ID!",fsize,4);
1760       fsize+=4;
1761      }
1762  MMFreePtr(&block1);
1763
1764
1765  //
1766  // COPY PERTINENT MAPFILEHEADER DATA TO NEWFILEHEADER
1767  //
1768  {
1769   char outname[14],tempname[14]="MTEMP.TMP",doutname[14];
1770
1771
1772   strcpy(outname,ext);
1773   strcat(outname,"MHEAD.OBJ");
1774
1775   NewFileHeader.RLEWtag=MapFileHeader->RLEWtag;
1776   fsize=sizeof(OutputHeadStr);
1777   SaveFile(tempname,(char huge *)&NewFileHeader,0,fsize);
1778
1779   for (i=0;i<numtplanes;i++)
1780         {
1781          SaveFile(tempname,MK_FP(Tinfo[i],0),fsize,tilenum);
1782          fsize+=tilenum;
1783         }
1784   for (i=0;i<numtmplanes;i++)
1785         {
1786          SaveFile(tempname,MK_FP(TMinfo[i],0),fsize,tilemnum);
1787          fsize+=tilemnum;
1788         }
1789
1790   MakeOBJ(tempname,outname,"_maphead",FARDATA,"MapHeader");
1791 //  unlink(tempname);
1792  }
1793
1794  RestoreBackground();
1795  SignalSound();
1796
1797  //
1798  // FINSIHED. PRINT REPORT?
1799  //
1800  if (Message("Finished with compression.\n"
1801              "Print report on lengths?")==2)
1802  {
1803   fprintf(stdprn,"TED5 Carmacized Map Lengths for .%s\n\n",ext);
1804   fprintf(stdprn,"#\tMap Name\t\tLength\n");
1805   fprintf(stdprn,"_\t--------\t\t------\n");
1806   for (i=0;i<100;i++)
1807     if (MapFileHeader->dataoffsets[i]!=-1)
1808     {
1809      char tstr[16];
1810      strcpy(tstr,MapNames[i]);
1811      while(strlen(tstr)<16)
1812        strcat(tstr," ");
1813      fprintf(stdprn,"%d\t%s\t%d\n",i,tstr,maplengths[i]);
1814     }
1815   fprintf(stdprn,"%c",12);
1816  }
1817
1818  LoadMap(whichmap);
1819  xbase=oxb;
1820  ybase=oyb;
1821 }
1822
1823
1824 ////////////////////////////////////////////////////
1825 //
1826 // Item - Change the LAUNCH name
1827 //
1828 ////////////////////////////////////////////////////
1829 btype CLNb={"                                    ",1,5,1};
1830 DialogDef CLNd={"Current LAUNCH name:\n\n\nNew LAUNCH name:",38,7,1,&CLNb,NULL};
1831
1832 void Item_LAUNCHname(void)
1833 {
1834  char tempstr[40];
1835
1836
1837  MouseHide();
1838  DrawDialog(&CLNd,1);
1839  GetDialogXY(&CLNd,&sx,&sy);
1840  sy++;
1841  sx++;
1842  print(launchname);
1843  GetButtonXY(&CLNd,0,&sx,&sy);
1844  if (input(tempstr,36))
1845  {
1846   strcpy(launchname,tempstr);
1847   SaveTEDInfo();
1848  }
1849  MouseShow();
1850  RestoreBackground();
1851 }
1852
1853
1854 ////////////////////////////////////////////////////
1855 //
1856 // Item - Change the PARM string
1857 //
1858 ////////////////////////////////////////////////////
1859 btype CPSb={"                                    ",1,5,1};
1860 DialogDef CPSd={"Current PARM string:\n\n\nNew PARM string:",38,7,1,&CPSb,NULL};
1861
1862 void Item_PARMstring(void)
1863 {
1864  char tempstr[40];
1865
1866
1867  MouseHide();
1868  DrawDialog(&CPSd,1);
1869  GetDialogXY(&CPSd,&sx,&sy);
1870  sy++;
1871  sx++;
1872  print(parmstring);
1873  GetButtonXY(&CPSd,0,&sx,&sy);
1874  if (input(tempstr,36))
1875  {
1876   strcpy(parmstring,tempstr);
1877   _fstrcpy(TEDInfo->parmstring,(char far *)parmstring);
1878   SaveTEDInfo();
1879  }
1880  MouseShow();
1881  RestoreBackground();
1882 }
1883
1884
1885 ////////////////////////////////////////////////////
1886 //
1887 // Item - Change Icon Rows
1888 //
1889 ////////////////////////////////////////////////////
1890 btype CIRb={"    ",8,4,1};
1891 DialogDef CIRd={"Enter amount of icons\n"
1892                 "to add/delete.\n"
1893                 "Use + or -.",22,6,1,&CIRb,NULL};
1894
1895 void Item_ChangeIconRows(void)
1896 {
1897  unsigned i,j,dx,dy,max,oxbase,oybase,base;
1898  int value,owm;
1899  memptr block;
1900
1901
1902  if (!(MapFileHeader->maptype&IPLANE))
1903  {
1904   ErrDialog("You don't have an icon plane!"," OK ");
1905   return;
1906  }
1907
1908  CheckForMapSave();
1909
1910  oxbase=xbase;
1911  oybase=ybase;
1912
1913  DrawDialog(&CIRd,1);
1914  GetButtonXY(&CIRd,0,&dx,&dy);
1915  sx=dx;
1916  sy=dy;
1917  MouseHide();
1918  value=inputint(3);
1919  MouseShow();
1920  if (!value || value==(int)ESCOUT)
1921  {
1922   RestoreBackground();
1923   return;
1924  }
1925
1926  value=SGN(value)*(18*((abs(value)+17)/18));
1927
1928  base=18*maxiconrows;
1929  maxiconrows+=value/18;
1930  MapFileHeader->NumIconRows+=value/18;
1931
1932  owm=whichmap;
1933  RestoreBackground();
1934
1935
1936  //
1937  // MAKE SURE WE ADJUST TILEINFOM!
1938  //
1939  MMAllocate(&block,tilemnum+value);
1940  for (i=0;i<numtmplanes;i++)
1941  {
1942   _fmemset(block,0,tilemnum+value);
1943   movedata((unsigned)TMinfo[i],0,(unsigned)block,0,base);
1944   movedata((unsigned)TMinfo[i],base,
1945            (unsigned)block,base+value,tilemnum-base);
1946   MMFreePtr((memptr *)&TMinfo[i]);
1947   MMAllocate((memptr *)&TMinfo[i],tilemnum+value);
1948   movedata((unsigned)block,0,(unsigned)TMinfo[i],0,tilemnum+value);
1949  }
1950  MMFreePtr(&block);
1951  MapFileHeader->oldtilemnum=tilemnum+value;
1952
1953
1954  //
1955  // RUN THROUGH EACH MAP AND ADJUST TILEM VALUES
1956  //
1957  for (i=0;i<100;i++)
1958    if (MapFileHeader->dataoffsets[i]>=0)
1959      {
1960       whichmap=i;
1961       LoadMap(i);
1962       max=mapwidth*mapheight;
1963       for (j=0;j<max;j++)
1964         if (MapFrgnd[j]>0)
1965           MapFrgnd[j]+=value;
1966       DirtyFlag=1;
1967       SaveMap(0);
1968      }
1969
1970  DirtyFlag=0;
1971  whichmap=owm;
1972  LoadMap(whichmap);
1973  xbase=oxbase;
1974  ybase=oybase;
1975  DrawMap();
1976  ErrDialog("If your map looks messed up,\n"
1977            "you need to change the amount\n"
1978            "of icons in your IGRAB script\n"
1979            "and re-grab your tiles!"," OK ");
1980 }
1981
1982
1983 ////////////////////////////////////////////////////
1984 //
1985 // Item - Change LAUNCH Icon
1986 //
1987 ////////////////////////////////////////////////////
1988 void Item_ChangeLaunchIcon(void)
1989 {
1990  sound(1700);
1991  TEDInfo->permicon=whichi-tilenum;
1992  delay(30);
1993  nosound();
1994 }
1995
1996
1997 ////////////////////////////////////////////////////
1998 //
1999 // Item - Change Background color
2000 //
2001 ////////////////////////////////////////////////////
2002 btype CBCb[]={{"\xb",5,2,1},
2003               {"\xc",16,2,1},
2004               {"Exit",9,2,2}};
2005 DialogDef CBCd={"Change Backgrnd Color!",22,4,3,&CBCb[0],0};
2006 void Item_ChangeBkgndColor(void)
2007 {
2008  int which;
2009
2010  do
2011  {
2012   which=DoDialog(&CBCd);
2013   switch(which)
2014   {
2015    case 1:
2016      sound(1700);
2017      if (--BkgndColor<0)
2018        BkgndColor=15;
2019      TEDInfo->BackgndColor=BkgndColor;
2020      DrawMap();
2021      DrawInfoBar();
2022      break;
2023    case 2:
2024      sound(1700);
2025      if (++BkgndColor>15)
2026        BkgndColor=0;
2027      TEDInfo->BackgndColor=BkgndColor;
2028      DrawMap();
2029      DrawInfoBar();
2030   }
2031   nosound();
2032  } while(which>0 && which<3);
2033 }