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

2780 lines
60 KiB
C++
Raw Permalink Blame History

////////////////////////////////////////////////////
//
// TED 5
// MultiVideo mode, MultiTile size, MultiMap editor
// by John Romero (C) 1991 Id Software
//
// Development Log:
// -------------------------------------------------
// Mar 19 91 - Starting this thing! Getting it to
// compile with the JHUFF and MEM stuff.
//
// Mar 20 91 - Got the whole deal compiling and wrote
// the EGA drawchar routine and got most of
// Dialogs written!
//
// Mar 25 91 - Forgot some days in there! Got the XMS
// stuff going and started the big initialization
// part. Past init will be lots easier!
//
// Mar 30 91 - Got map selection and dimensioning and
// allocation done. Added more MENU abilities to
// allow more flexible dialogs.
//
// Apr 7 91 - Got project initialization done. Got
// tiles into XMS. Wrote XMS routines for all
// memory functions needed.
//
// Apr 12 91 - FINALLY got the maps loading and saving
// correctly - NO THANKS TO MR.C OVER THERE! You
// see, he can't remember whether his expansion
// routines use the compressed or expanded length
// and that was causing me quite a problem. Got
// it solved and the map shuffling shit works
// PERFECTLY now! Got tile select in, map stats,
// and other stuff...
//
// Apr 19 91 - Got all 3 planes working (drawing,etc.)
// TileSelect screens jam...lots of little options
// thrown in... !!! I got my '75 Cougar !!!
//
// Apr 25 91 - Got map dimension changing done! Fixed
// some small bugs...had a WHOPPER of a fucking
// bug today ... I was overwriting the stack
// when the first background save happened. I'm SURE
// I allocated enough memory -- I don't know...
//
// Apr 27 91 - Map Edge Select works (for Copy) & now I
// draw a frame around the entire region.
//
// May 01 91 - Added a nice feature - retaining the Copy
// buffer wherever it may get toasted. Used XMS so
// I didn't chew mainmem. Also made it so you can
// turn the plane READ/WRITEs ON/OFF (obvious advantage).
// Got Copy/Paste from everywhere with FloatingPaste!
//
// May 03 91 - Got entering values for infoplane stuff & all
// that shit encompasses. Trying to get a cursor drawn
// (with backgrnd save/restore) in CGA & EGA3 modes.
// Wish me luck! ... FUCK IT! I removed EGA3 mode -- it
// was too much shit & kludgery to get a cursor going.
//
// May 08 91 - Well! Let's see...I got Huffman map compression
// done; wrote a MakeOBJ function that can be used within
// the Memory Manager or Standard Borland C. Added .OBJ
// generation to IGRAB. Started the function to generate
// graphic map dumps. Modified the MapHeader stuff more
// when John needed "extras".
//
// May 09 91 - Finished ILBM & Apple Preferred map dumps!
// Fixed a couple hidden bugs, made some things nicer,
// started on Flood Fill...
//
// May 11 91 - Got the TILEINFO/M stuff structured and loading
// and saving (with compression). Putting all the "hidden"
// commands in the menus...
//
// May 13 91 - Stuck in a PROJECT SELECT option (for the Keen2
// trilogy, it'll be nice).
//
// May 16 91 - Got all of TILEINFO stuff finished. Tom and
// Jason's first day! Tom BETAed IGRAB & TED5 big time.
// Had to basically dump the GraphHeaderStr and just
// make the ?GAHEAD.ext file all dataoffsets! (The simpler,
// the better!)
//
// May 19 91 - Almost got the Flood Fill mode working...Tom
// started drawing maps a little early & now I need to add
// a little kludge-fix to reformat his old maps...
//
// May 22 91 - Got AWESOME UNDO working ... fixed the nagging little
// paste/scrolling bug fixed (separated the PasteErase
// & PasteDraw routines) ... finished Block Fill ... fixed
// the floating paste/tile showthru bug ...
//
// May 27 91 - Basically finished up. Tom is BETAing now. I need
// to make SelectMap accept the arrows & make an array for
// the map names instead of the sorry way I'm doing it now.
//
// Jun 2 91 - Got level launching working! Been working on
// TED5 and IGRAB docs and MUSE most of the time.
//
// Jun 18 91 - v0.13 because John C.'s system didn't have
// the SCmapmask set to 15 in CopyEGA!
//
// Jun 20 91 - v0.14: It's annoying to LAUNCH the game and come
// back at the top-left corner!
//
// Jun 26 91 - v0.17: Made LAUNCH with ICON CHANGE ctrl-alt-L
// because Tomshit was having problems...adding Unused Tile
// Scan...fixing a couple minor Tom-irritants...
//
// Jul 12 91 - v0.23: Made VGA & CGA work! Fixed a small
// bug with plane-on starting...added a GridMode for the
// FloatingPaste...XMS Map-Cache...now saves the Launchname
// in TEDINFO? so user program doesn't need to send anything
// back but /LAUNCHED...finally fixed nagging FloatingPaste
// multi-plane viewing bug...
//
// Jul 19 91 - v0.24: Changed TEDINFO structure and added GFXINFO
// to IGRAB. Got most all bugs out...lowercase input now...
//
// Jul 23 91 - v0.26: Only write out .H if it needs to...got the
// SnapPaste feature in that Tom wanted...
//
// Aug 08 91 - v0.28: I can't believe this shit! Mr. Tom decided
// to enter the value "0xF00D" into the map, which was my secret
// value for passing an ESC press back from "inputint". I made
// it a #define now!
//
// Aug 09 91 - v0.29: I FUCKING FRIED THE LIB_A.ASM & LIB.C FILES!
// THESE USED TO HOLD TED5'S TILE-DRAWING AND CGA/VGA ROUTINES!
// AAAARRRRGGGG!!!! Trying to recontruct the program. It'll
// take a bit (I was trying to fix a bug in EditMapNames).
//
// Aug 14 91 - v0.30: Just got finished fixing the FRIED SOURCE HELL!
//
// Aug 16 91 - v0.31: Heh heh, I added the ViewMap function!
//
// Aug 19 91 - v0.32: Added the MapImport function and it works! YES!
//
// Aug 22-23 - v0.35: Fixed a WHOLE BUNCH of little things and added
// some cool features like easier TILEINFO entering, default
// Import drive, F3 to toggle Paste Overlay, etc. Very nice now.
//
// Aug 24 91 - v0.38: Fixed a bug in passing multiple command-line
// parameters to LAUNCHed program. Let user enter new parms and
// a new launch name while in TED5. Added the CarmackCompression
// and trashed the Huffman shit.
//
// Sep 07 91 - v0.40: Only ViewMap planes viewable instead of all; flag
// currently loaded map in SelectMap dialog; check NumIconRows for
// a bogus value for old TED5 compatibility; show map dimensions in
// ChangeMapEdges dialog; CTRL-ALT-arrows will go to map edges.
//
// Sep 12 91 - v0.41: Let user PERMANENTLY change the Launch icon. Also,
// the plane flags are always saved!
//
// Sep 27 91 - v0.43: Added REVIEW_MAP function. Fixed a hard-to-find bug
// in the BlockFill-with-pattern function.
//
// Sep 29 91 - v0.44: Fixed small annoying bug w/Flood-fill w/pattern.
//
// Oct 12 91 - v0.45: Added the PrintReport feature after Carmacizing
// all the maps.
//
// Nov 24 91 - v0.48: Saving the Import Path, added TILEINFOM copying
// from one area to another, getting rid of the "turning the plane
// viewing ON automatically sets it for writing."
//
// May 22 92 - v0.49: Added graphics-select switch to get rid of a dialog.
//
// Oct 20 95 - v0.50: Fixed EGA scrolling bug, added screensaver which comes
// on automatically after 2 minutes. Timelimit adjustable
// through TIMELIMIT command line MED
//
////////////////////////////////////////////////////
#include "ted5.h"
#pragma hdrstop
extern unsigned _stklen=0x2000;
////////////////////////////////////////////////////
//
// Variables
//
////////////////////////////////////////////////////
extern char far TEDCHAR,far VGAPAL,tdata;
extern unsigned doubled[256];
UndoStr UndoRegion;
CopyStr TileCopy;
MapFileHeaderStr _seg *MapFileHeader;
char _seg *Tinfo[10],_seg *TMinfo[10],_seg *GraphHeader;
long _seg *XMSlookup,_seg *EgaXMSlookup,_seg *CgaXMSlookup,_seg *VgaXMSlookup;
int _seg *MapBkgnd,_seg *MapFrgnd,_seg *MapInfoPl,
_seg *CutBkgnd,_seg *CutFrgnd,_seg *CutInfoPl;
MapHeaderStr MapHeader;
TempStruct LaunchInfo;
InfoStruct _seg *TEDInfo;
GfxStruct _seg *GFXInfo;
video lastvideo,videomode;
screentype whichscreen=TILES;
VMapStr VMapData;
char launchname[64],ext[4],format[2],projname[64],mapname[64],planes,
infoname[64],mapheadname[64],MapNames[100][16],parmstring[64];
char SM_name[64],SM_loadname[64],BkgndColor,GfxToUse;
unsigned temp,whichmap,numtplanes,tilenum,tilemnum,numtmplanes,left,
DirtyFlag,tilelen,tilemlen,whicht,whichtm,whichi,
tsize,infoy,infomaxw,mapwidth,mapheight,screenw,usingbat,
screenh,planeton,planemon,planeion,maxiconrows,lasticon,firsticon,
viewton,viewmon,viewion,XMSundoB,XMSundoF,XMSundoI,launched,
XMSmaps,EgaXMS,CgaXMS,VgaXMS,xmshandle,GridMode,SnapMode,snapx,
snapy,snapxsize,snapysize,writeH,NoAbout,F3_flag;
int tilebase=0,tilembase=0,infobaron=1,xbase,ybase,scrnbot,scrnrgt,
FillMode=0,PasteMode=0,SelectMode=0,SelX1=-1,SelY1=-1,PasteOK=0,SelX2=-1,
SelY2=-1,pixelx,pixely,selectcols,px,py,lastmap=-1,TIybase,TIymbase,TIxbase,
TIxmbase,BfillMode,Plotting,TsearchMode,NoXMSFlag;
long CgaXMSsize,EgaXMSsize,VgaXMSsize;
long tics, tictime=1092L*2L;
//
// harderr-called routine
//
int ignore(void)
{
hardresume(0);
return 0;
}
////////////////////////////////////////////////////
//
// Start of The Beast From Hell
//
////////////////////////////////////////////////////
void main(void)
{
ParseCmdline();
SetupKBD();
MMStartup();
setvideo(EGA1);
lastvideo=EGA1;
InitTed5();
harderr(ignore);
tics=biostime(0,0);
DeskEventLoop(HandleEvent,Continuous);
}
////////////////////////////////////////////////////
//
// Parse the commandline
//
////////////////////////////////////////////////////
void ParseCmdline(void)
{
int i;
for (i=1;i<_argc;i++)
{
_argv[i]=strupr(_argv[i]);
if (_argv[i][0]=='-' || _argv[i][0]=='/')
_argv[i]++;
if (!strcmp(_argv[i],"?"))
{
printf(TITLESTR" by John Romero (C) 1991 Id Software, Inc.\n\n");
printf("Command Line parameters:\n");
printf("/? : gets this stuff\n");
printf("/EXT=??? : set the project extension\n");
printf("<filename> : set the Launch filename\n");
printf("/PARMS=<string> : set parms to Launch with\n");
printf("/NOXMSMAPS : don't cache maps in XMS\n");
printf("/GFX=??? : set gfx to use - E,C,V\n");
printf("/TIME=??? : half-minutes until screenblanker (default 2 minutes)\n");
exit(0);
}
else
if (!strncmp(_argv[i],"EXT=",4))
strcpy(ext,&_argv[i][4]);
else
if (!strncmp(_argv[i],"GFX=",4))
GfxToUse = _argv[i][4];
else
if (!strcmp(_argv[i],"LAUNCH"))
launched=1;
else
if (!strcmp(_argv[i],"BAT"))
usingbat=1;
else
if (!strncmp(_argv[i],"PARMS=",6))
strcpy(parmstring,&_argv[i][6]);
else
if (!strncmp(_argv[i],"TIME=",5))
tictime=(atol(&_argv[i][5]))*546L;
else
if (!strcmp(_argv[i],"NOXMSMAPS"))
NoXMSFlag=1;
else
if (!strcmp(_argv[i],"NOABOUT"))
NoAbout=1;
else
strcpy(launchname,_argv[i]);
}
}
////////////////////////////////////////////////////
//
// Event handler - called when button is pressed
// outside menu bar
//
////////////////////////////////////////////////////
void HandleEvent(void)
{
int pixelx,pixely,mx,my,b0,b1;
unsigned loc;
b0=MouseButton()&1;
b1=(MouseButton()>>1)&1;
MouseCoords(&mx,&my);
pixely=my;
pixelx=mx;
//
// PLOT OR PICK-UP TILE
//
if (my>=8 && my<infoy*8 && (b0 || b1))
{
mx=xbase+(mx>>(tsize+2));
my=ybase+((my-8)>>(tsize+2));
loc=my*mapwidth+mx;
if (mx>=mapwidth || my>=mapheight)
errsound();
else
{
if (b1)
{
//
// SELECT BOTTOM-RIGHT EDGE
//
if (SelectMode || BfillMode)
{
SelX2=mx;
SelY2=my;
if ((SelX1==-1 && SelY1==-1) ||
(SelX2<SelX1 || SelY2<SelY1))
{
SelX1=mx;
SelY1=my;
}
DrawMap();
sound(2000);
}
//
// FLOOD FILL!
//
else
if (FillMode)
{
while(MouseButton());
DoFloodFill(mx,my,1);
}
//
// PICK UP TILE(S)
//
else
{
if (planeton)
whicht=*(MapBkgnd+loc);
if (planemon)
whichtm=*(MapFrgnd+loc)+tilenum;
if (planeion)
whichi=*(MapInfoPl+loc)+tilenum;
DrawInfoBar();
//
// IF WE'RE IN TILESEARCH MODE, SHOW IT!
//
if (TsearchMode)
DrawMap();
}
while(MouseButton()>>1);
nosound();
}
if (b0)
{
//
// SELECT TOP-LEFT EDGE
//
if (SelectMode || BfillMode)
{
SelX1=mx;
SelY1=my;
if ((SelX2==-1 && SelY2==-1) ||
(SelX1>SelX2 || SelY1>SelY2))
{
SelX2=mx;
SelY2=my;
}
DrawMap();
sound(2000);
while(MouseButton());
}
//
// FLOOD FILL!
//
else
if (FillMode)
{
while(MouseButton());
DoFloodFill(mx,my,0);
}
//
// PASTE A CHUNK O' TILES/MAP
//
else
if (PasteMode)
{
if (TileCopy.MapOrTileSelect) // TILE-SELECT AREA?
{
int i,j;
if (SnapMode)
{
mx=(mx/snapxsize)*snapxsize+snapx;
my=(my/snapysize)*snapysize+snapy;
}
if (mx+TileCopy.w>mapwidth ||
my+TileCopy.h>mapheight)
sound(500);
else
{
CopyUndoRegion();
UndoRegion.x=mx;
UndoRegion.y=my;
UndoRegion.w=TileCopy.w;
UndoRegion.h=TileCopy.h;
sound(500);
switch(TileCopy.MapOrTileSelect)
{
case 1: // TILES
for (j=0;j<TileCopy.h;j++)
for (i=0;i<TileCopy.w;i++)
{
int val=(j+TileCopy.y)*selectcols+TileCopy.x+i;
if (XMSlookup[val]!=-1)
MapBkgnd[(my+j)*mapwidth+mx+i]=val;
}
break;
case 2: // MASKED
for (j=0;j<TileCopy.h;j++)
for (i=0;i<TileCopy.w;i++)
{
int val=(j+TileCopy.y)*selectcols+TileCopy.x+i+tilenum+maxiconrows*selectcols;
if (XMSlookup[val]!=-1)
MapFrgnd[(my+j)*mapwidth+mx+i]=val-tilenum;
}
}
nosound();
DrawMap();
DirtyFlag=1;
}
while(MouseButton());
nosound();
}
else
{
int i,j;
if (SnapMode)
{
mx=(mx/snapxsize)*snapxsize+snapx;
my=(my/snapysize)*snapysize+snapy;
}
if (mx+TileCopy.w-1<mapwidth && my+TileCopy.h-1<mapheight)
{
sound(500);
CopyUndoRegion();
UndoRegion.x=mx;
UndoRegion.y=my;
UndoRegion.w=TileCopy.w;
UndoRegion.h=TileCopy.h;
for (j=0;j<TileCopy.h;j++)
for (i=0;i<TileCopy.w;i++)
{
int theM,theI;
if (TileCopy.PlanesCopied&BPLANE)
MapBkgnd[(j+my)*mapwidth+mx+i]=
CutBkgnd[(j+TileCopy.y)*mapwidth+TileCopy.x+i];
if (TileCopy.PlanesCopied&FPLANE)
{
theM=CutFrgnd[(j+TileCopy.y)*mapwidth+TileCopy.x+i];
if (theM || F3_flag)
MapFrgnd[(j+my)*mapwidth+mx+i]=theM;
}
if (TileCopy.PlanesCopied&IPLANE)
{
theI=CutInfoPl[(j+TileCopy.y)*mapwidth+TileCopy.x+i];
if (theI || F3_flag)
MapInfoPl[(j+my)*mapwidth+mx+i]=theI;
}
}
nosound();
DrawMap();
DirtyFlag=1;
}
else
sound(500);
while(MouseButton());
}
}
//
// PLOT TILE(S)
//
else
{
unsigned oldt,oldm,oldi;
//
// ARE WE STARTING THE PLOTTING REGION?
//
if (!Plotting)
{
CopyUndoRegion();
UndoRegion.x=mx;
UndoRegion.y=my;
UndoRegion.w=UndoRegion.h=1;
Plotting=1;
}
//
// FLOAT THE PLOTTING REGION
//
if (mx<UndoRegion.x)
UndoRegion.x=mx;
if (my<UndoRegion.y)
UndoRegion.y=my;
if (mx+1>UndoRegion.x+UndoRegion.w)
UndoRegion.w=mx-UndoRegion.x+1;
if (my+1>UndoRegion.y+UndoRegion.h)
UndoRegion.h=my-UndoRegion.y+1;
if (planeton)
*(MapBkgnd+loc)=whicht;
if (planemon)
*(MapFrgnd+loc)=whichtm-tilenum;
if (planeion)
*(MapInfoPl+loc)=whichi-tilenum;
oldt=MapBkgnd[loc];
oldm=MapFrgnd[loc]+tilenum;
oldi=MapInfoPl[loc]+tilenum;
CombineTiles(viewton?oldt:-BkgndColor,viewmon*oldm,oldi*viewion,tsize);
if (GridMode)
Overlay(tsize);
MouseHide();
DrawTile((mx-xbase)<<(tsize-1),(my-ybase)*(4<<tsize)+8,tsize);
CheckInfoValues(mx-xbase,my-ybase,oldi);
MouseShow();
DirtyFlag=1;
}
}
nosound();
}
}
//
// CLICK ON TILES
//
if (b0 && pixely>infoy*8)
{
if (pixelx<7*8)
SelectTiles(1);
else
if (pixelx<8*14 && tilemnum)
SelectTiles(2);
else
if (pixelx<8*20 && tilemnum)
SelectTiles(3);
}
}
#define PEL_WRITE_ADR 0x3c8
#define PEL_READ_ADR 0x3c7
#define PEL_DATA 0x3c9
#define PEL_MASK 0x3c6
void ScreenBlank ( void )
{
int done;
int x;
int y;
int r;
int g;
int b;
int c;
int oldx,oldy;
int i, j;
int xdir,ydir;
int cury;
int size;
int type;
struct {
int x,y;
} snake[256];
unsigned char far * screen=(unsigned char far *)0xa0000000l;
randomize();
_AX=0x13;
asm int 10h
done=0;
size=random(10)+2;
clearkeys();
for (i=255;i>=0;i--)
{
snake[i].x=160;
snake[i].y=100;
}
type=random(11);
r=random(200)+56;
g=random(200)+56;
b=random(200)+56;
outp (PEL_WRITE_ADR,0);
for (i=0;i<=255;i++)
{
outp (PEL_DATA, (unsigned char)((i*r)>>10));
outp (PEL_DATA, (unsigned char)((i*g)>>10));
outp (PEL_DATA, (unsigned char)((i*b)>>10));
}
xdir=0;
while (!xdir)
xdir=random(size<<1)-size;
ydir=0;
while (!ydir)
ydir=random(size<<1)-size;
while (!done)
{
if ((random(100)-80)>0)
{
xdir+=random(3)-1;
ydir+=random(3)-1;
}
for (i=255;i>0;i--)
snake[i]=snake[i-1];
snake[0].x+=xdir;
snake[0].y+=ydir;
if ((snake[0].x<size+1) || (snake[0].x>320-(size+1)))
{
xdir=-xdir;
snake[0].x+=xdir<<1;
}
else if (abs(xdir)>size-1)
xdir=-(xdir>>1);
if ((snake[0].y<size+1) || (snake[0].y>200-(size+1)))
{
ydir=-ydir;
snake[0].y+=ydir<<1;
}
else if (abs(ydir)>size-1)
ydir=-(ydir>>1);
for (x=255;x>=0;x--)
{
if (type<7)
{
for (j=snake[x].y,cury=320*snake[x].y;j<snake[x].y+size;j++,cury+=320)
_fmemset((screen+cury+snake[x].x),255-x,size);
}
else
{
_fmemset((screen+(320*snake[x].y)+snake[x].x),255-x,size);
}
}
oldx=pixelx;
oldy=pixely;
MouseCoords(&pixelx,&pixely);
if ((oldx!=pixelx) || (oldy!=pixely))
done=1;
for (x=0;x<127;x++)
if (keydown[x])
done=1;
}
}
////////////////////////////////////////////////////
//
// Routine called continuously by DeskEventLoop
//
////////////////////////////////////////////////////
void Continuous(void)
{
static int oldx, oldy;
if (biostime(0,0)-tics>tictime)
{
MouseHide();
ScreenBlank();
clearkeys();
videomode=lastvideo;
Item_ModeSwitch();
RedrawDesktop();
DrawMap();
DrawInfoBar();
MouseShow();
tics=biostime(0,0);
}
oldx=pixelx;
oldy=pixely;
MouseCoords(&pixelx,&pixely);
if ((oldx!=pixelx) || (oldy!=pixely))
{
tics=biostime(0,0);
PrintCoords();
}
if (!MouseButton())
Plotting=0;
//
// PLANE "WRITE" SELECTION
//
if (keydown[2] && viewton)
{
planeton^=1;
DrawInfoBar();
DrawMap();
PrintCoords();
tics=biostime(0,0);
while(keydown[2]);
}
if (keydown[3] && tilemnum && (MapFileHeader->maptype&FPLANE) && viewmon)
{
planemon^=1;
DrawInfoBar();
DrawMap();
PrintCoords();
tics=biostime(0,0);
while(keydown[3]);
}
if (keydown[4] && (MapFileHeader->maptype&IPLANE) && viewion)
{
planeion^=1;
DrawInfoBar();
DrawMap();
PrintCoords();
tics=biostime(0,0);
while(keydown[4]);
}
//
// PLANE "VIEW" SELECTION
//
if (keydown[5])
{
viewton^=1;
if (!viewton)
planeton=0;
DrawInfoBar();
DrawMap();
PrintCoords();
tics=biostime(0,0);
while(keydown[5]);
}
if (keydown[6] && tilemnum && (MapFileHeader->maptype&FPLANE))
{
viewmon^=1;
if (!viewmon)
planemon=0;
DrawInfoBar();
DrawMap();
PrintCoords();
tics=biostime(0,0);
while(keydown[6]);
}
if (keydown[7] && (MapFileHeader->maptype&IPLANE))
{
viewion^=1;
if (!viewion)
planeion=0;
DrawInfoBar();
DrawMap();
PrintCoords();
tics=biostime(0,0);
while(keydown[7]);
}
//
// Cancel COPY or PASTE or FLOOD FILL or BLOCK FILL
//
if (keydown[1] && (PasteMode || SelectMode || FillMode ||
BfillMode || TsearchMode))
{
while(keydown[1]);
if (PasteMode)
{
EraseFloatPaste();
px=py=-1;
}
SnapMode=TsearchMode=BfillMode=FillMode=PasteMode=SelectMode=0;
SelX1=SelX2=SelY1=SelY2=-1;
DrawMap();
DrawInfoBar();
tics=biostime(0,0);
}
//
// END OF COPY || BLOCK FILL
//
if (keydown[0x1c] && (SelectMode || BfillMode))
{
int temp,j,i;
tics=biostime(0,0);
while(keydown[0x1c]);
if (SelX2<SelX1)
{
temp=SelX1;
SelX1=SelX2;
SelX2=temp;
}
if (SelY2<SelY1)
{
temp=SelY1;
SelY1=SelY2;
SelY2=temp;
}
//
// BLOCK FILL?
//
if (BfillMode)
{
BfillMode=0;
DrawInfoBar();
DoBlockFill();
SelX1=SelX2=SelY1=SelY2=-1;
}
else
//
// COPY MODE?
//
if (SelectMode)
{
SelectMode=0;
TileCopy.x=SelX1;
TileCopy.y=SelY1;
TileCopy.w=SelX2-SelX1+1;
TileCopy.h=SelY2-SelY1+1;
TileCopy.MapOrTileSelect=0;
TileCopy.PlanesCopied=planeton*BPLANE | planemon*FPLANE | planeion*IPLANE;
//
// DO THE COPY!
//
sound(600);
for (j=SelY1;j<=SelY2;j++)
for (i=SelX1;i<=SelX2;i++)
{
if (planeton)
CutBkgnd[j*mapwidth+i]=MapBkgnd[j*mapwidth+i];
if (planemon)
CutFrgnd[j*mapwidth+i]=MapFrgnd[j*mapwidth+i];
if (planeion)
CutInfoPl[j*mapwidth+i]=MapInfoPl[j*mapwidth+i];
}
DrawInfoBar();
SelX1=SelX2=SelY1=SelY2=-1;
PasteOK=1;
px=py=-1;
nosound();
DrawMap();
}
clearkeys();
}
//
// See if we want to scroll the map!
//
CheckMapScroll();
CheckFloatPaste((pixelx>>(tsize+2))+xbase,((pixely-8)>>(tsize+2))+ybase);
}
////////////////////////////////////////////////////
//
// Draw the current map on the screen at xbase,ybase
//
////////////////////////////////////////////////////
void DrawMap(void)
{
int i,j,imax,jmax;
EraseFloatPaste();
jmax=screenh;
if (jmax>mapheight)
jmax=mapheight;
imax=screenw;
if (imax>mapwidth)
imax=mapwidth;
MouseHide();
for(j=0;j<jmax;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),j*(4<<tsize)+8,tsize);
CheckInfoValues(i,j,tilei);
CheckSelectEdges(i+xbase,j+ybase,i,j);
}
MouseShow();
DrawFloatPaste();
}
////////////////////////////////////////////////////
//
// Figure out SCREENW,SCREENH from videomode & tsize
//
////////////////////////////////////////////////////
void FigureScreenEdges(void)
{
switch(videomode)
{
case CGA:
case EGA1:
case VGA:
screenw=40>>(tsize-1);
screenh=22>>(tsize-1);
break;
case EGA2:
screenw=80>>(tsize-1);
screenh=57>>(tsize-1);
break;
}
if (!infobaron)
{
infoy=100; // WAY OFF THE BOTTOM!
screenh+=2*(tsize==1)+(tsize==2);
}
}
////////////////////////////////////////////////////
//
// Print the coords on the INFOBAR
//
////////////////////////////////////////////////////
void PrintCoords(void)
{
static zeroed=0;
int mx,my;
if (!infobaron)
return;
xormask=0;
MouseCoords(&mx,&my);
if (my<8 || my>=infoy*8)
{
if (zeroed)
return;
sx=infomaxw-9;
sy=infoy;
print("??? ?????");
sx=infomaxw-9;
sy=infoy+1;
print("??? ?????");
zeroed=1;
return;
}
zeroed=0;
mx=mx>>(tsize+2);
sx=infomaxw-9;
sy=infoy;
printint(mx+xbase);
print(" ");
sx=infomaxw-5;
printhex(mx+xbase);
my=(my-8)>>(tsize+2);
sx=infomaxw-9;
sy=infoy+1;
printint(my+ybase);
print(" ");
sx=infomaxw-5;
printhex(my+ybase);
}
////////////////////////////////////////////////////
//
// Draw the INFOBAR
//
////////////////////////////////////////////////////
void DrawInfoBar(void)
{
int ox,oy;
if (PasteMode)
{
px=py=-1;
CheckFloatPaste((pixelx>>(tsize+2))+xbase,((pixely-8)>>(tsize+2))+ybase);
}
if (!infobaron)
return;
EraseFloatPaste();
ox=sx=0;
switch(videomode)
{
case CGA:
case EGA1:
case VGA:
oy=sy=23-2*(tsize==3);
infomaxw=40;
break;
case EGA2:
oy=sy=58-2*(tsize==3)-1*(tsize==2);
infomaxw=80;
}
MouseHide();
infoy=oy;
bar(0,infoy,infomaxw-1,infoy+1,' ');
if (SelectMode)
{
sx=leftedge=1;
sy=infoy;
print("Copy Mode\nESC to exit");
}
else
if (TsearchMode)
{
sx=leftedge=1;
sy=infoy;
print("Tile Search Mode\nESC to exit");
}
else
if (BfillMode)
{
sx=leftedge=1;
sy=infoy;
print("Block Fill Mode\nESC to exit");
}
else
if (PasteMode)
{
sx=leftedge=1;
sy=infoy;
print("Paste Mode\nESC to exit");
}
else
if (FillMode)
{
sx=leftedge=1;
sy=infoy;
print("Flood Fill Mode\nESC to exit");
}
else
{
CombineTiles(whicht,0,0,tsize);
DrawTile(ox,oy*8+8*(tsize==1),tsize);
sx=ox+2+2*(tsize==3);
sy=oy;
printhex(whicht);
sx-=5;
sy++;
printint(whicht);
print(" ");
if (tilemnum)
{
ox+=7;
CombineTiles(-BkgndColor,whichtm,0,tsize);
DrawTile(ox,oy*8+8*(tsize==1),tsize);
sx=ox+2+2*(tsize==3);
sy=oy;
(whichtm==tilenum)?print(" No "):printhex(whichtm-tilenum);
sx-=5;
sy++;
(whichtm==tilenum)?print("Tile"):printint(whichtm-tilenum);
print(" ");
ox+=7;
CombineTiles(-ICONBACK,(whichi>lasticon)?firsticon:whichi,0,tsize);
DrawTile(ox,oy*8+8*(tsize==1),tsize);
sx=ox+2+2*(tsize==3);
sy=oy;
(whichi==tilenum)?print(" No "):printhex(whichi-tilenum);
sx-=5;
sy++;
(whichi==tilenum)?print("Icon"):printint(whichi-tilenum);
print(" ");
}
}
sx=infomaxw-11;
sy=infoy;
print("X=");
sy++;
sx-=2;
print("Y=");
sx=infomaxw-((videomode==EGA2)?19:18);
sy=infoy+1;
print("123");
if (SnapMode)
{
sx=infomaxw-((videomode==EGA2)?21:20);
sy=infoy+1;
print("S");
}
if (GridMode)
{
sx=infomaxw-((videomode==EGA2)?20:19);
sy=infoy+1;
print("G");
}
sx=infomaxw-((videomode==EGA2)?19:18);
sy=infoy;
(planeton)?print("B"):print(" ");
(planemon)?print("F"):print(" ");
(planeion)?print("I"):print(" ");
sx=infomaxw-15;
sy=infoy+1;
print("456");
sx=infomaxw-15;
sy=infoy;
(viewton)?print("b"):print(" ");
(viewmon)?print("f"):print(" ");
(viewion)?print("i"):print(" ");
if (videomode==EGA2)
{
sx=screencenterx-strlen(MapHeader.name)/2;
sy=infoy;
print(MapHeader.name);
}
DrawFloatPaste();
MouseShow();
}
////////////////////////////////////////////////////
////////////////////////////////////////////////////
////////////////////////////////////////////////////
//
// Initialize TED5:
//
// * Project Select if multiple projects
// * If Project has NO LEVELS:
// * Init Level 1
// * Init TILEINFO
// * Init TEDINFO file
// * Load TILES into XMS
//
////////////////////////////////////////////////////
////////////////////////////////////////////////////
////////////////////////////////////////////////////
char bstrings[10][15];
btype ProjButns[10];
DialogDef ProjSelect={"Select the project to work on:",
30,0,0,&ProjButns[0],DrawProjBord};
void InitTed5(void)
{
char pname[15];
unsigned i,loop,which;
MouseInit();
MouseShow();
if (!MouseStatus)
{
ErrDialog("Sorry, but TED5 will NOT\n"
"operate without a mouse!\n"," Press ENTER ");
Quit("Only REAL developers have a mouse!");
}
MouseOrigin(0,0);
ErrDialog("Initializing. One moment.","");
//
// Create bit-doubling lookup table
// for CGA font creation
//
for (loop=0;loop<256;loop++)
{
unsigned result,temp=loop;
asm mov ax,temp
asm mov ah,al
asm mov cx,8
LOOP0:
asm shl al,1
asm rcl bx,1
asm shl ah,1
asm rcl bx,1
asm loop LOOP0
asm xchg bh,bl
asm mov result,bx
doubled[loop]=result;
}
//
// Init everything!
//
InitXMS();
FindGraphFile();
LoadInfoFile();
LoadMapHeader();
RestoreBackground();
LoadGraphStuff(0,TEDInfo->lastvid);
DrawInfoBar();
DrawMap();
if (!launched && !NoAbout)
Item_About();
launched=0;
}
////////////////////////////////////////////////////
////////////////////////////////////////////////////
//
// Load the MAPTEMP.ext header in...
//
////////////////////////////////////////////////////
////////////////////////////////////////////////////
btype SelectTsizeb[]={{" 8x8 ",1,2,1},
{" 16x16 ",1,5,1},
{" 32x32 ",1,8,1}};
DialogDef SelectTsize={" Which tile size to use?"
,26,10,3,&SelectTsizeb[0],STnot};
void LoadMapHeader(void)
{
unsigned size,i,j,pflag;
char types=0;
strcpy(mapheadname,"MAPTHEAD.");
strcat(mapheadname,ext);
strcpy(mapname,"MAPTEMP.");
strcat(mapname,ext);
strcpy(SM_name,"MAPTEMP1.");
strcat(SM_name,ext);
strcpy(SM_loadname,"MAPTEMP.");
strcat(SM_loadname,ext);
if (access(mapheadname,0))
{
int i;
//
// Gotta create a new map file!
//
MMAllocate((memptr *)&MapFileHeader,sizeof(MapFileHeaderStr));
for (i=0;i<sizeof(MapFileHeaderStr);i++)
*((char _seg *)MapFileHeader+i)=0;
MapFileHeader->RLEWtag=0xabcd;
for (i=0;i<100;i++)
{
MapFileHeader->dataoffsets[i]=-1;
MapFileHeader->datalengths[i]=0;
memset(MapNames[i],0,16);
}
if (!GFXInfo->num8 &&
!GFXInfo->num8m &&
!GFXInfo->num16 &&
!GFXInfo->num16m &&
!GFXInfo->num32 &&
!GFXInfo->num32m)
{
ErrDialog("Uhh...you 'neglected' to\n"
"grab tiles to use. Running\n"
"TED5 is quite useless at\n"
"this point, I'm afraid.","Duh!");
Quit("Get some tiles ... quick! Me hungry!");
}
if (!GFXInfo->num8 &&
!GFXInfo->num16 &&
!GFXInfo->num32)
{
ErrDialog("You may have grabbed some\n"
"MASKED tiles, but I require\n"
"NON-MASKED tiles as a\n"
"minimum requirement!","Geez...");
Quit("Please grab some normal tiles!");
}
types+=(GFXInfo->num8>0)+(GFXInfo->num16>0)+(GFXInfo->num32>0);
redo:
if (types>1)
{
int which;
which=DoDialog(&SelectTsize);
switch(which)
{
case 0:
Quit("");
case 1:
if (!GFXInfo->num8)
which=0;
break;
case 2:
if (!GFXInfo->num16)
which=0;
break;
case 3:
if (!GFXInfo->num32)
which=0;
break;
}
MapFileHeader->tsize=TEDInfo->tsize=tsize=which;
}
else
{
if (GFXInfo->num8)
TEDInfo->tsize=1;
else
if (GFXInfo->num16)
TEDInfo->tsize=2;
else
if (GFXInfo->num32)
TEDInfo->tsize=3;
MapFileHeader->tsize=tsize=TEDInfo->tsize;
}
//
// pick the planes that all maps will use
//
if (PickMorePlanes())
goto redo;
//
// initialize TILEINFO/TILEINFOM
//
switch(tsize)
{
case 1:
tilenum=GFXInfo->num8;
tilemnum=GFXInfo->num8m;
break;
case 2:
tilenum=GFXInfo->num16;
tilemnum=GFXInfo->num16m;
break;
case 3:
tilenum=GFXInfo->num32;
tilemnum=GFXInfo->num32m;
}
InitTileinfo();
if (numtplanes || numtmplanes) // only input if applicable
Item_EditTinfoNames(); // void where prohibited
//
// now create a map!
//
CreateMap(0);
FigureScreenEdges();
MapFileHeader->NumIconRows=maxiconrows=InputIconAmount();
}
//
// MAP FILE ALREADY IN PLACE. LOAD STUFF IN...
//
else
{
memptr block,tempblock;
LoadIn(mapheadname,(memptr *)&MapFileHeader);
//
// See if the NumIconRows is toasty (old TED5 compatibility)
//
if (MapFileHeader->NumIconRows>50)
MapFileHeader->NumIconRows=4;
//
// has the TEDINFO?.ext file been changed?
// if so, reconstruct pertinent data...
//
if (!TEDInfo->tsize)
{
tsize=TEDInfo->tsize=MapFileHeader->tsize;
switch(tsize)
{
case 1:
tilenum=GFXInfo->num8;
tilemnum=GFXInfo->num8m;
break;
case 2:
tilenum=GFXInfo->num16;
tilemnum=GFXInfo->num16m;
break;
case 3:
tilenum=GFXInfo->num32;
tilemnum=GFXInfo->num32m;
}
}
maxiconrows=MapFileHeader->NumIconRows;
//
// Read-in all the Map Names
//
for (i=0;i<100;i++)
if (MapFileHeader->dataoffsets[i]!=-1)
{
MapHeaderStr TempHead;
LoadFile(mapname,(char huge *)&TempHead,
MapFileHeader->dataoffsets[i],sizeof(MapHeaderStr));
strcpy(MapNames[i],TempHead.name);
}
FigureScreenEdges();
if (!TEDInfo->level)
{
for(i=0;i<100;i++)
if (MapFileHeader->dataoffsets[i]!=-1)
{
whichmap=TEDInfo->level=i;
break;
}
}
else
whichmap=TEDInfo->level;
LoadMap(TEDInfo->level);
//
// IF WE WERE LAUNCHED AND CHARACTER POSITION WAS CHANGED,
// PUT IT BACK!
//
if (launched && (TEDInfo->lastx || TEDInfo->lasty))
{
int i;
for (i=0;i<mapwidth*mapheight;i++)
if (MapInfoPl[i]==TEDInfo->permicon)
{
MapInfoPl[i]=0;
MapInfoPl[TEDInfo->lasty*mapwidth+TEDInfo->lastx]=TEDInfo->permicon;
TEDInfo->lastx=TEDInfo->lasty=0;
DirtyFlag=1;
break;
}
}
//
// POSITION SCREEN
//
xbase=TEDInfo->oscrx;
ybase=TEDInfo->oscry;
if (xbase+screenw>mapwidth)
xbase=mapwidth-screenw;
if (ybase+screenh>mapheight)
ybase=mapheight-screenh;
if (launched)
_fmemcpy((void far *)parmstring,(void far *)TEDInfo->parmstring,64);
//
// LOAD TILEINFO/M AND ADJUST IF IT CHANGED
//
numtplanes=MapFileHeader->numtplanes;
numtmplanes=MapFileHeader->numtmplanes;
pflag=0;
for (i=0;i<numtplanes;i++)
{
//
// SPACE FOR OLD TILEINFO TO DECOMPRESS INTO
//
MMAllocate(&tempblock,MapFileHeader->oldtilenum);
//
// SPACE FOR OLD TILEINFO TO LOAD INTO
//
MMAllocate(&block,MapFileHeader->tileinfolen[i]);
LoadFile(mapheadname,MK_FP(block,0),MapFileHeader->tileinfooff[i],MapFileHeader->tileinfolen[i]);
//
// DECOMPRESS FROM "BLOCK" TO "TEMPBLOCK"
//
RLEBExpand(MK_FP(block,0),MK_FP(tempblock,0),
MapFileHeader->oldtilenum,MapFileHeader->RLEWtag);
MMFreePtr(&block);
//
// ALLOCATE TINFO ARRAY
//
MMAllocate((memptr *)&Tinfo[i],tilenum);
//
// MOVE FROM "TEMPBLOCK" TO "TINFO[I]" ARRAY
//
if (MapFileHeader->oldtilenum<tilenum)
{
movedata((unsigned)tempblock,0,(unsigned)Tinfo[i],0,MapFileHeader->oldtilenum);
//
// IF NEW TILEINFO IS MORE, FILL END WITH 0s
//
for (j=MapFileHeader->oldtilenum;j<tilenum;j++)
*(Tinfo[i]+j)=0;
DirtyFlag=pflag=1;
}
else
{
movedata((unsigned)tempblock,0,(unsigned)Tinfo[i],0,tilenum);
if (MapFileHeader->oldtilenum>tilenum)
DirtyFlag=pflag=2;
}
MMFreePtr(&tempblock);
}
switch(pflag)
{
case 1:
ErrDialog("The new TILEINFO data has\n"
"been expanded to accomodate\n"
"the newly grabbed tiles."," OK ");
break;
case 2:
ErrDialog("The new TILEINFO data has\n"
"been shrunk due to a reduced\n"
"amount of tiles."," OK ");
}
pflag=0;
if (tilemnum && (MapFileHeader->maptype&FPLANE))
for (i=0;i<numtmplanes;i++)
{
MMAllocate(&tempblock,MapFileHeader->oldtilemnum);
MMAllocate(&block,MapFileHeader->tileinfomlen[i]);
LoadFile(mapheadname,MK_FP(block,0),MapFileHeader->tileinfomoff[i],MapFileHeader->tileinfomlen[i]);
RLEBExpand(MK_FP(block,0),MK_FP(tempblock,0),
MapFileHeader->oldtilemnum,MapFileHeader->RLEWtag);
MMFreePtr(&block);
MMAllocate((memptr *)&TMinfo[i],tilemnum);
if (MapFileHeader->oldtilemnum<tilemnum)
{
movedata((unsigned)tempblock,0,(unsigned)TMinfo[i],0,MapFileHeader->oldtilemnum);
for (j=MapFileHeader->oldtilemnum;j<tilemnum;j++)
*(TMinfo[i]+j)=0;
DirtyFlag=pflag=1;
}
else
{
movedata((unsigned)tempblock,0,(unsigned)TMinfo[i],0,tilemnum);
if (MapFileHeader->oldtilemnum>tilemnum)
DirtyFlag=pflag=2;
}
MMFreePtr(&tempblock);
}
switch(pflag)
{
case 1:
ErrDialog("The new TILEINFOM data has\n"
"been expanded to accomodate\n"
"the newly grabbed masked tiles."," OK ");
break;
case 2:
ErrDialog("The new TILEINFOM data has\n"
"been shrunk due to a reduced\n"
"amount of tiles."," OK ");
}
#if 0
//
// TURN ON PLANES
//
viewton=planeton=1;
if (MapFileHeader->maptype&FPLANE)
viewmon=1;
if (MapFileHeader->maptype&IPLANE)
viewion=1;
planemon=planeion=0;
#endif
}
//
// LOAD THE MAPFILE INTO XMS IF ENOUGH ROOM
//
if (1024L*XMSTotalFree()>2L*filelen(mapname) && !NoXMSFlag)
{
#define LBCSIZE 0x4000
memptr block;
long size,clen,coff;
size=filelen(mapname);
MMAllocate(&block,LBCSIZE);
XMSmaps=XMSAllocate(size);
//
// LOAD ENTIRE MAPFILE FROM DISK TO XMS!
//
coff=0;
do
{
clen=LBCSIZE;
if (size<LBCSIZE)
clen=size;
LoadFile(mapname,MK_FP(block,0),coff,clen);
XMSmove(0,(long)MK_FP(block,0),XMSmaps,coff,clen);
size-=LBCSIZE;
coff+=clen;
} while(size>0);
MMFreePtr(&block);
}
}
void STnot(int x,int y)
{
sx=x+10;
sy=y+2;
if (!GFXInfo->num8)
print("<-Not available");
else
{
printint(GFXInfo->num8);
print(" total tiles");
}
sx=x+10;
sy=y+5;
if (!GFXInfo->num16)
print("<-Not available");
else
{
printint(GFXInfo->num16);
print(" total tiles");
}
sx=x+10;
sy=y+8;
if (!GFXInfo->num32)
print("<-Not available");
else
{
printint(GFXInfo->num32);
print(" total tiles");
}
}
////////////////////////////////////////////////////
////////////////////////////////////////////////////
//
// Load the graphheader file & ?GAGRAPH.ext file and stick it in XMS!
//
////////////////////////////////////////////////////
////////////////////////////////////////////////////
int LoadGraphStuff(int rtn,video newvid)
{
#define NUMFASTDECOMP 100 // # of tiles in fast decompress buffer
char gname[14]="?GAHEAD.",gname1[14]="?GAGRAPH.",_seg *packed,_seg *unpack,
dictname[14]="?GADICT.",hufftable[1020],_seg *CacheBlock;
unsigned index,indexm,num,numm,i,realnum,realnumm,ox,oy,cacheon=0,_seg *tile_len,
_seg *tilem_len,cacheon_h;
long expsize,expmsize,xmsoff=0,unpackoff,unpackmax,unpacksize,
unpackxms;
video tempvid,pickedvid;
char huge *offsets;
strcat(gname,ext);
strcat(gname1,ext);
strcat(dictname,ext);
gname[0]=format[0];
gname1[0]=format[0];
dictname[0]=format[0];
if (!launched)
switch(format[0])
{
case 'C': pickedvid=CGA; break;
case 'E': pickedvid=EGA1; break;
case 'V': pickedvid=VGA;
}
else
pickedvid=TEDInfo->lastvid;
//
// VALIDATE GRAPHICS MODE
//
tempvid=rtn?newvid:pickedvid;
switch(tempvid)
{
case CGA:
gname[0]='C';
if (access(gname,0))
{
if (rtn)
return 0;
}
else
{
TEDInfo->lastvid=CGA;
dictname[0]=format[0]=gname1[0]='C';
setvideo(CGA);
InitDesktop(TED5MenuBar,1);
MouseShow();
break;
}
case EGA1:
case EGA2:
gname[0]='E';
if (access(gname,0))
{
if (rtn)
return 0;
}
else
{
TEDInfo->lastvid=tempvid;
dictname[0]=format[0]=gname1[0]='E';
setvideo(tempvid);
InitDesktop(TED5MenuBar,1);
MouseShow();
break;
}
case VGA:
gname[0]='V';
if (access(gname,0))
{
if (rtn)
return 0;
gname[0]=format[0];
}
else
{
TEDInfo->lastvid=VGA;
dictname[0]=format[0]=gname1[0]='V';
setvideo(VGA);
InitDesktop(TED5MenuBar,1);
MouseShow();
break;
}
}
//
// FIND HEADER & LOAD IT
//
if (access(gname,0))
{
char errstr[100]="Can't find the ";
strcat(errstr,format);
strcat(errstr,"GAHEAD.");
strcat(errstr,ext);
strcat(errstr,"\nfile! Maybe you didn't\n"
"copy it from the graphics\n"
"subdirectory?");
ErrDialog(errstr," OK ");
if (rtn)
return 0;
Quit("You're stupid! Copy the damn file!");
}
LoadIn(gname,(memptr *)&GraphHeader);
switch(MapFileHeader->tsize)
{
case 1:
index=GFXInfo->off8;
indexm=GFXInfo->off8m;
num=GFXInfo->num8;
numm=GFXInfo->num8m;
if (indexm==index+1)
{
ErrDialog("I'm sorry, but you need to\n"
"capture your 8x8 tiles\n"
"individually, and not in a\n"
"big chunk."," Alright ");
if (rtn)
return 0;
Quit("Regrab-time, bag o' shit!");
}
switch(tempvid)
{
case CGA: expsize=16; expmsize=32; break;
case EGA1:
case EGA2: expsize=32; expmsize=40; break;
case VGA: expsize=64; expmsize=128;
}
break;
case 2:
index=GFXInfo->off16;
indexm=GFXInfo->off16m;
num=GFXInfo->num16;
numm=GFXInfo->num16m;
switch(tempvid)
{
case CGA: expsize=64; expmsize=128; break;
case EGA1:
case EGA2: expsize=128; expmsize=128+32; break;
case VGA: expsize=256; expmsize=512;
}
break;
case 3:
index=GFXInfo->off32;
indexm=GFXInfo->off32m;
num=GFXInfo->num32;
numm=GFXInfo->num32m;
switch(tempvid)
{
case CGA: expsize=256; expmsize=512; break;
case EGA1:
case EGA2: expsize=512; expsize=512+4*32; break;
case VGA: expsize=1024; expmsize=2048;
}
}
//
// MOVE TILES INTO XMS MEMORY!
//
MMAllocate((memptr *)&packed,expmsize);
unpackmax=expmsize*NUMFASTDECOMP;
MMAllocate((memptr *)&unpack,unpackmax);
tilelen=expsize;
tilemlen=expmsize;
offsets=MK_FP(GraphHeader,0);
//
// LOAD DICTIONARY IN & INITIALIZE IT
//
if (!launched)
{
char _seg *block;
if (access(dictname,0))
{
char errst[200]="I can't find the \n";
strcat(errst,dictname);
strcat(errst," file!");
ErrDialog(errst," OK ");
if (rtn)
return 0;
Quit("Look in the graphics grab directory!");
}
LoadIn(dictname,(memptr *)&block);
movedata((unsigned)block,0,FP_SEG(hufftable),FP_OFF(hufftable),1020);
MMFreePtr((memptr *)&block);
OptimizeNodes((huffnode *)hufftable);
}
//
// Count up the REAL number of tiles there are!
// Build tables for tile lengths
//
MMAllocate((memptr *)&tile_len,num*2);
for (realnum=i=0;i<num;i++)
{
int j;
if (OFF3(offsets,i+index)!=0xffffff)
{
realnum++;
if (OFF3(offsets,i+index+1)!=0xffffff)
tile_len[i]=OFF3(offsets,i+index+1)-OFF3(offsets,i+index);
else
for (j=i+1;j<num+numm;j++)
if (OFF3(offsets,j+index)!=0xffffff)
{
tile_len[i]=OFF3(offsets,j+index)-OFF3(offsets,i+index);
break;
}
}
else
tile_len[i]=0;
}
MMAllocate((memptr *)&tilem_len,numm*2);
for (realnumm=i=0;i<numm;i++)
{
int j;
if (OFF3(offsets,i+indexm)!=0xffffff)
{
realnumm++;
if (OFF3(offsets,i+indexm+1)!=0xffffff)
tilem_len[i]=OFF3(offsets,i+indexm+1)-OFF3(offsets,i+indexm);
else
for (j=i+1;j<numm+1;j++)
if (OFF3(offsets,j+indexm)!=0xffffff)
{
tilem_len[i]=OFF3(offsets,j+indexm)-OFF3(offsets,i+indexm);
break;
}
}
else
tilem_len[i]=0;
}
//
// DON'T REALLOCATE THIS IF WE'RE COMING BACK FROM A LAUNCH!
//
if (!launched)
{
long size=expsize*realnum+expmsize*realnumm,savings=0;
if (1024L*XMSTotalFree()<size)
{
savings=CgaXMSsize+EgaXMSsize+VgaXMSsize;
if (1024L*XMSTotalFree()<size-savings)
{
MouseShow();
ErrDialog("Not enough memory to load\n"
"requested graphics.\n"," OK ");
MMFreePtr((memptr *)&GraphHeader);
MMFreePtr((memptr *)&packed);
MMFreePtr((memptr *)&unpack);
if (rtn)
return -1;
else
Quit("Get more Extended memory!");
}
if (CgaXMS)
{
XMSFreeMem(CgaXMS);
MMFreePtr((memptr *)&CgaXMSlookup);
}
if (EgaXMS)
{
XMSFreeMem(EgaXMS);
MMFreePtr((memptr *)&EgaXMSlookup);
}
if (VgaXMS)
{
XMSFreeMem(VgaXMS);
MMFreePtr((memptr *)&VgaXMSlookup);
}
CgaXMSsize=EgaXMSsize=VgaXMSsize=CgaXMS=EgaXMS=VgaXMS=0;
}
switch(tempvid)
{
case CGA:
xmshandle=CgaXMS=XMSAllocate(size);
CgaXMSsize=size;
break;
case EGA1:
case EGA2:
xmshandle=EgaXMS=XMSAllocate(size);
EgaXMSsize=size;
break;
case VGA:
xmshandle=VgaXMS=XMSAllocate(size);
VgaXMSsize=size;
}
ErrDialog("GRAPHICS INSTALLATION\n"
"Decompressing and\n"
"moving tiles into\n"
"Extended memory:","");
}
else
{
long size;
CgaXMS=TEDInfo->OldCgaXMS;
EgaXMS=TEDInfo->OldEgaXMS;
VgaXMS=TEDInfo->OldVgaXMS;
CgaXMSsize=TEDInfo->OldCgaXMSsize;
EgaXMSsize=TEDInfo->OldEgaXMSsize;
VgaXMSsize=TEDInfo->OldVgaXMSsize;
size=(num+numm)*4;
if (CgaXMS)
{
MMAllocate((memptr *)&CgaXMSlookup,size);
XMSmove(TEDInfo->CgaXMSlook,0,0,(long)MK_FP(CgaXMSlookup,0),size);
XMSFreeMem(TEDInfo->CgaXMSlook);
TEDInfo->CgaXMSlook=0;
}
if (EgaXMS)
{
MMAllocate((memptr *)&EgaXMSlookup,size);
XMSmove(TEDInfo->EgaXMSlook,0,0,(long)MK_FP(EgaXMSlookup,0),size);
XMSFreeMem(TEDInfo->EgaXMSlook);
TEDInfo->EgaXMSlook=0;
}
if (VgaXMS)
{
MMAllocate((memptr *)&VgaXMSlookup,size);
XMSmove(TEDInfo->VgaXMSlook,0,0,(long)MK_FP(VgaXMSlookup,0),size);
XMSFreeMem(TEDInfo->VgaXMSlook);
TEDInfo->VgaXMSlook=0;
}
switch(tempvid)
{
case CGA:
xmshandle=CgaXMS;
XMSlookup=CgaXMSlookup;
break;
case EGA1:
case EGA2:
xmshandle=EgaXMS;
XMSlookup=EgaXMSlookup;
break;
case VGA:
xmshandle=VgaXMS;
XMSlookup=VgaXMSlookup;
}
ErrDialog("RE-INITIALIZING...","");
}
ox=sx;
oy=sy;
//
// INSTALL GRAPHICS IF NOT A LAUNCH...
//
if (!launched)
{
switch(tempvid)
{
case CGA:
MMAllocate((memptr *)&CgaXMSlookup,(num+numm)*4);
XMSlookup=CgaXMSlookup;
break;
case EGA1:
case EGA2:
MMAllocate((memptr *)&EgaXMSlookup,(num+numm)*4);
XMSlookup=EgaXMSlookup;
break;
case VGA:
MMAllocate((memptr *)&VgaXMSlookup,(num+numm)*4);
XMSlookup=VgaXMSlookup;
}
//
// SET UP MEMORY CACHE IF ENOUGH IS AVAILABLE...
//
cacheon_h=0;
if (filelen(gname1)<16L*MMTotalFree())
{
LoadIn(gname1,(memptr *)&CacheBlock);
cacheon=1;
}
else
//
// DAMN! TRY XMS AS A LAST RESORT...
//
if (filelen(gname1)<1024l*XMSTotalFree())
{
#define TMPBUFSIZE 32000l
long amtleft,tmpoff=0,tmpsize;
memptr tblock;
amtleft=filelen(gname1);
MMAllocate(&tblock,TMPBUFSIZE);
cacheon_h=XMSAllocate(amtleft);
tmpsize=TMPBUFSIZE;
while(amtleft>0)
{
LoadFile(gname1,MK_FP(tblock,0),tmpoff,tmpsize);
XMSmove(0,(long)MK_FP(tblock,0),cacheon_h,tmpoff,tmpsize);
amtleft-=TMPBUFSIZE;
tmpoff+=TMPBUFSIZE;
tmpsize=(amtleft>TMPBUFSIZE)?TMPBUFSIZE:amtleft;
}
MMFreePtr(&tblock);
cacheon=2;
}
clearkeys();
//
// MOVE NONMASKED TILES INTO XMS MEMORY!
// ---------
unpacksize=unpackoff=0;
unpackxms=xmsoff;
for (i=0;i<num;i++)
{
long size,off;
off=OFF3(offsets,index+i);
if (off==0xffffff) // SPARSE TILE?
{
*(XMSlookup+i)=-1;
continue;
}
size=tile_len[i];
//
// GET COMPRESSED TILE DATA FROM CACHE OR DISK
//
if (cacheon==1)
{
//
// HUFFMAN DECOMPRESS
//
HuffExpand((unsigned char huge *)CacheBlock+off,(unsigned char huge *)unpack+unpackoff,
expsize,(huffnode *)hufftable);
}
else
if (cacheon==2)
{
XMSmove(cacheon_h,off,0,(long)packed,size);
//
// HUFFMAN DECOMPRESS
//
HuffExpand((unsigned char huge *)packed,(unsigned char huge *)unpack+unpackoff,
expsize,(huffnode *)hufftable);
}
else
{
LoadFile(gname1,(char huge *)packed,off,size);
//
// HUFFMAN DECOMPRESS
//
HuffExpand((unsigned char huge *)packed,(unsigned char huge *)unpack+unpackoff,
expsize,(huffnode *)hufftable);
}
unpacksize+=expsize;
unpackoff+=expsize;
*(XMSlookup+i)=xmsoff;
xmsoff+=expsize;
if (unpacksize>unpackmax-expsize)
{
XMSmove(0,(long)MK_FP(unpack,0),xmshandle,unpackxms,unpacksize);
unpacksize=unpackoff=0;
unpackxms=xmsoff;
sx=ox;
sy=oy;
printint(num+numm-i);
print(" ");
}
//
// ESC will exit!
//
if (keydown[1])
if (rtn)
{
switch(tempvid)
{
case CGA:
XMSFreeMem(CgaXMS);
MMFreePtr((memptr *)&CgaXMSlookup);
CgaXMS=0;
break;
case EGA1:
case EGA2:
XMSFreeMem(EgaXMS);
MMFreePtr((memptr *)&EgaXMSlookup);
EgaXMS=0;
break;
case VGA:
XMSFreeMem(VgaXMS);
MMFreePtr((memptr *)&VgaXMSlookup);
VgaXMS=0;
}
switch(videomode)
{
case CGA:
xmshandle=CgaXMS;
XMSlookup=CgaXMSlookup;
break;
case EGA1:
case EGA2:
xmshandle=EgaXMS;
XMSlookup=EgaXMSlookup;
break;
case VGA:
xmshandle=VgaXMS;
XMSlookup=VgaXMSlookup;
}
MMFreePtr((memptr *)&GraphHeader);
MMFreePtr((memptr *)&packed);
MMFreePtr((memptr *)&unpack);
if (cacheon)
MMFreePtr((memptr *)&CacheBlock);
return 0;
}
else
Quit("XMS LOADING ABORTED!");
}
//
// FLUSH THE FAST(?)-CACHE
//
if (unpacksize)
{
XMSmove(0,(long)MK_FP(unpack,0),xmshandle,unpackxms,unpacksize);
unpacksize=unpackoff=0;
unpackxms=xmsoff;
}
//
// MOVE MASKED TILES INTO XMS MEMORY!
// ------
for (i=0;i<numm;i++)
{
long size,off;
off=OFF3(offsets,indexm+i);
if (off==0xffffff) // SPARSE TILE?
{
*(XMSlookup+i+num)=-1;
continue;
}
size=tilem_len[i];
//
// GET COMPRESSED TILE DATA FROM CACHE OR DISK
//
if (cacheon==1)
{
//
// HUFFMAN DECOMPRESS
//
HuffExpand((unsigned char huge *)CacheBlock+off,(unsigned char huge *)unpack+unpackoff,
expmsize,(huffnode *)hufftable);
}
else
if (cacheon==2)
{
XMSmove(cacheon_h,off,0,(long)packed,size);
//
// HUFFMAN DECOMPRESS
//
HuffExpand((unsigned char huge *)packed,(unsigned char huge *)unpack+unpackoff,
expmsize,(huffnode *)hufftable);
}
else
{
LoadFile(gname1,(char huge *)packed,off,size);
//
// HUFFMAN DECOMPRESS
//
HuffExpand((unsigned char huge *)packed,(unsigned char huge *)unpack+unpackoff,
expmsize,(huffnode *)hufftable);
}
unpacksize+=expmsize;
unpackoff+=expmsize;
*(XMSlookup+i+num)=xmsoff;
xmsoff+=expmsize;
if (unpacksize>unpackmax-expmsize)
{
XMSmove(0,(long)MK_FP(unpack,0),xmshandle,unpackxms,unpacksize);
unpacksize=unpackoff=0;
unpackxms=xmsoff;
sx=ox;
sy=oy;
printint(numm-i);
print(" ");
}
//
// ESC will exit!
//
if (keydown[1])
if (rtn)
{
switch(tempvid)
{
case CGA:
XMSFreeMem(CgaXMS);
MMFreePtr((memptr *)&CgaXMSlookup);
CgaXMS=0;
break;
case EGA1:
case EGA2:
XMSFreeMem(EgaXMS);
MMFreePtr((memptr *)&EgaXMSlookup);
EgaXMS=0;
break;
case VGA:
XMSFreeMem(VgaXMS);
MMFreePtr((memptr *)&VgaXMSlookup);
VgaXMS=0;
}
switch(videomode)
{
case CGA:
xmshandle=CgaXMS;
XMSlookup=CgaXMSlookup;
break;
case EGA1:
case EGA2:
xmshandle=EgaXMS;
XMSlookup=EgaXMSlookup;
break;
case VGA:
xmshandle=VgaXMS;
XMSlookup=VgaXMSlookup;
}
MMFreePtr((memptr *)&GraphHeader);
MMFreePtr((memptr *)&packed);
MMFreePtr((memptr *)&unpack);
if (cacheon)
MMFreePtr((memptr *)&CacheBlock);
return 0;
}
else
Quit("XMS LOADING ABORTED!");
}
//
// FLUSH THE FAST-CACHE
//
if (unpacksize)
{
XMSmove(0,(long)MK_FP(unpack,0),xmshandle,unpackxms,unpacksize);
unpacksize=unpackoff=0;
unpackxms=xmsoff;
}
if (cacheon==1)
MMFreePtr((memptr *)&CacheBlock);
else
if (cacheon==2)
XMSFreeMem(cacheon_h);
}
//
// GET RID OF TILE-FILE CACHE MEMORY (OR WE'RE TOASTY)
//
MMFreePtr((memptr *)&GraphHeader);
MMFreePtr((memptr *)&packed);
MMFreePtr((memptr *)&unpack);
MMFreePtr((memptr *)&tile_len);
MMFreePtr((memptr *)&tilem_len);
whicht=0;
whichi=tilenum;
whichtm=tilenum;
switch(tsize)
{
case 1: lasticon=tilenum+36*maxiconrows;
break;
case 2: lasticon=tilenum+18*maxiconrows;
break;
case 3: lasticon=tilenum+7*maxiconrows;
}
firsticon=tilenum;
RestoreBackground();
return 1;
}
////////////////////////////////////////////////////
////////////////////////////////////////////////////
//
// Load TEDINFO.ext file
//
////////////////////////////////////////////////////
////////////////////////////////////////////////////
void LoadInfoFile(void)
{
char pname[14]="TEDINFO.",gfxname[14]="GFXINFO";
//
// Load the TEDINFO.ext file!
//
strcat(pname,ext);
strcpy(infoname,pname);
if (access(pname,0))
{
MMAllocate((memptr *)&TEDInfo,sizeof(InfoStruct));
_fmemset(TEDInfo,0,sizeof(InfoStruct));
// BFI BFI
TEDInfo->pflags=0x27; // 0010 0111
}
else
LoadIn(pname,(memptr *)&TEDInfo);
tsize=TEDInfo->tsize;
if (launchname[0])
_fmemcpy((char far *)TEDInfo->launchname,(char far *)launchname,14);
//
// LOAD THE "GFXINFO?.EXT" FILE
//
strcat(gfxname,format);
strcat(gfxname,".");
strcat(gfxname,ext);
LoadIn(gfxname,(memptr *)&GFXInfo);
switch(tsize)
{
case 1:
tilenum=GFXInfo->num8;
tilemnum=GFXInfo->num8m;
break;
case 2:
tilenum=GFXInfo->num16;
tilemnum=GFXInfo->num16m;
break;
case 3:
tilenum=GFXInfo->num32;
tilemnum=GFXInfo->num32m;
}
_fstrcpy((char far *)launchname,(char far *)TEDInfo->launchname);
if (launched)
TEDInfo->lastvid=LaunchInfo.lastmode;
//
// SET PLANE FLAGS BACK TO NORMAL
//
planeton=(TEDInfo->pflags>>6)&1;
planemon=(TEDInfo->pflags>>5)&1;
planeion=(TEDInfo->pflags>>4)&1;
viewton=(TEDInfo->pflags>>2)&1;
viewmon=(TEDInfo->pflags>>1)&1;
viewion=(TEDInfo->pflags)&1;
//
// SET BACKGROUND COLOR
//
BkgndColor=TEDInfo->BackgndColor;
if (BkgndColor>16)
TEDInfo->BackgndColor=BkgndColor=O_FGNDBACK;
}
////////////////////////////////////////////////////
////////////////////////////////////////////////////
//
// Find ?GAGRAPH.ext file
//
////////////////////////////////////////////////////
////////////////////////////////////////////////////
void FindGraphFile(void)
{
struct ffblk ffblk;
char pname[15]="?GAGRAPH.*",*tempstr,tiname[13]="TEDINFO.TMP";
int i,which;
//
// RETURNING FROM LAUNCH...GET INFO BACK
//
if (launched)
{
LoadFile(tiname,(char huge *)&LaunchInfo,0,0);
unlink(tiname);
videomode=LaunchInfo.lastmode;
switch(videomode)
{
case CGA:
format[0]='C';
break;
case EGA1:
case EGA2:
format[0]='E';
break;
case VGA:
format[0]='V';
}
strcpy(ext,LaunchInfo.ext);
projname[0]=format[0];
strcat(projname,"GAGRAPH.");
strcat(projname,ext);
return;
}
//
// Find ?GAGRAPH.ext
//
if (ext[0])
{
strcpy(pname,"?GAGRAPH.");
strcat(pname,ext);
}
if (findfirst(pname,&ffblk,FA_ARCH))
{
ErrDialog("I can't find a graphics\nfile! (ex:?GAGRAPH.ext)"," Alright ");
Quit("Can't work without graphics ya know!");
}
if (GfxToUse)
format[0] = GfxToUse;
else
{
// setup the dialog
strcpy(bstrings[0],ffblk.ff_name);
ProjButns[0].xoff=9;
ProjButns[0].yoff=2;
ProjButns[0].border=0;
ProjButns[0].text=bstrings[0];
for (i=1;i<10;i++)
{
if (findnext(&ffblk))
break;
strcpy(bstrings[i],ffblk.ff_name);
ProjButns[i].xoff=9;
ProjButns[i].yoff=2+i;
ProjButns[i].border=0;
ProjButns[i].text=bstrings[i];
}
ProjSelect.numbuttons=i;
ProjSelect.height=i+3;
which=1;
if (i>1)
do
{
which=DoDialog(&ProjSelect);
} while(!which);
which--;
tempstr=strpbrk(bstrings[which],".")+1;
strcpy(ext,tempstr);
format[0]=bstrings[which][0];
}
strcpy(projname,bstrings[which]);
}
//
// draw border for project window
//
void DrawProjBord(int x,int y)
{
DrawBorder(x+8,y+1,13,ProjSelect.height-2,1);
}
////////////////////////////////////////////////////
//
// Input amount of icons to reserve
// Returns maximum # of icon rows to reserve
//
////////////////////////////////////////////////////
btype ICb={" ",8,3,1};
DialogDef ICd={"Enter maximum amount\nof icons to reserve:",20,5,1,&ICb,NULL};
int InputIconAmount(void)
{
char tempstr[4];
int value;
if (!(MapFileHeader->maptype&IPLANE))
return 4;
MouseHide();
DrawDialog(&ICd,1);
while(1)
{
GetDialogXY(&ICd,&sx,&sy);
GetButtonXY(&ICd,0,&sx,&sy);
if (input(tempstr,3))
{
value=atoi(tempstr);
if (value>0)
{
MouseShow();
RestoreBackground();
return (value+17)/18;
}
}
}
}
////////////////////////////////////////////////////
////////////////////////////////////////////////////
//
// Unhook everything
//
////////////////////////////////////////////////////
////////////////////////////////////////////////////
void Unhook(void)
{
ShutdownKBD();
if (CgaXMS)
XMSFreeMem(CgaXMS);
if (EgaXMS)
XMSFreeMem(EgaXMS);
if (VgaXMS)
XMSFreeMem(VgaXMS);
if (XMSundoB)
XMSFreeMem(XMSundoB);
if (XMSundoF)
XMSFreeMem(XMSundoF);
if (XMSundoI)
XMSFreeMem(XMSundoI);
if (XMSmaps)
XMSFreeMem(XMSmaps);
}
void PatchPointers(void)
{
}
////////////////////////////////////////////////////
////////////////////////////////////////////////////
//
// Menu Definitions
//
////////////////////////////////////////////////////
////////////////////////////////////////////////////
MenuDef AboutMenu[]=
{{"About...",Item_About,0,0},
{"Video Mode Switch",Item_ModeSwitch,0,0x43},
{"Last Video Mode",Item_LastVideo,ALT,0x2c},
{"Memory Available",Item_PrintMem,0,0x44},
{"Launch Project",Item_Launch,ALT,0x26},
{"--------------------",NULL,0,0},
// {"Display Unused Tiles",Item_CountTiles,0,0},
{"Project Re-Select",Item_ProjectReSelect,0,0},
{"Visit DOS",Item_VisitDOS,0,0}
};
MenuDef FileMenu[]=
{{"Edit New Map",Item_EditMap,ALT,0x18},
{"Save Map",Item_SaveMap,ALT,0x1f},
{"Create Map",Item_CreateMap,ALT,0x2e},
{"Delete Map",Item_DeleteMap,ALT,0x20},
{"Switch Map",Item_SwitchMap,ALT,0x11},
{"Amputate Maps",Item_Amputate},
{"---------------",NULL,0,0},
{"Import Maps",Item_ImportMaps,0,0},
{"Change ICON Rows",Item_ChangeIconRows,0,0},
{"Carmacize Maps",Item_Huffman,0,0},
{"Quit TED5",Item_Quit,ALT,0x2d}};
MenuDef EditMenu[]=
{{"Switch to Last Map",Item_LastMap,ALT,0x32},
{"Edit TILEINFO/M Values",Item_EditTinfoValues,ALT,0x14},
{"Change LAUNCH name",Item_LAUNCHname,0,0},
{"Change PARM string",Item_PARMstring,0,0},
{"Edit TILEINFO/M Names",Item_EditTinfoNames,0,0},
{"Add/Del TILEINFO/M Planes",Item_AddDelTinfo,0,0},
{"Edit MAP Names",Item_EditMapNames,0,0},
{"Change MAP Edges",Item_EditMapEdges,0,0}};
MenuDef ModeMenu[]=
{
{"Copy Mode",Item_Copy,0,0x2e},
{"Paste Mode",Item_Paste,0,0x19},
{"Block Fill",Item_BlockFill,0,0x30},
{"Flood Fill",Item_FloodFill,0,0x21},
{"Undo last action",Item_Undo,0,0x16},
{"Tile Search",Item_TileSearch,0,0x14},
{"GridMode toggle",Item_GridMode,0,0x22},
{"Snap-Paste toggle",Item_SnapTog,0,0x1f},
{"Paste Overlay toggle",Item_POtog,0,0x3d}
};
MenuDef MiscMenu[]=
{
{"Select Tile",Item_SelectTile,0,0x39},
{"Map Stats",Item_MapStats,0,0x17},
{"Toggle INFOBAR",Item_ToggleInfo,0,0x42},
{"New INFOPLANE value",Item_InputInfoplane,0,0x1c},
{"View Map & Goto",Item_ViewMap,ALT,0x2f},
{"ReView Map & Goto",Item_ReviewMap,0,0xe},
{"Change LAUNCH icon",Item_ChangeLaunchIcon,0,0},
{"Change bkgnd color",Item_ChangeBkgndColor,0,0},
{"TILEINFOM Copy",Item_TINFOCopy,0,0},
{"Graphic Map Dump",Item_GraphicDump,0,0}
};
MBarDef TED5MenuBar[]=
{{9,AboutMenu," ? "},
{11,FileMenu,"File"},
{8,EditMenu,"Edit"},
{9,ModeMenu,"Modes"},
{10,MiscMenu,"Misc"},
{0,0,""}};
Reference in New Issue View Git Blame Copy Permalink