/*****************************************************************************
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 *
 * @(#) Colloidal for Ndless 2.0 (Colloidal Engine file)
 * Core engine file
 *
 * Copyright (C) August 15, 2011 Joe Kim (SolusIpse)
 * Contact: solusipse0x5@gmail.com
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.
 *****************************************************************************/
 
#include <os.h>
#include "utils.h"
#include "Colloidal.h"

#define C_BLACK 0x00
#define C_DGRAY 0x06
#define C_MGRAY 0x0A
#define C_LGRAY 0x0D
#define C_WHITE	0x0F

#define MAX_BLOCKS 100			//self explanatory
#define BLOCK_SIZE 16			//in pixels
#define FP_FACTOR 8				//number of binary decimal places reserved for fractions
#define SCORE_SCALE 2			//100hz timer, divide by 2^SCORE_SCALE to get close to 1 point earned per second
#define NEW_BLOCK_FREQ_MASK 0x000003FF
								//Take a base 2 modulus so rougly every 100 points add another block
#define DEG_SPEED 1				//levels of speed for each direction
#define COLOR_CHANGE_DELAY_FACTOR 3		//2^FACTOR frames before tab and control really do anything
#define PLAYER_SPEED 0			//bigger is slower
/*
returns score
returns 0 if errors
*/
unsigned long colloidal(void)
{
	/*
	*initilize data
	*Fixed point math - 24.8  seems appropriate
	*Nspire screen is so big!!  Even travelling one pixel
	*at 100 fps means it takes 3.2 seconds to cross the screen!
	*It probably takes longer because of the wy idle() appears to work codewise.
	*Pity I can't set idle() to go at higher frame rates.
	*Don't ask me why I didn't malloc! 
	*I was just lazy and I only had a day to write this contest entry.
	*/
	void *scrbuf = malloc(SCREEN_BYTES_SIZE);
	unsigned long int *xlist, *ylist, *exlist, *eylist;
	signed long int *vxlist, *vylist;
	unsigned int *color;
	xlist = malloc(sizeof(unsigned long)*MAX_BLOCKS);
	ylist = malloc(sizeof(unsigned long)*MAX_BLOCKS);
	vxlist = malloc(sizeof(signed long)*MAX_BLOCKS);
	vylist = malloc(sizeof(signed long)*MAX_BLOCKS);	
	color = malloc(sizeof(unsigned int)*MAX_BLOCKS);
	exlist = malloc(sizeof(sizeof(unsigned int)*8));
	eylist = malloc(sizeof(sizeof(unsigned int)*8));
	//return if can't malloc enough memory
	if(xlist==NULL || ylist==NULL || vxlist==NULL || vylist==NULL || color==NULL || scrbuf==NULL || exlist == NULL || eylist ==NULL) return 0;
	
	unsigned int num_blocks = 1;	
	xlist[0]=0;
	ylist[0]=0;
	vxlist[0]=1<<(FP_FACTOR-1);
	vylist[0]=1<<(FP_FACTOR);
	color[0]=0;
	
	unsigned long score = 0;
	unsigned long px = 151<<PLAYER_SPEED, py=112<<PLAYER_SPEED;		//player position
	unsigned int pcolor = 0;
	unsigned int pcolorindex = 0;
	unsigned int nextcolor = 1;
	_Bool gameover=FALSE;
	_Bool addblock=FALSE;
	//_Bool explode=FALSE;
	_Bool wait=FALSE;
	unsigned long count=0;
	unsigned int pdir=0;
	
	unsigned int i,j;
	unsigned long int xtemp, ytemp;
	signed long int vtemp;
	
	//loop
	while(!isKeyPressed(KEY_NSPIRE_ESC))
	{
	//DRAW
		//clear screen buffer
		memset(scrbuf, 0xFF, SCREEN_BYTES_SIZE);
		//Draw blocks
		for(i=num_blocks; i--;)
		{
			brick_draw((xlist[i]>>FP_FACTOR), (ylist[i]>>FP_FACTOR), color[i], scrbuf);
		}

		/*
		*GAMEOVER DETECTION
		*The reason why it's here is because it uses the drawn updated screen
		* and does a pixel test to see if something is already occupying that area.
		*/
		xtemp=px>>PLAYER_SPEED;		//reduce back to whole screen coordinates
		ytemp=py>>PLAYER_SPEED;
		//the below is just lazy coding practice combined with not having a big enough screen.  Damn 1024 pixel width!
		if(!gameover)
		{
		if((j=getPixel2(xtemp, ytemp, scrbuf))!=C_WHITE || (j=getPixel2(xtemp+(BLOCK_SIZE-1), ytemp, scrbuf))!=C_WHITE || (j=getPixel2(xtemp, ytemp+(BLOCK_SIZE-1), scrbuf))!=C_WHITE || (j=getPixel2(xtemp+(BLOCK_SIZE-1), ytemp+(BLOCK_SIZE-1), scrbuf))!=C_WHITE)
		{
			if (j!=pcolor) 
			{
				gameover=TRUE;		//if it's not the same color, game over
				exlist[0]=xtemp;
				eylist[0]=ytemp;
				exlist[1]=xtemp+6;
				eylist[1]=ytemp;
				exlist[2]=xtemp+12;
				eylist[2]=ytemp;
				exlist[3]=xtemp;
				eylist[3]=ytemp+6;	
				exlist[4]=xtemp+12;
				eylist[4]=ytemp+6;
				exlist[5]=xtemp;
				eylist[5]=ytemp+12;
				exlist[6]=xtemp+6;
				eylist[6]=ytemp+12;
				exlist[7]=xtemp+12;
				eylist[7]=ytemp+12;				
			}
			else {score=score>>1;}				//half score as punishment
		}
		}
		
		//Draw player
		if(gameover==FALSE)
		{
			player_draw(px>>PLAYER_SPEED,py>>PLAYER_SPEED, pcolor, scrbuf);
		}
		else
		{
			for(i=8;i--;)
			{
				death_draw(exlist[i],eylist[i], pcolor, scrbuf);
			}
		}
		/*
		*Attempt to add another block
		*The reason why it's here is because it uses the drawn updated screen
		* and does a pixel test to see if we can add to the corners
		*/
		if(addblock==TRUE)
		{
			xtemp=(rand() & 0xFF);
			ytemp=(rand() & 0x7F);
			if((px+((BLOCK_SIZE*3)<<PLAYER_SPEED)-(xtemp<<PLAYER_SPEED))>((BLOCK_SIZE*6)<<PLAYER_SPEED) || (py+((BLOCK_SIZE*3)<<PLAYER_SPEED)-(ytemp<<PLAYER_SPEED))>((BLOCK_SIZE*6)<<PLAYER_SPEED))
			{
				if(getPixel2(xtemp, ytemp, scrbuf)==C_WHITE && getPixel2(xtemp+(BLOCK_SIZE-1), ytemp, scrbuf)==C_WHITE && getPixel2(xtemp, ytemp+(BLOCK_SIZE-1), scrbuf)==C_WHITE && getPixel2(xtemp+(BLOCK_SIZE-1), ytemp+(BLOCK_SIZE-1), scrbuf)==C_WHITE)
				{
					xlist[num_blocks]=xtemp<<FP_FACTOR;
					ylist[num_blocks]=ytemp<<FP_FACTOR;
					switch (nextcolor)
					{
						case 0: color[num_blocks]=C_BLACK; break;
						case 1: color[num_blocks]=C_DGRAY; break;
						case 2: color[num_blocks]=C_MGRAY; break;
						case 3: color[num_blocks]=C_LGRAY; break;
					}
					nextcolor++;
					nextcolor= nextcolor & 3;
					vxlist[num_blocks] = ((rand() & ((1<<DEG_SPEED)-1))+1) << (FP_FACTOR-DEG_SPEED);
					vylist[num_blocks] = ((rand() & ((1<<DEG_SPEED)-1))+1) << (FP_FACTOR-DEG_SPEED);
					switch (rand() & 3)
					{
						case 0: vxlist[num_blocks]=-vxlist[num_blocks];
						case 1: vylist[num_blocks]=-vylist[num_blocks]; break;
						case 2: vxlist[num_blocks]=-vxlist[num_blocks];
						break;
					}
					num_blocks++;
					addblock=FALSE;
				}
			}
		}

		//COPY ALL TO SCREEN
		memcpy(SCREEN_BASE_ADDRESS, scrbuf, SCREEN_BYTES_SIZE);
	//TAKE INPUT
	if(!gameover)
	{
		//Color changing keys
		if(isKeyPressed(KEY_NSPIRE_TAB))
		{
			pcolorindex++;
			switch(pcolorindex>>COLOR_CHANGE_DELAY_FACTOR)
			{
				case 0: pcolor = C_BLACK; break;
				case 1: pcolor = C_DGRAY; break;
				case 2: pcolor = C_MGRAY; break;
				case 3: pcolor = C_LGRAY; break;
				default: pcolorindex=0; pcolor = C_BLACK;
			}
		}
		else if (isKeyPressed(KEY_NSPIRE_CTRL))
		{
			pcolorindex--;
			switch(pcolorindex>>COLOR_CHANGE_DELAY_FACTOR)
			{
				case 0: pcolor = C_BLACK; break;
				case 1: pcolor = C_DGRAY; break;
				case 2: pcolor = C_MGRAY; break;
				case 3: pcolor = C_LGRAY; break;
				default: pcolorindex=0; pcolor = C_BLACK;
			}			
		}
		if(isKeyPressed(KEY_NSPIRE_0))
		{pcolorindex=3<<COLOR_CHANGE_DELAY_FACTOR; pcolor=C_LGRAY;}
		else if (isKeyPressed(KEY_NSPIRE_1))
		{pcolorindex=2<<COLOR_CHANGE_DELAY_FACTOR; pcolor=C_MGRAY;}
		else if (isKeyPressed(KEY_NSPIRE_4))
		{pcolorindex=1<<COLOR_CHANGE_DELAY_FACTOR; pcolor=C_DGRAY;}
		else if (isKeyPressed(KEY_NSPIRE_7))
		{pcolorindex=0<<COLOR_CHANGE_DELAY_FACTOR; pcolor=C_BLACK;}
		//arrow movement keys
		if(isKeyPressed(KEY_NSPIRE_UP)) pdir = 8;
		else if (isKeyPressed(KEY_NSPIRE_DOWN)) pdir = 4;
		else if (isKeyPressed(KEY_NSPIRE_LEFT)) pdir = 6;
		else if (isKeyPressed(KEY_NSPIRE_RIGHT)) pdir = 2;
		else if (isKeyPressed(KEY_NSPIRE_UPRIGHT)) pdir = 7;
		else if (isKeyPressed(KEY_NSPIRE_LEFTUP)) pdir = 5;
		else if (isKeyPressed(KEY_NSPIRE_RIGHTDOWN)) pdir = 1;
		else if (isKeyPressed(KEY_NSPIRE_DOWNLEFT)) pdir = 3;
		else pdir = 0;
		switch(pdir)
		{
			case 0: break;
			case 1:	py++;	//down
			case 2: px++; break;	//right break
			case 3: px--;	//left
			case 4: py++; break;	//down break
			case 5: py--;	//up
			case 6: px--; break;	//left break
			case 7: px++;	//right
			default: py--;	//up break
		}
		//check if it's in screen bounds
		if(px>((SCREEN_WIDTH-BLOCK_SIZE)<<PLAYER_SPEED))
		{
			pdir = 0;		//this variable is in case I come up with a good physics based death animation
			if(px>(SCREEN_WIDTH<<PLAYER_SPEED)) px=0;
			else px=((SCREEN_WIDTH-BLOCK_SIZE)<<PLAYER_SPEED);
		}
		if(py>((SCREEN_HEIGHT-BLOCK_SIZE)<<PLAYER_SPEED))
		{
			pdir = 0;
			if(py>(SCREEN_HEIGHT<<PLAYER_SPEED)) py=0;
			else py=((SCREEN_HEIGHT-BLOCK_SIZE)<<PLAYER_SPEED);
		}	
	}
	else if(wait !=TRUE)
	{
				exlist[0]--;
				eylist[0]--;
				//exlist[1]=xtemp+6;
				eylist[1]--;
				exlist[2]++;
				eylist[2]--;
				exlist[3]--;
				//eylist[3]=ytemp+6;	
				exlist[4]++;
				//eylist[4]=ytemp+6;
				exlist[5]--;
				eylist[5]++;
				//exlist[6]=xtemp+6;
				eylist[6]++;
				exlist[7]++;
				eylist[7]++;
		j=0;;
		for(i=8;i--;)
		{
			if(exlist[i]>SCREEN_WIDTH || eylist[i]>SCREEN_HEIGHT)
			{
			j++;
			}
		}
		if(j==8) wait=TRUE;
	}
		
	//UPDATE
		for(i=num_blocks; i--;)
		{
			//local loop temps
			xtemp = (xlist[i]+vxlist[i]);
			ytemp = (ylist[i]+vylist[i]);
			
			/*
			*Collision with box
			*The fixed point offers some buffering room
			*/
			if (xtemp > ((SCREEN_WIDTH-BLOCK_SIZE)<<FP_FACTOR))	//if off the screen
			{
				//Exchange momentum
				vxlist[i]=-vxlist[i];
				//if less than zero, we need to actually reset to zero.
				//unlike being greater than the screen width, shifting won't properly round down
				if((xtemp) > ((SCREEN_WIDTH)<<FP_FACTOR))
				{xtemp=0;}
				else
				{xtemp=((SCREEN_WIDTH-BLOCK_SIZE)<<FP_FACTOR);}
			}
			if (ytemp > ((SCREEN_HEIGHT-BLOCK_SIZE)<<FP_FACTOR))	//if off the screen
			{
				//Exchange momentum
				vylist[i]=-vylist[i];
				//if less than zero, we need to actually reset to zero.
				//unlike being greater than the screen width, shifting won't properly round down
				if(ytemp > ((SCREEN_HEIGHT)<<FP_FACTOR)) 
				{ytemp=0;}
				else
				{ytemp=((SCREEN_HEIGHT-BLOCK_SIZE)<<FP_FACTOR);}
			}
			//*/
			
			//Collision with others, only need to do with guys that haven't been updated	
			for(j=num_blocks; j--;)
			{
				if(color[i]==color[j]) continue;
				if(i!=j)
				{
					if((xtemp-xlist[j]+(BLOCK_SIZE<<FP_FACTOR))<=((BLOCK_SIZE*2)<<FP_FACTOR) && (ytemp-ylist[j]+(BLOCK_SIZE<<FP_FACTOR))<=((BLOCK_SIZE*2)<<FP_FACTOR))
					{
						if((ytemp-ylist[j]+(BLOCK_SIZE<<FP_FACTOR))>(xtemp-xlist[j]+(BLOCK_SIZE<<FP_FACTOR)))
						{
							//if collision, exchange momentum
							vtemp=vylist[i];
							vylist[i]=vylist[j];
							vylist[j]=vtemp;
							//don't proceed
							ytemp=ylist[i];						
						}
						else
						{
							//if collision, exchange momentum
							vtemp=vxlist[i];
							vxlist[i]=vxlist[j];
							vxlist[j]=vtemp;
							//don't proceed
							xtemp=xlist[i];
						}
					}					
				}
			}
			
			//update postion
			xlist[i]=xtemp;
			ylist[i]=ytemp;				
		}		
		
		//check if it's time to add another block, don't add if you've maxed out
		if((score & NEW_BLOCK_FREQ_MASK)==0 && num_blocks!=MAX_BLOCKS) addblock=TRUE;
		
		//increase score as long as no block needs to be added
		if(!gameover) score++;
		if(wait==TRUE)
		{
			count++;
			if(count>(30<<3)) break;
		}
		idle();
	}

	clearScreen();
	
	//free malloc'd memory
	free(xlist);
	free(ylist);
	free(vxlist);
	free(vylist);
	free(color);
	free(scrbuf);
	//divide by 64, this makes it so that you earn a little more than one point per second
	return score>>SCORE_SCALE;
}

/*Uses 1st timer which is 488hz, faster than 2nd timer (100hz) default for idle()*/
void idle2(void) 
{
	int irq_mask = *(volatile int *)0xDC000008;
	*(volatile int *)0xDC00000C = ~(1 << 18); // Disable all IRQs except timer
  __asm volatile("mcr p15, 0, %0, c7, c0, 4" : : "r"(0) ); // Wait for an interrupt to occur
	*(volatile int *)0x900A0018 = 1; // Acknowledge timer interrupt at source
	*(volatile int *)0xDC000028; // Make interrupt controller stop asserting nIRQ if there aren't any active IRQs left
	*(volatile int *)0xDC000008 = irq_mask; // Re-enable disabled IRQs
}

/* itoa:  convert n to characters in s */
 void itoa2(long n, char s[])
 {
     long sign;
	 int i;
 
     if ((sign = n) < 0)  /* record sign */
         n = -n;          /* make n positive */
     i = 0;
     do {       /* generate digits in reverse order */
         s[i++] = n % 10 + '0';   /* get next digit */
     } while ((n /= 10) > 0);     /* delete it */
     if (sign < 0)
         s[i++] = '-';
     s[i] = '\0';
     reverse(s);
 }
 
 /* reverse:  reverse string s in place */
 void reverse(char s[])
 {
     int i, j;
     char c;
 
     for (i = 0, j = strlen(s)-1; i<j; i++, j--) {
         c = s[i];
         s[i] = s[j];
         s[j] = c;
     }
 }

inline int getPixel2(int x, int y, unsigned char* screenbuf) 
{
  unsigned char* p = (unsigned char*)(screenbuf + ((x >> 1) + (y << 7) + (y << 5)));
  return ((x & 1) ? (*p & 0x0F) : (*p >> 4));
}
 
inline void brick_draw(int x, int y, unsigned char color, unsigned char* screenbuf)
{
	//counter, unsigned for speed
	unsigned int i;
	//Upper bits for a color, since 2 pixels per byte, hopefully improves speed
	unsigned char uppercolor = color<<4;
	unsigned char fullbytecolor = color | uppercolor;
	//get start address for sprite
	unsigned char* s = (unsigned char*)(screenbuf + ((x >> 1) + (y << 7) + (y << 5)));
	
	//in screen bounds?  Testing only
	//if ((x < 0) || (x > (SCREEN_WIDTH - BLOCK_SIZE)) || (y < 0) || (y > (SCREEN_HEIGHT - BLOCK_SIZE))) return;

	if(x &1)
	{
		for(i=BLOCK_SIZE; i--;)
		{
			//Unrolled, hopefully faster
			*s = (*s & 0xF0) | color;
			*(s + 1) = fullbytecolor;
			*(s + 2) = fullbytecolor;
			*(s + 3) = fullbytecolor;
			*(s + 4) = fullbytecolor;
			*(s + 5) = fullbytecolor;
			*(s + 6) = fullbytecolor;
			*(s + 7) = fullbytecolor;
			*(s + 8) = (*(s + 8) & 0x0F) | uppercolor;
			s += (SCREEN_WIDTH >> 1);
		}
	}
	else
	{
		for(i=BLOCK_SIZE; i--;)
		{
			*s = fullbytecolor;
			*(s + 1) = fullbytecolor;
			*(s + 2) = fullbytecolor;
			*(s + 3) = fullbytecolor;
			*(s + 4) = fullbytecolor;
			*(s + 5) = fullbytecolor;
			*(s + 6) = fullbytecolor;
			*(s + 7) = fullbytecolor;
			s += (SCREEN_WIDTH >> 1);
		}	
	}
	return;
}

inline void player_draw(int x, int y, unsigned char color, unsigned char* screenbuf)
{
	//counter, unsigned for speed
	unsigned int i;
	//Upper bits for a color, since 2 pixels per byte, hopefully improves speed
	unsigned char uppercolor = color<<4;
	unsigned char fullbytecolor = color | uppercolor;
	//get start address for sprite
	unsigned char* s = (unsigned char*)(screenbuf + ((x >> 1) + (y << 7) + (y << 5)));
	
	//in screen bounds?  Testing only
	//if ((x < 0) || (x > (SCREEN_WIDTH - BLOCK_SIZE)) || (y < 0) || (y > (SCREEN_HEIGHT - BLOCK_SIZE))) return;

	if(x &1)
	{
		for(i=BLOCK_SIZE; i--;)
		{
			//Unrolled, hopefully faster
			*s = (*s & 0xF0) | color;
			*(s + 1) = fullbytecolor;
			if(i-4>7)
			{
				*(s + 2) = fullbytecolor;
				*(s + 3) = fullbytecolor;
				*(s + 4) = fullbytecolor;
				*(s + 5) = fullbytecolor;
				*(s + 6) = fullbytecolor;
			}
			else
			{
				*(s + 2) = C_WHITE | uppercolor;
				*(s + 3) = C_WHITE | (C_WHITE<<4);
				*(s + 4) = C_WHITE | (C_WHITE<<4);
				*(s + 5) = C_WHITE | (C_WHITE<<4);
				*(s + 6) = color | (C_WHITE<<4);
			
			}
			*(s + 7) = fullbytecolor;
			*(s + 8) = (*(s + 8) & 0x0F) | uppercolor;
			s += (SCREEN_WIDTH >> 1);
		}
	}
	else
	{
		for(i=BLOCK_SIZE; i--;)
		{
			*s = fullbytecolor;
			*(s + 1) = fullbytecolor;
			if(i-4>7)
			{
				*(s + 2) = fullbytecolor;
				*(s + 3) = fullbytecolor;
				*(s + 4) = fullbytecolor;
				*(s + 5) = fullbytecolor;
			}
			else
			{
				*(s + 2) = C_WHITE | (C_WHITE<<4);
				*(s + 3) = C_WHITE | (C_WHITE<<4);
				*(s + 4) = C_WHITE | (C_WHITE<<4);
				*(s + 5) = C_WHITE | (C_WHITE<<4);			
			}

			*(s + 6) = fullbytecolor;
			*(s + 7) = fullbytecolor;
			s += (SCREEN_WIDTH >> 1);
		}	
	}
	return;
}
inline void death_draw(int x, int y, unsigned char color, unsigned char* screenbuf)
{
	//counter, unsigned for speed
	unsigned int i;
	//Upper bits for a color, since 2 pixels per byte, hopefully improves speed
	unsigned char uppercolor = color<<4;
	unsigned char fullbytecolor = color | uppercolor;
	//get start address for sprite
	unsigned char* s = (unsigned char*)(screenbuf + ((x >> 1) + (y << 7) + (y << 5)));
	
	//in screen bounds?  Testing only
	if ((x < 0) || (x > (SCREEN_WIDTH - 4)) || (y < 0) || (y > (SCREEN_HEIGHT - 4))) return;

	if(x &1)
	{
		for(i=4; i--;)
		{
			//Unrolled, hopefully faster
			*s = (*s & 0xF0) | color;
			*(s + 1) = fullbytecolor;
			*(s + 2) = (*(s + 2) & 0x0F) | uppercolor;
			s += (SCREEN_WIDTH >> 1);
		}
	}
	else
	{
		for(i=4; i--;)
		{
			*s = fullbytecolor;
			*(s + 1) = fullbytecolor;
			s += (SCREEN_WIDTH >> 1);
		}	
	}
	return;
}