// M_misc.c
#ifdef __NeXT__
#include <libc.h>
#else
#include <sys/stat.h>
#include <sys/types.h>
//#include <direct.h>
#include <fcntl.h>
#include <stdlib.h>
#endif

#include <ctype.h>

#include "doomdef.h"
#include "hu_stuff.h"

int		myargc;
char	**myargv;

/*
====================
=
= M_DrawText
=
= Returns the final X coordinate
= HU_Init must have been called to init the font
====================
*/

extern	patch_t *hu_font[HU_FONTSIZE];

int M_DrawText (int x, int y, boolean direct, char *string)
{
	int 	c,w;

	while (*string)
	{
		c = toupper(*string) - HU_FONTSTART;
		string++;
		if (c < 0 || c> HU_FONTSIZE)
		{
			x += 4;
			continue;
		}
		
		w = SHORT (hu_font[c]->width);
		if (x+w > SCREENWIDTH)
			break;
		if (direct)
			V_DrawPatchDirect(x, y, 0, hu_font[c]);
		else
			V_DrawPatch(x, y, 0, hu_font[c]);
		x+=w;
	}
  
  return x;
}


/* 
================= 
= 
= M_CheckParm 
= 
= Checks for the given parameter in the program's command line arguments 
= 
= Returns the argument number (1 to argc-1) or 0 if not present 
= 
================= 
*/ 
 
int M_CheckParm (char *check) 
{ 
	int		i; 
 
	for (i = 1;i<myargc;i++) 
	{ 
		if ( !strcasecmp(check, myargv[i]) ) 
			return i; 
	} 
 
	return 0; 
} 
 


/*
===============
=
= M_Random
=
= Returns a 0-255 number
=
===============
*/

unsigned char rndtable[256] = {
	0,   8, 109, 220, 222, 241, 149, 107,  75, 248, 254, 140,  16,  66 ,
	74,  21, 211,  47,  80, 242, 154,  27, 205, 128, 161,  89,  77,  36 ,
	95, 110,  85,  48, 212, 140, 211, 249,  22,  79, 200,  50,  28, 188 ,
	52, 140, 202, 120,  68, 145,  62,  70, 184, 190,  91, 197, 152, 224 ,
	149, 104,  25, 178, 252, 182, 202, 182, 141, 197,   4,  81, 181, 242 ,
	145,  42,  39, 227, 156, 198, 225, 193, 219,  93, 122, 175, 249,   0 ,
	175, 143,  70, 239,  46, 246, 163,  53, 163, 109, 168, 135,   2, 235 ,
	25,  92,  20, 145, 138,  77,  69, 166,  78, 176, 173, 212, 166, 113 ,
	94, 161,  41,  50, 239,  49, 111, 164,  70,  60,   2,  37, 171,  75 ,
	136, 156,  11,  56,  42, 146, 138, 229,  73, 146,  77,  61,  98, 196 ,
	135, 106,  63, 197, 195,  86,  96, 203, 113, 101, 170, 247, 181, 113 ,
	80, 250, 108,   7, 255, 237, 129, 226,  79, 107, 112, 166, 103, 241 ,
	24, 223, 239, 120, 198,  58,  60,  82, 128,   3, 184,  66, 143, 224 ,
	145, 224,  81, 206, 163,  45,  63,  90, 168, 114,  59,  33, 159,  95 ,
	28, 139, 123,  98, 125, 196,  15,  70, 194, 253,  54,  14, 109, 226 ,
	71,  17, 161,  93, 186,  87, 244, 138,  20,  52, 123, 251,  26,  36 ,
	17,  46,  52, 231, 232,  76,  31, 221,  84,  37, 216, 165, 212, 106 ,
	197, 242,  98,  43,  39, 175, 254, 145, 190,  84, 118, 222, 187, 136 ,
	120, 163, 236, 249 
};
int	rndindex = 0;
int prndindex = 0;

int P_Random (void)
{
	prndindex = (prndindex+1)&0xff;
	return rndtable[prndindex];
}

int M_Random (void)
{
	rndindex = (rndindex+1)&0xff;
	return rndtable[rndindex];
}

void M_ClearRandom (void)
{
	rndindex = prndindex = 0;
}


void M_ClearBox (fixed_t *box)
{
	box[BOXTOP] = box[BOXRIGHT] = MININT;
	box[BOXBOTTOM] = box[BOXLEFT] = MAXINT;
}

void M_AddToBox (fixed_t *box, fixed_t x, fixed_t y)
{
	if (x<box[BOXLEFT])
		box[BOXLEFT] = x;
	else if (x>box[BOXRIGHT])
		box[BOXRIGHT] = x;
	if (y<box[BOXBOTTOM])
		box[BOXBOTTOM] = y;
	else if (y>box[BOXTOP])
		box[BOXTOP] = y;
}



/* 
================== 
= 
= M_WriteFile
=
================== 
*/ 
 
#ifndef O_BINARY
#define O_BINARY 0
#endif

boolean M_WriteFile (char const *name, void *source, int length)
{
	int	handle, count;
	
	handle = open (name, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
	if (handle == -1)
		return false;
	count = write (handle, source, length);
	close (handle);
	
	if (count < length)
		return false;
		
	return true;
}


/* 
================== 
= 
= M_ReadFile
=
================== 
*/ 
 
int M_ReadFile (char const *name, byte **buffer)
{
	int	handle, count, length;
	struct stat	fileinfo;
	byte		*buf;
	
	handle = open (name, O_RDONLY | O_BINARY, 0666);
	if (handle == -1)
		I_Error ("Couldn't read file %s", name);
	if (fstat (handle,&fileinfo) == -1)
		I_Error ("Couldn't read file %s", name);
	length = fileinfo.st_size;
	buf = Z_Malloc (length, PU_STATIC, NULL);
	count = read (handle, buf, length);
	close (handle);
	
	if (count < length)
		I_Error ("Couldn't read file %s", name);
		
	*buffer = buf;
	return length;
}



/* 
============================================================================== 
 
							DEFAULTS 
 
============================================================================== 
*/ 

int		usemouse;
int		usejoystick;

extern	int		key_right, key_left, key_up, key_down;
extern	int		key_strafeleft, key_straferight;
extern	int		key_fire, key_use, key_strafe, key_speed;

extern	int			mousebfire;
extern	int			mousebstrafe;
extern	int			mousebforward;

extern	int			joybfire;
extern	int			joybstrafe;
extern	int			joybuse;
extern	int			joybspeed;

extern	int		viewwidth, viewheight;

extern	int	mouseSensitivity;
extern	int	showMessages;
extern	int	sfxVolume;
extern	int	musicVolume;
extern	int	detailLevel;

extern	int	screenblocks;

extern	int	showMessages;

// machine-independent sound params
extern	int	numChannels;

#ifdef __WATCOMC__
// machine-dependent sound params
extern	int	snd_DesiredMusicDevice;
extern	int	snd_DesiredSfxDevice;
extern	int	snd_SBport, snd_SBirq, snd_SBdma;
extern	int	snd_Mport;
#endif

#ifdef NORMALUNIX
extern  char *sndserver_filename;
extern	int	mb_used;
#endif

#ifdef LINUX
char *mousetype;
char *mousedev;
#endif

extern  char *chat_macros[];

typedef struct
{
	char	*name;
	int		*location;
	int		defaultvalue;
	int		scantranslate;		// PC scan code hack
	int		untranslated;		// lousy hack
} default_t;

default_t	defaults[] =
{
{"mouse_sensitivity",&mouseSensitivity, 5},
{"sfx_volume",&sfxVolume, 8},
{"music_volume",&musicVolume, 8},
{"show_messages",&showMessages, 1},

#ifdef __WATCOMC__
#define SC_UPARROW              0x48 
#define SC_DOWNARROW    		0x50 
#define SC_LEFTARROW            0x4b 
#define SC_RIGHTARROW   		0x4d 
#define SC_RCTRL		   		0x1d 
#define SC_RALT			   		0x38 
#define SC_RSHIFT		   		0x36 
#define SC_SPACE		   		0x39 
#define SC_COMMA		   		0x33 
#define SC_PERIOD		   		0x34 

{"key_right",&key_right, SC_RIGHTARROW,1},
{"key_left",&key_left, SC_LEFTARROW,1},
{"key_up",&key_up, SC_UPARROW,1},
{"key_down",&key_down, SC_DOWNARROW,1},
{"key_strafeleft",&key_strafeleft, SC_COMMA,1},
{"key_straferight",&key_straferight, SC_PERIOD,1},

{"key_fire",&key_fire, SC_RCTRL,1},
{"key_use",&key_use, SC_SPACE,1},
{"key_strafe",&key_strafe, SC_RALT,1},
{"key_speed",&key_speed, SC_RSHIFT,1},
#endif

#ifdef __NeXT__
{"key_right",&key_right, KEY_RIGHTARROW},
{"key_left",&key_left, KEY_LEFTARROW},
{"key_up",&key_up, KEY_UPARROW},
{"key_down",&key_down, KEY_DOWNARROW},
{"key_strafeleft",&key_strafeleft, ','},
{"key_straferight",&key_straferight, '.'},

{"key_fire",&key_fire, ' ',1},
{"key_use",&key_use, 'x',1},
{"key_strafe",&key_strafe, 'c',1},
{"key_speed",&key_speed, 'z',1},
#endif

#ifdef NORMALUNIX

{"key_right",&key_right, KEY_RIGHTARROW},
{"key_left",&key_left, KEY_LEFTARROW},
{"key_up",&key_up, KEY_UPARROW},
{"key_down",&key_down, KEY_DOWNARROW},
{"key_strafeleft",&key_strafeleft, ','},
{"key_straferight",&key_straferight, '.'},

{"key_fire",&key_fire, KEY_RCTRL},
{"key_use",&key_use, ' '},
{"key_strafe",&key_strafe, KEY_RALT},
{"key_speed",&key_speed, KEY_RSHIFT},

{"sndserver", (int *) &sndserver_filename, (int) "sndserver"},
{"mb_used", &mb_used, 2},

#endif

#ifdef LINUX
{"mousedev", (int*)&mousedev, (int)"/dev/ttyS0"},
{"mousetype", (int*)&mousetype, (int)"microsoft"},
#endif

{"use_mouse",&usemouse, 1},
{"mouseb_fire",&mousebfire,0},
{"mouseb_strafe",&mousebstrafe,1},
{"mouseb_forward",&mousebforward,2},

{"use_joystick",&usejoystick, 0},
{"joyb_fire",&joybfire,0},
{"joyb_strafe",&joybstrafe,1},
{"joyb_use",&joybuse,3},
{"joyb_speed",&joybspeed,2},

{"screenblocks",&screenblocks, 9},
{"detaillevel",&detailLevel, 0},

{"snd_channels",&numChannels, 3},

#ifdef __WATCOMC__
{"snd_musicdevice", &snd_DesiredMusicDevice, 0},
{"snd_sfxdevice", &snd_DesiredSfxDevice, 0},
{"snd_sbport", &snd_SBport, 0x220},
{"snd_sbirq", &snd_SBirq, 5},
{"snd_sbdma", &snd_SBdma, 1},
{"snd_mport", &snd_Mport, 0x330},
#endif

{"usegamma",&usegamma, 0},

{"chatmacro0", (int *) &chat_macros[0], (int) HUSTR_CHATMACRO0 },
{"chatmacro1", (int *) &chat_macros[1], (int) HUSTR_CHATMACRO1 },
{"chatmacro2", (int *) &chat_macros[2], (int) HUSTR_CHATMACRO2 },
{"chatmacro3", (int *) &chat_macros[3], (int) HUSTR_CHATMACRO3 },
{"chatmacro4", (int *) &chat_macros[4], (int) HUSTR_CHATMACRO4 },
{"chatmacro5", (int *) &chat_macros[5], (int) HUSTR_CHATMACRO5 },
{"chatmacro6", (int *) &chat_macros[6], (int) HUSTR_CHATMACRO6 },
{"chatmacro7", (int *) &chat_macros[7], (int) HUSTR_CHATMACRO7 },
{"chatmacro8", (int *) &chat_macros[8], (int) HUSTR_CHATMACRO8 },
{"chatmacro9", (int *) &chat_macros[9], (int) HUSTR_CHATMACRO9 }

};

int		numdefaults;
char	*defaultfile;

/*
==============
=
= M_SaveDefaults
=
==============
*/

void M_SaveDefaults (void)
{
	int		i,v;
	FILE	*f;
	
	f = fopen (defaultfile, "w");
	if (!f)
		return;			// can't write the file, but don't complain
		
	for (i=0 ; i<numdefaults ; i++)
	{
#ifdef __WATCOMC__
		if (defaults[i].scantranslate)
			defaults[i].location = &defaults[i].untranslated;
#endif
		if (defaults[i].defaultvalue > -0xfff
		  && defaults[i].defaultvalue < 0xfff)
		{
			v = *defaults[i].location;
			fprintf (f,"%s\t\t%i\n",defaults[i].name,v);
		} else {
			fprintf (f,"%s\t\t\"%s\"\n",defaults[i].name,
			  * (char **) (defaults[i].location));
		}
	}
	
	fclose (f);
}


/*
==============
=
= M_LoadDefaults
=
==============
*/

extern byte scantokey[128];

void M_LoadDefaults (void)
{
	int		i, len;
	FILE	*f;
	char	def[80];
	char		strparm[100];
	char	*newstring;
	int		parm;
	boolean		isstring;
		
//
// set everything to base values
//
	numdefaults = sizeof(defaults)/sizeof(defaults[0]);
	for (i=0 ; i<numdefaults ; i++)
		*defaults[i].location = defaults[i].defaultvalue;

//
// check for a custom default file
//
	i = M_CheckParm ("-config");
	if (i && i<myargc-1)
	{
		defaultfile = myargv[i+1];
		printf ("	default file: %s\n",defaultfile);
	}
	else
		defaultfile = basedefault;
		
//
// read the file in, overriding any set defaults
//
	f = fopen (defaultfile, "r");
	if (f)
	{
		while (!feof(f))
		{
			isstring = false;
			if (fscanf (f, "%79s %[^\n]\n", def, strparm) == 2)
			{
			  if (strparm[0] == '"')
			  {
			    // get a string default
			    isstring = true;
			    len = strlen(strparm);
			    newstring = (char *) malloc(len);
			    strparm[len-1] = 0;
			    strcpy(newstring, strparm+1);
			  }
			  else if (strparm[0] == '0' && strparm[1] == 'x')
				  sscanf(strparm+2, "%x", &parm);
			  else
				  sscanf(strparm, "%i", &parm);
			  for (i=0 ; i<numdefaults ; i++)
				  if (!strcmp(def, defaults[i].name))
				  {
					  if (!isstring)
					    *defaults[i].location = parm;
					  else 
					    *defaults[i].location =
					      (int) newstring;
					  break;
				  }
			}
		}
		
		fclose (f);
	}
	
#ifdef __WATCOMC__
	for (i=0 ; i<numdefaults ; i++)
		if (defaults[i].scantranslate)
		{
			parm = *defaults[i].location;
			defaults[i].untranslated = parm;
			*defaults[i].location = scantokey[parm];
		}
#endif
}
 

/* 
============================================================================== 
 
						SCREEN SHOTS 
 
============================================================================== 
*/ 
 

typedef struct
{
    char	manufacturer;
    char	version;
    char	encoding;
    char	bits_per_pixel;
    unsigned short	xmin,ymin,xmax,ymax;
    unsigned short	hres,vres;
    unsigned char	palette[48];
    char	reserved;
    char	color_planes;
    unsigned short	bytes_per_line;
    unsigned short	palette_type;
    char	filler[58];
    unsigned char	data;			// unbounded
} pcx_t;

/* 
============== 
= 
= WritePCXfile 
= 
============== 
*/ 
 
void WritePCXfile (char *filename, byte *data, int width, int height, byte *palette) 
{
	int		i, length;
	pcx_t	*pcx;
	byte		*pack;
	  
	pcx = Z_Malloc (width*height*2+1000, PU_STATIC, NULL); 
 
	pcx->manufacturer = 0x0a;	// PCX id
	pcx->version = 5;			// 256 color
 	pcx->encoding = 1;		// uncompressed
	pcx->bits_per_pixel = 8;		// 256 color
	pcx->xmin = 0;
	pcx->ymin = 0;
	pcx->xmax = SHORT(width-1);
	pcx->ymax = SHORT(height-1);
	pcx->hres = SHORT(width);
	pcx->vres = SHORT(height);
	memset (pcx->palette,0,sizeof(pcx->palette));
	pcx->color_planes = 1;		// chunky image
	pcx->bytes_per_line = SHORT(width);
	pcx->palette_type = SHORT(2);		// not a grey scale
	memset (pcx->filler,0,sizeof(pcx->filler));

//
// pack the image
//
	pack = &pcx->data;
	
	for (i=0 ; i<width*height ; i++)
		if ( (*data & 0xc0) != 0xc0)
			*pack++ = *data++;
		else
		{
			*pack++ = 0xc1;
			*pack++ = *data++;
		}
			
//
// write the palette
//
	*pack++ = 0x0c;	// palette ID byte
	for (i=0 ; i<768 ; i++)
		*pack++ = *palette++;
		
// 
// write output file 
// 
	length = pack - (byte *)pcx;
	M_WriteFile (filename, pcx, length);
 
	Z_Free (pcx); 
} 
 

//==============================================================================

/* 
================== 
= 
= M_ScreenShot 
= 
================== 
*/ 
 
void M_ScreenShot (void) 
{ 
	int     i; 
	byte	*linear; 
	char		lbmname[12]; 

// 
// munge planar buffer to linear 
// 
	linear = screens[2];
	I_ReadScreen (linear);

// 
// find a file name to save it to 
// 
	strcpy(lbmname,"DOOM00.pcx");
		
	for (i=0 ; i<=99 ; i++) 
	{ 
		lbmname[4] = i/10 + '0'; 
		lbmname[5] = i%10 + '0'; 
		if (access(lbmname,0) == -1)
			break;	// file doesn't exist
	} 
	if (i==100) 
		I_Error ("M_ScreenShot: Couldn't create a PCX"); 
 
// 
// save the pcx file 
// 
	WritePCXfile (lbmname, linear, SCREENWIDTH, SCREENHEIGHT
		, W_CacheLumpName ("PLAYPAL",PU_CACHE));
	
	players[consoleplayer].message = "screen shot";
}