void EventQueue::ignoreEvents() { checkInit(); al_unregister_event_source(this->implementation->allegroEventQueue, al_get_display_event_source(fgeal::display->implementation->allegroDisplay)); al_unregister_event_source(this->implementation->allegroEventQueue, al_get_keyboard_event_source()); al_unregister_event_source(this->implementation->allegroEventQueue, al_get_mouse_event_source()); al_flush_event_queue(this->implementation->allegroEventQueue); }
WPJInputUtil::~WPJInputUtil() { ClearAllTriggedEvents(); if (al_is_keyboard_installed()) al_unregister_event_source(m_pEventQueue, al_get_keyboard_event_source()); if (al_is_mouse_installed()) al_unregister_event_source(m_pEventQueue, al_get_mouse_event_source()); al_destroy_event_queue(m_pEventQueue); }
void Framework::close_log_window() { if (!textlog) return; al_unregister_event_source(event_queue, al_get_native_text_log_event_source(textlog)); textlog = NULL; }
void Window::resize(int width, int height, Window::WindowMode windowMode) { assert(mDisplay); if (windowMode == mWindowMode) { al_resize_display(mDisplay, width, height); return; } al_unregister_event_source(mEventQueue, al_get_display_event_source(mDisplay)); al_destroy_display(mDisplay); switch (windowMode) { case Windowed: al_set_new_display_flags(ALLEGRO_WINDOWED | ALLEGRO_OPENGL); break; case Resizable: al_set_new_display_flags(ALLEGRO_RESIZABLE | ALLEGRO_OPENGL); break; case FullScreen: al_set_new_display_flags(ALLEGRO_FULLSCREEN | ALLEGRO_OPENGL); break; } mDisplay = al_create_display(width, height); if (mDisplay == 0) { error(U"Creating a window failed"); sys::closeProgram(); } al_register_event_source(mEventQueue, al_get_display_event_source(mDisplay)); activate(); }
void Framework::UnregisterEventSource( ALLEGRO_EVENT_SOURCE* Source ) { if( Source != nullptr ) { al_unregister_event_source( eventAllegro, Source ); } }
void TimerEvent::unregister_from_queue(ALLEGRO_EVENT_QUEUE *queue) { RAGE_CHECK_DISPOSED(disposed); if (timer_queue != nullptr) al_unregister_event_source(timer_queue, al_get_timer_event_source(timer)); timer_queue = nullptr; }
GUI::~GUI() { al_stop_timer(timer); al_unregister_event_source(queue, al_get_keyboard_event_source()); al_unregister_event_source(queue, al_get_display_event_source(display)); al_unregister_event_source(queue, al_get_timer_event_source(timer)); al_destroy_event_queue(queue); al_destroy_bitmap(tiles); al_destroy_display(display); al_uninstall_keyboard(); al_shutdown_font_addon(); al_shutdown_primitives_addon(); al_shutdown_image_addon(); al_uninstall_system(); }
void Framework::ShutdownDisplay() { #ifdef WRITE_LOG printf( "Framework: Shutdown Display\n" ); #endif al_unregister_event_source( eventQueue, al_get_display_event_source( displaySurface ) ); fontMgr->Clear(); imageMgr->Clear(); al_destroy_display( displaySurface ); }
/* Internal function: _al_event_source_free * Free the resources using by an event source structure. It * automatically unregisters the event source from all the event * queues it is currently registered with. */ void _al_event_source_free(ALLEGRO_EVENT_SOURCE *es) { ALLEGRO_EVENT_SOURCE_REAL *this = (ALLEGRO_EVENT_SOURCE_REAL *)es; /* Unregister from all queues. */ while (!_al_vector_is_empty(&this->queues)) { ALLEGRO_EVENT_QUEUE **slot = _al_vector_ref_back(&this->queues); al_unregister_event_source(*slot, es); } _al_vector_free(&this->queues); _al_mutex_destroy(&this->mutex); }
static int allua_Event_queue_unregister_event_source(lua_State * L) { ALLUA_event_queue event_queue = allua_check_event_queue(L, 1); ALLUA_event_source event_source = allua_check_event_source(L, 2); if (!event_source) { luaL_error(L, "null Event_source"); } al_unregister_event_source(event_queue, event_source); printf("Event_queue (%p) ", (void *)event_queue); printf("unregistered (%p)\n", (void *)event_source); return 0; }
void TimerEvent::dispose(void) { if (disposed) return; if (timer_queue != nullptr) al_unregister_event_source(timer_queue, al_get_timer_event_source(timer)); if (timer != nullptr) al_destroy_timer(timer); rb_ary_clear(timer_observer); disposed = true; }
void * kresliace_vlakno(ALLEGRO_THREAD *thread, void *event_queue) { ALLEGRO_DISPLAY *display = NULL; display = al_create_display(640, 480); if (!display) { fprintf(stderr, "failed to create display!\n"); exit(1); } al_register_event_source(event_queue, al_get_display_event_source(display)); while (!al_get_thread_should_stop(thread)) { al_clear_to_color(al_map_rgb(100,0,100)); int i = 0; al_lock_mutex(mutex); // struct Player * _player = player_copy(player); struct List *kopia_sceny = list_deep_copy(scena, objekt_copy); al_unlock_mutex(mutex); /* for (i = 0; i < 300; i++) { player_draw(_player); }*/ struct List *iterator = kopia_sceny; for (; iterator != NULL; iterator = iterator->next) { struct Objekt *obj = iterator->item; obj->draw(obj->objekt); } //zmazeme kopie objektov z kopie sceny iterator = kopia_sceny; for (; iterator != NULL; iterator = iterator->next) { struct Objekt *obj = iterator->item; obj->destroy(obj->objekt); free(obj); } //zmazeme kopiu sceny // list_destroy(kopia_sceny); // player_destroy(_player); al_flip_display(); } al_unregister_event_source(event_queue, al_get_display_event_source(display)); al_destroy_display(display); }
/* Function: al_destroy_event_queue */ void al_destroy_event_queue(ALLEGRO_EVENT_QUEUE *queue) { ASSERT(queue); _al_unregister_destructor(_al_dtor_list, queue); /* Unregister any event sources registered with this queue. */ while (_al_vector_is_nonempty(&queue->sources)) { ALLEGRO_EVENT_SOURCE **slot = _al_vector_ref_back(&queue->sources); al_unregister_event_source(queue, *slot); } ASSERT(_al_vector_is_empty(&queue->sources)); _al_vector_free(&queue->sources); ASSERT(queue->events_head == queue->events_tail); _al_vector_free(&queue->events); _al_cond_destroy(&queue->cond); _al_mutex_destroy(&queue->mutex); al_free(queue); }
void SceneManager::sendContextWillChangedMessage() { al_unregister_event_source(queue, al_get_display_event_source(m_devices->getDisplay()->getContext())); }
int main() { camera *cam = camera_inicializa(0); if(!cam) erro("nao foi possivel inicializar camera"); int largura = cam->largura; int altura = cam->altura; if(!al_init()) erro("nao foi possivel inicializar allegro"); if(!al_init_primitives_addon()) erro("nao foi possivel inicializar adicional de primitivas"); if(!al_init_image_addon()) erro("nao foi possivel inicializar a adicional de imagem "); ALLEGRO_EVENT_QUEUE *queue = al_create_event_queue(); if(!queue) erro("nao foi possivel criar fila de eventos"); ALLEGRO_DISPLAY *display = al_create_display(2 * largura, altura * 2); if(!display) erro("nao foi possivel criar janela"); al_register_event_source(queue, al_get_display_event_source(display)); ALLEGRO_TIMER *timer = al_create_timer(1.0 / FPS); if(!timer) erro("nao foi possivel criar relogio"); al_register_event_source(queue, al_get_timer_event_source(timer)); /**********/ unsigned char ***matriz = camera_aloca_matriz(cam); unsigned char ***anterior; ALLEGRO_COLOR cor = al_map_rgb_f(0, 0, 1); ALLEGRO_BITMAP *buffer = al_get_backbuffer(display); ALLEGRO_BITMAP *esquerda = al_create_sub_bitmap(buffer, 0, 0, largura, altura); ALLEGRO_BITMAP *direita = al_create_sub_bitmap(buffer, largura, 0, largura, altura); ALLEGRO_BITMAP * baixo = al_create_sub_bitmap(buffer, largura/2, altura, largura, altura); sniper = al_load_bitmap("semi.png"); /**********/ int continuar = 1; int atualizar = 0; al_start_timer(timer); while(continuar) { ALLEGRO_EVENT event; al_wait_for_event(queue, &event); switch(event.type) { case ALLEGRO_EVENT_DISPLAY_CLOSE: continuar = 0; break; case ALLEGRO_EVENT_TIMER: atualizar = 1; break; } if(atualizar && al_is_event_queue_empty(queue)) { camera_atualiza(cam); /**********/ int cy = 0; int cx = 0; int cn = 0; for(int y = 0; y < altura; y++) for(int x = 0; x < largura; x++) { float r = (cam->quadro[y][x][0]) / 255; float g = (cam->quadro[y][x][1]) / 255; float b = (cam->quadro[y][x][2]) / 255; /*if(compara_imagem(cam, matriz, anterior)) { cy += y; cx += x; cn += 1; matriz[y][x][0] = 255; matriz[y][x][1] = 255; matriz[y][x][2] = 255; } else { matriz[y][x][0] = 0; matriz[y][x][1] = 0; matriz[y][x][2] = 0; } } */ anterior = compara_imagem(cam, matriz, anterior); //int x1 = cx / cn; //int y1 = cy / cn; /**********/ } camera_copia(cam, cam->quadro, esquerda); camera_copia(cam, matriz, direita); camera_copia(cam, anterior, baixo); if(cn > 0){ //al_draw_circle(cx / cn, cy / cn, 120, cor, 1); //al_draw_bitmap(sniper, cx / cn, cy / cn, 120); // SNIPER al_draw_bitmap(sniper, cx / cn - 400, cy / cn - 300, 120); camera_copia(cam, cam->quadro, direita); /**********/ al_flip_display(); atualizar = 0; } } } al_stop_timer(timer); /**********/ al_destroy_bitmap(direita); al_destroy_bitmap(esquerda); camera_libera_matriz(cam, matriz); /**********/ al_unregister_event_source(queue, al_get_timer_event_source(timer)); al_destroy_timer(timer); al_unregister_event_source(queue, al_get_display_event_source(display)); al_destroy_display(display); al_destroy_event_queue(queue); al_shutdown_primitives_addon(); al_uninstall_system(); camera_finaliza(cam); return EXIT_SUCCESS; }
void AllegroEventSource::unwatchWindow(Window &w) { al_unregister_event_source(m_impl->event_queue, al_get_display_event_source(w.allegro_display())); }
Mouse::~Mouse() { al_unregister_event_source( EventQueue, &mouseEventSource ); al_destroy_event_queue( mouseQueue ); al_destroy_user_event_source( &mouseEventSource ); }
int main(void) { initialize(); int nva = al_get_num_video_adapters(); assert(nva); ALLEGRO_MONITOR_INFO aminfo; al_get_monitor_info(0, &aminfo); screen_w = aminfo.x2 - aminfo.x1 + 1; screen_h = aminfo.y2 - aminfo.y1 + 1; ALLEGRO_DISPLAY *display = al_create_display(screen_w, screen_h); ALLEGRO_EVENT_QUEUE *evqueue = al_create_event_queue(); ALLEGRO_TIMER *fps_timer = al_create_timer(1.0 / 120.0); al_set_display_flag(display, ALLEGRO_FULLSCREEN_WINDOW, true); if (!display) { printf("Failed to create display!\n"); exit(EXIT_FAILURE); } al_register_event_source(evqueue, al_get_keyboard_event_source()); al_register_event_source(evqueue, al_get_mouse_event_source()); al_register_event_source(evqueue, al_get_display_event_source(display)); al_register_event_source(evqueue, al_get_timer_event_source(fps_timer)); al_start_timer(fps_timer); //////////////////////////////////////////////////////////////////////////////////////////////// // Local Variables //////////////////////////////////////////////////////////////////////////////////////////////// //#ifdef DEBUG float fps = 0, delta_time = 0, current_time = 0, last_time = al_get_time(); //#endif //DEBUG bool render = true, executing = true; unsigned int spawn_counter = 0; Assets* assets = new Assets(); Stage stage = Menu; Stats stats; Button *play = new Button("Play", assets->fnt_menu, screen_w / 2, 300, [&stage, &stats]() -> void { stage = Game; stats.start_time = al_get_time(); }), *leaderboard = new Button("Leaderboard", assets->fnt_menu, screen_w / 2, 400, [&stage]() -> void { stage = Leaderboard; }), *options = new Button("Options", assets->fnt_menu, screen_w / 2, 500, [&stage]() -> void { stage = Options; }), *quit = new Button("Quit", assets->fnt_menu, screen_w / 2, 600, [&executing]() -> void { executing = false; }); b2Vec2 gravity(0.0f, 0.0f); b2World world(gravity); Projectile *player = new Projectile(assets->png_player, &world, screen_w / 2, screen_h - 200); std::vector<Projectile*> Meteors; //////////////////////////////////////////////////////////////////////////////////////////////// // Game Loop //////////////////////////////////////////////////////////////////////////////////////////////// while (executing) { ALLEGRO_EVENT event; al_wait_for_event(evqueue, &event); //#ifdef DEBUG current_time = al_get_time(); delta_time = current_time - last_time; fps = 1/(delta_time); last_time = current_time; //#endif //DEBUG world.Step(delta_time, 8, 3); switch (event.type) { // HANDLE ALLEGRO EVENTS case ALLEGRO_EVENT_TIMER: render = true; if (stage == Game) spawn_counter++; break; case ALLEGRO_EVENT_DISPLAY_CLOSE: executing = false; break; case ALLEGRO_EVENT_KEY_DOWN: executing = event.keyboard.keycode != ALLEGRO_KEY_ESCAPE; switch(event.keyboard.keycode) { case ALLEGRO_KEY_A: case ALLEGRO_KEY_LEFT: if (stage == Game) player->Velocity.x = -5; break; case ALLEGRO_KEY_D: case ALLEGRO_KEY_RIGHT: if (stage == Game) player->Velocity.x = 5; break; } break; case ALLEGRO_EVENT_KEY_UP: if (stage == Game) { player->Velocity.x = 0; player->Velocity.y = 0; } break; default: break; } switch (stage) { // UPDATE case Menu: play->Update(&event); leaderboard->Update(&event); options->Update(&event); quit->Update(&event); break; case Game: if (player->m_body->GetPosition().x < 1) player->m_body->SetTransform(b2Vec2(screen_w - 2, player->m_body->GetPosition().y), 0); if (player->m_body->GetPosition().x > screen_w - 1) player->m_body->SetTransform(b2Vec2(2, player->m_body->GetPosition().y), 0); if (spawn_counter > 75) { spawn_counter = 0; ALLEGRO_BITMAP *meteor_png; switch (rand() % 4) { // Size case 0: switch (rand() % 4) { // Selection case 0: meteor_png = rand() % 2 ? assets->png_meteor_brown_big1 : assets->png_meteor_grey_big1; break; case 1: meteor_png = rand() % 2 ? assets->png_meteor_brown_big2 : assets->png_meteor_grey_big2; break; case 2: meteor_png = rand() % 2 ? assets->png_meteor_brown_big3 : assets->png_meteor_grey_big3; break; case 3: meteor_png = rand() % 2 ? assets->png_meteor_brown_big4 : assets->png_meteor_grey_big4; break; default: break; } break; case 1: switch (rand() % 2) { // Selection case 0: meteor_png = rand() % 2 ? assets->png_meteor_brown_med1 : assets->png_meteor_grey_med1; break; case 1: meteor_png = rand() % 2 ? assets->png_meteor_brown_med2 : assets->png_meteor_grey_med2; break; default: break; } break; case 2: switch (rand() % 2) { // Selection case 0: meteor_png = rand() % 2 ? assets->png_meteor_brown_small1 : assets->png_meteor_grey_small1; break; case 1: meteor_png = rand() % 2 ? assets->png_meteor_brown_small2 : assets->png_meteor_grey_small2; break; default: break; } break; case 3: switch (rand() % 2) { // Selection case 0: meteor_png = rand() % 2 ? assets->png_meteor_brown_tiny1 : assets->png_meteor_grey_tiny1; break; case 1: meteor_png = rand() % 2 ? assets->png_meteor_brown_tiny2 : assets->png_meteor_grey_tiny2; break; default: break; } break; default: break; } auto it = Meteors.end(); Projectile *meteor = new Projectile(meteor_png, &world, rand() % screen_w, -75); meteor->Velocity = b2Vec2(-5 + (rand() % 10), rand() % 15); Meteors.insert(it, meteor); } for (std::vector<Projectile*>::iterator it = Meteors.begin(); it != Meteors.end(); ++it) { if (((*it)->m_body->GetPosition().x >= screen_w + 500 || (*it)->m_body->GetPosition().x <= -500) || ((*it)->m_body->GetPosition().y >= screen_h + 500 || (*it)->m_body->GetPosition().y <= -500) || (((*it)->m_body->GetTransform().p.x == 0.0) && (*it)->m_body->GetTransform().p.y == 0.0)) { delete *it; Meteors.erase(it); } } player->Update(&event); for (auto& x : Meteors) { x->Update(&event); } break; case Leaderboard: break; case Options: break; case End: break; default: break; } if (render && al_is_event_queue_empty(evqueue)) { render = false; al_clear_to_color(al_map_rgb(0, 0, 0)); al_set_target_bitmap(al_get_backbuffer(display)); for (float x = 0; x < screen_w; x += al_get_bitmap_width(assets->png_background)) { for (float y = 0; y < screen_h; y += al_get_bitmap_height(assets->png_background)) { al_draw_bitmap(assets->png_background, x, y, 0); } } #ifdef DEBUG //al_draw_textf(assets->fnt_menu, al_map_rgb(255, 0, 255), 10, 5, ALLEGRO_ALIGN_LEFT, "Debug"); //al_draw_textf(assets->fnt_menu, al_map_rgb(255, 0, 255), 10, 35, ALLEGRO_ALIGN_LEFT, "FPS: %i", (int)fps); //al_draw_textf(assets->fnt_menu, al_map_rgb(255, 0, 255), 10, 65, ALLEGRO_ALIGN_LEFT, "Meteor Count: %i", Meteors.size()); #endif // DEBUG switch (stage) { // RENDER default: break; case Menu: al_draw_text(assets->fnt_title, al_map_rgb(255, 255, 255), screen_w/2, 100, ALLEGRO_ALIGN_CENTRE, "SPACE SHOOTER III"); play->Render(); leaderboard->Render(); options->Render(); quit->Render(); break; case Game: player->Render(); for (auto& x : Meteors) { x->Render(); } break; case Leaderboard: break; case Options: break; case End: break; } al_flip_display(); } render = false; } //////////////////////////////////////////////////////////////////////////////////////////////// // Deinitialization //////////////////////////////////////////////////////////////////////////////////////////////// delete player; al_unregister_event_source(evqueue, al_get_keyboard_event_source()); al_unregister_event_source(evqueue, al_get_mouse_event_source()); al_unregister_event_source(evqueue, al_get_display_event_source(display)); al_unregister_event_source(evqueue, al_get_timer_event_source(fps_timer)); al_destroy_display(display); al_destroy_event_queue(evqueue); al_destroy_timer(fps_timer); delete assets; shutdown(); return EXIT_SUCCESS; }
UserEventEmitter::~UserEventEmitter() { al_unregister_event_source(Framework::event_queue, &event_source); }
int main() { bool menu = true; char pontuacao[100]; char vida[100]; ALLEGRO_COLOR font_color; ALLEGRO_FONT *font,*font2; ALLEGRO_AUDIO_STREAM *musica = NULL; camera *cam = camera_inicializa(0); if(!cam) erro("erro na inicializacao da camera\n"); int x = 0, y = 0; int largura = cam->largura; int altura = cam->altura; int fps = 0,tempo = 5; int ndisco = 9; if(!al_init()) erro("erro na inicializacao do allegro\n"); if(!al_init_image_addon()) erro("erro na inicializacao do adicional de imagem\n"); al_init_font_addon(); al_init_ttf_addon(); font_color = al_map_rgb(0, 0, 0); font = al_load_ttf_font("Fontes/Blokletters-Viltstift.ttf", 20, 0); font2 = al_load_ttf_font("Fontes/Blokletters-Viltstift.ttf", 50, 0); if(!al_init_primitives_addon()) erro("erro na inicializacao do adicional de primitivas\n"); ALLEGRO_TIMER *timer = al_create_timer(1.0 / FPS); if(!timer) erro("erro na criacao do relogio\n"); ALLEGRO_DISPLAY *display = al_create_display(2 * largura,altura); if(!display) erro("erro na criacao da janela\n"); ALLEGRO_EVENT_QUEUE *queue = al_create_event_queue(); if(!queue) erro("erro na criacao da fila\n"); if (!al_install_audio()) { fprintf(stderr, "Falha ao inicializar áudio.\n"); return false; } if (!al_init_acodec_addon()) { fprintf(stderr, "Falha ao inicializar codecs de áudio.\n"); return false; } if (!al_reserve_samples(1)) { fprintf(stderr, "Falha ao alocar canais de áudio.\n"); return false; } musica = al_load_audio_stream("Audio/elementary.ogg", 4, 1024); if(!musica) erro("Erro na alocação da musica de fundo\n"); al_attach_audio_stream_to_mixer(musica, al_get_default_mixer()); al_set_audio_stream_playing(musica, true); al_register_event_source(queue, al_get_timer_event_source(timer)); al_register_event_source(queue, al_get_display_event_source(display)); al_start_timer(timer); unsigned char ***matriz = camera_aloca_matriz(cam); ALLEGRO_BITMAP *buffer = al_get_backbuffer(display); ALLEGRO_BITMAP *fundo = al_load_bitmap("Imagens/Elementary2.png"); if(!fundo) erro("erro ao carregar Elementary.png"); ALLEGRO_BITMAP *esquerda = al_create_sub_bitmap(buffer, 0, 0, largura, altura); ALLEGRO_BITMAP *direita = al_create_sub_bitmap(buffer, largura, 0, largura, altura); /**********/ Disco *discos[9]; bool perdeu = false; carregarDiscos(discos); int pontos=0,velo = 1; int aux1 = 1; int vidas = 10; int ultimoDisco = 0; int distance = 0; int desenhar = 0; int terminar = 0; al_set_target_bitmap(esquerda); al_draw_bitmap(fundo,0,0,0); while(1) { ALLEGRO_EVENT event; al_wait_for_event(queue, &event); switch(event.type) { case ALLEGRO_EVENT_TIMER: desenhar = 1; break; case ALLEGRO_EVENT_DISPLAY_CLOSE: terminar = 1; break; } if(terminar) break; if(desenhar && al_is_event_queue_empty(queue)) { desenhar = 0; camera_atualiza(cam); mediana(cam); /**********/ al_set_target_bitmap(esquerda); al_draw_bitmap(fundo,0,0,0); if(!menu){ while(aux1 <= ndisco){ if(discos[aux1]->status == false){ if(distance > 50 || ultimoDisco==0 ){ printf("%d\n",aux1 ); al_draw_bitmap(discos[aux1]->elemento,discos[aux1]->pos_x,discos[aux1]->pos_y,0); discos[aux1]->status = true; distance = 0; ultimoDisco = aux1; break; }else aux1++; }else{ discos[aux1]->pos_y+=(10+velo); al_draw_bitmap(discos[aux1]->elemento,discos[aux1]->pos_x,discos[aux1]->pos_y,0); aux1++; } } distance = discos[ultimoDisco]->pos_y; for(aux1 = 1;aux1<ndisco;aux1++){ if(discos[aux1]->pos_x >= x-30 && discos[aux1]->pos_x <= x+30 && discos[aux1]->pos_y >= y-30 && discos[aux1]->pos_y <= y+30){ if(discos[aux1]->tipo == 2){ // Tipo do fogo(Necessario para vencer o jogo) pontos +=10; velo += 1; discos[aux1]->pos_x = rand()%9 * 55; discos[aux1]->pos_y = 0; discos[aux1]->status = false; }else if(discos[aux1]->tipo == 1){ //Tipo da agua(Perde o jogo se destruir esse disco) discos[aux1]->pos_x = rand()%9 * 55; discos[aux1]->pos_y = 0; discos[aux1]->status = false; al_flip_display(); vidas--; }else if(discos[aux1]->tipo == 3){//Tipo planta(Aumenta velocidade de queda das peças) velo *= 2; discos[aux1]->pos_x = rand()%9 * 55; discos[aux1]->pos_y = 0; discos[aux1]->status = false; } }else if( discos[aux1]->pos_y > 480){ if(discos[aux1]->tipo == 2){ //Tipo da agua e Planta(Não perde se deixar cair) discos[aux1]->pos_x = rand()%9 * 55; discos[aux1]->pos_y = 0; discos[aux1]->status = false; al_flip_display(); vidas--; }else{ discos[aux1]->pos_x = rand()%9 * 55; discos[aux1]->pos_y = 0; discos[aux1]->status = false; } } } aux1 = 1; sprintf(pontuacao,"PONTUAÇÃO: %d",pontos); al_draw_text(font, al_map_rgb(255, 255, 255), 50, 5, 0,pontuacao); sprintf(vida,"VIDAS: %d",vidas); al_draw_text(font, al_map_rgb(255, 255, 255), 300, 5, 0,vida); al_flip_display(); } if(perdeu){ al_draw_text(font2, al_map_rgb(255, 0, 0), 50, 100, 0,"PONTUAÇÃO FINAL"); sprintf(pontuacao,"%d",pontos); al_draw_text(font2, al_map_rgb(255, 0, 0), 250, 170, 0,pontuacao); al_flip_display(); al_rest(3); break; } if(vidas == 0){ perdeu = true; } if(menu){ if(abrirJogo(x,y,&fps,&tempo,font,font2, font_color)){ fundo = al_load_bitmap("Imagens/galaxia.png"); menu = false; } } cameraRastreia(cam,&x,&y); al_set_target_bitmap(direita); camera_copia(cam, cam->quadro, direita); al_flip_display(); } } al_destroy_bitmap(direita); al_destroy_bitmap(fundo); al_destroy_bitmap(esquerda); camera_libera_matriz(cam, matriz); int fri = 9; while(fri != 0){ free(discos[fri]); fri--; } al_stop_timer(timer); al_unregister_event_source(queue, al_get_display_event_source(display)); al_unregister_event_source(queue, al_get_timer_event_source(timer)); al_destroy_event_queue(queue); al_destroy_display(display); al_destroy_timer(timer); al_destroy_audio_stream(musica); al_shutdown_primitives_addon(); al_shutdown_image_addon(); al_uninstall_system(); camera_finaliza(cam); return EXIT_SUCCESS; }
void Mousebinds::shutdownMouseBinds() noexcept { al_unregister_event_source(m_events, m_mouseEventSource); al_destroy_event_queue(m_events); }
int main() { //inicialização camera *cam = camera_inicializa(0); if(!cam) erro("erro na inicializacao da camera\n"); int largura = cam->largura; int altura = cam->altura; if(!al_init()) erro("erro na inicializacao do allegro\n"); if(!al_init_image_addon()) erro("erro na inicializacao do adicional de imagem\n"); if(!al_init_primitives_addon()) erro("erro na inicializacao do adicional de primitivas\n"); ALLEGRO_TIMER *timer = al_create_timer(1.0 / FPS); if(!timer) erro("erro na criacao do relogio\n"); ALLEGRO_DISPLAY *display = al_create_display(largura, altura); if(!display) erro("erro na criacao da janela\n"); ALLEGRO_EVENT_QUEUE *queue = al_create_event_queue(); if(!queue) erro("erro na criacao da fila\n"); al_register_event_source(queue, al_get_timer_event_source(timer)); al_register_event_source(queue, al_get_display_event_source(display)); al_start_timer(timer); /**********/ unsigned char ***matriz = camera_aloca_matriz(cam); int ***background = alocaHsvMatriz(cam->largura, cam->altura); fila *f = aloca(); //cor para desenhar o círculo ALLEGRO_COLOR cor = al_map_rgb_f(0, 0, 1); ALLEGRO_BITMAP *buffer = al_get_backbuffer(display); //tela exibindo img normal ALLEGRO_BITMAP *esquerda = al_create_sub_bitmap(buffer, 0, 0, largura, altura); //tela mostrando como o computador enxerga //ALLEGRO_BITMAP *direita = al_create_sub_bitmap(buffer, largura/2, 0, largura/2, altura/2); ALLEGRO_BITMAP *silhueta = al_create_bitmap(largura, altura); /**********/ srand(time(NULL)); int desenhar = 0; int terminar = 0; int cycle = 0; int hitx = rand() % (largura); int hity = rand() % (altura); int x, y; float cyr, cxr, cnr, lastCx, lastCy; int r, g, b, r2, g2, b2; int h, s, v, h2, s2, v2; int fh, fs, fv; int dh, ds, dv; int tempH; int token; double value; int dist; al_rest(1); for(y = 0; y < altura; y++) for(x = 0; x < largura; x++){ rgbToHsv(cam->quadro[y][x][0], cam->quadro[y][x][1], cam->quadro[y][x][2], &background[y][x][0], &background[y][x][1], &background[y][x][2]); if(background[y][x][0] > 180){ background[y][x][0] -= 360; background[y][x][0] = -background[y][x][0]; } } al_rest(1); for(y = 0; y < altura; y++) for(x = 0; x < largura; x++){ rgbToHsv(cam->quadro[y][x][0], cam->quadro[y][x][1], cam->quadro[y][x][2], &fh, &fs, &fv); if(fh > 180){ fh -= 360; fh = -fh; } background[y][x][0] += fh; background[y][x][0] /=2; background[y][x][1] += fs; background[y][x][1] /=2; background[y][x][2] += fv; background[y][x][2] /=2; } //gameloop while(1) { ALLEGRO_EVENT event; al_wait_for_event(queue, &event); switch(event.type) { case ALLEGRO_EVENT_TIMER: desenhar = 1; break; case ALLEGRO_EVENT_DISPLAY_CLOSE: terminar = 1; break; default: printf("evento desconhecido\n"); } if(terminar) break; //interpretar img e realizar transformações printf("%d\n", al_is_event_queue_empty(queue)); if(desenhar && al_is_event_queue_empty(queue)) { desenhar = 0; camera_atualiza(cam); /**********/ int bx, by, bn; cyr = 0; cxr = 0; cnr = 0; for(y = 0; y < altura; y++){ for(x = 0; x < largura; x++){ //Espada r = cam->quadro[y][x][0]; g = cam->quadro[y][x][1]; b = cam->quadro[y][x][2]; rgbToHsv(r, g, b, &h, &s, &v); if(h < 15 || h > 345) if(s > 75 && v > 75){ cyr += y; cxr += x; cnr++; } //Silhueta (REFINAR!!!) if(h > 180) tempH = -(h - 360); else tempH = h; dh = tempH - background[y][x][0]; if(dh < 0) dh = -dh; ds = s - background[y][x][1]; if(ds < 0) ds = -ds; dv = v - background[y][x][2]; if(dv < 0) dv = -dv; //dh > 15 && ds > 10 para tirar a interfencia de iluminacao, mas gera mtuiro ruido //ds > 25 é o mais preciso, mas sofre de interferencia de iluminacao if(dv > 25){ //valores para teste! matriz[y][x][0] = 37; matriz[y][x][1] = 50; matriz[y][x][2] = 248; } else{ matriz[y][x][0] = 0; matriz[y][x][1] = 0; matriz[y][x][2] = 0; } //Escudo if(h < 135 && h > 105 && s > 50 && v > 75){ by += y; bx += x; bn++; matriz[y][x][0] = 0; matriz[y][x][1] = 255; matriz[y][x][2] = 0; } } } /*for(y = 1; y < altura-1; y++) for(x = 1; x < largura-1; x++){ token = 4; if(255 != matriz[y+1][x][0]) token--; if(255 != matriz[y-1][x][0]) token--; if(255 != matriz[y][x+1][0]) token--; if(255 != matriz[y][x-1][0]) token--; if(token == 0){ matriz[y][x][0] = 0; matriz[y][x][1] = 0; matriz[y][x][2] = 0; }*/ cycle++; if(cycle > 50 && bn > 0){ value = (pow(hitx - (bx / 2 /bn), 2) + pow(hity - (by / 2 / bn), 2)); dist = sqrt(value) - 7; if(dist < 100 && dist > -100 && bn > 0) printf("block!\n"); else{ if(matriz[hity][hitx][0] == 255) printf("hit\n"); else printf("miss\n"); } cycle = 0; hitx = rand() % (largura/2); hity = rand() % (altura/2); } /**********/ camera_copia(cam, cam->quadro, esquerda); //Copia img editada na img direita camera_copia(cam, matriz, silhueta); //cor para teste! al_convert_mask_to_alpha(silhueta, al_map_rgb(37, 50, 248)); al_draw_bitmap(silhueta, 0, 0, 0); /**********/ if(bn > 0) al_draw_circle(bx / bn, by / bn, 100, al_map_rgb(0, 0, 255), 1); if(cycle >= 40){ if(cycle < 48){ al_draw_circle(hitx, hity, 15, al_map_rgb(0, 0, 255), 30); al_draw_circle(hitx + largura, hity, 6, al_map_rgb(0, 0, 255), 3); } else al_draw_circle(hitx, hity, 15, al_map_rgb(255, 0, 0), 30); } if(cnr > 10){ lastCx = cxr / cnr; lastCy = cyr / cnr; al_draw_circle(lastCx, lastCy, 100, al_map_rgb(255, 0, 0), 1); insere(f, lastCx, lastCy); } else insere(f, lastCx, lastCy); if(f->count > 10) retira(f); drawAtk(f); al_flip_display(); } } /**********/ libera(f); al_destroy_bitmap(silhueta); al_destroy_bitmap(esquerda); camera_libera_matriz(cam, matriz); liberaHsvMatriz(background, cam->largura, cam->altura); /**********/ al_stop_timer(timer); al_unregister_event_source(queue, al_get_display_event_source(display)); al_unregister_event_source(queue, al_get_timer_event_source(timer)); al_destroy_event_queue(queue); al_destroy_display(display); al_destroy_timer(timer); al_shutdown_primitives_addon(); al_shutdown_image_addon(); al_uninstall_system(); camera_finaliza(cam); return EXIT_SUCCESS; }
Framework::~Framework() { #ifdef WRITE_LOG fprintf( LogFile, "Framework: Save Config\n" ); #endif SaveSettings(); #ifdef PANDORA #ifdef WRITE_LOG fprintf( LogFile, "Framework: Hacky Pandora Shutdown\n" ); #endif raise(SIGKILL); #endif #ifdef WRITE_LOG fprintf( LogFile, "Framework: Clear stages\n" ); #endif if( ProgramStages != 0 ) { // Just make sure all stages are popped and deleted ShutdownFramework(); } #ifdef WRITE_LOG fprintf( LogFile, "Framework: Shutdown\n" ); #endif al_unregister_event_source( eventAllegro, DISPLAY->GetEventSource() ); al_destroy_event_queue( eventAllegro ); al_destroy_mutex( eventMutex ); al_destroy_timer( frameTimer ); #ifdef WRITE_LOG fprintf( LogFile, "Framework: Shutdown display\n" ); #endif DISPLAY->Shutdown(); delete DISPLAY; #ifdef WRITE_LOG fprintf( LogFile, "Framework: Shutdown audio\n" ); #endif delete AUDIO; #ifdef NETWORK_SUPPORT #ifdef WRITE_LOG fprintf( LogFile, "Framework: Shutdown enet\n" ); #endif enet_deinitialize(); #endif #ifdef DOWNLOAD_SUPPORT #ifdef WRITE_LOG fprintf( LogFile, "Framework: Shutdown downloads\n" ); #endif DOWNLOADS->AbortDownloads = true; delete DOWNLOADS; #endif #ifdef WRITE_LOG fprintf( LogFile, "Framework: Shutdown Allegro\n" ); #endif al_uninstall_system(); #ifdef WRITE_LOG fclose( LogFile ); #endif }