/*
NMGRFX v.2.01 (c) 2002. Nick Meyer

Very simple and easy to use MODE13H graphics library
in Turbo C++.

DESCRIPTION OF CAPABILITIES:
-mode13h support
-double buffering
-direct input
-drawing functions

HOW TO USE MODE13H:
-call setmode(MODE13H) at beggining of program
-call setmode(TEXTMODE) at end of program

DOUBLE BUFFERING:
-call setupbuf() at beggining
-call clrbuf() to clear buffer
-call showbuf() to show buffer
-all drawing functions draw to buffer

DIRECT INPUT:
-all key variables are either true or false.
	true=key pressed down. false=key up.
-test for key like this:

	if (KEY_VARIABLE) do_something();

	key variables:

	CursorUp        Up Arrow
	CursorDown      Down Arrow
	CursorLeft      ...
	CursorRight     ...

	KeyA            'A' key
	KeyS            'S' key
	KeyW            ...
	KeyD            ...


ÚÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
³ Scan Codes ³\
ÀÄÄÄÄÄÄÄÄÄÄÄÄÙ\

The following is a list of all the regular key scan codes in numerical
order:

Scan                                   Scan
Code Key                               Code Key
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ             ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
 1   ESC                               44   Z
 2   1                                 45   X
 3   2                                 46   C
 4   3                                 47   V
 5   4                                 48   B
 6   5                                 49   N
 7   6                                 50   M
 8   7                                 51   , <
 9   8                                 52   . >
10   9                                 53   / ?
11   0                                 54   RIGHT SHIFT
12   - _                               55   *            (KEYPAD)
13   = +                               56   LEFT ALT
14   BACKSPACE                         57   SPACEBAR
15   TAB                               58   CAPSLOCK
16   Q                                 59   F1
17   W                                 60   F2
18   E                                 61   F3
19   R                                 62   F4
20   T                                 63   F5
21   Y                                 64   F6
22   U                                 65   F7
23   I                                 66   F8
24   O                                 67   F9
25   P                                 68   F10
26   [ {                               69   NUMLOCK      (KEYPAD)
27   ] }                               70   SCROLL LOCK
28   ENTER (RETURN)                    71   7 HOME       (KEYPAD)
29   LEFT CONTROL                      72   8 UP         (KEYPAD)
30   A                                 73   9 PGUP       (KEYPAD)
31   S                                 74   -            (KEYPAD)
32   D                                 75   4 LEFT       (KEYPAD)
33   F                                 76   5            (KEYPAD)
34   G                                 77   6 RIGHT      (KEYPAD)
35   H                                 78   +            (KEYPAD)
36   J                                 79   1 END        (KEYPAD)
37   K                                 80   2 DOWN       (KEYPAD)
38   L                                 81   3 PGDN       (KEYPAD)
39   ; :                               82   0 INSERT     (KEYPAD)
40   ' "                               83   . DEL        (KEYPAD)
41   ` ~                               87   F11
42   LEFT SHIFT                        88   F12


The following is a list of all the extended key scan codes in numerical
order:

Scan                                   Scan
Code Key                               Code Key
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ        ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
28   ENTER        (KEYPAD)              75   LEFT         (NOT KEYPAD)
29   RIGHT CONTROL                      77   RIGHT        (NOT KEYPAD)
42   PRINT SCREEN (SEE TEXT)            79   END          (NOT KEYPAD)
53   /            (KEYPAD)              80   DOWN         (NOT KEYPAD)
55   PRINT SCREEN (SEE TEXT)            81   PAGE DOWN    (NOT KEYPAD)
56   RIGHT ALT                          82   INSERT       (NOT KEYPAD)
71   HOME         (NOT KEYPAD)          83   DELETE       (NOT KEYPAD)
72   UP           (NOT KEYPAD)         111   MACRO
73   PAGE UP      (NOT KEYPAD)


DRAWING FUNCTIONS:
-just look at the prototypes for drawing.
	Same as in normal BGI graphics, but
	with 'color' parameter in function call.

*/

//=========INCLUDES=====================

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <math.h>
#include <mem.h>
#include <iostream.h>
#include <alloc.h>
#include <mem.h>
#include <fstream.h>

//=========MODE DECS================

#define MODE13H 0x13
#define TEXTMODE 0x03

//========COLORS=================

#define WHITE 15
#define GRAY 7
#define DARKGRAY 8
#define BLACK 0
#define BROWN 6
#define GREEN 2
#define LIGHTGREEN 10
#define ORANGE 66
#define YELLOW 14
#define RED 4
#define BLUE 1
#define LIGHTBLUE 3
#define PURPLE 5

//==========KEYS====================

#define LEFT_ARROW 75
#define UP_ARROW 72
#define RIGHT_ARROW 77
#define DOWN_ARROW 80

//========MUSIX=======================

#define nA  100
#define nAs 200
#define nB  300
#define nBs 400
#define nC  500
#define nCs 600
#define nD  700
#define nDs 800
#define nE  900
#define nEs 1000
#define nF  1100
#define nFs 1200
#define nG  1300
#define nGs 1400

//==========PROTOTYPES==============================

char far *video_buffer = (char far *)0xA0000000L;
char far *double_buffer;
char far *temp;

#include <dos.h>
#ifdef __DJGPP
  #include <go32.h>
  #include <dpmi.h>
#endif
#ifdef __cplusplus
  #include <conio.h>
  #include <stdio.h>
#endif

//Key status indicators
int CursorUp,
  CursorDown,
  CursorLeft,
  CursorRight,
  KeyW,
  KeyS,
  KeyA,
  KeyD,
  KeyF,
  KeyP,
  KeyI,
  KeyK,
  KeyJ,
  KeyL,
  Key3,
  Key0,
  Key1,
  KeyDel,
  KeyEnter,
  KeyAlt,
  KeyRShift,
  KeyRCtrl,
  KeyEscape,
  Spacebar;

//Pointer to original keyboard handler
#ifdef __DJGPP
  //and for DJGPP also to the new handler...
  _go32_dpmi_seginfo BIOSHandler, MyHandler;
#else
  #ifdef __cplusplus
	void interrupt (*BIOSHandler)(...);
  #else
	void interrupt (*BIOSHandler)();
  #endif
#endif

int getkeyval();
int randint(int low, int high);

void setmode(int mode);
void setupbuf();
void disablebuf();
void clrbuf();
void showbuf();
void cleardevice();
void fillbuf(unsigned char color);
void setupkbd();
void restorekbd();

void putpixel(int x,int y, unsigned char color);
unsigned char getpixel(int x,int y);
void putbigpixel(int x,int y, unsigned char color);
void horiz(float x1,float y1,float x2,unsigned char color);
void horiz(float x1,float y1,float x2,float width,unsigned char color);
void vert(float x1,float y1,float y2,unsigned char color);
void vert(float x1,float y1,float y2,float width,unsigned char color);
void line(float x1,float y1,float x2,float y2, unsigned char color);
void line(float x1,float y1,float x2,float y2,float width,unsigned char color);
void triangle(float x1,float y1,float x2,float y2, float x3, float y3, unsigned char color);
void circle(float x,float y, float radius, unsigned char color);

//==========DRAWING FUNCTIONS===================================
void line(float x1,float y1,float x2,float y2, unsigned char color)
{
	if (abs(y1 - y2) > abs(x1 - x2)) {
	  // ! (0 < the magnitude of the slope < 1) 

	// make the first point the bottom-most point 
  if (y1 > y2) { 
   int temp; 
   temp = x1; 
   x1 = x2; 
   x2 = temp; 
   temp = y1; 
   y1 = y2; 
   y2 = temp;
  } 


  // make the algorithm work for negative slopes 
  int slopeSign = 1; 
  if (x2 < x1) slopeSign = -1; 

  int dx = x2 - x1, dy = y2 - y1; 
  int d = 2 * dx - dy; 
  int incrE = 2 * dx * slopeSign, incrNE = 2 * ((dx * slopeSign) - dy); 
  int x = x1, y = y1; 

  putpixel(x,y,color); 

  while (y < y2) { 
   if (d < 0) { 
 d += incrE; 
 y++; 
   } 
   else { 
 d += incrNE; 
 y++; 
 x += slopeSign; 
   } 
   putpixel(x,y,color); 
  } 
 } 

 // 0 < the magnitude of the slope < 1
 else { 

  // make the first point the left-most point
  if (x1 > x2) { 
   int temp;
   temp = x1; 
   x1 = x2;
   x2 = temp; 
   temp = y1; 
   y1 = y2; 
   y2 = temp; 
  } 



  // make the algorithm work for negative slopes
  int slopeSign = 1; 
  if (y2 < y1) slopeSign = -1; 

  int dx = x2 - x1, dy = y2 - y1; 
  int d = 2 * dy - dx; 
  int incrE = 2 * dy * slopeSign, incrNE = 2 * ((dy * slopeSign) - dx); 
  int x = x1, y = y1; 

  putpixel(x,y,color); 

  while (x < x2) { 
   if (d < 0) { 
 d += incrE; 
 x++; 
   } 
   else { 
 d += incrNE; 
 x++; 
 y += slopeSign; 
   } 
   putpixel(x,y,color); 
  } 
 } 

}
void line(float x1,float y1,float x2,float y2,float width,unsigned char color)
{
	float hw = width / 2;
	for (int n=-hw;n<=hw;n++)
		line(x1+n,y1,x2+n,y2,color);
}
void horiz(float x1,float y1,float x2,unsigned char color)
{
	for (int x=x1;x<x2;x++)
		putpixel(x,y1,color);
}
void horiz(float x1,float y1,float x2,float width,unsigned char color)
{
	for (int x=x1;x<x2;x++)
		for (int n=y1-width/2;n<=y1+width/2;n++)
			putpixel(x,n,color);
}
void vert(float x1,float y1,float y2,unsigned char color)
{
	for (int y=y1;y<y2;y++)
		putpixel(x1,y,color);
}
void vert(float x1,float y1,float y2,int width,unsigned char color)
{
	for (int y=y1;y<y2;y++)
		for (int n=x1-width/2;n<=x1+width/2;n++)
			putpixel(n,y,color);
}
void putpixel(int x,int y, unsigned char color)
{
	//double_buffer[((y<<8) + (y<<60)) + x] = color;
	double_buffer[ x + 320 * y ] = color;
}
void putpixel(int x,int y, unsigned char color,char far *dest)
{
	//double_buffer[((y<<8) + (y<<60)) + x] = color;
	dest[ x + 320 * y ] = color;
}

unsigned char getpixel(int x,int y)
{
	return double_buffer[ x +320 * y];
}
void putbigpixel(int x,int y,unsigned char color)
{
	for (int n=0;n<3;n++)
		{
		putpixel(x+n,y-1,color);
		putpixel(x+n,y  ,color);
		putpixel(x+n,y+1,color);
		}
}
void rectangle(float x1,float y1, float x2,float y2,unsigned char color)
{
	horiz(x1,y1,x2,color);
	horiz(x1,y2,x2,color);
	vert(x1,y1,y2,color);
	vert(x2-1,y1,y2,color);
}
void circle(float x,float y, float radius, unsigned char color)
{
	for (float s=0.0;s<4.0 * 3.1415926; s+= .01)
	{
		putpixel((cos(s)*radius+x),(sin(s)*radius) * .8 + y,color);
	}
}
void circle(float x,float y, float radius, unsigned char color,char far* dest)
{
	for (float s=0.0;s<4.0 * 3.1415926; s+= .01)
	{
		putpixel((cos(s)*radius+x),(sin(s)*radius) * .8 + y,color,dest);
	}
}

void triangle(float x1,float y1,float x2, float y2,float x3,float y3, unsigned char color)
{
	line(x1,y1,x2,y2,color);
	line(x2,y2,x3,y3,color);
	line(x3,y3,x1,y1,color);
}

//========MANAGMENT FUNCTIONS==================

int getmaxx() { return 320; }
int getmaxy() { return 200; }
void showbuf()
{
	_fmemcpy(video_buffer,double_buffer,64000);
}
void showback()
{
	_fmemcpy(video_buffer,double_buffer,64000);
}
void cleardevice()
{
	_fmemset(video_buffer,0,64000);
}
void setupbuf()
{
	double_buffer = (char far*) farmalloc(64000);
	if (!double_buffer) exit(1);
}
void disablebuf()
{
	farfree(double_buffer);
	if (temp) farfree(temp);
}
void clrbuf()
{
	_fmemset(double_buffer,0,64000);
}
void fillbuf(unsigned char color)
{
	_fmemset(double_buffer,color,64000);
}
void setmode(int mode)
{
	asm mov ah, 0
	asm mov al, BYTE PTR mode
	asm int 10h
}
#ifdef __DJGPP
  void KeyCheck ()
#else
  #ifdef __cplusplus
	void interrupt KeyCheck (...)
  #else
	void interrupt KeyCheck ()
  #endif
#endif
{
  //Assume BIOS has to be called
  int CallBIOSHandler = 1;

  //Read scancode from keyboard
  unsigned char scanCode = inp (0x60);

  //Esc key pressed
  if (scanCode == 1) {
	KeyEscape = 1;
	CallBIOSHandler = 0;
  }
  //Esc key depressed
  if (scanCode == 129) {
	KeyEscape = 0;
	CallBIOSHandler = 0;
  }
  //Enter key pressed
  if (scanCode == 28) {
	KeyEnter = 1;
	CallBIOSHandler = 0;
  }
  //Enter key depressed
  if (scanCode == 156) {
	KeyEnter = 0;
	CallBIOSHandler = 0;
  }
  //Alt key pressed
  if (scanCode == 56) {
	KeyAlt = 1;
	CallBIOSHandler = 0;
  }
  //Alt key depressed
  if (scanCode == 184) {
	KeyAlt = 0;
	CallBIOSHandler = 0;
  }
  //RShift key pressed
  if (scanCode == 54) {
	KeyRShift = 1;
	CallBIOSHandler = 0;
  }
  //RShift key depressed
  if (scanCode == 182) {
	KeyRShift = 0;
	CallBIOSHandler = 0;
  }
  //RCtrl key pressed
  if (scanCode == 29) {
	KeyRCtrl = 1;
	CallBIOSHandler = 0;
  }
  //RCtrl key depressed
  if (scanCode == 157) {
	KeyRCtrl = 0;
	CallBIOSHandler = 0;
  }
  //Space pressed
  if (scanCode == 57) {
	Spacebar = 1;
	CallBIOSHandler = 0;
  }
  //Space depressed
  if (scanCode == 185) {
	Spacebar = 0;
	CallBIOSHandler = 0;
  }
  //Up key pressed
  if (scanCode == 72) {
	CursorUp = 1;
	CallBIOSHandler = 0;
  }
  //Up key depressed
  if (scanCode == 200) {
	CursorUp = 0;
	CallBIOSHandler = 0;
  }
  //Left key pressed
  if (scanCode == 75) {
	CursorLeft = 1;
	CallBIOSHandler = 0;
  }
  //Left key depressed
  if (scanCode == 203) {
	CursorLeft = 0;
	CallBIOSHandler = 0;
  }
  //Right key pressed
  if (scanCode == 77) {
	CursorRight = 1;
	CallBIOSHandler = 0;
  }
  //Right key depressed
  if (scanCode == 205) {
	CursorRight = 0;
	CallBIOSHandler = 0;
  }
  //Down key pressed
  if (scanCode == 80) {
	CursorDown = 1;
	CallBIOSHandler = 0;
  }
  //Down key depressed
  if (scanCode == 208) {
	CursorDown = 0;
	CallBIOSHandler = 0;
  }
//===================================//
// ASDW KEYS FOR 2ND PLAYER MOVEMENT ||
//===================================//
   if (scanCode == 30) {
	KeyA = 1;
	CallBIOSHandler = 0;
  }
  if (scanCode == 158) {
	KeyA = 0;
	CallBIOSHandler = 0;
  }
  if (scanCode == 17) {
	KeyW = 1;
	CallBIOSHandler = 0;
  }
  if (scanCode == 145) {
	KeyW = 0;
	CallBIOSHandler = 0;
  }
  if (scanCode == 32) {
	KeyD = 1;
	CallBIOSHandler = 0;
  }
  if (scanCode == 160) {
	KeyD = 0;
	CallBIOSHandler = 0;
  }
  if (scanCode == 31) {
	KeyS = 1;
	CallBIOSHandler = 0;
  }
  if (scanCode == 159) {
	KeyS = 0;
	CallBIOSHandler = 0;
  }
//===================================//
// JKLI KEYS FOR 3RD PLAYER MOVEMENT ||
//===================================//
   if (scanCode == 36) {
	KeyJ = 1;
	CallBIOSHandler = 0;
  }
  if (scanCode == 164) {
	KeyJ = 0;
	CallBIOSHandler = 0;
  }
  if (scanCode == 37) {
	KeyK = 1;
	CallBIOSHandler = 0;
  }
  if (scanCode == 165) {
	KeyK = 0;
	CallBIOSHandler = 0;
  }
  if (scanCode == 38) {
	KeyL = 1;
	CallBIOSHandler = 0;
  }
  if (scanCode == 166) {
	KeyL = 0;
	CallBIOSHandler = 0;
  }
  if (scanCode == 23) {
	KeyI = 1;
	CallBIOSHandler = 0;
  }
  if (scanCode == 151) {
	KeyI = 0;
	CallBIOSHandler = 0;
  }
//===================================//
// 30DE KEYS FOR 4th PLAYER MOVEMENT ||
//===================================//
   if (scanCode == 81) {
	Key3 = 1;
	CallBIOSHandler = 0;
  }
  if (scanCode == 209) {
	Key3 = 0;
	CallBIOSHandler = 0;
  }
  if (scanCode == 82) {
	Key0 = 1;
	CallBIOSHandler = 0;
  }
  if (scanCode == 210) {
	Key0 = 0;
	CallBIOSHandler = 0;
  }
  if (scanCode == 83) {
	KeyDel = 1;
	CallBIOSHandler = 0;
  }
  if (scanCode == 211) {
	KeyDel = 0;
	CallBIOSHandler = 0;
  }
//==========================//
//     MISC. BUTTONS...     ||
//==========================//
  //'1'
  if (scanCode == 2) {
	Key1 = 1;
	CallBIOSHandler = 0;
  }
  //'1' key depressed
  if (scanCode == 130) {
	Key1 = 0;
	CallBIOSHandler = 0;
  }
  //'P' key pressed
  if (scanCode == 25) {
	KeyP = 1;
	CallBIOSHandler = 0;
  }
  //'P' key depressed
  if (scanCode == 153) {
	KeyP = 0;
	CallBIOSHandler = 0;
  }
  //'F' key pressed
  if (scanCode == 33)
  {
	KeyF =1;
	CallBIOSHandler = 0;
  }
  //'F' key depressed
  if (scanCode == 161)
  {
	KeyF = 0;
	CallBIOSHandler = 0;
  }

  //If we haven't handled the keypress ourselves...
  if (CallBIOSHandler) {
	//...let the BIOS take care of it...
	#ifdef __DJGPP
	  //DJGPP takes care of passing on to the BIOS iself
	#else
	  asm { pushf }
	  BIOSHandler ();
	#endif
  } else {
	//...otherwise, acknowledge the hardware interrupt
	outportb (0x20, 0x20);
  }
}
void setupkbd()
{
 #ifdef __DJGPP

 //     Don't be scared now!
//	  If you're not using DJGPP, skip to the "#else" part!


    //Get location of the new keyboard handler
    MyHandler.pm_offset = (int) KeyCheck;
    MyHandler.pm_selector = _go32_my_cs();
    //Save the old interrupt handler
    _go32_dpmi_get_protected_mode_interrupt_vector(9, &BIOSHandler);
	//Set the new interrupt handler in the chain
    _go32_dpmi_chain_protected_mode_interrupt_vector(9, &MyHandler);
  #else
    //Save BIOS keyboard handler
    BIOSHandler = getvect (9);
    //Set interrupt vector to our own routine
	setvect (9, KeyCheck);
  #endif
}
void restorekbd()
{
	setvect (9, BIOSHandler);
}

//===========CONVENIENT FUNCTIONS=======================


int getkeyval()
{
	int key = 0;
	while (!kbhit()) ;
	key = getch();

return (key);
}
int randint(int low,int high)
{
	return (random(high - low + 1) + low);
}

//=========SPECIALIZED CLASSES=======

class bitmap
{
	private:
		float x;
		float y;
		int width;
		int height;
		unsigned char *data;

	public:
		//constructor
		bitmap()
		{
			width = 16;
			height= 16;
			data = (unsigned char *) malloc(16*16);
//			if (!data) exit(1);
		}
		bitmap(int w,int h) ;
		bitmap(float xx,float yy,int w,int h);
		~bitmap() {}
		//accessors
		int getw() { return width ; }
		int geth() { return height; }
		float getx() { return x; }
		float gety() { return y; }
		unsigned char * getdata() { return data; }
		//utilities
		void draw() ;
		void erase(float x,float y);
		void setdata(unsigned char *tmpsprite) ;
		void setx(float xx);
		void sety(float yy);
		void printdata();
		void restore();
};

// bitmap functions:
bitmap::bitmap(int w,int h)
{
	x = 0;
	y = 0;
	width = w;
	height = h;
	data = (unsigned char *) malloc(width*height);
	/*error checker*/ if (!data) exit(1);
}
bitmap::bitmap(float xx,float yy,int w,int h)
{
	x = xx;
	y = yy;
	width = w;
	height = h;
	data = (unsigned char *) malloc(width*height);
	/*error checker*/ if (!data) exit(1);
}

void bitmap:: printdata()
{
	for (int yy=0;yy<height;yy++)
	{
		for (int xx=0;xx<width;xx++)
			cout << data[width*yy+xx];
	cout << endl;
	}
}

void bitmap:: setx(float xx) { x = xx; }
void bitmap:: sety(float yy) { y = yy; }

void bitmap:: setdata(unsigned char *tmpsprite)
{
	_fmemcpy(data,tmpsprite,width*height);
}
void bitmap:: draw()
{
	float offsetx = x;
	float offsety = y;

	for(int xx=0;xx<height;xx++)
	{
		for (int yy=0;yy<width;yy++)
		{
			if (data[width*yy + xx]=='-') /* do nothing */ ;
			else //draw the pixel to buffer
			{
				int color;
				if (data[width*yy+xx] == '@') color = WHITE;
				else color = data[width*yy+xx]-48;
				putpixel(offsetx+xx,offsety+yy,color);
			}
		}
	}
}
void bitmap:: erase(float x,float y)
{
	float offsetx = x;
	float offsety = y;

	for(int xx=0;xx<height;xx++)
		for (int yy=0;yy<width;yy++)
				putpixel(offsetx+xx,offsety+yy,BLACK);
}
void bitmap:: restore()
{
	free(data);
	delete (data);
}