X-Git-Url: http://4ch.mooo.com/gitweb/?p=16.git;a=blobdiff_plain;f=16%2Fted5%2FTED5-3.C;fp=16%2Fted5%2FTED5-3.C;h=f41aa23b8af66628021bd4c41c751fd931762c60;hp=0000000000000000000000000000000000000000;hb=4c15d088479b9b6c4a8b298a9db585bc11582321;hpb=21ff8e5607ba86e91ed0d71f6261fd0fcc676e16

diff --git a/16/ted5/TED5-3.C b/16/ted5/TED5-3.C
new file mode 100755
index 00000000..f41aa23b
--- /dev/null
+++ b/16/ted5/TED5-3.C
@@ -0,0 +1,2033 @@
+////////////////////////////////////////////////////
+////////////////////////////////////////////////////
+//
+// TED5-3
+//
+////////////////////////////////////////////////////
+////////////////////////////////////////////////////
+#include "ted5.h"
+#pragma hdrstop
+
+int xms1;
+extern int tics;
+
+////////////////////////////////////////////////////
+//
+// MAP SCROLLING
+//
+////////////////////////////////////////////////////
+void CheckMapScroll(void)
+{
+ //
+ // LEFT
+ //
+ if (keydown[0x4b])	// left arrow
+   {
+    int i,j,imax,jmax,tilesmoved;
+
+    tics=biostime(0,0);
+
+    if (xbase)
+    {
+     EraseFloatPaste();
+
+     if (keydown[0x1d])	// CTRL-KEY
+     {
+      tilesmoved=screenw;
+      if (keydown[0x38]) // ALT-KEY
+      {
+       xbase=0;
+       DrawMap();
+       return;
+      }
+     }
+     else
+       switch(videomode)
+       {
+	case CGA:
+	case EGA1:
+	case VGA:
+	  tilesmoved=1;
+	  break;
+	case EGA2:
+	  tilesmoved=2;
+       }
+
+     if (xbase<tilesmoved)
+       tilesmoved=xbase;
+     xbase-=tilesmoved;
+
+     MouseHide();
+     if (tilesmoved<screenw)
+       CopyScreen(0,8,infomaxw-(tilesmoved<<(tsize-1)),screenh<<(tsize+2),tilesmoved<<(tsize-1),8);
+
+     jmax=screenh;
+     if (jmax>mapheight)
+       jmax=mapheight;
+
+     for (i=0;i<tilesmoved;i++)
+       for (j=0;j<jmax;j++)
+       {
+	unsigned tilet,tilem,tilei,loc;
+
+	loc=(ybase+j)*mapwidth+xbase+i;
+
+	tilet=*(MapBkgnd+loc);
+	tilem=*(MapFrgnd+loc)+tilenum;
+	tilei=*(MapInfoPl+loc)+tilenum;
+
+	CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
+	if (GridMode)
+	  Overlay(tsize);
+	DrawTile(i<<(tsize-1),j*(4<<tsize)+8,tsize);
+	CheckInfoValues(i,j,tilei);
+	CheckSelectEdges(i+xbase,j+ybase,i,j);
+       }
+
+     px+=tilesmoved;
+     DrawFloatPaste();
+     MouseShow();
+     if (keydown[0x36] || keydown[0x1d])
+       while(keydown[0x4b]);
+    }
+   }
+ else
+ //
+ // RIGHT
+ //
+ if (keydown[0x4d])	// right arrow
+   {
+    int i,j,imax,jmax,tilesmoved;
+
+    tics=biostime(0,0);
+
+    if (xbase+screenw<mapwidth)
+    {
+     EraseFloatPaste();
+
+     if (keydown[0x1d])	// CTRL-KEY
+     {
+      tilesmoved=screenw;
+      if (keydown[0x38]) // ALT-KEY
+      {
+       xbase=mapwidth-screenw;
+       DrawMap();
+       return;
+      }
+     }
+     else
+       switch(videomode)
+       {
+	case CGA:
+	case EGA1:
+	case VGA:
+	  tilesmoved=1;
+	  break;
+	case EGA2:
+	  tilesmoved=2;
+       }
+
+
+     if (xbase+screenw+tilesmoved>=mapwidth)
+       tilesmoved=mapwidth-screenw-xbase;
+     xbase+=tilesmoved;
+
+     MouseHide();
+     if (tilesmoved<screenw)
+       CopyScreen(tilesmoved<<(tsize-1),8,infomaxw-(tilesmoved<<(tsize-1)),screenh<<(tsize+2),0,8);
+
+     jmax=screenh;
+     if (jmax>mapheight)
+       jmax=mapheight;
+
+     for (i=0;i<tilesmoved;i++)
+       for (j=0;j<jmax;j++)
+       {
+	unsigned tilet,tilem,tilei,loc;
+
+	loc=(ybase+j)*mapwidth+xbase+screenw-tilesmoved+i;
+
+	tilet=*(MapBkgnd+loc);
+	tilem=*(MapFrgnd+loc)+tilenum;
+	tilei=*(MapInfoPl+loc)+tilenum;
+
+	CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
+	if (GridMode)
+	  Overlay(tsize);
+	DrawTile(infomaxw-((tilesmoved-i)<<(tsize-1)),j*(4<<tsize)+8,tsize);
+	CheckInfoValues(screenw-tilesmoved+i,j,tilei);
+	CheckSelectEdges(screenw-tilesmoved+i+xbase,j+ybase,i+screenw-tilesmoved,j);
+       }
+
+     px+=tilesmoved;
+     DrawFloatPaste();
+     MouseShow();
+     if (keydown[0x36] || keydown[0x1d])
+       while(keydown[0x4d]);
+    }
+   }
+
+ //
+ // UP
+ //
+ if (keydown[0x48])	// up arrow
+   {
+    int i,j,imax,jmax,tilesmoved;
+
+    tics=biostime(0,0);
+
+    if (ybase)
+    {
+     EraseFloatPaste();
+
+     if (keydown[0x1d])	// CTRL-KEY
+     {
+      tilesmoved=screenh;
+      if (keydown[0x38]) // ALT-KEY
+      {
+       ybase=0;
+       DrawMap();
+       return;
+      }
+     }
+     else
+       switch(videomode)
+       {
+	case CGA:
+	case EGA1:
+	case VGA:
+	  tilesmoved=1;
+	  break;
+	case EGA2:
+	  tilesmoved=2;
+       }
+
+     if (ybase<tilesmoved)
+       tilesmoved=ybase;
+     ybase-=tilesmoved;
+
+     MouseHide();
+     if (tilesmoved<screenh)
+       CopyScreen(0,8,infomaxw,(screenh-tilesmoved)<<(tsize+2),0,8+(tilesmoved<<(tsize+2)));
+
+     imax=screenw;
+     if (imax>mapwidth)
+       imax=mapwidth;
+
+     for (j=0;j<tilesmoved;j++)
+       for (i=0;i<imax;i++)
+       {
+	unsigned tilet,tilem,tilei,loc;
+
+	loc=(ybase+j)*mapwidth+xbase+i;
+
+	tilet=*(MapBkgnd+loc);
+	tilem=*(MapFrgnd+loc)+tilenum;
+	tilei=*(MapInfoPl+loc)+tilenum;
+
+	CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
+	if (GridMode)
+	  Overlay(tsize);
+	DrawTile(i<<(tsize-1),8+(j<<(tsize+2)),tsize);
+	CheckInfoValues(i,j,tilei);
+	CheckSelectEdges(i+xbase,j+ybase,i,j);
+       }
+
+     py+=tilesmoved;
+     DrawFloatPaste();
+     MouseShow();
+     if (keydown[0x36] || keydown[0x1d])
+       while(keydown[0x48]);
+    }
+   }
+ else
+ //
+ // DOWN
+ //
+ if (keydown[0x50])	// down arrow
+   {
+    int i,j,imax,jmax,tilesmoved;
+
+    tics=biostime(0,0);
+
+    if (ybase+screenh<mapheight)
+    {
+     EraseFloatPaste();
+
+     if (keydown[0x1d])	// CTRL-KEY
+     {
+      tilesmoved=screenh;
+      if (keydown[0x38]) // ALT-KEY
+      {
+       ybase=mapheight-screenh;
+       DrawMap();
+       return;
+      }
+     }
+     else
+       switch(videomode)
+       {
+	case CGA:
+	case EGA1:
+	case VGA:
+	  tilesmoved=1;
+	  break;
+	case EGA2:
+	  tilesmoved=2;
+       }
+
+     if (ybase+screenh+tilesmoved>=mapheight)
+       tilesmoved=mapheight-screenh-ybase;
+     ybase+=tilesmoved;
+
+     MouseHide();
+     if (tilesmoved<screenh)
+       CopyScreen(0,8+(tilesmoved<<(tsize+2)),infomaxw,(screenh-tilesmoved)<<(tsize+2),0,8);
+
+     imax=screenw;
+     if (imax>mapwidth)
+       imax=mapwidth;
+
+     for (j=0;j<tilesmoved;j++)
+       for (i=0;i<imax;i++)
+       {
+	unsigned tilet,tilem,tilei,loc;
+
+	loc=(ybase+j+screenh-tilesmoved)*mapwidth+xbase+i;
+
+	tilet=*(MapBkgnd+loc);
+	tilem=*(MapFrgnd+loc)+tilenum;
+	tilei=*(MapInfoPl+loc)+tilenum;
+
+	CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
+	if (GridMode)
+	  Overlay(tsize);
+	DrawTile(i<<(tsize-1),8+((screenh-tilesmoved+j)<<(tsize+2)),tsize);
+	CheckInfoValues(i,screenh-tilesmoved+j,tilei);
+	CheckSelectEdges(i+xbase,screenh-tilesmoved+j+ybase,i,j+screenh-tilesmoved);
+       }
+
+
+     py+=tilesmoved;
+     DrawFloatPaste();
+     MouseShow();
+     if (keydown[0x36] || keydown[0x1d])
+       while(keydown[0x50]);
+    }
+   }
+}
+
+
+////////////////////////////////////////////////////
+//
+// Copy a screen section to another, mode independent
+//
+////////////////////////////////////////////////////
+void CopyScreen(int srcx,int srcy,int width,int height,int destx,int desty)
+{
+ switch(videomode)
+ {
+  case CGA: CopyCGA(srcx,srcy,width,height,destx,desty); break;
+  case EGA1:
+  case EGA2:outport(SCindex,0x0f00 | SCmapmask);CopyEGA(srcx,srcy,width,height,destx,desty); break;
+  case VGA: CopyVGA(srcx,srcy,width,height,destx,desty);
+ }
+}
+
+
+////////////////////////////////////////////////////
+//
+// See if either of the Select edges are visible on the map
+// Draw them if so
+//
+////////////////////////////////////////////////////
+void CheckSelectEdges(int x,int y,int i,int j)
+{
+ int temp;
+
+ if (SelX2<SelX1)
+   {
+    temp=SelX1;
+    SelX1=SelX2;
+    SelX2=temp;
+   }
+ if (SelY2<SelY1)
+   {
+    temp=SelY1;
+    SelY1=SelY2;
+    SelY2=temp;
+   }
+
+ if (y==SelY2 && x==SelX2)
+   {
+    switch(tsize)
+    {
+     case 1: drawchar(i,j+1,8);
+	     break;
+     case 2: drawchar(i*2+1,j*2+2,8);
+	     drawchar(i*2+1,j*2+1,5);
+	     drawchar(i*2,j*2+2,7);
+	     break;
+     case 3: drawchar(i*4+3,j*4+4,8);
+
+	     drawchar(i*4+3,j*4+3,5);
+	     drawchar(i*4+3,j*4+2,5);
+	     drawchar(i*4+3,j*4+1,5);
+
+	     drawchar(i*4+2,j*4+4,7);
+	     drawchar(i*4+1,j*4+4,7);
+	     drawchar(i*4,j*4+4,7);
+	     break;
+    }
+   }
+
+ if (y==SelY1 && x==SelX1)
+   {
+    switch(tsize)
+    {
+     case 1: drawchar(i,j+1,1);
+	     break;
+     case 2: drawchar(i*2,j*2+1,1);
+	     drawchar(i*2+1,j*2+1,2);
+	     drawchar(i*2,j*2+2,4);
+	     break;
+     case 3: drawchar(i*4,j*4+1,1);
+
+	     drawchar(i*4+1,j*4+1,2);
+	     drawchar(i*4+2,j*4+1,2);
+	     drawchar(i*4+3,j*4+1,2);
+
+	     drawchar(i*4,j*4+2,4);
+	     drawchar(i*4,j*4+3,4);
+	     drawchar(i*4,j*4+4,4);
+	     break;
+    }
+   }
+
+ if (y==SelY2 && x==SelX1)
+   {
+    switch(tsize)
+    {
+     case 1: drawchar(i,j+1,6);
+	     break;
+     case 2: drawchar(i*2  ,j*2+2,6);
+	     drawchar(i*2+1,j*2+2,7);
+	     drawchar(i*2  ,j*2+1,4);
+	     break;
+     case 3: drawchar(i*4,j*4+4,6);
+
+	     drawchar(i*4+1,j*4+4,7);
+	     drawchar(i*4+2,j*4+4,7);
+	     drawchar(i*4+3,j*4+4,7);
+
+	     drawchar(i*4,j*4+1,4);
+	     drawchar(i*4,j*4+2,4);
+	     drawchar(i*4,j*4+3,4);
+	     break;
+    }
+   }
+
+ if (y==SelY1 && x==SelX2)
+   {
+    switch(tsize)
+    {
+     case 1: drawchar(i,j+1,3);
+	     break;
+     case 2: drawchar(i*2+1,j*2+1,3);
+	     drawchar(i*2+1,j*2+2,5);
+	     drawchar(i*2  ,j*2+1,2);
+	     break;
+     case 3: drawchar(i*4+3,j*4+1,3);
+
+	     drawchar(i*4+3,j*4+4,5);
+	     drawchar(i*4+3,j*4+3,5);
+	     drawchar(i*4+3,j*4+2,5);
+
+	     drawchar(i*4+2,j*4+4,7);
+	     drawchar(i*4+1,j*4+4,7);
+	     drawchar(i*4,j*4+4,7);
+	     break;
+    }
+   }
+
+ if (y==SelY1 && x>SelX1 && x<SelX2)
+   {
+    switch(tsize)
+    {
+     case 3: drawchar(i*4+2,j*4+1,2);
+	     drawchar(i*4+3,j*4+1,2);
+	     drawchar(i*4+1,j*4+1,2);
+	     drawchar(i*4  ,j*4+1,2);
+	     break;
+     case 2: drawchar(i*2+1,j*2+1,2);
+	     drawchar(i*2  ,j*2+1,2);
+	     break;
+     case 1: drawchar(i,j+1,2);
+	     break;
+    }
+   }
+
+ if (y==SelY2 && x>SelX1 && x<SelX2)
+   {
+    switch(tsize)
+    {
+     case 1: drawchar(i,j+1,7);
+	     break;
+     case 2: drawchar(i*2,j*2+2,7);
+	     drawchar(i*2+1,j*2+2,7);
+	     break;
+     case 3: drawchar(i*4  ,j*4+4,7);
+	     drawchar(i*4+1,j*4+4,7);
+	     drawchar(i*4+2,j*4+4,7);
+	     drawchar(i*4+3,j*4+4,7);
+	     break;
+    }
+   }
+
+ if (x==SelX1 && y>SelY1 && y<SelY2)
+   {
+    switch(tsize)
+    {
+     case 3: drawchar(i*4,j*4+3,4);
+	     drawchar(i*4,j*4+4,4);
+	     drawchar(i*4,j*4+2,4);
+	     drawchar(i*4,j*4+1,4);
+	     break;
+     case 2: drawchar(i*2,j*2+2,4);
+	     drawchar(i*2,j*2+1,4);
+	     break;
+     case 1: drawchar(i,j+1,4);
+	     break;
+    }
+   }
+
+ if (x==SelX2 && y>SelY1 && y<SelY2)
+   {
+    switch(tsize)
+    {
+     case 1: drawchar(i,j+1,5);
+	     break;
+     case 2: drawchar(i*2+1,j*2+1,5);
+	     drawchar(i*2+1,j*2+2,5);
+	     break;
+     case 3: drawchar(i*4+3,j*4+1,5);
+	     drawchar(i*4+2,j*4+1,5);
+	     drawchar(i*4+1,j*4+1,5);
+	     drawchar(i*4  ,j*4+1,5);
+    }
+   }
+
+
+}
+
+////////////////////////////////////////////////////
+//
+// FLOATING PASTE REGION!
+//
+////////////////////////////////////////////////////
+void CheckFloatPaste(int mx,int my)
+{
+ int i,j,maxh,maxw;
+
+
+ if (SnapMode && PasteMode && (pixely>=8 || pixely<infoy*8))
+   {
+    mx=(mx/snapxsize)*snapxsize+snapx;
+    my=(my/snapysize)*snapysize+snapy;
+
+    if (mx<xbase)
+      mx+=snapxsize;
+    if (my<ybase)
+      my+=snapysize;
+    if (mx>=xbase+screenw)
+      mx-=snapxsize;
+    if (my>=ybase+screenh)
+      my-=snapysize;
+   }
+
+ if (!PasteMode || (px==mx && py==my) || (pixely<8 || pixely>infoy*8))
+   return;
+
+ if (mx>mapwidth || my>mapheight)
+   return;
+
+ MouseHide();
+ EraseFloatPaste();
+
+ //
+ // FLOAT IT...
+ //
+ px=mx;
+ py=my;
+
+ DrawFloatPaste();
+ MouseShow();
+}
+
+
+////////////////////////////////////////////////////
+//
+// DRAW FLOATING PASTE REGION
+//
+void DrawFloatPaste(void)
+{
+ int i,j,maxw,maxh;
+
+
+ if (px==-1 || py==-1 || !PasteMode)
+   return;
+ //
+ // NOW, DRAW IT IN A NEW LOCATION!
+ //
+ MouseHide();
+
+
+ maxh=TileCopy.h;
+ if (py+maxh>mapheight)
+   maxh=mapheight-py;
+ if (py+maxh-ybase>screenh)
+   maxh=screenh-(py-ybase);
+
+ maxw=TileCopy.w;
+ if (px+maxw>mapwidth)
+   maxw=mapwidth-px;
+ if (px+maxw-xbase>screenw)
+   maxw=screenw-(px-xbase);
+
+ switch(TileCopy.MapOrTileSelect)
+ {
+  case 0: // MAP PASTE DRAW
+    for (j=0;j<maxh;j++)
+      for (i=0;i<maxw;i++)
+	{
+	 unsigned tilet,tilem,tilei,loc,loc1,oldt,oldm,oldi;
+	 int theT,theM,theI;
+
+	 loc=(TileCopy.y+j)*mapwidth+TileCopy.x+i;
+	 loc1=(py+j)*mapwidth+px+i;
+
+	 tilet=*(CutBkgnd+loc);
+	 oldt=MapBkgnd[loc1];
+	 tilem=*(CutFrgnd+loc)+tilenum;
+	 if (tilem==tilenum)
+	   tilem=0;
+	 oldm=MapFrgnd[loc1]+tilenum;
+	 tilei=*(CutInfoPl+loc)+tilenum;
+	 if (tilei==tilenum)
+	   tilei=0;
+	 oldi=MapInfoPl[loc1]+tilenum;
+
+	 theT=(TileCopy.PlanesCopied&BPLANE)?tilet:-BkgndColor;
+	 if (theT==-BkgndColor && viewton)
+	   theT=oldt;
+	 theM=(TileCopy.PlanesCopied&FPLANE)?tilem:0;
+	 if (!theM && viewmon && !(TileCopy.PlanesCopied&FPLANE && F3_flag))
+	   theM=oldm;
+	 theI=(TileCopy.PlanesCopied&IPLANE)?tilei:0;
+	 if (!theI && viewion && !(TileCopy.PlanesCopied&IPLANE && F3_flag))
+	   theI=oldi;
+
+	 CombineTiles(theT,theM,theI,tsize);
+	 if (GridMode)
+	   Overlay(tsize);
+	 DrawTile((px+i-xbase)<<(tsize-1),(py+j-ybase)*(4<<tsize)+8,tsize);
+	}
+    break;
+
+  case 1: // TILE PASTE DRAW
+    for (j=0;j<maxh;j++)
+      for (i=0;i<maxw;i++)
+	{
+	 int val=(j+TileCopy.y)*selectcols+TileCopy.x+i;
+	 unsigned tilem,tilei,loc;
+
+	 loc=(py+j)*mapwidth+px+i;
+
+	 tilem=MapFrgnd[loc]+tilenum;
+	 tilei=MapInfoPl[loc]+tilenum;
+
+	 if (XMSlookup[val]!=-1)
+	   {
+	    CombineTiles(viewton?val:-BkgndColor,
+			 viewmon?tilem:0,
+			 viewion?tilei:0,
+			 tsize);
+	    if (GridMode)
+	      Overlay(tsize);
+	    DrawTile((px+i-xbase)<<(tsize-1),(py+j-ybase)*(4<<tsize)+8,tsize);
+	   }
+	}
+    break;
+
+  case 2: // MASKED PASTE DRAW
+    for (j=0;j<maxh;j++)
+      for (i=0;i<maxw;i++)
+	{
+	 int val=(j+TileCopy.y)*selectcols+TileCopy.x+i+tilenum+maxiconrows*selectcols;
+	 unsigned tilet,tilei,loc;
+
+	 loc=(py+j)*mapwidth+px+i;
+
+	 tilet=MapBkgnd[loc];
+	 tilei=MapInfoPl[loc]+tilenum;
+
+	 if (XMSlookup[val]!=-1)
+	   {
+	    CombineTiles(viewton?tilet:-BkgndColor,
+			 viewmon?val:0,
+			 viewion?tilei:0,
+			 tsize);
+	    if (GridMode)
+	      Overlay(tsize);
+	    DrawTile((px+i-xbase)<<(tsize-1),(py+j-ybase)*(4<<tsize)+8,tsize);
+	   }
+	}
+ }
+
+ MouseShow();
+}
+
+////////////////////////////////////////////////////
+//
+// ERASE FLOATING PASTE REGION
+//
+void EraseFloatPaste(void)
+{
+ int maxh,maxw,i,j;
+
+
+ if (px==-1 || py==-1 || !PasteMode)
+   return;
+
+ //
+ // ERASE THE FLOATING REGION
+ // (PRECLIPPING REGION)
+ //
+ MouseHide();
+
+ maxh=TileCopy.h;
+ if (py+maxh>mapheight)
+   maxh=mapheight-py;
+ if (py+maxh-ybase>screenh)
+   maxh=screenh-(py-ybase);
+
+ maxw=TileCopy.w;
+ if (px+maxw>mapwidth)
+   maxw=mapwidth-px;
+ if (px+maxw-xbase>screenw)
+   maxw=screenw-(px-xbase);
+
+ for (j=0;j<maxh;j++)
+   for (i=0;i<maxw;i++)
+     {
+      unsigned tile_t,tile_m,tile_i,loc;
+
+      loc=(py+j)*mapwidth+px+i;
+
+      tile_t=*(MapBkgnd+loc);
+      tile_m=*(MapFrgnd+loc)+tilenum;
+      tile_i=*(MapInfoPl+loc)+tilenum;
+
+      CombineTiles(viewton?tile_t:-BkgndColor,viewmon?tile_m:0,viewion?tile_i:0,tsize);
+      if (GridMode)
+	Overlay(tsize);
+      DrawTile((px+i-xbase)<<(tsize-1),(py+j-ybase)*(4<<tsize)+8,tsize);
+     }
+
+ MouseShow();
+}
+
+
+////////////////////////////////////////////////////
+//
+// SAVE CUT BUFFERS TO XMS BEFORE MAP LOAD/CREATE
+//
+////////////////////////////////////////////////////
+void SaveCutBuffers(void)
+{
+ long size,off;
+ int j;
+
+ //
+ // IS SOMETHING IN THE COPY BUFFER?
+ // IF SO, PRESERVE AS MUCH AS POSSIBLE
+ //
+ if (!TileCopy.MapOrTileSelect)
+   {
+    size=(2L*TileCopy.w*TileCopy.h)*(((TileCopy.PlanesCopied&BPLANE)>0)+
+      ((TileCopy.PlanesCopied&FPLANE)>0)+((TileCopy.PlanesCopied&IPLANE)>0));
+
+    xms1=XMSAllocate(size);
+
+    off=0;
+    if (TileCopy.PlanesCopied&BPLANE)
+      for (j=0;j<TileCopy.h;j++)
+	{
+	 XMSmove(0,(long)MK_FP(CutBkgnd,2L*((TileCopy.y+j)*mapwidth)+2L*TileCopy.x),
+	   xms1,off,2L*TileCopy.w);
+	 off+=2L*TileCopy.w;
+	}
+
+    if (TileCopy.PlanesCopied&FPLANE)
+      for (j=0;j<TileCopy.h;j++)
+	{
+	 XMSmove(0,(long)MK_FP(CutFrgnd,2L*((TileCopy.y+j)*mapwidth)+2L*TileCopy.x),
+	   xms1,off,2L*TileCopy.w);
+	 off+=2L*TileCopy.w;
+	}
+
+    if (TileCopy.PlanesCopied&IPLANE)
+      for (j=0;j<TileCopy.h;j++)
+	{
+	 XMSmove(0,(long)MK_FP(CutInfoPl,2L*((TileCopy.y+j)*mapwidth)+2L*TileCopy.x),
+	   xms1,off,2L*TileCopy.w);
+	 off+=2L*TileCopy.w;
+	}
+   }
+}
+
+
+////////////////////////////////////////////////////
+//
+// RESTORE CUT BUFFERS FROM XMS AFTER MAP LOAD/CREATE
+//
+////////////////////////////////////////////////////
+void RestoreCutBuffers(void)
+{
+ //
+ // COPY BACK STUFF IN XMS
+ //
+ if (!TileCopy.MapOrTileSelect)
+   {
+    long ToOff,off;
+    int newwidth,newheight,j;
+
+    newwidth=(TileCopy.w>mapwidth)?mapwidth:TileCopy.w;
+    newheight=(TileCopy.h>mapheight)?mapheight:TileCopy.h;
+
+    ToOff=off=0;
+
+    if (TileCopy.PlanesCopied&BPLANE)
+      for (j=0;j<newheight;j++)
+	{
+	 XMSmove(xms1,off,0,(long)MK_FP(CutBkgnd,2L*(j*mapwidth)),2L*newwidth);
+	 ToOff+=2L*newwidth;
+	 off+=2L*TileCopy.w;
+	}
+
+    if (TileCopy.PlanesCopied&FPLANE)
+      for (j=0;j<newheight;j++)
+	{
+	 XMSmove(xms1,off,0,(long)MK_FP(CutFrgnd,2L*(j*mapwidth)),2L*newwidth);
+	 ToOff+=2L*newwidth;
+	 off+=2L*TileCopy.w;
+	}
+
+    if (TileCopy.PlanesCopied&IPLANE)
+      for (j=0;j<newheight;j++)
+	{
+	 XMSmove(xms1,off,0,(long)MK_FP(CutInfoPl,2L*(j*mapwidth)),2L*newwidth);
+	 ToOff+=2L*newwidth;
+	 off+=2L*TileCopy.w;
+	}
+
+    TileCopy.x=TileCopy.y=0;
+    TileCopy.w=newwidth;
+    TileCopy.h=newheight;
+
+    XMSFreeMem(xms1);	// RELEASE THE MEMORY
+   }
+}
+
+////////////////////////////////////////////////////
+//
+// SEE IF THERE'S AN INFO VALUES AT THE CURRENT POSITION
+// THAT NEEDS TO BE PRINTED
+//
+////////////////////////////////////////////////////
+void CheckInfoValues(int i,int j,int tilei)
+{
+ sx=i<<(tsize-1);
+ sy=(j<<(tsize-1))+1;
+
+ if (TsearchMode)
+   {
+    unsigned loc,temp,p=0;
+
+    loc=(j+ybase)*mapwidth+i+xbase;
+
+    if (planeton)
+      {
+       if (MapBkgnd[loc]==whicht)
+	 {
+	  temp=whicht;
+	  p=1;
+	 }
+      }
+    else
+    if (planemon)
+      {
+       if (MapFrgnd[loc]==whichtm-tilenum)
+	 {
+	  temp=whichtm-tilenum;
+	  p=1;
+	 }
+      }
+    else
+    if (planeion)
+      if ((unsigned)MapInfoPl[loc]==whichi-tilenum)
+	{
+	 temp=whichi-tilenum;
+	 p=1;
+	}
+
+    if (p)
+      switch(tsize)
+      {
+       case 1:
+	 print("#");
+	 break;
+       case 2:
+	 printhexb(temp>>8);
+	 sx-=2;
+	 sy++;
+	 printhexb(temp&0xff);
+	 break;
+       case 3: printhex(temp);
+      }
+   }
+ else
+ if (viewion && tilei>lasticon)
+   {
+    switch(tsize)
+    {
+     case 1:
+       print("#");
+       break;
+     case 2:
+       printhexb(tilei-tilenum>>8);
+       sx-=2;
+       sy++;
+       printhexb(tilei-tilenum&0xff);
+       break;
+     case 3: printhex(tilei-tilenum);
+    }
+   }
+}
+
+////////////////////////////////////////////////////
+//
+// Item - Edit Map Edges
+//
+////////////////////////////////////////////////////
+btype MapEdgeB[]={{"\xb",7,3,1},
+		  {"\xc",7,7,1},
+		  {"\xe",4,5,1},
+		  {"\x1f",10,5,1},
+		  {" Exit ",5,16,2}};
+DialogDef MapEdgeD={"  PICK MAP EDGE\n"
+		    "    TO CHANGE",
+		    16,18,5,&MapEdgeB[0],NULL};
+
+void Item_EditMapEdges(void)
+{
+ int which,val,newwidth,newheight,b,f,i,
+	_seg *tempB,_seg *tempF,_seg *tempI;
+ unsigned dx,dy,obx,oby,k,j,modified=0;
+ long size;
+
+ b=MapFileHeader->maptype&BPLANE;
+ f=MapFileHeader->maptype&FPLANE;
+ i=MapFileHeader->maptype&IPLANE;
+
+ DrawDialog(&MapEdgeD,1);
+ GetDialogXY(&MapEdgeD,&dx,&dy);
+ do
+ {
+  MouseHide();
+  sx=dx+2;
+  sy=dy+14;
+  print("W:");
+  printint(MapHeader.width);
+  print(", H:");
+  printint(MapHeader.height);
+  print("   ");
+  MouseShow();
+
+
+  which=CheckButtons(&MapEdgeD);
+  GetButtonXY(&MapEdgeD,which-1,&obx,&oby);
+  MouseHide();
+  if (which>=1 && which<=4)
+    {
+     // DRAW INPUT BAR
+     sx=dx;
+     sy=dy+9;
+     print("+ or - value");
+     DrawBorder(dx,dy+10,15,2,1);
+
+     // INPUT VALUE
+     sx=dx+1;
+     sy=dy+11;
+     val=inputint(9);
+
+     // ERASE THE ARROW AND INPUT BAR
+     sx=obx;
+     sy=oby;
+     print(MapEdgeB[which-1].text);
+     bar(dx,dy+9,dx+15,dy+12,' ');
+
+     // CHECK FOR ESC
+     if (val==(int)ESCOUT)
+       which=6;
+    }
+
+  MouseShow();
+  switch(which)
+  {
+   //
+   // ADD OR DELETE FROM TOP
+   //
+   case 1:
+     newheight=mapheight+val;
+     size=2L*newheight*mapwidth;
+     if (size<=0 || size>0x10000L)
+       {
+	RestoreBackground();
+	ErrDialog("Invalid Map height!"," OK ");
+	return;
+       }
+
+     // FREE UP SOME MEMORY!
+     SaveCutBuffers();
+     RemoveUndoBuffers();
+
+     if (b)
+       {
+	MMFreePtr((memptr *)&CutBkgnd);
+	MMAllocate((memptr *)&tempB,size);
+       }
+     if (f)
+       {
+	MMFreePtr((memptr *)&CutFrgnd);
+	MMAllocate((memptr *)&tempF,size);
+       }
+     if (i)
+       {
+	MMFreePtr((memptr *)&CutInfoPl);
+	MMAllocate((memptr *)&tempI,size);
+       }
+
+     if (val<0)
+       {
+	// COPY MAP PLANES INTO TEMP MEMORY (CLIPPED, HERE)
+	for (j=abs(val);j<mapheight;j++)
+	  for (k=0;k<mapwidth;k++)
+	    {
+	     if (b)
+	       tempB[(j+val)*mapwidth+k]=MapBkgnd[j*mapwidth+k];
+	     if (f)
+	       tempF[(j+val)*mapwidth+k]=MapFrgnd[j*mapwidth+k];
+	     if (i)
+	       tempI[(j+val)*mapwidth+k]=MapInfoPl[j*mapwidth+k];
+	    }
+       }
+     else
+       {
+	for (j=0;j<mapheight+val;j++)
+	  for (k=0;k<mapwidth;k++)
+	    {
+	     if (j<abs(val))
+	       {
+		if (b)
+		  tempB[j*mapwidth+k]=whicht;
+		if (f)
+		  tempF[j*mapwidth+k]=whichtm-tilenum;
+		if (i)
+		  tempI[j*mapwidth+k]=whichi-tilenum;
+	       }
+	     else
+	       {
+		if (b)
+		  tempB[j*mapwidth+k]=MapBkgnd[(j-val)*mapwidth+k];
+		if (f)
+		  tempF[j*mapwidth+k]=MapFrgnd[(j-val)*mapwidth+k];
+		if (i)
+		  tempI[j*mapwidth+k]=MapInfoPl[(j-val)*mapwidth+k];
+	       }
+	    }
+       }
+
+     // DEALLOCATE & REALLOCATE THE MAP BUFFERS, RESIZED
+     if (b)
+       {
+	MMFreePtr((memptr *)&MapBkgnd);
+	MMAllocate((memptr *)&MapBkgnd,size);
+       }
+     if (f)
+       {
+	MMFreePtr((memptr *)&MapFrgnd);
+	MMAllocate((memptr *)&MapFrgnd,size);
+       }
+     if (i)
+       {
+	MMFreePtr((memptr *)&MapInfoPl);
+	MMAllocate((memptr *)&MapInfoPl,size);
+       }
+
+     // COPY THE REGION BACK IN...
+     for (j=0;j<newheight;j++)
+       for (k=0;k<mapwidth;k++)
+	 {
+	  if (b)
+	    MapBkgnd[j*mapwidth+k]=tempB[j*mapwidth+k];
+	  if (f)
+	    MapFrgnd[j*mapwidth+k]=tempF[j*mapwidth+k];
+	  if (i)
+	    MapInfoPl[j*mapwidth+k]=tempI[j*mapwidth+k];
+	 }
+
+     // TOAST THE 'TEMP' BUFFERS & REALLOCATE THE 'CUT' BUFFERS
+     if (b)
+       {
+	MMFreePtr((memptr *)&tempB);
+	MMAllocate((memptr *)&CutBkgnd,size);
+       }
+     if (f)
+       {
+	MMFreePtr((memptr *)&tempF);
+	MMAllocate((memptr *)&CutFrgnd,size);
+       }
+     if (i)
+       {
+	MMFreePtr((memptr *)&tempI);
+	MMAllocate((memptr *)&CutInfoPl,size);
+       }
+
+     mapheight=newheight;
+     MapHeader.height=newheight;
+     modified=DirtyFlag=1;
+     AllocateUndoBuffers();
+     UndoRegion.x=-1;
+     SaveUndo(0,0,mapwidth,mapheight);
+     RestoreCutBuffers();
+
+     break;
+
+   //
+   // ADD OR DELETE FROM BOTTOM
+   //
+   case 2:
+     newheight=mapheight+val;
+     size=2L*newheight*mapwidth;
+     if (size<=0 || size>0x10000L)
+       {
+	RestoreBackground();
+	ErrDialog("Invalid Map height!"," OK ");
+	return;
+       }
+
+     // FREE UP SOME MEMORY!
+     SaveCutBuffers();
+     RemoveUndoBuffers();
+     if (b)
+       {
+	MMFreePtr((memptr *)&CutBkgnd);
+	MMAllocate((memptr *)&tempB,size);
+       }
+     if (f)
+       {
+	MMFreePtr((memptr *)&CutFrgnd);
+	MMAllocate((memptr *)&tempF,size);
+       }
+     if (i)
+       {
+	MMFreePtr((memptr *)&CutInfoPl);
+	MMAllocate((memptr *)&tempI,size);
+       }
+
+     if (val<0)
+       {
+	// COPY MAP PLANES INTO TEMP MEMORY (CLIPPED, HERE)
+	for (j=0;j<mapheight+val;j++)
+	  for (k=0;k<mapwidth;k++)
+	    {
+	     if (b)
+	       tempB[j*mapwidth+k]=MapBkgnd[j*mapwidth+k];
+	     if (f)
+	       tempF[j*mapwidth+k]=MapFrgnd[j*mapwidth+k];
+	     if (i)
+	       tempI[j*mapwidth+k]=MapInfoPl[j*mapwidth+k];
+	    }
+       }
+     else
+       {
+	for (j=0;j<mapheight+val;j++)
+	  for (k=0;k<mapwidth;k++)
+	    {
+	     if (j>=mapheight)
+	       {
+		if (b)
+		  tempB[j*mapwidth+k]=whicht;
+		if (f)
+		  tempF[j*mapwidth+k]=whichtm-tilenum;
+		if (i)
+		  tempI[j*mapwidth+k]=whichi-tilenum;
+	       }
+	     else
+	       {
+		if (b)
+		  tempB[j*mapwidth+k]=MapBkgnd[j*mapwidth+k];
+		if (f)
+		  tempF[j*mapwidth+k]=MapFrgnd[j*mapwidth+k];
+		if (i)
+		  tempI[j*mapwidth+k]=MapInfoPl[j*mapwidth+k];
+	       }
+	    }
+       }
+
+     // DEALLOCATE & REALLOCATE THE MAP BUFFERS, RESIZED
+     if (b)
+       {
+	MMFreePtr((memptr *)&MapBkgnd);
+	MMAllocate((memptr *)&MapBkgnd,size);
+       }
+     if (f)
+       {
+	MMFreePtr((memptr *)&MapFrgnd);
+	MMAllocate((memptr *)&MapFrgnd,size);
+       }
+     if (i)
+       {
+	MMFreePtr((memptr *)&MapInfoPl);
+	MMAllocate((memptr *)&MapInfoPl,size);
+       }
+
+     // COPY THE REGION BACK IN...
+     for (j=0;j<newheight;j++)
+       for (k=0;k<mapwidth;k++)
+	 {
+	  if (b)
+	    MapBkgnd[j*mapwidth+k]=tempB[j*mapwidth+k];
+	  if (f)
+	    MapFrgnd[j*mapwidth+k]=tempF[j*mapwidth+k];
+	  if (i)
+	    MapInfoPl[j*mapwidth+k]=tempI[j*mapwidth+k];
+	 }
+
+     // TOAST THE 'TEMP' BUFFERS & REALLOCATE THE 'CUT' BUFFERS
+     if (b)
+       {
+	MMFreePtr((memptr *)&tempB);
+	MMAllocate((memptr *)&CutBkgnd,size);
+       }
+     if (f)
+       {
+	MMFreePtr((memptr *)&tempF);
+	MMAllocate((memptr *)&CutFrgnd,size);
+       }
+     if (i)
+       {
+	MMFreePtr((memptr *)&tempI);
+	MMAllocate((memptr *)&CutInfoPl,size);
+       }
+
+     mapheight=newheight;
+     MapHeader.height=newheight;
+     modified=DirtyFlag=1;
+     AllocateUndoBuffers();
+     UndoRegion.x=-1;
+     SaveUndo(0,0,mapwidth,mapheight);
+     RestoreCutBuffers();
+
+     break;
+
+   //
+   // ADD OR DELETE FROM LEFTEDGE
+   //
+   case 3:
+     newwidth=mapwidth+val;
+     size=2L*newwidth*mapheight;
+     if (size<=0 || size>0x10000L)
+       {
+	RestoreBackground();
+	ErrDialog("Invalid Map width!"," OK ");
+	return;
+       }
+
+     // FREE UP SOME MEMORY!
+     SaveCutBuffers();
+     RemoveUndoBuffers();
+     if (b)
+       {
+	MMFreePtr((memptr *)&CutBkgnd);
+	MMAllocate((memptr *)&tempB,size);
+       }
+     if (f)
+       {
+	MMFreePtr((memptr *)&CutFrgnd);
+	MMAllocate((memptr *)&tempF,size);
+       }
+     if (i)
+       {
+	MMFreePtr((memptr *)&CutInfoPl);
+	MMAllocate((memptr *)&tempI,size);
+       }
+
+     if (val<0)
+       {
+	// COPY MAP PLANES INTO TEMP MEMORY (CLIPPED, HERE)
+	for (j=0;j<mapheight;j++)
+	  for (k=abs(val);k<mapwidth;k++)
+	    {
+	     if (b)
+	       tempB[j*newwidth+k+val]=MapBkgnd[j*mapwidth+k];
+	     if (f)
+	       tempF[j*newwidth+k+val]=MapFrgnd[j*mapwidth+k];
+	     if (i)
+	       tempI[j*newwidth+k+val]=MapInfoPl[j*mapwidth+k];
+	    }
+       }
+     else
+       {
+	for (j=0;j<mapheight;j++)
+	  for (k=0;k<mapwidth+val;k++)
+	    {
+	     if (k<abs(val))
+	       {
+		if (b)
+		  tempB[j*newwidth+k]=whicht;
+		if (f)
+		  tempF[j*newwidth+k]=whichtm-tilenum;
+		if (i)
+		  tempI[j*newwidth+k]=whichi-tilenum;
+	       }
+	     else
+	       {
+		if (b)
+		  tempB[j*newwidth+k]=MapBkgnd[j*mapwidth+k-val];
+		if (f)
+		  tempF[j*newwidth+k]=MapFrgnd[j*mapwidth+k-val];
+		if (i)
+		  tempI[j*newwidth+k]=MapInfoPl[j*mapwidth+k-val];
+	       }
+	    }
+       }
+
+     // DEALLOCATE & REALLOCATE THE MAP BUFFERS, RESIZED
+     if (b)
+       {
+	MMFreePtr((memptr *)&MapBkgnd);
+	MMAllocate((memptr *)&MapBkgnd,size);
+       }
+     if (f)
+       {
+	MMFreePtr((memptr *)&MapFrgnd);
+	MMAllocate((memptr *)&MapFrgnd,size);
+       }
+     if (i)
+       {
+	MMFreePtr((memptr *)&MapInfoPl);
+	MMAllocate((memptr *)&MapInfoPl,size);
+       }
+
+     // COPY THE REGION BACK IN...
+     for (j=0;j<mapheight;j++)
+       for (k=0;k<newwidth;k++)
+	 {
+	  if (b)
+	    MapBkgnd[j*newwidth+k]=tempB[j*newwidth+k];
+	  if (f)
+	    MapFrgnd[j*newwidth+k]=tempF[j*newwidth+k];
+	  if (i)
+	    MapInfoPl[j*newwidth+k]=tempI[j*newwidth+k];
+	 }
+
+     // TOAST THE 'TEMP' BUFFERS & REALLOCATE THE 'CUT' BUFFERS
+     if (b)
+       {
+	MMFreePtr((memptr *)&tempB);
+	MMAllocate((memptr *)&CutBkgnd,size);
+       }
+     if (f)
+       {
+	MMFreePtr((memptr *)&tempF);
+	MMAllocate((memptr *)&CutFrgnd,size);
+       }
+     if (i)
+       {
+	MMFreePtr((memptr *)&tempI);
+	MMAllocate((memptr *)&CutInfoPl,size);
+       }
+
+     mapwidth=newwidth;
+     MapHeader.width=newwidth;
+     modified=DirtyFlag=1;
+     AllocateUndoBuffers();
+     UndoRegion.x=-1;
+     SaveUndo(0,0,mapwidth,mapheight);
+     RestoreCutBuffers();
+
+     break;
+
+   //
+   // ADD OR DELETE FROM RIGHTEDGE
+   //
+   case 4:
+     newwidth=mapwidth+val;
+     size=2L*newwidth*mapheight;
+     if (size<=0 || size>0x10000L)
+       {
+	RestoreBackground();
+	ErrDialog("Invalid Map width!"," OK ");
+	return;
+       }
+
+     // FREE UP SOME MEMORY!
+     SaveCutBuffers();
+     RemoveUndoBuffers();
+     if (b)
+       {
+	MMFreePtr((memptr *)&CutBkgnd);
+	MMAllocate((memptr *)&tempB,size);
+       }
+     if (f)
+       {
+	MMFreePtr((memptr *)&CutFrgnd);
+	MMAllocate((memptr *)&tempF,size);
+       }
+     if (i)
+       {
+	MMFreePtr((memptr *)&CutInfoPl);
+	MMAllocate((memptr *)&tempI,size);
+       }
+
+     if (val<0)
+       {
+	// COPY MAP PLANES INTO TEMP MEMORY (CLIPPED, HERE)
+	for (j=0;j<mapheight;j++)
+	  for (k=0;k<mapwidth+val;k++)
+	    {
+	     if (b)
+	       tempB[j*newwidth+k]=MapBkgnd[j*mapwidth+k];
+	     if (f)
+	       tempF[j*newwidth+k]=MapFrgnd[j*mapwidth+k];
+	     if (i)
+	       tempI[j*newwidth+k]=MapInfoPl[j*mapwidth+k];
+	    }
+       }
+     else
+       {
+	for (j=0;j<mapheight;j++)
+	  for (k=0;k<mapwidth+val;k++)
+	    {
+	     if (k>=mapwidth)
+	       {
+		if (b)
+		  tempB[j*newwidth+k]=whicht;
+		if (f)
+		  tempF[j*newwidth+k]=whichtm-tilenum;
+		if (i)
+		  tempI[j*newwidth+k]=whichi-tilenum;
+	       }
+	     else
+	       {
+		if (b)
+		  tempB[j*newwidth+k]=MapBkgnd[j*mapwidth+k];
+		if (f)
+		  tempF[j*newwidth+k]=MapFrgnd[j*mapwidth+k];
+		if (i)
+		  tempI[j*newwidth+k]=MapInfoPl[j*mapwidth+k];
+	       }
+	    }
+       }
+
+     // DEALLOCATE & REALLOCATE THE MAP BUFFERS, RESIZED
+     if (b)
+       {
+	MMFreePtr((memptr *)&MapBkgnd);
+	MMAllocate((memptr *)&MapBkgnd,size);
+       }
+     if (f)
+       {
+	MMFreePtr((memptr *)&MapFrgnd);
+	MMAllocate((memptr *)&MapFrgnd,size);
+       }
+     if (i)
+       {
+	MMFreePtr((memptr *)&MapInfoPl);
+	MMAllocate((memptr *)&MapInfoPl,size);
+       }
+
+     // COPY THE REGION BACK IN...
+     for (j=0;j<mapheight;j++)
+       for (k=0;k<newwidth;k++)
+	 {
+	  if (b)
+	    MapBkgnd[j*newwidth+k]=tempB[j*newwidth+k];
+	  if (f)
+	    MapFrgnd[j*newwidth+k]=tempF[j*newwidth+k];
+	  if (i)
+	    MapInfoPl[j*newwidth+k]=tempI[j*newwidth+k];
+	 }
+
+     // TOAST THE 'TEMP' BUFFERS & REALLOCATE THE 'CUT' BUFFERS
+     if (b)
+       {
+	MMFreePtr((memptr *)&tempB);
+	MMAllocate((memptr *)&CutBkgnd,size);
+       }
+     if (f)
+       {
+	MMFreePtr((memptr *)&tempF);
+	MMAllocate((memptr *)&CutFrgnd,size);
+       }
+     if (i)
+       {
+	MMFreePtr((memptr *)&tempI);
+	MMAllocate((memptr *)&CutInfoPl,size);
+       }
+
+     mapwidth=newwidth;
+     MapHeader.width=newwidth;
+     modified=DirtyFlag=1;
+     AllocateUndoBuffers();
+     UndoRegion.x=-1;
+     SaveUndo(0,0,mapwidth,mapheight);
+     RestoreCutBuffers();
+     break;
+  }
+ } while(which && which!=5);
+ RestoreBackground();
+ if (modified)
+   {
+    xbase=ybase=0;
+    MouseHide();
+    InitDesktop(TED5MenuBar,0);
+    DrawInfoBar();
+    DrawMap();
+    MouseShow();
+   }
+}
+
+
+////////////////////////////////////////////////////
+//
+// Display amount of memory available
+//
+////////////////////////////////////////////////////
+btype     ShowMemb={" OK ",6,11,2};
+DialogDef ShowMemd={"Extended Memory \n"
+		    "Available:\n\n"
+		    "Main Memory\n"
+		    "Available:\n\n"
+		    "In Extended Mem\n"
+		    "----------------\n"
+		    "CGA:     EGA:\n"
+		    "VGA:    Maps:"
+		    ,16,13,1,&ShowMemb,PrintMem};
+
+void Item_PrintMem(void)
+{
+ DoDialog(&ShowMemd);
+}
+
+void PrintMem(int x,int y)
+{
+ long total;
+ char memstring[10];
+
+ sx=x+10;
+ sy=y+1;
+ itoa(XMSTotalFree(),memstring,10);
+ strcat(memstring,"K");
+ print(memstring);
+
+ sx=x+10;
+ sy=y+4;
+ total=(MMTotalFree()*16L)/1024;
+ ltoa(total,memstring,10);
+ strcat(memstring,"K");
+ print(memstring);
+
+ sx=x+4;
+ sy=y+8;
+ if (!CgaXMS)
+   print("No");
+ else
+   print("Yes");
+
+ sx=x+13;
+ sy=y+8;
+ if (!EgaXMS)
+   print("No");
+ else
+   print("Yes");
+
+ sx=x+4;
+ sy=y+9;
+ if (!VgaXMS)
+   print("No");
+ else
+   print("Yes");
+
+
+ sx=x+13;
+ sy=y+9;
+ if (!XMSmaps)
+   print("No");
+ else
+   print("Yes");
+}
+
+
+////////////////////////////////////////////////////
+//
+// CARMACIZE THE MAP FILE!
+//
+////////////////////////////////////////////////////
+void Item_Huffman(void)
+{
+ OutputHeadStr NewFileHeader;
+ char huffname[14]="GAMEMAPS.",huffheadname[14]="MAPSHEAD.",tempstr[200],
+	mapidstr[8]=IDSTRING,objname[14],dictname[14],tempname[14];
+ int dx,dy,i,oxb,oyb,maplengths[100];
+ MapHeaderStr TempHeader;
+ memptr block,block1,block2;
+ long size,fsize,nsize;
+
+
+ Item_SaveMap();
+
+ strcat(huffname,ext);
+ strcat(huffheadname,ext);
+ strcpy(tempstr,"This will take a while.\n");
+ strcat(tempstr,huffname);
+ strcat(tempstr,". [               ]");
+ ErrDialog(tempstr,"");
+ dy=sy;
+ dx=sx-16;
+
+ oxb=xbase;
+ oyb=ybase;
+ //
+ // Free up memory
+ //
+ if (MapBkgnd)
+   {
+    MMFreePtr((memptr *)&MapBkgnd);
+    MMFreePtr((memptr *)&CutBkgnd);
+   }
+ if (MapFrgnd)
+   {
+    MMFreePtr((memptr *)&MapFrgnd);
+    MMFreePtr((memptr *)&CutFrgnd);
+   }
+ if (MapInfoPl)
+   {
+    MMFreePtr((memptr *)&MapInfoPl);
+    MMFreePtr((memptr *)&CutInfoPl);
+   }
+
+ //
+ // Now, time to Carmacize all the maps
+ //
+ sx=dx;
+ sy=dy;
+ print("Carmacizing");
+ dx=sx+1;
+
+ fsize=0;
+ SaveFile(huffname,(char huge *)&mapidstr,fsize,strlen(mapidstr));
+ fsize+=strlen(mapidstr);
+
+ memset(&maplengths,0,sizeof(long)*100);
+ memset(&NewFileHeader,0,sizeof(OutputHeadStr));
+ MMAllocate(&block1,sizeof(MapHeaderStr));
+ for (i=0;i<100;i++)
+   if (MapFileHeader->dataoffsets[i]!=-1)
+     {
+      //
+      // LOAD MAP HEADER
+      //
+      sx=dx;
+      printint(i);
+      LoadFile(mapname,(char huge *)&TempHeader,MapFileHeader->dataoffsets[i],sizeof(MapHeaderStr));
+
+      //
+      // COMPRESS EACH MAP PLANE
+      //
+      #pragma warn -sus
+      if (MapFileHeader->maptype&BPLANE)
+	{
+	 size=TempHeader.mapbkgndlen;
+	 MMAllocate(&block,size);
+	 MMAllocate(&block2,size);
+	 LoadFile(mapname,block,TempHeader.mapbkgndpl,size);
+	 *(int _seg *)block2=TempHeader.mapbkgndlen;
+	 nsize=CarmackCompress((unsigned  char huge *)block,size,(unsigned char huge *)block2+2)+2;
+	 maplengths[i]+=nsize;
+	 if (nsize==2)
+	 {
+	  RestoreBackground();
+	  MMFreePtr(&block2);
+	  MMFreePtr(&block);
+	  MMFreePtr(&block1);
+	  LoadMap(whichmap);
+	  xbase=oxb;
+	  ybase=oyb;
+	  ErrDialog("ESC out of this infernal thing!"," YES! ");
+	  return;
+	 }
+
+	 SaveFile(huffname,block2,fsize,nsize);
+	 TempHeader.mapbkgndpl=fsize;
+	 TempHeader.mapbkgndlen=nsize;
+	 MMFreePtr(&block2);
+	 MMFreePtr(&block);
+	 fsize+=nsize;
+	}
+      if (MapFileHeader->maptype&FPLANE)
+	{
+	 size=TempHeader.mapfrgndlen;
+	 MMAllocate(&block,size);
+	 MMAllocate(&block2,size);
+	 LoadFile(mapname,block,TempHeader.mapfrgndpl,size);
+	 *(int _seg *)block2=TempHeader.mapfrgndlen;
+	 nsize=CarmackCompress((unsigned  char huge *)block,size,(unsigned  char huge *)block2+2)+2;
+	 maplengths[i]+=nsize;
+	 if (nsize==2)
+	 {
+	  RestoreBackground();
+	  MMFreePtr(&block2);
+	  MMFreePtr(&block);
+	  MMFreePtr(&block1);
+	  LoadMap(whichmap);
+	  xbase=oxb;
+	  ybase=oyb;
+	  ErrDialog("ESC out of this infernal thing!"," YES! ");
+	  return;
+	 }
+
+	 SaveFile(huffname,block2,fsize,nsize);
+	 TempHeader.mapfrgndpl=fsize;
+	 TempHeader.mapfrgndlen=nsize;
+	 MMFreePtr(&block2);
+	 MMFreePtr(&block);
+	 fsize+=nsize;
+	}
+      if (MapFileHeader->maptype&IPLANE)
+	{
+	 size=TempHeader.mapinfolen;
+	 MMAllocate(&block,size);
+	 MMAllocate(&block2,size);
+	 LoadFile(mapname,block,TempHeader.mapinfopl,size);
+	 *(int _seg *)block2=TempHeader.mapinfolen;
+	 nsize=CarmackCompress((unsigned  char huge *)block,size,(unsigned  char huge *)block2+2)+2;
+	 maplengths[i]+=nsize;
+	 if (nsize==2)
+	 {
+	  RestoreBackground();
+	  MMFreePtr(&block2);
+	  MMFreePtr(&block);
+	  MMFreePtr(&block1);
+	  LoadMap(whichmap);
+	  xbase=oxb;
+	  ybase=oyb;
+	  ErrDialog("ESC out of this infernal thing!"," YES! ");
+	  return;
+	 }
+
+	 SaveFile(huffname,block2,fsize,nsize);
+	 TempHeader.mapinfopl=fsize;
+	 TempHeader.mapinfolen=nsize;
+	 MMFreePtr(&block2);
+	 MMFreePtr(&block);
+	 fsize+=nsize;
+	}
+      #pragma warn +sus
+
+      //
+      // SAVE MAP HEADER
+      //
+      nsize=sizeof(TempHeader);
+      maplengths[i]+=nsize;
+      SaveFile(huffname,(char huge *)&TempHeader,fsize,nsize);
+      NewFileHeader.dataoffsets[i]=fsize;
+      fsize+=nsize;
+
+      SaveFile(huffname,"!ID!",fsize,4);
+      fsize+=4;
+     }
+ MMFreePtr(&block1);
+
+
+ //
+ // COPY PERTINENT MAPFILEHEADER DATA TO NEWFILEHEADER
+ //
+ {
+  char outname[14],tempname[14]="MTEMP.TMP",doutname[14];
+
+
+  strcpy(outname,ext);
+  strcat(outname,"MHEAD.OBJ");
+
+  NewFileHeader.RLEWtag=MapFileHeader->RLEWtag;
+  fsize=sizeof(OutputHeadStr);
+  SaveFile(tempname,(char huge *)&NewFileHeader,0,fsize);
+
+  for (i=0;i<numtplanes;i++)
+	{
+	 SaveFile(tempname,MK_FP(Tinfo[i],0),fsize,tilenum);
+	 fsize+=tilenum;
+	}
+  for (i=0;i<numtmplanes;i++)
+	{
+	 SaveFile(tempname,MK_FP(TMinfo[i],0),fsize,tilemnum);
+	 fsize+=tilemnum;
+	}
+
+  MakeOBJ(tempname,outname,"_maphead",FARDATA,"MapHeader");
+//  unlink(tempname);
+ }
+
+ RestoreBackground();
+ SignalSound();
+
+ //
+ // FINSIHED. PRINT REPORT?
+ //
+ if (Message("Finished with compression.\n"
+	     "Print report on lengths?")==2)
+ {
+  fprintf(stdprn,"TED5 Carmacized Map Lengths for .%s\n\n",ext);
+  fprintf(stdprn,"#\tMap Name\t\tLength\n");
+  fprintf(stdprn,"_\t--------\t\t------\n");
+  for (i=0;i<100;i++)
+    if (MapFileHeader->dataoffsets[i]!=-1)
+    {
+     char tstr[16];
+     strcpy(tstr,MapNames[i]);
+     while(strlen(tstr)<16)
+       strcat(tstr," ");
+     fprintf(stdprn,"%d\t%s\t%d\n",i,tstr,maplengths[i]);
+    }
+  fprintf(stdprn,"%c",12);
+ }
+
+ LoadMap(whichmap);
+ xbase=oxb;
+ ybase=oyb;
+}
+
+
+////////////////////////////////////////////////////
+//
+// Item - Change the LAUNCH name
+//
+////////////////////////////////////////////////////
+btype CLNb={"                                    ",1,5,1};
+DialogDef CLNd={"Current LAUNCH name:\n\n\nNew LAUNCH name:",38,7,1,&CLNb,NULL};
+
+void Item_LAUNCHname(void)
+{
+ char tempstr[40];
+
+
+ MouseHide();
+ DrawDialog(&CLNd,1);
+ GetDialogXY(&CLNd,&sx,&sy);
+ sy++;
+ sx++;
+ print(launchname);
+ GetButtonXY(&CLNd,0,&sx,&sy);
+ if (input(tempstr,36))
+ {
+  strcpy(launchname,tempstr);
+  SaveTEDInfo();
+ }
+ MouseShow();
+ RestoreBackground();
+}
+
+
+////////////////////////////////////////////////////
+//
+// Item - Change the PARM string
+//
+////////////////////////////////////////////////////
+btype CPSb={"                                    ",1,5,1};
+DialogDef CPSd={"Current PARM string:\n\n\nNew PARM string:",38,7,1,&CPSb,NULL};
+
+void Item_PARMstring(void)
+{
+ char tempstr[40];
+
+
+ MouseHide();
+ DrawDialog(&CPSd,1);
+ GetDialogXY(&CPSd,&sx,&sy);
+ sy++;
+ sx++;
+ print(parmstring);
+ GetButtonXY(&CPSd,0,&sx,&sy);
+ if (input(tempstr,36))
+ {
+  strcpy(parmstring,tempstr);
+  _fstrcpy(TEDInfo->parmstring,(char far *)parmstring);
+  SaveTEDInfo();
+ }
+ MouseShow();
+ RestoreBackground();
+}
+
+
+////////////////////////////////////////////////////
+//
+// Item - Change Icon Rows
+//
+////////////////////////////////////////////////////
+btype CIRb={"    ",8,4,1};
+DialogDef CIRd={"Enter amount of icons\n"
+		"to add/delete.\n"
+		"Use + or -.",22,6,1,&CIRb,NULL};
+
+void Item_ChangeIconRows(void)
+{
+ unsigned i,j,dx,dy,max,oxbase,oybase,base;
+ int value,owm;
+ memptr block;
+
+
+ if (!(MapFileHeader->maptype&IPLANE))
+ {
+  ErrDialog("You don't have an icon plane!"," OK ");
+  return;
+ }
+
+ CheckForMapSave();
+
+ oxbase=xbase;
+ oybase=ybase;
+
+ DrawDialog(&CIRd,1);
+ GetButtonXY(&CIRd,0,&dx,&dy);
+ sx=dx;
+ sy=dy;
+ MouseHide();
+ value=inputint(3);
+ MouseShow();
+ if (!value || value==(int)ESCOUT)
+ {
+  RestoreBackground();
+  return;
+ }
+
+ value=SGN(value)*(18*((abs(value)+17)/18));
+
+ base=18*maxiconrows;
+ maxiconrows+=value/18;
+ MapFileHeader->NumIconRows+=value/18;
+
+ owm=whichmap;
+ RestoreBackground();
+
+
+ //
+ // MAKE SURE WE ADJUST TILEINFOM!
+ //
+ MMAllocate(&block,tilemnum+value);
+ for (i=0;i<numtmplanes;i++)
+ {
+  _fmemset(block,0,tilemnum+value);
+  movedata((unsigned)TMinfo[i],0,(unsigned)block,0,base);
+  movedata((unsigned)TMinfo[i],base,
+	   (unsigned)block,base+value,tilemnum-base);
+  MMFreePtr((memptr *)&TMinfo[i]);
+  MMAllocate((memptr *)&TMinfo[i],tilemnum+value);
+  movedata((unsigned)block,0,(unsigned)TMinfo[i],0,tilemnum+value);
+ }
+ MMFreePtr(&block);
+ MapFileHeader->oldtilemnum=tilemnum+value;
+
+
+ //
+ // RUN THROUGH EACH MAP AND ADJUST TILEM VALUES
+ //
+ for (i=0;i<100;i++)
+   if (MapFileHeader->dataoffsets[i]>=0)
+     {
+      whichmap=i;
+      LoadMap(i);
+      max=mapwidth*mapheight;
+      for (j=0;j<max;j++)
+	if (MapFrgnd[j]>0)
+	  MapFrgnd[j]+=value;
+      DirtyFlag=1;
+      SaveMap(0);
+     }
+
+ DirtyFlag=0;
+ whichmap=owm;
+ LoadMap(whichmap);
+ xbase=oxbase;
+ ybase=oybase;
+ DrawMap();
+ ErrDialog("If your map looks messed up,\n"
+	   "you need to change the amount\n"
+	   "of icons in your IGRAB script\n"
+	   "and re-grab your tiles!"," OK ");
+}
+
+
+////////////////////////////////////////////////////
+//
+// Item - Change LAUNCH Icon
+//
+////////////////////////////////////////////////////
+void Item_ChangeLaunchIcon(void)
+{
+ sound(1700);
+ TEDInfo->permicon=whichi-tilenum;
+ delay(30);
+ nosound();
+}
+
+
+////////////////////////////////////////////////////
+//
+// Item - Change Background color
+//
+////////////////////////////////////////////////////
+btype CBCb[]={{"\xb",5,2,1},
+	      {"\xc",16,2,1},
+	      {"Exit",9,2,2}};
+DialogDef CBCd={"Change Backgrnd Color!",22,4,3,&CBCb[0],0};
+void Item_ChangeBkgndColor(void)
+{
+ int which;
+
+ do
+ {
+  which=DoDialog(&CBCd);
+  switch(which)
+  {
+   case 1:
+     sound(1700);
+     if (--BkgndColor<0)
+       BkgndColor=15;
+     TEDInfo->BackgndColor=BkgndColor;
+     DrawMap();
+     DrawInfoBar();
+     break;
+   case 2:
+     sound(1700);
+     if (++BkgndColor>15)
+       BkgndColor=0;
+     TEDInfo->BackgndColor=BkgndColor;
+     DrawMap();
+     DrawInfoBar();
+  }
+  nosound();
+ } while(which>0 && which<3);
+}