/*
NMGRFX v.1.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            ...

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>

//=========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,
  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;
}
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 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 cleardevice()
{
	_fmemset(video_buffer,0,64000);
}
void setupbuf()
{
	double_buffer = (char far*) farmalloc(64000);
	if (!double_buffer) exit(1);
}
void disablebuf()
{
	farfree(double_buffer);
}
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;
  }
//==========================//
//     MISC. BUTTONS...     ||
//==========================//
  //'P' key pressed
  if (scanCode == 25) {
	KeyP = 1;
	CallBIOSHandler = 0;
  }
  //'P' key depressed
  if (scanCode == 183) {
	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 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:: restore()
{
	free(data);
	delete (data);
}













//=========================================================================//
//0000000000000000000000000000000000000000000000000000000000000000000000000//
//=========================================================================//















unsigned int far *screen = (unsigned int far *) 0xB8000000L;
unsigned char tchar;

void clrscreen();
void speedup();
void slowdown();

struct col
{
	int scount;
	int speed;

	col()
	{
		scount = 0;
		speed = 100;
	}
};

col columns[80];
char *str1 = "+-------------------+";
char *str2 = "| SYSTEM OVERLOADED |";
char *str3 = "+-------------------+";

int main()
{
	clrscreen();
	setupkbd();
	for (int m=0;m<80;m++) columns[m].speed = (random(250)+50)*30;

	while (!KeyEscape)
	{
		if (CursorUp) slowdown();
		if (CursorDown) speedup();

		// move stuff if speed update is met.
		int tmpcol;
		for (int n=0;n<80;n++)
		{
			tmpcol = n%80;
			if (columns[tmpcol].scount >= columns[tmpcol].speed)
			{
				for (int s=25;s>0;s--)
				{
					screen[s*80+tmpcol] = screen[(s-1)*80+tmpcol];
					screen[(s-1)*80] = 0x0000;
				}
				columns[tmpcol].scount = 0;
				// draw new character at top
				tchar = random(255)+1;

				if (screen[tmpcol+80] != 0x0000)
				{
					if (random(100) < 80)
					{
//						if (random(5)<4) screen[tmpcol] = 0x0200 | tchar;
//							else screen[tmpcol] = 0x0A00 | tchar;
						screen[tmpcol] = 0x0200 | tchar;
					}
					else screen[tmpcol] = 0x0000;
				}
				else
				{
					if (random(100) > 93)
					{
//						if (random(5)<4) screen[tmpcol] = 0x0200 | tchar;
//							else screen[tmpcol] = 0x0A00 | tchar;
						screen[tmpcol] = 0xA00 | tchar;
					}
				}
			}
		}
		for (int m=0;m<80;m++)
			columns[m].scount++;
	}

	for (int n=0;n<21;n++)
	{
		screen[11*80+31+n] = 0x0200 | str1[n];
		screen[12*80+31+n] = 0x0200 | str2[n];
		screen[13*80+31+n] = 0x0200 | str3[n];
	}

KeyEscape = 0;
while(!KeyEscape)
{
	tchar = random(255)+1;
	screen[random(2001)] = 0x0100 | tchar;
	tchar = random(255)+1;
	screen[random(2001)] = 0x0900 | tchar;
	delay(10);
}

restorekbd();
return (0);
}

void clrscreen()
{
	_fmemset(screen,0x0000,2000);
}
void speedup()
{
	for (int n=0;n<80;n++) columns[n].speed-=50;
	CursorDown = 0;
}
void slowdown()
{
	for (int n=0;n<80;n++) columns[n].speed+=50;
	CursorUp = 0;
}