src/explos.c

   1 /*-------------------------------------------------------
   2  explos.c
   3  --------------------------------------------------------
   4  Copyright (c) 2002, Kronoman
   5  En memoria de mi querido padre
   6  Agosto - 2002
   7  --------------------------------------------------------
   8  Engine de explosiones usando una lista enlazada
   9  muy sencilla, sirve para muchas capas de explosiones
  10  mediante el uso de punteros.
  11  --------------------------------------------------------*/
  12
  13 #ifndef EXPLOS_C
  14 #define EXPLOS_C
  15
  16 #include <stdio.h>
  17 #include "allegro.h"
  18
  19 #include "explos.h"
  20
  21 /* esta variable NO es necesaria, solo la uso para
  22    ver cuantos enemigos hay en memoria, y de esa manera,
  23    revisar la performance... */
  24 int cant_explosion_debug = 0;
  25
  26
  27 /* --- globales internas --- */
  28
  29 /* Cache de imagenes y sonidos, para el combo de explosion */
  30 BITMAP *explo_cache_bmp[3];
  31 SAMPLE *explo_cache_snd[3];
  32
  33 /* No hay puntero al 1er item de la lista, debe crearse,
  34    permite usar muchas listas a la vez! */
  35
  36 /* Estos dos punteros deben ser puestos cada vez que se quieren usar
  37    en las diferentes llamadas */
  38 EXPLOSION *ptr_explo_fondo = NULL;
  39 EXPLOSION *ptr_explo_arriba = NULL;
  40
  41 /*----
  42 Esta funcion agrega una nueva explosion a la lista enlazada [al principio].
  43 PASARLE el puntero a la primera de la lista como &puntero!
  44 ----*/
  45 void       agrega_explosion( EXPLOSION **prt_1era,
  46                              fixed x,  fixed y,
  47                              fixed dx, fixed dy,
  48                              int vida,
  49                              fixed r, fixed dr,
  50                              int rot,
  51                              BITMAP *spr ) {
  52
  53     EXPLOSION *nueva = (EXPLOSION *)malloc(sizeof(EXPLOSION));
  54     nueva->next = *prt_1era;
  55     *prt_1era = nueva;
  56
  57     if (nueva != NULL) /* si el malloc funciono, seteo los datos... */
  58     {
  59         nueva->x = x;
  60         nueva->y = y;
  61         nueva->dx = dx;
  62         nueva->dy = dy;
  63         nueva->vida = vida;
  64         nueva->r = r;
  65         nueva->dr = dr;
  66         nueva->rot = rot;
  67         nueva->spr = spr;
  68     }
  69
  70 }
  71
  72 /*
  73    Esta funcion actualiza la logica (mueve)
  74    tambien las elimina si vida < 0
  75    pasarle el puntero con &puntero
  76    */
  77 void mover_explosiones(EXPLOSION **prt_1era) {
  78     EXPLOSION **tmp_p = prt_1era;
  79     EXPLOSION *tmp = NULL;
  80
  81     cant_explosion_debug = 0; /* DEBUG: innecesario */
  82
  83     while (*tmp_p) {
  84
  85         cant_explosion_debug++; /* DEBUG: innecesario */
  86
  87         tmp = *tmp_p;
  88
  89         /* aqui muevo */
  90         tmp->x = fixadd(tmp->x, tmp->dx);
  91         tmp->y = fixadd(tmp->y, tmp->dy);
  92
  93         tmp->vida--;
  94
  95         /* girar sprite  */
  96         tmp->rot += rand()%32+1; /* girar */
  97         if (tmp->rot > 255) tmp->rot = 0;
  98
  99         /* decrementar */
 100         tmp->r = fixsub(tmp->r, tmp->dr);
 101
 102         if (tmp->r < ftofix(0.001) ) tmp->vida = -1; /* se extinguio... */
 103
 104         if (tmp->vida < 0) {
 105           /* murio, eliminar!!! */
 106           *tmp_p = tmp->next;
 107           free(tmp);
 108         } else {
 109             tmp_p = &tmp->next; /* siguiente por favor! */
 110         }
 111     }
 112 }
 113
 114 /*
 115    Esta funcion dibuja en el bitmap bmp
 116    Las dibuja desplazadas x,y
 117    */
 118 void dibujar_explosion(EXPLOSION *prt_1era, BITMAP *bmp, int x, int y) {
 119
 120     EXPLOSION *tmp = prt_1era;
 121
 122 /* calculos */
 123 int x2, y2;
 124
 125
 126  while (tmp) {
 127
 128       x2 = fixtoi(tmp->x)-x;
 129       x2 -= fixtoi(fmul(itofix(tmp->spr->w), tmp->r))/2;
 130
 131       y2 = fixtoi(tmp->y)-y;
 132       y2 -= fixtoi(fmul(itofix(tmp->spr->h), tmp->r))/2;
 133
 134       /* dibujar */
 135       rotate_scaled_sprite(bmp, tmp->spr, x2, y2, itofix(tmp->rot), tmp->r);
 136
 137       tmp = tmp->next; /* proximo... */
 138   }
 139 }
 140
 141 /* Esta funcion se debe llamar cuando no se precise mas la lista
 142    Libera la RAM usada y reinicia la lista
 143    pasar el puntero asi &puntero
 144    */
 145 void liberar_lista_explosion(EXPLOSION **prt_1era) {
 146     EXPLOSION *tmp = *prt_1era;
 147     *prt_1era = NULL;
 148
 149     while (tmp) {
 150         EXPLOSION *next = tmp->next;
 151         free(tmp);
 152         tmp = next;
 153     }
 154
 155 }
 156
 157 #endif