#include "lib/libreria.h"

//Les dues següents llibreries ens permetran generar nombres aleatoris
#include <stdlib.h> 
#include <time.h> 
//////////////////////////////////////////////////////////////////////

//La seguent llibreria ens permetra ficar retards (sleep)
#include <Windows.h>
//////////////////////////////////////////////////////////////////////

#include "NerdsVsZombies.h"

#define maxVidesZombie 3
#define zombiesMortsObjectiu 5


int NerdsVsZombies_Init(struct regInfo *reg)
// Funcio que inicialitza les variables, registres, etc
// Nomes s'executara una vegada (no esta dins el bucle del joc sino fora)
{	
	int i;

	//Iniciem les estructures de dades dels nerds i zombies 
	for (i = 0; i<=9; i++)
	{	
		//Com que nomes tenim 5 nerds...
		if (i<=4)
		{
			//iniciem les dades dels nerds
			reg ->tNerd[i].disparActiu = FALSE;
			reg ->tNerd[i].graficNerdActiu = FALSE;
			reg ->tNerd[i].zombieDavant = FALSE;
			reg ->tNerd[i].dades.apuntador = NULL;
			reg ->tNerd[i].dispar.apuntador = NULL;

		}
		//iniciem les dades dels zombies
		reg ->tZombie[i].graficZombieActiu = FALSE;
		reg ->tZombie[i].vidaZombie = maxVidesZombie; //Modificar per ficar-ho com a constant; #modificar constant videsZombie
		reg ->tZombie[i].dades.apuntador = NULL;  
	}

	// Iniciem el fons de pantalla
	reg ->background = Sprite_Create("data/background_sinacabar.png");

	// Inicialitzem l'estat del joc
	reg ->JocFinalitzat = FALSE;

	// Inicialitzem l'objectiu del joc (matar zombiesMortsObjectiu zombies)
	reg ->ZombiesMorts = 0;
	return 1;
}

int NerdsVsZombies_Tick(struct regInfo *reg)
// Funcio que s'executara cada cop que passi el bucle del joc
{	
	// IMPORTANT!!!!!!  INCLOURE LA LINIA
	// 	struct regInfo reg;
	// A L'ARXIU MAIN.C (1A LINIA, ABANS DE RES)

	int i,j,k;	
	int nombreAleatori;
	srand(time(NULL)); 

	// Proces de creacio de zombie en cas de que no n'hi hagin 10
	CreacioZombie(reg);

	// Avancem els zombies
	AvancarZombie(reg);

	//Comprovem l'objectiu del joc o si un zombie ha arribat a l'esquerra
	// si es aixi, finalitzem el joc
	if (ComprovarObjectiu(reg) || ComprovarZombieEsquerra(reg))
		FinalitzarJoc(reg);

	//Mirem si hi ha algun zombie mort, en aquest cas l'esborrem i correm la informacio dels zombies un lloc
	for (i = 0; i <= 9 ; i++)
	{ 
		if (ComprovarZombieMort(reg,i))
		{
			AugmentarZombiesMorts(reg);
			EsborrarZombie(reg,i);
		}
	}
	
	// Avancem els dispars
	AvancarDispars(reg);

	//Recorrem els nerds
	for (i = 0; i <=4; i++)
	{
		//Recorrem els zombies
		for (j = 0; j <= 9; j++)
		{
			// Comprovem si el nerd te un zombie davant
			ComprovarZombieDavant(reg,i,j);

			// si te zombieDavant i el dispar no estava activat, activem el dispar
			ActivarDispar(reg,i);

			// Comprovar l'estat de xoc entre els dispars i els zombies
			if (ComprovarXocDisparZombie(reg,i,j))
			{
				// Si xoquen, el zombie perd una vida
				DisminuirVidaZombie(reg, j);
				// i esborrem el dispar
				EsborrarDispar(reg,i);
			}	

			//Mirar si zombie i nerd xoquen, en aquest cas eliminem el nerd:
			if (ComprovarXocNerdZombie(reg,i,j))
				EliminarNerd(reg,i);					
		}// Tanca for per recorrer zombies
	}// Tanca for per recorrer nerds

	// Si s'apreta el boto esquerra del ratoli
	if(g_Mouse.trg[BUTTON_LEFT]) {
		// comprovem que no existeixin ja 5 nerds
		if (!ComprovarNerdsMaxims(reg,4))
		{
			// Creem un nerd, passant-li a la funcio l'ultim lloc lliure com a indexNerd			
			CrearNerd(reg, UltimLlocLliureNerd(reg));	
		}
	}

	// Si s'apreta el boto dreta del ratoli
	if(g_Mouse.trg[BUTTON_RIGHT])
	{
		// Eliminem l'ultim nerd creat
		EliminarNerd(reg, UltimNerdCreat(reg, 4));
	}

	return !reg ->JocFinalitzat;
}

void NerdsVsZombies_Draw(struct regInfo *reg)
{	
	int i;

	//dibuixem el fons (background)
	Sprite_Draw(reg ->background,1,1);

	// part de dibuix dels dispars:
	for (i = 0; i <= 4; i ++)
	{
		if (reg ->tNerd[i].disparActiu)
			Sprite_Draw(reg ->tNerd[i].dispar.apuntador, reg ->tNerd[i].dispar.x, reg ->tNerd[i].dispar.y);
	}

	//part de dibuixar el Nerd
	i = 0;
	while (i <= 4 && reg ->tNerd[i].dades.apuntador != NULL)
	{
		// Dibuixem el nerd
		Sprite_Draw(reg ->tNerd[i].dades.apuntador, reg ->tNerd[i].dades.x, reg ->tNerd[i].dades.y);
		// i indiquem que hi ha un grafic actiu
		reg ->tNerd[i].graficNerdActiu = TRUE;
		i++;
	}
	//Si nerd.apuntador es NULL, vol dir que no està actiu, per tant:
	if (reg ->tNerd[i].dades.apuntador == NULL)		
		reg ->tNerd[i].graficNerdActiu = FALSE;

	//part de dibuix del Zombie	
	i = 0;
	while (i <= 9 && reg ->tZombie[i].dades.apuntador != NULL)
	{			
		// Dibuixem el zombie de la posicio i
		Sprite_Draw(reg ->tZombie[i].dades.apuntador, reg ->tZombie[i].dades.x, reg ->tZombie[i].dades.y);
		i++;
	}
	//Si zombie.apuntador es NULL, vol dir que no està actiu, per tant:
	if (reg ->tZombie[i].dades.apuntador == NULL)		
		reg ->tZombie[i].graficZombieActiu = FALSE;


}

void NerdsVsZombies_Release()
{
}

void CreacioZombie(struct regInfo *reg)
// Crea nou zombie mitjançant un nombre aleatori
{
	int i, nombreAleatori;

	srand(time(NULL)); 
	if (!reg ->tZombie[9].graficZombieActiu)
	{
		//Creem un nombre aleatori 		
		nombreAleatori = rand();
		if (nombreAleatori < 0,20)
		{
			// Hem de recorrer els zombies per saber el primer que no esta actiu
			i = 0;
			while (reg ->tZombie[i].graficZombieActiu)
				i++;
			//Deixem espai entre zombies
			if (i == 0)
			{
					//Creem un gràfic per al zombie:
					reg ->tZombie[i].dades.apuntador = Sprite_Create("data/zombie1/walk/zombie1_walk0000.png");
					//Indiquem que hi ha un grafic de Zombie actiu:
					reg ->tZombie[i].graficZombieActiu = TRUE;
					//Finalment el dibuixem, just a la dreta de la pantalla i en una fila aleatoria:
					reg ->tZombie[i].dades.x = 1368-10; // s'ha de modificar per RESOLUTION_X; #modificar
					// La seguent operacio ens permetra assegurar-nos que zombie.y conté un valor multiple de 100
					reg ->tZombie[i].dades.y = (((((rand()%600)-1)/100)*100)+1); //s'ha de modificar per a RESOLUTION_Y; #modificar
					// Li assignem les vides
					reg ->tZombie[i].vidaZombie = maxVidesZombie; //#modificar  constant videsZombie
			}
			else if (reg->tZombie[i-1].dades.x < 1368-75) //modificar per a RESOLUTION_X #modificar
				{
					//Creem un gràfic per al zombie:
					reg ->tZombie[i].dades.apuntador = Sprite_Create("data/zombie1/walk/zombie1_walk0000.png");
					//Indiquem que hi ha un grafic de Zombie actiu:
					reg ->tZombie[i].graficZombieActiu = TRUE;
					//Finalment el dibuixem, just a la dreta de la pantalla i en una fila aleatoria:
					reg ->tZombie[i].dades.x = 1368-10; // s'ha de modificar per RESOLUTION_X; #modificar
					// La seguent operacio ens permetra assegurar-nos que zombie.y conté un valor multiple de 100
					reg ->tZombie[i].dades.y = (((((rand()%600)-1)/100)*100)+1); //s'ha de modificar per a RESOLUTION_Y; #modificar
					// Li assignem les vides
					reg ->tZombie[i].vidaZombie = maxVidesZombie; //#modificar constant videsZombie
				}			
		}
	}
}
void AvancarZombie(struct regInfo *reg)
// Li resta 1 a la posicio x de tots els zombies
{
	int i;
	// Avancem els zombies
	i = 0; 
	while (i <= 9 && reg ->tZombie[i].graficZombieActiu)
	{ 
		// Fem que el zombie avanci una passa cap a l'esquerra
		reg ->tZombie[i].dades.x -= 1;		
		i++;
	}
}
void FinalitzarJoc(struct regInfo *reg)
// Fica la variable JocFinalitzat a 1 (TRUE) i crea una breu parada del joc de 1 segon i mig
{
	reg ->JocFinalitzat = TRUE;
	Sleep(1500);
}
int ComprovarObjectiu(struct regInfo *reg)
// retorna 1 si hem assolit l'objectiu del joc (matar zombiesMortsObjectiu zombies)
{
	int retornar = FALSE;
	if (reg ->ZombiesMorts == zombiesMortsObjectiu)
		retornar = TRUE;
	return retornar;
}
int ComprovarZombieEsquerra(struct regInfo *reg)
// Retorna CERT si hi ha algun zombie tocant l'esquerra o FALS en cas contrari
{
	int retornar = FALSE;	
	if (reg ->tZombie[0].dades.x < 50)
		retornar = TRUE;
	return retornar;
}
int ComprovarZombieMort(struct regInfo *reg, int index)
// Retorna CERT si zombie es mort i FALS si encara esta viu
{
	int retornar = FALSE;	
	if (reg ->tZombie[index].vidaZombie == 0)
		retornar = TRUE;
	return retornar;
}
void AugmentarZombiesMorts(struct regInfo *reg)
//Augmenta en 1 la quantitat de zombies que hem matat
{
	reg ->ZombiesMorts += 1;
}
void EsborrarZombie(struct regInfo *reg, int index)
// Esborra la informacio del zombie[index] i fa correr la informacio un lloc per sobreescriure'l i conservar l'ordre
{
	while (index <= 9 && reg ->tZombie[index].graficZombieActiu)
	{
		// Cas que sigui el zombie numero 10, l'ultim
		// o sigui un entremitg pero no n'hi hagin mes (tots els posteriors no existeixin)
		if (index == 9 || !reg ->tZombie[index].graficZombieActiu)
		{
			reg ->tZombie[index].dades.apuntador = NULL;
			reg ->tZombie[index].graficZombieActiu = FALSE;
			reg ->tZombie[index].dades.x = 0;
			reg ->tZombie[index].dades.y = 0;
		}
		// Sino es l'ultim, correm la informacio un lloc			
		else 
		{
		// Li assignem la informacio del seguent zombie
			reg ->tZombie[index] = reg ->tZombie[index+1];
		}
		index++;
	}
}
void AvancarDispars(struct regInfo *reg)
// Li suma 1 a la posicio dels dispars
{
	int i;
	for (i = 0; i <= 4; i++) 
	{ 
		if (reg ->tNerd[i].disparActiu)
			// Fem que el dispar avanci cap a la dreta
			reg ->tNerd[i].dispar.x += 1;
	}
}
void ComprovarZombieDavant(struct regInfo *reg, int indexNerd, int indexZombie)
// Actualitza la variable zombieDavant en funcio de si te (true) o no te (false) un zombie mes endavant el nerd
{
	// Comprovem si el nerd te un zombie davant
	if (reg ->tNerd[indexNerd].dades.x + 10 < reg ->tZombie[indexZombie].dades.x - 10 && reg ->tNerd[indexNerd].dades.y == reg ->tZombie[indexZombie].dades.y)// && !reg ->tNerd[i].disparActiu)
		reg ->tNerd[indexNerd].zombieDavant = TRUE;
	else 
		reg ->tNerd[indexNerd].zombieDavant = FALSE;
}
void ActivarDispar(struct regInfo *reg, int indexNerd)
// Li passem el registre i l'index del nerd i li inicialitza el dispar
{
	if (reg ->tNerd[indexNerd].zombieDavant && !reg ->tNerd[indexNerd].disparActiu)
	{
		// Li diem que el dispar esta actiu
		reg ->tNerd[indexNerd].disparActiu = TRUE;
		// Li assignem les mateixes dades que el nerd perque apareixi a la seva mateixa posicio
		reg ->tNerd[indexNerd].dispar.x = reg ->tNerd[indexNerd].dades.x;
		reg ->tNerd[indexNerd].dispar.y = reg ->tNerd[indexNerd].dades.y;
		// Li creem el sprite
		reg ->tNerd[indexNerd].dispar.apuntador = Sprite_Create("data/disparo_bird/disparo_bird0000.png");
	}
}
int ComprovarXocDisparZombie(struct regInfo *reg, int indexNerd,int indexZombie)
// Retorna 1 si dispar del nerd indexNerd i zombie de index indexZombie xoquen, 0 si no
{
	int retorna = FALSE;
	if (reg ->tNerd[indexNerd].dispar.x  >= reg ->tZombie[indexZombie].dades.x   && reg ->tNerd[indexNerd].dispar.y == reg ->tZombie[indexZombie].dades.y)
		retorna = TRUE;
	return retorna;
}
void DisminuirVidaZombie(struct regInfo *reg, int indexZombie)
{
	reg ->tZombie[indexZombie].vidaZombie -= 1;
}
void EsborrarDispar(struct regInfo *reg, int indexNerd)
{
	reg ->tNerd[indexNerd].dispar.x = 0;
	reg ->tNerd[indexNerd].dispar.y = 0;
	reg ->tNerd[indexNerd].dispar.apuntador = NULL;
	reg ->tNerd[indexNerd].disparActiu = FALSE;
}
int ComprovarXocNerdZombie(struct regInfo *reg, int indexNerd,int indexZombie)
// Retorna 1 si el zombie de index indexZombie i el nerd de index indexNerd xoquen, 0 en altre cas
{
	int retorna = FALSE;
	if (reg ->tNerd[indexNerd].dades.x + 10 == reg ->tZombie[indexZombie].dades.x - 10 && reg ->tNerd[indexNerd].dades.y == reg ->tZombie[indexZombie].dades.y)
	{
		retorna = TRUE;
	}
	return retorna;
}
void EliminarNerd(struct regInfo *reg, int indexNerd)
// Elimina nerd de posicio indexNerd i corra la informacio un lloc perque quedi la taula ben ordenada
{
	while (indexNerd <= 4 && reg ->tNerd[indexNerd].graficNerdActiu)
	{
		// Cas que sigui el nerd numero 5, l'ultim
		// o sigui un entremitg  no n'hi hagin mes (tots els posteriors no existeixin)
		if (indexNerd == 4 || !reg ->tNerd[indexNerd+1].graficNerdActiu)
		{
			reg ->tNerd[indexNerd].dades.apuntador = NULL;
			reg ->tNerd[indexNerd].graficNerdActiu = NULL;
			reg ->tNerd[indexNerd].dades.x = 0;
			reg ->tNerd[indexNerd].dades.y = 0;
		}
		// Sino es l'ultim, correm la informacio un lloc			
		else 
			// Li assignem la informacio del seguent nerd
			reg->tNerd[indexNerd] = reg ->tNerd[indexNerd+1];
					
		indexNerd++;
	}
}
int ComprovarNerdsMaxims(struct regInfo *reg, int maximNerds)
//Retorna CERT si hem arribat al maxim de nerds i FALS si encara ens queda algun espai lliure
{
	int retorna = FALSE;
	if (reg->tNerd[maximNerds].graficNerdActiu)
		retorna = TRUE;
	return retorna;
}
int UltimLlocLliureNerd(struct regInfo *reg)
// Retorna ultim lloc lliure dels nerds, -1 si no n'hi ha cap de lliure
{
	int retorna, i = 0;
	if (ComprovarNerdsMaxims(reg,4))
		retorna = -1;
	else 
	{
		while (reg ->tNerd[i].graficNerdActiu)
			i++;
		retorna = i;
	}
	return retorna;
}
void CrearNerd(struct regInfo *reg, int indexNerd)
{
	// Senyalem que el grafic està creat
	reg->tNerd[indexNerd].graficNerdActiu = TRUE;
	// crear o modificar posicio del nerd
	reg ->tNerd[indexNerd].dades.x = g_Mouse.x;
	// La seguent operacio ens permetra assegurar-nos que nerd.y conte un valor multiple de 100
	reg ->tNerd[indexNerd].dades.y = ((((g_Mouse.y-1)/100)*100)+1);	

	//Si no existeix un grafic el creem
	if (reg ->tNerd[indexNerd].dades.apuntador == NULL)
	{
		reg ->tNerd[indexNerd].dades.apuntador = Sprite_Create("data/nerd1/nerd_standing/nerd0000.png");
	}
}
int UltimNerdCreat(struct regInfo *reg, int maximNerds)
// Retorna ultim nerd creat o -1 si no n'hi ha cap de creat
{
	while (!reg ->tNerd[maximNerds].graficNerdActiu && maximNerds >= 0)
		maximNerds--;
	return maximNerds;
}

/*								===================================
								============ TO DO LIST =========== 
								=================================== #TODO
-Coses fetes:
	* fer que zombies i nerds apareguin en multiples de y (fet)
	* background (fet)
	* ficar un registre extra amb una taula per permetre tindre fins a 10 zombies (fet)
	* boto dret --> elimini l'ultim zombie creat (fet)
	* fer 2 registres diferents: un pels zombies i l'altre pels nerds (fet)
	* implementar xocs (fet)
	* dintre de DRAW pintar tots els zombies que tinguin grafics i no nomes zombie[1] (fet)
	* dintre de TICK crear mes de un zombie (fet)
		* implementar sistema d'aleatorietat perque no surtin tots de cop (fet)
	* implementar dispars (fet)
		* comprovar a funcio tick mes o menys com el xoc de nerds i zombies pero amb dispars (fet)
		* pintar-los (fet)
		* fer que avancin a cada tick (fet)
		* crear estructura per les dades del dispar a part i després incloure-la dins de l'estructura del nerd (fet)
		* nerds disparen si i nomes si tenen un zombie al davant (fet)
			* a cada tick del programa, actualitzar l'estat de la variable zombieDavant (dintre de Nerd) segons si
			  cada nerd te (1) o no te (0) un zombie a la mateixa y que ell (fet)
		* zombies aguantaran 3 atacs maxim (fet)
		* LUXE: implementar-ho amb funcions per separar el codi i d'aquesta manera optimitzar-lo (fet)
____________________________________________________________________________________________________
____________________________________________________________________________________________________
-Coses per fer:
*/

/*===========================
==========TO DO LIST========= 
=============================
	* fer que zombies i nerds apareguin en multiples de y (fet)
	* background (fet)
	* ficar un registre extra amb una taula per permetre tindre fins a 10 zombies (fet)
	* boto dret --> elimini l'ultim zombie creat (fet)
	* fer 2 registres diferents: un pels zombies i l'altre pels nerds (fet)
	* implementar xocs (fet)
____________________________________________________________________________________________________
____________________________________________________________________________________________________
	* fer que zombie avançi mes rapid (canviar tambe comprovacio de xoc)
	* SI joc va massa rapid --> introduir retards a l'actualitzacio de les posicions
	* implementar dispars
		* comprovar a funcio tick mes o menys com el xoc de nerds i zombies pero amb dispars
		* crear estructura per les dades del dispar a part i després incloure-la dins de l'estructura del nerd
		* nerds disparen si i nomes si tenen un zombie al davant
			* a cada tick del programa, actualitzar l'estat de la variable zombieDavant (dintre de Nerd) segons si
			  cada nerd te (1) o no te (0) un zombie a la mateixa y que ell
		* zombies aguantaran 3 atacs maxim
	* LUXE: implementar-ho amb funcions per separar el codi i d'aquesta manera optimitzar-lo
	* LUXE: no fer xoc per posicio de y i x sino per tamx i tamy trobats dintre l'estructura T_SPRITE (fitxer "sprites.h")
	* LUXE: fer que nomes dispari el primer nerd de cada fila
	

*/
#include "lib/libreria.h"

//Les dues següents llibreries ens permetran generar nombres aleatoris
#include <stdlib.h> 
#include <time.h> 
//////////////////////////////////////////////////////////////////////

#include "NerdsVsZombies.h"


int NerdsVsZombies_Init(struct regInfo *reg)
// Funcio que inicialitza les variables, registres, etc
// Nomes s'executara una vegada (no esta dins el bucle del joc sino fora)
{	
	int i;

	//Iniciem les estructures de dades dels nerds i zombies 
	for (i = 0; i<=9; i++)
	{	
		//Com que nomes tenim 5 nerds...
		if (i<=4)
		{
			//iniciem les dades dels nerds
			reg ->tNerd[i].disparActiu = FALSE;
			reg ->tNerd[i].graficNerdActiu = FALSE;
			reg ->tNerd[i].zombieDavant = FALSE;
			reg ->tNerd[i].dades.apuntador = FALSE;

		}
		//iniciem les dades dels zombies
		reg ->tZombie[i].graficZombieActiu = FALSE;
		reg ->tZombie[i].vidaZombie = 3; //Modificar per ficar-ho com a constant
		reg ->tZombie[i].dades.apuntador = FALSE;
	}

	// Iniciem el fons de pantalla
	reg ->background = Sprite_Create("data/background_sinacabar.png");
	return 1;
}

int NerdsVsZombies_Tick(struct regInfo *reg)
// Funcio que s'executara cada cop que passi el bucle del joc
// Aqui -farem la majoria del codi
//      -tractarem els estimuls del ratoli i teclat
{	
	int i,j,k;
	
	//Recorrem els nerds
	for (i = 0; i <=4; i++)
	{
		//Recorrem els zombies
		for (j = 0; j <= 9; j++)
		{
			//Mirar si zombie i nerd xoquen, en aquest cas eliminem ambdos:
			if (reg ->tNerd[i].dades.x + 10 == reg ->tZombie[j].dades.x - 10 && reg ->tNerd[i].dades.y == reg ->tZombie[j].dades.y)
			{
				k = i;				
				while (k <= 4 && reg ->tNerd[k].graficNerdActiu)
				{
					// Cas que sigui el nerd numero 5, l'ultim
					// o sigui un entremitg pero no n'hi hagin mes (tots els posteriors no existeixin)
					if (k == 4 || !reg ->tNerd[k+1].graficNerdActiu)
					{
						reg ->tNerd[k].dades.apuntador = NULL;
						reg ->tNerd[k].graficNerdActiu = NULL;
						reg ->tNerd[k].dades.x = 0;
						reg ->tNerd[k].dades.y = 0;
					}
					// Sino es l'ultim, correm la informacio un lloc			
					else 
					{
						// Li assignem la informacio del seguent nerd
						reg->tNerd[k] = reg ->tNerd[k+1];
					}
					k++;
				}
				// Fem el mateix procediment amb els zombies, hem de tenir en compte que hi han 9 zombies
				// #FORTESTING 
				/*k = j;				
				while (k <= 9 && reg ->tZombie[k].graficZombieActiu)
				{
					// Cas que sigui el zombie numero 10, l'ultim
					// o sigui un entremitg pero no n'hi hagin mes (tots els posteriors no existeixin)
					if (k == 9 || !reg ->tZombie[k].graficZombieActiu)
					{
						reg ->tZombie[k].dades.apuntador = NULL;
						reg ->tZombie[k].graficZombieActiu = NULL;
						reg ->tZombie[k].dades.x = 0;
						reg ->tZombie[k].dades.y = 0;
					}
					// Sino es l'ultim, correm la informacio un lloc			
					else 
					{
						// Li assignem la informacio del seguent zombie
						reg->tZombie[k] = reg ->tZombie[k+1];
					}
					k++;
				}*/
			}
			//Comprovem si el zombie ha arribat a l'esquerra, si es aixi l'esborrem
			if (reg ->tZombie[i].dades.x < 50) //modificar el nombre, aquest es nomes de prova
			{
				reg ->tZombie[i].dades.apuntador = NULL;
				reg ->tZombie[i].graficZombieActiu = 0;
			}
		}
	}


	// Si s'apreta el boto esquerra del ratoli
	if(g_Mouse.trg[BUTTON_LEFT]) {
		// comprovem que no existeixin ja 5 nerds
		if (!reg->tNerd[4].graficNerdActiu)
		{
			// Busquem l'ultim lloc lliure dintre dels nerds
			i = 0;
			while (reg->tNerd[i].graficNerdActiu)
				i++;
			// Senyalem que el grafic està creat
			reg->tNerd[i].graficNerdActiu = TRUE;
			// crear o modificar posicio del nerd
			reg ->tNerd[i].dades.x = g_Mouse.x;
			// La seguent operacio ens permetra assegurar-nos que nerd.y conte un valor multiple de 100
			reg ->tNerd[i].dades.y = ((((g_Mouse.y-1)/100)*100)+1);	

			//Si no existeix un grafic el creem
			if (reg ->tNerd[i].dades.apuntador == NULL)
			{
				reg ->tNerd[i].dades.apuntador = Sprite_Create("data/nerd1/nerd_standing/nerd0000.png");
			}	
		}
	}
	// Si s'apreta el boto dreta del ratoli
	if(g_Mouse.trg[BUTTON_RIGHT]) {
		// eliminar grafic de l'ultim zombie creat
		//    busquem l'ultim zombie creat
		i = 4;
		while (!reg ->tNerd[i].graficNerdActiu && i >= 0)
			i--;
		// eliminem les seves dades
		reg ->tNerd[i].dades.apuntador = NULL;
		reg ->tNerd[i].graficNerdActiu = FALSE;
		reg ->tNerd[i].dades.x = 0;
		reg ->tNerd[i].dades.y = 0;
	
	}
	return 1;
}

void NerdsVsZombies_Draw(struct regInfo *reg)
{	
	float nombreAleatori;
	int i;

	//dibuixem el fons (background)
	Sprite_Draw(reg ->background,1,1);

	//part de dibuixar el Nerd
	i = 0;
	while (i <= 4 && reg ->tNerd[i].dades.apuntador != NULL)
	{
		// Dibuixem el nerd
		Sprite_Draw(reg ->tNerd[i].dades.apuntador, reg ->tNerd[i].dades.x, reg ->tNerd[i].dades.y);
		// i indiquem que hi ha un grafic actiu
		reg ->tNerd[i].graficNerdActiu = TRUE;
		i++;
	}
	//Si nerd.apuntador es NULL, vol dir que no està actiu, per tant:
	if (reg ->tNerd[i].dades.apuntador == NULL)		
		reg ->tNerd[i].graficNerdActiu = FALSE;



	//part de dibuix del Zombie	
	if (reg ->tZombie[1].dades.apuntador != NULL)
	{
		reg ->tZombie[1].dades.x -= 1;
		Sprite_Draw(reg ->tZombie[1].dades.apuntador, reg ->tZombie[1].dades.x, reg ->tZombie[1].dades.y);
	}
	//Si no hi ha cap zombie creat, el creem: 
	else 
	{
		//Creem un nombre aleatori entre 0 i 1
		srand(time(NULL)); 
		nombreAleatori = ((rand()%101) / 100);

		if (nombreAleatori < 0.25)
		{
			//Creem un gràfic per al zombie:
			reg ->tZombie[1].dades.apuntador = Sprite_Create("data/zombie1/disintegration/zombie_disintegration0000.png");

			//Indiquem que hi ha un grafic de Zombie actiu:
			reg ->tZombie[1].graficZombieActiu = TRUE;

			//Finalment el dibuixem, just a la dreta de la pantalla i en una fila aleatoria:
			reg ->tZombie[1].dades.x = 1368-10; // s'ha de modificar per RESOLUTION_X;
			// La seguent operacio ens permetra assegurar-nos que zombie.y conté un valor multiple de 100
			reg ->tZombie[1].dades.y = (((((rand()%600)-1)/100)*100)+1); //s'ha de modificar per a RESOLUTION_Y
			Sprite_Draw(reg ->tZombie[1].dades.apuntador, reg ->tZombie[1].dades.x, reg ->tZombie[1].dades.y);
		}
	}
}
void NerdsVsZombies_Release()
{
}

/*===========================
==========TO DO LIST========= 
=============================
	* fer que zombies i nerds apareguin en multiples de y (fet)
	* background (fet)
	* ficar un registre extra amb una taula per permetre tindre fins a 10 zombies (fet)
____________________________________________________________________________________________________
____________________________________________________________________________________________________
	* fer que zombie avan�§i mes rapid (canviar tambe comprovacio de xoc)
	* boto dret --> elimini l'ultim zombie creat
	

*/
#include "lib/libreria.h"

//Les dues seg�¼ents llibreries ens permetran generar nombres aleatoris
#include <stdlib.h> 
#include <time.h> 
//////////////////////////////////////////////////////////////////////

#include "NerdsVsZombies.h"


int NerdsVsZombies_Init(struct regInfo *reg)
// Funcio que inicialitza les variables, registres, etc
// Nomes s'executara una vegada (no esta dins el bucle del joc sino fora)
{	
	int i;
	for (i = 0; i<=9; i++)
	{		
		//iniciem els punters a les seves imatges a NULL	
		reg ->taulaDades[i].nerd.apuntador = NULL;
		reg ->taulaDades[i].zombie.apuntador = NULL;

		// Fiquem els grafics a 0, ja que encara no n'hi han
		reg ->taulaDades[i].graficNerdActiu = FALSE;
		reg ->taulaDades[i].graficZombieActiu = FALSE;
	}

	// Iniciem el fons de pantalla
	reg ->background = Sprite_Create("data/background_sinacabar.png");
	return 1;
}

int NerdsVsZombies_Tick(struct regInfo *reg)
// Funcio que s'executara cada cop que passi el bucle del joc
// Aqui -farem la majoria del codi
//      -tractarem els estimuls del ratoli i teclat
{	
	int i,j;
	
	//Recorrem els nerds
	for (i = 0; i <=4; i++)
	{
		//Recorrem els zombies
		for (j = 0; j <= 9; j++)
		{
			//Mirar si zombie i nerd xoquen, en aquest cas eliminem ambdos:
			if (reg ->taulaDades[i].nerd.x + 10 == reg ->taulaDades[j].zombie.x - 10 && reg ->taulaDades[i].nerd.y == reg ->taulaDades[j].zombie.y)
			{
				reg ->taulaDades[i].nerd.apuntador = NULL;
				reg ->taulaDades[j].zombie.apuntador = NULL;
				reg ->taulaDades[i].graficNerdActiu = NULL;
				reg ->taulaDades[j].graficZombieActiu = NULL;
			}
			//Comprovem si el zombie ha arribat a l'esquerra, si es aixi l'esborrem
			if (reg ->taulaDades[i].zombie.x < 50) //modificar el nombre, aquest es nomes de prova
			{
				reg ->taulaDades[i].zombie.apuntador = NULL;
				reg ->taulaDades[i].graficZombieActiu = 0;
			}
		}
	}


	// Si s'apreta el boto esquerra del ratoli
	if(g_Mouse.trg[BUTTON_LEFT]) {
		// comprovem que no existeixin ja 5 nerds
		if (!reg->taulaDades[4].graficNerdActiu)
		{
			// Busquem l'ultim lloc lliure dintre dels nerds
			i = 0;
			while (reg->taulaDades[i].graficNerdActiu)
				i++;
			// Senyalem que el grafic est�  creat
			reg->taulaDades[i].graficNerdActiu = TRUE;
			// crear o modificar posicio del nerd
			reg ->taulaDades[i]. nerd.x = g_Mouse.x;
			// La seguent operacio ens permetra assegurar-nos que nerd.y conte un valor multiple de 100
			reg ->taulaDades[i]. nerd.y = ((((g_Mouse.y-1)/100)*100)+1);	

			//Si no existeix un grafic el creem
			if (reg ->taulaDades[i]. nerd.apuntador == NULL)
			{
				reg ->taulaDades[i]. nerd.apuntador = Sprite_Create("data/nerd1/nerd_standing/nerd0000.png");
			}	
		}
	}
	// Si s'apreta el boto dreta del ratoli
	if(g_Mouse.cnt[BUTTON_RIGHT]) {
		// eliminar gr� fic
		reg ->taulaDades[1]. nerd.apuntador = NULL;
	}
	return 1;
}

void NerdsVsZombies_Draw(struct regInfo *reg)
{	
	float nombreAleatori;
	int i;

	//dibuixem el fons (background)
	Sprite_Draw(reg ->background,1,1);

	//part de dibuixar el Nerd
	i = 0;
	while (i <= 4 && reg ->taulaDades[i]. nerd.apuntador != NULL)
	{
		// Dibuixem el nerd
		Sprite_Draw(reg ->taulaDades[i]. nerd.apuntador, reg ->taulaDades[i]. nerd.x, reg ->taulaDades[i]. nerd.y);
		// i indiquem que hi ha un grafic actiu
		reg ->taulaDades[i]. graficNerdActiu = TRUE;
		i++;
	}
	//Si nerd.apuntador es NULL, vol dir que no est�  actiu, per tant:
	if (reg ->taulaDades[i]. nerd.apuntador == NULL)		
		reg ->taulaDades[i]. graficNerdActiu = FALSE;



	//part de dibuix del Zombie	
	if (reg ->taulaDades[1]. zombie.apuntador != NULL)
	{
		reg ->taulaDades[1].zombie.x -= 1;
		Sprite_Draw(reg ->taulaDades[1]. zombie.apuntador, reg ->taulaDades[1]. zombie.x, reg ->taulaDades[1]. zombie.y);
	}
	//Si no hi ha cap zombie creat, el creem: 
	else 
	{
		//Creem un nombre aleatori entre 0 i 1
		srand(time(NULL)); 
		nombreAleatori = ((rand()%101) / 100);

		if (nombreAleatori < 0.25)
		{
			//Creem un gr� fic per al zombie:
			reg ->taulaDades[1].zombie.apuntador = Sprite_Create("data/zombie1/disintegration/zombie_disintegration0000.png");

			//Indiquem que hi ha un grafic de Zombie actiu:
			reg ->taulaDades[1].graficZombieActiu = TRUE;

			//Finalment el dibuixem, just a la dreta de la pantalla i en una fila aleatoria:
			reg ->taulaDades[1].zombie.x = 1368-10; // s'ha de modificar per RESOLUTION_X;
			// La seguent operacio ens permetra assegurar-nos que zombie.y cont�© un valor multiple de 100
			reg ->taulaDades[1].zombie.y = (((((rand()%600)-1)/100)*100)+1); //s'ha de modificar per a RESOLUTION_Y
			Sprite_Draw(reg ->taulaDades[1]. zombie.apuntador, reg ->taulaDades[1]. zombie.x, reg ->taulaDades[1]. zombie.y);
		}
	}
}
void NerdsVsZombies_Release()
{
}

/*===========================
==========TO DO LIST========= 
=============================
	* fer que zombies i nerds apareguin en multiples de y (fet)
	* background (fet)
	* ficar un registre extra amb una taula per permetre tindre fins a 10 zombies (fet)
____________________________________________________________________________________________________
____________________________________________________________________________________________________
	* fer que zombie avançi mes rapid (canviar tambe comprovacio de xoc)
	* boto dret --> elimini l'ultim zombie creat
	

*/
#include "lib/libreria.h"

//Les dues següents llibreries ens permetran generar nombres aleatoris
#include <stdlib.h> 
#include <time.h> 
//////////////////////////////////////////////////////////////////////

#include "NerdsVsZombies.h"


int NerdsVsZombies_Init(struct regInfo *reg)
// Funcio que inicialitza les variables, registres, etc
// Nomes s'executara una vegada (no esta dins el bucle del joc sino fora)
{	
	int i;
	for (i = 0; i<=9; i++)
	{		
		//iniciem els punters a les seves imatges a NULL	
		reg ->taulaDades[i].nerd.apuntador = NULL;
		reg ->taulaDades[i].zombie.apuntador = NULL;

		// Fiquem els grafics a 0, ja que encara no n'hi han
		reg ->taulaDades[i].graficNerdActiu = FALSE;
		reg ->taulaDades[i].graficZombieActiu = FALSE;
	}

	// Iniciem el fons de pantalla
	reg ->background = Sprite_Create("data/background_sinacabar.png");
	return 1;
}

int NerdsVsZombies_Tick(struct regInfo *reg)
// Funcio que s'executara cada cop que passi el bucle del joc
// Aqui -farem la majoria del codi
//      -tractarem els estimuls del ratoli i teclat
{	
	int i,j;
	
	//Recorrem els nerds
	for (i = 0; i <=4; i++)
	{
		//Recorrem els zombies
		for (j = 0; j <= 9; j++)
		{
			//Mirar si zombie i nerd xoquen, en aquest cas eliminem ambdos:
			if (reg ->taulaDades[i].nerd.x + 10 == reg ->taulaDades[j].zombie.x - 10 && reg ->taulaDades[i].nerd.y == reg ->taulaDades[j].zombie.y)
			{
				reg ->taulaDades[i].nerd.apuntador = NULL;
				reg ->taulaDades[j].zombie.apuntador = NULL;
				reg ->taulaDades[i].graficNerdActiu = NULL;
				reg ->taulaDades[j].graficZombieActiu = NULL;
			}
			//Comprovem si el zombie ha arribat a l'esquerra, si es aixi l'esborrem
			if (reg ->taulaDades[i].zombie.x < 50) //modificar el nombre, aquest es nomes de prova
			{
				reg ->taulaDades[i].zombie.apuntador = NULL;
				reg ->taulaDades[i].graficZombieActiu = 0;
			}
		}
	}


	// Si s'apreta el boto esquerra del ratoli
	if(g_Mouse.trg[BUTTON_LEFT]) {
		// comprovem que no existeixin ja 5 nerds
		if (!reg->taulaDades[4].graficNerdActiu)
		{
			// Busquem l'ultim lloc lliure dintre dels nerds
			i = 0;
			while (reg->taulaDades[i].graficNerdActiu)
				i++;
			// Senyalem que el grafic està creat
			reg->taulaDades[i].graficNerdActiu = TRUE;
			// crear o modificar posicio del nerd
			reg ->taulaDades[i]. nerd.x = g_Mouse.x;
			// La seguent operacio ens permetra assegurar-nos que nerd.y conte un valor multiple de 100
			reg ->taulaDades[i]. nerd.y = ((((g_Mouse.y-1)/100)*100)+1);	

			//Si no existeix un grafic el creem
			if (reg ->taulaDades[i]. nerd.apuntador == NULL)
			{
				reg ->taulaDades[i]. nerd.apuntador = Sprite_Create("data/nerd1/nerd_standing/nerd0000.png");
			}	
		}
	}
	// Si s'apreta el boto dreta del ratoli
	if(g_Mouse.cnt[BUTTON_RIGHT]) {
		// eliminar gràfic
		reg ->taulaDades[1]. nerd.apuntador = NULL;
	}
	return 1;
}

void NerdsVsZombies_Draw(struct regInfo *reg)
{	
	float nombreAleatori;
	int i;

	//dibuixem el fons (background)
	Sprite_Draw(reg ->background,1,1);

	//part de dibuixar el Nerd
	i = 0;
	while (i <= 4 && reg ->taulaDades[i]. nerd.apuntador != NULL)
	{
		// Dibuixem el nerd
		Sprite_Draw(reg ->taulaDades[i]. nerd.apuntador, reg ->taulaDades[i]. nerd.x, reg ->taulaDades[i]. nerd.y);
		// i indiquem que hi ha un grafic actiu
		reg ->taulaDades[i]. graficNerdActiu = TRUE;
		i++;
	}
	//Si nerd.apuntador es NULL, vol dir que no està actiu, per tant:
	if (reg ->taulaDades[i]. nerd.apuntador == NULL)		
		reg ->taulaDades[i]. graficNerdActiu = FALSE;



	//part de dibuix del Zombie	
	if (reg ->taulaDades[1]. zombie.apuntador != NULL)
	{
		reg ->taulaDades[1].zombie.x -= 1;
		Sprite_Draw(reg ->taulaDades[1]. zombie.apuntador, reg ->taulaDades[1]. zombie.x, reg ->taulaDades[1]. zombie.y);
	}
	//Si no hi ha cap zombie creat, el creem: 
	else 
	{
		//Creem un nombre aleatori entre 0 i 1
		srand(time(NULL)); 
		nombreAleatori = ((rand()%101) / 100);

		if (nombreAleatori < 0.25)
		{
			//Creem un gràfic per al zombie:
			reg ->taulaDades[1].zombie.apuntador = Sprite_Create("data/zombie1/disintegration/zombie_disintegration0000.png");

			//Indiquem que hi ha un grafic de Zombie actiu:
			reg ->taulaDades[1].graficZombieActiu = TRUE;

			//Finalment el dibuixem, just a la dreta de la pantalla i en una fila aleatoria:
			reg ->taulaDades[1].zombie.x = 1368-10; // s'ha de modificar per RESOLUTION_X;
			// La seguent operacio ens permetra assegurar-nos que zombie.y conté un valor multiple de 100
			reg ->taulaDades[1].zombie.y = (((((rand()%600)-1)/100)*100)+1); //s'ha de modificar per a RESOLUTION_Y
			Sprite_Draw(reg ->taulaDades[1]. zombie.apuntador, reg ->taulaDades[1]. zombie.x, reg ->taulaDades[1]. zombie.y);
		}
	}
}
void NerdsVsZombies_Release()
{
}

/*===========================
==========TO DO LIST========= 
=============================
	* fer que zombies i nerds apareguin en multiples de y (fet)
	* background (fet)
	* ficar un registre extra amb una taula per permetre tindre fins a 10 zombies (fet)
____________________________________________________________________________________________________
____________________________________________________________________________________________________
	* fer que zombie avançi mes rapid (canviar tambe comprovacio de xoc)
	* boto dret --> elimini l'ultim zombie creat
	

*/
#include "lib/libreria.h"

//Les dues següents llibreries ens permetran generar nombres aleatoris
#include <stdlib.h> 
#include <time.h> 
//////////////////////////////////////////////////////////////////////

#include "NerdsVsZombies.h"


int NerdsVsZombies_Init(struct regInfo *reg)
// Funcio que inicialitza les variables, registres, etc
// Nomes s'executara una vegada (no esta dins el bucle del joc sino fora)
{	
	int i;
	for (i = 0; i<=9; i++)
	{		
		//iniciem els punters a les seves imatges a NULL	
		reg ->taulaDades[i].nerd.apuntador = NULL;
		reg ->taulaDades[i].zombie.apuntador = NULL;

		// Fiquem els grafics a 0, ja que encara no n'hi han
		reg ->taulaDades[i].graficNerdActiu = FALSE;
		reg ->taulaDades[i].graficZombieActiu = FALSE;
	}

	// Iniciem el fons de pantalla
	reg ->background = Sprite_Create("data/background_sinacabar.png");
	return 1;
}

int NerdsVsZombies_Tick(struct regInfo *reg)
// Funcio que s'executara cada cop que passi el bucle del joc
// Aqui -farem la majoria del codi
//      -tractarem els estimuls del ratoli i teclat
{	
	int i,j;
	
	//Recorrem els nerds
	for (i = 0; i <=4; i++)
	{
		//Recorrem els zombies
		for (j = 0; j <= 9; j++)
		{
			//Mirar si zombie i nerd xoquen, en aquest cas eliminem ambdos:
			if (reg ->taulaDades[i].nerd.x + 10 == reg ->taulaDades[j].zombie.x - 10 && reg ->taulaDades[i].nerd.y == reg ->taulaDades[j].zombie.y)
			{
				reg ->taulaDades[i].nerd.apuntador = NULL;
				reg ->taulaDades[j].zombie.apuntador = NULL;
				reg ->taulaDades[i].graficNerdActiu = NULL;
				reg ->taulaDades[j].graficZombieActiu = NULL;
			}
			//Comprovem si el zombie ha arribat a l'esquerra, si es aixi l'esborrem
			if (reg ->taulaDades[i].zombie.x < 50) //modificar el nombre, aquest es nomes de prova
			{
				reg ->taulaDades[i].zombie.apuntador = NULL;
				reg ->taulaDades[i].graficZombieActiu = 0;
			}
		}
	}


	// Si s'apreta el boto esquerra del ratoli
	if(g_Mouse.trg[BUTTON_LEFT]) {
		// comprovem que no existeixin ja 5 nerds
		if (!reg->taulaDades[4].graficNerdActiu)
		{
			// Busquem l'ultim lloc lliure dintre dels nerds
			i = 0;
			while (reg->taulaDades[i].graficNerdActiu)
				i++;
			// Senyalem que el grafic està creat
			reg->taulaDades[i].graficNerdActiu = TRUE;
			// crear o modificar posicio del nerd
			reg ->taulaDades[i]. nerd.x = g_Mouse.x;
			// La seguent operacio ens permetra assegurar-nos que nerd.y conte un valor multiple de 100
			reg ->taulaDades[i]. nerd.y = ((((g_Mouse.y-1)/100)*100)+1);	

			//Si no existeix un grafic el creem
			if (reg ->taulaDades[i]. nerd.apuntador == NULL)
			{
				reg ->taulaDades[i]. nerd.apuntador = Sprite_Create("data/nerd1/nerd_standing/nerd0000.png");
			}	
		}
	}
	// Si s'apreta el boto dreta del ratoli
	if(g_Mouse.cnt[BUTTON_RIGHT]) {
		// eliminar gràfic
		reg ->taulaDades[1]. nerd.apuntador = NULL;
	}
	return 1;
}

void NerdsVsZombies_Draw(struct regInfo *reg)
{	
	float nombreAleatori;
	int i;

	//dibuixem el fons (background)
	Sprite_Draw(reg ->background,1,1);

	//part de dibuixar el Nerd
	i = 0;
	while (i <= 4 && reg ->taulaDades[i]. nerd.apuntador != NULL)
	{
		// Dibuixem el nerd
		Sprite_Draw(reg ->taulaDades[i]. nerd.apuntador, reg ->taulaDades[i]. nerd.x, reg ->taulaDades[i]. nerd.y);
		// i indiquem que hi ha un grafic actiu
		reg ->taulaDades[i]. graficNerdActiu = TRUE;
		i++;
	}
	//Si nerd.apuntador es NULL, vol dir que no està actiu, per tant:
	if (reg ->taulaDades[i]. nerd.apuntador == NULL)		
		reg ->taulaDades[i]. graficNerdActiu = FALSE;



	//part de dibuix del Zombie	
	if (reg ->taulaDades[1]. zombie.apuntador != NULL)
	{
		reg ->taulaDades[1].zombie.x -= 1;
		Sprite_Draw(reg ->taulaDades[1]. zombie.apuntador, reg ->taulaDades[1]. zombie.x, reg ->taulaDades[1]. zombie.y);
	}
	//Si no hi ha cap zombie creat, el creem: 
	else 
	{
		//Creem un nombre aleatori entre 0 i 1
		srand(time(NULL)); 
		nombreAleatori = ((rand()%101) / 100);

		if (nombreAleatori < 0.25)
		{
			//Creem un gràfic per al zombie:
			reg ->taulaDades[1].zombie.apuntador = Sprite_Create("data/zombie1/disintegration/zombie_disintegration0000.png");

			//Indiquem que hi ha un grafic de Zombie actiu:
			reg ->taulaDades[1].graficZombieActiu = TRUE;

			//Finalment el dibuixem, just a la dreta de la pantalla i en una fila aleatoria:
			reg ->taulaDades[1].zombie.x = 1368-10; // s'ha de modificar per RESOLUTION_X;
			// La seguent operacio ens permetra assegurar-nos que zombie.y conté un valor multiple de 100
			reg ->taulaDades[1].zombie.y = (((((rand()%600)-1)/100)*100)+1); //s'ha de modificar per a RESOLUTION_Y
			Sprite_Draw(reg ->taulaDades[1]. zombie.apuntador, reg ->taulaDades[1]. zombie.x, reg ->taulaDades[1]. zombie.y);
		}
	}
}
void NerdsVsZombies_Release()
{
}

NerdsVsZombies

NerdsVsZombiesEntrega1.c

C