Eliminar procesos o sprites SDL C++

[blacklotus.938]

Hola colegas,soy nuevo en este foro me acabo de registrar hoy ,espero que puedan ayudarme con mi problemita. Hace un mes que empeze a programar con sdl y hacia programas (no puedo decir que son juegos si no tienen todas las caracteristicas para llamarlo asi). En este hay un sprite (cuadrado gris) que colisiona con un rectangulo negro,lo que quiero hacer es que cuando el sprite colisione con el rectangulo el sprite desaparesca.Un ejemplo de esto es el clasico mario bros, que cuando mario salta para coger una moneda ,el hud que indica cuantas monedas llevo se incrementa dependiendo el numero de monedas que coja mario y luego las monedas desaparecen.Lo que quiero hacer es que el objeto que valla a coger desaparesca al momento de ser tocado por el sprite. he intentando buscar algo sobre esto pero no he encontrado nada y tampoco tengo ni idea de como hacer esto. Si hay alguien que sepa como hacer esto por favor que me de un ejemplo o alguna pagina en donde pueda encontrar esto, aqui les dejo un codigo fuente traducido en español basado en los tutoriales de un colega gringo :

Código: Seleccionar todo


#include <stdio.h>
#include <iostream>
#include <SDL.h>

void teclado();
bool colision( SDL_Rect A, SDL_Rect B );

SDL_Surface *pantalla;

SDL_Rect rectangulo_1;
SDL_Rect rectangulo_2;
SDL_Rect pantalla_r;

SDL_Event evento;

bool salir = false;
char TITULO[]="PROGRAMA DE MANEJO DE PROCESOS 30-OCT-2012";
int vel_x;
int vel_y;
int vel = 3;

const int PANTALLA_ALTO = 800;
const int PANTALLA_ANCHO = 600;

int main( int argc, char *argv[] )
{

   SDL_Init( SDL_INIT_VIDEO );
   SDL_WM_SetCaption( TITULO, NULL );
   pantalla = SDL_SetVideoMode(PANTALLA_ALTO,PANTALLA_ANCHO,24,SDL_HWSURFACE);

   rectangulo_1.x = 0;
   rectangulo_1.y = 0;
   rectangulo_1.w = 50;
   rectangulo_1.h = 50;

   rectangulo_2.x = 350;
   rectangulo_2.y = 300;
   rectangulo_2.w = 300;
   rectangulo_2.h = 50;

   pantalla_r.x = 0;
   pantalla_r.y = 0;
   pantalla_r.w = pantalla->w;
   pantalla_r.h = pantalla->h;



   while( salir==false)
   {

      while( SDL_PollEvent( &evento ) )
        {
         
         teclado();
         if( evento.type == SDL_QUIT ){ salir = true; }
         if(evento.key.keysym.sym == SDLK_ESCAPE ){ salir = true;}

      }

      rectangulo_1.x += vel_x;
      rectangulo_1.y += vel_y;

      if ( colision( rectangulo_1, rectangulo_2 ) ){ rectangulo_1.x -= vel_x; rectangulo_1.y -= vel_y; }
      if(rectangulo_1.x<0)rectangulo_1.x=0;
      if(rectangulo_1.x+50>PANTALLA_ALTO)rectangulo_1.x-= vel_x;
      if(rectangulo_1.y<0)rectangulo_1.y=0;
      if(rectangulo_1.y+50>PANTALLA_ANCHO)rectangulo_1.y-= vel_y;

      SDL_FillRect(pantalla,&pantalla_r,SDL_MapRGB(pantalla->format,255,255,255));
      SDL_FillRect(pantalla,&rectangulo_1,SDL_MapRGB(pantalla->format,128,128,128));
      SDL_FillRect(pantalla,&rectangulo_2,SDL_MapRGB(pantalla->format,60,60,60));
      SDL_Flip(pantalla);


   }

   SDL_Quit ();
   return 0;
}

void teclado(){

if( evento.type == SDL_KEYDOWN )
    {
        switch( evento.key.keysym.sym )
        {
            case SDLK_UP: vel_y -= vel; break;
            case SDLK_DOWN: vel_y += vel; break;
            case SDLK_LEFT: vel_x -= vel; break;
            case SDLK_RIGHT: vel_x += vel; break;
      }
    }
   
    else if( evento.type == SDL_KEYUP )
    {
        switch( evento.key.keysym.sym )
        {
            case SDLK_UP: vel_y += vel; break;
            case SDLK_DOWN: vel_y -= vel; break;
            case SDLK_LEFT: vel_x += vel; break;
            case SDLK_RIGHT: vel_x -= vel; break;
      }
    }

}

bool colision( SDL_Rect A, SDL_Rect B )
{
    //Lados de los rectangulos
    int leftA, leftB;
    int rightA, rightB;
    int topA, topB;
    int bottomA, bottomB;

    //Calcular los lados del rectangulo A
    leftA = A.x;
    rightA = A.x + A.w;
    topA = A.y;
    bottomA = A.y + A.h;

    //calcular los lados del rectangulo B
    leftB = B.x;
    rightB = B.x + B.w;
    topB = B.y;
    bottomB = B.y + B.h;

    //Si alguno de los lados de A esta fuera de B
    if( bottomA <= topB ){ return false; }
   if( topA >= bottomB ){ return false; }
   if( rightA <= leftB ){ return false; }
   if( leftA >= rightB ){ return false; }

    //Si ninguno de los lados de A esta fuera de B
    return true;
}



[Barajas]

Hay dos forma de hacer que el objeto "desaparezca".

Imagina que los sprites están contenidos en una lista especifica. Una lista para items como monedas, una lista para enemigos, y una para el personaje-personajes.

Lo que se suele hacer es que cuando digamos, un personaje colisione con item, es retirar ese item de las listas en las que esta contenido, o dejar de llamar a sus metodos. En pseudo código esto serie algo como esto:

Creo lista de items
Creo lista del heroe.
Mientras jugar:
    if heroe choca con items:
        ver con que item esta chocando.
        contador_items += valor_del_item.
        retirar item de la lista.
    dibujar todo lo que esta en la lista items
    actualizar todo lo que esta en la lista items //esto puede ser su animación o movimiento
    dibujar todo lo que esta en la lista del heroe // que es el heroe
    actualizar al heroe
    ...

La segunda forma es asumiendo que es un objeto y que cuando lo tocas, lo borras de la faz de la tierra, pero esto no es recomendable...

Además, no te preocupes por la implementación de la lista, en c++ existe el tipo de dato "vector" y te hace la vida mucho mas fácil, solo búscalo en google.

Y recuerda, estas usando c++, aprovecha las clases y las ventajas del orientado a objetos . Mira cada sprite como un objeto con métodos dibujar y actualizar.

Te complicas mucho las colisiones, me gusta más esta función para ver colisiones entre dos rects en SDL, es menos intuitiva a primera vista, pero mas corta y rápida.

//regresa verdadero si existe una colisión entre dos rects 
int colision(SDL_Rect rect_a,SDL_Rect rect_b){
    return (
        (rect_a.x < rect_b.x + rect_ b.w) &&
        (rect_b.x < rect_a.x + rect_a.w) &&
        (rect_a.y < rect_b.y + rect_b.h) &&
        (rect_b.y < rect_a.y + rect_a.h));
    };

De hecho si me esperas podría darte un ejemplo practico de como se hace, pero ahora no tengo mucho tiempo jeje.

Espero que te sea útil.

[blacklotus.938]

O_o gracias.por tu ayuda colega voy ha intentar hacer lo que pusiste aqui, pero estoy dispuesto a esperar a que me dejes un ejemplo practico . si logro hacer que funcione lo que me dices entoces publicare el codigo aqui en el foro. gracias¡¡¡

[Barajas]

Bien, aquí esta lo que te comentaba de utilizar al máximo las bondades del orientado a objetos y del tipo vector de c++, pero creo que solo tendrás que cambiar la parte en que se incluye la librería SDL.

Dudas, pregunta

using namespace std;
#include <SDL/SDL.h>
#include <stdio.h>
#include <iostream>
#include <math.h>
#include <vector>
#include <time.h> //para la semilla aleatoria...
/*El tamaño de la ventana...*/
#define screenWidth 256
#define screenHeight 256
/* Defino algunos colores que utilizare */
SDL_Color GRIS = {155,155,155};
SDL_Color VERDE = {0,255,0};
SDL_Color AZUL = {0,0,255};
SDL_Color ROJO = {255,0,0};
//*
/* Primero los prototipos de función, por qué, es una buena practica */
//inicializar a SDL
SDL_Surface * inicia(int,int,int,const char*,const char*);
//llenar una superficie...
void fill(SDL_Surface *, SDL_Color); //como amo la sobrecarga de operadores 
void fill(SDL_Surface *, SDL_Color, SDL_Rect);
/******************************************************************************/
//Defino las clases de nuestros personajes... primero, un objeto sprite...
class Sprite{
    SDL_Rect persona;
    SDL_Color color;
    public:
    Sprite(void){
         this->SetPersona(0,0,32,32);
         this->SetColor(ROJO);
         this->SetPos(10,10);
         };
    ~Sprite(void){};
    SDL_Rect GetPersona(void){
        return this->persona;
        };
    void SetPersona(int px, int py, int pw, int ph){
        this->persona.x = px;
        this->persona.y = py;
        this->persona.w = pw;
        this->persona.h = ph;
        }
    void SetColor(SDL_Color color){
        this->color = color;
        }
    void SetPos(int px, int py){
        this->persona.x = px;
        this->persona.y = py;
        }
    virtual void update(void){
         };
    void dibujar(SDL_Surface * pantalla){
         fill(pantalla,this->color,this->GetPersona());
         };
    /**colisión resive un sprite y revisa si choco con el mismo...*/
    bool colision(Sprite sprite_a){
        //obtenemos la rects de los sprites...
        SDL_Rect a = sprite_a.GetPersona();
        SDL_Rect b = this->GetPersona();
        return ((a.x < b.x + b.w) && (b.x < a.x + a.w) && (a.y < b.y + b.h) && (b.y < a.y + a.h));
        }
    };
//ahora defino a los personajes, en este caso... nuestro heroe...
class Heroe:public Sprite{
    int pos_x, pos_y;
    public:
    Heroe(void){
         this->SetPersona(0,0,32,32);
         this->SetColor(VERDE);
         pos_x=100;
         pos_y=100;
         this->SetPos(pos_x,pos_y);
         };
    ~Heroe(void){};
    //**Solo definimos el metodo update, dibujar lo heredan de Sprite...
    void update(){
         Uint8 *keys;
         keys=SDL_GetKeyState(NULL);
         if (keys[SDLK_LEFT] == 1){
             pos_x-=5;
             }
         else if (keys[SDLK_RIGHT] == 1){
             pos_x+=5;
             }
         if (keys[SDLK_UP] == 1){
             pos_y-=5;
             }
         else if (keys[SDLK_DOWN] == 1){
             pos_y+=5;
             }
         this->SetPos(pos_x,pos_y);
         }
    };
//Defino los items...
class Item:public Sprite{
    int pos_x, pos_y;
    int buf, delta;
    public:
    Item(int x, int y){
         this->SetColor(AZUL);
         pos_x=x;
         pos_y=y;
         delta = 1;
         buf = 16;
         this->SetPersona(0,0,buf,buf);
         this->SetPos(pos_x,pos_y);
         };
    ~Item(void){};
    void update(){
         if (buf > 20 || buf < 16 ){
             delta = -delta;
             }
         buf += delta;
         this->SetPersona(0,0,buf,buf);
         this->SetPos(pos_x,pos_y);
         }
    };
/******************************************************************************/
//La función principal...
/******************************************************************************/
int main( int argc, char *argv[] ){
    SDL_Surface *screen;
    screen = inicia(screenWidth,screenHeight,0,"Manejo sprites","Nullo");
    //defino variables para manejar el tiempo...
    Uint32 waittime = 1000/30; // fijo a 30 fps
    Uint32 framestarttime = 0;
    Sint32 delaytime;
    //defino las variables para la entrada...
    Uint8 *keys;
    SDL_Event event;

    //defino al heroe...
    Heroe heroe = Heroe();
    
    //creo los grupos
    //*definimos un vector que contendra Items...
    vector<Item> GItems;
    //* y un que contendra nuestro heroe...
    vector<Heroe> GHeroe;
    
    GHeroe.push_back(heroe);
    //creo 5 items y los agrego a la lista...
    int i;
    srand ( time(NULL) );
    for(i=0;i<10;i++){
        //colocamos los items de manera aleatoria...
        Item it(Item(10+(rand()%screenHeight-20), //pos en x
                       10+(rand()%screenHeight-20))); // pos en y
        GItems.push_back(it);
        }
    // una variable que sostiene el bucle...
    bool jugar = 1;
    while(jugar){
        //lo siguiente mantiene el framerate constante...
        delaytime = waittime - (SDL_GetTicks() - framestarttime);
        if(delaytime > 0){
            SDL_Delay((Uint32)delaytime);}
        framestarttime = SDL_GetTicks();
        fill(screen,GRIS);
        
        //dibujo todos los objetos contenidos en el grupo GItems...
        for(i=0;i<GItems.size();i++){
            GItems[i].update();
            GItems[i].dibujar(screen);
            //si hay una colisión con el heroe, removemos el item de la lista...
            if (GItems[i].colision(heroe)){
                cout << "colision con item " << endl;
                GItems.erase(GItems.begin()+i);
                }
            }
        /*
        actualizamos y dibujamos al heroe....
        */
        heroe.dibujar(screen);
        heroe.update();
        
        SDL_Flip(screen);
        //y esto revisa los eventos de las teclas y eventos
        keys=SDL_GetKeyState(NULL);
        while ( SDL_PollEvent(&event) ) {
            //si se presiona la tecla escape, o hay un evento de cierre...
            if ( (event.type == SDL_KEYDOWN && keys[SDLK_ESCAPE] == 1) || (event.type == SDL_QUIT) ){
                jugar = 0; //cerrara el programa
                }
            }
        //termina el bucle de juego...
        }
    //limpiamos la casa...
    SDL_Quit();
    //...salimos.
    return 0;
    };
/******************************************************************************/
/**
    Las funciones las suelo declarar después del main....
**/
/******************************************************************************/
SDL_Surface * inicia(int W, int H,int Full, const char *title,const char *ico){
    // Iniciar SDL
    SDL_Surface *temp;
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        exit(1);
        }
    // Activamos modo de video
    if(Full){ }
    else{
        temp = SDL_SetVideoMode(W,H,32,SDL_HWSURFACE);
        if (temp == NULL) {
            exit(1);
            }
        }
    SDL_WM_SetCaption(title, ico);
    return temp;
    }
//------
void fill(SDL_Surface * surf, SDL_Color color) {
    //cout << ">> La imagen se llena de color " << surf->w << endl;
    SDL_Rect Rect = {0,0,surf->w,surf->h};
    SDL_FillRect(surf, &Rect, SDL_MapRGBA(surf->format,color.r,color.g,color.b,255) );
    };
void fill(SDL_Surface * surf, SDL_Color color, SDL_Rect rect){
    SDL_FillRect(surf, &rect, SDL_MapRGBA(surf->format,color.r,color.g,color.b,255) );
    };
//------

[blacklotus.938]

wauuuuu men gracias te lo agredasco mucho , sobre todo por sacar de tu tiempo para hacer este codigo. hay unas cosas que no entiendo pero empezare a investigarlas desde hoy , gracias por tu atencion, te lo agradesco mucho personas como tu que ayuden a la gente son las que necesita este mundo. si logro hacer mi propia version de tu codigo lo subire aqui para que todos lo vean gracias men. te avisare si me funciona . estare en contacto

[blacklotus.938]

Hola colegas , como dije , subi el codigo de mi propia version de "eleminar enemigos" , si lo compilan todo parece estar bien a simple vista pero no es asi, cuando el PJ colisiona con los enemigos el "grafico" de este desaparece pero el rectangulo que define al enemigo sigue hay, si descomentan la linea de codigo que esta en donde se comprueba la colision ( la linea de codigo hace que se detenga el PJ) veran que el grafico desaparece pero el PJ no se puede mover por que ahi, era en done estaba el rectangulo. Creo que este es el problema al que se referia el colega BARAJAS. Ahora BRARAJAS me dijiste que aprovechara las ventajas de POO pero es que yo apenas estoy empezando en la programacion y no entiendo mucho de clases , por eso ves que los programas que hago las funciones y todo eso estan por su parte, to davia no profundizo con el tema de las clases . Ahora el codigo que pusiste no lo logro entender bien, intente implementar la clase vector en mi codigo pero no me funcionaba . Si pudieras decirme un metodo para eleminar la estructura que define las dimensiones del enemigo sin utilizar la clase vector ya no te pediria mas o podrias modificar el codigo agregandole la clase vector:

#include <stdio.h> 
#include <iostream> 
#include <time.h>
#include <stdlib.h>
#include <SDL.h>

typedef struct enemigo
{
	SDL_Rect sprite;
	int enemigo_vivo;


}Enemigo;

void Teclado();
bool colision( SDL_Rect A, SDL_Rect B ); 

const int PANTALLA_ANCHO = 800; 
const int PANTALLA_ALTO = 600; 
const int VEL_MAX = 3;
const int MAX_ENEMIGOS = 15;

SDL_Surface *pantalla; 
SDL_Rect pantalla_rect;
SDL_Rect PJ;
Enemigo enemigo[MAX_ENEMIGOS];
SDL_Event evento; 

bool salir = false; 
char TITULO[]="PROGRAMA DE MANEJO DE PROCESOS 23-DIC-2012"; 

int vel_x;
int vel_y;

using namespace std;

int main( int argc, char *argv[] ) 
{ 

   SDL_Init( SDL_INIT_VIDEO ); 
   SDL_WM_SetCaption( TITULO, NULL ); 
   pantalla = SDL_SetVideoMode(PANTALLA_ANCHO,PANTALLA_ALTO,24,SDL_HWSURFACE); 

   srand(time(NULL));

   pantalla_rect.x = 0;
   pantalla_rect.y = 0;
   pantalla_rect.w = PANTALLA_ANCHO;
   pantalla_rect.h = PANTALLA_ALTO;

   PJ.x = 0;
   PJ.y = 0;
   PJ.w = 50;
   PJ.h = 50;

   for( int i = 0; i<MAX_ENEMIGOS;i++)
   {
	

   enemigo[i].sprite.x = rand()%801;
   enemigo[i].sprite.y = rand()%601;
   enemigo[i].sprite.w = 50;
   enemigo[i].sprite.h = 50;
   enemigo[i].enemigo_vivo = 1;

   }

   

   while( salir==false) 
   { 

      while( SDL_PollEvent( &evento ) ) 
        { 
          
		 Teclado();	
         if( evento.type == SDL_QUIT ){ salir = true; } 
         if(evento.key.keysym.sym == SDLK_ESCAPE ){ salir = true;} 

      } 

	  PJ.x += vel_x; 
      PJ.y += vel_y; 

	  //if( colision(PJ,enemigo[3] )){ PJ.x -= vel_x;  PJ.y -= vel_y;  }

	  for(int i = 0; i<MAX_ENEMIGOS;i++)
	  {

		  if(colision(PJ,enemigo[i].sprite))
		  {
			  enemigo[i].enemigo_vivo = 0;
			  //PJ.x -= vel_x;
			  //PJ.y -= vel_y;
			  cout << "El PJ colisiono con el enemigo # " << i << endl;
		  }

	  }

	  
      
      if(PJ.x<0)PJ.x=0; 
      if(PJ.x+50>PANTALLA_ANCHO)PJ.x-= vel_x; 
      if(PJ.y<0)PJ.y=0; 
      if(PJ.y+50>PANTALLA_ALTO)PJ.y-= vel_y; 

      SDL_FillRect(pantalla,&pantalla_rect,SDL_MapRGB(pantalla->format,255,255,255)); 
	  SDL_FillRect(pantalla,&PJ,SDL_MapRGB(pantalla->format,92,163,99)); 

	  for(int i = 0; i<MAX_ENEMIGOS;i++)
	  {
		  if(enemigo[i].enemigo_vivo == 1)
		  {
		  SDL_FillRect(pantalla,&enemigo[i].sprite,SDL_MapRGB(pantalla->format,241,80,88)); 


		  }
	  }
	  
	  SDL_Flip( pantalla );

   } 

   SDL_Quit (); 
   return 0; 
} 

void Teclado(){ 

if( evento.type == SDL_KEYDOWN ) 
    { 
        switch( evento.key.keysym.sym ) 
        { 
			case SDLK_UP: vel_y -= VEL_MAX; break; 
            case SDLK_DOWN: vel_y += VEL_MAX; break; 
            case SDLK_LEFT: vel_x -= VEL_MAX; break; 
            case SDLK_RIGHT: vel_x += VEL_MAX; break; 
      } 
    } 
    
    else if( evento.type == SDL_KEYUP ) 
    { 
        switch( evento.key.keysym.sym ) 
        { 
            case SDLK_UP: vel_y += VEL_MAX; break; 
            case SDLK_DOWN: vel_y -= VEL_MAX; break; 
            case SDLK_LEFT: vel_x += VEL_MAX; break; 
            case SDLK_RIGHT: vel_x -= VEL_MAX; break; 
      } 
    } 

} 

bool colision( SDL_Rect A, SDL_Rect B ) 
{ 
    //Lados de los rectangulos 
    int leftA, leftB; 
    int rightA, rightB; 
    int topA, topB; 
    int bottomA, bottomB; 

    //Calcular los lados del rectangulo A 
    leftA = A.x; 
    rightA = A.x + A.w; 
    topA = A.y; 
    bottomA = A.y + A.h; 

    //calcular los lados del rectangulo B 
    leftB = B.x; 
    rightB = B.x + B.w; 
    topB = B.y; 
    bottomB = B.y + B.h; 

    //Si alguno de los lados de A esta fuera de B 
    if( bottomA <= topB ){ return false; } 
   if( topA >= bottomB ){ return false; } 
   if( rightA <= leftB ){ return false; } 
   if( leftA >= rightB ){ return false; } 

    //Si ninguno de los lados de A esta fuera de B 
    return true; 
}

[Barajas]

Ahora BRARAJAS me dijiste que aprovechara las ventajas de POO pero es que yo apenas estoy empezando en la programacion y no entiendo mucho de clases , por eso ves que los programas que hago las funciones y todo eso estan por su parte, to davia no profundizo con el tema de las clases .

Bueno, en ese caso, te recomiendo que busques un libro llamado "el lenguaje de programación c", de Kernighan y Ritchie, y veas la sección sobre estructuras. (Entender estructuras te hara mucho más sencillo entender los objetos.)

Las estructuras ("structs"), te permiten empaquetar datos de diferentes tipos, incluso otras estructuras, y para trabajar con ellas utilizas funciones.

hora el codigo que pusiste no lo logro entender bien, intente implementar la clase vector en mi codigo pero no me funcionaba . Si pudieras decirme un metodo para eliminar la estructura que define las dimensiones del enemigo sin utilizar la clase vector

La razón para utilizar vector, es que me evita tener que reintentar la rueda implementando una lista (y no es que sea difícil implementar una lista, el problema es que eso aumentaría el código y su dificultad).

Pero bueno, si tienes dudas sobre como funciona vector puedes ver la referencia de todo lo que puede hacer (en ingles) http://www.cplusplus.com/reference/vector/vector/

Si pudieras decirme un metodo para eleminar la estructura que define las dimensiones del enemigo sin utilizar la clase vector ya no te pediria mas o podrias modificar el codigo agregandole la clase vector:

Y si no quieres usar vetor, ni implementar tu propia lista, puedes usar un array de tamaño fijo, y todo tenga una bandera logica si es "visible o invisible". Por suerte, tengo un ejemplo de eso..

http://db.tt/FUaPUReV

Espero que te sea útil.

[blacklotus.938]

Oh gracias colega perdon por no responderte antes es que estaba de vacaciones jeje . En fin eh encontrado por hay varios metodos para hacer lo que quiero hacer pero tengo que analizar a ver como funcionan.No pude compilar el codigo que pusistes hay , pero de todos modos gracias colega