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

2185 lines
41 KiB
C++
Raw Blame History

////////////////////////////////////////////////////
////////////////////////////////////////////////////
//
// TED5-2 : Menu Item Routines
//
////////////////////////////////////////////////////
////////////////////////////////////////////////////
#include "ted5.h"
#pragma hdrstop
////////////////////////////////////////////////////
//
// Toggle the INFOBAR on and off
//
////////////////////////////////////////////////////
void Item_ToggleInfo(void)
{
infobaron^=1;
MouseHide();
InitDesktop(TED5MenuBar,0);
FigureScreenEdges();
if (ybase+screenh>mapheight && mapheight>screenh)
ybase--;
DrawMap();
DrawInfoBar();
MouseShow();
}
////////////////////////////////////////////////////
//
// Tile Select
//
////////////////////////////////////////////////////
btype SelTb[]={{" Tiles ",2,21,1},
{" Masked ",11,21,1},
{" Icons ",21,21,1},
{" Exit ",30,21,2}};
DialogDef SelTd={"",38,23,4,&SelTb[0],NULL};
void SelectTiles(int screen)
{
int exitok=0,which,i,numrows,numcols,b0,b1,redraw=0;
//
// if parameter passed, change the screen
//
if (screen)
whichscreen=screen-1;
if (PasteMode || SelectMode) // RE-BLIT MAP IF WE ARE ENTERING WHILE
redraw=1; // FLOATING AN IMAGE
PasteMode=SelectMode=0;
SelX1=SelX2=SelY1=SelY2=-1;
switch(videomode)
{
case CGA:
case EGA1:
case VGA:
SelTd.height=23;
for(i=0;i<4;i++)
SelTb[i].yoff=21;
break;
case EGA2:
SelTd.height=58;
for(i=0;i<4;i++)
SelTb[i].yoff=56;
}
DrawDialog(&SelTd,1);
DrawTileSelect(0,&numrows,&numcols);
selectcols=numcols; // VERY IMPORTANT TO PASTE-FROM-TILESELECT MODE
DrawCurrentTiles();
while(keydown[0x39]); // WAIT FOR SPACE-UP
do
{
which=CheckButtonsRet(&SelTd);
b0=MouseButton()&1;
b1=(MouseButton()>>1)&1;
if (which<0)
{
//
// GRAB CURRENT TILE FROM MATRIX
//
if (b0 || b1)
{
int mx,my;
MouseCoords(&mx,&my);
mx/=8;
if (mx>=left && mx<left+(numcols<<(tsize-1)) &&
my>=16 && my<=16+(numrows<<(2+tsize)))
{
int tile;
tile=((my-16)>>(tsize+2))*numcols+
((mx-left)>>(tsize-1));
if (SelectMode)
{
int thebase;
switch(whichscreen)
{
case TILES: thebase=tilebase/numcols; break;
case MASKED: thebase=tilembase/numcols;
}
if (b0)
{
sound(1000);
SelY1=((my-16)>>(tsize+2))+thebase;
SelX1=((mx-left)>>(tsize-1));
if (SelX2==-1 && SelY2==-1)
{
SelX2=SelX1;
SelY2=SelY1;
}
DrawTileSelect(0,&numrows,&numcols);
nosound();
}
else
if (b1)
{
sound(1000);
SelY2=((my-16)>>(tsize+2))+thebase;
SelX2=((mx-left)>>(tsize-1));
if (SelX1==-1 && SelY1==-1)
{
SelX1=SelX2;
SelY1=SelY2;
}
DrawTileSelect(0,&numrows,&numcols);
nosound();
}
}
else
{
switch(whichscreen)
{
case TILES:
if (XMSlookup[tile+tilebase]>=0)
whicht=tile+tilebase;
else
errsound();
break;
case MASKED:
whichtm=tile+tilembase+numcols*maxiconrows+tilenum;
if (XMSlookup[whichtm]==-1)
whichtm=tilenum;
break;
case ICONS:
if (XMSlookup[tile+tilenum]>=0 || !tile)
whichi=tile+tilenum;
else
errsound();
break;
}
DrawCurrentTiles();
}
}
}
if (keydown[0x48]) // UP
DrawTileSelect(-1,&numrows,&numcols);
else
if (keydown[0x50]) // DOWN
DrawTileSelect(1,&numrows,&numcols);
else
if (keydown[0x47]) // HOME
{
if (whichscreen==TILES)
DrawTileSelect(-tilebase/numcols,&numrows,&numcols);
else
if (whichscreen==MASKED)
DrawTileSelect(-tilembase/numcols,&numrows,&numcols);
}
else
if (keydown[0x4f]) // END
{
if (whichscreen==TILES)
DrawTileSelect(tilenum,&numrows,&numcols);
else
if (whichscreen==MASKED)
DrawTileSelect(tilemnum,&numrows,&numcols);
}
else
if (keydown[0x49]) // PgUP
{
DrawTileSelect(-numrows,&numrows,&numcols);
if (!keydown[0x1d]) // if not CTRL down, wait for keyup
while(keydown[0x49]);
}
else
if (keydown[0x51]) // PgDN
{
DrawTileSelect(numrows,&numrows,&numcols);
if (!keydown[0x1d]) // if not CTRL down, wait for keyup
while(keydown[0x51]);
}
else
if (keydown[0x39]) // SPACEBAR
{
RestoreBackground();
while(keydown[0x39]);
SelectMode=0;
if (redraw)
DrawMap();
DrawInfoBar();
return;
}
else // 'C' TO COPY
if (keydown[0x2e] && (whichscreen==TILES || whichscreen==MASKED))
{
char temp[]="COPY MODE";
sx=screencenterx-strlen(temp)/2;
SelectMode=sy=1;
print(temp);
while(keydown[0x2e]);
}
}
else
switch(which)
{
case 0:
if (!SelectMode)
exitok=1;
else
{
char temp[]=" ";
sx=screencenterx-strlen(temp)/2;
SelectMode=0;
SelX1=SelX2=SelY1=SelY2=-1;
sy=1;
print(temp);
DrawTileSelect(0,&numrows,&numcols);
}
break;
case 4:
if (!SelectMode)
exitok=1;
//
// 'ENTER' TO FINALIZE COPY
//
else
{
char temp[]=" ";
if (MouseButton()) // IF CLICKED ON 'EXIT' WITH MOUSE
break;
sound(500);
sx=screencenterx-strlen(temp)/2;
PasteOK=sy=1;
print(temp);
TileCopy.x=SelX1;
TileCopy.y=SelY1;
TileCopy.w=SelX2-SelX1+1;
TileCopy.h=SelY2-SelY1+1;
TileCopy.MapOrTileSelect=(whichscreen==TILES)+2*(whichscreen==MASKED);
while(keydown[0x1c]);
nosound();
SelectMode=0;
SelX1=SelX2=SelY1=SelY2=-1;
DrawTileSelect(0,&numrows,&numcols);
}
break;
//
// NORMAL TILE SELECT
//
case 1:
if (whichscreen!=TILES)
{
SelX1=SelX2=SelY1=SelY2=-1;
SelectMode=0;
whichscreen=TILES;
DrawDialog(&SelTd,0);
DrawCurrentTiles();
DrawTileSelect(0,&numrows,&numcols);
}
else
errsound();
GetButtonXY(&SelTd,0,&sx,&sy);
MouseHide();
print(SelTb[0].text);
MouseShow();
break;
//
// MASKED TILE SELECT
//
case 2:
if (tilemnum && whichscreen!=MASKED)
{
SelX1=SelX2=SelY1=SelY2=-1;
SelectMode=0;
whichscreen=MASKED;
DrawDialog(&SelTd,0);
DrawCurrentTiles();
DrawTileSelect(0,&numrows,&numcols);
}
else
errsound();
GetButtonXY(&SelTd,1,&sx,&sy);
MouseHide();
print(SelTb[1].text);
MouseShow();
break;
//
// ICON SELECT
//
case 3:
if (tilemnum && whichscreen!=ICONS)
{
whichscreen=ICONS;
DrawDialog(&SelTd,0);
DrawCurrentTiles();
DrawTileSelect(0,&numrows,&numcols);
}
else
errsound();
GetButtonXY(&SelTd,2,&sx,&sy);
MouseHide();
print(SelTb[2].text);
MouseShow();
}
} while(!exitok);
RestoreBackground();
SelectMode=0;
SelX1=SelX2=SelY1=SelY2=-1;
DrawInfoBar();
if (redraw)
DrawMap();
}
//
// DRAW THE CURRENT TILES IN THE TILE-SELECT WINDOW
//
void DrawCurrentTiles(void)
{
MouseHide();
GetButtonXY(&SelTd,0,&sx,&sy);
sy-=1+tsize;
CombineTiles(whicht,0,0,tsize);
DrawTile(sx,sy*8,tsize);
sx+=2;
printhex(whicht);
sy++;
sx-=5;
printint(whicht);
print(" ");
if (tilemnum)
{
GetButtonXY(&SelTd,1,&sx,&sy);
sy-=1+tsize;
CombineTiles(-BkgndColor,whichtm,0,tsize);
DrawTile(sx,sy*8,tsize);
sx+=2;
(whichtm==tilenum)?print(" No "):printhex(whichtm-tilenum);
sy++;
sx-=5;
(whichtm==tilenum)?print(" Tile "):printint(whichtm-tilenum);
print(" ");
GetButtonXY(&SelTd,2,&sx,&sy);
sy-=1+tsize;
CombineTiles(-ICONBACK,whichi,0,tsize);
DrawTile(sx,sy*8,tsize);
sx+=2;
(whichi==tilenum)?print(" No "):printhex(whichi-tilenum);
sy++;
sx-=5;
(whichi==tilenum)?print(" Icon "):printint(whichi-tilenum);
print(" ");
}
MouseShow();
}
//
// CHECK TILESELECT EDGES
//
void CheckTSelectEdges(int x,int y,int basey)
{
int xx,yy,temp;
xx=left+(x<<(tsize-1));
yy=(y<<(tsize-1))+2;
if (SelX2<SelX1)
{
temp=SelX1;
SelX1=SelX2;
SelX2=temp;
}
if (SelY2<SelY1)
{
temp=SelY1;
SelY1=SelY2;
SelY2=temp;
}
if (x==SelX1 && y==SelY1-basey)
{
switch(tsize)
{
case 1: drawchar(xx,yy,1); return;
case 2: drawchar(xx ,yy,1);
drawchar(xx+1,yy,2);
drawchar(xx ,yy+1,4);
break;
case 3: drawchar(xx,yy,1);
drawchar(xx,yy+1,4);
drawchar(xx,yy+2,4);
drawchar(xx,yy+3,4);
drawchar(xx+1,yy,2);
drawchar(xx+2,yy,2);
drawchar(xx+3,yy,2);
break;
}
}
if (x==SelX2 && y==SelY2-basey)
{
switch(tsize)
{
case 1: drawchar(xx,yy,8); return;
case 2: drawchar(xx+1,yy+1,8);
drawchar(xx+1,yy,5);
drawchar(xx,yy+1,7);
break;
case 3: drawchar(xx+3,yy+3,8);
drawchar(xx+3,yy ,5);
drawchar(xx+3,yy+1,5);
drawchar(xx+3,yy+2,5);
drawchar(xx ,yy+3,7);
drawchar(xx+1,yy+3,7);
drawchar(xx+2,yy+3,7);
break;
}
}
if (x==SelX2 && y==SelY1-basey)
{
switch(tsize)
{
case 1: drawchar(xx,yy,3); return;
case 2: drawchar(xx+1,yy,3);
drawchar(xx,yy,2);
drawchar(xx+1,yy+1,5);
break;
case 3: drawchar(xx+3,yy,3);
drawchar(xx+2,yy,2);
drawchar(xx+1,yy,2);
drawchar(xx ,yy,2);
drawchar(xx+3,yy+1,5);
drawchar(xx+3,yy+2,5);
drawchar(xx+3,yy+3,5);
break;
}
}
if (x==SelX1 && y==SelY2-basey)
{
switch(tsize)
{
case 1: drawchar(xx,yy,6); return;
case 2: drawchar(xx,yy+1,6);
drawchar(xx+1,yy+1,7);
drawchar(xx,yy,4);
break;
case 3: drawchar(xx,yy+3,6);
drawchar(xx ,yy+2,4);
drawchar(xx ,yy+1,4);
drawchar(xx ,yy,4);
drawchar(xx+1,yy+3,7);
drawchar(xx+2,yy+3,7);
drawchar(xx+3,yy+3,7);
break;
}
}
if (x==SelX1 && y>SelY1-basey && y<SelY2-basey)
{
switch(tsize)
{
case 3: drawchar(xx,yy+3,4);
drawchar(xx,yy+2,4);
case 2: drawchar(xx,yy+1,4);
case 1: drawchar(xx,yy,4);
break;
}
}
else
if (y==SelY1-basey && x>SelX1 && x<SelX2)
{
switch(tsize)
{
case 3: drawchar(xx+3,yy,2);
drawchar(xx+2,yy,2);
case 2: drawchar(xx+1,yy,2);
case 1: drawchar(xx ,yy,2);
break;
}
}
else
if (x==SelX2 && y>SelY1-basey && y<SelY2-basey)
{
switch(tsize)
{
case 1: drawchar(xx,yy,5); return;
case 2: drawchar(xx+1,yy,5);
drawchar(xx+1,yy+1,5);
break;
case 3: drawchar(xx+3,yy,5);
drawchar(xx+3,yy+1,5);
drawchar(xx+3,yy+2,5);
drawchar(xx+3,yy+3,5);
break;
}
}
else
if (y==SelY2-basey && x>SelX1 && x<SelX2)
{
switch(tsize)
{
case 1: drawchar(xx,yy,7); return;
case 2: drawchar(xx ,yy+1,7);
drawchar(xx+1,yy+1,7);
break;
case 3: drawchar(xx ,yy+3,7);
drawchar(xx+1,yy+3,7);
drawchar(xx+2,yy+3,7);
drawchar(xx+3,yy+3,7);
break;
}
}
}
//
// FILL THE TILE SELECT SCREEN WITH TILES
//
void DrawTileSelect(int deltarow,int *retrows,int *retcols)
{
char tile[32*32];
int numcols,numrows,i,j;
MouseHide();
switch(videomode)
{
case CGA:
case EGA1:
case VGA:
numrows=18-10*(tsize==2)-15*(tsize==3);
left=2;
break;
case EGA2:
numrows=49-23*(tsize==2)-34*(tsize==3);
left=22;
}
switch(tsize)
{
case 1: numcols=36; break;
case 2: numcols=18; break;
case 3: numcols=9;
}
if (whichscreen==TILES && tilebase+numrows*numcols>tilenum)
{
tilebase=0;
numrows=tilenum/numcols;
}
if (whichscreen==MASKED && tilembase+numrows*numcols>tilemnum-maxiconrows*numcols)
{
tilembase=0;
numrows=tilemnum/numcols-maxiconrows;
}
if (whichscreen==ICONS && numrows*numcols>maxiconrows*numcols)
{
tilembase=0;
numrows=maxiconrows;
}
switch((deltarow<0?-1:deltarow>0?1:0))
{
case -1:
switch(whichscreen)
{
case TILES:
tilebase+=deltarow*numcols;
if (tilebase<0)
tilebase=0;
break;
case MASKED:
tilembase+=deltarow*numcols;
if (tilembase<0)
tilembase=0;
}
break;
case 1:
switch(whichscreen)
{
case TILES:
tilebase+=deltarow*numcols;
if (tilebase+numrows*numcols>tilenum)
tilebase=tilenum-numcols*numrows;
break;
case MASKED:
tilembase+=deltarow*numcols;
if (tilembase+numrows*numcols>tilemnum-maxiconrows*numcols)
tilembase=(tilemnum-maxiconrows*numcols)-numcols*numrows;
}
}
switch(whichscreen)
{
case TILES:
for(j=0;j<numrows;j++)
for(i=0;i<numcols;i++)
{
CombineTiles(tilebase+j*numcols+i,0,0,tsize);
if (GridMode)
Overlay(tsize);
DrawTile(i*2+left,j*16+16,tsize);
CheckTSelectEdges(i,j,tilebase/numcols);
}
break;
case MASKED:
for(j=0;j<numrows;j++)
for(i=0;i<numcols;i++)
{
CombineTiles(-BkgndColor,tilenum+numcols*maxiconrows+tilembase+j*numcols+i,0,tsize);
if (GridMode)
Overlay(tsize);
DrawTile(i*2+left,j*16+16,tsize);
CheckTSelectEdges(i,j,tilembase/numcols);
}
break;
default:
for(j=0;j<numrows;j++)
for(i=0;i<numcols;i++)
{
CombineTiles(-ICONBACK,tilenum+j*numcols+i,0,tsize);
if (GridMode)
Overlay(tsize);
DrawTile(i*2+left,j*16+16,tsize);
}
}
MouseShow();
*retrows=numrows;
*retcols=numcols;
}
void errsound(void)
{
sound(1000);
delay(50);
nosound();
}
////////////////////////////////////////////////////
//
// Item - About
//
////////////////////////////////////////////////////
void Item_About(void)
{
char dstr[200]=IDSTSTR;
strcat(dstr,"\n\n IdWare by John Romero\n");
strcat(dstr," ");
strcat(dstr,__DATE__);
strcat(dstr,"\n (C)1991 Id Software\n\n"
" DeluxePaint for Tile Maps! ");
ErrDialog(dstr," OK ");
}
////////////////////////////////////////////////////
//
// Item - Video Mode Switch
//
////////////////////////////////////////////////////
btype VMS1b[]={{" CGA 320x200 ",5,2,1},
{" EGA 320x200 ",5,5,1},
{" EGA 640x350 ",5,8,1},
{" VGA 320x200 ",5,11,1}};
DialogDef VMS1d={"Select the resolution:",22,14,4,&VMS1b[0],NULL};
void Item_ModeSwitch(void)
{
int i,which,rtn;
for(i=0;i<VMS1d.numbuttons;i++)
{
VMS1b[i].border=1;
if (i==lastvideo)
VMS1b[i].border=2;
}
// which=DoDialog(&VMS1d);
//
// Keep track of last video mode!
//
if (videomode==EGA1)
{
which=3;
lastvideo=videomode;
}
else
{
which=2;
lastvideo=videomode;
}
MouseHide();
switch(which)
{
case 0:
MouseShow();
return;
case 1:
if (!CgaXMS)
{
rtn=LoadGraphStuff(1,CGA);
if (!rtn)
{
MouseShow();
ErrDialog("There aren't any CGA\n"
"graphics files available!"," OK ");
return;
}
if (rtn<0)
return;
MouseShow();
}
else
{
xmshandle=CgaXMS;
XMSlookup=CgaXMSlookup;
}
setvideo(CGA);
break;
case 2:
if (!EgaXMS)
{
rtn=LoadGraphStuff(1,EGA1);
if (!rtn)
{
MouseShow();
ErrDialog("There aren't any EGA\n"
"graphics files available!"," OK ");
return;
}
if (rtn<0)
return;
MouseShow();
}
else
{
xmshandle=EgaXMS;
XMSlookup=EgaXMSlookup;
}
setvideo(EGA1);
break;
case 3:
if (!EgaXMS)
{
rtn=LoadGraphStuff(1,EGA1);
if (!rtn)
{
MouseShow();
ErrDialog("There aren't any EGA\n"
"graphics files available!"," OK ");
return;
}
if (rtn<0)
return;
MouseShow();
}
else
{
xmshandle=EgaXMS;
XMSlookup=EgaXMSlookup;
}
setvideo(EGA2);
break;
case 4:
if (!VgaXMS)
{
rtn=LoadGraphStuff(1,VGA);
if (!rtn)
{
MouseShow();
ErrDialog("There aren't any VGA\n"
"graphics files available!"," OK ");
return;
}
if (rtn<0)
return;
MouseShow();
}
else
{
xmshandle=VgaXMS;
XMSlookup=VgaXMSlookup;
}
setvideo(VGA);
}
InitDesktop(TED5MenuBar,0);
DrawInfoBar();
FigureScreenEdges();
if (xbase+screenw>mapwidth)
xbase=mapwidth-screenw;
if (mapwidth<screenw)
xbase=0;
if (ybase+screenh>mapheight)
ybase=mapheight-screenh;
if (mapheight<screenh)
ybase=0;
DrawMap();
MouseShow();
}
////////////////////////////////////////////////////
//
// Item - Map Stats
//
////////////////////////////////////////////////////
btype MapStatsb={" OK ",11,11,2};
DialogDef MapStatsd={" MAP STATS\n\n"
"Width :\n"
"Height :\n"
"Name :\n"
"Planes :",
24,13,1,&MapStatsb,NULL};
void Item_MapStats(void)
{
int ox,oy;
unsigned i,_seg *unique;
DrawDialog(&MapStatsd,1);
MouseHide();
GetDialogXY(&MapStatsd,&sx,&sy);
ox=sx+9;
oy=sy+2;
sx=ox;
sy=oy;
printint(mapwidth);
sx=ox;
sy=oy+1;
printint(mapheight);
sx=ox;
sy=oy+2;
print(MapHeader.name);
sx=ox;
sy=oy+3;
if (MapFileHeader->maptype&BPLANE)
print("BACK");
if (MapFileHeader->maptype&FPLANE)
print(",FORE");
if (MapFileHeader->maptype&IPLANE)
print(",INFO");
//
// Count amount of unique background tiles
//
sx=ox-9;
sy=oy+4;
if (MapFileHeader->maptype&BPLANE)
{
int amount=0;
print("Unique Bkgnd Tiles:");
MMAllocate((memptr *)&unique,tilenum*2);
_fmemset(unique,0,tilenum*2);
for (i=0;i<mapwidth*mapheight;i++)
unique[MapBkgnd[i]]=1;
for (i=0;i<tilenum;i++)
amount+=unique[i];
MMFreePtr((memptr *)&unique);
printint(amount);
}
//
// Count amount of unique foreground tiles
//
sx=ox-9;
sy=oy+5;
if (MapFileHeader->maptype&FPLANE)
{
int amount=0;
print("Unique Frgnd Tiles:");
MMAllocate((memptr *)&unique,tilemnum*2);
_fmemset(unique,0,tilemnum*2);
for (i=0;i<mapwidth*mapheight;i++)
if (MapFrgnd[i])
unique[MapFrgnd[i]]=1;
for (i=0;i<tilemnum;i++)
amount+=unique[i];
MMFreePtr((memptr *)&unique);
printint(amount);
}
//
// Count amount of icons
//
sx=ox-9;
sy=oy+6;
if (MapFileHeader->maptype&IPLANE)
{
int amount=0;
print("Amount of Icons:");
for (i=0;i<mapwidth*mapheight;i++)
if (MapInfoPl[i])
amount++;
printint(amount);
}
//
// Display amount of memory the map needs
//
sx=ox-9;
sy=oy+7;
{
long length=0;
if (MapFileHeader->maptype&BPLANE)
length+=2L*mapwidth*mapheight;
if (MapFileHeader->maptype&FPLANE)
length+=2L*mapwidth*mapheight;
if (MapFileHeader->maptype&IPLANE)
length+=2L*mapwidth*mapheight;
length+=sizeof(MapHeaderStr);
print("Size of map:");
length=(length+1023)/1024;
printint(length);
print("K");
}
MouseShow();
CheckButtons(&MapStatsd);
RestoreBackground();
}
////////////////////////////////////////////////////
//
// Item - Edit New Map
//
////////////////////////////////////////////////////
btype DOSAVEb[]={{" Yes ",3,3,2},
{" No! ",15,3,1}};
DialogDef DOSAVEd={"Your map has changed!\n"
" Save it?",
21,5,2,&DOSAVEb[0],NULL};
void Item_EditMap(void)
{
int which,olddirt;
olddirt=DirtyFlag;
if (DirtyFlag)
{
which=DoDialog(&DOSAVEd);
if (!which)
return;
if (which==1)
Item_SaveMap();
DirtyFlag=0;
}
if ((which=SelectMap(1,CREATED,"TO EDIT"))==-1)
{
DirtyFlag=olddirt;
return;
}
TEDInfo->level=whichmap=which;
LoadMap(whichmap);
MouseHide();
InitDesktop(TED5MenuBar,0);
DrawInfoBar();
FigureScreenEdges();
DrawMap();
MouseShow();
}
////////////////////////////////////////////////////
//
// Item - Save Map
//
////////////////////////////////////////////////////
void Item_SaveMap(void)
{
SaveMap(0);
DirtyFlag=0;
}
////////////////////////////////////////////////////
//
// Item - Create Map
//
////////////////////////////////////////////////////
void Item_CreateMap(void)
{
if (DirtyFlag)
{
int button;
button=DoDialog(&DoCreated);
if (!button)
return;
if (button==1)
Item_SaveMap();
DirtyFlag=0;
}
CreateMap(1);
MouseHide();
InitDesktop(TED5MenuBar,0);
DrawInfoBar();
FigureScreenEdges();
DrawMap();
MouseShow();
}
////////////////////////////////////////////////////
//
// Item - Delete Map
//
////////////////////////////////////////////////////
btype AreSureB[]={{" Yes ",1,4,1},
{" No ",11,4,2}};
DialogDef AreSureD={"Are you sure you\n"
"you want to delete",
18,6,2,&AreSureB[0],NULL};
void Item_DeleteMap(void)
{
MapHeaderStr TempHead;
int whichdel,which,temp;
if ((whichdel=SelectMap(1,CREATED,"TO DELETE"))==-1)
return;
if (whichmap==whichdel)
{
ErrDialog("I'm just not gonna stand for\n"
"you deleting the map you're\n"
"currently editing. I'm not\n"
"gonna doit. Nope."," Gee... ");
return;
}
LoadFile(mapname,(char huge *)&TempHead,
MapFileHeader->dataoffsets[whichdel],sizeof(MapHeaderStr));
MouseHide();
DrawDialog(&AreSureD,1);
GetDialogXY(&AreSureD,&sx,&sy);
sy+=2;
sx=screencenterx-(strlen(TempHead.name)+1)/2;
print(TempHead.name);
print("?");
MouseShow();
which=CheckButtons(&AreSureD);
switch(which)
{
case 1:
temp=whichmap;
whichmap=whichdel;
RestoreBackground();
SaveMap(1);
whichmap=temp;
return;
}
RestoreBackground();
}
////////////////////////////////////////////////////
//
// Item - Amputate Maps
//
////////////////////////////////////////////////////
void Item_Amputate(void)
{
char tstr[40];
MapHeaderStr TempHead;
int which1,which2,whichtemp,i,button;
long temp;
if ((which1 = SelectMap(1,CREATED,"TO START AMPUTATE"))==-1)
return;
LoadFile(mapname,(char huge *)&TempHead,
MapFileHeader->dataoffsets[which1],sizeof(MapHeaderStr));
if ((which2 = SelectMap(1,ANYLIST,"TO END AMPUTATE"))==-1)
return;
if (which2 < which1)
{
whichtemp = which1;
which1 = which2;
which2 = whichtemp;
}
if (whichmap >= which1 && whichmap <= which2)
{
ErrDialog ( "The currently loaded map\n"
"is within that range!\n"
"NON-AMPUTATENESS!!","Wah!");
return;
}
DrawDialog(&AreSureD,1);
button = CheckButtons(&AreSureD);
switch (button)
{
case 1:
for (i = which1;i <= which2;i++)
{
MapFileHeader->dataoffsets[i] = -1;
MapFileHeader->datalengths[i] = 0;
}
DirtyFlag = writeH = 1;
SaveMap(0);
}
}
////////////////////////////////////////////////////
//
// Item - Switch Maps
//
////////////////////////////////////////////////////
void Item_SwitchMap(void)
{
char tstr[40];
MapHeaderStr TempHead;
int which1,which2;
long temp;
while(1)
{
if ((which1=SelectMap(1,CREATED,"TO SWAP"))==-1)
return;
LoadFile(mapname,(char huge *)&TempHead,
MapFileHeader->dataoffsets[which1],sizeof(MapHeaderStr));
strcpy(tstr,"TO SWAP WITH '");
strcat(tstr,TempHead.name);
strcat(tstr,"'");
if ((which2=SelectMap(1,ANYLIST,tstr))==-1)
return;
if (which1==whichmap) // MAKE SURE THE CURRENTLY EDITED MAP GETS CHANGED!
whichmap=which2;
else
if (which2==whichmap)
whichmap=which1;
temp=MapFileHeader->dataoffsets[which1];
strcpy(tstr,MapNames[which1]);
strcpy(MapNames[which1],MapNames[which2]);
strcpy(MapNames[which2],tstr);
MapFileHeader->dataoffsets[which1]=MapFileHeader->dataoffsets[which2];
MapFileHeader->dataoffsets[which2]=temp;
writeH=DirtyFlag=1;
}
}
////////////////////////////////////////////////////
//
// Item - Quit
//
////////////////////////////////////////////////////
btype Qbuttons[]={{" Yes ",4,2,2},{" No ",12,2,1}},
DoSaveb[]={{" Yes ",7,4,2},{" No ",14,4,1}};
DialogDef Qdialog={"Quit - Are you sure?",20,4,2,&Qbuttons[0],NULL},
DoSaved={"The map has been modified.\n"
"Do you want to SAVE it\n"
"before exiting TED5?",26,6,2,&DoSaveb[0],NULL},
DoCreated={"The map has been modified.\n"
"Do you want to SAVE it\n"
"before CREATING a new one?",26,6,2,&DoSaveb[0],NULL};
void Item_Quit(void)
{
int button;
button=DoDialog(&Qdialog);
if (button==1)
{
TEDInfo->lastvid=videomode;
TEDInfo->level=whichmap;
TEDInfo->OldCgaXMS=0;
TEDInfo->OldEgaXMS=0;
TEDInfo->OldVgaXMS=0;
TEDInfo->OldCgaXMSsize=0;
TEDInfo->OldEgaXMSsize=0;
TEDInfo->OldVgaXMSsize=0;
TEDInfo->pflags=((planeton&1)<<6)|
((planemon&1)<<5)|
((planeion&1)<<4)|
((viewton&1)<<2)|
((viewmon&1)<<1)|
(viewion&1);
SaveTEDInfo();
if (DirtyFlag)
{
button=DoDialog(&DoSaved);
if (button==1)
Item_SaveMap();
if (!button)
return; // ESC exits
}
SaveOutputHeader();
Quit("");
}
}
////////////////////////////////////////////////////
//
// Item - Edit Map Names
//
////////////////////////////////////////////////////
char EMNstring[16];
btype EMNb[]={{EMNstring,1,4,1},
{" ",1,8,1},
{" Exit ",7,11,1}};
DialogDef EMNd={" MAP RENAME\n\nChange...\n\n\n\nTo..."
,20,13,3,&EMNb[0],NULL};
void Item_EditMapNames(void)
{
int which,mapnum,redraw=0,omapnum,oxb,oyb;
MapHeaderStr TempHeader;
char temp[16];
CheckForMapSave();
omapnum=whichmap;
oxb=xbase;
oyb=ybase;
if ((mapnum=SelectMap(1,CREATED,"TO RENAME"))<0)
return;
whichmap=mapnum;
LoadMap(whichmap);
strcpy(EMNstring,MapHeader.name);
MouseHide();
DrawDialog(&EMNd,1);
GetDialogXY(&EMNd,&sx,&sy);
MouseShow();
which=2;
#pragma warn -rch
goto badboy;
do
{
which=CheckButtons(&EMNd);
badboy:
#pragma warn +rch
switch(which)
{
case 1:
RestoreBackground();
if ((mapnum=SelectMap(1,CREATED,"TO RENAME"))<0)
{
if (redraw)
DrawInfoBar();
whichmap=omapnum;
LoadMap(whichmap);
xbase=oxb;
ybase=oyb;
return;
}
whichmap=mapnum;
LoadMap(whichmap);
strcpy(EMNstring,MapHeader.name);
MouseHide();
DrawDialog(&EMNd,1);
MouseShow();
case 2:
MouseHide();
GetButtonXY(&EMNd,1,&sx,&sy);
print(EMNb[1].text);
GetButtonXY(&EMNd,1,&sx,&sy);
if (input(temp,15))
{
writeH=1;
strcpy(MapHeader.name,temp);
strcpy(MapNames[mapnum],temp);
DirtyFlag=1;
Item_SaveMap();
}
else
{
GetButtonXY(&EMNd,1,&sx,&sy);
print(EMNb[1].text);
}
MouseShow();
break;
case 3:
which=0;
}
} while(which);
RestoreBackground();
if (redraw)
DrawInfoBar();
whichmap=omapnum;
LoadMap(whichmap);
xbase=oxb;
ybase=oyb;
}
////////////////////////////////////////////////////
//
// Item - Paste Mode
//
////////////////////////////////////////////////////
void Item_Paste(void)
{
if (!TileCopy.w)
return;
ZeroModes();
PasteMode=1;
DrawInfoBar();
px=(pixelx>>(tsize+2))+xbase;
py=((pixely-8)>>(tsize+2))+ybase;
}
////////////////////////////////////////////////////
//
// Item - Copy Mode
//
////////////////////////////////////////////////////
void Item_Copy(void)
{
ZeroModes();
SelectMode=1;
SelX1=SelY1=SelX2=SelY2=-1;
DrawInfoBar();
}
////////////////////////////////////////////////////
//
// Item - LastVideo
//
////////////////////////////////////////////////////
void Item_LastVideo(void)
{
int temp=videomode;
videomode=lastvideo;
lastvideo=temp;
if (temp==EGA1)
videomode=EGA2;
else
videomode=EGA1;
switch(videomode)
{
case CGA:
xmshandle=CgaXMS;
XMSlookup=CgaXMSlookup;
break;
case EGA1:
case EGA2:
xmshandle=EgaXMS;
XMSlookup=EgaXMSlookup;
break;
case VGA:
xmshandle=VgaXMS;
XMSlookup=VgaXMSlookup;
}
MouseHide();
setvideo(videomode);
InitDesktop(TED5MenuBar,0);
DrawInfoBar();
FigureScreenEdges();
if (xbase+screenw>mapwidth)
xbase=mapwidth-screenw;
if (mapwidth<screenw)
xbase=0;
if (ybase+screenh>mapheight)
ybase=mapheight-screenh;
if (mapheight<screenh)
ybase=0;
DrawMap();
MouseShow();
}
////////////////////////////////////////////////////
//
// Item - Switch to the Last Map
//
////////////////////////////////////////////////////
void Item_LastMap(void)
{
int temp;
if (!CheckForMapSave())
return;
if (lastmap==-1)
{
int which=SelectMap(1,CREATED,"TO EDIT");
if (which==-1)
return;
lastmap=which;
}
temp=whichmap;
whichmap=lastmap;
lastmap=temp;
LoadMap(whichmap);
InitDesktop(TED5MenuBar,0);
MouseShow();
DrawMap();
DrawInfoBar();
}
////////////////////////////////////////////////////
//
// Item - Flood Fill!
//
////////////////////////////////////////////////////
void Item_FloodFill(void)
{
ZeroModes();
FillMode=1;
DrawInfoBar();
}
void DoFloodFill(int x,int y,int whichb)
{
#define NUMSPORES 500
int obx[NUMSPORES],oby[NUMSPORES],i,used,j,width,k,highest,height,
vectx[4]={0,1,0,-1},vecty[4]={-1,0,1,0},orgt,orgm,orgi,Ton,Mon,Ion;
unsigned ptr,newoff,whichplanes=0,ctrl=0;
int nx,ny,newt,newm,newi;
if (keydown[0x1d] || whichb)
ctrl++;
whichplanes=planeton+planemon+planeion;
if (whichplanes>1)
{
ErrDialog("I will only allow Flood Filling\n"
"one plane at a time; you have\n"
"more than one plane selected."," OK ");
return;
}
for (i=0;i<NUMSPORES;i++)
obx[i]=oby[i]=-1;
obx[0]=x;
oby[0]=y;
newoff=ptr=oby[0]*mapwidth+obx[0];
width=MapHeader.width;
height=MapHeader.height;
used=1;
highest=1;
if (obx[0]<0 || oby[0]<0 || obx[0]>width || oby[0]>height)
{
FillMode=0;
DrawInfoBar();
return;
}
Ton=planeton;
Mon=planemon;
Ion=planeion;
orgt=*(MapBkgnd+ptr);
orgm=*(MapFrgnd+ptr);
orgi=*(MapInfoPl+ptr);
if (((Ton?whicht==orgt:0) ||
(Mon?whichtm-tilenum==orgm:0) ||
(Ion?whichi-tilenum==orgi:0)) && !ctrl)
{
FillMode=0;
DrawInfoBar();
return;
}
MouseHide();
CopyUndoRegion();
UndoRegion.x=UndoRegion.y=0;
UndoRegion.w=mapwidth;
UndoRegion.h=mapheight;
if (ctrl)
{
unsigned from=(TileCopy.y+(y%TileCopy.h))*mapwidth+
TileCopy.x+(x%TileCopy.w);
switch(TileCopy.MapOrTileSelect)
{
case 0: // COPY BUFFER
Ton=TileCopy.PlanesCopied&BPLANE;
Mon=TileCopy.PlanesCopied&FPLANE;
Ion=TileCopy.PlanesCopied&IPLANE;
newt=CutBkgnd[from];
newm=CutFrgnd[from];
newi=CutInfoPl[from];
break;
case 1: // TILES
Ton=1;
Mon=Ion=0;
newt=((y%TileCopy.h)+TileCopy.y)*selectcols+
TileCopy.x+(x%TileCopy.w);
if (XMSlookup[newt]<0)
Ton=0;
break;
case 2: // MASKED
Ton=Ion=0;
Mon=1;
newm=((y%TileCopy.h)+TileCopy.y)*selectcols+
TileCopy.x+(x%TileCopy.w)+tilenum+maxiconrows*selectcols;
if (XMSlookup[newm]<0)
Mon=0;
else
newm-=tilenum;
}
}
else
{
newt=whicht;
newm=whichtm-tilenum;
newi=whichi-tilenum;
}
if (Ton)
*(MapBkgnd+newoff)=newt;
if (Mon)
*(MapFrgnd+newoff)=newm;
if (Ion)
*(MapInfoPl+newoff)=newi;
do
{
for (i=0;i<=highest;i++)
//
// SEE IF SPORE EXISTS
//
if (obx[i]!=-1)
{
//
// DRAW TILE AT SPORE IF IT'S ONSCREEN
//
if (oby[i]>=ybase && oby[i]<ybase+screenh &&
obx[i]>=xbase && obx[i]<xbase+screenw)
{
unsigned oldt,oldm,oldi,off;
off=oby[i]*width+obx[i];
oldt=*(MapBkgnd+off);
oldm=*(MapFrgnd+off)+tilenum;
oldi=*(MapInfoPl+off)+tilenum;
CombineTiles(viewton?oldt:-BkgndColor,
viewmon?oldm:0,
viewion?oldi:0,
tsize);
DrawTile((obx[i]-xbase)<<(tsize-1),((oby[i]-ybase)<<(tsize+2))+8,tsize);
}
//
// FREE THIS SPORE
//
x=obx[i];
y=oby[i];
obx[i]=-1;
used--;
//
// SEARCH 4 QUADRANTS FOR A SPORE TO FILL
// (ONLY 4 QUADS SO WE DON'T FILL THRU DIAGONALS)
//
if (!ctrl)
for (j=0;j<4;j++)
{
newoff=(y+vecty[j])*mapwidth+x+vectx[j];
if ((Ton?*(MapBkgnd+newoff)==orgt:1) &&
(Mon?*(MapFrgnd+newoff)==orgm:1) &&
(Ion?*(MapInfoPl+newoff)==orgi:1))
{
for (k=0;k<NUMSPORES;k++)
if (obx[k]==-1)
{
obx[k]=x+vectx[j];
oby[k]=y+vecty[j];
if (obx[k]<0 || obx[k]>width || oby[k]<0 || oby[k]>height)
{
obx[k]=-1;
break;
}
used++;
if (Ton)
*(MapBkgnd+newoff)=whicht;
if (Mon)
*(MapFrgnd+newoff)=whichtm-tilenum;
if (Ion)
*(MapInfoPl+newoff)=whichi-tilenum;
DirtyFlag=1;
if (k>highest)
highest=k;
break;
}
}
if (keydown[1]) // ESC OUT
{
while(keydown[1]);
goto done;
}
}
else
for (j=0;j<4;j++)
{
unsigned from;
ny=y+vecty[j];
nx=x+vectx[j];
newoff=ny*mapwidth+nx;
if ((Ton?*(MapBkgnd+newoff)==orgt:1) &&
(Mon?*(MapFrgnd+newoff)==orgm:1) &&
(Ion?*(MapInfoPl+newoff)==orgi:1))
{
for (k=0;k<NUMSPORES;k++)
if (obx[k]==-1)
{
obx[k]=nx;
oby[k]=ny;
if (obx[k]<0 || obx[k]>width || oby[k]<0 || oby[k]>height)
{
obx[k]=-1;
break;
}
from=(TileCopy.y+(ny%TileCopy.h))*mapwidth+
TileCopy.x+(nx%TileCopy.w);
switch(TileCopy.MapOrTileSelect)
{
case 0: // COPY BUFFER
Ton=TileCopy.PlanesCopied&BPLANE;
Mon=TileCopy.PlanesCopied&FPLANE;
Ion=TileCopy.PlanesCopied&IPLANE;
newt=CutBkgnd[from];
newm=CutFrgnd[from];
newi=CutInfoPl[from];
break;
case 1: // TILES
Ton=1;
Mon=Ion=0;
newt=((ny%TileCopy.h)+TileCopy.y)*selectcols+
TileCopy.x+(nx%TileCopy.w);
if (XMSlookup[newt]<0)
Ton=0;
break;
case 2: // MASKED
Ton=Ion=0;
Mon=1;
newm=((ny%TileCopy.h)+TileCopy.y)*selectcols+
TileCopy.x+(nx%TileCopy.w)+tilenum+maxiconrows*selectcols;
if (XMSlookup[newm]<0)
Mon=0;
else
newm-=tilenum;
}
if (Ton)
*(MapBkgnd+newoff)=newt;
if (Mon)
*(MapFrgnd+newoff)=newm;
if (Ion)
*(MapInfoPl+newoff)=newi;
used++;
DirtyFlag=1;
if (k>highest)
highest=k;
break;
}
}
if (keydown[1]) // ESC OUT
{
while(keydown[1]);
goto done;
}
}
}
} while(used);
done:
DrawMap();
MouseShow();
FillMode=0;
DrawInfoBar();
}
////////////////////////////////////////////////////
//
// If map has been changed, ask user if they want
// to SAVE it before continuing.
//
////////////////////////////////////////////////////
btype oktosaveB[]={{" Yes ",10,2,2},{" No ",20,2,1}};
DialogDef oktosaveD={"The map has been modified!\n"
"Save it?",26,4,2,&oktosaveB[0],NULL};
int CheckForMapSave(void)
{
if (DirtyFlag)
{
int which=DoDialog(&oktosaveD);
if (!which)
return 0;
if (which==1)
Item_SaveMap();
}
return 1;
}
////////////////////////////////////////////////////
//
// Zero all special mode flags
//
////////////////////////////////////////////////////
void ZeroModes(void)
{
SelX1=SelX2=SelY1=SelY2=-1;
if (BfillMode || SelectMode || PasteMode || FillMode)
{
DrawMap();
DrawInfoBar();
}
BfillMode=SelectMode=PasteMode=FillMode=0;
}
////////////////////////////////////////////////////
//
// Item - Count Map Tiles
//
////////////////////////////////////////////////////
btype CMTb[]={
{" Exit ",9,20,2},
{" TILE ",1,20,1},
{" MASKED ",17,20,1},
{" Rebuild ",27,20,1}
};
DialogDef CMTd={" Count Unused Map Tiles",38,22,4,&CMTb[0],0};
unsigned char _seg *tarray,_seg *tmarray,thesparse;
void Item_CountTiles(void)
{
enum {TILE,TILEM};
unsigned i,j,dx,dy,max,exit=0,numt,numtm,oxbase,oybase,nsize,nmsize,redraw;
int which,dumrow,dumcol;
char pb,pf,pi;
CheckForMapSave();
oxbase=xbase;
oybase=ybase;
//
// COMPUTE SIZE OF EACH TILE
//
switch(videomode)
{
case CGA: nsize=16; nmsize=32; break;
case EGA1:
case EGA2: nsize=32; nmsize=40; break;
case VGA: nsize=64; nmsize=128;
}
nsize=nsize<<((tsize-1)<<1);
nmsize=nmsize<<((tsize-1)<<1);
MouseHide();
DrawDialog(&CMTd,1);
GetDialogXY(&CMTd,&dx,&dy);
sx=dx+4;
sy=dy+2;
print("Counting tiles in map:");
MouseShow();
MMAllocate((memptr *)&tarray,tilenum);
MMAllocate((memptr *)&tmarray,tilemnum);
_fmemset(tarray,0,tilenum);
_fmemset(tmarray,0,tilemnum);
//
// Now, load each map in & count the tiles
//
pb=MapFileHeader->maptype&BPLANE;
pf=MapFileHeader->maptype&FPLANE;
pi=MapFileHeader->maptype&IPLANE;
for (i=0;i<100;i++)
if (MapFileHeader->dataoffsets[i]>=0)
{
sx=dx+26;
sy=dy+2;
printint(i);
LoadMap(i);
max=mapwidth*mapheight;
for (j=0;j<max;j++)
{
if (pb)
tarray[MapBkgnd[j]]=1;
if (pf)
tmarray[MapFrgnd[j]]=1;
if (pi)
tmarray[MapInfoPl[j]]=1;
}
}
//
// Find a SPARSE tile
//
for (i=0;i<tilenum;i++)
if (XMSlookup[i]<0)
{
thesparse=i;
break;
}
//
// Count unused amount
//
numt=0;
for (i=0;i<tilenum;i++)
if (XMSlookup[i]>=0 && !tarray[i])
numt++;
numtm=0;
for (i=0;i<tilemnum;i++)
if (XMSlookup[i+tilenum]>=0 && !tmarray[i])
numtm++;
//
// INPUT FROM DIALOG
//
do
{
MouseHide();
xormask=0;
sx=dx+2;
sy=dy+17;
print("Unused TILES:");
printint(numt);
print(", unused MASKED:");
printint(numtm);
print(" ");
sx=dx+2;
sy=dy+18;
print("TILE Memory:");
printint((1023l+(long)numt*nsize)/1024);
print("K, MASKED Memory:");
printint((1023l+(long)numtm*nmsize)/1024);
print("K ");
MouseShow();
DrawUnused(0);
redraw=0;
do
{
if (!MouseButton())
which=CheckButtonsRet(&CMTd);
MouseCoords(&pixelx,&pixely);
pixelx/=8;
pixely/=8;
if (MouseButton() && pixelx>dx && pixelx<dx+37 && pixely>dy && pixely<dy+18)
{
int tile=((pixelx-dx-1)>>(tsize-1))+((pixely-dy-1)>>(tsize-1))*(9<<(3-tsize));
switch(whichscreen)
{
case TILES:
if (!tarray[tile+tilebase] && XMSlookup[tile+tilebase]>=0)
{
tarray[tile+tilebase]=1;
numt--;
redraw=1;
}
break;
case MASKED:
if (!tmarray[tile+tilembase] && XMSlookup[tilenum+tile+tilembase]>=0)
{
tmarray[tile+tilembase]=1;
numtm--;
redraw=1;
}
}
continue;
}
switch(which)
{
case 0:
case 1:
exit=1;
continue;
case 2:
MouseHide();
GetButtonXY(&CMTd,which-1,&sx,&sy);
print(CMTb[which-1].text);
whichscreen=TILES;
DrawUnused(0);
MouseShow();
continue;
case 3:
MouseHide();
GetButtonXY(&CMTd,which-1,&sx,&sy);
print(CMTb[which-1].text);
whichscreen=MASKED;
DrawUnused(0);
MouseShow();
continue;
//
// REBUILD GRAPHICS FILE & HEADER
//
case 4:
{
char newgfx[13]="NEW?GA.",
newhead[13]="NEW?HEAD.",
newhobj[13]="NEW?HEAD.",
oldhead[13]="?GAHEAD.";
char _seg *gfxhead;
newgfx[3]=format[0];
newhead[3]=format[0];
newhobj[3]=format[0];
oldhead[0]=format[0];
LoadIn(oldhead,(memptr *)&gfxhead);
for (i=0;i<tilenum;i++)
{
if (tarray[i])
*(gfxhead+i*3)=*(gfxhead+i*3);
}
}
continue;
}
//
// KEY CHECKS
//
if (keydown[1])
{
exit=1;
continue;
}
else
if (keydown[0x50])
DrawUnused(1);
else
if (keydown[0x48])
DrawUnused(-1);
else
if (keydown[0x49])
{
DrawUnused(-8);
while(keydown[0x49]);
}
else
if (keydown[0x51])
{
DrawUnused(8);
while(keydown[0x51]);
}
} while(!redraw && !exit);
} while(!exit);
RestoreBackground();
LoadMap(whichmap);
tilebase=tilembase=0;
xbase=oxbase;
ybase=oybase;
}
//
// FILL THE "UNUSED TILES" SCREEN WITH TILES
//
void DrawUnused(int deltarow)
{
char tile[32*32];
int numcols,numrows,i,j,top;
if (whichscreen==ICONS)
whichscreen=TILES;
MouseHide();
numrows=18-10*(tsize==2)-15*(tsize==3);
left=2;
top=2*8;
if (videomode==EGA2)
{
left=22;
top=20*8;
}
switch(tsize)
{
case 1: numcols=36; break;
case 2: numcols=18; break;
case 3: numcols=9;
}
if (whichscreen==TILES && tilebase+numrows*numcols>tilenum)
{
tilebase=0;
numrows=tilenum/numcols;
}
if (whichscreen==MASKED && tilembase+numrows*numcols>tilemnum)
{
tilembase=0;
numrows=tilemnum/numcols;
}
switch((deltarow<0?-1:deltarow>0?1:0))
{
case -1:
switch(whichscreen)
{
case TILES:
tilebase+=deltarow*numcols;
if (tilebase<0)
tilebase=0;
break;
case MASKED:
tilembase+=deltarow*numcols;
if (tilembase<0)
tilembase=0;
}
break;
case 1:
switch(whichscreen)
{
case TILES:
tilebase+=deltarow*numcols;
if (tilebase+numrows*numcols>tilenum)
tilebase=tilenum-numcols*numrows;
break;
case MASKED:
tilembase+=deltarow*numcols;
if (tilembase+numrows*numcols>tilemnum)
tilembase=tilemnum-numcols*numrows;
}
}
switch(whichscreen)
{
case TILES:
for(j=0;j<numrows;j++)
for(i=0;i<numcols;i++)
{
if (!tarray[tilebase+j*numcols+i] && XMSlookup[tilebase+j*numcols+i]>=0)
CombineTiles(tilebase+j*numcols+i,0,0,tsize);
else
CombineTiles(thesparse,0,0,tsize);
DrawTile(i*2+left,j*16+top,tsize);
}
break;
case MASKED:
for(j=0;j<numrows;j++)
for(i=0;i<numcols;i++)
{
if (!tmarray[tilembase+j*numcols+i] && XMSlookup[tilenum+tilembase+j*numcols+i]>=0)
CombineTiles(-BkgndColor,tilenum+tilembase+j*numcols+i,0,tsize);
else
CombineTiles(thesparse,0,0,tsize);
DrawTile(i*2+left,j*16+top,tsize);
}
}
MouseShow();
}
Reference in New Issue View Git Blame Copy Permalink