no-reply@allegro.cc (pito2901) — Fri, 20 Nov 2015 01:41:29 +0000

Hi !

I'm here because I can't resolve my problem :

I'm releazing a 2D game with Allegro 5 and I'm not able to make collision with my character. Actually, I made a tile map and a table with the tiles number.

My problem is that I can't know the position of my character on the map. So I can't control collision with it.

So if you can give me some answers, it will be great !

Here the zip file.

Thanks.

PS: I'm french and sorry if there are mistakes in my language.

no-reply@allegro.cc (Chris Katko) — Fri, 20 Nov 2015 02:08:50 +0000

You always track your player position.

for example:

float player_x;
float player_y;

bool map[32][32]; //1 indicates solid, 0 is empty
const int TILE_WIDTH = 16;
const int TILE_HEIGHT = TILE_WIDTH;

if(map[player_x / TILE_WIDTH][player_y / HEIGHT) == 1) //convert from position to index in the map by dividing by the tile size
{
//collision has occurred
}

You can use the player_x and player_y to represent the "center" of your character, then draw the character with:

my_draw_function(player_bitmap, player_x / PLAYER_WIDTH, player_y / PLAYER_HEIGHT)

This would center it at your player point. Or for a platformer, you want to center horizontally, but not vertically. You want to be checking your players feet, not his chest. (Whereas the exact center could work for a space ship.) So you'd do:

my_draw_function(player_bitmap, player_x / PLAYER_WIDTH, player_y - PLAYER_HEIGHT).

That is, centered horizontally, but not vertically. And you subtract the height to move the sprite higher on the screen so now the bottom of the graphic (typically his / her feet) will be the contact point.

You can also have more contact points, such as top/bottom/left/right.

no-reply@allegro.cc (pito2901) — Fri, 20 Nov 2015 16:13:23 +0000

Can you translate your answer with my code please ?

Allegro.h

#SelectExpand
  1#include 
  2#include 
  3#include 
  4#include 
  5#include 
  6
  7//Couleurs
  8#define GRIS   al_map_rgb(178,178,178)
  9#define BLEUF  al_map_rgb(12,99,238)
 10#define BLEUC  al_map_rgb(17,193,243)
 11#define VERT   al_map_rgb(51,205,95)
 12#define ORANGE al_map_rgb(255,201,0)
 13#define ROUGE  al_map_rgb(239,71,58)
 14#define VIOLET al_map_rgb(136,106,234)
 15#define NOIR   al_map_rgb(68,68,68)
 16
 17#define screenx 400
 18#define screeny 400
 19
 20#define tilex 100
 21#define tiley 100
 22
 23
 24/****************************************
 25PERSO
 26****************************************/
 27
 28struct perso {
 29  ALLEGRO_BITMAP *face[3], *gauche[3], *droite[3], *back[3];
 30  int posx, posy;
 31  int x = screenx / 2,
 32    y = screeny / 2;
 33};
 34
 35/**********************************
 36        MAP
 37**********************************/
 38
 39struct carte {
 40  ALLEGRO_BITMAP *image;
 41  int x, y;
 42};
 43
 44void init_carte(carte *m, int largeur, int hauteur) {
 45  m->x = - largeur / 2 + screenx / 2;
 46  m->y = - hauteur / 2 + screeny /2;
 47}
 48
 49void affiche_carte(carte *m, perso *p) {
 50  al_draw_bitmap(m->image, m->x, m->y, 0);
 51  al_draw_bitmap(p->face[1], p->x - 23, p->y - 23, 0);
 52}
 53
 54/* Déplacements */
 55enum KEYS { UP, RIGHT, LEFT, DOWN, F, KEY_MAX };
 56bool key[KEY_MAX] = { false };
 57
 58/* Mouvements */
 59void haut(carte *m, perso *p, int compt_back) {
 60  m->y = m->y + 5;
 61  al_draw_bitmap(m->image, m->x, m->y, 0);
 62
 63  al_draw_bitmap(p->back[compt_back], p->x - 23, p->y - 23, 0);
 64}
 65void bas(carte *m, perso *p, int compt_face) {
 66  m->y = m->y - 5;
 67  al_draw_bitmap(m->image, m->x, m->y, 0);
 68
 69  al_draw_bitmap(p->face[compt_face], p->x - 23, p->y - 23, 0);
 70}
 71void gauche(carte *m, perso *p, int compt_gauche) {
 72  m->x = m->x + 5;
 73  al_draw_bitmap(m->image, m->x, m->y, 0);
 74  
 75  al_draw_bitmap(p->gauche[compt_gauche], p->x - 23, p->y - 23, 0);
 76}
 77void droite(carte *m, perso *p, int compt_droite) {
 78  m->x = m->x - 5;
 79  al_draw_bitmap(m->image, m->x, m->y, 0);
 80
 81  al_draw_bitmap(p->droite[compt_droite], p->x - 23, p->y - 23, 0);
 82}

main.cpp

#SelectExpand
   1#include 
   2#include 
   3#include 
   4
   5// fonction contrôle d'erreur
   6void erreur(const char*txt)
   7{
ALLEGRO_DISPLAY*d;
d = al_is_system_installed() ? al_get_current_display() : NULL;
al_show_native_message_box(d, "ERREUR", txt, NULL, NULL, 0);
exit(EXIT_FAILURE);
  12}
  13/******************************************************************
  14******************************************************************/
  15int main()
  16{
// Pointeurs
ALLEGRO_DISPLAY      *display;  // fenêtre
ALLEGRO_EVENT_QUEUE    *queue;    // evenement
ALLEGRO_TIMER      *timer;    // temps
  21
/****************************************
      INITIALISATIONS
****************************************/
if (!al_init())
  erreur("Erreur : Allegro");
  27
// Création d'une fenêtre
display = al_create_display(screenx, screeny);
if (!display)
  erreur("Erreur : Display");
  // Propriétés de la fenêtre
    // Titre
    al_set_window_title(display, "Premier programme !");
  35
    // Couleur de fond
    al_clear_to_color(ROUGE);
  38
/****************************************
        VARIABLES
****************************************/
  42
// Map
carte map;
  45
// Perso
perso mario;

bool fin = false,
   dessin = false;

// Dessin
if (!al_init_primitives_addon())
  erreur("Dessin");
  55
// Clavier
if (!al_install_keyboard())
  erreur("Clavier");
  59
// Souris
if (!al_install_mouse())
  erreur("Souris");

// Image
if (!al_init_image_addon())
  erreur("Images");
  67
  // Face
  char nom[256];
  for (int i = 0; i < 3; i++) {
    sprintf_s(nom, "./images/perso/face%d.png", i);
    mario.face[i] = al_load_bitmap(nom);
  }
  float compt_face = 0;
  75
  // Gauche
  for(int i = 0; i < 3; i++) {
    sprintf_s(nom, "./images/perso/gauche%d.png", i);
    mario.gauche[i] = al_load_bitmap(nom);
  }
  float compt_gauche = 0;
  82
  // Droite
  for (int i = 0; i < 3; i++) {
    sprintf_s(nom, "./images/perso/droite%d.png", i);
    mario.droite[i] = al_load_bitmap(nom);
  }
  float compt_droite = 0;
  89
  // Back
  for (int i = 0; i < 3; i++) {
    sprintf_s(nom, "./images/perso/back%d.png", i);
    mario.back[i] = al_load_bitmap(nom);
  }
  float compt_back = 0;
  96
  // Map
    // Collision
    map.image = al_load_bitmap("./images/map/test.png");
    int hauteur = al_get_bitmap_height(map.image);
    int largeur = al_get_bitmap_width(map.image);
    init_carte(&map, largeur, hauteur);
 103
// Carte
int carte[5][5] = {
  { 16,16,16,16,16 },
  { 16,1,16,3,16 },
  { 16,16,16,16,16 },
  { 16,9,16,11,16 },
  { 16,16,16,16,16 }
};

// Temps
const int fps = 24;
timer = al_create_timer(1.0 / fps);
if (!timer)
  erreur("timer");
 118
// Evenements
queue = al_create_event_queue();
if (!queue)
  erreur("queue");
 123
  al_register_event_source(queue,
    al_get_display_event_source(display));
  al_register_event_source(queue,
    al_get_keyboard_event_source());
  al_register_event_source(queue,
    al_get_timer_event_source(timer));
      
al_start_timer(timer);
 132
while (!fin)
{
  // Récupérer un évenement
  ALLEGRO_EVENT even;
  al_wait_for_event(queue, &even);
 138
  // [Échap]
  if (even.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
    fin = true;
      
  else if (even.type == ALLEGRO_EVENT_KEY_DOWN)
  {
    switch (even.keyboard.keycode)
    {
      case ALLEGRO_KEY_UP:
        key[UP] = true;
        break;
      case ALLEGRO_KEY_DOWN:
        key[DOWN] = true;
        break;
      case ALLEGRO_KEY_LEFT:
        key[LEFT] = true;
        break;
      case ALLEGRO_KEY_RIGHT:
        key[RIGHT] = true;
        break;

      case ALLEGRO_KEY_ESCAPE:
        fin = true;
        break;
    }
  }
 165
  else if (even.type == ALLEGRO_EVENT_KEY_UP)
  {
    switch (even.keyboard.keycode)
    {
      case ALLEGRO_KEY_UP:
        key[UP] = false;
        break;
      case ALLEGRO_KEY_DOWN:
        key[DOWN] = false;
        break;
      case ALLEGRO_KEY_LEFT:
        key[LEFT] = false;
        break;
      case ALLEGRO_KEY_RIGHT:
        key[RIGHT] = false;
        break;
      default:
        dessin = false;
    }
  }
  
  else if (even.type == ALLEGRO_EVENT_TIMER)
  {
    al_clear_to_color(ROUGE);
    
    affiche_carte(&map, &mario);
    
    if (key[UP])
    {
      haut(&map, &mario, compt_back);
      compt_back = compt_back + .5;
      if (compt_back > 2)
        compt_back = 0;
    }
    else if (key[DOWN])
    {
      bas(&map, &mario, compt_face);
      compt_face = compt_face + .5;
      if (compt_face > 2)
        compt_face = 0;
    }
    else if (key[LEFT])
    {
      gauche(&map, &mario, compt_gauche);
      compt_gauche = compt_gauche + .5;
      if (compt_gauche > 2)
        compt_gauche = 0;
    }
    else if (key[RIGHT])
    {
      droite(&map, &mario, compt_droite);
      compt_droite = compt_droite + .5;
      if (compt_droite > 2)
        compt_droite = 0;
    }
    else
    {
      affiche_carte(&map, &mario);
    }
  }
 226
  al_flip_display();
 228
 229
}

al_destroy_display(display);
 233
return 0;
 235}

Thanks.

Control Collision