bool Game::initialize()
{
m_pNetwork->initialize();
m_pFrameTimer = al_create_timer(1.0 / FPS);
if (!m_pFrameTimer)
{
return false;
}
m_pNetworkTimer = al_create_timer(0.06);
if (!m_pNetworkTimer)
{
return false;
}
if (!m_pGraphics->initialize())
{
al_destroy_timer(m_pFrameTimer);
return false;
}
if (!m_pPlatform[0]->initialize() || !m_pPlatform[1]->initialize() || !m_pBall->initialize())
{
al_destroy_timer(m_pFrameTimer);
return false;
}
m_pEventQueue = al_create_event_queue();
if (!m_pEventQueue)
{
al_destroy_timer(m_pFrameTimer);
return false;
}
al_register_event_source(m_pEventQueue, al_get_display_event_source(m_pGraphics->getDisplay()));
al_register_event_source(m_pEventQueue, al_get_timer_event_source(m_pFrameTimer));
al_register_event_source(m_pEventQueue, al_get_timer_event_source(m_pNetworkTimer));
al_register_event_source(m_pEventQueue, al_get_keyboard_event_source());
al_set_target_bitmap(al_get_backbuffer(m_pGraphics->getDisplay()));
al_clear_to_color(al_map_rgb(0, 0, 0));
al_flip_display();
al_start_timer(m_pFrameTimer);
al_start_timer(m_pNetworkTimer);
return true;
}
GUI::GUI()
{
al_init();
al_init_image_addon();
al_init_primitives_addon();
al_init_font_addon();
al_install_keyboard();
al_set_new_display_flags(ALLEGRO_WINDOWED);
display = al_create_display(640, 480);
al_set_window_position(display,10,10);
al_set_window_title(display, "Rogue");
timer = al_create_timer(1.0 / TICK_PER_S);
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_display_event_source(display));
al_register_event_source(queue, al_get_timer_event_source(timer));
al_start_timer(timer);
viewport.view = Rectangle(0,0,640,480);
tiles = al_load_bitmap("Images/Phoebus_tileset.png");
}
void gfx_init(int w, int h, int fps)
{
if (!al_init())
die(1, "can't init allegro\n");
if (!(al_init_primitives_addon()))
die(1, "can't init primitives addon\n");
if (!(al_install_keyboard()))
die(1, "can't init keyboard\n");
if (!(G.display = al_create_display(w, h)))
die(2, "can't create display");
if (!(G.ev = al_create_event_queue()))
die(3, "can't create event queue");
if (!(G.tick = al_create_timer(1.0 / (fps*MOVE_FRAMES))))
die(4, "invalid fps");
al_init_font_addon(); // initialize the font addon
al_init_ttf_addon(); // initialize the ttf (True Type Font) addon
G.font = al_load_ttf_font("font.ttf", 10,0 );
assert(G.font);
/* current position is the begining */
G.gi.cur[0] = G.gi.start[0];
G.gi.cur[1] = G.gi.start[1];
G.w = w;
G.h = h;
al_register_event_source(G.ev, al_get_keyboard_event_source());
al_register_event_source(G.ev, al_get_display_event_source(G.display));
al_register_event_source(G.ev, al_get_timer_event_source(G.tick));
al_start_timer(G.tick);
}
void game_loop(void)
{
bool redraw = true;
al_start_timer(timer);
while (!done) {
ALLEGRO_EVENT event;
al_wait_for_event(event_queue, &event);
switch(event.type)
{
case ALLEGRO_EVENT_TIMER:
redraw = true;
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
return;
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
return;
break;
}
if (redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
draw(display);
al_flip_display();
}
}
}
void Engine::Init()
{
done = false;
al_init(); //Initialises the allegro library
al_init_image_addon();
al_init_primitives_addon();
display = al_create_display(WIDTH, HEIGHT);
al_set_window_title(display, "Double Pendulum Simulation");
al_install_keyboard(); //Installs keyboard driver
al_install_mouse(); //installs mouse driver
eventQueue = al_create_event_queue();
al_register_event_source(eventQueue, al_get_display_event_source(display));
al_register_event_source(eventQueue, al_get_keyboard_event_source());
al_register_event_source(eventQueue, al_get_mouse_event_source());
timer = al_create_timer(1.0f / FPS);
al_register_event_source(eventQueue, al_get_timer_event_source(timer));
al_start_timer(timer);
doublePendulum = new DoublePendulum();
doublePendulum->Init(150, 150, 4, 4, 0.5, 0.5, 400, 200);
}
void AllegroEngine::Start()
{
al_start_timer(timer_fps);
quit=false;
while(!quit)
Run();
}
static SCM
game_run (SCM game_smob)
{
Game *game = check_game (game_smob);
if (scm_is_true (game->on_start)) {
scm_call_0 (game->on_start);
}
al_start_timer (game->timer);
game->last_update_time = al_get_time ();
while (game->running) {
game_process_event (game);
if (game->redraw && al_is_event_queue_empty (game->event_queue)) {
game->redraw = false;
game_draw (game);
}
}
game_destroy (game);
return SCM_UNSPECIFIED;
}
void DrawingClass::Run () {
bool redraw = false;
al_start_timer(mTimer);
while (!mDone) {
ALLEGRO_EVENT ev;
al_wait_for_event(mEventQueue, &ev);
if (ev.type == ALLEGRO_EVENT_TIMER) {
mInterface->Update();
redraw = true;
} else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
mDone = true;
} else if (ev.type == ALLEGRO_EVENT_MOUSE_AXES ||
ev.type == ALLEGRO_EVENT_MOUSE_ENTER_DISPLAY) {
mMousePosition.x = ev.mouse.x;
mMousePosition.y = ev.mouse.y;
} else if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP) {
mInterface->Mouse(MouseUp);
} else if (ev.type == ALLEGRO_EVENT_KEY_DOWN) {
mInterface->Keyboard(KeyMap[ev.keyboard.keycode]);
}
if (redraw && al_is_event_queue_empty(mEventQueue)) {
redraw = false;
al_clear_to_color(al_map_rgb(0,0,0));
mInterface->Draw();
al_flip_display();
}
}
}
void inicializar_timer_mothership(Mothership *mothership) {
mothership->event_queue = al_create_event_queue();
mothership->timer = al_create_timer(mothership->frequencia);
al_register_event_source(mothership->event_queue, al_get_timer_event_source(mothership->timer));
al_start_timer(mothership->timer);
}
void game_loop(void)
{
bool redraw = true;
al_start_timer(timer);
int frame = 0;
while (!done) {
ALLEGRO_EVENT event;
al_wait_for_event(event_queue, &event);
if (event.type == ALLEGRO_EVENT_TIMER) {
redraw = true;
//update_logic();
}
else if (event.type == ALLEGRO_EVENT_KEY_DOWN) {
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
done = true;
}
get_user_input(event.keyboard.keycode);
}
if (redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
al_clear_to_color(al_map_rgb(0,0,0));
update_graphics();
al_flip_display();
}
frame++;
}
}
void game_loop(ALLEGRO_EVENT_QUEUE **event_queue, ALLEGRO_TIMER **timer,
ALLEGRO_DISPLAY **display, bool *done)
{
al_start_timer(*timer);
ALLEGRO_EVENT event;
bool redraw = true;
Game game(event_queue, timer, display);
while(!*done)
{
al_wait_for_event(*event_queue, &event);
if(event.type == ALLEGRO_EVENT_TIMER)
{
redraw = true;
game.update();
} // if timer ticks
else
{
if(event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
break;
game.inputs.gather(&event);
} // else
if(redraw && al_is_event_queue_empty(*event_queue))
{
game.draw();
redraw = false;
} // if redraw
} // while not done
} // gameloop()
void Framework::Run()
{
#ifdef WRITE_LOG
fprintf( LogFile, "Framework: Run.Program Loop\n" );
#endif
ProgramStages->Push( new BootUp() );
al_start_timer( frameTimer );
while( !quitProgram )
{
ProcessEvents();
while( framesToProcess > 0 )
{
if( ProgramStages->IsEmpty() )
{
break;
}
ProgramStages->Current()->Update();
#ifdef DOWNLOAD_SUPPORT
DOWNLOADS->Update();
#endif
framesToProcess--;
}
if( !ProgramStages->IsEmpty() )
{
ProgramStages->Current()->Render();
DISPLAY->Render();
}
}
}
int init(ALG* allg, ALLEGRO_FONT* font)
{
if (!al_init()) {
fprintf(stderr, "failed to initialize allegro!\n");
return -1;
}
if (!al_install_keyboard()) {
fprintf(stderr, "failed to initialize the keyboard!\n");
return -1;
}
allg->timer2 = al_create_timer(1.0 / FPS);
if (!allg->timer2) {
fprintf(stderr, "failed to create timer!\n");
return -1;
}
allg->display2 = al_create_display(SCREEN_W, SCREEN_H);
if (!allg->display2) {
fprintf(stderr, "failed to create display!\n");
al_destroy_timer(allg->timer2);
return -1;
}
al_set_window_title(allg->display2, "Set Value");
al_init_font_addon();
al_clear_to_color(al_map_rgb(255, 0, 255));
al_set_target_bitmap(al_get_backbuffer(allg->display2));
allg->event_queue2 = al_create_event_queue();
if (!allg->event_queue2) {
fprintf(stderr, "failed to create event_queue!\n");
al_destroy_display(allg->display2);
al_destroy_timer(allg->timer2);
return -1;
}
al_register_event_source(allg->event_queue2, al_get_display_event_source(allg->display2));
al_register_event_source(allg->event_queue2, al_get_timer_event_source(allg->timer2));
al_register_event_source(allg->event_queue2, al_get_keyboard_event_source());
al_clear_to_color(al_map_rgb(0, 0, 0));
al_draw_text(font, al_map_rgb(255, 255, 255), 150 / 2, 30, ALLEGRO_ALIGN_CENTRE, "value:");
al_flip_display();
al_start_timer(allg->timer2);
return 0;
}
void TimerEvent::start(void)
{
RAGE_CHECK_DISPOSED(disposed);
if ((timer != nullptr) && !al_get_timer_started(timer))
al_start_timer(timer);
}
void BaseGame::run()
{
gameTime = new GameTime();
al_start_timer(timer);
while(running)
{
ALLEGRO_EVENT events;
al_wait_for_event(eventQueue, &events);
if(events.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
stop();
}
else if(events.type == ALLEGRO_EVENT_TIMER)
{
gameTime->Update();
prevMouseState = mouseState;
prevKeyState = keyState;
al_get_keyboard_state(&keyState);
al_get_mouse_state(&mouseState);
Update(gameTime);
Draw(gameTime);
al_flip_display();
al_clear_to_color(CORNFLOWER_BLUE);
}
}
}
void tela_boot_jogo (Jogo* jogo) {
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_EVENT ev;
int alfa = 0;
int velocidade = 5;
ALLEGRO_BITMAP* minerva = al_load_bitmap("resources/minerva.png");
if (minerva == NULL) {
puts("Erro ao carregar o arquivo \"resources/minerva.png\"");
puts("Erro ao carregar o arquivo resources/minerva.png");
exit(0);
}
event_queue = al_create_event_queue();
timer = al_create_timer(1.0 / 30);
al_register_event_source(event_queue, al_get_display_event_source(jogo->display));
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_install_keyboard();
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_rest(1);
al_start_timer(timer);
while (true) {
alfa += velocidade;
al_wait_for_event(event_queue, &ev);
if (ev.type == ALLEGRO_EVENT_TIMER) {
if (alfa > 0 && alfa < 255) {
al_clear_to_color(al_map_rgb(0,0,0));
al_draw_tinted_bitmap(minerva,
al_map_rgba(alfa, alfa, alfa, alfa),
(jogo->largura - al_get_bitmap_width(minerva))/2,
(jogo->altura - al_get_bitmap_height(minerva))/2,
0);
al_flip_display();
}
if (alfa > 350)
velocidade = -velocidade;
if (alfa < 0)
break;
}
else if (ev.type == ALLEGRO_EVENT_KEY_DOWN) {
break;
}
}
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
al_destroy_bitmap(minerva);
}
int main(int argc, char * argv[])
{
ALLEGRO_CONFIG *config;
ALLEGRO_EVENT event;
unsigned buffer_count;
unsigned samples;
const char *s;
initialize();
if (argc < 2) {
log_printf("This example needs to be run from the command line.\nUsage: %s {audio_files}\n", argv[0]);
goto done;
}
buffer_count = 0;
samples = 0;
config = al_load_config_file("ex_stream_seek.cfg");
if (config) {
if ((s = al_get_config_value(config, "", "buffer_count"))) {
buffer_count = atoi(s);
}
if ((s = al_get_config_value(config, "", "samples"))) {
samples = atoi(s);
}
al_destroy_config(config);
}
if (buffer_count == 0) {
buffer_count = 4;
}
if (samples == 0) {
samples = 1024;
}
stream_filename = argv[1];
music_stream = al_load_audio_stream(stream_filename, buffer_count, samples);
if (!music_stream) {
abort_example("Stream error!\n");
}
loop_start = 0.0;
loop_end = al_get_audio_stream_length_secs(music_stream);
al_set_audio_stream_loop_secs(music_stream, loop_start, loop_end);
al_set_audio_stream_playmode(music_stream, ALLEGRO_PLAYMODE_LOOP);
al_attach_audio_stream_to_mixer(music_stream, al_get_default_mixer());
al_start_timer(timer);
while (!exiting) {
al_wait_for_event(queue, &event);
event_handler(&event);
}
done:
myexit();
al_destroy_display(display);
close_log(true);
return 0;
}
bool init()
{
if (!al_init())
return false;
if (!al_init_image_addon())
return false;
if (!al_install_keyboard())
return false;
if (!al_install_mouse())
return false;
_eventQueue = al_create_event_queue();
if (!_eventQueue)
return false;
_timer = al_create_timer(1.0f / 30.0f);
if (!_timer)
return (false);
al_register_event_source(_eventQueue, al_get_keyboard_event_source());
al_start_timer(_timer);
_cameraContext = new CameraCtx();
if (!_cameraContext)
return false;
_captureListener = new CaptureListener();
if (!_captureListener)
return false;
_captureDisplay = new CaptureDisplay();
if (!_captureDisplay)
return false;
_slideshowDisplay = new SlideshowDisplay();
if (!_slideshowDisplay)
return false;
_optionParser = new OptionParser();
if (!_optionParser)
return false;
if (!_cameraContext->init())
return false;
if (!_captureListener->init())
return false;
if (!_captureDisplay->init())
return false;
if (!_slideshowDisplay->init())
return false;
if (!_optionParser->init())
return false;
// init subscriptions
sub("stopRunning", [&](){
this->_running = false;
});
return true;
}
int main(int argc, char * argv[])
{
ALLEGRO_CONFIG *config;
ALLEGRO_EVENT event;
unsigned buffer_count;
unsigned samples;
const char *s;
if (argc < 2) {
printf("Usage: ex_stream_seek <filename>\n");
return -1;
}
if (!initialize())
return 1;
buffer_count = 0;
samples = 0;
config = al_load_config_file("ex_stream_seek.cfg");
if (config) {
if ((s = al_get_config_value(config, "", "buffer_count"))) {
buffer_count = atoi(s);
}
if ((s = al_get_config_value(config, "", "samples"))) {
samples = atoi(s);
}
al_destroy_config(config);
}
if (buffer_count == 0) {
buffer_count = 4;
}
if (samples == 0) {
samples = 1024;
}
stream_filename = argv[1];
music_stream = al_load_audio_stream(stream_filename, buffer_count, samples);
if (!music_stream) {
printf("Stream error!\n");
return 1;
}
loop_start = 0.0;
loop_end = al_get_audio_stream_length_secs(music_stream);
al_set_audio_stream_loop_secs(music_stream, loop_start, loop_end);
al_set_audio_stream_playmode(music_stream, ALLEGRO_PLAYMODE_LOOP);
al_attach_audio_stream_to_mixer(music_stream, al_get_default_mixer());
al_start_timer(timer);
while (!exiting) {
al_wait_for_event(queue, &event);
event_handler(&event);
}
myexit();
return 0;
}
int MenuManager::main_loop(ALLEGRO_TIMER *timer,ALLEGRO_EVENT_QUEUE *event_queue,Client *myDad){
bool done=false;
bool redraw=false;
ALLEGRO_EVENT ev;
ALLEGRO_MOUSE_STATE mouseState;
al_clear_to_color(al_map_rgb(255,255,255));
al_start_timer(timer);
while(!done){
al_wait_for_event(event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
exit(0);
else if(ev.type == ALLEGRO_EVENT_KEY_DOWN){
if(ev.keyboard.keycode == ALLEGRO_KEY_ESCAPE){
exit(0);
}
}
else if(ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN){
int result=menu->botao_action();
if(result==EXIT)
exit(0);
else if(result==CHANGE_MENU){
delete menu;
menu=new MenuArmas(res_x,res_y);
}
else if(result == MENU_RIFLE){
myDad->setWeapon(RIFLE);
if(!myDad->connect()){
std::cout << "Error connecting to the server\n";
exit(-1);
}
myDad->main_loop();
exit(0);
}
else if(result == MENU_PISTOL){
myDad->setWeapon(PISTOL);
if(!myDad->connect()){
std::cout << "Error connecting to the server\n";
exit(-1);
}
myDad->main_loop();
exit(0);
}
}
else if(ev.type == ALLEGRO_EVENT_TIMER){
al_get_mouse_state(&mouseState);
menu->botao(&mouseState);
redraw=true;
}
if(redraw && al_is_event_queue_empty(event_queue)){
menu->print_menu();
al_flip_display();
redraw=false;
}
}
}
void Core::GameLoop()
{
al_start_timer(timer);
while(running)
{
Update();
Draw();
}
}
bool init(int w, int h, bool fullscreen = false) {
// HWND hWndDisplay = NULL;
const char* err;
#define INIT(x, y) if(!(x)) { err = y; goto err; }
mt_seed();
// Allegro initialization
INIT( al_init() &&
al_install_mouse() &&
al_install_keyboard() &&
al_init_image_addon() &&
al_init_primitives_addon(),
"initialize allegro" );
if(fullscreen) al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
INIT(display = al_create_display(w, h), "create display")
al_set_window_title(display, "ŒwiteŸ");
// { auto icon = al_load_bitmap("img\\icon.gif");
// if(icon) al_set_display_icon(display, icon); }
// if(fullscreen) {
// hWndDisplay = al_get_win_window_handle(display);
// SetWindowLong(hWndDisplay, GWL_STYLE, 0);
// ShowWindow(hWndDisplay, SW_MAXIMIZE);
// }
INIT(timer = al_create_timer(1.0 / 60), "create timer")
INIT(event_queue = al_create_event_queue(), "create event queue")
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_start_timer(timer);
// End of Allegro initialization
INIT(setup(display), "initialize renderer");
#undef INIT
return true;
err:
if(display) al_destroy_display(display);
{
char* buf = new char[strlen(err) + 13];
sprintf(buf, "Failed to %s!\n", err);
// MessageBoxA(NULL, buf, "Error", MB_ICONERROR);
delete buf;
}
return false;
}
void AllegroShell::run(){
// run the loop
unsigned num = 0;
ALLEGRO_EVENT ev;
al_start_timer(timer);
unsigned keyboard_count = 0;
unsigned mouse_count = 0;
unsigned timer_count = 0;
while( run_flag ){
al_wait_for_event(queue,&ev);
num++;
printf("\r%d",num);
if( ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE){
run_flag = false;
}else if( isKeyboardEvent(&ev)){
// handle keyboard input
++keyboard_count;
al_get_keyboard_state(&(keyboard));
handle_keyboard(&ev);
}else if( isMouseEvent(&ev) ){
// handle mouse input
++mouse_count;
mouse->update(&ev);
handle_mouse(&ev);
}else if( ev.type == ALLEGRO_EVENT_TIMER){
++timer_count;
// Update the model only if we haven't drawn the scene
if(draw_flag == false){
if(step_once_flag){
// always step once if the user requests it
model->step();
step_once_flag = false;
}else if(step_flag) {
model->step();
}
}
draw_flag = true;
}else if (ev.type == USER_VIEW_EVENT){
// handling user events
al_unref_user_event(&ev.user);
}
if( draw_flag && al_event_queue_is_empty(queue)){
draw();
draw_flag = false;
}
} // end while(run_flag)
Textlog::get().log("\nkeyboard_count = %u\n",keyboard_count);
Textlog::get().log("mouse_count = %u\n",mouse_count);
Textlog::get().log("timer_count = %u\n",timer_count);
}
int main( int argc, char **argv )
{
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
//VARIABLES
const int FPS =200;
bool redraw = true;
bool jump = false;
SCR_CREATE_DISPLAY
INIT_ALLEGRO_ADDONS
initGameCore();
event_queue = al_create_event_queue();
timer = al_create_timer(1.0 / FPS);
REGISTER_QUEUE
al_clear_to_color(al_map_rgb(0,0,0));
srand(time(NULL));
al_start_timer(timer);
while(!done)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { done = true; }
else if( (ev.type == ALLEGRO_EVENT_KEY_DOWN)||(ev.type == ALLEGRO_EVENT_KEY_UP) )
{ manageKeys(ev); }
if(ev.type == ALLEGRO_EVENT_TIMER)
{
//cout << "loop\n";
managePlayer();
//cout << "going for progress\n";
AnimatorHolder::Progress( GET_TIMER(timer) );
terrain->drawTerrain();
AnimatorHolder::Draw();
//cout << "leaving for progress\n";
DestructionManager::Commit();
al_flip_display();
al_clear_to_color(al_map_rgb(0,0,0));
}
}
DESTROY_SEQ
return 1;
}
int main(void){
init_allegro();
bool redraw = true;
bool done = false;
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
al_start_timer(timer);
init_stars();
while(!done){
ALLEGRO_EVENT event;
al_wait_for_event(event_queue, &event);
switch (event.type) {
case ALLEGRO_EVENT_TIMER:
redraw = true;
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
done = true;
break;
case ALLEGRO_EVENT_KEY_UP:
switch(event.keyboard.keycode){
case ALLEGRO_KEY_MINUS:
// decrease velocity of each plane
velocity_1-=1;
velocity_2-=2;
velocity_3-=3;
break;
case ALLEGRO_KEY_EQUALS:
// decrease velocity of each plane
velocity_1+=1;
velocity_2+=2;
velocity_3+=3;
break;
case ALLEGRO_KEY_Q:
done = true;
break;
}
}
if(redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
draw_stars();
}
}
return 0;
}
int startGame(Difficulty difficulty){
int render = 0;
State state = ON_GAME;
ALLEGRO_EVENT_QUEUE *event_queue;
ALLEGRO_TIMER *timer;
ALLEGRO_FONT fonts[10];
ALLEGRO_BITMAP *bg1;
ALLEGRO_BITMAP *bg2;
ALLEGRO_BITMAP *bg3;
ALLEGRO_BITMAP *bg4;
al_clear_to_color(al_map_rgb(255, 255, 255));
al_flip_display();
al_init_native_dialog_addon();
event_queue = al_create_event_queue();
timer = al_create_timer(1.0 / 60);
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_display_event_source(al_get_current_display()));
al_start_timer(timer);
while (state == ON_GAME || state == PAUSED){
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if (ev.type == ALLEGRO_EVENT_KEY_DOWN){
if (state != PAUSED){
switch (ev.keyboard.keycode){
case ALLEGRO_KEY_ESCAPE:
state = PAUSED;
break;
}
}
else{
switch (ev.keyboard.keycode){
case ALLEGRO_KEY_P:
return 0;
break;
}
}
}
else if (ev.type == ALLEGRO_EVENT_TIMER)
{
render = 1;
}
if (render == 1 && al_is_event_queue_empty(event_queue))
{
render = 0;
}
}
return 0;
}
void
start_video_effect (enum video_effect_type type, int duration)
{
ALLEGRO_BITMAP *screen = mr.cell[0][0].screen;
video_effect.type = type;
video_effect.duration = duration;
clear_bitmap (effect_buffer, BLACK);
clear_bitmap (black_screen, BLACK);
draw_bitmap (screen, effect_buffer, 0, 0, 0);
al_start_timer (video_timer);
}
void initAutoReload()
{
if( ssConfig.automatic_reload_time > 0 ) {
if(!reloadtimer) {
reloadtimer = al_create_timer(ALLEGRO_MSECS_TO_SECS(ssConfig.automatic_reload_time));
} else {
al_set_timer_speed(reloadtimer, ALLEGRO_MSECS_TO_SECS(ssConfig.automatic_reload_time));
}
al_start_timer(reloadtimer);
}
//install_int( automaticReloadProc, ssConfig.automatic_reload_time );
}
Timer::Timer(){
Set(500);
running = false;
remainingTime = 0;
coreTimer = NULL;
coreTimer = al_create_timer(1.0 / 60);
startingTime = al_get_timer_count(coreTimer);
lastTick = al_get_timer_count(coreTimer);
al_start_timer(coreTimer);
}
Timer::Timer(double duration){
Set(duration);
running = false;
remainingTime = 0;
coreTimer = NULL;
coreTimer = al_create_timer(1.0 / 60);
startingTime = al_get_timer_count(coreTimer);
lastTick = al_get_timer_count(coreTimer);
al_start_timer(coreTimer);
lastFrameTimeStamp = al_get_timer_count(coreTimer);
globalDeltaTime = 0;
}
