/*          ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
            º                                                               º
            º                                                               º
	    º     planet = PROGRAM TO GENERATE PLANET FROM MOON             º
            º                                                               º
            ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ
*/

#include <stdio.h>
#include <math.h>
#include <dos.h>
#include <stdlib.h>
#include <time.h>
#include "tools.h"

#define convert(x,y)      {x = (x + 319);  y = (175 - ((93*y) >> 7));}

void ranFillOval(int x, int y, int b, int color, float aspect);
float gauss(void);
void generate(int x1, int y_one, int x2, int y2, int x3, int y3, int level,
	int color1,int color2);
void gen_quad (int x1, int y_one, int x2, int y2, int x3, int y3, int x4,
	int y4, int level, int color1, int color2);
void midpoint();
void midpoint2();
void node(int x1, int y_one, int x2, int y2, int x3, int y3, int x4,
	int y4, int x5, int y5, int x6, int y6, int level,
	int color1, int color2);
void plot_triangle(int x1, int y_one, int x2, int y2, int x3, int y3,
	int color1,int color2,int type);
void plot(int x, int y, int color);
void setMode(int mode);
void setEGApalette(int palette, int color);
void sort(int index, int x_coord[], int y_coord[]);

int combination = 0,LINEWIDTH=1, OPERATOR=0, ANGLE, XCENTER, YCENTER;
unsigned long int PATTERN=0xFFFFFFFF;
unsigned char PALETTE[16]={0,1,2,3,4,5,20,7,56,57,58,59,60,61,62,63};
int i,j;
int y_max = 280;
int level[26] = {3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4};
int x1[27] = {-100,-200,200,12,-280,20, -470,-350,-220,-200};
int y_one[27] = {-30,-110,-110,140,-210,-210,  -300,-280,-280,-280};
int x2[27] = {-210,-160,-160,0,0,80,  -250,-60,80,230};
int y2[27] = {210,0,0,0,0,50, -110,-140,-130,-120,0};
int x3[27] = {0,-90,0,120,80,200,  300,300,340,580};
int y3[27] = {-80,-110,0,-110,50,50,  -300,-300,-300,-300};
int xz,yz,xp,yp,type,row,col;
int xa[35] = {-82,-80,-90,-70,-50,-30,-25,25,40,42,20,35,40,50,60,60,-28,
	70,100,70,108,81,60,45,48,96,45,38,-8,0,-20,-28};
int xb[35] = {-70,-70,-80,-50,-30,25,-25,40,65,65,40,38,40,60,60,70,-28,
	100,127,129,92,70,56,48,54,100,38,46,12,14,14,8};
int xc[35] = {-70,-70,-80,-50,-50,20,30,40,40,58,40,37,50,50,70,75,20,
	100,129,120,83,70,45,60,60,54,106,65,12,40,14,-8};
int xd[35] = {-90,-80,-90,-70,-30,20,20,25,50,50,20,40,50,60,70,75,20,
	70,100,108,81,108,45,56,96,45,100,106,8,44,0,-30};
int ya[35] = {52,52,76,80,76,38,10,80,90,55,50,3,60,60,52,55,80,
	115,120,109,76,80,-130,-124,-90,-70,-60,-50,0,-10,10,90};
int yb[35] = {52,52,76,80,80,30,30,80,70,70,40,5,8,52,38,38,20,
	120,116,104,58,95,-124,-90,-65,-60,-50,-25,0,-10,10,80};
int yc[35] = {60,80,80,55,56,38,10,90,80,70,3,-5,60,20,38,40,20,
	106,104,76,60,110,-124,-100,-100,-65,-50,-25,-18,-30,-18,75};
int yd[35] = {60,80,77,55,38,30,30,90,60,60,3,-4,20,27,38,40,74,
	109,106,76,80,76,-124,-124,-70,-60,-60,-50,-18,-30,-18,85};
int color_value=2;
int level1 = 4;
float x,y;
long int x_center, y_center, radius;

main()
{

	setMode(16);
	cls(0);

	setEGApalette(0,8);
	setEGApalette(1,57);
	setEGApalette(3,20);
	setEGApalette(6,60);
	x_center = -100;
	y_center = 0;
	radius = 150;
	for (i=0; i<2000; i++)
	{
		row = rand()/93;
		col = rand()/51;
		plot(col,row,15);
	}
	fillOval(-100,0,152,1,1.0);
	type = 1;
	for (i=0; i<32; i++)
	{
		gen_quad(xa[i]+x_center,ya[i]+y_center,xb[i]+x_center,
			yb[i]+y_center,xc[i]+x_center,yc[i]+y_center,
			xd[i]+x_center,yd[i]+y_center,level1,2,3);
	}
	ranFillOval(-100,0,152,0,1.0);
	type = 0;
	y_max = -60;
	for (i=6; i<10; i++)
	{
		generate(x1[i],y_one[i],x2[i],y2[i],x3[i],y3[i],level[i],14,6);
	}
	fillOval(-180,-200,10,6,.35);
	fillOval(0,-160,10,6,.35);
	fillOval(40,-220,16,6,.3);
	fillOval(100,-170,6,6,.35);
	fillOval(200,-190,12,6,.35);
	fillOval(-220,-130,8,6,.35);
	fillOval(280,-150,8,6,.35);
	getch();
}


               /*ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
                 ³                                                       ³
		 ³ fillTriangle() = fills a triangle in specified color  ³
                 ³                                                       ³
                 ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ*/

void fillTriangle (int x1, int y_one, int x2, int y2, int x3, int y3,
	int color)
{

	#define sign(x) ((x) > 0 ? 1:  ((x) == 0 ? 0:  (-1)))

	int dx, dy, dxabs, dyabs, i, index=0, j, k, px, py, sdx, sdy, x, y,
		xpoint[4], ypoint[4], toggle,
        	old_sdy,sy0;
	long int check,xa,ya;
	int *x_coord, *y_coord;

	x_coord = (int *) malloc(4000 * sizeof(int));
	y_coord = (int *) malloc(4000 * sizeof(int));
	xpoint[0] = x1 + 319;
	ypoint[0] = 175 - ((y_one*93L) >> 7);
	xpoint[1] = x2 + 319;
	ypoint[1] = 175 - ((y2*93L) >> 7);
	xpoint[2] = x3 + 319;
	ypoint[2] = 175 - ((y3*93L) >> 7);
	xpoint[3] = xpoint[0];
	ypoint[3] = ypoint[0];
	i = 3;
	px = xpoint[0];
	py = ypoint[0];
	if (ypoint[1] == ypoint[0])
	{
		x_coord[index] = px;
		y_coord[index++] = py;
	}
	for (j=0; j<i; j++)
	{
		dx = xpoint[j+1] - xpoint[j];
		dy = ypoint[j+1] - ypoint[j];
		sdx = sign(dx);
		sdy = sign(dy);
		if (j==0)
		{
			old_sdy = sdy;
			sy0 = sdy;
		}
		dxabs = abs(dx);
		dyabs = abs(dy);
		x = 0;
		y = 0;
		if (dxabs >= dyabs)
		{
			for (k=0; k<dxabs; k++)
			{
				y += dyabs;
				if (y>=dxabs)
				{
					y -= dxabs;
					py += sdy;
					if (old_sdy != sdy)
					{
						old_sdy = sdy;
						index--;
					}
					x_coord[index] = px+sdx;
					y_coord[index++] = py;
				}
				px += sdx;
			}
		}
		else
		{
			for (k=0; k<dyabs; k++)
			{
				x += dxabs;
				if (x>=dyabs)
				{
					x -= dyabs;
					px += sdx;
        			}
				py += sdy;
				if (old_sdy != sdy)
				{
					old_sdy = sdy;
					if (sdy != 0)
						index--;
				}

				x_coord[index] = px;
				y_coord[index++] = py;
			}
		}
        }
	index--;
	if (sy0 + sdy== 0)
		index--;
	sort(index,x_coord,y_coord);
	toggle = 0;
			if (x_coord[0] < 0)
				x_coord[0] = 0;
			if (x_coord[0] > 639)
				x_coord[0] = 639;
	for (i=0; i<index; i++)
	{
		if (x_coord[i+1] < 0)
			x_coord[i+1] = 0;
		if (x_coord[i+1] > 639)
			x_coord[i+1] = 639;
		if ((y_coord[i] == y_coord[i+1]) && (toggle == 0) &&
			(y_coord[i] >= 0) && (y_coord[i] < 350))
		{
			for (j=x_coord[i]; j<=x_coord[i+1]; j++)
			{
				xa = j - 319;
				ya = (175 - y_coord[i])*128L/93;
				if (((xa-x_center)*(xa-x_center) + (ya
					- y_center)*(ya - y_center))
					< (radius*radius) || (type == 0))
					plot(j,y_coord[i],color);
			}
			toggle = 1;
		}
		else
			toggle = 0;
	}

	free(x_coord);
	free(y_coord);
}


	       /*ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
                 ³                                                       ³
                 ³ sort() = sorts coordinate pairs for drawing and       ³
                 ³          filling polygons.                            ³
                 ³                                                       ³
                 ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ*/



void sort(int index, int x_coord[], int y_coord[])
{
	int d=4,i,j,k,temp;

	while (d<=index)
		d*=2;
	d-=1;
	while (d>1)
	{
		d/=2;
        	for (j=0; j<=(index-d); j++)
		{
			for (i=j; i>=0; i-=d)
			{
				if ((y_coord[i+d] < y_coord[i]) ||
					((y_coord[i+d] == y_coord[i]) &&
					(x_coord[i+d] <= x_coord[i])))
				{
					temp = y_coord[i];
					y_coord[i] = y_coord[i+d];
					y_coord[i+d] = temp;
					temp = x_coord[i];
					x_coord[i] = x_coord[i+d];
					x_coord[i+d] = temp;
				}
			}
		}
	}
}

void node(int x1, int y_one, int x2, int y2, int x3, int y3, int x4,int y4,
	int x5, int y5, int x6, int y6, int level,int color1, int color2)
{
	if (level == 0)
		return(0);
	generate (x1,y_one,x4,y4,x6,y6,level-1,color1,color2);
	generate (x6,y6,x5,y5,x3,y3,level-1,color1,color2);
	generate (x4,y4,x2,y2,x5,y5,level-1,color1,color2);
	generate (x4,y4,x5,y5,x6,y6,level-1,color1,color2);
}

void generate(int x1, int y_one, int x2, int y2, int x3, int y3, int level,
	int color1, int color2)
{
	int x4,x5,x6,y4,y5,y6,ax,bx,cx,ay,by,cy;

	x = x2 - x1;
	y = y2 - y_one;
	midpoint(x,y);
	x4 = x1 + xz -xp;
	y4 = y_one + yz - yp;
	ax = -xp;
	ay = -yp;
	x = x3-x1;
	y = y3-y_one;
	midpoint(x,y);
	x6 = x1 + xz;
	y6 = y_one + yz;
	cx = xp;
	cy = yp;
	x = x3-x2;
	y = y3-y2;
	midpoint(x,y);
	x5 = x2 + xz;
	y5 = y2 + yz;
	bx = -xp;
	by = -yp;

	if (level == 0)
	{
		plot_triangle(x1,y_one,x4,y4,x6,y6,color1,color2,0);
		plot_triangle(x6,y6,x5,y5,x3,y3,color1,color2,0);
		plot_triangle(x4,y4,x5,y5,x6,y6,color1,color2,0);
		plot_triangle(x4,y4,x2,y2,x5,y5,color1,color2,0);
	}
	else
	{
		plot_triangle(x1,y_one,x4+ax,y4+ay,x6+cx,y6+cy,color1,color2,0);
		plot_triangle(x6+cx,y6+cy,x5+bx,y5+by,x3,y3,color1,color2,0);
		plot_triangle(x4+ax,y4+ay,x5+bx,y5+by,x6+cx,y6+cy,color1,
			color2,0);
		plot_triangle(x4+ax,y4+ay,x2,y2,x5+bx,y5+by,color1,color2,0);
		node(x1,y_one,x2,y2,x3,y3,x4,y4,x5,y5,x6,y6,level,color1,
			color2);
	}
}


void plot_triangle(int x1, int y_one, int x2, int y2, int x3, int y3,int color1,
	int color2,int type)
{
	int ytt,color,temp;
	float zt;

	if (y_one > y2)
		ytt = y_one;
	else
		ytt = y2;
	if (ytt < y3)
		ytt = y3;
	zt = (y_max+240)*(1-(float)(ytt+240)/(y_max+240)*
		(float)(ytt+240)/(y_max+240));
	if (type == 0)
	{
		temp = 32767/(y_max+241);
		temp = rand()/temp;
		if (temp<= zt)
			color = color1;
		else
			color = color2;
		if (ytt + 240 < (.35 * (y_max + 240)))
			color = color1;
		if (ytt+240 > (.92 * (y_max+240)))
			color = color2;
	}
	else
	{
		if (rand() <= 24000)
			color = color1;
		else
			color = color2;
	}
	fillTriangle(x1,y_one,x2,y2,x3,y3,color);
}

void midpoint()
{
	float r,w;
	int sign1,sign2;

	if (rand() > 16383)
		sign1 = 1;
	else
		sign1 = -1;
	if (rand() > 16383)
		sign2 = 1;
	else
		sign2 = -1;
	r = 0.5 + sign1*(float)rand()/196602.0;
	w =  ((float)(rand()/819175.0) + 0.03)*sign2;
	r = 0.5 + gauss()/6;
	w =  gauss()/25 + .03;
	xz = r*x - w*y;
	yz = r*y + w*x;
	xp = 0.05*y;
	yp = -0.05*x;
}
void midpoint2()
{
	float r,w;
	int sign1,sign2;

	if (rand() > 16383)
		sign1 = 1;
	else
		sign1 = -1;
	if (rand() > 16383)
		sign2 = 1;
	else
		sign2 = -1;
	r = 0.5 + sign1*(float)rand()/196602.0;
	w =  ((float)(rand()/819175.0) + 0.03)*sign2;
	r = 0.5 + gauss()/6;
	w =  gauss()/25 + .03;
	xz = r*x - w*y;
	yz = r*y + w*x;
	xp = 0.1*y;
	yp = -0.1*x;
}

float gauss(void)
{
	int k;
	float value,exponent,gauss;

	k = rand() - 16383;
	value = k/5461.0;
	exponent = -(value*value)/2.;
	gauss = .15915494*exp(exponent);
	k = rand();

	if (k > 16383)
		gauss *= -1;
	return(gauss);
}

               /*ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
                 ³                                                       ³
		 ³  ranFillOval() = draws an oval centered at (x,y) with ³
                 ³               radius in y direction of 'b' with       ³
                 ³               aspect ratio 'aspect' and fills it      ³
		 ³               randomly with color 'color'.            ³
                 ³                                                       ³
                 ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ*/



void ranFillOval(int x, int y, int b, int color, float aspect)
{
	union REGS reg;

	#define seq_out(index,val)  {outp(0x3C4,index);\
					 outp(0x3C5,val);}
	#define graph_out(index,val)  {outp(0x3CE,index);\
					 outp(0x3CF,val);}

	unsigned int offset;
	char far * mem_address;
	float a,aspect_square;
	int col,row,dummy,mask,end_x,end_y,kx;
	long a_square,b_square,b_test;

	a = b/aspect;
	a_square = a*a;
	b = (93*b) >> 7;
	b_square = b*b;
	convert (x,y);
	end_x = x+a;
	end_y = y+b;
	for (col=x-a; col<=end_x; col++)
	{
		b_test = b_square - (b_square*(col-x)*(col-x))/a_square;
		mask = 0x80 >> ((col) % 8);
		graph_out(8,mask);
		seq_out(2,0x0F);
		for (row=y-b; row<=end_y; row++)
		{
			kx = rand()/(32767/(1.3*radius));
			if (((row-y)*(row-y) <= b_test) && (kx < (col-x+20)))
			{
				offset = (long)row*80L + ((long)(col)/8L);
				mem_address = (char far *) 0xA0000000L +
					offset;
				dummy = *mem_address;
				*mem_address = 0;
				seq_out(2,color);
				*mem_address = 0xFF;
				seq_out(2,0x0F);
			}
		}
	}
	graph_out(3,0);
	graph_out(8,0xFF);
}


	       /*ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
                 ³                                                       ³
                 ³  fillOval() = draws an oval centered at (x,y) with    ³
                 ³               radius in y direction of 'b' with       ³
                 ³               aspect ratio 'aspect' and fills it      ³
                 ³               with color 'color'.                     ³
                 ³                                                       ³
                 ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ*/



/*void fillOval(int x, int y, int b, int color, float aspect)
{
	union REGS reg;

	#define seq_out(index,val)  {outp(0x3C4,index);\
					 outp(0x3C5,val);}
	#define graph_out(index,val)  {outp(0x3CE,index);\
					 outp(0x3CF,val);}

	unsigned int offset;
	char far * mem_address;
	float a,aspect_square;
	int col,row,dummy,mask,end_x,end_y;
	long a_square,b_square,b_test;

	a = b/aspect;
	a_square = a*a;
	b = (93*b) >> 7;
	b_square = b*b;
	convert (x,y);
	end_x = x+a;
	end_y = y+b;
	for (col=x-a; col<=end_x; col++)
	{
		b_test = b_square - (b_square*(col-x)*(col-x))/a_square;
		mask = 0x80 >> ((col) % 8);
		graph_out(8,mask);
		seq_out(2,0x0F);
		for (row=y-b; row<=end_y; row++)
			if ((row-y)*(row-y) <= b_test)
			{
				offset = (long)row*80L + ((long)(col)/8L);
				mem_address = (char far *) 0xA0000000L +
					offset;
				dummy = *mem_address;
				*mem_address = 0;
				seq_out(2,color);
				*mem_address = 0xFF;
				seq_out(2,0x0F);
			}
	}
	graph_out(3,0);
	graph_out(8,0xFF);
}
*/
void gen_quad (int x1, int y_one, int x2, int y2, int x3, int y3, int x4,
	int y4, int level, int color1, int color2)
{
	int x5,x6,x7,x8,x9,y5,y6,y7,y8,y9,ax,bx,cx,dx,ex,ay,by,cy,dy,ey;

	x = x2 - x1;
	y = y2 - y_one;
	midpoint2(x,y);
	x5 = x1 + xz -xp;
	y5 = y_one + yz - yp;
	ax = -xp;
	ay = -yp;
	x = x4-x1;
	y = y4-y_one;
	midpoint2(x,y);
	x7 = x1 + xz;
	y7 = y_one + yz;
	cx = xp;
	cy = yp;
	x = x4-x2;
	y = y4-y2;
	midpoint2(x,y);
	x6 = x2 + xz;
	y6 = y2 + yz;
	bx = -xp;
	by = -yp;
	x = x3 - x2;
	y = y3 - y2;
	midpoint2(x,y);
	x8 = x2 + xz -xp;
	y8 = y2 + yz - yp;
	dx = -xp;
	dy = -yp;
	x = x4-x3;
	y = y4-y3;
	midpoint2(x,y);
	x9 = x3 + xz;
	y9 = y3 + yz;
	ex = xp;
	ey = yp;

	if (level == 0)
	{
		plot_triangle(x1,y_one,x5,y5,x7,y7,color1,color2,1);
		plot_triangle(x7,y7,x6,y6,x4,y4,color1,color2,1);
		plot_triangle(x5,y5,x6,y6,x7,y7,color1,color2,1);
		plot_triangle(x5,y5,x2,y2,x6,y6,color1,color2,1);
		plot_triangle(x2,y2,x8,y8,x9,y9,color1,color2,1);
		plot_triangle(x9,y9,x6,y6,x4,y4,color1,color2,1);
		plot_triangle(x6,y6,x8,y8,x9,y9,color1,color2,1);
		plot_triangle(x6,y6,x2,y2,x8,y8,color1,color2,1);
	}
	else
	{
		plot_triangle(x1,y_one,x5+ax,y5+ay,x7+cx,y7+cy,color1,color2,1);
		plot_triangle(x7+cx,y7+cy,x6+bx,y6+by,x4,y4,color1,color2,1);
		plot_triangle(x5+ax,y5+ay,x6+bx,y6+by,x7+cx,y7+cy,color1,
			color2,1);
		plot_triangle(x5+ax,y5+ay,x2,y2,x6+bx,y6+by,color1,color2,1);
		plot_triangle(x2,y2,x8+dx,y8+dy,x9+ex,y9+ey,color1,color2,1);
		plot_triangle(x9+ex,y9+ey,x6+bx,y6+by,x4,y4,color1,color2,1);
		plot_triangle(x6+bx,y6+by,x8+dx,y8+dy,x9+ex,y9+ey,color1,
			color2,1);
		plot_triangle(x6+bx,y6+by,x2,y2,x8+dx,y8+dy,color1,color2,1);
		node(x1,y_one,x2,y2,x4,y4,x5,y5,x6,y6,x7,y7,level,color1,
			color2);
		node(x2,y2,x3,y3,x4,y4,x8,y8,x9,y9,x6,y6,level,color1,
			color2);
	}
}