Mapa de tiles en SDL

[RafaG]

Estoy intentando hacer un juego con un mapa hecho con tiles con SDL en C++. Pero no consigo hacerlo. He hecho que se imprima en la pantalla los tiles, pero creo que el sistema que he utilizado no es muy bueno:

Código: Seleccionar todo

void Imprimir()
{
    while (1) //Hasta que no se hayan impreso todos los tiles no sale del bucle.
    {
        if (x!=9)
        {
            x++;
            PosTiles.x+=50;
        }
        else
        {
            if (y!=9)
            {
                x=0;
                PosTiles.x=0;
                y++;
                PosTiles.y+=50;
            }
            else
            {
                break; //Sale del bucle.
            }
        }
        if (MAP1[y][x]==0) //Dedice que imagen hay que imprimir
        {
            PosTilesR.x=0;
            PosTilesR.w=50;
        }
        if (MAP1[y][x]==1)
        {
            PosTilesR.x=50;
            PosTilesR.w=100;
        }

        SDL_BlitSurface(tiles,&PosTilesR,pantalla,&PosTiles);
    }
    SDL_BlitSurface(personaje1,&PosPersonaje1R,pantalla,&PosPersonaje1);
    SDL_Flip(pantalla);
}


No es bueno el código, al mover el personaje no se ve fluido. Tampoco se me ocurre un modo de detectar colisiones.

Miré el ejemplo de Colisión de plataformas pero me cuesta entender tanto código que no he escrito yo.

A ver si alguien me da la teoría, o un ejemplo sencillo, para:
-Imprimir tiles (de un buen modo).
-Detectar colisiones con los tiles.

Luego intentaré ponerlo en práctica. El juego no será de plataformas, la vista será desde arriba (http://i37.tinypic.com/10e3db8.jpg), así que no necesita nada de gravedad.

Saludos y gracias.

[hugoruscitti]

Hola, como estas?

En la web hay un ejemplo llamado "scroll suave" y tiene una rutina que te puede
servir.

La rutina se encarga de imprimir todo el escenario de tiles sobre la pantalla
usando una matriz:

Código: Seleccionar todo

void imprimir_escenario (SDL_Surface * screen, SDL_Surface * ima, int x, int y)
{
   static char mapa [FILAS_MAPA] [COLUMNAS_MAPA + 1] = {
      "00000002115000000211",
      "00000002115000000211",
      "00000002115000000211",
      "00000002115000000211",
      "33333334116333333411",
      "11111111111111111111",
      "11111111111111111111",
      "11111111111111111111",
      "11111111111111111111",
      "11111111111111111111"};
   int i;
   int j;
   int fila = y / ALTO_TILE;
   int columna = x / ANCHO_TILE;
   int desplazamiento_x = x % ANCHO_TILE;
   int desplazamiento_y = y % ALTO_TILE;
   
   for (i = 0; i < 6; i ++)
   {
      for (j = 0; j < 8; j ++)
      {
         imprimir_grilla (screen, ima,
               mapa [fila + i] [columna + j] - '0',
               COLUMNAS_TILES,
               j * ANCHO_TILE - desplazamiento_x,
               i * ALTO_TILE - desplazamiento_y);
      }
   }
   
}

void imprimir_grilla (SDL_Surface * screen, SDL_Surface * src, int cuadro,
      int cols, int x, int y)
{
   int w = src->w / cols;
   SDL_Rect fuente = {cuadro * w, 0, w, src->h};
   SDL_Rect rect = {x, y, 0, 0};
   
   if (cuadro < 0 || cuadro > cols)
   {
      printf ("No se puede imprimir el cuadro %d\n", cuadro);
      return;
   }
   
   SDL_BlitSurface (src, & fuente,   screen, &rect);
}


Con la diferencia que en tu código no creo que uses las variables "desplazamiento_x" y "desplazamiento_y". A menos
que quieras mover un cámara o algo así...

La página donde puedes encontrar el ejemplo es:

http://www.losersjuegos.com.ar/referencia/ejemplos

y en particular el ejemplo es:

http://www.losersjuegos.com.ar/_media/r ... oll.tar.gz

hay otros ejemplos que también usan una técnica muy parecida, pero están en python y no
en C. Si algún voluntario se anima a traducirlos bienvenido...

[adrigm77]

Si quieres que tenga Scroll, detención de colisiones, capas y demás no es algo trivial. pero quizás esto te sirva:

http://www.wired-weasel.com/users/serhi ... /tut4.html

[RafaG]

Gracias al tutorial de adrigm77 ahora entiendo mejor el ejemplo de Hugo, pero sigo sin saber nada de las colisiones. Alomojor logro averiguarlo solo, pero no estoy seguro.

Por cierto Hugo, no logro comprender el tercer parámetro que le pasas a imprimir_grilla(). Se que es para elegir el cuadro que será impreso, pero no entiendo: mapa [fila + i] [columna + j] - '0'

¿No se supone que hay que pasarle un int? mapa[x][y] es char.

[hugoruscitti]

Por cierto Hugo, no logro comprender el tercer parámetro que le pasas a imprimir_grilla(). Se que es para elegir el cuadro que será impreso, pero no entiendo: mapa [fila + i] [columna + j] - '0'

¿No se supone que hay que pasarle un int? mapa[x][y] es char.

Buenas, en principio si. La función tiene que recibir un número, que podría ser
un int. Solo que C trata a los char también como números, y a veces son mas convenientes
que los enteros. Te comento por qué:

La grilla la estoy tratando como una cadena, así me resulta mas sencillo indicar como es
toda una fila del mapa "01000234", el problema es que para C estos valores son como
un vector de números, donde cada elemento es el valor ascii de cada caracter: [48, 19, 48 ...etc]

Entonces, en esa función que imprime, no me gustaría usar el valor 48 sino 0, pero como
'0' es un char (y vale 48) lo tengo que llevar a 0, eso se puede hacer con la
sentencia "variable - '0'". Luego si tienes " '4' - '0' " el resultado sería 4 (pero como entero
y no como caracter.

No se si lo he explicado bien, es medio complicado, pero ante dudas preguntame nuevamente y
lo explico desde otro enfoque.

Saludos.

[RafaG]

Ya he conseguido imprimir los tiles, por fin.

Edito: Ya solo me queda detectar colisiones, ¿alguna idea?

Este es el código:

Código: Seleccionar todo

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

#define ANCHO_MAPA 20
#define ALTO_MAPA 20
#define ANCHO_TILE 30
#define LAT_DERECHO ANCHO_TILE*ANCHO_MAPA
#define LAT_INFERIOR ANCHO_TILE*ALTO_MAPA
#define VELOCIDAD 8

#define C 1

void Cargar();

void Imprimir();
void Mover();

class Camara
{
    public:
        int X;
        int Y;
};
class Personaje
{
    public:
        int x,y;
        SDL_Surface*img;
};

SDL_Surface*pantalla,*tiles;
SDL_Rect PosTiles, PosTilesR,PosBola;
Camara Camara;
Personaje Personaje;
Uint8 *tecla;
int ELSE=1;
int x=0,y=0;


int map[ALTO_MAPA][ANCHO_MAPA]=
{
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,C,0,0,0,0,0,0,0,0,0,0,0,C,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,C,C,C,C,0,0,0,0,0,0,0,0},
    {0,0,C,0,0,0,0,C,0,0,0,0,C,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,C,0,C,0,0,C,0,C,0,0,0,0,0,0},
    {0,0,0,0,0,0,C,0,0,0,0,0,0,C,0,0,0,0,0,0},
    {0,0,0,0,0,0,C,0,C,0,0,C,0,C,0,0,0,0,0,0},
    {0,0,0,0,0,0,C,0,0,C,C,0,0,C,0,0,0,0,0,0},
    {0,0,C,0,0,0,0,C,0,0,0,0,C,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,C,C,C,C,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,C,0,0,0,0},
    {0,0,0,0,0,C,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,C,0,0,0,0,0,0,0,0,C,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
};

int main ( int argc, char** argv )
{
    Cargar();

    while (1)
    {
        Mover();
        Imprimir();
        SDL_Delay(10);
    }
    return 0;
}

void Imprimir()
{
    SDL_FillRect(pantalla,NULL,0);
    for (y=0; y<ALTO_MAPA; y++)
    {
        for (x=0; x<ANCHO_MAPA; x++)
        {
            if (map[y][x]==0)
            {
                PosTilesR.x=0;
                PosTilesR.y=0;
                PosTilesR.w=ANCHO_TILE;
                PosTilesR.h=ANCHO_TILE;
            }
            if (map[y][x]==C)
            {
                PosTilesR.x=ANCHO_TILE;
                PosTilesR.y=0;
                PosTilesR.w=ANCHO_TILE*2;
                PosTilesR.h=ANCHO_TILE;
            }
            PosTiles.x=x*ANCHO_TILE-Camara.X;
            PosTiles.y=y*ANCHO_TILE-Camara.Y;
            if (PosTiles.x>=-(ANCHO_TILE)&& PosTiles.x<=200+ANCHO_TILE&&PosTiles.y>=-(ANCHO_TILE)&& PosTiles.y<=200)
            {
                SDL_BlitSurface(tiles,&PosTilesR,pantalla,&PosTiles);
            }
        }
    }
    SDL_BlitSurface(Personaje.img,NULL,pantalla,&PosBola);
    SDL_Flip(pantalla);
}
void Mover()
{
    PosBola.x=Personaje.x;
    PosBola.y=Personaje.y;

    SDL_PumpEvents();
    tecla=SDL_GetKeyState(NULL);

    if (tecla[SDLK_ESCAPE])
    {
        exit(1);
    }

    ///******************************************///
    if (tecla[SDLK_UP])
    {
        //Personaje.y+=VELOCIDAD;
        if (Camara.Y>0)
        {
            Camara.Y-=VELOCIDAD;
        }
        if (Personaje.y>(200/2)-(Personaje.img->w/2))
        {
            Personaje.y-=VELOCIDAD;
        }
        if (Camara.Y==0 && Personaje.y>0)
        {
            Personaje.y-=VELOCIDAD;
        }
    }
    if (tecla[SDLK_DOWN])
    {
        //Personaje.y-=VELOCIDAD;
        ///Camara.Y+=VELOCIDAD;
        if (Camara.Y<LAT_INFERIOR-200)
        {
            Camara.Y+=VELOCIDAD;
        }
        if (Personaje.y<(200/2)-(Personaje.img->w/2))
        {
            Personaje.y+=VELOCIDAD;
        }
        if (Camara.Y==LAT_INFERIOR-200 && Personaje.y<200-(Personaje.img->h))
        {
            Personaje.y+=VELOCIDAD;
        }
    }
    if (tecla[SDLK_LEFT])
    {
        //Personaje.x+=VELOCIDAD;
        //Camara.X-=VELOCIDAD;
        if (Camara.X>0)
        {
            Camara.X-=VELOCIDAD;
        }
        if (Personaje.x>(200/2)-(Personaje.img->w/2))
        {
            Personaje.x-=VELOCIDAD;
        }
        if (Camara.X==0 && Personaje.x>0)
        {
            Personaje.x-=VELOCIDAD;
        }
    }
    if (tecla[SDLK_RIGHT])
    {
        //Personaje.x-=VELOCIDAD;
        if (Camara.X<LAT_INFERIOR-200)
        {
            Camara.X+=VELOCIDAD;
        }
        if (Personaje.x<(200/2)-(Personaje.img->w/2))
        {
            Personaje.x+=VELOCIDAD;
        }
        if (Camara.X==LAT_INFERIOR-200 && Personaje.x<200-(Personaje.img->h))
        {
            Personaje.x+=VELOCIDAD;
        }
    }

    ///*****************************************///


}

void Cargar()
{
    if (SDL_Init(SDL_INIT_VIDEO)<0)
    {
        cerr << "Error: " << SDL_GetError() << endl;
        exit(1);
    }

    pantalla=SDL_SetVideoMode(200,200,24,SDL_HWSURFACE|SDL_DOUBLEBUF);
    if (pantalla==NULL)
    {
        cerr << "Error: " << SDL_GetError() << endl;
        exit(1);
    }

    tiles=SDL_LoadBMP("tiles.bmp");
    if (tiles==NULL)
    {
        cerr << "Error: " << SDL_GetError() << endl;
        exit(1);
    }

    Personaje.img=SDL_LoadBMP("pers.bmp");
    if (Personaje.img==NULL)
    {
        cerr << "Error: " << SDL_GetError() << endl;
        exit(1);
    }
    Personaje.x=(200/2)-(Personaje.img->w/2);
    Personaje.y=(200/2)-(Personaje.img->h/2);

    PosBola.x=(200/2)-(Personaje.img->w/2);
    PosBola.y=(200/2)-(Personaje.img->h/2);

    Camara.X=LAT_DERECHO-200;
    Camara.Y=LAT_INFERIOR-200;
    /*Camara.X=PosBola.x+50;
    Camara.Y=PosBola.y+50;*/

}




Saludos.

[RafaG]

Quizá haciendo una función que me devuelva en que tipo de tile (0,C) estoy... Pero no sé cómo.

[adrigm77]

Depende de si quieres colisiones por pixel o por tiles.

Por tiles es muy fácil, solo debes saber por donde se puede pasar y por donde no y crear una matriz del mismo tamaño del mapa con los valores 1 y 0

Código: Seleccionar todo

0 0 1 0 1 0
1 1 1 1 1 0
1 1 1 1 1 1
0 1 1 0 1 0


Los 1 son transitables y los 0 no. Pues ahora antes de moverte a un tile solo tienes que comprobar si la casilla es transitable.

En realidad si quieres algo serio es mas complejo que esto poque puede haber bloqueos parciales (tiles que puedes moverte en unas direcciones y en otras no). Quiero escribir un artículo acerca de esto en mi blog, si lo hago te aviso.

[RafaG]

Si haces el artículo lo leeré.

He hecho un avance (ya era hora), pero como siempre surge otro problema. Con un cálculo sencillo he conseguido averiguar en qué casilla se encuentra el personaje (me costó...):

Código: Seleccionar todo

        if (tecla[SDLK_UP])
        {
            if (Camara.Y>0 && Personaje.y==(200/2)-(Personaje.img->w/2))
            {
                Camara.Y-=VELOCIDAD;
                if (map[(Camara.Y+Personaje.y)/30][((Camara.X+Personaje.x))/30]==C)
                {
                    Camara.Y+=VELOCIDAD;
                }
            }
            if (Personaje.y>(200/2)-(Personaje.img->w/2) || (Camara.Y==0 && Personaje.y>0))
            {
                Personaje.y-=VELOCIDAD;
                if (map[(Camara.Y+Personaje.y)/30][(Camara.X+Personaje.x)/30]==C)
                {
                    Personaje.y+=VELOCIDAD;
                }
            }


            if (Personaje.y<(200/2)-(Personaje.img->h/2)&&Camara.Y!=0)
            {
                Personaje.y=(200/2)-(Personaje.img->h/2);
            }

        }


El problema es que cuando Personaje.x sale de un tile Personaje.x+Personage.img->w sigue estando en el tile anterior (no se si me he explicado bien), entonces las colisiones funcionan mal, si compilais el código de arriba y lo probáis veréis el error, a ver si alguien sabe solucionarlo.

Saludos.

[Juanxo]

Una opción es comprobar que ninguna de las cuatro esquinas choque con nada, así te evitarás este tipo de problemas. En 3d esto se conoce como BoundingBox

[RafaG]

Después de diez días, y gracias a vuestra ayuda, lo he conseguido.

Para resolver el último problema con las colisiones creé una función que detectaba las colisiones con las cuatro esquinas (como dijo Juanxo).

Aquí dejo el código completo, seguro que a alguien le será útil:

Código: Seleccionar todo

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

#define ANCHO_MAPA 20
#define ALTO_MAPA 20
#define ANCHO_TILE 30
#define LAT_DERECHO ANCHO_TILE*ANCHO_MAPA
#define LAT_INFERIOR ANCHO_TILE*ALTO_MAPA
#define VELOCIDAD 5

#define C 1

void Cargar();

int CeldaPersonaje();
void Imprimir();
void Mover();

class Camara
{
    public:
        int X;
        int Y;
};
class Personaje
{
    public:
        int x,y;
        SDL_Surface*img;
};

SDL_Surface*pantalla,*tiles;
SDL_Rect PosTiles, PosTilesR,PosBola;
Camara Camara;
Personaje Personaje;
Uint8 *tecla;
int ELSE=1;
int x=0,y=0;

int map[ALTO_MAPA][ANCHO_MAPA]=
{
    {C,C,C,0,0,C,C,C,C,C,C,C,C,C,C,C,C,C,C,C},
    {C,0,C,C,0,C,0,0,0,0,0,0,0,C,0,0,0,0,0,C},
    {C,0,C,0,0,0,0,0,0,0,0,0,0,C,C,C,C,C,0,C},
    {C,0,C,C,C,C,0,0,0,0,0,0,0,0,0,0,0,C,0,C},
    {C,0,C,0,0,C,0,0,0,0,0,0,C,C,C,C,C,C,0,C},
    {C,0,C,C,C,C,0,0,C,C,C,C,C,0,0,0,0,0,0,C},
    {C,0,C,C,0,0,0,C,0,0,0,0,C,C,C,0,C,C,0,C},
    {C,0,0,C,0,C,C,C,C,C,C,C,0,C,C,0,C,C,0,C},
    {0,C,0,C,0,C,0,C,0,0,C,0,0,C,C,0,C,C,0,C},
    {0,C,0,C,0,0,0,C,C,0,C,0,0,C,C,C,C,C,0,C},
    {C,C,0,C,C,C,0,0,C,0,C,0,0,C,0,0,0,0,0,C},
    {0,C,0,0,0,C,0,C,C,0,C,0,C,C,C,C,C,C,0,C},
    {0,C,0,C,C,C,0,C,C,0,C,C,C,0,0,0,0,0,0,C},
    {0,C,0,C,0,0,0,C,0,0,0,0,0,0,C,C,C,C,C,C},
    {0,C,0,C,0,C,C,C,C,C,C,C,C,0,C,0,0,0,0,0},
    {0,C,0,C,0,C,0,0,0,0,0,0,0,0,C,C,0,0,0,0},
    {0,C,0,C,0,C,C,C,0,C,C,C,C,C,C,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {C,C,C,C,C,C,C,C,0,C,C,C,C,C,C,0,0,0,0,0},
    {0,0,0,0,0,0,0,C,0,C,0,0,0,0,0,0,0,0,0,0},
};

int main ( int argc, char** argv )
{
    Cargar();

    while (1)
    {
        Mover();
        Imprimir();
        SDL_Delay(10);
    }
    return 0;
}

void Imprimir()
{
    SDL_FillRect(pantalla,NULL,0);
    for (y=0; y<ALTO_MAPA; y++)
    {
        for (x=0; x<ANCHO_MAPA; x++)
        {
            if (map[y][x]==0)
            {
                PosTilesR.x=0;
                PosTilesR.y=0;
                PosTilesR.w=ANCHO_TILE;
                PosTilesR.h=ANCHO_TILE;
            }
            if (map[y][x]==C)
            {
                PosTilesR.x=ANCHO_TILE;
                PosTilesR.y=0;
                PosTilesR.w=ANCHO_TILE*2;
                PosTilesR.h=ANCHO_TILE;
            }
            PosTiles.x=x*ANCHO_TILE-Camara.X;
            PosTiles.y=y*ANCHO_TILE-Camara.Y;
            if (PosTiles.x>=-(ANCHO_TILE)&& PosTiles.x<=200+ANCHO_TILE&&PosTiles.y>=-(ANCHO_TILE)&& PosTiles.y<=200)
            {
                SDL_BlitSurface(tiles,&PosTilesR,pantalla,&PosTiles);
            }
        }
    }
    SDL_BlitSurface(Personaje.img,NULL,pantalla,&PosBola);
    SDL_Flip(pantalla);
}
void Mover()
{
    PosBola.x=Personaje.x;
    PosBola.y=Personaje.y;

    SDL_PumpEvents();
    tecla=SDL_GetKeyState(NULL);

    if (tecla[SDLK_ESCAPE])
    {
        exit(1);
    }

    ///******************************************///

        if (tecla[SDLK_UP])
        {
            if (Camara.Y>0 && Personaje.y==(200/2)-(Personaje.img->w/2))
            {
                Camara.Y-=VELOCIDAD;
                if (CeldaPersonaje()==C)
                {
                    Camara.Y+=VELOCIDAD;
                }
            }
            if (Personaje.y>(200/2)-(Personaje.img->w/2) || (Camara.Y==0 && Personaje.y>0))
            {
                Personaje.y-=VELOCIDAD;
                if (CeldaPersonaje()==C)
                {
                    Personaje.y+=VELOCIDAD;
                }
            }


            if (Personaje.y<(200/2)-(Personaje.img->h/2)&&Camara.Y!=0)
            {
                Personaje.y=(200/2)-(Personaje.img->h/2);
            }

        }
        if (tecla[SDLK_DOWN])
        {
            if (Camara.Y<LAT_INFERIOR-200 && Personaje.y==(200/2)-(Personaje.img->w/2))
            {
                Camara.Y+=VELOCIDAD;
                if (CeldaPersonaje()==C)
                {
                    Camara.Y-=VELOCIDAD;
                }
            }
            if (Personaje.y<(200/2)-(Personaje.img->w/2)||(Camara.Y==LAT_INFERIOR-200 && Personaje.y<200-(Personaje.img->h)))
            {
                Personaje.y+=VELOCIDAD;
                if (CeldaPersonaje()==C)
                {
                    Personaje.y-=VELOCIDAD;
                }
            }

            if (Personaje.y>(200/2)-(Personaje.img->h/2)&&Camara.Y==0)
            {
                Personaje.y=(200/2)-(Personaje.img->h/2);
            }

        }
        if (tecla[SDLK_LEFT])
        {
            if (Camara.X>0 && Personaje.x==(200/2)-(Personaje.img->w/2))
            {
                Camara.X-=VELOCIDAD;
                if (CeldaPersonaje()==C)
                {
                    Camara.X+=VELOCIDAD;
                }
            }
            if (Personaje.x>(200/2)-(Personaje.img->w/2)||(Camara.X==0 && Personaje.x>0))
            {
                Personaje.x-=VELOCIDAD;
                if (CeldaPersonaje()==C)
                {
                    Personaje.x+=VELOCIDAD;
                }
            }

            if (Personaje.x<(200/2)-(Personaje.img->w/2)&&Camara.X!=0)
            {
                Personaje.x=(200/2)-(Personaje.img->w/2);
            }
        }
        if (tecla[SDLK_RIGHT])
        {
            if (Camara.X<LAT_INFERIOR-200 && Personaje.x==(200/2)-(Personaje.img->w/2))
            {
                Camara.X+=VELOCIDAD;
                if (CeldaPersonaje()==C)
                {
                    Camara.X-=VELOCIDAD;
                }
            }
            if (Personaje.x<(200/2)-(Personaje.img->w/2)||(Camara.X==LAT_INFERIOR-200 && Personaje.x<200-(Personaje.img->h)))
            {
                Personaje.x+=VELOCIDAD;
                if (CeldaPersonaje()==C)
                {
                    Personaje.x-=VELOCIDAD;
                }
            }
            if (Personaje.x>(200/2)-(Personaje.img->w/2)&&Camara.X==0)
            {
                Personaje.x=(200/2)-(Personaje.img->w/2);
            }

        }

    if (Personaje.x+Personaje.img->w>200)
    {
        Personaje.x=200-Personaje.img->w;
        PosBola.x=Personaje.x;
    }
    if (Personaje.y+Personaje.img->h>200)
    {
        Personaje.y=200-Personaje.img->h;
        PosBola.y=Personaje.y;
    }
    if (Personaje.x<0)
    {
        Personaje.x=0;
        PosBola.x=Personaje.x;
    }
    if (Personaje.y<0)
    {
        Personaje.y=0;
        PosBola.y=Personaje.y;
    }

    ///*****************************************///


}

int CeldaPersonaje()
{
    ///U
    if (map[(Camara.Y+Personaje.y)/ANCHO_TILE][(Camara.X+Personaje.x)/ANCHO_TILE]==C)
    {
        return C;
    }
    if (map[(Camara.Y+Personaje.y)/ANCHO_TILE][(Camara.X+Personaje.x+(ANCHO_TILE-1))/ANCHO_TILE]==C)
    {
        return C;
    }
    ///D
    if (map[(Camara.Y+Personaje.y+(ANCHO_TILE-1))/ANCHO_TILE][(Camara.X+Personaje.x)/ANCHO_TILE]==C)
    {
        return C;
    }
    if (map[(Camara.Y+Personaje.y+(ANCHO_TILE-1))/ANCHO_TILE][(Camara.X+Personaje.x+(ANCHO_TILE-1))/ANCHO_TILE]==C)
    {
        return C;
    }

    return 0;
}

void Cargar()
{
    if (SDL_Init(SDL_INIT_VIDEO)<0)
    {
        cerr << "Error: " << SDL_GetError() << endl;
        exit(1);
    }

    pantalla=SDL_SetVideoMode(200,200,24,SDL_HWSURFACE|SDL_DOUBLEBUF);
    if (pantalla==NULL)
    {
        cerr << "Error: " << SDL_GetError() << endl;
        exit(1);
    }

    tiles=SDL_LoadBMP("tiles.bmp");
    if (tiles==NULL)
    {
        cerr << "Error: " << SDL_GetError() << endl;
        exit(1);
    }

    Personaje.img=SDL_LoadBMP("pers.bmp");
    if (Personaje.img==NULL)
    {
        cerr << "Error: " << SDL_GetError() << endl;
        exit(1);
    }
    SDL_SetColorKey(Personaje.img, SDL_SRCCOLORKEY|SDL_RLEACCEL,SDL_MapRGB(Personaje.img->format, 255, 0, 255));
    Personaje.x=(200/2)-(Personaje.img->w/2);
    Personaje.y=(200/2)-(Personaje.img->h/2);

    PosBola.x=(200/2)-(Personaje.img->w/2);
    PosBola.y=(200/2)-(Personaje.img->h/2);

    Camara.X=LAT_DERECHO-200;
    Camara.Y=LAT_INFERIOR-200;

}


Gracias a todos.