// C Source File
// Created 11/16/2007 08:39:39 PM

// Delete or comment out the items you do not need.
#define COMMENT_STRING         "Moon Buggy for the TI 89"
#define COMMENT_PROGRAM_NAME   "Moon Buggy"
#define COMMENT_AUTHORS        "Jeremy Salwen"
#include <tigcclib.h>
#include <stdlib.h>

#define GROUND_HEIGHT LCD_HEIGHT-5;
#define GROUND_INC 1
#define BUGGY_X LCD_WIDTH-16

volatile int counter=0;
INT_HANDLER old_int_handler;
static unsigned char lasersprite[] = {
	0b11111110,
};

static unsigned char chasislight[] ={
	0b00100000,
};
static unsigned char chasisdark[] = {
	0b11000000,
};

static unsigned char wheel1light[] = {
	0b00010000,
	0b00010000,
	0b00010000,
	0b00010000,
	0b00010000,
	0b00010000,
	0b00010000,
	0b00011000,
};
static unsigned char wheel1dark[] = {
	0b00001000,
	0b00001000,
	0b00001000,
	0b00001000,
	0b00001000,
	0b00001000,
	0b00001000,
};

static unsigned char wheel3light[] ={
	0b1000001,
};

static unsigned char wheel3dark[] = {
	0b01111110,
};

static unsigned char wheel2light[] = {
	0b00100000,
	0b01000000,
	0b00000000,
	0b00010000,
	0b00001000,
	0b00001000,
	0b00000100,
	0b00001000,
};
static unsigned char wheel2dark[] = {
	0b00000000,
	0b00100000,
	0b00110000,
	0b00010000,
	0b00010000,
	0b00001000,
	0b00001000,
	0b00000100,
};

static unsigned char wheel4light[] = {
	0b00000100,
	0b00001000,
	0b00000100,
	0b00010000,
	0b00001000,
	0b00010000,
	0b00010000,
	0b00100000,
};
static unsigned char wheel4dark[] = {
	0b00000000,
	0b00000100,
	0b00001000,
	0b00001000,
	0b00010000,
	0b00010000,
	0b00100000,
	0b00100000,
};
static unsigned int wheeloutlinelight[] = {
	0b0000000001000000,
	0b1000000000000000,
	0b1000000000100000,
	0b0100000000010000,
	0b1000000000010000,
	0b0100000000010000,
	0b0100000000100000,
	0b1000000000010000,
	0b0100000000100000,
};
static unsigned int wheeloutlinedark[] = {
	0b0100000000100000,
	0b0100000000010000,
	0b1000000000010000,
	0b1000000000010000,
	0b1000000000010000,
	0b1000000000010000,
	0b0100000000100000,
	};
static unsigned long buggytoplight[] = {
	0b00000000000000111100000000000000,
	0b00000000000000101011111011110000,
	0b00000000000001000000000000001000,
	0b00000000000001000000101001010000,
	0b00000000000000100001101001011000,
	0b00000000000000011010101011010000,
	0b00000000000000100101011111101000,
};

static unsigned long buggytopdark[] ={
	0b00000000000000011000000000000000,
	0b00000000000000100100000000000000,
	0b00000000000000100111111111110000,
	0b00000000000000100111010110101000,
	0b00000000000000100110010110100000,
	0b00000000000000100101010100101000,
	0b00000000000000011000000000000000,
};
//for holes in the ground
typedef struct segment {
	short x;
	short width;
} segment;

typedef struct point {
	short x;
	short y;
} point;

typedef struct rock {
	point loc;
	short health;
} rock;

typedef struct llnode {
	struct llnode *next;
	union data {
		segment hole;
		point location;
	};
} llnode;

typedef struct rocknode {
	llnode node;
	short health;
} rocknode;

typedef struct world {
	llnode *holesstart;
	llnode *holesend;
	llnode *lasersstart;
	llnode *lasersend;
	llnode *rocksstart;
	llnode *rocksend;
	short buggyHeight;
	short scrollSpeed;
} world;

BOOL collision(point *object1, point *object2, point *object1dim, point *object2dim) {
	if(object1->x+object1dim->x<object2->x) {
		return FALSE;
	}
	if(object1->x>object2->x+object2dim->x) {
		return FALSE;
	}
	if(object1->y+object1dim->y>object2->y) {
		return FALSE;
	}
	if(object1->y<object2->y+object2dim->y) {
		return FALSE;
	}
	return TRUE;
}

void removeNext(llnode *node) {
	llnode *twoahead=node->next->next;
	free(node->next);
	node->next=twoahead;
}

void lose(world *w) {
	
}

void collideCarAndRocks(world *w) {
	llnode *rocktmp=w->rocksstart;
	while(rocktmp!=NULL) {
		if(collion(&(point){BUGGY_X,w->buggyHeight},&rocktmp->location,) {
			lose(w);
		}
		rocktmp=rocktmp->next;
	}
}
void collideLasersAndRocks(world *w) {  //TODO:optimize this
	llnode *rocktmp=w->rocksstart;
	llnode *rocklast=NULL;
	llnode *lasertmp=w->lasersstart;
	llnode *laserlast=NULL;
	box rockbox;
	box laserbox;
	while(rocktmp!=NULL) {
		while(lasertmp!=NULL) {
			rockbox.upperleft=rocktmp->location;
			rockbox.lowerright.x=rockbox.upperleft.x+ROCK_WIDTH;
			rockbox.lowerright.y=rockbox.upperleft.y+ROCK_HEIGHT;
			laserbox.upperleft=lasertmp->location;
			laserbox.lowerright.x=laserbox.upperleft.x+LASER_WIDTH;
			laserbox.lowerright.y=laserbox.upperleft.y+LASER_HEIGHT;
			if(collision(&laserbox,&rockbox)) {
				if(rocklast==NULL) {
					free(rocktmp);
				} else {
					removeNext(rocklast);
				}
				if(laserlast==NULL) {
					free(rocktmp);
				} else {
					removeNext(laserlast);
				}
			}
			laserlast=lasertmp;
			lasertmp=lasertmp->next;
		}

	}
}
void scrollWorld(world *w) {
	llnode *tmp=w->holesstart;
	while(tmp!=NULL) {
		tmp->hole.x+=w->scrollSpeed;
		tmp=tmp->next;
	}
	tmp=w->lasersstart;
	while(tmp!=NULL) {
		tmp->hole.x-=w->scrollSpeed;
		tmp=tmp->next;
	}
	tmp=w->rocksstart;
	while(tmp!=NULL) {
		tmp->hole.x+=w->scrollSpeed;
		tmp=tmp->next;
	}
}

void cleanup(world *w) {
	llnode *tmp;
	while(w->holesstart->hole.x>160) {
		tmp=w->holesstart->next;
		free(w->holesstart);
		w->holesstart=tmp;
	}
	while(w->rocksstart->location.x>160) {
		tmp=w->rocksstart->next;
		free(w->rocksstart);
		w->rocksstart=tmp;
	}
	while(w->lasersstart->location.x<-6) {
		tmp=w->lasersstart->next;
		free(w->lasersstart);
		w->lasersstart=tmp;
	}
}

/* void renderWorld(world w) { //note:Render sounds more high tech than draw,  everything is XORED, so calling twice has no effect
	Sprite16(BUGGY_X,w.buggyHeight,10,buggysprite,LCD_MEM,SPRT_XOR);
	llnode *tmp=w.lasersstart;
	while(tmp!=NULL) {
		point p=tmp->location;
		Sprite8(p.x,p.y,4,rocksprite,LCD_MEM,SPRT_XOR);
		tmp=tmp->next;
	}
	
	tmp=w.rocksstart;
	while(tmp!=NULL) {
		point p=tmp->location;
		Sprite8(p.x,p.y,1,lasersprite,LCD_MEM,SPRT_XOR);
		tmp=tmp->next;
	}
	
	DrawLine(0,LCD_HEIGHT,LCD_WIDTH,LCD_HEIGHT,A_XOR);
	tmp=w.holesstart;
	while(tmp!=NULL) {
		segment s=tmp->hole;
		DrawLine(s.x,LCD_HEIGHT,s.x+s.width,LCD_HEIGHT,A_XOR);
		tmp=tmp->next;
	}
	
	int b=GROUND_HEIGHT;
	SCR_RECT r={{0,b,LCD_WIDTH,LCD_HEIGHT}};
	ScrRectFill(&r,ScrRect,A_XOR);
}
*/
void drawBuggy(short x, short y,char mode) {
	Sprite32(x+0,y+0,7,buggytoplight,GrayGetPlane(LIGHT_PLANE),A_XOR);
	Sprite8(x+15,y+15,1,chasislight,GrayGetPlane(LIGHT_PLANE),A_XOR);
	Sprite16(x+0,y+10,9,wheeloutlinelight,GrayGetPlane(LIGHT_PLANE),A_XOR);
	Sprite16(x+20,y+10,9,wheeloutlinelight,GrayGetPlane(LIGHT_PLANE),A_XOR);
	Sprite32(x+0,y+0,7,buggytopdark,GrayGetPlane(DARK_PLANE),A_XOR);
	Sprite16(x+0,y+11,7,wheeloutlinedark,GrayGetPlane(DARK_PLANE),A_XOR);
	Sprite16(x+20,y+11,7,wheeloutlinedark,GrayGetPlane(DARK_PLANE),A_XOR);
	Sprite8(x+15,y+15,1,chasisdark,GrayGetPlane(DARK_PLANE),A_XOR);
	switch(mode) {
		case 0:
			Sprite8(x+2,y+11,8,wheel1light,GrayGetPlane(LIGHT_PLANE),A_XOR);
			Sprite8(x+2,y+11,7,wheel1dark,GrayGetPlane(DARK_PLANE),A_XOR);
			Sprite8(x+22,y+11,8,wheel1light,GrayGetPlane(LIGHT_PLANE),A_XOR);
			Sprite8(x+22,y+11,7,wheel1dark,GrayGetPlane(DARK_PLANE),A_XOR);
			break;
		case 1:
			Sprite8(x+2,y+11,8,wheel2light,GrayGetPlane(LIGHT_PLANE),A_XOR);
			Sprite8(x+2,y+11,8,wheel2dark,GrayGetPlane(DARK_PLANE),A_XOR);
			Sprite8(x+22,y+11,8,wheel2light,GrayGetPlane(LIGHT_PLANE),A_XOR);
			Sprite8(x+22,y+11,8,wheel2dark,GrayGetPlane(DARK_PLANE),A_XOR);
			break;
		case 2:
			Sprite8(x+2,y+14,1,wheel3light,GrayGetPlane(LIGHT_PLANE),A_XOR);
			Sprite8(x+2,y+14,1,wheel3dark,GrayGetPlane(DARK_PLANE),A_XOR);
			Sprite8(x+22,y+14,1,wheel3light,GrayGetPlane(LIGHT_PLANE),A_XOR);
			Sprite8(x+22,y+14,1,wheel3dark,GrayGetPlane(DARK_PLANE),A_XOR);
			break;
		case 3:
			Sprite8(x+2,y+11,8,wheel4light,GrayGetPlane(LIGHT_PLANE),A_XOR);
			Sprite8(x+2,y+11,8,wheel4dark,GrayGetPlane(DARK_PLANE),A_XOR);
			Sprite8(x+22,y+11,8,wheel4light,GrayGetPlane(LIGHT_PLANE),A_XOR);
			Sprite8(x+22,y+11,8,wheel4dark,GrayGetPlane(DARK_PLANE),A_XOR);
			break;
	}
}
DEFINE_INT_HANDLER (my_int_handler) {
	counter++;
	ExecuteHandler(old_int_handler);
}
// Main Function
void _main(void)
{
	old_int_handler=GetIntVec(AUTO_INT_5);
	SetIntVec(AUTO_INT_5,my_int_handler);
	ClrScr();
	GrayOn();
	char mode=0;
	while(!kbhit()) {
		drawBuggy(0,0,mode);
		while(counter<2) {
			;
		}
		counter=0;
		drawBuggy(0,0,mode);
		mode=(mode+1)%4;
	}
	GrayOff();
	SetIntVec(AUTO_INT_5,old_int_handler);
	exit(0);
	int lastElement=0;
	segment segments[80];
	int i;
	int dy=0;
	int buggy=GROUND_HEIGHT-1;
	while(!_keytest(RR_ESC)) {
	}
	// Place your code here.
}