Revision: 56743
Updated Code
at April 16, 2012 03:18 by Skabed
Updated Code
#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: */
Revision: 56742
Updated Code
at April 14, 2012 07:52 by Skabed
Updated Code
/*=========================== ==========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() { }
Revision: 56741
Updated Code
at April 13, 2012 08:23 by Skabed
Updated Code
/*=========================== ==========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() { }
Revision: 56740
Updated Code
at April 13, 2012 08:22 by Skabed
Updated Code
/*=========================== ==========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() { }
Revision: 56739
Initial Code
Initial URL
Initial Description
Initial Title
Initial Tags
Initial Language
at April 13, 2012 08:21 by Skabed
Initial Code
/*=========================== ==========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() { }
Initial URL
Initial Description
NerdsVsZombies
Initial Title
NerdsVsZombiesEntrega1.c
Initial Tags
Initial Language
C