Posted By

Skabed on 04/13/12

Tagged

Versions (?)

Last Edited at 04/13/12 08:21am

Statistics

Viewed 110 times

Favorited by 0 user(s)

NerdsVsZombiesEntrega1.c

/ Published in: C

NerdsVsZombies

Highlighted TextExpand

#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:
*/

Report this snippet Tweet

Comments

Subscribe to comments

Comment:

You need to login to post a comment.