/****************************************************************************/
/*                                                                          */
/* Layer Editor for Greed I                                                 */
/*                                                                          */
/* Copyright(C) 1995 by Robert Morgan of Channel 7                          */
/*                                                                          */
/****************************************************************************/

#include <STDIO.H>
#include <DOS.H>
#include <STDARG.H>
#include <STRING.H>
#include <STDLIB.H>
#include <CONIO.H>


/**** CONSTANTS ****/

#define VERSION          "1.017"
#define NUMLAYERS        18
#define XMAX             64
#define YMAX             64
#define TEXTMODE         0x03
#define VGAMODE          0x13
#define PEL_WRITE_ADR    0x3c8
#define PEL_READ_ADR     0x3c7
#define PEL_DATA         0x3c9
#define SCREEN           0xA000
#define SCREENWIDTH      320
#define SCREENHEIGHT     200
#define OUTBYTE(x,y)     (outp((unsigned)(x),(unsigned)(y)))
#define OUTWORD(x,y)     (outpw((unsigned)(x),(unsigned)(y)))
#define INBYTE(x)        (inp((unsigned)(x)))
#define INWORD(x)        (inpw((unsigned)(x)))
#define CLI              _disable()
#define STI              _enable()
#define MAXFONTCHARS     94
#define FONTWIDTH        5
#define TEXTCOLOR        5
#define BUFX             190
#define BUFY             190

 /* text modes */
#define TEXT_NORMAL      0
#define TEXT_NOOVERWRITE 1
#define TEXT_CENTER      2

 /* flags */
#define F_RIGHT          (1<<0)
#define F_LEFT           (1<<1)
#define F_UP             (1<<2)
#define F_DOWN           (1<<3)
#define F_TRANSPARENT    (1<<4)
#define F_NOCLIP         (1<<5)
#define F_NOBULLETCLIP   (1<<6)
#define F_DAMAGE         (1<<7)

 /* layer names */
#define NORTHWALL        0
#define NORTHFLAGS       1
#define WESTWALL         2
#define WESTFLAGS        3
#define FLOOR            4
#define FLOORFLAGS       5
#define CEILING          6
#define CEILINGFLAGS     7
#define FLOORHEIGHT      8
#define CEILINGHEIGHT    9
#define FLOORDEF         10
#define FLOORDEFFLAGS    11
#define CEILINGDEF       12
#define CEILINGDEFFLAGS  13
#define LIGHTS           14
#define EFFECTS          15
#define SPRITES          16
#define SLOPES           17


char *layernames[NUMLAYERS]=
 {
  "NORTHWALL    ",
  "",
  "WESTWALL     ",
  "",
  "FLOOR        ",
  "",
  "CEILING      ",
  "",
  "FLOORHEIGHT  ",
  "CEILINGHEIGHT",
  "FLOORDEF     ",
  "",
  "CEILINGDEF   ",
  "",
  "LIGHTS       ",
  "EFFECTS      ",
  "SPRITES      ",
  "SLOPES       "
  };

/**** TYPES ****/

typedef unsigned char     byte;
typedef byte              layerdata_t;
typedef layerdata_t       layer_t[YMAX][XMAX];
typedef enum {false,true} boolean;
typedef short             word;
typedef unsigned long     longint;

 /* CPR file format header */
typedef struct
 {
  int signature;
  byte version;
  int  width, height;
  byte flags, headersize;
  byte indicator;
  int  orgx, orgy;
  } CPR_HEADER;

 /* FON character */
typedef struct
 {
  byte width;
  word lines[16];
  } fontchartype;

 /* FON file format header */
typedef struct
 {
  char signature[4];
  int  height;
  int  asciistart;
  int  nchars;
  fontchartype fontchar[MAXFONTCHARS];
  } fonttype;


/**** VARIABLES ****/

layer_t far *layers[NUMLAYERS]; // map layers
char         filename[13], printstr[128];
boolean      quit, messageready;
byte         colors[768];
byte far     *screen, *ylookup[SCREENHEIGHT], buffer[BUFY][BUFX],
	     *bufylookup[BUFY];
fonttype     font;
int          tcolor, bkcolor, fontmode, fontavgwidth, currentvalue[NUMLAYERS],
	     currentx, currenty, currentlayer;


/**** FUNCTIONS ****/

 /* protos */
void Error(char *error,...);
void ReadFile(char *filename,word length,void *buffer);


/* GRAPHICS *****************************************************************/

void SetPalette(byte *palette)
{
 int i;

 while (inp(0x3da) & 0x08) ;
 while (!(inp(0x3da) & 0x08)) ;
 while (!(inp(0x3da) & 0x01)) ;
 OUTBYTE(PEL_WRITE_ADR,0);
 for (i=0;i<768;i++)
  OUTBYTE(PEL_DATA,*palette++);
 }


void FillPalette(int red, int green, int blue)
{
 int i;

 while (inp(0x3da) & 0x08) ;
 while (!(inp(0x3da) & 0x08)) ;
 while (!(inp(0x3da) & 0x01)) ;
 OUTBYTE(PEL_WRITE_ADR,0);
 for (i=0;i<256;i++)
  {
   OUTBYTE(PEL_DATA,red);
   OUTBYTE(PEL_DATA,green);
   OUTBYTE(PEL_DATA,blue);
   }
 }


void LoadCPR(char *s)
{
 int        x, y, i, data, count, orgx, orgy, indicator;
 char       str1[14];
 FILE       *f;
 CPR_HEADER h;
 byte far   *t;

 FillPalette(0,0,0);
 f=fopen(s,"rb");
 if (f==NULL)
  Error("%s not found");
 if (!fread(&h,sizeof(CPR_HEADER),1,f) ||
  h.signature!=19794 || fseek(f,h.headersize,0) ||
  ((h.flags & 1) && !fread(colors,768,1,f)))
   Error("Error reading %s");
 if (h.version==4)
  {
   indicator=255;
   orgx=0;
   orgy=0;
   }
 else if (h.version==5)
  {
   indicator=h.indicator;
   orgx=h.orgx;
   orgy=h.orgy;
   memset(screen,0,SCREENHEIGHT*SCREENWIDTH);
   }
 else Error("Invalid %s CPR file version",s);
 y=orgy;
 x=orgx;
 t=ylookup[y]+x;
 while (y<h.height)
  {
   data=fgetc(f);
   if (data==indicator)
    {
     count=fgetc(f);
     data=fgetc(f);
     for (i=0;i<count;i++)
      {
       *t++=data;
       ++x;
       if (x==h.width)
	{
	 x=orgx;
	 ++y;
	 t=ylookup[y]+x;
	 }
       }
     }
   else if (data>=0)
    {
     *t++=data;
     ++x;
     if (x==h.width)
      {
       x=orgx;
       ++y;
       t=ylookup[y]+x;
       }
     }
   else Error("%s corrupted",s);
   }
 fclose(f);
 SetPalette(colors);
 }


void LoadFON(char *s,int setwidth)
{
 ReadFile(s,sizeof(fonttype),&font);
 fontavgwidth=setwidth;
 }


int FontStrLen(char *s)
{
 int i, j, result;

 i=0;
 result=0;
 j=font.asciistart;
 while (s[i])
  {
   result+=font.fontchar[s[i]-j].width;
   ++i;
   }
 return result;
 }


void PrintXY(int x1,int y1,char *s)
{
 int           i, h, j, k, width, lines;
 int           x, y, l, letter;
 fontchartype *f;
 byte         *dest;

 if (fontmode & TEXT_CENTER)
  {
   i=FontStrLen(s)>>1;
   x1-=i;
   }
 l=strlen(s);
 x=x1;
 h=font.height;
 for (k=0; k<l; k++)
  {
   y=y1;
   letter=s[k]-font.asciistart;
   f=&font.fontchar[letter];
   width=f->width;
   for (i=0;i<h;i++,y++)
    {
     lines=f->lines[i];
     dest=ylookup[y]+x;
     for (j=0;j<width;j++,dest++)
      {
       if (lines & (1<<j))
	*dest=tcolor;
       else if (bkcolor!=255)
	*dest=bkcolor;
       }
     }
   x+=width;
   }
 width=l*fontavgwidth+x1;
 if (!(fontmode & TEXT_NOOVERWRITE) && x<width && bkcolor!=255)
  {
   y=y1;
   width=width-x+1;
   dest=ylookup[y]+x;
   for (i=0;i<h;i++,y++,dest+=320)
    memset(dest,bkcolor,width);
   }
 }


void PrintfXY(int x,int y,char *sfmt,...)
{
 va_list argptr;

 va_start(argptr,sfmt);
 vsprintf(printstr,sfmt,argptr);
 va_end(argptr);
 PrintXY(x,y,printstr);
 }


/* MISC & ERROR *************************************************************/

void SetVidMode(int mode)
{
 union REGS r;

 r.x.ax=mode;
 int86(0x10,&r,&r);
 }


void Error(char *error,...)
{
 va_list   argptr;
 byte far *vidmode;

 vidmode=MK_FP(0x40,0x49);
 if (*vidmode!=TEXTMODE)
  SetVidMode(TEXTMODE);
 printf("Error: ");
 va_start(argptr,error);
 vprintf(error,argptr);
 va_end(argptr);
 while (kbhit())
  getch();
 exit(255);
 }


word ReadKey(void)
{
 union REGS r;

 r.h.ah=0x10;
 int86(0x16,&r,&r);
 return r.x.ax;
 }


void DeleteMessage(void)
{
 int i;

 for (i=193;i<200;i++)
  memset(ylookup[i]+201,0,119);
 messageready=false;
 }


void Message(char *error,...)
{
 va_list argptr;
 char    s[40];

 if (messageready) DeleteMessage();
 va_start(argptr,error);
 vsprintf(s,error,argptr);
 PrintXY(201,193,s);
 messageready=true;
 va_end(argptr);
 }


boolean AskQuestion(char *s)
{
 int     ans, c;
 boolean result;

 Message(s);
 ans=ReadKey();
 c=ans & 255;
 if (c=='Y' || c=='y')
  result=true;
 else
  result=false;
 while (kbhit())
  getch();
 DeleteMessage();
 return result;
 }


boolean AskFileName(char *s,char *name)
{
 char str[40];
 int  cursor, cindex, c, ans;

 strcpy(str,s);
 strcat(str,name);
 cindex=strlen(s);
 cursor=strlen(str)-1;
 while (cursor>cindex && str[cursor]==' ')
  --cursor;
 ++cursor;
 while (1)
  {
   DeleteMessage();
   str[cursor]='_';
   Message(str);
   ans=ReadKey();
   c=ans & 255;
   switch (c)
    {
     case 0x00:
     case 0xE0:
      c=(word)ans>>8;
      switch (c)
       {
	case 75:
	case 83:
	 if (cursor>cindex)
	  {
	   str[cursor]=' ';
	   --cursor;
	   str[cursor]='_';
	   }
	 break;
	default:
	 break;
	}
      break;
     case 8:
      if (cursor>cindex)
       {
	str[cursor]=' ';
	--cursor;
	str[cursor]='_';
	}
      break;
     case 13:
      str[cursor]=' ';
      strcpy(name,&str[strlen(s)]);
      DeleteMessage();
      return true;
     case 27:
      DeleteMessage();
      return false;
     default:
      str[cursor]=c;
      if (cursor-cindex<12)
       cursor++;
      str[cursor]='_';
      break;
     }
   }
 }


/* CONVERSION ***************************************************************/

void Convert1(char *s)
{
 FILE    *f;
 int     result, dest, source, i, j;
 layer_t *l[4];


 if (stricmp(s,"IGNORE")==0) return;
 for (i=0;i<4;i++)
  {
   l[i]=(layer_t*)malloc(sizeof(layer_t));
   if (l[i]==NULL) Error("Out of memory in Convert");
   memset(l[i],0,sizeof(layer_t));
   }
 f=fopen(s,"rt");
 if (f==NULL) Error("Error loading %s",s);
 do
  {
   result=fscanf(f,"%i %i\n",&dest,&source);

   for (i=0;i<YMAX;i++)
    for (j=0;j<XMAX;j++)
     if ((*layers[NORTHWALL])[i][j]==source && !(*l[0])[i][j])
      {
       (*layers[NORTHWALL])[i][j]=dest;
       (*l[0])[i][j]=1;
       }
   for (i=0;i<YMAX;i++)
    for (j=0;j<XMAX;j++)
     if ((*layers[WESTWALL])[i][j]==source && !(*l[1])[i][j])
      {
       (*layers[WESTWALL])[i][j]=dest;
       (*l[1])[i][j]=1;
       }
   for (i=0;i<YMAX;i++)
    for (j=0;j<XMAX;j++)
     if ((*layers[FLOORDEF])[i][j]==source && !(*l[2])[i][j])
      {
       (*layers[FLOORDEF])[i][j]=dest;
       (*l[2])[i][j]=1;
       }
   for (i=0;i<YMAX;i++)
    for (j=0;j<XMAX;j++)
     if ((*layers[CEILINGDEF])[i][j]==source && !(*l[3])[i][j])
      {
       (*layers[CEILINGDEF])[i][j]=dest;
       (*l[3])[i][j]=1;
       }
   } while (result==2);
 fclose(f);
 for (i=0;i<4;i++)
  free(l);
 }


void Convert2(char *s)
{
 FILE    *f;
 int     result, dest, source, i, j;
 layer_t *l[4];


 if (stricmp(s,"IGNORE")==0) return;
 for (i=0;i<4;i++)
  {
   l[i]=(layer_t*)malloc(sizeof(layer_t));
   if (l[i]==NULL) Error("Out of memory in Convert");
   memset(l[i],0,sizeof(layer_t));
   }
 f=fopen(s,"rt");
 if (f==NULL) Error("Error loading %s",s);
 do
  {
   result=fscanf(f,"%i %i\n",&dest,&source);

   for (i=0;i<YMAX;i++)
    for (j=0;j<XMAX;j++)
     if ((*layers[FLOOR])[i][j]==source && !(*l[0])[i][j])
      {
       (*layers[FLOOR])[i][j]=dest;
       (*l[0])[i][j]=1;
       }
   for (i=0;i<YMAX;i++)
    for (j=0;j<XMAX;j++)
     if ((*layers[CEILING])[i][j]==source && !(*l[1])[i][j])
      {
       (*layers[CEILING])[i][j]=dest;
       (*l[1])[i][j]=1;
       }
   } while (result==2);
 fclose(f);
 for (i=0;i<4;i++)
  free(l);
 }


void InitMEDIT(void)
{
 int i;

  /* initialize graphical data */
 screen=MK_FP(0xA000,0);
 for (i=0;i<SCREENHEIGHT;i++)
  ylookup[i]=screen+i*SCREENWIDTH;
 for (i=0;i<BUFY;i++)
  bufylookup[i]=buffer[i];

  /* init font info */
 tcolor=TEXTCOLOR;
 bkcolor=0;

  /* init cursor info */
 currentx=31;
 currenty=31;
 memset(currentvalue,0,sizeof(currentvalue));
 currentlayer=0;

  /* init layers */
 for (i=0;i<NUMLAYERS;i++)
  {
   layers[i]=(layer_t*)malloc(sizeof(layer_t));
   if (layers[i]==NULL)
    Error("Out of memory for layers");
   }
 }


long getlong(FILE *f)
{
 long l;

 fread(&l,4,1,f);
 return l;
 }


void ConvertLVL(char *s)
{
 FILE *f;
 long  l;
 int   i, j;
 byte  flags;

 f=fopen(s,"rb");
 if (f==NULL) Error("Error opening %s",s);

 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   {
    l=getlong(f);
    (*layers[WESTWALL])[i][j]=l&255;
    l>>=8;
    flags=0;
    if (l & 0x1)
     flags|=F_TRANSPARENT;
    if (l & 0x2)
     flags|=F_NOCLIP;
    if (l & 0x4)
     flags|=F_LEFT;
    if (l & 0x8)
     flags|=F_RIGHT;
    if (l & 0x10)
     flags|=F_NOBULLETCLIP;
    (*layers[WESTFLAGS])[i][j]=flags;
    }
 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   {
    l=getlong(f);
    (*layers[NORTHWALL])[i][j]=l&255;
    l>>=8;
    flags=0;
    if (l & 0x1)
     flags|=F_TRANSPARENT;
    if (l & 0x2)
     flags|=F_NOCLIP;
    if (l & 0x4)
     flags|=F_LEFT;
    if (l & 0x8)
     flags|=F_RIGHT;
    if (l & 0x10)
     flags|=F_NOBULLETCLIP;
    (*layers[NORTHFLAGS])[i][j]=flags;
    }
 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   {
    l=getlong(f);
    (*layers[FLOOR])[i][j]=l&255;
    l>>=8;
    flags=0;
    (*layers[FLOORFLAGS])[i][j]=flags;
    }
 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   {
    l=getlong(f);
    (*layers[CEILING])[i][j]=l&255;
    l>>=8;
    flags=0;
    if (l & 0x1)
     flags|=F_TRANSPARENT;
    (*layers[CEILINGFLAGS])[i][j]=flags;
    }
 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   (*layers[FLOORHEIGHT])[i][j]=fgetc(f);
 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   (*layers[CEILINGHEIGHT])[i][j]=fgetc(f);
 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   {
    l=getlong(f);
    (*layers[FLOORDEF])[i][j]=l&255;
    }
 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   {
    l=getlong(f);
    (*layers[CEILINGDEF])[i][j]=l&255;
    }
 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   (*layers[LIGHTS])[i][j]=fgetc(f);
 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   {
    l=getlong(f);
    (*layers[SPRITES])[i][j]=l&255;
    }
 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   {
    l=getlong(f);
    l&=255;
    if (l<32)
     (*layers[EFFECTS])[i][j]=l;
    else
     (*layers[SLOPES])[i][j]=l;
    }
 fclose(f);
 }


void CreateNewLAY(void)
{
 int i, j;

 for (i=0;i<NUMLAYERS;i++)
  memset(layers[i],0,sizeof(layer_t));

 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   (*layers[CEILINGHEIGHT])[i][j]=255;

 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   (*layers[LIGHTS])[i][j]=63;

 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   (*layers[CEILINGDEF])[i][j]=1;

 for (i=0;i<YMAX;i++)
  for (j=0;j<XMAX;j++)
   (*layers[FLOORDEF])[i][j]=1;
 }


/* DISK IO ******************************************************************/

void ReadLevel(char *s)
{
 FILE *f;
 int  i, result;
 char fname[20];

 strcpy(fname,s);

 /* upcase the string */
 i=0;
 while (fname[i]!=0)
  {
   if (fname[i]>='a' && fname[i]<='z')
    fname[i]+='A'-'a';
   i++;
   }

 /* find filename extention */
 i=0;
 while (fname[i]!=0 && fname[i]!='.') i++;
 if (fname[i]==0)
  strcat(fname,".LAY");                 // assume new file format
 else if (strcmp(&fname[i],".LVL")==0)  // old file format
  {
   CreateNewLAY();
   ConvertLVL(fname);
   strcpy(&fname[i],".LAY");
   sprintf(filename,"%-13s",fname);
   PrintfXY(233,10,filename);
   return;
   }

 sprintf(filename,"%-13s",fname);
 PrintfXY(233,10,filename);

 /* open and read */
 f=fopen(fname,"rb+");
 if (f==NULL)
  {
   CreateNewLAY();
   return;
   }
 for (i=0;i<NUMLAYERS;i++)
  if (!fread(layers[i],sizeof(layer_t),1,f))
   Error("Reading %s, layer %i",fname,i);
 fclose(f);
 }


void ReadFile(char *filename,word length,void *buffer)
{
 FILE *f;

 f=fopen(filename,"rb");
 if (f==NULL)
  Error("Error opening %s",filename);
 if (fread(buffer,length,1,f)==0)
  Error("Error reading %s",filename);
 fclose(f);
 }


void SaveLAYFile(void)
{
 int   i;
 FILE *f;

 if (!AskFileName("Save: ",filename))
  return;
 i=0;
 while (filename[i]!=0)
  {
   if (filename[i]>='a' && filename[i]<='z')
    filename[i]+='A'-'a';
   i++;
   }
 PrintfXY(233,10,filename);
 f=fopen(filename,"wb");
 if (f==NULL)
  Error("Error saving %s",filename);
 for (i=0;i<NUMLAYERS;i++)
  if (!fwrite(layers[i],sizeof(layer_t),1,f))
   Error("Error writing %s",filename);
 fclose(f);
 Message("File Saved");
 }


void LoadLAYFile(void)
{
 int   i;
 FILE *f;

 if (!AskFileName("Load: ",filename))
  return;

 i=0;
 while (filename[i]!=0)
  {
   if (filename[i]>='a' && filename[i]<='z')
    filename[i]+='A'-'a';
   i++;
   }
 PrintfXY(233,10,filename);
 f=fopen(filename,"rb");
 if (f==NULL)
  Message("%s not found",filename);
 for (i=0;i<NUMLAYERS;i++)
  if (!fread(layers[i],sizeof(layer_t),1,f))
   Error("Error reading %s",filename);
 fclose(f);
 Message("File Loaded");
 }


/* Buffer Functions *********************************************************/

void BlitBuffer(void)
{
 int i;

 for (i=0;i<BUFY;i++)
  memcpy(ylookup[i+5]+5,bufylookup[i],BUFY);
 }


void ResetBuffer(void)
{
 int i, j;

 memset(buffer,0,sizeof(buffer));
 for (i=0;i<BUFY;i+=10)
  memset(bufylookup[i],1,BUFX);
 for (j=0;j<BUFX;j+=10)
  for (i=0;i<BUFY;i++)
   *(bufylookup[i]+j)=1;
 }


void DrawBuffer(void)
{
 int tilex, tiley, color, x, y, i, j, upper, lower, cw, ch;

 ResetBuffer();
 y=0;

 switch (currentlayer)
  {
   case FLOORDEF:
   case CEILINGDEF:
    upper=CEILINGDEF;
    lower=FLOORDEF;
    break;
   case CEILINGHEIGHT:
   case FLOORHEIGHT:
    upper=CEILINGHEIGHT;
    lower=FLOORHEIGHT;
    break;
   default:
    upper=CEILING;
    lower=FLOOR;
    break;
   }

 for (tiley=currenty-9;tiley<=currenty+9;tiley++,y+=10)
  if (tiley>=0 && tiley<YMAX)
   {
    x=0;
    for (tilex=currentx-9;tilex<=currentx+9;tilex++,x+=10)
     if (tilex>=0 && tilex<XMAX)
      {
       color=(*layers[lower])[tiley][tilex];
       if (color)
	{
	 color=(color%240) + 16;
	 for (i=1;i<10;i++)
	  memset(bufylookup[y+i]+x+1,color,9);
	 }

       color=(*layers[upper])[tiley][tilex];
       if (color)
	{
	 color=(color%240) + 16;
	 for (i=1;i<10;i++)
	  for (j=10-i;j>0;j--)
	   *(bufylookup[y+i]+x+j)=color;
	 }

       color=(*layers[NORTHWALL])[tiley][tilex];
       if (color)
	{
	 if (lower!=FLOOR)
	  color=5;
	 else
	  color=(color%240) + 16;
	 memset(bufylookup[y]+x,color,10);
	 memset(bufylookup[y+1]+x,color,10);
	 }

       color=(*layers[WESTWALL])[tiley][tilex];
       if (color)
	{
	 if (lower!=FLOOR)
	  color=5;
	 else
	  color=(color%240) + 16;
	 for (i=0;i<10;i++)
	  *(bufylookup[y+i]+x)=color;
	 for (i=0;i<10;i++)
	  *(bufylookup[y+i]+x+1)=color;
	 }

       color=(*layers[SPRITES])[tiley][tilex];
       if (color)
	{
	 color=(color%240) + 16;
	 *(bufylookup[y+4]+x+4)=color;
	 *(bufylookup[y+5]+x+4)=color;
	 *(bufylookup[y+6]+x+4)=color;
	 *(bufylookup[y+4]+x+5)=color;
	 *(bufylookup[y+5]+x+5)=color;
	 *(bufylookup[y+6]+x+5)=color;
	 *(bufylookup[y+4]+x+6)=color;
	 *(bufylookup[y+5]+x+6)=color;
	 *(bufylookup[y+6]+x+6)=color;
	 }
       if ((*layers[SLOPES])[tiley][tilex])
	*(bufylookup[y+5]+x+5)=3;
       }
     else
      for (i=0;i<10;i++)
       memset(bufylookup[y+i]+x,0,10);
    }
  else
   for (i=0;i<10;i++)
    memset(bufylookup[y+i],0,BUFX);

 if (currentlayer==WESTWALL)
  {
   cw=4;
   ch=12;
   }
 else if (currentlayer==NORTHWALL)
  {
   cw=12;
   ch=4;
   }
 else
  {
   cw=13;
   ch=13;
   }
 memset(bufylookup[89]+89,6,cw);
 memset(bufylookup[88+ch]+89,6,cw);
 for (i=90;i<89+ch;i++)
  {
   *(bufylookup[i]+89)=6;
   *(bufylookup[i]+88+cw)=6;
   }
 }


/* Edit Functions ***********************************************************/

void FloodFill(void)
{
 byte *x, *y, *processed;
 int   index, total, curx, cury;

 index=0;
 total=1;

 x=(byte *)malloc(YMAX*XMAX);
 if (x==NULL)
  Error("Out of memory for flood fill (1)");
 y=(byte *)malloc(YMAX*XMAX);
 if (y==NULL)
  Error("Out of memory for flood fill (2)");
 processed=(byte *)malloc(YMAX*XMAX);
 if (processed==NULL)
  Error("Out of memory for flood fill (3)");

 memset(x,0,XMAX*YMAX);
 memset(y,0,XMAX*YMAX);
 memset(processed,0,XMAX*YMAX);

 x[0]=currentx;
 y[0]=currenty;
 processed[currenty*XMAX+currentx]=1;
 while (index<total)
  {
   curx=x[index];
   cury=y[index];
   index++;
   if (!(*layers[NORTHWALL])[cury][curx] && cury-1>=0)
    {
     if (!processed[(cury-1)*XMAX+curx])
      {
       x[total]=curx;
       y[total]=cury-1;
       total++;
       processed[(cury-1)*XMAX+curx]=1;
       }
     }
   if (!(*layers[WESTWALL])[cury][curx] && curx-1>=0)
    {
     if (!processed[(cury)*XMAX+curx-1])
      {
       x[total]=curx-1;
       y[total]=cury;
       total++;
       processed[(cury)*XMAX+curx-1]=1;
       }
     }
   if (cury<YMAX-1 && !(*layers[NORTHWALL])[cury+1][curx])
    {
     if (!processed[(cury+1)*XMAX+curx])
      {
       x[total]=curx;
       y[total]=cury+1;
       total++;
       processed[(cury+1)*XMAX+curx]=1;
       }
     }
   if (curx<XMAX-1 && !(*layers[WESTWALL])[cury][curx+1])
    {
     if (!processed[(cury)*XMAX+curx+1])
      {
       x[total]=curx+1;
       y[total]=cury;
       total++;
       processed[(cury)*XMAX+curx+1]=1;
       }
     }
   if (total>=XMAX*YMAX)
    Error("Flood fill overflow");
   (*layers[currentlayer])[cury][curx]=currentvalue[currentlayer];
   }
 free(x);
 free(y);
 free(processed);
 }


void UpdateLocalInfo(void)
{
 char *s;
 byte flags;

 PrintXY(233,20,layernames[currentlayer]);
 PrintfXY(233,30,"%3i",currentvalue[currentlayer]);
 PrintfXY(263,30,"%2i",currentx);
 PrintfXY(288,30,"%2i",currenty);
 PrintfXY(236,52,"%3i",(*layers[NORTHWALL])[currenty][currentx]);
 PrintfXY(255,52,"%3i",(*layers[WESTWALL])[currenty][currentx]);
 PrintfXY(236,63,"%3i",(*layers[FLOOR])[currenty][currentx]);
 PrintfXY(255,63,"%3i",(*layers[CEILING])[currenty][currentx]);
 PrintfXY(236,74,"%3i",(*layers[FLOORHEIGHT])[currenty][currentx]);
 PrintfXY(255,74,"%3i",(*layers[CEILINGHEIGHT])[currenty][currentx]);
 PrintfXY(236,85,"%3i",(*layers[FLOORDEF])[currenty][currentx]);
 PrintfXY(255,85,"%3i",(*layers[CEILINGDEF])[currenty][currentx]);
 PrintfXY(236,96,"%3i",(*layers[LIGHTS])[currenty][currentx]);
 PrintfXY(255,96,"%3i",(*layers[EFFECTS])[currenty][currentx]);
 PrintfXY(236,107,"%3i",(*layers[SPRITES])[currenty][currentx]);
 PrintfXY(255,107,"%3i",(*layers[SLOPES])[currenty][currentx]);

 switch (currentlayer)
  {
   case NORTHWALL:
   case WESTWALL:
   case FLOORDEF:
   case CEILINGDEF:
   case FLOOR:
   case CEILING:
    flags=(*layers[currentlayer+1])[currenty][currentx];
    if (flags & F_RIGHT)
     s="Yes";
    else
     s="No ";
    PrintXY(236,130,s);
    if (flags & F_LEFT)
     s="Yes";
    else
     s="No ";
    PrintXY(255,130,s);
    if (flags & F_UP)
     s="Yes";
    else
     s="No ";
    PrintXY(236,141,s);
    if (flags & F_DOWN)
     s="Yes";
    else
     s="No ";
    PrintXY(255,141,s);
    if (flags & F_TRANSPARENT)
     s="Yes";
    else
     s="No ";
    PrintXY(236,152,s);
    if (flags & F_NOCLIP)
     s="Yes";
    else
     s="No ";
    PrintXY(255,152,s);
    if (flags & F_NOBULLETCLIP)
     s="Yes";
    else
     s="No ";
    PrintXY(236,163,s);
    if (flags & F_DAMAGE)
     s="Yes";
    else
     s="No ";
    PrintXY(255,163,s);
    break;
   default:
    PrintXY(236,130,"No ");
    PrintXY(255,130,"No ");
    PrintXY(236,141,"No ");
    PrintXY(255,141,"No ");
    PrintXY(236,152,"No ");
    PrintXY(255,152,"No ");
    PrintXY(236,163,"No ");
    PrintXY(255,163,"No ");
    break;
   }
 }



/* MAIN *********************************************************************/

void MainLoop(void)
{
 int c, ans, i;

 UpdateLocalInfo();
 DrawBuffer();
 BlitBuffer();
 while (!quit)
  {
   ans=ReadKey();
   if (messageready) DeleteMessage();
   c=ans & 255;
   switch (c)
    {
     case 0x00:
     case 0xE0:
      c=(word)ans>>8;
      switch (c)
       {
	 /* keypad controls */
	case 75:
	 if (currentx>0)
	  {
	   --currentx;
	   if (*(byte*)MK_FP(0x0040,0x0017)&64)
	    (*layers[currentlayer])[currenty][currentx]=currentvalue[currentlayer];
	   UpdateLocalInfo();
	   DrawBuffer();
	   BlitBuffer();
	   }
	 break;
	case 77:
	 if (currentx<XMAX-1)
	  {
	   ++currentx;
	   if (*(byte*)MK_FP(0x0040,0x0017)&64)
	    (*layers[currentlayer])[currenty][currentx]=currentvalue[currentlayer];
	   UpdateLocalInfo();
	   DrawBuffer();
	   BlitBuffer();
	   }
	 break;
	case 72:
	 if (currenty>0)
	  {
	   --currenty;
	   if (*(byte*)MK_FP(0x0040,0x0017)&64)
	    (*layers[currentlayer])[currenty][currentx]=currentvalue[currentlayer];
	   UpdateLocalInfo();
	   DrawBuffer();
	   BlitBuffer();
	   }
	 break;
	case 80:
	 if (currenty<YMAX-1)
	  {
	   ++currenty;
	   if (*(byte*)MK_FP(0x0040,0x0017)&64)
	    (*layers[currentlayer])[currenty][currentx]=currentvalue[currentlayer];
	   UpdateLocalInfo();
	   DrawBuffer();
	   BlitBuffer();
	   }
	 break;
	case 73:
	 currenty-=10;
	 if (currenty<0) currenty=0;
	 if (*(byte*)MK_FP(0x0040,0x0017)&64)
	  (*layers[currentlayer])[currenty][currentx]=currentvalue[currentlayer];
	 UpdateLocalInfo();
	 DrawBuffer();
	 BlitBuffer();
	 break;
	case 81:
	 currenty+=10;
	 if (currenty>=YMAX) currenty=YMAX;
	 if (*(byte*)MK_FP(0x0040,0x0017)&64)
	  (*layers[currentlayer])[currenty][currentx]=currentvalue[currentlayer];
	 UpdateLocalInfo();
	 DrawBuffer();
	 BlitBuffer();
	 break;
	case 71:
	 currentx-=10;
	 if (currentx<0) currentx=0;
	 if (*(byte*)MK_FP(0x0040,0x0017)&64)
	  (*layers[currentlayer])[currenty][currentx]=currentvalue[currentlayer];
	 UpdateLocalInfo();
	 DrawBuffer();
	 BlitBuffer();
	 break;
	case 79:
	 currentx+=10;
	 if (currentx>=YMAX) currentx=YMAX;
	 if (*(byte*)MK_FP(0x0040,0x0017)&64)
	  (*layers[currentlayer])[currenty][currentx]=currentvalue[currentlayer];
	 UpdateLocalInfo();
	 DrawBuffer();
	 BlitBuffer();
	 break;

	 /* flood/fill commands */
	case 33: // alt-f
	 if (AskQuestion("Fill? (y/n)"))
	  {
	   memset(layers[currentlayer],currentvalue[currentlayer],sizeof(layer_t));
	   UpdateLocalInfo();
	   Drawbuffer();
	   BlitBuffer();
	   }
	 break;

	case 36: // alt-j
	 if (AskQuestion("Flood? (y/n)"))
	  {
	   FloodFill();
	   UpdateLocalInfo();
	   Drawbuffer();
	   BlitBuffer();
	   }
	 break;

	 /* flag setting commands */
	case 59:
	 switch (currentlayer)
	  {
	   case NORTHWALL:
	   case WESTWALL:
	   case FLOORDEF:
	   case CEILINGDEF:
	   case FLOOR:
	   case CEILING:
	    (*layers[currentlayer+1])[currenty][currentx]^=F_RIGHT;
	    UpdateLocalInfo();
	    break;
	   }
	 break;
	case 60:
	 switch (currentlayer)
	  {
	   case NORTHWALL:
	   case WESTWALL:
	   case FLOORDEF:
	   case CEILINGDEF:
	   case FLOOR:
	   case CEILING:
	    (*layers[currentlayer+1])[currenty][currentx]^=F_LEFT;
	    UpdateLocalInfo();
	    break;
	   }
	 break;
	case 61:
	 switch (currentlayer)
	  {
	   case NORTHWALL:
	   case WESTWALL:
	   case FLOORDEF:
           case CEILINGDEF:
	   case FLOOR:
           case CEILING:
            (*layers[currentlayer+1])[currenty][currentx]^=F_UP;
            UpdateLocalInfo();
            break;
           }
         break;
        case 62:
         switch (currentlayer)
          {
	   case NORTHWALL:
           case WESTWALL:
	   case FLOORDEF:
           case CEILINGDEF:
           case FLOOR:
           case CEILING:
            (*layers[currentlayer+1])[currenty][currentx]^=F_DOWN;
            UpdateLocalInfo();
            break;
           }
	 break;
        case 64:
         switch (currentlayer)
          {
	   case NORTHWALL:
           case WESTWALL:
            (*layers[currentlayer+1])[currenty][currentx]^=F_NOCLIP;
            UpdateLocalInfo();
            break;
           }
         break;
        case 63:
         switch (currentlayer)
          {
           case NORTHWALL:
           case WESTWALL:
           case FLOORDEF:
           case CEILINGDEF:
           case CEILING:
            (*layers[currentlayer+1])[currenty][currentx]^=F_TRANSPARENT;
	    UpdateLocalInfo();
            break;
           }
         break;
        case 65:
         switch (currentlayer)
          {
           case NORTHWALL:
           case WESTWALL:
            (*layers[currentlayer+1])[currenty][currentx]^=F_NOBULLETCLIP;
	    UpdateLocalInfo();
            break;
	   }
         break;
        case 66:
         switch (currentlayer)
          {
           case NORTHWALL:
           case WESTWALL:
           case FLOOR:
           case CEILING:
            (*layers[currentlayer+1])[currenty][currentx]^=F_DAMAGE;
	    UpdateLocalInfo();
            break;
           }
         break;

         /* file commands */
        case 31: // alt-s
	 SaveLAYFile();
         break;
        case 38: // alt-l
         LoadLayFile();
         UpdateLocalInfo();
         Drawbuffer();
         BlitBuffer();
         break;


         /* quit command */
	case 45: // alt-x
        case 16: // alt-q
         if (AskQuestion("Quit? (y/n)")) quit=true;
         break;

        }
      break;

       /* value commands */
     case ' ':
      (*layers[currentlayer])[currenty][currentx]=currentvalue[currentlayer];
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;
     case '.':
     case '+':
      currentvalue[currentlayer]++;
      currentvalue[currentlayer]&=255;
      UpdateLocalInfo();
      break;
     case ',':
     case '-':
      currentvalue[currentlayer]--;
      currentvalue[currentlayer]&=255;
      UpdateLocalInfo();
      break;
     case 'z':
     case 'Z':
      currentvalue[currentlayer]=(*layers[currentlayer])[currenty][currentx];
      UpdateLocalInfo();
      break;
     case 'x':
     case 'X':
      (*layers[currentlayer])[currenty][currentx]=0;
      UpdateLocalInfo();
      DrawBuffer();
      BlitBuffer();
      break;
     case 'c':
     case 'C':
      for (i=0;i<NUMLAYERS;i++)
       currentvalue[i]=(*layers[i])[currenty][currentx];
      UpdateLocalInfo();
      break;
     case 'v':
     case 'V':
      for (i=0;i<NUMLAYERS;i++)
       (*layers[i])[currenty][currentx]=currentvalue[i];
      UpdateLocalInfo();
      DrawBuffer();
      BlitBuffer();
      break;

      /* layer commands */
     case 9:
      switch (currentlayer)
       {
        case NORTHWALL:
         currentlayer=WESTWALL;
         break;
        case WESTWALL:
         currentlayer=NORTHWALL;
         break;
        case FLOOR:
         currentlayer=CEILING;
	 break;
        case CEILING:
         currentlayer=FLOOR;
         break;
        case FLOORHEIGHT:
         currentlayer=CEILINGHEIGHT;
         break;
        case CEILINGHEIGHT:
         currentlayer=FLOORHEIGHT;
         break;
        case CEILINGDEF:
         currentlayer=FLOORDEF;
         break;
        case FLOORDEF:
         currentlayer=CEILINGDEF;
         break;
        }
      UpdateLocalInfo();
      DrawBuffer();
      BlitBuffer();
      break;
     case '1':
      currentlayer=NORTHWALL;
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;
     case '2':
      currentlayer=WESTWALL;
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;
     case '3':
      currentlayer=FLOOR;
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;
     case '4':
      currentlayer=CEILING;
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;
     case '5':
      currentlayer=FLOORHEIGHT;
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;
     case '6':
      currentlayer=CEILINGHEIGHT;
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;
     case '7':
      currentlayer=FLOORDEF;
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;
     case '8':
      currentlayer=CEILINGDEF;
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;
     case '9':
      currentlayer=LIGHTS;
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;
     case '0':
      currentlayer=EFFECTS;
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;
     case 'q':
     case 'Q':
      currentlayer=SPRITES;
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;
     case 'w':
     case 'W':
      currentlayer=SLOPES;
      UpdateLocalInfo();
      Drawbuffer();
      BlitBuffer();
      break;

      /* quit */
     case 27:
      if (AskQuestion("Quit? (y/n)")) quit=true;
      break;
     }
   }
 }


cdecl main(int argc, char **argv)
{
 /* Initialize */
 InitMEDIT();
 SetVidMode(VGAMODE);
 LoadCPR("MEDIT.CPR");
 LoadFON("BLOCK.FON",FONTWIDTH);

 /* check parameters */
 if (argc==1) Error("No LAY/LVL file specified");
  else if (argc>4) Error("Too many parameters");
  else
  {
   ReadLevel(argv[1]);
   if (argc>=3) Convert1(argv[2]);
   if (argc>=4) Convert2(argv[3]);
   MainLoop();
   }

 /* end message */
 SetVidMode(TEXTMODE);
 printf("MEDIT (v%s)\n"
	"LAY/LVL File Editor\n"
	"Copyright (C) 1995 by Robert Morgan of Channel 7\n"
	"All rights reserved.\n\n",VERSION);
 }