Posted By

Skabed on 04/13/12


Tagged


Versions (?)

NerdsVsZombiesEntrega1.c


 / Published in: C
 

NerdsVsZombies

  1. #include "lib/libreria.h"
  2.  
  3. //Les dues següents llibreries ens permetran generar nombres aleatoris
  4. #include <stdlib.h>
  5. #include <time.h>
  6. //////////////////////////////////////////////////////////////////////
  7.  
  8. //La seguent llibreria ens permetra ficar retards (sleep)
  9. #include <Windows.h>
  10. //////////////////////////////////////////////////////////////////////
  11.  
  12. #include "NerdsVsZombies.h"
  13.  
  14. #define maxVidesZombie 3
  15. #define zombiesMortsObjectiu 5
  16.  
  17.  
  18. int NerdsVsZombies_Init(struct regInfo *reg)
  19. // Funcio que inicialitza les variables, registres, etc
  20. // Nomes s'executara una vegada (no esta dins el bucle del joc sino fora)
  21. {
  22. int i;
  23.  
  24. //Iniciem les estructures de dades dels nerds i zombies
  25. for (i = 0; i<=9; i++)
  26. {
  27. //Com que nomes tenim 5 nerds...
  28. if (i<=4)
  29. {
  30. //iniciem les dades dels nerds
  31. reg ->tNerd[i].disparActiu = FALSE;
  32. reg ->tNerd[i].graficNerdActiu = FALSE;
  33. reg ->tNerd[i].zombieDavant = FALSE;
  34. reg ->tNerd[i].dades.apuntador = NULL;
  35. reg ->tNerd[i].dispar.apuntador = NULL;
  36.  
  37. }
  38. //iniciem les dades dels zombies
  39. reg ->tZombie[i].graficZombieActiu = FALSE;
  40. reg ->tZombie[i].vidaZombie = maxVidesZombie; //Modificar per ficar-ho com a constant; #modificar constant videsZombie
  41. reg ->tZombie[i].dades.apuntador = NULL;
  42. }
  43.  
  44. // Iniciem el fons de pantalla
  45. reg ->background = Sprite_Create("data/background_sinacabar.png");
  46.  
  47. // Inicialitzem l'estat del joc
  48. reg ->JocFinalitzat = FALSE;
  49.  
  50. // Inicialitzem l'objectiu del joc (matar zombiesMortsObjectiu zombies)
  51. reg ->ZombiesMorts = 0;
  52. return 1;
  53. }
  54.  
  55. int NerdsVsZombies_Tick(struct regInfo *reg)
  56. // Funcio que s'executara cada cop que passi el bucle del joc
  57. {
  58. // IMPORTANT!!!!!! INCLOURE LA LINIA
  59. // struct regInfo reg;
  60. // A L'ARXIU MAIN.C (1A LINIA, ABANS DE RES)
  61.  
  62. int i,j,k;
  63. int nombreAleatori;
  64. srand(time(NULL));
  65.  
  66. // Proces de creacio de zombie en cas de que no n'hi hagin 10
  67. CreacioZombie(reg);
  68.  
  69. // Avancem els zombies
  70. AvancarZombie(reg);
  71.  
  72. //Comprovem l'objectiu del joc o si un zombie ha arribat a l'esquerra
  73. // si es aixi, finalitzem el joc
  74. if (ComprovarObjectiu(reg) || ComprovarZombieEsquerra(reg))
  75. FinalitzarJoc(reg);
  76.  
  77. //Mirem si hi ha algun zombie mort, en aquest cas l'esborrem i correm la informacio dels zombies un lloc
  78. for (i = 0; i <= 9 ; i++)
  79. {
  80. if (ComprovarZombieMort(reg,i))
  81. {
  82. AugmentarZombiesMorts(reg);
  83. EsborrarZombie(reg,i);
  84. }
  85. }
  86.  
  87. // Avancem els dispars
  88. AvancarDispars(reg);
  89.  
  90. //Recorrem els nerds
  91. for (i = 0; i <=4; i++)
  92. {
  93. //Recorrem els zombies
  94. for (j = 0; j <= 9; j++)
  95. {
  96. // Comprovem si el nerd te un zombie davant
  97. ComprovarZombieDavant(reg,i,j);
  98.  
  99. // si te zombieDavant i el dispar no estava activat, activem el dispar
  100. ActivarDispar(reg,i);
  101.  
  102. // Comprovar l'estat de xoc entre els dispars i els zombies
  103. if (ComprovarXocDisparZombie(reg,i,j))
  104. {
  105. // Si xoquen, el zombie perd una vida
  106. DisminuirVidaZombie(reg, j);
  107. // i esborrem el dispar
  108. EsborrarDispar(reg,i);
  109. }
  110.  
  111. //Mirar si zombie i nerd xoquen, en aquest cas eliminem el nerd:
  112. if (ComprovarXocNerdZombie(reg,i,j))
  113. EliminarNerd(reg,i);
  114. }// Tanca for per recorrer zombies
  115. }// Tanca for per recorrer nerds
  116.  
  117. // Si s'apreta el boto esquerra del ratoli
  118. if(g_Mouse.trg[BUTTON_LEFT]) {
  119. // comprovem que no existeixin ja 5 nerds
  120. if (!ComprovarNerdsMaxims(reg,4))
  121. {
  122. // Creem un nerd, passant-li a la funcio l'ultim lloc lliure com a indexNerd
  123. CrearNerd(reg, UltimLlocLliureNerd(reg));
  124. }
  125. }
  126.  
  127. // Si s'apreta el boto dreta del ratoli
  128. if(g_Mouse.trg[BUTTON_RIGHT])
  129. {
  130. // Eliminem l'ultim nerd creat
  131. EliminarNerd(reg, UltimNerdCreat(reg, 4));
  132. }
  133.  
  134. return !reg ->JocFinalitzat;
  135. }
  136.  
  137. void NerdsVsZombies_Draw(struct regInfo *reg)
  138. {
  139. int i;
  140.  
  141. //dibuixem el fons (background)
  142. Sprite_Draw(reg ->background,1,1);
  143.  
  144. // part de dibuix dels dispars:
  145. for (i = 0; i <= 4; i ++)
  146. {
  147. if (reg ->tNerd[i].disparActiu)
  148. Sprite_Draw(reg ->tNerd[i].dispar.apuntador, reg ->tNerd[i].dispar.x, reg ->tNerd[i].dispar.y);
  149. }
  150.  
  151. //part de dibuixar el Nerd
  152. i = 0;
  153. while (i <= 4 && reg ->tNerd[i].dades.apuntador != NULL)
  154. {
  155. // Dibuixem el nerd
  156. Sprite_Draw(reg ->tNerd[i].dades.apuntador, reg ->tNerd[i].dades.x, reg ->tNerd[i].dades.y);
  157. // i indiquem que hi ha un grafic actiu
  158. reg ->tNerd[i].graficNerdActiu = TRUE;
  159. i++;
  160. }
  161. //Si nerd.apuntador es NULL, vol dir que no està actiu, per tant:
  162. if (reg ->tNerd[i].dades.apuntador == NULL)
  163. reg ->tNerd[i].graficNerdActiu = FALSE;
  164.  
  165. //part de dibuix del Zombie
  166. i = 0;
  167. while (i <= 9 && reg ->tZombie[i].dades.apuntador != NULL)
  168. {
  169. // Dibuixem el zombie de la posicio i
  170. Sprite_Draw(reg ->tZombie[i].dades.apuntador, reg ->tZombie[i].dades.x, reg ->tZombie[i].dades.y);
  171. i++;
  172. }
  173. //Si zombie.apuntador es NULL, vol dir que no està actiu, per tant:
  174. if (reg ->tZombie[i].dades.apuntador == NULL)
  175. reg ->tZombie[i].graficZombieActiu = FALSE;
  176.  
  177.  
  178. }
  179.  
  180. void NerdsVsZombies_Release()
  181. {
  182. }
  183.  
  184. void CreacioZombie(struct regInfo *reg)
  185. // Crea nou zombie mitjançant un nombre aleatori
  186. {
  187. int i, nombreAleatori;
  188.  
  189. srand(time(NULL));
  190. if (!reg ->tZombie[9].graficZombieActiu)
  191. {
  192. //Creem un nombre aleatori
  193. nombreAleatori = rand();
  194. if (nombreAleatori < 0,20)
  195. {
  196. // Hem de recorrer els zombies per saber el primer que no esta actiu
  197. i = 0;
  198. while (reg ->tZombie[i].graficZombieActiu)
  199. i++;
  200. //Deixem espai entre zombies
  201. if (i == 0)
  202. {
  203. //Creem un gràfic per al zombie:
  204. reg ->tZombie[i].dades.apuntador = Sprite_Create("data/zombie1/walk/zombie1_walk0000.png");
  205. //Indiquem que hi ha un grafic de Zombie actiu:
  206. reg ->tZombie[i].graficZombieActiu = TRUE;
  207. //Finalment el dibuixem, just a la dreta de la pantalla i en una fila aleatoria:
  208. reg ->tZombie[i].dades.x = 1368-10; // s'ha de modificar per RESOLUTION_X; #modificar
  209. // La seguent operacio ens permetra assegurar-nos que zombie.y conté un valor multiple de 100
  210. reg ->tZombie[i].dades.y = (((((rand()%600)-1)/100)*100)+1); //s'ha de modificar per a RESOLUTION_Y; #modificar
  211. // Li assignem les vides
  212. reg ->tZombie[i].vidaZombie = maxVidesZombie; //#modificar constant videsZombie
  213. }
  214. else if (reg->tZombie[i-1].dades.x < 1368-75) //modificar per a RESOLUTION_X #modificar
  215. {
  216. //Creem un gràfic per al zombie:
  217. reg ->tZombie[i].dades.apuntador = Sprite_Create("data/zombie1/walk/zombie1_walk0000.png");
  218. //Indiquem que hi ha un grafic de Zombie actiu:
  219. reg ->tZombie[i].graficZombieActiu = TRUE;
  220. //Finalment el dibuixem, just a la dreta de la pantalla i en una fila aleatoria:
  221. reg ->tZombie[i].dades.x = 1368-10; // s'ha de modificar per RESOLUTION_X; #modificar
  222. // La seguent operacio ens permetra assegurar-nos que zombie.y conté un valor multiple de 100
  223. reg ->tZombie[i].dades.y = (((((rand()%600)-1)/100)*100)+1); //s'ha de modificar per a RESOLUTION_Y; #modificar
  224. // Li assignem les vides
  225. reg ->tZombie[i].vidaZombie = maxVidesZombie; //#modificar constant videsZombie
  226. }
  227. }
  228. }
  229. }
  230. void AvancarZombie(struct regInfo *reg)
  231. // Li resta 1 a la posicio x de tots els zombies
  232. {
  233. int i;
  234. // Avancem els zombies
  235. i = 0;
  236. while (i <= 9 && reg ->tZombie[i].graficZombieActiu)
  237. {
  238. // Fem que el zombie avanci una passa cap a l'esquerra
  239. reg ->tZombie[i].dades.x -= 1;
  240. i++;
  241. }
  242. }
  243. void FinalitzarJoc(struct regInfo *reg)
  244. // Fica la variable JocFinalitzat a 1 (TRUE) i crea una breu parada del joc de 1 segon i mig
  245. {
  246. reg ->JocFinalitzat = TRUE;
  247. Sleep(1500);
  248. }
  249. int ComprovarObjectiu(struct regInfo *reg)
  250. // retorna 1 si hem assolit l'objectiu del joc (matar zombiesMortsObjectiu zombies)
  251. {
  252. int retornar = FALSE;
  253. if (reg ->ZombiesMorts == zombiesMortsObjectiu)
  254. retornar = TRUE;
  255. return retornar;
  256. }
  257. int ComprovarZombieEsquerra(struct regInfo *reg)
  258. // Retorna CERT si hi ha algun zombie tocant l'esquerra o FALS en cas contrari
  259. {
  260. int retornar = FALSE;
  261. if (reg ->tZombie[0].dades.x < 50)
  262. retornar = TRUE;
  263. return retornar;
  264. }
  265. int ComprovarZombieMort(struct regInfo *reg, int index)
  266. // Retorna CERT si zombie es mort i FALS si encara esta viu
  267. {
  268. int retornar = FALSE;
  269. if (reg ->tZombie[index].vidaZombie == 0)
  270. retornar = TRUE;
  271. return retornar;
  272. }
  273. void AugmentarZombiesMorts(struct regInfo *reg)
  274. //Augmenta en 1 la quantitat de zombies que hem matat
  275. {
  276. reg ->ZombiesMorts += 1;
  277. }
  278. void EsborrarZombie(struct regInfo *reg, int index)
  279. // Esborra la informacio del zombie[index] i fa correr la informacio un lloc per sobreescriure'l i conservar l'ordre
  280. {
  281. while (index <= 9 && reg ->tZombie[index].graficZombieActiu)
  282. {
  283. // Cas que sigui el zombie numero 10, l'ultim
  284. // o sigui un entremitg pero no n'hi hagin mes (tots els posteriors no existeixin)
  285. if (index == 9 || !reg ->tZombie[index].graficZombieActiu)
  286. {
  287. reg ->tZombie[index].dades.apuntador = NULL;
  288. reg ->tZombie[index].graficZombieActiu = FALSE;
  289. reg ->tZombie[index].dades.x = 0;
  290. reg ->tZombie[index].dades.y = 0;
  291. }
  292. // Sino es l'ultim, correm la informacio un lloc
  293. else
  294. {
  295. // Li assignem la informacio del seguent zombie
  296. reg ->tZombie[index] = reg ->tZombie[index+1];
  297. }
  298. index++;
  299. }
  300. }
  301. void AvancarDispars(struct regInfo *reg)
  302. // Li suma 1 a la posicio dels dispars
  303. {
  304. int i;
  305. for (i = 0; i <= 4; i++)
  306. {
  307. if (reg ->tNerd[i].disparActiu)
  308. // Fem que el dispar avanci cap a la dreta
  309. reg ->tNerd[i].dispar.x += 1;
  310. }
  311. }
  312. void ComprovarZombieDavant(struct regInfo *reg, int indexNerd, int indexZombie)
  313. // Actualitza la variable zombieDavant en funcio de si te (true) o no te (false) un zombie mes endavant el nerd
  314. {
  315. // Comprovem si el nerd te un zombie davant
  316. 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)
  317. reg ->tNerd[indexNerd].zombieDavant = TRUE;
  318. else
  319. reg ->tNerd[indexNerd].zombieDavant = FALSE;
  320. }
  321. void ActivarDispar(struct regInfo *reg, int indexNerd)
  322. // Li passem el registre i l'index del nerd i li inicialitza el dispar
  323. {
  324. if (reg ->tNerd[indexNerd].zombieDavant && !reg ->tNerd[indexNerd].disparActiu)
  325. {
  326. // Li diem que el dispar esta actiu
  327. reg ->tNerd[indexNerd].disparActiu = TRUE;
  328. // Li assignem les mateixes dades que el nerd perque apareixi a la seva mateixa posicio
  329. reg ->tNerd[indexNerd].dispar.x = reg ->tNerd[indexNerd].dades.x;
  330. reg ->tNerd[indexNerd].dispar.y = reg ->tNerd[indexNerd].dades.y;
  331. // Li creem el sprite
  332. reg ->tNerd[indexNerd].dispar.apuntador = Sprite_Create("data/disparo_bird/disparo_bird0000.png");
  333. }
  334. }
  335. int ComprovarXocDisparZombie(struct regInfo *reg, int indexNerd,int indexZombie)
  336. // Retorna 1 si dispar del nerd indexNerd i zombie de index indexZombie xoquen, 0 si no
  337. {
  338. int retorna = FALSE;
  339. if (reg ->tNerd[indexNerd].dispar.x >= reg ->tZombie[indexZombie].dades.x && reg ->tNerd[indexNerd].dispar.y == reg ->tZombie[indexZombie].dades.y)
  340. retorna = TRUE;
  341. return retorna;
  342. }
  343. void DisminuirVidaZombie(struct regInfo *reg, int indexZombie)
  344. {
  345. reg ->tZombie[indexZombie].vidaZombie -= 1;
  346. }
  347. void EsborrarDispar(struct regInfo *reg, int indexNerd)
  348. {
  349. reg ->tNerd[indexNerd].dispar.x = 0;
  350. reg ->tNerd[indexNerd].dispar.y = 0;
  351. reg ->tNerd[indexNerd].dispar.apuntador = NULL;
  352. reg ->tNerd[indexNerd].disparActiu = FALSE;
  353. }
  354. int ComprovarXocNerdZombie(struct regInfo *reg, int indexNerd,int indexZombie)
  355. // Retorna 1 si el zombie de index indexZombie i el nerd de index indexNerd xoquen, 0 en altre cas
  356. {
  357. int retorna = FALSE;
  358. if (reg ->tNerd[indexNerd].dades.x + 10 == reg ->tZombie[indexZombie].dades.x - 10 && reg ->tNerd[indexNerd].dades.y == reg ->tZombie[indexZombie].dades.y)
  359. {
  360. retorna = TRUE;
  361. }
  362. return retorna;
  363. }
  364. void EliminarNerd(struct regInfo *reg, int indexNerd)
  365. // Elimina nerd de posicio indexNerd i corra la informacio un lloc perque quedi la taula ben ordenada
  366. {
  367. while (indexNerd <= 4 && reg ->tNerd[indexNerd].graficNerdActiu)
  368. {
  369. // Cas que sigui el nerd numero 5, l'ultim
  370. // o sigui un entremitg no n'hi hagin mes (tots els posteriors no existeixin)
  371. if (indexNerd == 4 || !reg ->tNerd[indexNerd+1].graficNerdActiu)
  372. {
  373. reg ->tNerd[indexNerd].dades.apuntador = NULL;
  374. reg ->tNerd[indexNerd].graficNerdActiu = NULL;
  375. reg ->tNerd[indexNerd].dades.x = 0;
  376. reg ->tNerd[indexNerd].dades.y = 0;
  377. }
  378. // Sino es l'ultim, correm la informacio un lloc
  379. else
  380. // Li assignem la informacio del seguent nerd
  381. reg->tNerd[indexNerd] = reg ->tNerd[indexNerd+1];
  382.  
  383. indexNerd++;
  384. }
  385. }
  386. int ComprovarNerdsMaxims(struct regInfo *reg, int maximNerds)
  387. //Retorna CERT si hem arribat al maxim de nerds i FALS si encara ens queda algun espai lliure
  388. {
  389. int retorna = FALSE;
  390. if (reg->tNerd[maximNerds].graficNerdActiu)
  391. retorna = TRUE;
  392. return retorna;
  393. }
  394. int UltimLlocLliureNerd(struct regInfo *reg)
  395. // Retorna ultim lloc lliure dels nerds, -1 si no n'hi ha cap de lliure
  396. {
  397. int retorna, i = 0;
  398. if (ComprovarNerdsMaxims(reg,4))
  399. retorna = -1;
  400. else
  401. {
  402. while (reg ->tNerd[i].graficNerdActiu)
  403. i++;
  404. retorna = i;
  405. }
  406. return retorna;
  407. }
  408. void CrearNerd(struct regInfo *reg, int indexNerd)
  409. {
  410. // Senyalem que el grafic està creat
  411. reg->tNerd[indexNerd].graficNerdActiu = TRUE;
  412. // crear o modificar posicio del nerd
  413. reg ->tNerd[indexNerd].dades.x = g_Mouse.x;
  414. // La seguent operacio ens permetra assegurar-nos que nerd.y conte un valor multiple de 100
  415. reg ->tNerd[indexNerd].dades.y = ((((g_Mouse.y-1)/100)*100)+1);
  416.  
  417. //Si no existeix un grafic el creem
  418. if (reg ->tNerd[indexNerd].dades.apuntador == NULL)
  419. {
  420. reg ->tNerd[indexNerd].dades.apuntador = Sprite_Create("data/nerd1/nerd_standing/nerd0000.png");
  421. }
  422. }
  423. int UltimNerdCreat(struct regInfo *reg, int maximNerds)
  424. // Retorna ultim nerd creat o -1 si no n'hi ha cap de creat
  425. {
  426. while (!reg ->tNerd[maximNerds].graficNerdActiu && maximNerds >= 0)
  427. maximNerds--;
  428. return maximNerds;
  429. }
  430.  
  431. /* ===================================
  432. ============ TO DO LIST ===========
  433. =================================== #TODO
  434. -Coses fetes:
  435. * fer que zombies i nerds apareguin en multiples de y (fet)
  436. * background (fet)
  437. * ficar un registre extra amb una taula per permetre tindre fins a 10 zombies (fet)
  438. * boto dret --> elimini l'ultim zombie creat (fet)
  439. * fer 2 registres diferents: un pels zombies i l'altre pels nerds (fet)
  440. * implementar xocs (fet)
  441. * dintre de DRAW pintar tots els zombies que tinguin grafics i no nomes zombie[1] (fet)
  442. * dintre de TICK crear mes de un zombie (fet)
  443. * implementar sistema d'aleatorietat perque no surtin tots de cop (fet)
  444. * implementar dispars (fet)
  445. * comprovar a funcio tick mes o menys com el xoc de nerds i zombies pero amb dispars (fet)
  446. * pintar-los (fet)
  447. * fer que avancin a cada tick (fet)
  448. * crear estructura per les dades del dispar a part i després incloure-la dins de l'estructura del nerd (fet)
  449. * nerds disparen si i nomes si tenen un zombie al davant (fet)
  450. * a cada tick del programa, actualitzar l'estat de la variable zombieDavant (dintre de Nerd) segons si
  451. cada nerd te (1) o no te (0) un zombie a la mateixa y que ell (fet)
  452. * zombies aguantaran 3 atacs maxim (fet)
  453. * LUXE: implementar-ho amb funcions per separar el codi i d'aquesta manera optimitzar-lo (fet)
  454. ____________________________________________________________________________________________________
  455. ____________________________________________________________________________________________________
  456. -Coses per fer:
  457. */

Report this snippet  

You need to login to post a comment.