id-software/TED5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ded6b82878517e30c8ba6285a2c7f13a1d89f382
TED5/TED5-3.C
T
Ben N ded6b82878 Initial put
2014-06-14 13:53:43 -05:00

2034 lines
41 KiB
C++
Raw Blame History

////////////////////////////////////////////////////
////////////////////////////////////////////////////
//
// 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);
}
Reference in New Issue View Git Blame Copy Permalink