Sand Game Help

Bingocat

I'm a beginner to c++ and allegro, so the code is bad. Whenever the amount of sand gets near or above 2000 the game freezes. Is there a better way to do collision with it?

#SelectExpand
   1#include <allegro5\allegro.h>
   2#include <allegro5\allegro_primitives.h>
   3#include <allegro5\allegro_font.h>
   4#include <allegro5\allegro_ttf.h>
   5
   6int width = 640;
   7int height = 480;
   8
   9struct Particle
  10{
int x;
int y;
int prevX;
int prevY;
bool active;
bool collision;
  17};
  18
  19void InitSand(Particle sand[], int maxSand);
  20void NewSand(Particle sand[], int maxSand, int x, int y, int &sandNum);
  21void UpdateSand(Particle sand[], int maxSand);
  22void DrawSand(Particle sand[], int maxSand);
  23void CollideSand(Particle sand[], int maxSand);
  24
  25ALLEGRO_FONT *font18 = NULL;
  26
  27int main() {
int FPS = 60;
bool done = false;
bool redraw = true;
const int maxSand = 10000;
Particle sand[maxSand];
int mouseX;
int mouseY;
bool mouseHold = false;
int sandNum = 0;
  37
al_init();
al_init_primitives_addon();
al_init_font_addon();
al_init_ttf_addon();
al_install_mouse();
InitSand(sand, maxSand);
  44
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE  *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
  48
display = al_create_display(width, height);
event_queue = al_create_event_queue();
timer = al_create_timer(1.0 / FPS);
font18 = al_load_font("arial.ttf", 18, 0);
  53
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_mouse_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(timer));
  57
al_start_timer(timer);
  59
  60
while (!done) {
  ALLEGRO_EVENT ev;
  al_wait_for_event(event_queue, &ev);
  64
  if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
    done = true;
  else if (ev.type == ALLEGRO_EVENT_TIMER) {
    redraw = true;
  69
    for (int i = 0; i < maxSand; i++) {
      if (sand[i].active) {
        sand[i].prevX = sand[i].x;
        sand[i].prevY = sand[i].y;
      }
    }
  76
    UpdateSand(sand, maxSand);
    CollideSand(sand, sandNum);
  }
  else if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) {
    if (ev.mouse.button == 1)
      mouseHold = true;
    else if (ev.mouse.button == 2) {
      InitSand(sand, maxSand);
      sandNum = 0;
    }
  }
  else if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP) {
    if (ev.mouse.button == 1)
      mouseHold = false;
  }
  else if (ev.type == ALLEGRO_EVENT_MOUSE_AXES) {
    mouseX = ev.mouse.x;
    mouseY = ev.mouse.y;
  }
  96
  if (mouseHold) {
    NewSand(sand, maxSand, mouseX, mouseY, sandNum);
  }
 100
  if (redraw && al_is_event_queue_empty(event_queue)) {
    redraw = false;
 103
    al_draw_textf(font18, al_map_rgb(255, 255, 255), 0, 100, 0, "Amout of sand: %i    %i    %i", sandNum, mouseX, mouseY);
    DrawSand(sand, maxSand);
    al_flip_display();
    al_clear_to_color(al_map_rgb(0,0,0));
  }
}
 110
al_destroy_display(display);
al_destroy_event_queue(event_queue);
al_destroy_timer(timer);
return 0;
 115}
 116
 117void InitSand(Particle sand[], int maxSand) {
for (int i = 0; i < maxSand; i++) {
  sand[i].active = false;
  sand[i].x = 0;
  sand[i].y = 0;
  sand[i].collision = false;
}
 124}
 125void NewSand(Particle sand[], int maxSand, int x, int y, int &sandNum) {
for (int t = 0; t < 5; t++) {
  for (int i = 0; i < maxSand; i++) {
    if (!sand[i].active) {
      sand[i].x = x + rand() % 10 - 5;
      sand[i].y = y + rand() % 10 - 5;
      sand[i].active = true;
      sandNum++;
      break;
    }
  }
}
 137}
 138void UpdateSand(Particle sand[], int maxSand) {
for (int i = 0; i < maxSand; i++) {
  if (sand[i].active) {
    sand[i].y += 1;
  }
}
 144}
 145void DrawSand(Particle sand[], int maxSand) {
for (int i = 0; i < maxSand; i++) {
  if (sand[i].active) {
    al_draw_pixel(sand[i].x, sand[i].y, al_map_rgb(255, 195, 33));
    //al_draw_filled_rectangle(sand[i].x, sand[i].y, sand[i].x + 5, sand[i].y + 5, al_map_rgb(255, 195, 33));
  }
}
 152}
 153
 154void CollideSand(Particle sand[], int maxSand) {
for (int i = 0; i < maxSand; i++) {
  if (sand[i].y >= height)
    sand[i].y = height;
  if (sand[i].active) {
    for (int j = 0; j < maxSand; j++) {
      if (sand[j].active && i != j) {
        if (sand[i].x == sand[j].x && sand[i].y == sand[j].y) {
          if (sand[i].prevY <= sand[j].y)
            sand[i].y = sand[j].y - 1;
        }
      }
    }
  }
}
 169}

hyreia77

I see two main issues: yes the collision and the other is the drawing. Let's tackle the drawing first. That's a slightly easier fix.

You're drawing 10,000 pixels to the screen 60 times a second.
Drawing individual pixels is surprisingly slow this way. You're making 10,000 calls to whatever is drawing your screen in under 1/60th of a second.
Solution:
First: use al_put_pixel(). The difference is al_draw_pixel uses current blender and transformation settings. If you're just trying to put pixels use that.
Second: al_lock_bitmap() your target bitmap before you start drawing the pixels then al_unlock_bitmap() it when you're finished. That holds off all drawing to that until it's unlocked, so it can do it in one batch (theoretically anyway).

Now, the collision is much more complicated: you're testing 10,000 objects against 9,999 other objects. That's 99,990,000 tests I think. If all you're doing is stopping the sand from falling when it encounters more sand, instead consider just testing the next pixel it might move to to see if it's sand colored. al_get_pixel, but be sure to lock the bitmap before you start this process for the same reason.
If you're going to reuse that color, I would instead draw all the sand to a "sand bitmap" that is clear other than sand, then draw that to the buffer.

This is from my experience, maybe try that and see if anyone comes along to tell you otherwise.

Thread #613623. Printed from Allegro.cc