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 MonopolyGame::halt() {
// Cleanup all properties.
for(int pCount = 0; pCount < MAX_PROPERTIES; pCount++) {
m_propertyList[pCount].cleanup();
}
// Cleanup all players.
for(int pCount = 0; pCount < NUM_PLAYERS; pCount++) {
m_playerList[pCount].cleanup();
}
// Free the display device.
if(m_alDisplayDevice) {
al_destroy_display(m_alDisplayDevice);
}
// Free the game's sound effects.
for( int sfxCount = 0; sfxCount < MAX_NUM_SAMPLES; sfxCount++ ) {
if( m_sfx[sfxCount] ) {
al_destroy_sample( m_sfx[sfxCount] );
}
}
// Free the board image bitmap.
if(m_alBoardImage) {
al_destroy_bitmap(m_alBoardImage);
}
// Nullify each player piece.
for(int ppCount = 0; ppCount < PLAYER_PIECES_COUNT; ppCount++) {
if(m_alpieceImages[ppCount]) {
al_destroy_bitmap(m_alpieceImages[ppCount]);
}
}
// Free the loaded fonts.
for(int fCount = 0; fCount < MAX_FONTS; fCount++) {
if(m_fontCollection[fCount]) {
al_destroy_font(m_fontCollection[fCount]);
}
}
// Free the FPS timer.
if(m_alTimer) {
al_destroy_timer(m_alTimer);
}
// Free the frame timer.
if(m_alFrameTimer) {
al_destroy_timer(m_alFrameTimer);
}
// Finally we will free the event queue.
if(m_alEventQueue) {
al_destroy_event_queue(m_alEventQueue);
}
}
Root::~Root()
{
delete m_world;
delete m_tileDatabase;
delete m_spritesheetDatabase;
delete m_assets;
if(al_is_system_installed()) //allegro deinitializes itself before global destructors are called. Without this check allegro crashes.
{
al_destroy_timer(m_drawTimer);
al_destroy_timer(m_tickTimer);
}
//deiniting allegro stuff
}
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;
}
int AllegroApp::Init() {
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;
}
timer = al_create_timer(1.0 / FPS);
if(!timer) {
fprintf(stderr, "failed to create timer!\n");
return -1;
}
display = al_create_display(screenWidth, screenHeight);
if(!display) {
fprintf(stderr, "failed to create display!\n");
al_destroy_timer(timer);
return -1;
}
al_clear_to_color(al_map_rgb(255, 0, 255));
al_set_target_bitmap(al_get_backbuffer(display));
event_queue = al_create_event_queue();
if(!event_queue) {
fprintf(stderr, "failed to create event_queue!\n");
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
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_register_event_source(event_queue, al_get_keyboard_event_source());
al_clear_to_color(al_map_rgb(0,0,0));
al_start_timer(timer);
al_set_target_bitmap(al_get_backbuffer(display));
red_color = al_map_rgb(184, 22, 22);
grey_color = al_map_rgb(184, 184, 184);
yellow_color = al_map_rgb(255, 255, 0);
Ready();
return 0;
}
int destroy(ALG* allg)
{
al_destroy_timer(allg->timer2);
al_destroy_display(allg->display2);
al_destroy_event_queue(allg->event_queue2);
return 0;
}
void abortAutoReload()
{
ssConfig.automatic_reload_time = 0;
al_stop_timer(reloadtimer);
al_destroy_timer(reloadtimer);
//remove_int( automaticReloadProc );
}
Core::~Core(void)
{
// Destroy display, timer, and event queue.
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_event_queue(evQueue);
}
movida::~movida() {
delete gameWorld;
delete gameInterface;
if (timer) al_destroy_timer(timer);
if (screen) al_destroy_display(screen);
if (event_queue) al_destroy_event_queue(event_queue);
}
void GameEngine::Destroy()
{
//project objects destroy
for (auto state : states)
{
if (!state->GetCleanedUp())
{
state->Cleanup();
}
delete state;
}
states.clear();
states.shrink_to_fit();
activeStates.clear();
activeStates.shrink_to_fit();
delete input;
delete collisionDetector;
graphicEngine::Instance().Destroy(); //bitmap
//allegro vars destroy
//al_destroy_font(font18);
al_destroy_display(display);
al_destroy_event_queue(eventQueue);
al_destroy_timer(timer);
}
static void
game_destroy (Game *game)
{
al_destroy_timer (game->timer);
al_destroy_event_queue (game->event_queue);
al_destroy_display (game->display);
}
/* FUNCION DESTRUIR ALLEGRO */
void destruir_allegro (){
al_destroy_font(font);
al_destroy_sample (sample);
al_destroy_timer (timer);
al_destroy_display (display);
al_destroy_event_queue (event_queue);
}
int main(int argc, char **argv){
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_BITMAP *bouncer = NULL;
float bouncer_x = SCREEN_W / 2.0 - BOUNCER_SIZE / 2.0;
float bouncer_y = SCREEN_H / 2.0 - BOUNCER_SIZE / 2.0;
float bouncer_dx = -4.0, bouncer_dy = 4.0;
bool redraw = true;
if(!al_init()) {
fprintf(stderr, "failed to initialize allegro!\n");
return -1;
}
timer = al_create_timer(1.0 / FPS);
if(!timer) {
fprintf(stderr, "failed to create timer!\n");
return -1;
}
display = al_create_display(SCREEN_W, SCREEN_H);
if(!display) {
fprintf(stderr, "failed to create display!\n");
al_destroy_timer(timer);
return -1;
}
/
int init_fail(ALLEGRO_DISPLAY *janela, ALLEGRO_FONT *fonte, ALLEGRO_EVENT_QUEUE *fila_eventos, ALLEGRO_BITMAP *imagem, ALLEGRO_TIMER *timer, ALLEGRO_BITMAP *trilha)
{
if (!al_init())
{
fprintf(stderr, "Falha ao inicializar a Allegro.\n");
return -1;
}
if (!al_install_mouse())
{
fprintf(stderr, "Falha ao inicializar o mouse.\n");
al_destroy_display(janela);
return -1;
}
if (!janela)
{
fprintf(stderr, "Falha ao criar janela.\n");
return -1;
}
if (!al_set_system_mouse_cursor(janela, ALLEGRO_SYSTEM_MOUSE_CURSOR_DEFAULT))
{
fprintf(stderr, "Falha ao atribuir ponteiro do mouse.\n");
al_destroy_display(janela);
return -1;
}
if (!imagem)
{
fprintf(stderr, "Falha ao carregar imagem.\n");
al_destroy_bitmap(imagem);
al_destroy_display(janela);
return -1;
}
if (!trilha)
{
fprintf(stderr, "Falha ao carregar imagem da trilha.\n");
al_destroy_bitmap(trilha);
al_destroy_display(janela);
return -1;
}
if (!fila_eventos)
{
fprintf(stderr, "Falha ao inicializar o fila de eventos.\n");
al_destroy_display(janela);
return -1;
}
if(!fonte)
{
fprintf(stderr, "Falha ao inicializar a fonte.\n");
al_destroy_font(fonte);
al_destroy_display(janela);
return -1;
}
if(!timer)
{
fprintf(stderr, "Falha ao inicializar o timer.\n");
al_destroy_timer(timer);
al_destroy_display(janela);
return -1;
}
}
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);
}
void destroy_al(ALLEGRO_DISPLAY *janela,ALLEGRO_FONT *fonte, ALLEGRO_EVENT_QUEUE *fila_eventos, ALLEGRO_BITMAP *imagem, ALLEGRO_TIMER *timer)
{
al_destroy_display(janela);
al_destroy_font(fonte);
al_destroy_event_queue(fila_eventos);
al_destroy_bitmap(imagem);
al_destroy_timer(timer);
}
void Engine::Destroy()
{
delete doublePendulum;
al_destroy_display(display);
al_destroy_event_queue(eventQueue);
al_destroy_timer(timer);
}
void Shutdown()
{
al_destroy_display(display);
al_destroy_event_queue(queue);
al_destroy_timer(timer);
al_destroy_font(textFont);
std::cout << "Termination successfull, now quiting..." << std::endl;
}
bool ALGraphics::CleanUp()
{
al_destroy_bitmap(pixel);
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(eventQueue);
return true;
}
void uninit()
{
if (this->event_queue_)
al_destroy_event_queue(this->event_queue_);
if (this->timer_)
al_destroy_timer(this->timer_);
al_uninstall_keyboard();
al_uninstall_mouse();
}
CEngine::~CEngine(void)
{
al_destroy_event_queue(m_evQ);
m_evQ = nullptr;
al_destroy_timer(m_timer);
m_timer = nullptr;
al_destroy_display(m_display);
m_display = nullptr;
}
/** A Menu felszabaditasa
* @param menu-re mutato pointer
* @return nincs void
* @author Pjatacsuk Bence
* @date 2011.10.29
*/
void FreeMenu(Menu* MyMenu)
{
al_destroy_display(MyMenu->display);
al_destroy_timer(MyMenu->timer);
al_destroy_bitmap(MyMenu->bg);
al_destroy_font(MyMenu->font);
free(MyMenu);
}
/** A Menu inicializalasas
* @param Nincs
* @return a Menu-re mutato pointer
* @author Pjatacsuk Bence
* @date 2011.10.29
*/
Menu* InitMenu()
{
Menu* MyMenu = MallocMenu();
MyMenu->timer= al_create_timer(1.0 / FPS);
if(!MyMenu->timer)
{
printf("failed to create timer!\n");
return 0;
}
//display kreálása
MyMenu->display = al_create_display(SCREEN_W,SCREEN_H);
if(!MyMenu->display)
{
fprintf(stderr, "failed to create display!\n");
al_destroy_timer(MyMenu->timer);
return 0;
}
//event queue kreálása
MyMenu->event_queue = al_create_event_queue();
if(!MyMenu->event_queue) {
fprintf(stderr, "failed to create event_queue!\n");
al_destroy_display(MyMenu->display);
al_destroy_timer(MyMenu->timer);
return 0;
}
al_init_font_addon();
al_init_ttf_addon();
MyMenu->bg = al_load_bitmap("data\\images\\menubg.png");
CheckBitmap(MyMenu->bg,"data\\images\\menubg.png");
MyMenu->font = al_load_ttf_font("TELE2.ttf",40,0);
return MyMenu;
}
void destroi_jogo (Jogo* jogo){
finaliza_jogo(jogo);
finaliza_menu( jogo->menu[0]);
finaliza_menu( jogo->menu[1]);
finaliza_menu( jogo->menu[2]);
if (jogo->sound_mng) jogo->sound_mng = finaliza_sound_manager(jogo->sound_mng);
al_destroy_event_queue(jogo->event_queue);
al_destroy_timer(jogo->timer);
al_destroy_display(jogo->display);
}
void
destruir_allegro ()
{
al_destroy_timer (timer);
al_destroy_display (display);
al_destroy_event_queue (event_queue);
}
void AllegroShell::destroy(){
al_stop_timer(timer);
al_destroy_timer(timer);
al_destroy_event_queue(queue);
al_destroy_display(display);
delete mouse;
delete model;
delete view;
Textlog::get().log("AllegroShell destroyed\n");
}
void StateControl::Terminate()
{
cout << "Dealocating memory and quitting..." << endl;
al_destroy_display(display);
al_destroy_event_queue(event_queue);
al_destroy_timer(timer);
al_destroy_font(forms_font);
al_destroy_font(small_forms_font);
al_destroy_font(musics_font);
}
void GameEngine::Cleanup() {
// cleanup all states
while ( !states.empty() ) {
states.back()->Cleanup();
states.pop_back();
}
al_destroy_timer(redrawTimer);
al_destroy_display(display);
}
void game_exit_gracefully(){
if (g_display) al_destroy_display(g_display);
if(g_queue) al_destroy_event_queue(g_queue);
if(g_screen) al_destroy_bitmap(g_screen);
if(g_timer) al_destroy_timer(g_timer);
if(timer_ingame) al_destroy_timer(timer_ingame);
if(resource_path) al_destroy_path(resource_path);
DEBUG_PRINT("Game Assets Freed");
close_game_hard();
}
void shutdown(void)
{
if (timer)
al_destroy_timer(timer);
if (display)
al_destroy_display(display);
if (event_queue)
al_destroy_event_queue(event_queue);
}
