/*
this program constantly generates 9 random points, and makes a bézier interpolation
over those points, and making a landscape following the interpolation :)
it also draws the lines connecting the 9 random points, so you can see how the interpolation
is done (notice it'll touch the first and last line in the beginning and ending point, that's
one of the properties of a bézier interpolation)

basically i put all the coordinates in an integer array , fill the screen with green, and
then draw vertical lines from the top until the interpolated value in black, so i get the green
landscape with as shape the interpolated bézier curve over the 9 randomly generated points :)

this is a first attempt, so it's a bit messy, also i'm new to fenix, so i've probably
done some things pretty inefficient :)
*/
program terra;
const
	width=320;//constant containing the width of the screen.
global
	terra[width];//this integer array will hold the interpolated values
	points[9];//this integer array will hold the randomly generated points.
begin
	SET_MODE(320,240,8);
	loop
	delete_draw(0);//i'll draw lines, so i need to remove them every time :)
	generateland();//i generate the 9 points and calculate the interpolation with this process :)
	fill(40);//i fill the screen with green (hey, that rhymes!)
	drawland(0);//and i draw the land (well the not land in fact, WHO CARES?)
	drawch();//and i draw the lines :)
	frame;//if i don't do this, nothing would show, you'd like that, don't you?
	end;
end;

/*
method drawing the landscape, we have got the coordinates in terra[] (filled by generateland())
and we draw it in the given color :)
*/
process drawland(color)
private
	i;
begin
	for(i=0; i<width; i++)//iterate over all the x values
		drawvline(i,terra[i],color);//and draw a line on the right heigt :D
	end;
	return;
end;

/*
method drawing a vertical lign at a given x coord, with given height, and given color
the height is until where we draw, starting from the top of the screen.
*/
process drawvline(place,hght,color)
private 
	i;
begin
	for(i =0;i<hght; i++)//iterate over all the points that have to be colored :)
		put_pixel(place,i,color);//and color them (duhhhhhh)
	end;
	return;
end;
/*
method filling the screen with given color (can probably we done easier, but i don't know how :p)
besides, speed isn't an issue :), generating the terrain should only happen once :)
*/
process fill(color)
private 
	i;
	j;
begin 
	for(i=0; i<320; i++)//iterate over all x values
		for(j=0; j<240;j++)//iterate over all y values
			put_pixel(i,j,color);//color the pixel with the given color
		end;
	end;
	return;
end;
/*
method putting the actual interpolated values in the int array.
*/
process generateland()
private
	i;
	j;
	float sum=0;//will contain the sum of all bernstein polynome values
	float pt;//float that will contain the height of the current point (so we don't get problems because it's an int)
	float prod;//yeat another float to prevent problems.... 
begin
	for (i=0;i<9;i++)
		points[i]=rand(0,240);//we generate the points :) (their y values, their x values are 0,40,...,320
	end;
  for (i=0;i<320;i++)//we'll have to do every x value!
  	sum=0;//setting the sum to 0 again
  	for(j=0; j<9; j++)//we interpolate over all points
  		pt = points[j];//we store the current point height in a float (damn fenix!)
  		prod = bern(8,j,i)*pt;//we multiply the value returned from the bernstein polynome by the height of the current point
			sum += prod/10000;//and we add it to the sum(after deviding it by 10000, cause it was multiplyed by that to be able to return it as an int)
		end;
		terra[i]=sum;//assign the found value to the i't int in the array
	end;
	return;
end;
/*
process returning the value of the bernstein polynome
with given variables :)
*/
process bern(n,i,tme)
private
	float t;
	float r;
	float tfn = width-1;
begin;
	t = tme/tfn;//calculating the t for the bernstein polynome, is a value between 0 and 1, 0 when x=0, 1 when x=359 :)
	r=(binnew(n,i)*pow(1-t,n-i)*pow(t,i));//calculating the actual value
	return r*10000;//returning 10.000 times the found value (is between 0 and 1), because whatever we return is an int...
end;

/*
process returning binomial coefficient of n and i
*/
process binnew(n,i)
begin
	return(fac(n)/(fac(i)*fac(n-i)));// simply calculating and returning it using the formula... 
end;
/*
process returning the faculty of the given int
*/
process fac(t);
private
	r=1;
begin
	while(t>0)//as long as our number is higher than 0 (well, even 1 would be good, cause x*1 = 1 :D)
		r*=t--;//multiply the value we'll return by it, and decrease it's value
	end;
	return r;//return the found value
end;
/*
method drawing the lines between the controlling points of which we make the bézier interpolation.
*/
process drawch();
private i;
begin
	for(i=0;i<8;i++)//we'll have to draw 8 lines (between 9 points)
		 DRAW_LINE(i*40,points[i],(i+1)*40,points[i+1]);//draw the line between the current and next point.
	end;
end;