no-reply@allegro.cc (Fredrik Beckman) — Sun, 22 Dec 2013 02:03:35 +0000

[edit] made a mistake with code formatting, tried to fix

hi,
the problem: it seems like my program starts without waiting for my keypress. After loading bitmaps, fonts and stuff I added a wait loop for pressing space, but if I start the program, wait for about 5 sec and then press space, I can see that the game started without me, kind of.

I can't figure out how, its like a separate program is running invisible and spoils everything.

Allegro 5.0.10
VCC 2008 Express

Could it be some unload/detach or something I've missed?

Is there a kind soul out there to take a peek and give a hint of what it could be? Code and bitmaps attached, adding most of code below too (can't add all - post too long):

main.cpp:

#SelectExpand
   1
   2#include 
   3#include 
   4#include 
   5#pragma comment(lib,"ws2_32.lib")
   6
   7#include "allegro5/allegro.h"
   8#include "allegro5/allegro_image.h"
   9#include "allegro5/allegro_native_dialog.h"
  10#include 
  11#include 
  12
  13#include "Main_loc.h"
  14
  15const float 
FPS = 60,
pi  = 3.14159265;
  18
  19const int 
SCREEN_W = 800,
SCREEN_H = 600,
GAME_AREA_W = 600,
GAME_AREA_H = 500,
GAME_AREA_OFFSX = 45,
GAME_AREA_OFFSY = 45,
GAME_AREA_BORDER_W = 10,
GAME_AREA_BORDER_H = 10,
TANK_SIZE = 26,
TANK_OFFS_X = 12,
TANK_OFFS_Y = 12,
BULLET_OFFS_X = 2,
BULLET_OFFS_Y = 2,
TANK_SPEED = 1,
BULLET_SPEED = 3,
BULLET_COUNT = 60,
INFO_TEXT_X = 670,
PLAYER_TEXT_Y = 60,
ENEMY_TEXT_Y = 150,
ENEMY_DIST_OFFSET = 25,
ENEMY_FIRE_OFFSET = 200;
  41
  42bool CollDetectWalls(objectData_st *object_p);
  43
  44bool CollDetectTanks(float object1_x, float object1_y, objectData_st *object2_p);
  45
  46bool CollDetectShot(objectData_st *shot_p, objectData_st *tank_p);
  47
  48bool MoveTank(objectData_st *tank1_p, objectData_st *tank2_p, bool *key_p);
  49
  50bool SetEnemyDirectionRight(objectData_st *tank1_p, objectData_st *tank2_p);
  51
  52bool SetEnemyDirectionLeft(objectData_st *tank1_p, objectData_st *tank2_p);
  53
  54bool SetEnemyDirectionFwd(objectData_st *tank1_p, objectData_st *tank2_p);
  55
  56bool SetEnemyFire(objectData_st *tank1_p, objectData_st *tank2_p);
  57
  58int 
main(int argc, char **argv)
{
  ALLEGRO_BITMAP 
    *backGround = NULL;
    
  ALLEGRO_FONT 
    *font;
  66
  ALLEGRO_DISPLAY 
    *display = NULL;
  69
  ALLEGRO_EVENT_QUEUE 
    *event_queue = NULL;
  72
  ALLEGRO_EVENT 
    ev;
  75
  ALLEGRO_KEYBOARD_STATE 
    kbdstate;
    
  ALLEGRO_TIMER 
    *timer = NULL;
  81
  bool 
    redraw = true,
    key[5] = { false, false, false, false, false },
    enKey[5] = { false, false, false, false, false },
    doexit = false;
  87
  char
    tmpText[255];
    
  int
    counter1 = 0,
    counter2 = 0;
  94
  objectData_st
    playerShot = 
    {
      NULL,   /* ALLEGRO_BITMAP *bitmap */
      0.0,    /* float x                */
      0.0,    /* float y                */
      0.0,    /* float angle            */
      0.0,    /* float angle            */
      3.0,    /* float speed            */
      0,      /* int cnt                */
      0,      /* int fireCnt            */
      0,      /* int points             */
      10,     /* type                   */
      false,  /* bool active            */
      false   /* bool hit               */
    },
    
    playerTank = 
    {
      NULL,                                        /* ALLEGRO_BITMAP *bitmap */
      (SCREEN_W / 2.0 - TANK_SIZE / 2.0),          /* float x                */
      (4.0 * (SCREEN_H / 5.0) - TANK_SIZE / 2.0),  /* float y                */
      0.0,                                         /* float angle            */
      0.0,                                         /* float angle            */
      1.0,                                         /* float speed            */
      0,                                           /* int cnt                */
      0,                                           /* int fireCnt            */
      0,                                           /* int points             */
      0,                                           /* type                   */
      true,                                        /* bool active            */
      false                                        /* bool hit               */
    },
 127
    enemyShot  = 
    {
      NULL,   /* ALLEGRO_BITMAP *bitmap */
      0.0,    /* float x                */
      0.0,    /* float y                */
      0.0,    /* float angle            */
      0.0,    /* float angle            */
      3.0,    /* float speed            */
      0,      /* int cnt                */
      0,      /* int cnt                */
      0,      /* int points             */
      11,     /* type                   */
      false,  /* bool active            */ 
      false   /* bool hit               */
    },
    enemyTank  = 
    {
      NULL,                                       /* ALLEGRO_BITMAP *bitmap */
      (SCREEN_W / 2.0 - TANK_SIZE / 2.0),         /* float x                */
      (1.0 * (SCREEN_H / 5.0) - TANK_SIZE / 2.0), /* float y                */
      pi,                                         /* float angle            */
      pi,                                         /* float angle            */
      1.0,                                        /* float speed            */
      0,                                          /* int cnt                */
      0,                                          /* int cnt                */
      0,                                          /* int points             */
      1,                                          /* type                   */
      true,                                       /* bool active            */
      false                                       /* bool hit               */
    };
    
  fprintf(stderr, "Starting!\n");
 160
  /*******************************************/
  /* Init Allegro                            */
  if(!al_init())
  {
    fprintf(stderr, "Failed to initialize allegro!\n");
  }
 167
  /*******************************************/
  /* Create timer                            */
  timer = al_create_timer(1.0 / FPS);
  if(!timer)
  {
    al_show_native_message_box(display, "Error", "Error", "Failed to create timer!",
                               NULL, ALLEGRO_MESSAGEBOX_ERROR);
                               
    al_destroy_timer(timer);
    return 0;
 178
  }
 180
  /*******************************************/
  /* Init image addon                        */
  if(!al_init_image_addon()) {
    al_show_native_message_box(display, "Error", "Error", "Failed to initialize al_init_image_addon!",
                               NULL, ALLEGRO_MESSAGEBOX_ERROR);
 186
    al_destroy_timer(timer);
    return 0;
  }
 190
  /*******************************************/
  /* Start keyboard detection                */
  if(!al_install_keyboard()) {
    al_show_native_message_box(display, "Error", "Error", "Failed to initialize the keyboard!",
                               NULL, ALLEGRO_MESSAGEBOX_ERROR);
 196
    al_destroy_timer(timer);
    return 0;
  }
 200
  /*******************************************/
  /* Create display                          */
  display = al_create_display(SCREEN_W, SCREEN_H);
  if(!display)
  {
    al_show_native_message_box(display, "Error", "Error", "Failed to create display!",
                               NULL, ALLEGRO_MESSAGEBOX_ERROR);
 208
    al_destroy_display(display);
    al_destroy_timer(timer);
    return 0;
  }
 213
  /*******************************************/
  /* Text                                    */
  /* Create the info text                    */
 217
  /* initialize the font addon (really? ttf below...) */
  al_init_font_addon();
  
  /* initialize the ttf (True Type Font) addon */
  al_init_ttf_addon();
 223
  font = al_load_ttf_font(".\\data\\pixlkrud.ttf", 18, 0 );
 225
  if (!font){
    al_show_native_message_box(display, "Error", "Error", "Failed to load 'pixlkrud.ttf!",
                               NULL, ALLEGRO_MESSAGEBOX_ERROR);
 229
    al_destroy_font(font);
    al_destroy_display(display);
    al_destroy_timer(timer);
    return 0;
  }
 235
  /*******************************************/
  /* Background bitmap                       */
  /* Create bitmap picture background        */
  backGround = al_load_bitmap(".\\data\\backGround.bmp");
  if(!backGround) {
    al_show_native_message_box(display, "Error", "Error", "Failed to load image background!",
                               NULL, ALLEGRO_MESSAGEBOX_ERROR);
 243
    al_destroy_bitmap(backGround);
    al_destroy_font(font);
    al_destroy_display(display);
    al_destroy_timer(timer);
    return 0;
  }
 250
  /* Mask "Magic pink" */
  al_set_target_bitmap(backGround);
  al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
  al_convert_mask_to_alpha(backGround, al_map_rgba_f(1, 0, 1, 1));
 255
  /*******************************************/
  /* Player bitmaps                          */
  /* Create bitmap picture player playerShot */
  playerShot.bitmap = al_load_bitmap(".\\data\\Bullet.bmp");
  if(!playerShot.bitmap) {
    al_show_native_message_box(display, "Error", "Error", "Failed to load image playerShot.bitmap!",
                               NULL, ALLEGRO_MESSAGEBOX_ERROR);
 263
    al_destroy_bitmap(playerShot.bitmap);
    al_destroy_bitmap(backGround);
    al_destroy_font(font);
    al_destroy_display(display);
    al_destroy_timer(timer);
    return 0;
  }
 271
  /* Mask "Magic pink" */
  al_set_target_bitmap(playerShot.bitmap);
  al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
  al_convert_mask_to_alpha(playerShot.bitmap, al_map_rgba_f(1, 0, 1, 1));
 276
  /* Create bitmap picture player tank */
  playerTank.bitmap = al_load_bitmap(".\\data\\TankBlack.bmp");
  if(!playerTank.bitmap) {
    al_show_native_message_box(display, "Error", "Error", "Failed to load image playerTank.bitmap!",
                               NULL, ALLEGRO_MESSAGEBOX_ERROR);
 282
    al_destroy_bitmap(playerTank.bitmap);
    al_destroy_bitmap(playerShot.bitmap);
    al_destroy_bitmap(backGround);
    al_destroy_font(font);
    al_destroy_display(display);
    al_destroy_timer(timer);
    return 0;
  }
 291
  /* Mask "Magic pink" */
  al_set_target_bitmap(playerTank.bitmap);
  al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
  al_convert_mask_to_alpha(playerTank.bitmap, al_map_rgba_f(1, 0, 1, 1));
 296
  /*******************************************/
  /* Enemy bitmaps                          */
  /* Create bitmap picture enemy playerShot */
  enemyShot.bitmap = al_load_bitmap(".\\data\\Bullet.bmp");
  if(!enemyShot.bitmap) {
    al_show_native_message_box(display, "Error", "Error", "Failed to load image enemyShot.bitmap!",
                               NULL, ALLEGRO_MESSAGEBOX_ERROR);
 304
    al_destroy_bitmap(enemyShot.bitmap);
    al_destroy_bitmap(playerTank.bitmap);
    al_destroy_bitmap(playerShot.bitmap);
    al_destroy_bitmap(backGround);
    al_destroy_font(font);
    al_destroy_display(display);
    al_destroy_timer(timer);
    return 0;
  }
 314
  /* Mask "Magic pink" */
  al_set_target_bitmap(enemyShot.bitmap);
  al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
  al_convert_mask_to_alpha(enemyShot.bitmap, al_map_rgba_f(1, 0, 1, 1));
 319
  /* Create bitmap picture enemy tank */
  enemyTank.bitmap = al_load_bitmap(".\\data\\TankRed.bmp");
  if(!enemyTank.bitmap) {
    al_show_native_message_box(display, "Error", "Error", "Failed to load image enemyTank.bitmap!",
                               NULL, ALLEGRO_MESSAGEBOX_ERROR);
 325
    al_destroy_bitmap(enemyTank.bitmap);
    al_destroy_bitmap(enemyShot.bitmap);
    al_destroy_bitmap(playerTank.bitmap);
    al_destroy_bitmap(playerShot.bitmap);
    al_destroy_bitmap(backGround);
    al_destroy_font(font);
    al_destroy_display(display);
    al_destroy_timer(timer);
    return 0;
  }
 336
  /* Mask "Magic pink" */
  al_set_target_bitmap(enemyTank.bitmap);
  al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
  al_convert_mask_to_alpha(enemyTank.bitmap, al_map_rgba_f(1, 0, 1, 1));
 341
  /* Create event queue */
  event_queue = al_create_event_queue();
  if(!event_queue)
  {
    al_destroy_event_queue(event_queue);
    al_destroy_bitmap(enemyTank.bitmap);
    al_destroy_bitmap(enemyShot.bitmap);
    al_destroy_bitmap(playerTank.bitmap);
    al_destroy_bitmap(playerShot.bitmap);
    al_destroy_bitmap(backGround);
    al_destroy_font(font);
    al_destroy_display(display);
    al_destroy_timer(timer);
    return 0;
  }
 357
  /* Display event */
  al_register_event_source(event_queue, al_get_display_event_source(display));
 360
  /* Timer event */
  al_register_event_source(event_queue, al_get_timer_event_source(timer));
 363
  /* Key event */
  //al_register_event_source(event_queue, al_get_keyboard_event_source());
 366
  /* Clear screen to white */
  al_set_target_bitmap(al_get_backbuffer(display));
  al_clear_to_color(al_map_rgb(255, 255, 255));
  al_flip_display();
 371
  /* Start timer */
  al_start_timer(timer);
 374
  /* Draw window area */
  al_set_target_backbuffer(display);
  al_clear_to_color(al_map_rgb(255, 255, 255));
 378
  /* Draw text */
  al_draw_text(font, al_map_rgb(200, 0, 0), (SCREEN_W / 2), (SCREEN_H / 2), ALLEGRO_ALIGN_CENTRE, "Press fire when ready");
 381
  al_flip_display();
 383
  /* SPACE pressed */
  do
  {
    al_get_keyboard_state(&kbdstate);
  } while (al_key_down(&kbdstate, ALLEGRO_KEY_SPACE) != true);
  
  /* SPACE released */
  do
  {
    al_get_keyboard_state(&kbdstate);
  } while (al_key_down(&kbdstate, ALLEGRO_KEY_SPACE) == true);
 395
 396
  /*************/
  /* MAIN LOOP */
  
  fprintf(stderr, "Starting main loop\n");
  while(doexit == false)
  {
    al_wait_for_event(event_queue, &ev);
    if(ev.type == ALLEGRO_EVENT_TIMER)
    {
      /* Enemy tank - checked if turn left */
      if (SetEnemyDirectionLeft(&enemyTank, &playerTank))
      {
        enKey[KEY_LEFT]  = true;
        enKey[KEY_RIGHT]  = false;
      }
      /* Enemy tank - checked if turn right */
      else if (enKey[KEY_RIGHT] = SetEnemyDirectionRight(&enemyTank, &playerTank))
      {
        enKey[KEY_RIGHT]  = true;
        enKey[KEY_LEFT]  = false;
      }
 418
      enKey[KEY_UP]    = SetEnemyDirectionFwd(&enemyTank, &playerTank);
      enKey[KEY_SPACE] = SetEnemyFire(&enemyTank, &playerTank);
 421
      /* TODO: Use keyb event! */
      al_get_keyboard_state(&kbdstate);
      key[KEY_UP]    = al_key_down(&kbdstate, ALLEGRO_KEY_UP);
      key[KEY_DOWN]  = al_key_down(&kbdstate, ALLEGRO_KEY_DOWN);
      key[KEY_LEFT]  = al_key_down(&kbdstate, ALLEGRO_KEY_LEFT);
      key[KEY_RIGHT] = al_key_down(&kbdstate, ALLEGRO_KEY_RIGHT);
      key[KEY_SPACE] = al_key_down(&kbdstate, ALLEGRO_KEY_SPACE);
      
      if (al_key_down(&kbdstate, ALLEGRO_KEY_ESCAPE))
      {
        /* Quit */
        break;
      }
      
      enemyTank.active  = MoveTank(&playerTank, &enemyTank,  &key[0]);
      playerTank.active = MoveTank(&enemyTank,  &playerTank, &enKey[0]);
      
      /* Check if player FIRE */
      if (key[KEY_SPACE] && !playerShot.active && playerTank.active)
      {
        /* Shoot! */
        playerShot.x        = playerTank.x;
        playerShot.y        = playerTank.y;
        playerShot.movAngle = playerTank.movAngle;
        playerShot.rotAngle = playerShot.movAngle;
        playerShot.active   = true;
        playerShot.cnt      = 0;
        fprintf(stderr, "Player shoot! playerShot.cnt = %d\n", playerShot.cnt);
      }
 451
      if (playerShot.active && playerShot.cnt < BULLET_COUNT)
      {
        /* Bullet's moving */
        playerShot.y -= playerShot.speed * cos(playerShot.movAngle);
        playerShot.x += playerShot.speed * sin(playerShot.movAngle);
        playerShot.cnt += 1;
      }
      else if(playerShot.active)
      {
        /* Bullet reached end */
        playerShot.cnt = 0;
        playerShot.active = false;
      }
 465
      /* Collision detection player bullet / enemy tank */
      if (CollDetectShot(&playerShot, &enemyTank) && playerShot.active)
      {
        /* Collision */
        fprintf(stderr, "Collision (player shot - enemy tank)!\n\n");
        playerShot.active = false;
        playerTank.active = false;
        playerTank.points += 1;
        
        enemyTank.hit = true;
        enemyTank.active = false;
        enemyTank.movAngle = playerShot.movAngle;
        enemyTank.speed = BULLET_SPEED;
      }
 480
 481
 482
      /* Check if enemy FIRE */
      if (enKey[KEY_SPACE] && !enemyShot.active && enemyTank.active)
      {
        /* Shoot! */
        enemyShot.x        = enemyTank.x;
        enemyShot.y        = enemyTank.y;
        enemyShot.movAngle = enemyTank.movAngle;
        enemyShot.rotAngle = enemyTank.movAngle;
        enemyShot.active   = true;
        enemyShot.cnt      = 0;
        fprintf(stderr, "Enemy shoot! playerShot.cnt = %d\n", enemyShot.cnt);
      }
 495
      if (enemyShot.active && enemyShot.cnt < BULLET_COUNT)
      {
        /* Bullet's moving */
        enemyShot.y -= enemyShot.speed * cos(enemyShot.movAngle);
        enemyShot.x += enemyShot.speed * sin(enemyShot.movAngle);
        enemyShot.cnt += 1;
      }
      else if(enemyShot.active)
      {
        /* Bullet reached end */
        enemyShot.cnt = 0;
        enemyShot.active = false;
      }
 509
      /* Collision detection player bullet / enemy tank */
      if (CollDetectShot(&enemyShot, &playerTank) && enemyShot.active)
      {
        /* Collision */
        fprintf(stderr, "Collision (enemy shot - player tank)!\n\n");
        enemyShot.active = false;
        enemyTank.active = false;
        enemyTank.points += 1;
        
        playerTank.hit = true;
        playerTank.active = false;
        playerTank.movAngle = enemyShot.movAngle;
        playerTank.speed = BULLET_SPEED;
      }
      
      /* Collision detection outer walls (Y) */
      (void) CollDetectWalls(&playerTank);
 527
      /* Collision detection outer walls */
      (void) CollDetectWalls(&enemyTank);
      
      redraw = true;
    }
    else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
    {
      break;
    }
 537
    if(redraw && al_is_event_queue_empty(event_queue))
    {
      redraw = false;
 541
      /* Draw window area */
      al_set_target_backbuffer(display);
      al_clear_to_color(al_map_rgb(255, 255, 255));
 545
      /* Draw text */
      al_draw_text(font, al_map_rgb(200, 0, 0), (SCREEN_W / 2), (GAME_AREA_OFFSY / 2), ALLEGRO_ALIGN_CENTRE, "T.A.N.K.S");
 548
      al_draw_text(font, al_map_rgb(200, 0, 0), INFO_TEXT_X, PLAYER_TEXT_Y, ALLEGRO_ALIGN_LEFT, "PLAYER");
      sprintf(tmpText, "%d", playerTank.points);
      al_draw_text(font, al_map_rgb(200, 0, 0), INFO_TEXT_X, PLAYER_TEXT_Y + al_get_font_line_height(font), ALLEGRO_ALIGN_LEFT, tmpText);
 552
      al_draw_text(font, al_map_rgb(200, 0, 0), INFO_TEXT_X, ENEMY_TEXT_Y, ALLEGRO_ALIGN_LEFT, "ENEMY");
      sprintf(tmpText, "%d", enemyTank.points);
      al_draw_text(font, al_map_rgb(200, 0, 0), INFO_TEXT_X, ENEMY_TEXT_Y + al_get_font_line_height(font), ALLEGRO_ALIGN_LEFT, tmpText);
 556
      /* Draw background */
      al_draw_bitmap(backGround, GAME_AREA_OFFSX, GAME_AREA_OFFSY, 0);
 559
      /* Draw player */
      al_draw_rotated_bitmap(playerTank.bitmap, TANK_OFFS_X, TANK_OFFS_Y, playerTank.x, playerTank.y, playerTank.rotAngle, 0);
      if (playerShot.active)
      {
        al_draw_rotated_bitmap(playerShot.bitmap, BULLET_OFFS_X, BULLET_OFFS_Y, playerShot.x, playerShot.y, playerShot.rotAngle, 0);
      }
      
      /* Draw enemy */
      al_draw_rotated_bitmap(enemyTank.bitmap, TANK_OFFS_X, TANK_OFFS_Y, enemyTank.x, enemyTank.y, enemyTank.rotAngle, 0);
      if (enemyShot.active)
      {
        al_draw_rotated_bitmap(enemyShot.bitmap, BULLET_OFFS_X, BULLET_OFFS_Y, enemyShot.x, enemyShot.y, enemyShot.rotAngle, 0);
      }
     
     al_flip_display();
    }
  }
 577
  al_destroy_event_queue(event_queue);
  al_destroy_bitmap(enemyTank.bitmap);
  al_destroy_bitmap(enemyShot.bitmap);
  al_destroy_bitmap(playerTank.bitmap);
  al_destroy_bitmap(playerShot.bitmap);
  al_destroy_bitmap(backGround);
  al_destroy_font(font);
  al_destroy_display(display);
  al_destroy_timer(timer);
  
  al_uninstall_system();
 589
  return 0;
}

no-reply@allegro.cc (Arthur Kalliokoski) — Sun, 22 Dec 2013 02:09:56 +0000

Fredrik Beckman said:

the problem: it seems like my program starts without waiting for my keypress. After loading bitmaps, fonts and stuff I added a wait loop for pressing space, but if I start the program, wait for about 5 sec and then press space, I can see that the game started without me, kind of.

That's way too much unformatted code to wade through, but at a guess I'd say it does wait for the keypress, but then it "catches up" all at once before settling back down to the correct timer rate. Is there something you increment each loop then decrement every display flip? Set that to zero when the keypress finally comes.

no-reply@allegro.cc (Fredrik Beckman) — Sun, 22 Dec 2013 02:16:38 +0000

No increments, just a timer event.

Should I wait to start the timer until I press the key, maybe?

[EDIT]
Right on spot! Thanks Arthur. Solved - no timer event start until key press....

no-reply@allegro.cc (l j) — Sun, 22 Dec 2013 02:26:28 +0000

Don't use a busy loop like that.

Anyway, to fix your problem, start the timer after you've waited for the keypresses. I think your event queue is filled with unhandled timer events before starting your program.

no-reply@allegro.cc (Arthur Kalliokoski) — Sun, 22 Dec 2013 03:32:54 +0000

I just threw this little demo together real quick. It has the

#define NUM_BLITS 100000

to bog down the video card to simulate a slow card, at 100000 redraws of the ball per frame it slows down to 6.8 fps on my computer, but the ball still moves at the correct speed overall. Adjust to suit, or set to 1 to see how fast the ball will move unloaded.

Change

char font_string[] = "DejaVuSans.ttf";

to whatever ttf font you have handy.

Source code

I have to shower up and go to work now.

[EDIT]

I forgot to add stuff so it doesn't use 100% cpu, I'll update it tomorrow.

[EDIT2]

It doesn't hog cpu with NUMBLITS 1

no-reply@allegro.cc (Fredrik Beckman) — Sun, 22 Dec 2013 04:42:29 +0000

taron said:

Don't use a busy loop like that.

If you mean:

#SelectExpand
  /* SPACE pressed */
  do
  {
    al_get_keyboard_state(&kbdstate);
  } while (al_key_down(&kbdstate, ALLEGRO_KEY_SPACE) != true);
  
  /* SPACE released */
  do
  {
    al_get_keyboard_state(&kbdstate);
  } while (al_key_down(&kbdstate, ALLEGRO_KEY_SPACE) == true);

then I couldn't agree more, that's ugly, but added before I saw the problem. Will fix that soon along with a lot of other stuff... and yes - you saw the problem too. Timer event started too soon.

Arthur Kalliokoski said:

I just threw this little demo together real quick

Too kind It looked interesting, will check it a bit deeper tomorrow if I get a chance. Close to Christmas though, so maybe I don't get get more time until later in the week.

thanks for the comments and merry christmas!

Allegro 5.0.10 strange behaviour