Como borrar las balas¿?

[sofoke]

Actualmente estoy desarrollando un juego de aviones...
y el problema es que cuando la nave dispara y una de las balas ya a colisionado como hago para borrarla...
Las balas las manejo en una estructura...

struct balas{
int x, y, activa;
};
struct balas Balas[100];

La verdad no tengo idea de si esta es una buena opcion (a la estructura me refiero)
segun yo tendria que crear una funcion para crear la bala una para moverla y una para detectar la colision...Ahora hay otro problema, como seria la estructura de esta ultima¿?

[hugoruscitti]

Saludos, para mí la estructura está bien. Si estás utilizando
ANSI C (y no C++) tal vez te sirva seguir un estilo de programación
que se denomina "modularizada". La idea consiste en crear
estructuras que representen los elementos de tu juego (un disparo,
un personaje...) y un conjunto de funciones que te permita
manipularlas.

La ventana principal de esta forma de escribir programas en C
se observa en la claridad de transmite el código, te facilita hacer
cambios en cualquier momento y es consistente. Por ejemplo,
en este caso, yo crearía un módulo "Disparo" y funciones que
tengan nombres como "disparo_crear",
"disparo_detectar_colisiones" ... etc. Cada una de estas funciones
recibe como primer parámetro un disparo. Te dejo un pequeño
programa de ejemplo, ten en cuenta que lo escribí directamente
en el foro: solo es ilustrativo (no compila, ni funciona). Solo te
será útil para observar en que consisten los módulos:

Código: Seleccionar todo

/*
* Representa un disparo que puede eliminar enemigos
*/
typedef struct disparo_t
{
    int x;
    int y;
    SDL_Surface * image;
    int velocity;
} Disparo;


/*
* Genera un modulo Disparo y le asigna propiedades iniciales.
*/
Disparo * disparo_crear(int x, int x, int velocity)
{
    Disparo * nuevo = (Disparo *) malloc(sizeof(Disparo));

    nuevo->x = x;
    nuevo->y = y;
    nuevo->image = SDL_LoadBMP("disparo.bmp");
    nuevo->velocity = velocity;

    return nuevo;
}


/*
* Dibuja el disparo sobre una superficie.
*/
void disparo_draw(Disparo * data, SDL_surface * screen)
{
    SDL_Rect destino = {data->x, data->y, 0, 0};

    SDL_BlitSurface(data->image, NULL, screen, &destino);
}

/*
* Actualiza la posición del disparo y verifica colisiones con los enemigos.
*/
void disparo_update(Disparo * data, Enemigo * enemigos, int cantidad_enemigos)
{
    int i;
    data->y -= data->velocidad;

    /* verifica colisiones con todos los enemigos.
     * si se presenta una colision hace 'explotar' al enemigo y desaparece
     * al disparo. */
    for (i=0; i<cantidad_enemigos; i++)
    {
        if (disparo_colisiona_con(data, enemigos[i]))
        {
            enemigo_explotar(enemigos[i]);
            disparo_desaparecer(data);
            return;
        }
    }
}

/*
* Programa de prueba (sin terminar, solo ilustrativo).
*
* Genera 5 enemigos y un solo disparo.
*/
int main(void)
{
    Disparo * d1 = NULL;
    Enemigo * enemigos[5];
    int i;
   
    /* [...] codigo que define el modo de video en `screen` */

    /* genera un disparo que "debería" colisionar con alguna nave. */
    d1 = disparo_crear(60, 200, -1);

    /* genera 5 enemigos alineados en y=30, separados por 40 pixeles en x */
    for (i=0, i<5; i++)
        enemigos[i] = enemigo_crear(40 * i, 30)

    /* Bucle del programa */
    while (! salir)
    {
        /* actualización de elementos de juego */
        disparo_update(d1, enemigos, 5);

        for (i=0, i<5; i++)
            enemigo_update(enemigos[i]);

        /* actualización de la pantalla */
        disparo_draw(d1, screen)

        for (i=0, i<5; i++)
            enemigo_draw(enemigos[i], screen);
    }


    /* libera memoria de los modulos */
    disparo_free(d1);

    for (i=0; i>5; i++)
        enemigo_free(enemigos[i]);

    return 0;
}

Si quieres un ejemplo de módulos que funciona, podrías descargar
el juego "pocket volleyball", ese juego usa módulos para cada
elemento del juego:

http://www.losersjuegos.com.ar/juegos/v ... eyball.php

Saludos.

[sofoke]

Me parece una muy buena opción... Ahora el problema es:
que ha decir verdad con eso de: modularizada no tengo idea alguna de como funciona
Esta forma de rpogramar es valida solo para C o tambien para C++¿?
Porias poner un link hacia algo de referencía...

[hugoruscitti]

Esta forma de rpogramar es valida solo para C o tambien para C++¿?

Solo es recomendada cuando se está trabajando con ANSI C,
es decir, solo C. En el caso de utilizar C++ es recomendable crear
Objetos en lugar de modulos, y métodos en lugar de funciones
claro.

Te dejo algunos sitios de referencia (sin un orden especifico):

http://teleformacion.edu.aytolacoruna.e ... odular.htm
http://es.wikipedia.org/wiki/Programaci%C3%B3n_modular
http://www.desarrolloweb.com/articulos/2477.php

Saludos.

[sofoke]

Que buen aporte
Gracias y estoy checando los enlaces y son de muy buena ayuda...
espero si tengo alguna traba poder recivir + ayuda...
Ahora... sería buena idea solo crear como dije al principio crear solo funciones que se encargen de hacer todo lo necesario para esta opcion... en este caso mover crear y destruir la bala...
ahora si es correcta mi apreciasion, afectaria la velocidad del juego¿?
y/o ensancharia el ejecutable¿? o hay alguna otra desventaja¿?

[hugoruscitti]

...
ahora si es correcta mi apreciasion, afectaria la velocidad del juego¿?
y/o ensancharia el ejecutable¿? o hay alguna otra desventaja¿?

No, no afectaría la ejecución del juego ni el tamaño del programa (de manera
considerable). Ten en cuenta que cualquier equipo es lo suficientemente
rápido para correr casi cualquier cosa en C o C++, se que suena muy general
pero casi siempre se cumple.

Mi recomendación es que sigas una forma de programar que brinde resultados
para tí y a los usuarios de juego que tengas en mente. Siempre es mejor
un juego funcionando que un prototipo rápido, el prototipo ni siquiera es un
juego...

Existe un buena recomendación para programadores que indica: "no es bueno
optimizar antes de tiempo". Esto es gran consejo para todos los que
empezamos a programar y perdemos mucho tiempo buscando el mejor algoritmo
o consumir la menor cantidad de recursos. Te dejo un conjunto de pautas
y recomendaciones al respecto por parte del equipo de programación de GNOME:

http://www.calcifer.org/documentos/prog ... mance.html

Saludos.