int main (int argc, char *argv[]) { al_init(); ALLEGRO_DISPLAY *display = al_create_display(640, 480); al_init_primitives_addon(); al_init_image_addon(); al_init_font_addon(); al_init_ttf_addon(); srand(time(NULL)); char* disappointed[] = {" Razocharovana sum!", " Tolkova losho kontrolno ne sum vijdala!", "Golqm murzel vi e nalegnal...", " Potresavashto!!"}; ALLEGRO_BITMAP *image = al_load_bitmap("pic.bmp"); ALLEGRO_EVENT_QUEUE *event_queue = al_create_event_queue(); ALLEGRO_TIMER *timer = al_create_timer(1/60.0); al_register_event_source(event_queue, al_get_timer_event_source(timer)); ALLEGRO_FONT *font = al_load_font("Arial.ttf", 20, 0); int done = 0; int render = 0; int x = 375; int y = 340; int traveled_y = 0; int delay = 120; int time_elapsed = 0; int dir = -1; int move_left = 0; int traveled_x = 0; int time_elapsed2 = 0; int draw_text = 0; int random = 0; int should_draw_text = 0; al_start_timer(timer); while(!done) { ALLEGRO_EVENT event; al_wait_for_event(event_queue, &event); if(event.type == ALLEGRO_EVENT_TIMER) { if(x < 50) done = 1; if(traveled_y >= 75) { if(!draw_text) { random = rand() % 4; if(y < 350) should_draw_text = 1; } draw_text = 1; if(++time_elapsed >= delay) { traveled_y = 0; time_elapsed = 0; if(y <= 60 || y >= 375) { if(!move_left) { if(y <= 60) { if(traveled_x >= 50) { if(++time_elapsed2 >= delay) { traveled_x = 0; time_elapsed2 = 0; move_left = 1; } } else { x -= 3; traveled_x += 3; } } else if(y >= 375) { should_draw_text = 0; if(traveled_x >= 140) { if(++time_elapsed2 >= delay) { traveled_x = 0; time_elapsed2 = 0; move_left = 1; } } else { x -= 3; traveled_x += 3; } } time_elapsed = 120; traveled_y = 75; } else { dir *= -1; move_left = 0; } } } } else { draw_text = 0; should_draw_text = 0; y += 3 * dir; traveled_y += 3; } render = 1; } if(render) { al_draw_bitmap(image, 0, 0, 0); al_draw_pixel(x, y, al_map_rgb(255, 0, 0)); if(should_draw_text) { al_draw_text(font, al_map_rgb(255, 255, 255), 10, 450, 0, disappointed[random]); } al_flip_display(); al_clear_to_color(al_map_rgb(0, 0, 0)); render = 0; } } al_destroy_display(display); al_destroy_bitmap(image); al_destroy_event_queue(event_queue); al_destroy_timer(timer); return 0; }
//prototype int main(void){ bool done = false; bool redraw = true; const int FPS = 60; bool isGameOver = false; //object variables spaceShip ship; Bullet bullets[NUM_BULLETS]; Comet comets[NUM_COMETS]; ALLEGRO_DISPLAY *display = NULL; ALLEGRO_EVENT_QUEUE *eventQueue = NULL; ALLEGRO_TIMER *timer = NULL; ALLEGRO_FONT *font18 = NULL; //check if allegro is initialised <allegro_native_dialog.h> if(!al_init()){ return -1; } display = al_create_display(WIDTH,HEIGHT); //check if display was created if(!display){ return -1; } al_init_primitives_addon(); al_install_keyboard(); al_init_font_addon(); al_init_ttf_addon(); eventQueue = al_create_event_queue(); timer= al_create_timer(1.0/FPS); srand(time(NULL)); // gives the rand() some value initShip(ship); initBullet(bullets, NUM_BULLETS); initComet(comets, NUM_COMETS); font18 = al_load_font("arial.ttf",18,0); al_register_event_source(eventQueue, al_get_keyboard_event_source()); al_register_event_source(eventQueue, al_get_timer_event_source(timer)); al_register_event_source(eventQueue, al_get_display_event_source(display)); //event os display resize closing, moving al_start_timer(timer); while(!done){ ALLEGRO_EVENT ev; al_wait_for_event(eventQueue, &ev); if (ev.type==ALLEGRO_EVENT_TIMER){ redraw=true; if(keys[UP]){ moveShipUp(ship); } if(keys[DOWN]){ moveShipDown(ship); } if(keys[LEFT]){ moveShipLeft(ship); } if(keys[RIGHT]){ moveShipRight(ship); } if(!isGameOver){ updateBullet(bullets,NUM_BULLETS); startComet(comets, NUM_COMETS); updateComet(comets, NUM_COMETS); collideBullet(bullets,NUM_BULLETS, comets, NUM_BULLETS, ship); collideComet(comets, NUM_COMETS, ship); if (ship.lives <= 0){ isGameOver = true; } } } // when clicling on red X icon to close the game else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE){ done=true; } else if (ev.type==ALLEGRO_EVENT_KEY_DOWN){ switch(ev.keyboard.keycode){ case ALLEGRO_KEY_ESCAPE: done=true; break; case ALLEGRO_KEY_UP: keys[UP]=true; break; case ALLEGRO_KEY_DOWN: keys[DOWN]=true; break; case ALLEGRO_KEY_LEFT: keys[LEFT]=true; break; case ALLEGRO_KEY_RIGHT: keys[RIGHT]=true; break; case ALLEGRO_KEY_SPACE: keys[SPACE]=true; fireBullet(bullets, NUM_BULLETS, ship); break; } } else if (ev.type==ALLEGRO_EVENT_KEY_UP){ switch(ev.keyboard.keycode){ //make sure when exiting the program exit with esc button case ALLEGRO_KEY_ESCAPE: done=true; break; case ALLEGRO_KEY_UP: keys[UP]=false; break; case ALLEGRO_KEY_DOWN: keys[DOWN]=false; break; case ALLEGRO_KEY_LEFT: keys[LEFT]=false; break; case ALLEGRO_KEY_RIGHT: keys[RIGHT]=false; break; case ALLEGRO_KEY_SPACE: keys[SPACE]=false; break; } } if (redraw && al_is_event_queue_empty(eventQueue)){ // I only draw the screen if there no more event redraw=false; if(!isGameOver){ drawShip(ship); drawBullet(bullets,NUM_BULLETS); drawComet(comets, NUM_COMETS); al_draw_textf(font18, al_map_rgb(255,0,255), 5, 5, 0, "Player has %i lives left. Player has destroyed %i objects", ship.lives, ship.score); } else{ al_draw_textf(font18, al_map_rgb(0,255,255),WIDTH / 2, HEIGHT / 2, ALLEGRO_ALIGN_CENTRE, "Game Over, Pal. Final Score: %i", ship.score); } al_flip_display(); al_clear_to_color(al_map_rgb(0,0,0)); //that prevents the filled rectangle draw imga just like snake style } //make sure when exiting the program exit with esc button // when clicling on red X icon to close the game } //al_rest(5.0); al_destroy_display(display); //hadouken return 0; }
int main (int argc, char **argv) { Mario mario; ALLEGRO_BITMAP *mario_spritesheet = NULL; bool tecla[4] = { false, false, false, false }; int sprite_number = 0; srand (time (NULL)); iniciar_allegro (); mario_spritesheet = al_load_bitmap (SPRITESHEET); if (!mario_spritesheet) { al_show_native_message_box (display, "Error", "Error", "No se ha podido crear el bitmap", NULL, ALLEGRO_MESSAGEBOX_ERROR); al_destroy_timer (timer); al_destroy_display (display); exit (EXIT_FAILURE); } mario.set_dibujo (mario_spritesheet); while (1) { /* Buzz Lightyear */ ALLEGRO_EVENT ev; ALLEGRO_TIMEOUT timeout; al_init_timeout (&timeout, 0.06); bool get_event = al_wait_for_event_until (event_queue, &ev, &timeout); if (get_event) { if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) break; if (ev.type == ALLEGRO_EVENT_TIMER) redraw = true; if (ev.type == ALLEGRO_EVENT_KEY_DOWN) { switch (ev.keyboard.keycode) { case ALLEGRO_KEY_UP: tecla[KEY_UP] = true; break; case ALLEGRO_KEY_DOWN: tecla[KEY_DOWN] = true; break; case ALLEGRO_KEY_LEFT: tecla[KEY_LEFT] = true; break; case ALLEGRO_KEY_RIGHT: tecla[KEY_RIGHT] = true; break; } } if (ev.type == ALLEGRO_EVENT_KEY_UP) { switch (ev.keyboard.keycode) { case ALLEGRO_KEY_UP: tecla[KEY_UP] = false; break; case ALLEGRO_KEY_DOWN: tecla[KEY_DOWN] = false; break; case ALLEGRO_KEY_LEFT: tecla[KEY_LEFT] = false; break; case ALLEGRO_KEY_RIGHT: tecla[KEY_RIGHT] = false; break; case ALLEGRO_KEY_LSHIFT: sprite_number++; break; } } } /* Actualizar las coordenadas de la pelota */ if (tecla[KEY_UP]) mario.change_vy(-DELTA); if (tecla[KEY_DOWN]) mario.change_vy(DELTA); if (tecla[KEY_LEFT]) mario.change_vx(-DELTA); if (tecla[KEY_RIGHT]) mario.change_vx(DELTA); mario.actualizate(); if (redraw && al_is_event_queue_empty (event_queue)) { al_clear_to_color (al_map_rgb (0, 0, 0)); for (int i = 0; i < N; i++) al_draw_bitmap (mario.get_dibujo (), mario.get_x () + 450, mario.get_y () + 450, 0); al_flip_display (); redraw = false; } } al_destroy_bitmap (mario_spritesheet); destruir_allegro (); return 0; }
void Whack_a_Skunk_Loop::draw(void) { al_clear_to_color(al_map_rgb(0x00, 0x00, 0x00)); al_draw_bitmap( bg_bitmap->bitmap, top_offset.x, top_offset.y, 0 ); float scales[3] = { 0.83f, 0.9f, 1.0f }; Wrap::Bitmap *hole_bmps[3] = { mask_back, mask_middle, mask_front }; int hole_yoffs[3] = { 6, 8, 10 }; Wrap::Bitmap *highlight_bmps[3] = { highlight_back, highlight_middle, highlight_front }; int highlight_yoffs[3] = { 5, 6, 8 }; Wrap::Bitmap *maskhighlight_bmps[3] = { mask_backhighlight, mask_middlehighlight, mask_fronthighlight }; for (int i = 0; i < 9; i++) { int row = i / 3; if (i == curr_hole) { Wrap::Bitmap *highlight = highlight_bmps[row]; int highlight_w = al_get_bitmap_width(highlight->bitmap); int highlight_h = al_get_bitmap_height(highlight->bitmap); al_draw_bitmap( highlight->bitmap, holes[i].x-highlight_w/2+top_offset.x, holes[i].y-highlight_h+highlight_yoffs[row]+top_offset.y, 0 ); } Animation_Set *anim_set; bool done = get_skunk_info(i, &anim_set); int x = holes[i].x - skunk_size.w/2 + top_offset.x; int y = holes[i].y - skunk_size.h + top_offset.y; float scale = scales[row]; int ox = (skunk_size.w * (1.0f-scale)) / 2; int oy = 10; oy += (skunk_size.h * (1.0f-scale)) / 2; int len = anim_set->get_length(anim_set->get_sub_animation_name()); if (holes[i].count > len/2) { oy += ((float)(holes[i].count-(len/2)) / (len/2)) * 60 /* 60 = base skunk height */; } else { oy += (1.0 - ((float)holes[i].count / (len/2))) * 60; } if (!done) { int cx, cy, cw, ch; al_get_clipping_rectangle(&cx, &cy, &cw, &ch); General::set_clipping_rectangle(x, y, skunk_size.w, skunk_size.h); if (holes[i].status == ALIVE || holes[i].status == TAUNTING || holes[i].status == GOING_DOWN) { anim_set->get_current_animation()->draw_scaled( 0, 0, skunk_size.w, skunk_size.h, x+ox, y+oy, skunk_size.w*scale, skunk_size.h*scale, 0 ); } else if (holes[i].status == DYING) { std::string name = anim_set->get_sub_animation_name(); int frame = anim_set->get_current_animation()->get_current_frame_num(); anim_set->set_sub_animation("popup"); anim_set->set_frame(holes[i].type == FAKE ? 0 : 3); anim_set->get_current_animation()->draw_scaled( 0, 0, skunk_size.w, skunk_size.h, x+ox, y+oy, skunk_size.w*scale, skunk_size.h*scale, 0 ); anim_set->set_sub_animation(name); anim_set->set_frame(frame); } al_set_clipping_rectangle(cx, cy, cw, ch); } Wrap::Bitmap *mask = i == curr_hole ? maskhighlight_bmps[row] : hole_bmps[row]; int mask_w = al_get_bitmap_width(mask->bitmap); int mask_h = al_get_bitmap_height(mask->bitmap); al_draw_bitmap( mask->bitmap, holes[i].x-mask_w/2+top_offset.x, holes[i].y-mask_h+hole_yoffs[row]+top_offset.y, 0 ); if (!done) { if (holes[i].status == DYING) { anim_set->get_current_animation()->draw_scaled( 0, 0, skunk_size.w, skunk_size.h, x+ox, y+oy, skunk_size.w*scale, skunk_size.h*scale, 0 ); } } } // Draw timer int digits; if (timer/1000 >= 10) { digits = 2; } else { digits = 1; } int font_w = font->get_current_animation()->get_current_frame()->get_width(); float xx = (cfg.screen_w-font_w*(digits+1))/2; float yy = 5; int tmp = timer; for (int i = 0; i < digits; i++) { int p = powf(10, (digits-i)+2); int frame = tmp / p; font->set_sub_animation(General::itos(frame)); font->get_current_animation()->draw( xx, yy, 0 ); tmp -= frame * p; xx += font_w; } font->set_sub_animation("s"); font->get_current_animation()->draw( xx, yy, 0 ); // Draw score/hitx if (hits < 0) { hits = 0; } char buf[100]; snprintf(buf, 100, "%d", hits); draw_centered_text(font, al_map_rgb(0x00, 0xff, 0x00), buf, cfg.screen_w/4-30, 5); int hitx; if (hits_in_a_row >= 7) { hitx = 3; } else if (hits_in_a_row >= 3) { hitx = 2; } else { hitx = 1; } snprintf(buf, 100, "x%d", hitx); draw_centered_text(font, al_map_rgb(0xff, 0xd7, 0x00), buf, cfg.screen_w*3/4+15, 5); std::list<Pow>::iterator pow_it; for (pow_it = pows.begin(); pow_it != pows.end(); pow_it++) { Pow &p = *pow_it; ALLEGRO_COLOR tint; float a; if (p.count < POW_LIFETIME/2) { a = 1.0; } else { a = ((float)p.count-POW_LIFETIME/2) / (POW_LIFETIME/2); if (a > 1.0) a = 1.0; a = 1.0 - a; } tint = al_map_rgba_f(1.0, 1.0, 1.0, a); int r = (cfg.screen_w / 120) * 2 + 1; al_draw_tinted_bitmap( p.kratch ? kratch_bmp->bitmap : pow_bmp->bitmap, tint, p.x-al_get_bitmap_width(pow_bmp->bitmap)/2+General::rand()%r-(r/2)+top_offset.x, p.y-al_get_bitmap_height(pow_bmp->bitmap)/2+General::rand()%r-(r/2)+top_offset.y, 0 ); } std::list<Star>::iterator star_it; for (star_it = stars.begin(); star_it != stars.end(); star_it++) { Star &s = *star_it; ALLEGRO_COLOR tint; float b = (float)s.count / STAR_LIFETIME; if (b > 1.0) b = 1.0; tint = al_map_rgb_f(1.0, 1.0, b); al_draw_tinted_rotated_bitmap( star_bmp->bitmap, tint, al_get_bitmap_width(star_bmp->bitmap)/2, al_get_bitmap_height(star_bmp->bitmap)/2, s.x+top_offset.x, s.y+top_offset.y, s.angle, 0 ); } if (bashing) { float xx = holes[curr_hole].x; float yy = holes[curr_hole].y - hand_size.h; xx += top_offset.x; yy += top_offset.y; xx += 90; // trial and error yy += 110; if (curr_hole == 0 || curr_hole == 3 || curr_hole == 6) { hand->set_sub_animation("left"); } else if (curr_hole == 1 || curr_hole == 4 || curr_hole == 7) { hand->set_sub_animation("middle"); xx -= 68; } else { hand->set_sub_animation("right"); xx -= 68*2; } hand->get_current_animation()->draw( xx-hand_size.w/2, yy, 0 ); } }
int main(void) { ALLEGRO_DISPLAY *display; ALLEGRO_BITMAP *cursor; ALLEGRO_EVENT_QUEUE *queue; ALLEGRO_EVENT event; ALLEGRO_FONT *font; int mx = 0; int my = 0; int mz = 0; int mw = 0; int mmx = 0; int mmy = 0; int mmz = 0; int mmw = 0; bool in = true; bool buttons[NUM_BUTTONS] = {false}; int i; float p = 0.0; ALLEGRO_COLOR black; if (!al_init()) { abort_example("Could not init Allegro.\n"); } al_init_primitives_addon(); al_install_mouse(); al_install_keyboard(); al_init_image_addon(); al_init_font_addon(); actual_buttons = al_get_mouse_num_buttons(); if (actual_buttons > NUM_BUTTONS) actual_buttons = NUM_BUTTONS; al_set_new_display_flags(ALLEGRO_RESIZABLE); display = al_create_display(640, 480); if (!display) { abort_example("Error creating display\n"); } al_hide_mouse_cursor(display); cursor = al_load_bitmap("data/cursor.tga"); if (!cursor) { abort_example("Error loading cursor.tga\n"); } font = al_load_font("data/fixed_font.tga", 1, 0); if (!font) { abort_example("data/fixed_font.tga not found\n"); } black = al_map_rgb_f(0, 0, 0); queue = al_create_event_queue(); al_register_event_source(queue, al_get_mouse_event_source()); al_register_event_source(queue, al_get_keyboard_event_source()); al_register_event_source(queue, al_get_display_event_source(display)); while (1) { if (al_is_event_queue_empty(queue)) { al_clear_to_color(al_map_rgb(0xff, 0xff, 0xc0)); for (i = 0; i < actual_buttons; i++) { draw_mouse_button(i, buttons[i]); } al_draw_bitmap(cursor, mx, my, 0); al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA); al_draw_textf(font, black, 5, 5, 0, "dx %i, dy %i, dz %i, dw %i", mmx, mmy, mmz, mmw); al_draw_textf(font, black, 5, 25, 0, "x %i, y %i, z %i, w %i", mx, my, mz, mw); al_draw_textf(font, black, 5, 45, 0, "p = %g", p); al_draw_textf(font, black, 5, 65, 0, "%s", in ? "in" : "out"); al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA); mmx = mmy = mmz = 0; al_flip_display(); } al_wait_for_event(queue, &event); switch (event.type) { case ALLEGRO_EVENT_MOUSE_AXES: mx = event.mouse.x; my = event.mouse.y; mz = event.mouse.z; mw = event.mouse.w; mmx = event.mouse.dx; mmy = event.mouse.dy; mmz = event.mouse.dz; mmw = event.mouse.dw; p = event.mouse.pressure; break; case ALLEGRO_EVENT_MOUSE_BUTTON_DOWN: if (event.mouse.button-1 < NUM_BUTTONS) { buttons[event.mouse.button-1] = true; } p = event.mouse.pressure; break; case ALLEGRO_EVENT_MOUSE_BUTTON_UP: if (event.mouse.button-1 < NUM_BUTTONS) { buttons[event.mouse.button-1] = false; } p = event.mouse.pressure; break; case ALLEGRO_EVENT_MOUSE_ENTER_DISPLAY: in = true; break; case ALLEGRO_EVENT_MOUSE_LEAVE_DISPLAY: in = false; break; case ALLEGRO_EVENT_KEY_DOWN: if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) { goto done; } break; case ALLEGRO_EVENT_DISPLAY_RESIZE: al_acknowledge_resize(event.display.source); break; case ALLEGRO_EVENT_DISPLAY_CLOSE: goto done; } } done: al_destroy_event_queue(queue); return 0; }
void drawFrame(ALLEGRO_FONT *font) { if (gameRunning) { ballLocation.x += ballIncrement.x; ballLocation.y += ballIncrement.y; if (ballLocation.y > 470 || ballLocation.y < 10) ballIncrement.y = ballIncrement.y * -1; if (ballLocation.x > 625) ballIncrement.x = ballIncrement.x * -1; if (ballLocation.x < 16 && ballIncrement.x < 0) { ballLocation.x = 16; if (ballLocation.y >= playerPaddle.y - 35 && ballLocation.y <= playerPaddle.y + 35) { score += 10; if (score > highscore) highscore = score; if (score % 50 == 0) { ballIncrement.x *= 1.5; ballIncrement.y *= 1.5; } ballIncrement.x = ballIncrement.x * -1; } else gameRunning = false; } } if (ballIncrement.x > 0) { if (computerPaddle.y < ballLocation.y && ballLocation.y - computerPaddle.y > 4) computerPaddle.y += 8; else if (computerPaddle.y > ballLocation.y && computerPaddle.y - ballLocation.y > 4) computerPaddle.y -= 8; if (computerPaddle.y < 35) computerPaddle.y = 35; else if (computerPaddle.y > 445) computerPaddle.y = 445; } al_clear_to_color(al_map_rgb(128, 128, 255)); al_draw_filled_circle(ballLocation.x, ballLocation.y, 10, al_map_rgb(100, 100, 100)); al_draw_filled_rectangle(0, playerPaddle.y - 35, 5, playerPaddle.y + 35, al_map_rgb(196, 196, 196)); al_draw_filled_rectangle(635, computerPaddle.y - 35, 640, computerPaddle.y + 35, al_map_rgb(196, 196, 196)); if (!gameRunning) al_draw_text(font, al_map_rgb(200, 200, 200), 320, 240, 1, "Game over!"); else { char scoretext[1024]; sprintf(scoretext, "Score: %d", score); al_draw_text(font, al_map_rgb(200, 200, 200), 300, 3, 0, scoretext); sprintf(scoretext, "High Score: %d", highscore); al_draw_text(font, al_map_rgb(200, 200, 200), 300, 22, 0, scoretext); } al_flip_display(); }
void Menu_Draw(struct Game *game) { if (!game->menu.loaded) { game->gamestate=GAMESTATE_LOADING; game->loadstate=GAMESTATE_MENU; return; } al_set_target_bitmap(game->menu.pinkcloud_bitmap); al_clear_to_color(al_map_rgba(0,0,0,0)); float x = 1.5; int minus; if (game->menu.cloud_position>0) minus=1; else minus=-1; al_draw_bitmap(game->menu.rain_bitmap, fmod(minus*game->menu.cloud_position,3)*x*5+al_get_bitmap_width(game->menu.pinkcloud_bitmap)/2.7, al_get_bitmap_height(game->menu.pinkcloud_bitmap)*(0.88+(fmod(-1.8*(game->menu.cloud_position+80), 6))/20.0), 0); al_draw_bitmap(game->menu.rain_bitmap, fmod(minus*game->menu.cloud_position,3)*x*3+al_get_bitmap_width(game->menu.pinkcloud_bitmap)/3.1, al_get_bitmap_height(game->menu.pinkcloud_bitmap)*(0.78+(fmod(-2.8*(game->menu.cloud_position+80), 4))/18.0), 0); al_draw_scaled_bitmap(game->menu.rain_bitmap, 0, 0, al_get_bitmap_width(game->menu.rain_bitmap), al_get_bitmap_height(game->menu.rain_bitmap), fmod(minus*game->menu.cloud_position,3)*x*6+al_get_bitmap_width(game->menu.pinkcloud_bitmap)/2.1, al_get_bitmap_height(game->menu.pinkcloud_bitmap)*(0.87+(fmod(-4.9*(game->menu.cloud_position+80), 8))/26.0), al_get_bitmap_width(game->menu.pinkcloud_bitmap)*0.4, al_get_bitmap_height(game->menu.pinkcloud_bitmap)*0.08, 0); al_draw_bitmap(game->menu.pinkcloud, 0, 0, 0); al_set_target_bitmap(al_get_backbuffer(game->display)); al_clear_to_color(al_map_rgb(183,234,193)); float tint = (sin((game->menu.cloud_position-80)/15)+1)/2; if (tint < 0.000004) { PrintConsole(game, "random tint %f", tint); game->menu.mountain_position = (game->viewportWidth*(rand()/(float)RAND_MAX)/2)+game->viewportWidth/2; } al_draw_tinted_bitmap(game->menu.mountain,al_map_rgba_f(tint,tint,tint,tint),game->menu.mountain_position, 0,0); al_draw_scaled_bitmap(game->menu.cloud,0,0,al_get_bitmap_width(game->menu.cloud), al_get_bitmap_height(game->menu.cloud), game->viewportWidth*(sin((game->menu.cloud_position/40)-4.5)-0.3), game->viewportHeight*0.35, al_get_bitmap_width(game->menu.cloud)/2, al_get_bitmap_height(game->menu.cloud)/2,0); al_draw_bitmap(game->menu.cloud2,game->viewportWidth*(game->menu.cloud2_position/100.0), game->viewportHeight-(game->viewportWidth*(1240.0/3910.0))*0.7,0); al_draw_bitmap(game->menu.image,0, game->viewportHeight-(game->viewportWidth*(1240.0/3910.0)),0); al_draw_bitmap(game->menu.pinkcloud_bitmap,(game->viewportWidth*0.12) + (cos((game->menu.cloud_position/25+80)*1.74444))*40, 0,0); al_draw_bitmap(game->menu.cloud,game->viewportWidth*game->menu.cloud_position/100, game->viewportHeight*0.1,0); al_draw_bitmap(game->menu.pie_bitmap, game->viewportWidth/2, game->viewportHeight*(game->menu.cloud_position)/10,0); /* GLASS EFFECT */ al_set_target_bitmap(game->menu.blurbg); al_clear_to_color(al_map_rgb(183,234,193)); al_draw_scaled_bitmap(game->menu.cloud,0,0,al_get_bitmap_width(game->menu.cloud), al_get_bitmap_height(game->menu.cloud), game->viewportWidth*(sin((game->menu.cloud_position/40)-4.5)-0.3) - (game->viewportWidth/2)+(al_get_bitmap_width(game->menu.logo)/2), game->viewportHeight*0.35-(game->viewportHeight*0.1), al_get_bitmap_width(game->menu.cloud)/2, al_get_bitmap_height(game->menu.cloud)/2,0); al_draw_bitmap(game->menu.pinkcloud_bitmap,(game->viewportWidth*0.12) + (cos((game->menu.cloud_position/25+80)*1.74444))*40 - (game->viewportWidth/2)+(al_get_bitmap_width(game->menu.logo)/2), -(game->viewportHeight*0.1),0); al_draw_bitmap(game->menu.cloud,game->viewportWidth*game->menu.cloud_position/100 - (game->viewportWidth/2)+(al_get_bitmap_width(game->menu.logo)/2), game->viewportHeight*0.1-(game->viewportHeight*0.1),0); al_draw_bitmap(game->menu.pie_bitmap, game->viewportWidth/2 - (game->viewportWidth/2)+(al_get_bitmap_width(game->menu.logo)/2), game->viewportHeight*(game->menu.cloud_position)/10 -(game->viewportHeight*0.1),0); /*al_draw_bitmap_region(al_get_backbuffer(game->display), (game->viewportWidth/2)-(al_get_bitmap_width(game->menu.logo)/2), (game->viewportHeight*0.1), al_get_bitmap_width(game->menu.logo), al_get_bitmap_height(game->menu.logo), 0, 0, 0);*/ al_set_target_bitmap(game->menu.blurbg2); al_clear_to_color(al_map_rgba(0,0,0,0)); float alpha = (1.0/8.0); ALLEGRO_COLOR color = al_map_rgba_f(alpha, alpha, alpha, alpha); int bx = 0, by = 0; for (by = -2; by <= 2; by++) { for (bx = -2; bx <= 2; bx++) { if (sqrt(bx*bx+by*by) <= 2) al_draw_tinted_bitmap(game->menu.blurbg, color, bx*2, by*2, 0); } } al_draw_bitmap(game->menu.glass, 0, 0, 0); al_set_blender(ALLEGRO_ADD, ALLEGRO_ZERO, ALLEGRO_ALPHA); al_draw_bitmap(game->menu.logo, 0, 0, 0); al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA); al_set_target_bitmap(al_get_backbuffer(game->display)); al_draw_bitmap(game->menu.blurbg2, (game->viewportWidth/2)-(al_get_bitmap_width(game->menu.logo)/2), (game->viewportHeight*0.1), 0); al_draw_bitmap(game->menu.logoblur, (game->viewportWidth/2)-(al_get_bitmap_width(game->menu.logo)/2)-2, (game->viewportHeight*0.1)-2, 0); al_draw_tinted_bitmap(game->menu.logo, al_map_rgba_f(0.1, 0.1, 0.1, 0.1), (game->viewportWidth/2)-(al_get_bitmap_width(game->menu.logo)/2), (game->viewportHeight*0.1), 0); /* END OF GLASS EFFECT */ al_draw_text_with_shadow(game->menu.font_title, al_map_rgb(255,255,255), game->viewportWidth*0.5, game->viewportHeight*0.1, ALLEGRO_ALIGN_CENTRE, "Przygody Super Kuca"); al_draw_text_with_shadow(game->menu.font_title, al_map_rgb(255,255,255), game->viewportWidth*0.5, game->viewportHeight*0.275, ALLEGRO_ALIGN_CENTRE, "Prętulino"); DrawMenuState(game); }
void MenuStage::Render() { ALLEGRO_BITMAP* bkgImg = Framework::SystemFramework->GetImageManager()->GetImage( "resource/background.png" ); int notificationsX = 0; int notificationsW = 0; if( bkgImg == 0 ) { if( Framework::SystemFramework->Settings->GetQuickBooleanValue( "Application.BrightTheme" ) ) { al_clear_to_color( al_map_rgb( 255, 255, 255 ) ); } else { al_clear_to_color( al_map_rgb( 0, 0, 0 ) ); } } else { al_draw_scaled_bitmap( bkgImg, 0, 0, al_get_bitmap_width( bkgImg ), al_get_bitmap_height( bkgImg ), 0, 0, Framework::SystemFramework->GetDisplayWidth(), Framework::SystemFramework->GetDisplayHeight(), 0 ); } #ifdef WRITE_LOG printf( "MenuStage: Rendering Tab (%d)\n", activeTab ); #endif al_set_target_bitmap( tabCanvas ); al_clear_to_color( al_map_rgba( 0, 0, 0, 0 ) ); tabList.at( activeTab )->Render(); Framework::SystemFramework->RestoreDisplayTarget(); if( tabAlpha >= 255 ) { al_draw_bitmap( tabCanvas, 0, 0, 0 ); } else if( tabAlpha > 0 ) { al_draw_tinted_bitmap( tabCanvas, al_map_rgba( 255, 255, 255, tabAlpha ), 0, 0, 0 ); } al_draw_filled_rectangle( 0, Tab::CanvasHeight, Framework::SystemFramework->GetDisplayWidth(), Framework::SystemFramework->GetDisplayHeight(), al_map_rgb( 0, 0, 0 ) ); #ifdef WRITE_LOG printf( "MenuStage: Rendering Tab Icons\n" ); #endif if( tabIconScrollMode ) { // TODO: Scroll mode draw } else { int tabIconStartX = (Framework::SystemFramework->GetDisplayWidth() / 2) - (tabIconWidth * tabList.size() / 2); notificationsW = tabIconStartX; for( int idx = 0; idx < tabList.size(); idx++ ) { DrawTabBox( idx, tabIconStartX ); tabIconStartX += tabIconWidth; } } #ifdef WRITE_LOG printf( "MenuStage: Rendering Notification Icons\n" ); #endif // TODO: Process Notification Icons // notificationsX -> notificationsW for( std::vector<Notification*>::const_iterator N = notificationList.begin(); N != notificationList.end(); N++ ) { if( ((Notification*)*N)->Active() ) { al_set_target_bitmap( notificationCanvas ); al_clear_to_color( al_map_rgb( 0, 0, 0 ) ); ((Notification*)*N)->Render(); Framework::SystemFramework->RestoreDisplayTarget(); al_draw_bitmap( notificationCanvas, notificationsX, Tab::CanvasHeight + 1, 0 ); notificationsX += NOTIFICATION_ICON_WIDTH; if( notificationsX + NOTIFICATION_ICON_WIDTH > notificationsW ) { break; } } } al_draw_line( 0, Tab::CanvasHeight, Framework::SystemFramework->GetDisplayWidth(), Tab::CanvasHeight, al_map_rgb( 255, 255, 255 ), 1 ); }
int main(void) { srand(static_cast<int>(time(nullptr) % 100 )); bool keys[10] = {false, false, false, false, false, false, false, false, false, false}; bool done = false; bool redraw = true; int FPS = 60; ALLEGRO_DISPLAY *display = NULL; ALLEGRO_EVENT_QUEUE *event_queue = NULL; ALLEGRO_TIMER *timer = NULL; //initialize allegro if(!al_init()) { al_show_native_message_box(NULL, NULL, NULL, "failed to initialize allegro!", NULL, NULL); return -1; } //create our display object display = al_create_display(app_width, app_height); //test display object if(!display) { al_show_native_message_box(NULL, NULL, NULL, "failed to initialize display!", NULL, NULL); return -1; } al_init_font_addon(); al_init_ttf_addon(); ALLEGRO_FONT *font12 = al_load_font("arial.ttf", 12, 0); ALLEGRO_FONT *font24 = al_load_font("arial.ttf", 24, 0); ALLEGRO_FONT *font36 = al_load_font("arial.ttf", 36, 0); ALLEGRO_FONT *font18 = al_load_font("arial.ttf", 18, 0); al_init_primitives_addon(); al_install_keyboard(); al_install_mouse(); event_queue = al_create_event_queue(); timer = al_create_timer(1.0 / FPS); 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_hide_mouse_cursor(display); al_start_timer(timer); Tilemap tilemap; /*int mountain_index = rand() % (tilemap_size_num_tiles_x * tilemap_size_num_tiles_y); tilemap.tile_[300].height_ = 10; tilemap.tile_[300].erosion_givingness = 0; int deep_index = rand() % (tilemap_size_num_tiles_x * tilemap_size_num_tiles_y); tilemap.tile_[301].height_ = -10; tilemap.tile_[301].erosion_givingness = 0;*/ std::vector<Sprite> tree; Sprite p1(tile_render_size*1.5,tile_render_size*1.5,color_p1); Sprite p2(tile_render_size*2.5,tile_render_size*1.5,color_p2); Timer tilemap_time; int num_natural_erosions = 0; int sec_per_natural_erosion = 1; int num_tree_periods = 0; int sec_per_tree_period = 0.3; 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_MOUSE_BUTTON_DOWN) { if(ev.mouse.button & 1) { p1.x = ev.mouse.x; p1.y = ev.mouse.y; } else if (ev.mouse.button & 2) { p2.x = ev.mouse.x; p2.y = ev.mouse.y; } } else if(ev.type == ALLEGRO_EVENT_MOUSE_AXES) { } else if(ev.type == ALLEGRO_EVENT_KEY_DOWN) { switch(ev.keyboard.keycode) { case ALLEGRO_KEY_UP: keys[UP] = true; break; case ALLEGRO_KEY_LEFT: keys[LEFT] = true; break; case ALLEGRO_KEY_DOWN: keys[DOWN] = true; break; case ALLEGRO_KEY_RIGHT: keys[RIGHT] = true; break; case ALLEGRO_KEY_W: keys[W] = true; break; case ALLEGRO_KEY_A: keys[A] = true; break; case ALLEGRO_KEY_S: keys[S] = true; break; case ALLEGRO_KEY_D: keys[D] = true; break; case ALLEGRO_KEY_E: keys[E] = true; std::cout << "E:\n"; //std::cout << "\n" << tilemap.tile[1][1].height() << "\n"; ErodeTilemap(tilemap); //std::cout << "\n" << tilemap.tile[1][1].height() << "\n"; break; case ALLEGRO_KEY_N: keys[N] = true; Tilemap new_tilemap; //for ( int i = 0; i < 10; i++ ) new_tilemap = ErodeTilemap(new_tilemap); tilemap = new_tilemap; tree.clear(); break; } } else if(ev.type == ALLEGRO_EVENT_KEY_UP) { switch(ev.keyboard.keycode) { case ALLEGRO_KEY_UP: keys[UP] = false; break; case ALLEGRO_KEY_LEFT: keys[LEFT] = false; break; case ALLEGRO_KEY_DOWN: keys[DOWN] = false; break; case ALLEGRO_KEY_RIGHT: keys[RIGHT] = false; break; case ALLEGRO_KEY_W: keys[W] = false; break; case ALLEGRO_KEY_A: keys[A] = false; break; case ALLEGRO_KEY_S: keys[S] = false; break; case ALLEGRO_KEY_D: keys[D] = false; break; case ALLEGRO_KEY_E: keys[E] = false; break; case ALLEGRO_KEY_N: keys[N] = false; break; case ALLEGRO_KEY_ESCAPE: done = true; break; } } else if(ev.type == ALLEGRO_EVENT_TIMER) { if ( keys[UP] ) p1.y -= 1; if ( keys[DOWN] ) p1.y += 1; if ( keys[RIGHT] ) p1.x += 1; if ( keys[LEFT] ) p1.x -= 1; if ( keys[W] ) p2.y -= 1; if ( keys[S] ) p2.y += 1; if ( keys[D] ) p2.x += 1; if ( keys[A] ) p2.x -= 1; /*ALLEGRO_MOUSE_STATE MouseState; al_get_mouse_state(&MouseState); if ( MouseState.buttons & 1 ) { p1.x = ev.mouse.x; }*/ if ( tilemap_time.now() > num_natural_erosions * sec_per_natural_erosion ) { ErodeTilemap(tilemap); num_natural_erosions++; //kill underwater and beach trees: for( int i = 0; i < tree.size(); i++ ) { if ( 0.2 > tilemap.tile_[(int)tree[i].x%tile_render_size,(int)tree[i].y/tile_render_size].height() ) { tree.erase(tree.begin()+i); } } } if ( tilemap_time.now() > num_tree_periods * sec_per_tree_period ) { for ( int i = 0; i < tilemap_size_num_tiles_x * tilemap_size_num_tiles_y; i++) { if ( tilemap.tile_[i].height_ > 1 ) { if ( 0.05 > (float)(rand() % 10000) / 100 ) { int x = i_t_x(i)*tile_render_size + rand()%tile_render_size; int y = i_t_y(i)*tile_render_size + rand()%tile_render_size; int g = 102+rand()%102; tree.push_back(Sprite(x,y,Color(0,g,0))); } } } } if ( collision(p1,p2) ) std::cout << "collision!\n"; redraw = true; } if(redraw && al_is_event_queue_empty(event_queue)) { redraw = false; // Draw tilemap tiles: // i and j changes are hack that will cause problems later for ( int i = 1; i < view_tile_count_x+1; i++ ) { for ( int j = 1; j < view_tile_count_y+1; j++ ) { al_draw_filled_rectangle(i*tile_render_size,j*tile_render_size,i*tile_render_size+tile_render_size,j*tile_render_size+tile_render_size, al_map_rgb(tilemap.tile_[xy_t_i(i,j)].color_.r,tilemap.tile_[xy_t_i(i,j)].color_.g,tilemap.tile_[xy_t_i(i,j)].color_.b)); //al_draw_textf(font12, al_map_rgb(255,255,255), i*tile_render_size + tile_render_size/2,j*tile_render_size, ALLEGRO_ALIGN_CENTRE, "%.1fm", tilemap.tile_[xy_t_i(i,j)].height() ); //al_draw_textf(font12, al_map_rgb(255,255,255), i*tile_render_size + tile_render_size/2,(j+.5)*tile_render_size, ALLEGRO_ALIGN_CENTRE, "%d", i + j * tilemap_size_num_tiles_x ); } } // Draw player 1 //al_draw_filled_rectangle(p1.x-p1.radius, p1.y-p1.radius, p1.x+p1.radius, p1.y+p1.radius, al_map_rgb(204, 0, 0)); al_draw_filled_circle(p1.x, p1.y, p1.radius, al_map_rgb(p1.color.r, p1.color.g, p1.color.b)); al_draw_text(font24, al_map_rgb(0,0,0), p1.x, p1.y-p1.radius, ALLEGRO_ALIGN_CENTRE, "1"); // Draw player 2 //al_draw_filled_rectangle(p2.x-p2.radius, p2.y-p2.radius, p2.x+p2.radius, p2.y+p2.radius, al_map_rgb(0, 102, 204)); al_draw_filled_circle(p2.x, p2.y, p2.radius, al_map_rgb(p2.color.r, p2.color.g, p2.color.b)); al_draw_text(font24, al_map_rgb(0,0,0), p2.x, p2.y-p2.radius, ALLEGRO_ALIGN_CENTRE, "2"); // Draw trees for( int i = 0; i < tree.size(); i++ ) { al_draw_filled_circle(tree[i].x, tree[i].y, tree[i].radius, al_map_rgb(tree[i].color.r, tree[i].color.g, tree[i].color.b)); } // Draw info al_draw_textf(font12, al_map_rgb(255,255,255), tilemap_size_num_tiles_x*tile_render_size,0,0, "tilemap_time.now(): %.1f --- ErodeTilemap occurs every 10s!", tilemap_time.now() ); al_draw_textf(font12, al_map_rgb(255,255,255), tilemap_size_num_tiles_x*tile_render_size,12,0, "ErodeTilemap occurs every %ds!", sec_per_natural_erosion ); al_flip_display(); al_clear_to_color(al_map_rgb(0,0,0)); } } al_destroy_font(font12); al_destroy_font(font18); al_destroy_font(font24); al_destroy_font(font36); al_destroy_event_queue(event_queue); al_destroy_timer(timer); al_destroy_display(display); //destroy our display object return 0; }
void drawEvent(){ // Menu draw switch(gamePos){ case(1):{ // menu // Menu music if(!audio->isMenuPlaying()) audio->loopMenu(Volume, Pan); // draw menu screen draw->menu(menuText, menuSelect, resWidth[resPos], resHeight[resPos], tempFPS, tempVolume, tempPan); break; } case(2):{ // start gamePos = 3; //go to ingame player->start(startSpeed, WIDTH, HEIGHT); // set player start position ground = new Ground(HEIGHT); // create new ground class ground->start(WIDTH, HEIGHT, draw->playerHeight(), lastX, lastY); //set ground postion to start groundVector.push_back(*ground); // add ground to vector delete ground; // delete ground from memory (it is already copied to vector) for (int j = 0; j != int((WIDTH / 300) + 15); j++){ // loop as many times as diffrent ground are needed ground = new Ground(HEIGHT); // create new ground ground->create(lastX, lastY, player->getSpeed()); // set position from last ground groundVector.push_back(*ground); // add ground to vector delete ground; // delete ground from memory (it is already copied to vector) } startTimer(0); // start timers (0 = speed, score and down timers break; } case(3):{ // ingame // If menu song is playing then stop it if(audio->isMenuPlaying()) audio->stopLoopMenu(); // If ingame song is not playing then start it if(!audio->isInGamePlaying()) audio->loopInGame(Volume, Pan); // draw backround image draw->bg(); // check if player has dropped to bottom if (player->getY() + draw->playerHeight() >= HEIGHT) { // set gamepos to 4 (end) and stop ingame song and play end sound gamePos = 4; audio->stopLoopInGame(); audio->death(Volume, Pan); }; // Draw grounds to screen for (it = groundVector.begin(); it != groundVector.end(); it++) draw->ground(it->getX(), it->getY()); // draw player and text to backbuffer draw->player(player->getX(), player->getY()); draw->gameText(player->getScore(), player->getSpeed()); break; } case(4):{ // Draw end text to backbuffer draw->endText(player->getScore()); break; } } al_flip_display(); // Flip backbuffer to screen al_clear_to_color(al_map_rgb(0,0,0)); // empty backbuffer }
/* Draw our example scene. */ static void draw(void) { ALLEGRO_COLOR test[5]; ALLEGRO_BITMAP *target = al_get_target_bitmap(); char const *blend_names[] = {"ZERO", "ONE", "ALPHA", "INVERSE"}; char const *blend_vnames[] = {"ZERO", "ONE", "ALPHA", "INVER"}; int blend_modes[] = {ALLEGRO_ZERO, ALLEGRO_ONE, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA}; float x = 40, y = 40; int i, j; al_clear_to_color(al_map_rgb_f(0.5, 0.5, 0.5)); test[0] = al_map_rgba_f(1, 1, 1, 1); test[1] = al_map_rgba_f(1, 1, 1, 0.5); test[2] = al_map_rgba_f(1, 1, 1, 0.25); test[3] = al_map_rgba_f(1, 0, 0, 0.75); test[4] = al_map_rgba_f(0, 0, 0, 0); print(x, 0, false, "D E S T I N A T I O N (%0.2f fps)", ex.fps); print(0, y, true, "S O U R C E"); for (i = 0; i < 4; i++) { print(x + i * 110, 20, false, blend_names[i]); print(20, y + i * 110, true, blend_vnames[i]); } al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO); if (ex.mode >= 1 && ex.mode <= 5) { al_set_target_bitmap(ex.offscreen); al_clear_to_color(test[ex.mode - 1]); } if (ex.mode >= 6 && ex.mode <= 10) { al_set_target_bitmap(ex.memory); al_clear_to_color(test[ex.mode - 6]); } for (j = 0; j < 4; j++) { for (i = 0; i < 4; i++) { al_set_blender(ALLEGRO_ADD, blend_modes[j], blend_modes[i]); if (ex.image == 0) al_draw_bitmap(ex.example, x + i * 110, y + j * 110, 0); else if (ex.image >= 1 && ex.image <= 6) { al_draw_filled_rectangle(x + i * 110, y + j * 110, x + i * 110 + 100, y + j * 110 + 100, test[ex.image - 1]); } } } if (ex.mode >= 1 && ex.mode <= 5) { al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA); al_set_target_bitmap(target); al_draw_bitmap_region(ex.offscreen, x, y, 430, 430, x, y, 0); } if (ex.mode >= 6 && ex.mode <= 10) { al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA); al_set_target_bitmap(target); al_draw_bitmap_region(ex.memory, x, y, 430, 430, x, y, 0); } #define IS(x) ((ex.image == x) ? "*" : " ") print(ex.BUTTONS_X, 20 * 1, false, "What to draw"); print(ex.BUTTONS_X, 20 * 2, false, "%s Picture", IS(0)); print(ex.BUTTONS_X, 20 * 3, false, "%s Rec1 (1/1/1/1)", IS(1)); print(ex.BUTTONS_X, 20 * 4, false, "%s Rec2 (1/1/1/.5)", IS(2)); print(ex.BUTTONS_X, 20 * 5, false, "%s Rec3 (1/1/1/.25)", IS(3)); print(ex.BUTTONS_X, 20 * 6, false, "%s Rec4 (1/0/0/.75)", IS(4)); print(ex.BUTTONS_X, 20 * 7, false, "%s Rec5 (0/0/0/0)", IS(5)); #undef IS #define IS(x) ((ex.mode == x) ? "*" : " ") print(ex.BUTTONS_X, 20 * 9, false, "Where to draw"); print(ex.BUTTONS_X, 20 * 10, false, "%s screen", IS(0)); print(ex.BUTTONS_X, 20 * 11, false, "%s offscreen1", IS(1)); print(ex.BUTTONS_X, 20 * 12, false, "%s offscreen2", IS(2)); print(ex.BUTTONS_X, 20 * 13, false, "%s offscreen3", IS(3)); print(ex.BUTTONS_X, 20 * 14, false, "%s offscreen4", IS(4)); print(ex.BUTTONS_X, 20 * 15, false, "%s offscreen5", IS(5)); print(ex.BUTTONS_X, 20 * 16, false, "%s memory1", IS(6)); print(ex.BUTTONS_X, 20 * 17, false, "%s memory2", IS(7)); print(ex.BUTTONS_X, 20 * 18, false, "%s memory3", IS(8)); print(ex.BUTTONS_X, 20 * 19, false, "%s memory4", IS(9)); print(ex.BUTTONS_X, 20 * 20, false, "%s memory5", IS(10)); #undef IS }
int main(int argc, char **argv) { ////////////// if (argc < 2) { cout << "Podaj adres serwera" << endl; return 1; } string server = string(argv[1]); if (!connect_to_server(server)) { cout << "Połączenie nie powiodło się." << endl; return 1; } ////////////// 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; bool redraw = true; if(!al_init()) { fprintf(stderr, "failed to initialize allegro!\n"); return -1; } if(!al_install_mouse()) { fprintf(stderr, "failed to initialize the mouse!\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; } bouncer = al_create_bitmap(BOUNCER_SIZE, BOUNCER_SIZE); if(!bouncer) { fprintf(stderr, "failed to create bouncer bitmap!\n"); al_destroy_display(display); al_destroy_timer(timer); return -1; } al_set_target_bitmap(bouncer); 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_bitmap(bouncer); 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_mouse_event_source()); al_clear_to_color(al_map_rgb(0,0,0)); al_flip_display(); al_start_timer(timer); while(1) { ALLEGRO_EVENT ev; al_wait_for_event(event_queue, &ev); ///////////////// int n = service_websockets(); string s; while (receive_packet(s)) { cout << "ODEBRAŁEM: " << s << endl; stringstream ss; ss << s; string p; ss >> p; if (p == "DRAW") { int x,y; ss >> x; ss >> y; al_draw_bitmap(bouncer, x, y, 0); } } ///////////////// if(ev.type == ALLEGRO_EVENT_TIMER) { redraw = true; } else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { break; } else if(ev.type == ALLEGRO_EVENT_MOUSE_AXES || ev.type == ALLEGRO_EVENT_MOUSE_ENTER_DISPLAY) { bouncer_x = ev.mouse.x; bouncer_y = ev.mouse.y; } else if(ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP) { stringstream ss; ss << "DRAW " << ev.mouse.x << " " << ev.mouse.y; send_packet(ss.str()); } if(redraw && al_is_event_queue_empty(event_queue)) { redraw = false; al_flip_display(); } }
int main() { al_init(); al_install_mouse(); al_install_keyboard(); al_init_image_addon(); al_init_font_addon(); ALLEGRO_DISPLAY *display; al_set_new_display_flags(ALLEGRO_WINDOWED | ALLEGRO_OPENGL); al_set_new_display_option(ALLEGRO_DEPTH_SIZE, 24, ALLEGRO_REQUIRE); display = al_create_display(800, 600); if(!display) { std::cout<<"Failed to create display"<<std::endl; return 0; } ALLEGRO_EVENT_QUEUE *event_queue = al_create_event_queue(); al_register_event_source(event_queue, (ALLEGRO_EVENT_SOURCE *)display); al_register_event_source(event_queue, al_get_keyboard_event_source()); al_register_event_source(event_queue, al_get_mouse_event_source()); if(!Init()) return 0; double last_time = al_current_time(); bool quit = false; while(1) { ALLEGRO_EVENT event; while (al_get_next_event(event_queue, &event)) { if (ALLEGRO_EVENT_KEY_DOWN == event.type) { if (ALLEGRO_KEY_ESCAPE == event.keyboard.keycode) { quit = true; } } if (ALLEGRO_EVENT_DISPLAY_CLOSE == event.type) { quit = true; } Event(event); } if (quit) break; double current_time = al_current_time(); double dt = current_time - last_time; last_time = current_time; Update(dt); al_clear_to_color(al_map_rgb(0, 0, 0)); Render(); al_flip_display(); al_rest(0.001); } al_destroy_event_queue(event_queue); al_destroy_display(display); return 0; }
int main(int argc, char **argv) { ALLEGRO_DISPLAY *display; ALLEGRO_BITMAP *bmp; ALLEGRO_FONT *f; ALLEGRO_EVENT_QUEUE *queue; ALLEGRO_EVENT event; bool redraw; int min_w, min_h, max_w, max_h; int ret_min_w, ret_min_h, ret_max_w, ret_max_h; bool constr_min_w, constr_min_h, constr_max_w, constr_max_h; (void)argc; (void)argv; if (!al_init()) { abort_example("Could not init Allegro.\n"); } al_install_keyboard(); al_init_image_addon(); al_init_font_addon(); al_set_new_display_flags(ALLEGRO_RESIZABLE | ALLEGRO_GENERATE_EXPOSE_EVENTS); display = al_create_display(640, 480); if (!display) { abort_example("Unable to set any graphic mode\n"); } bmp = al_load_bitmap("data/mysha.pcx"); if (!bmp) { abort_example("Unable to load image\n"); } f = al_load_font("data/a4_font.tga", 0, 0); if (!f) { abort_example("Failed to load a4_font.tga\n"); } min_w = 640; min_h = 480; max_w = 800; max_h = 600; constr_min_w = constr_min_h = constr_max_w = constr_max_h = true; if (!al_set_window_constraints( display, constr_min_w ? min_w : 0, constr_min_h ? min_h : 0, constr_max_w ? max_w : 0, constr_max_h ? max_h : 0)) { abort_example("Unable to set window constraints.\n"); } al_apply_window_constraints(display, true); queue = al_create_event_queue(); al_register_event_source(queue, al_get_display_event_source(display)); al_register_event_source(queue, al_get_keyboard_event_source()); redraw = true; while (true) { if (redraw && al_is_event_queue_empty(queue)) { al_clear_to_color(al_map_rgb(255, 0, 0)); al_draw_scaled_bitmap(bmp, 0, 0, al_get_bitmap_width(bmp), al_get_bitmap_height(bmp), 0, 0, al_get_display_width(display), al_get_display_height(display), 0); /* Display screen resolution */ al_draw_textf(f, al_map_rgb(255, 255, 255), 0, 0, 0, "Resolution: %dx%d", al_get_display_width(display), al_get_display_height(display)); if (!al_get_window_constraints(display, &ret_min_w, &ret_min_h, &ret_max_w, &ret_max_h)) { abort_example("Unable to get window constraints\n"); } al_draw_textf(f, al_map_rgb(255, 255, 255), 0, al_get_font_line_height(f), 0, "Min Width: %d, Min Height: %d, Max Width: %d, Max Height: %d", ret_min_w, ret_min_h, ret_max_w, ret_max_h); al_draw_textf(f, al_map_rgb(255, 255, 255), 0, al_get_font_line_height(f) * 2,0, "Toggle Restriction: Min Width: Z, Min Height: X, Max Width: C, Max Height: V"); al_flip_display(); redraw = false; } al_wait_for_event(queue, &event); if (event.type == ALLEGRO_EVENT_DISPLAY_RESIZE) { al_acknowledge_resize(event.display.source); redraw = true; } if (event.type == ALLEGRO_EVENT_DISPLAY_EXPOSE) { redraw = true; } if (event.type == ALLEGRO_EVENT_KEY_DOWN) { if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) { break; } else if (event.keyboard.keycode == ALLEGRO_KEY_Z) { constr_min_w = ! constr_min_w; } else if (event.keyboard.keycode == ALLEGRO_KEY_X) { constr_min_h = ! constr_min_h; } else if (event.keyboard.keycode == ALLEGRO_KEY_C) { constr_max_w = ! constr_max_w; } else if (event.keyboard.keycode == ALLEGRO_KEY_V) { constr_max_h = ! constr_max_h; } redraw = true; if (!al_set_window_constraints(display, constr_min_w ? min_w : 0, constr_min_h ? min_h : 0, constr_max_w ? max_w : 0, constr_max_h ? max_h : 0)) { abort_example("Unable to set window constraints.\n"); } al_apply_window_constraints(display, true); } if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { break; } } al_destroy_bitmap(bmp); al_destroy_display(display); return 0; }
int main(int argc, char **argv) { ALLEGRO_DISPLAY *display; ALLEGRO_TIMER *timer; ALLEGRO_EVENT_QUEUE *queue; int redraw = 0; double t = 0; if (!al_init()) { abort_example("Could not init Allegro.\n"); } open_log_monospace(); al_init_primitives_addon(); al_install_mouse(); al_init_font_addon(); al_init_ttf_addon(); al_init_image_addon(); init_platform_specific(); #ifdef ALLEGRO_IPHONE al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW); #endif display = al_create_display(640, 480); if (!display) { abort_example("Could not create display.\n"); } al_install_keyboard(); if (argc >= 2) { font_file = argv[1]; } ex.f1 = al_load_font(font_file, 48, 0); ex.f2 = al_load_font(font_file, 48, ALLEGRO_TTF_NO_KERNING); ex.f3 = al_load_font(font_file, 12, 0); /* Specifying negative values means we specify the glyph height * in pixels, not the usual font size. */ ex.f4 = al_load_font(font_file, -140, 0); ex.f5 = al_load_font(font_file, 12, ALLEGRO_TTF_MONOCHROME); { int ranges[] = {0x1F40A, 0x1F40A}; ALLEGRO_BITMAP *icon = al_load_bitmap("data/icon.png"); if (!icon) { abort_example("Couldn't load data/icon.png.\n"); } ALLEGRO_BITMAP *glyph = al_create_bitmap(50, 50); al_set_target_bitmap(glyph); al_clear_to_color(al_map_rgba_f(0, 0, 0, 0)); al_draw_rectangle(0.5, 0.5, 49.5, 49.5, al_map_rgb_f(1, 1, 0), 1); al_draw_bitmap(icon, 1, 1, 0); al_set_target_backbuffer(display); ex.f_alex = al_grab_font_from_bitmap(glyph, 1, ranges); } if (!ex.f1 || !ex.f2 || !ex.f3 || !ex.f4 || !ex.f_alex) { abort_example("Could not load font: %s\n", font_file); } al_set_fallback_font(ex.f3, ex.f_alex); ex.ranges_count = al_get_font_ranges(ex.f1, 0, NULL); print_ranges(ex.f1); ex.config = al_load_config_file("data/ex_ttf.ini"); if (!ex.config) { abort_example("Could not data/ex_ttf.ini\n"); } timer = al_create_timer(1.0 / 60); 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); while (true) { ALLEGRO_EVENT event; al_wait_for_event(queue, &event); if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) break; if (event.type == ALLEGRO_EVENT_KEY_DOWN && event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) { break; } if (event.type == ALLEGRO_EVENT_TIMER) redraw++; while (redraw > 0 && al_is_event_queue_empty(queue)) { double dt; redraw--; dt = al_get_time(); render(); dt = al_get_time() - dt; t = 0.99 * t + 0.01 * dt; ex.fps = 1.0 / t; al_flip_display(); } } al_destroy_font(ex.f1); al_destroy_font(ex.f2); al_destroy_font(ex.f3); al_destroy_font(ex.f4); al_destroy_font(ex.f5); al_destroy_config(ex.config); close_log(false); return 0; }
void desenha_fundo_jogo (Jogo* jogo) { al_clear_to_color(al_map_rgb(20,20,20)); // al_draw_bitmap (jogo->fundo, 0, 0, 0); }
static void render(void) { ALLEGRO_COLOR white = al_map_rgba_f(1, 1, 1, 1); ALLEGRO_COLOR black = al_map_rgba_f(0, 0, 0, 1); ALLEGRO_COLOR red = al_map_rgba_f(1, 0, 0, 1); ALLEGRO_COLOR green = al_map_rgba_f(0, 0.5, 0, 1); ALLEGRO_COLOR blue = al_map_rgba_f(0.1, 0.2, 1, 1); ALLEGRO_COLOR purple = al_map_rgba_f(0.3, 0.1, 0.2, 1); int x, y, w, h, as, de, xpos, ypos; unsigned int index; int target_w, target_h; ALLEGRO_USTR_INFO info, sub_info; const ALLEGRO_USTR *u; ALLEGRO_USTR *tulip = al_ustr_new("Tulip"); ALLEGRO_USTR *dimension_text = al_ustr_new("Tulip"); ALLEGRO_USTR *vertical_text = al_ustr_new("Rose."); al_clear_to_color(white); al_hold_bitmap_drawing(true); al_draw_textf(ex.f1, black, 50, 20, 0, "Tulip (kerning)"); al_draw_textf(ex.f2, black, 50, 80, 0, "Tulip (no kerning)"); x = 50; y = 140; for (index = 0; index < al_ustr_length(dimension_text); index ++) { int cp = ustr_at(dimension_text, index); int bbx, bby, bbw, bbh; al_get_glyph_dimensions(ex.f2, cp, &bbx, &bby, &bbw, &bbh); al_draw_rectangle(x + bbx + 0.5, y + bby + 0.5, x + bbx + bbw - 0.5, y + bby + bbh - 0.5, blue, 1); al_draw_rectangle(x + 0.5, y + 0.5, x + bbx + bbw - 0.5, y + bby + bbh - 0.5, green, 1); al_draw_glyph(ex.f2, purple, x, y, cp); x += al_get_glyph_advance(ex.f2, cp, ALLEGRO_NO_KERNING); } al_draw_line(50.5, y+0.5, x+0.5, y+0.5, red, 1); al_draw_textf(ex.f2, black, x + 10, y, 0, "(dimensions)"); al_draw_textf(ex.f3, black, 50, 200, 0, "This font has a size of 12 pixels, " "the one above has 48 pixels."); al_hold_bitmap_drawing(false); al_hold_bitmap_drawing(true); al_draw_textf(ex.f3, red, 50, 220, 0, "The color can simply be changed.🐊← fallback glyph"); al_hold_bitmap_drawing(false); al_hold_bitmap_drawing(true); al_draw_textf(ex.f3, green, 50, 240, 0, "Some unicode symbols:"); al_draw_textf(ex.f3, green, 50, 260, 0, "%s", get_string("symbols1")); al_draw_textf(ex.f3, green, 50, 280, 0, "%s", get_string("symbols2")); al_draw_textf(ex.f3, green, 50, 300, 0, "%s", get_string("symbols3")); #define OFF(x) al_ustr_offset(u, x) #define SUB(x, y) al_ref_ustr(&sub_info, u, OFF(x), OFF(y)) u = al_ref_cstr(&info, get_string("substr1")); al_draw_ustr(ex.f3, green, 50, 320, 0, SUB(0, 6)); u = al_ref_cstr(&info, get_string("substr2")); al_draw_ustr(ex.f3, green, 50, 340, 0, SUB(7, 11)); u = al_ref_cstr(&info, get_string("substr3")); al_draw_ustr(ex.f3, green, 50, 360, 0, SUB(4, 11)); u = al_ref_cstr(&info, get_string("substr4")); al_draw_ustr(ex.f3, green, 50, 380, 0, SUB(0, 11)); al_draw_textf(ex.f5, black, 50, 395, 0, "forced monochrome"); /* Glyph rendering tests. */ al_draw_textf(ex.f3, red, 50, 410, 0, "Glyph adv Tu: %d, draw: ", al_get_glyph_advance(ex.f3, 'T', 'u')); x = 50; y = 425; for (index = 0; index < al_ustr_length(tulip); index ++) { int cp = ustr_at(tulip, index); /* Use al_get_glyph_advance for the stride, with no kerning. */ al_draw_glyph(ex.f3, red, x, y, cp); x += al_get_glyph_advance(ex.f3, cp, ALLEGRO_NO_KERNING); } x = 50; y = 440; /* First draw a red string using al_draw_text, that should be hidden * completely by the same text drawing in green per glyph * using al_draw_glyph and al_get_glyph_advance below. */ al_draw_ustr(ex.f3, red, x, y, 0, tulip); for (index = 0; index < al_ustr_length(tulip); index ++) { int cp = ustr_at(tulip, index); int ncp = (index < (al_ustr_length(tulip) - 1)) ? ustr_at(tulip, index + 1) : ALLEGRO_NO_KERNING; /* Use al_get_glyph_advance for the stride and apply kerning. */ al_draw_glyph(ex.f3, green, x, y, cp); x += al_get_glyph_advance(ex.f3, cp, ncp); } x = 50; y = 466; al_draw_ustr(ex.f3, red, x, y, 0, tulip); for (index = 0; index < al_ustr_length(tulip); index ++) { int cp = ustr_at(tulip, index); int bbx, bby, bbw, bbh; al_get_glyph_dimensions(ex.f3, cp, &bbx, &bby, &bbw, &bbh); al_draw_glyph(ex.f3, blue, x, y, cp); x += bbx + bbw; } x = 10; y = 30; for (index = 0; index < al_ustr_length(vertical_text); index ++) { int bbx, bby, bbw, bbh; int cp = ustr_at(vertical_text, index); /* Use al_get_glyph_dimensions for the height to apply. */ al_get_glyph_dimensions(ex.f3, cp, &bbx, &bby, &bbw, &bbh); al_draw_glyph(ex.f3, green, x, y, cp); y += bby; y += bbh; } x = 30; y = 30; for (index = 0; index < al_ustr_length(vertical_text); index ++) { int bbx, bby, bbw, bbh; int cp = ustr_at(vertical_text, index); /* Use al_get_glyph_dimensions for the height to apply, here bby is * omited for the wrong result. */ al_get_glyph_dimensions(ex.f3, cp, &bbx, &bby, &bbw, &bbh); al_draw_glyph(ex.f3, red, x, y, cp); y += bbh; } al_hold_bitmap_drawing(false); target_w = al_get_bitmap_width(al_get_target_bitmap()); target_h = al_get_bitmap_height(al_get_target_bitmap()); xpos = target_w - 10; ypos = target_h - 10; al_get_text_dimensions(ex.f4, "Allegro", &x, &y, &w, &h); as = al_get_font_ascent(ex.f4); de = al_get_font_descent(ex.f4); xpos -= w; ypos -= h; x += xpos; y += ypos; al_draw_rectangle(x, y, x + w - 0.5, y + h - 0.5, black, 0); al_draw_line(x+0.5, y + as + 0.5, x + w - 0.5, y + as + 0.5, black, 0); al_draw_line(x + 0.5, y + as + de + 0.5, x + w - 0.5, y + as + de + 0.5, black, 0); al_hold_bitmap_drawing(true); al_draw_textf(ex.f4, blue, xpos, ypos, 0, "Allegro"); al_hold_bitmap_drawing(false); al_hold_bitmap_drawing(true); al_draw_textf(ex.f3, black, target_w, 0, ALLEGRO_ALIGN_RIGHT, "%.1f FPS", ex.fps); al_draw_textf(ex.f3, black, 0, 0, 0, "%s: %d unicode ranges", font_file, ex.ranges_count); al_hold_bitmap_drawing(false); }
int init_bitmaps(Board *b){ // will load bitmaps from folders named 0, 1,..., 7 // inside the folder "icons", each containing 8 square bitmaps int i,j, k=0; char pathname[1000]; ALLEGRO_PATH *path; ALLEGRO_BITMAP *dispbuf = al_get_target_bitmap(); al_set_target_bitmap(NULL); // this is a workaround for android -- try removing later #ifdef ALLEGRO_ANDROID al_android_set_apk_file_interface(); #endif al_set_target_bitmap(dispbuf); for(i=0;i<b->h+1;i++){ for(j=0;j<b->n; j++){ al_utf8_encode(symbol_char[i][j], BF_CODEPOINT_START+ j + i*b->n); symbol_char[i][j][al_utf8_width(BF_CODEPOINT_START+ j + i*b->n)] = '\0'; } } // create buttons // xxx todo: improve these default_font = al_load_font(DEFAULT_FONT_FILE, 16, 0); if(!default_font) errlog("Error loading default font"); b->info_text_bmp = NULL; b->info_panel.bmp = NULL; // if this fails, buttons will be created anyway at update_bitmaps b->button_bmp[0] = al_load_bitmap("buttons/light-bulb.png"); b->button_bmp[1] = al_load_bitmap("buttons/question.png"); b->button_bmp[2] = al_load_bitmap("buttons/gear.png"); b->button_bmp[3] = al_load_bitmap("buttons/undo.png"); if(b->type_of_tiles == 2) return init_bitmaps_classic(b); if(b->type_of_tiles == 1){ // use bitmaps #ifndef ALLEGRO_ANDROID path = al_get_standard_path(ALLEGRO_RESOURCES_PATH); al_path_cstr(path, '/'); #else path = al_create_path(""); #endif for(j=0; j<b->h; j++){ for(k=0; k<b->n; k++){ snprintf(pathname, 999, "%sicons/%d/%d.png", al_path_cstr(path, '/'), j, k); basic_bmp[j][k] = al_load_bitmap(pathname); if(!basic_bmp[j][k]){ errlog("Error loading %s.", pathname); unload_basic_bmps(b, j,k-1); al_destroy_path(path); return -1; } } } al_destroy_path(path); } // create symbols (alternatively we could load these from files!)) symbol_bmp[SYM_FORBIDDEN] = al_create_bitmap(256, 256); symbol_bmp[SYM_SWAPPABLE] = al_create_bitmap(3*256 + 2*b->clue_unit_space, 256); symbol_bmp[SYM_ONE_SIDE] = al_create_bitmap(256, 256); symbol_bmp[SYM_ONLY_ONE] = al_create_bitmap(256, 3*256); if( (!symbol_bmp[SYM_FORBIDDEN]) || (!symbol_bmp[SYM_SWAPPABLE]) || (!symbol_bmp[SYM_ONE_SIDE]) || !symbol_bmp[SYM_ONLY_ONE]){ fprintf(stderr, "Error creating bitmap.\n"); return -1; } al_set_target_bitmap(symbol_bmp[SYM_FORBIDDEN]); al_clear_to_color(NULL_COLOR); al_draw_line(1, 1, 254, 254, al_map_rgba_f(1,0,0,0.5),4); al_draw_line(1, 254, 254, 1, al_map_rgba_f(1,0,0,0.5),4); al_set_target_bitmap(symbol_bmp[SYM_SWAPPABLE]); al_clear_to_color(NULL_COLOR); al_draw_line(256*0.7,256*0.9, 256*(3-0.7),256*0.9, al_map_rgba_f(1,0,0,0.5), 2); al_draw_filled_triangle(256*0.5,256*0.9, 256*0.7,256, 256*0.7, 256*0.8, al_map_rgba_f(1,0,0,0.35)); al_set_target_bitmap(symbol_bmp[SYM_ONE_SIDE]); al_clear_to_color(NULL_COLOR); al_draw_filled_circle(256/2, 256/2, 0.03*256, WHITE_COLOR); al_draw_filled_circle(256/2 - 0.2*256, 256/2, 0.03*256, WHITE_COLOR); al_draw_filled_circle(256/2 + 0.2*256, 256/2, 0.03*256, WHITE_COLOR); al_set_target_bitmap(symbol_bmp[SYM_ONLY_ONE]); al_clear_to_color(NULL_COLOR); al_draw_filled_triangle(256*0.3, 256, 256*0.7, 256, 256*0.5, 256*0.7, al_map_rgba_f(1,0,0,0.5)); al_draw_filled_triangle(256*0.3, 256, 256*0.7, 256, 256*0.5, 256*1.3, al_map_rgba_f(1,0,0,0.5)); al_draw_line(256*0.5, 256*0.8, 256*0.5, 256*1.2, WHITE_COLOR, 3); al_set_target_bitmap(dispbuf); return 0; }
void Prog::run() { d.prepare(); while (!d.is_quit_requested()) { if (d.is_draw_requested()) { al_clear_to_color(al_map_rgb(128, 128, 128)); float v[SLIDERS_COUNT]; int keep = -1; for (int i = 0; i < SLIDERS_COUNT; i++) { int x = sliders[i].get_cur_value(); v[i] = x / 1000.0; if (previous[i] != x) { keep = i; } } if (keep != -1) { int space = keep < 12 ? keep / 3 : 4; switch (space) { case 0: al_color_rgb_to_hsv(v[0], v[1], v[2], v + 3, v + 4, v + 5); al_color_rgb_to_hsl(v[0], v[1], v[2], v + 6, v + 7, v + 8); al_color_rgb_to_cmyk(v[0], v[1], v[2], v + 12, v + 13, v + 14, v + 15); al_color_rgb_to_yuv(v[0], v[1], v[2], v + 9, v + 10, v + 11); v[3] /= 360; v[6] /= 360; break; case 1: al_color_hsv_to_rgb(v[3] * 360, v[4], v[5], v + 0, v + 1, v + 2); al_color_rgb_to_hsl(v[0], v[1], v[2], v + 6, v + 7, v + 8); al_color_rgb_to_cmyk(v[0], v[1], v[2], v + 12, v + 13, v + 14, v + 15); al_color_rgb_to_yuv(v[0], v[1], v[2], v + 9, v + 10, v + 11); v[6] /= 360; break; case 2: al_color_hsl_to_rgb(v[6] * 360, v[7], v[8], v + 0, v + 1, v + 2); al_color_rgb_to_hsv(v[0], v[1], v[2], v + 3, v + 4, v + 5); al_color_rgb_to_cmyk(v[0], v[1], v[2], v + 12, v + 13, v + 14, v + 15); al_color_rgb_to_yuv(v[0], v[1], v[2], v + 9, v + 10, v + 11); v[3] /= 360; break; case 3: al_color_yuv_to_rgb(v[9], v[10], v[11], v + 0, v + 1, v + 2); v[0] = clamp(v[0]); v[1] = clamp(v[1]); v[2] = clamp(v[2]); al_color_rgb_to_yuv(v[0], v[1], v[2], v + 9, v + 10, v + 11); al_color_rgb_to_hsv(v[0], v[1], v[2], v + 3, v + 4, v + 5); al_color_rgb_to_hsl(v[0], v[1], v[2], v + 6, v + 7, v + 8); al_color_rgb_to_cmyk(v[0], v[1], v[2], v + 12, v + 13, v + 14, v + 15); v[3] /= 360; v[6] /= 360; break; case 4: al_color_cmyk_to_rgb(v[12], v[13], v[14], v[15], v + 0, v + 1, v + 2); al_color_rgb_to_hsv(v[0], v[1], v[2], v + 3, v + 4, v + 5); al_color_rgb_to_hsl(v[0], v[1], v[2], v + 6, v + 7, v + 8); al_color_rgb_to_yuv(v[0], v[1], v[2], v + 9, v + 10, v + 11); v[3] /= 360; v[6] /= 360; break; } } for (int i = 0; i < SLIDERS_COUNT; i++) { sliders[i].set_cur_value((int)(v[i] * 1000)); previous[i] = sliders[i].get_cur_value(); char c[100]; sprintf(c, "%d", (int)(v[i] * 100)); labels2[i].set_text(c); } d.draw(); al_draw_filled_rectangle(0, 400, 640, 480, al_map_rgb_f(v[0], v[1], v[2])); char const *name = al_color_rgb_to_name(v[0], v[1], v[2]); char html[8]; al_color_rgb_to_html(v[0], v[1], v[2], html); al_draw_text(d.get_theme().font, al_map_rgb(0, 0, 0), 0, 380, 0, name); al_draw_text(d.get_theme().font, al_map_rgb(0, 0, 0), 0, 360, 0, html); al_flip_display(); } d.run_step(true); } }
int update_font_bitmaps(Game *g, Board *b){ int i, j, s; float FONT_FACTOR=1; ALLEGRO_FONT *tile_font1, *tile_font2, *tile_font3; ALLEGRO_BITMAP *dispbuf = al_get_target_bitmap(); int bbx, bby, bbw, bbh; al_set_target_bitmap(NULL); s=min(b->panel.b[0]->b[0]->w, b->panel.b[0]->b[0]->h); tile_font1 = load_font_mem(tile_font_mem, TILE_FONT_FILE, -s*FONT_FACTOR); tile_font2 = load_font_mem(tile_font_mem, TILE_FONT_FILE, -b->panel_tile_size*FONT_FACTOR); tile_font3 = load_font_mem(tile_font_mem, TILE_FONT_FILE, -b->clue_unit_size*FONT_FACTOR); if(!tile_font1 || !tile_font2 || !tile_font3) { fprintf(stderr, "Error loading tile font file %s.\n", TILE_FONT_FILE); return -1; } for(i=0;i<b->h;i++){ for(j=0;j<b->n;j++){ b->guess_bmp[i][j] = al_create_bitmap(b->panel.b[0]->b[0]->w, b->panel.b[0]->b[0]->h); b->panel_tile_bmp[i][j] = al_create_bitmap(b->panel_tile_size,b->panel_tile_size); b->clue_unit_bmp[i][j] = al_create_bitmap(b->clue_unit_size, b->clue_unit_size); if(!b->guess_bmp[i][j] || !b->panel_tile_bmp[i][j] || !b->clue_unit_bmp[i][j]){ fprintf(stderr, "Error creating bitmap.\n"); return -1; } // guessed bitmaps al_set_target_bitmap(b->guess_bmp[i][j]); al_clear_to_color(al_color_html(CLUE_BG_COLOR[i])); al_get_glyph_dimensions(tile_font1, CLUE_CODE[i][j][0], &bbx, &bby, &bbw, &bbh); if(GLYPH_SHADOWS){ al_draw_glyph(tile_font1, DARK_GREY_COLOR, (b->panel.b[0]->b[0]->w-bbw)/2 -bbx +1,(b->panel.b[0]->b[0]->h-bbh)/2-bby+1, CLUE_CODE[i][j][0]); } al_draw_glyph(tile_font1, al_color_html(CLUE_FG_COLOR[i]), (b->panel.b[0]->b[0]->w-bbw)/2 -bbx,(b->panel.b[0]->b[0]->h-bbh)/2-bby, CLUE_CODE[i][j][0]); // this draws a border for all tiles, independent of the "bd" setting in b if(TILE_SHADOWS) draw_shadow(b->panel.b[0]->b[0]->w, b->panel.b[0]->b[0]->h,2); else al_draw_rectangle(.5,.5,b->panel.b[0]->b[0]->w-.5, b->panel.b[0]->b[0]->h-.5, TILE_GENERAL_BD_COLOR,1); // panel bitmaps al_set_target_bitmap(b->panel_tile_bmp[i][j]); al_clear_to_color(al_color_html(CLUE_BG_COLOR[i])); al_get_glyph_dimensions(tile_font2, CLUE_CODE[i][j][0], &bbx, &bby, &bbw, &bbh); if(GLYPH_SHADOWS){ al_draw_glyph(tile_font2, DARK_GREY_COLOR,(b->panel_tile_size -bbw)/2-bbx+1, (b->panel_tile_size - bbh)/2-bby+1, CLUE_CODE[i][j][0]); } al_draw_glyph(tile_font2, al_color_html(CLUE_FG_COLOR[i]),(b->panel_tile_size -bbw)/2-bbx, (b->panel_tile_size - bbh)/2-bby, CLUE_CODE[i][j][0]); if(TILE_SHADOWS) draw_shadow(b->panel_tile_size, b->panel_tile_size,2); else al_draw_rectangle(.5,.5,b->panel_tile_size-.5,b->panel_tile_size-.5, TILE_GENERAL_BD_COLOR,1); // clue unit tile bitmaps al_set_target_bitmap(b->clue_unit_bmp[i][j]); al_clear_to_color(al_color_html(CLUE_BG_COLOR[i])); al_get_glyph_dimensions(tile_font3, CLUE_CODE[i][j][0], &bbx, &bby, &bbw, &bbh); if(GLYPH_SHADOWS){ al_draw_glyph(tile_font3, DARK_GREY_COLOR, (b->clue_unit_size-bbw)/2 -bbx +1,(b->clue_unit_size-bbh)/2-bby+1, CLUE_CODE[i][j][0]); } al_draw_glyph(tile_font3, al_color_html(CLUE_FG_COLOR[i]), (b->clue_unit_size-bbw)/2 -bbx,(b->clue_unit_size-bbh)/2-bby, CLUE_CODE[i][j][0]); if(TILE_SHADOWS) draw_shadow(b->clue_unit_size,b->clue_unit_size,2); else al_draw_rectangle(.5,.5,b->clue_unit_size-.5, b->clue_unit_size-.5, TILE_GENERAL_BD_COLOR,1); } } if(draw_symbols(g, b)) return -1; al_destroy_font(tile_font1); al_destroy_font(tile_font2); al_destroy_font(tile_font3); al_set_target_backbuffer(al_get_current_display()); // create clue tile bmps al_set_target_bitmap(dispbuf); return make_clue_bitmaps(g, b); }
void Menu_Preload(struct Game *game, void (*progress)(struct Game*, float)) { PROGRESS_INIT(16); game->menu.options.fullscreen = game->fullscreen; game->menu.options.fps = game->fps; game->menu.options.width = game->width; game->menu.options.height = game->height; game->menu.loaded = true; game->menu.image = LoadScaledBitmap( "menu/menu.png", game->viewportWidth, game->viewportWidth*(1240.0/3910.0)); PROGRESS; game->menu.mountain = LoadScaledBitmap( "menu/mountain.png", game->viewportHeight*1.6*0.055, game->viewportHeight/9 ); PROGRESS; game->menu.cloud = LoadScaledBitmap( "menu/cloud.png", game->viewportHeight*1.6*0.5, game->viewportHeight*0.25 ); PROGRESS; game->menu.cloud2 = LoadScaledBitmap( "menu/cloud2.png", game->viewportHeight*1.6*0.2, game->viewportHeight*0.1 ); PROGRESS; game->menu.logo = LoadScaledBitmap( "menu/logo.png", game->viewportHeight*1.6*0.3, game->viewportHeight*0.35 ); game->menu.blurbg = al_create_bitmap(game->viewportHeight*1.6*0.3, game->viewportHeight*0.35); game->menu.blurbg2 = al_create_bitmap(game->viewportHeight*1.6*0.3, game->viewportHeight*0.35); PROGRESS; game->menu.logoblur = al_create_bitmap(game->viewportHeight*1.6*0.3+4, game->viewportHeight*0.35+4); al_set_target_bitmap(game->menu.logoblur); al_clear_to_color(al_map_rgba(0,0,0,0)); float alpha = (1.0/40.0); ALLEGRO_COLOR color = al_map_rgba_f(alpha, alpha, alpha, alpha); int by, bx; for (by = -2; by <= 2; by++) { for (bx = -2; bx <= 2; bx++) { if (sqrt(bx*bx+by*by) <= 2) al_draw_tinted_bitmap(game->menu.logo, color, bx, by, 0); } } al_set_target_bitmap(al_get_backbuffer(game->display)); PROGRESS; game->menu.glass = LoadScaledBitmap( "menu/glass.png", game->viewportHeight*1.6*0.3, game->viewportHeight*0.35 ); PROGRESS; //game->menu.pinkcloud = LoadScaledBitmap( "menu/pinkcloud.png", game->viewportWidth*0.33125, game->viewportHeight*0.8122); game->menu.pinkcloud = LoadScaledBitmap( "menu/pinkcloud.png", game->viewportHeight*0.8122*(1171.0/2218.0), game->viewportHeight*0.8122); PROGRESS; al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); game->menu.rain = al_load_bitmap( GetDataFilePath("menu/rain.png") ); PROGRESS; game->menu.pie = al_load_bitmap( GetDataFilePath("menu/pie.png") ); al_set_new_bitmap_flags(ALLEGRO_MAG_LINEAR | ALLEGRO_MIN_LINEAR); PROGRESS; game->menu.sample = al_load_sample( GetDataFilePath("menu/menu.flac") ); PROGRESS; game->menu.rain_sample = al_load_sample( GetDataFilePath("menu/rain.flac") ); PROGRESS; game->menu.click_sample = al_load_sample( GetDataFilePath("menu/click.flac") ); PROGRESS; game->menu.mountain_position = game->viewportWidth*0.7; game->menu.music = al_create_sample_instance(game->menu.sample); al_attach_sample_instance_to_mixer(game->menu.music, game->audio.music); al_set_sample_instance_playmode(game->menu.music, ALLEGRO_PLAYMODE_LOOP); game->menu.rain_sound = al_create_sample_instance(game->menu.rain_sample); al_attach_sample_instance_to_mixer(game->menu.rain_sound, game->audio.fx); al_set_sample_instance_playmode(game->menu.rain_sound, ALLEGRO_PLAYMODE_LOOP); game->menu.click = al_create_sample_instance(game->menu.click_sample); al_attach_sample_instance_to_mixer(game->menu.click, game->audio.fx); al_set_sample_instance_playmode(game->menu.click, ALLEGRO_PLAYMODE_ONCE); game->menu.font_title = al_load_ttf_font(GetDataFilePath("fonts/ShadowsIntoLight.ttf"),game->viewportHeight*0.16,0 ); game->menu.font_subtitle = al_load_ttf_font(GetDataFilePath("fonts/ShadowsIntoLight.ttf"),game->viewportHeight*0.08,0 ); game->menu.font = al_load_ttf_font(GetDataFilePath("fonts/ShadowsIntoLight.ttf"),game->viewportHeight*0.05,0 ); game->menu.font_selected = al_load_ttf_font(GetDataFilePath("fonts/ShadowsIntoLight.ttf"),game->viewportHeight*0.065,0 ); PROGRESS; if (!game->menu.sample){ fprintf(stderr, "Audio clip sample not loaded!\n" ); exit(-1); } if (!game->menu.rain_sample){ fprintf(stderr, "Audio clip sample#2 not loaded!\n" ); exit(-1); } if (!game->menu.click_sample){ fprintf(stderr, "Audio clip sample#3 not loaded!\n" ); exit(-1); } game->menu.pinkcloud_bitmap = al_create_bitmap(game->viewportHeight*0.8122*(1171.0/2218.0), game->viewportHeight); game->menu.pie_bitmap = al_create_bitmap(game->viewportHeight*0.8, game->viewportHeight); al_set_target_bitmap(game->menu.pie_bitmap); al_clear_to_color(al_map_rgba(0,0,0,0)); al_draw_scaled_bitmap(game->menu.pie, 0, 0, al_get_bitmap_width(game->menu.pie), al_get_bitmap_height(game->menu.pie), al_get_bitmap_width(game->menu.pie_bitmap)*0.5, 0, game->viewportHeight*1.6*0.11875, game->viewportHeight*0.0825, 0); al_draw_scaled_bitmap(game->menu.pie, 0, 0, al_get_bitmap_width(game->menu.pie), al_get_bitmap_height(game->menu.pie), al_get_bitmap_width(game->menu.pie_bitmap)*0.1, al_get_bitmap_height(game->menu.pie_bitmap)*0.3, game->viewportHeight*1.6*0.09, game->viewportHeight*0.06, ALLEGRO_FLIP_HORIZONTAL); al_draw_scaled_bitmap(game->menu.pie, 0, 0, al_get_bitmap_width(game->menu.pie), al_get_bitmap_height(game->menu.pie), al_get_bitmap_width(game->menu.pie_bitmap)*0.3, al_get_bitmap_height(game->menu.pie_bitmap)*0.6, game->viewportHeight*1.6*0.13, game->viewportHeight*0.1, 0); al_destroy_bitmap(game->menu.pie); PROGRESS; al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP); game->menu.rain_bitmap = al_create_bitmap(al_get_bitmap_width(game->menu.pinkcloud_bitmap)*0.5, al_get_bitmap_height(game->menu.pinkcloud_bitmap)*0.1); al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR); al_set_target_bitmap(game->menu.rain_bitmap); al_clear_to_color(al_map_rgba(0,0,0,0)); al_draw_scaled_bitmap(game->menu.rain,0, 0, al_get_bitmap_width(game->menu.rain), al_get_bitmap_height(game->menu.rain), 0, 0, al_get_bitmap_width(game->menu.rain_bitmap), al_get_bitmap_height(game->menu.rain_bitmap),0); al_destroy_bitmap(game->menu.rain); PROGRESS; }
int update_bitmaps(Game *g, Board *b){ int i, j, s; ALLEGRO_BITMAP *dispbuf = al_get_target_bitmap(); al_set_target_bitmap(NULL); // reload text fonts // estimate font size for panel: if(!(b->text_font = load_font_mem(text_font_mem, TEXT_FONT_FILE, -min(b->info_panel.h/2.2, sqrt(b->info_panel.w*b->info_panel.h)/10))) ){ fprintf(stderr, "Error loading font %s.\n", TEXT_FONT_FILE); } // update buttons and timer bmps b->time_bmp = al_create_bitmap(b->time_panel.b[0]->w, b->time_panel.b[0]->h); al_set_target_bitmap(b->time_bmp); al_clear_to_color(b->time_panel.b[0]->bg_color); // this should go here, but by android problems we have to recreate the bitmap on every new text drawing: // b->info_text_bmp = al_create_bitmap(b->info_panel.w, b->info_panel.h); for(i=0; i<4; i++){ b->button_bmp_scaled[i] = scaled_clone_bitmap(b->button_bmp[i], b->time_panel.b[i+1]->w, b->time_panel.b[i+1]->h); } al_set_target_bitmap(dispbuf); if (b->type_of_tiles == 0) { // use font bitmaps return update_font_bitmaps(g, b); } // else update normal bitmaps: al_set_target_bitmap(NULL); s=min(b->panel.b[0]->b[0]->w, b->panel.b[0]->b[0]->h); for(i=0;i<b->h;i++){ for(j=0;j<b->n;j++){ b->guess_bmp[i][j] = al_create_bitmap(b->panel.b[0]->b[0]->w, b->panel.b[0]->b[0]->h); b->panel_tile_bmp[i][j] = al_create_bitmap(b->panel_tile_size,b->panel_tile_size); b->clue_unit_bmp[i][j] = al_create_bitmap(b->clue_unit_size, b->clue_unit_size); if(!b->guess_bmp[i][j] || !b->panel_tile_bmp[i][j] || !b->clue_unit_bmp[i][j]){ fprintf(stderr, "Error creating bitmap.\n"); return -1; } // guessed bitmaps al_set_target_bitmap(b->guess_bmp[i][j]); if(b->type_of_tiles != 2) // not classic tiles al_clear_to_color(al_color_html(CLUE_BG_COLOR_BMP[i])); else al_clear_to_color(b->panel.b[0]->b[0]->bg_color); if(TILE_SHADOWS) draw_shadow(b->panel.b[0]->b[0]->w, b->panel.b[0]->b[0]->h,2); else al_draw_rectangle(.5,.5,b->panel.b[0]->b[0]->w-.5, b->panel.b[0]->b[0]->h-.5, TILE_GENERAL_BD_COLOR,1); al_draw_scaled_bitmap(basic_bmp[i][j], 0, 0, al_get_bitmap_width(basic_bmp[i][j]), al_get_bitmap_height(basic_bmp[i][j]), (b->panel.b[0]->b[0]->w-s)/2, (b->panel.b[0]->b[0]->h-s)/2, s, s, 0); // panel bitmaps al_set_target_bitmap(b->panel_tile_bmp[i][j]); al_clear_to_color(al_color_html(CLUE_BG_COLOR_BMP[i])); if(TILE_SHADOWS) draw_shadow(b->panel_tile_size, b->panel_tile_size,1); else al_draw_rectangle(.5,.5,b->panel_tile_size-.5,b->panel_tile_size-.5, TILE_GENERAL_BD_COLOR,1); al_draw_scaled_bitmap(basic_bmp[i][j], 0, 0, al_get_bitmap_width(basic_bmp[i][j]), al_get_bitmap_height(basic_bmp[i][j]), 0, 0, b->panel_tile_size, b->panel_tile_size,0); // clue unit tile bitmaps al_set_target_bitmap(b->clue_unit_bmp[i][j]); al_clear_to_color(al_color_html(CLUE_BG_COLOR_BMP[i])); if(TILE_SHADOWS) draw_shadow(b->clue_unit_size,b->clue_unit_size,2); else al_draw_rectangle(.5,.5,b->clue_unit_size-.5, b->clue_unit_size-.5, TILE_GENERAL_BD_COLOR,1); al_draw_scaled_bitmap(basic_bmp[i][j], 0, 0, al_get_bitmap_width(basic_bmp[i][j]), al_get_bitmap_height(basic_bmp[i][j]), 0, 0, b->clue_unit_size, b->clue_unit_size,0); } } if(b->type_of_tiles != 2) { if(draw_symbols(g,b)) return -1; } else { if(draw_classic_symbols(g,b)) return -1; } al_set_target_bitmap(dispbuf); // create clue tile bmps return make_clue_bitmaps(g, b); }
void gfx_render(int step) { static int last[2] = {0.0, 0.0}; int i, j, scale = MIN(G.w / G.gi.map_size[0], G.h / G.gi.map_size[1]); float cur[2]; ALLEGRO_COLOR colors[] = { al_map_rgb( 0, 0, 0), /* x */ al_map_rgb( 0,200, 0), /* p */ al_map_rgb( 0,150, 0), /* r */ al_map_rgb( 0,100, 0), /* a */ al_map_rgb( 0, 50, 0), /* s */ }; al_clear_to_color(al_map_rgb(0,0,0)); /* tiles */ for (i=0; i<G.gi.map_size[0]; i++) { for (j=0; j<G.gi.map_size[1]; j++) { int map_index = i + j * G.gi.map_size[1]; al_draw_filled_rectangle(scale*i, scale*j, scale*(i + 1), scale*(j + 1), colors[G.gi.mapv[map_index]]); } } /* prizes */ for (i=0; i<G.gi.num_prizes_orig; i++) { float x = G.gi.prizes[i][0] + 0.5; float y = G.gi.prizes[i][1] + 0.5; char buff[255]; if (!G.gi.prizes_visited[i]) al_draw_filled_triangle(scale*(x), scale*(y-0.3), scale*(x+0.3), scale*(y+0.3), scale*(x-0.3), scale*(y+0.3), al_map_rgb(255, 255, 0)); else al_draw_triangle(scale*(x), scale*(y-0.3), scale*(x+0.3), scale*(y+0.3), scale*(x-0.3), scale*(y+0.3), al_map_rgb(255, 255, 0), 1.0); sprintf(buff, "%d", i+1); al_draw_text(G.font, al_map_rgb(0,0,0), scale*x, scale*(y-0.1), ALLEGRO_ALIGN_CENTRE, buff); } /* start */ al_draw_filled_circle((float)scale * (G.gi.start[0]+0.5), (float)scale * (G.gi.start[1]+0.5), scale/3, al_map_rgb(0, 255, 0)); /* end */ al_draw_filled_circle((float)scale * (G.gi.end[0]+0.5), (float)scale * (G.gi.end[1]+0.5), scale/3, al_map_rgb(255, 0, 0)); if (step == MOVE_FRAMES-1) { last[0] = G.gi.cur[0]; last[1] = G.gi.cur[1]; } cur[0] = last[0] + (step * ((float)G.gi.cur[0]-last[0]))/MOVE_FRAMES; cur[1] = last[1] + (step * ((float)G.gi.cur[1]-last[1]))/MOVE_FRAMES; /* player */ al_draw_filled_circle((float)scale * (cur[0]+0.5), (float)scale * (cur[1]+0.5), scale/3, al_map_rgb(0, 0, 255)); al_flip_display(); }
int main(int argc, char **argv) { ALLEGRO_DISPLAY *display = NULL; ALLEGRO_EVENT_QUEUE *event_queue = NULL; ALLEGRO_TIMER *timer = NULL; ALLEGRO_BITMAP *buffer = NULL; bool key[5] = { false, false, false, false, false }; bool redraw = true; bool doexit = false; 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; } if (!al_init_primitives_addon()) { fprintf(stderr, "failed to initialize the primitives library!\n"); } 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; } al_init_image_addon(); // Next, initiale the buffer buffer = al_create_bitmap(SCREEN_W, SCREEN_H); 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_bitmap(bouncer); 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()); // This is our rootnode. const struct rectangle dimensions( { 0.0f, 0.0, 2048.0f, 2048.0f }); World rootNode(dimensions); Player player; Image background("http://force.mjay.me/farthestbackground.png", 10.0f); Image aNotherButAbitCloser("http://force.mjay.me/alittbitcloser.png", 1.0f); InpenetrableBlock p(point( { 200.0f, 200.0f })); InpenetrableBlock p1(point( { 250.0f, 300.0f })); InpenetrableBlock p2(point( { 350.0f, 150.0f })); rootNode.AddNode(background); background.AddNode(aNotherButAbitCloser); aNotherButAbitCloser.AddNode(p); p.AddNode(p1); p1.AddNode(p2); al_flip_display(); al_start_timer(timer); while (!doexit) { ALLEGRO_EVENT ev; al_wait_for_event(event_queue, &ev); /** * The allegro event timer. This timer, * fires each 1/fps. */ if (ev.type == ALLEGRO_EVENT_TIMER) { // This is our force window. struct point vector( { 0.0f, 0.0f }); float multiplier = 1.0f; if (key[KEY_SHIFT]) { multiplier = 2.0f; } if (key[KEY_UP]) { vector.y = -4.5f * multiplier; } if (key[KEY_DOWN]) { vector.y = 4.5f * multiplier; } if (key[KEY_LEFT]) { vector.x = -4.5f * multiplier; } if (key[KEY_RIGHT]) { vector.x = 4.5f * multiplier; } // do not copy this, reference it, RAII. rootNode.Process(vector, player); // Once, all forces have been calculated, do the // actual move player.Update(); redraw = true; } else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { break; // Theese guys, transfer events into main event loop, async. } else if (ev.type == ALLEGRO_EVENT_KEY_DOWN) { switch (ev.keyboard.keycode) { case ALLEGRO_KEY_UP: key[KEY_UP] = true; break; case ALLEGRO_KEY_DOWN: key[KEY_DOWN] = true; break; case ALLEGRO_KEY_LEFT: key[KEY_LEFT] = true; break; case ALLEGRO_KEY_RIGHT: key[KEY_RIGHT] = true; break; case ALLEGRO_KEY_LSHIFT: key[KEY_SHIFT] = true; break; } } else if (ev.type == ALLEGRO_EVENT_KEY_UP) { switch (ev.keyboard.keycode) { case ALLEGRO_KEY_UP: key[KEY_UP] = false; break; case ALLEGRO_KEY_DOWN: key[KEY_DOWN] = false; break; case ALLEGRO_KEY_LEFT: key[KEY_LEFT] = false; break; case ALLEGRO_KEY_RIGHT: key[KEY_RIGHT] = false; break; case ALLEGRO_KEY_ESCAPE: doexit = true; break; case ALLEGRO_KEY_LSHIFT: key[KEY_SHIFT] = false; break; } } if (redraw && al_is_event_queue_empty(event_queue)) { redraw = false; // Allways, use the buffer, to draw on. Clear it, and draw it scaled onto the display. al_set_target_bitmap(buffer); al_clear_to_color(al_map_rgb(0, 0, 0)); // This is our sliding window. const struct rectangle playerCoordinates = player.GetDimensions(); struct rectangle window( { playerCoordinates.x, playerCoordinates.y, SCREEN_W, SCREEN_H }); // Draw all scene-components, according to the window. rootNode.Draw(window); struct rectangle pcwindow( { playerCoordinates.x - SCREEN_W / 2, playerCoordinates.y - SCREEN_H / 2, SCREEN_W, SCREEN_H }); player.Draw(pcwindow); // Next, draw the buffer onto the display (scaling or not). al_set_target_bitmap(al_get_backbuffer(display)); al_clear_to_color(al_map_rgb(0, 0, 0)); al_draw_bitmap(buffer, 0, 0, 0); //al_draw_scaled_bitmap(buffer, 0,0, SCREEN_W, SCREEN_H, 1.0, 1.0, 1.0, 1.0, 0); al_flip_display(); } } //al_destroy_bitmap(bouncer); al_destroy_timer(timer); al_destroy_display(display); al_destroy_event_queue(event_queue); return 0; }
int main(){ int SCREEN_W = 400; int SCREEN_H = 400; ALLEGRO_DISPLAY *display = NULL; if(!al_init()) { fprintf(stderr, "failed to initialize allegro!\n"); return 0; } display = al_create_display(SCREEN_W, SCREEN_H); if(!display) { fprintf(stderr, "failed to create display!\n"); return 0; } if(!al_install_keyboard()) { fprintf(stderr, "failed to initialize the keyboard!\n"); return 0; } ALLEGRO_COLOR negro = al_map_rgb(0,0,0); ALLEGRO_COLOR rojo = al_map_rgb(255,0,0); ALLEGRO_COLOR azul = al_map_rgb(0,0,255); al_clear_to_color(negro); al_flip_display(); int i,j,n,nl; scanf("%d",&n);//cantidad de puntos. nl = n*(n-1)/2;//cantidad de lineas. _linea * l = (_linea *)malloc(sizeof(_linea)*nl); int puntos[n][2];//matriz para almacenar los puntos. for(i=0;i<n;i++){ scanf("%d",&puntos[i][0]); scanf("%d",&puntos[i][1]); al_draw_circle(puntos[i][0],SCREEN_H - puntos[i][1], 1, rojo,2);//dibujo de los puntos en la pantalla. al_flip_display(); } ALLEGRO_EVENT_QUEUE *queue = NULL; queue = al_create_event_queue(); if(!queue) { return 0; } ALLEGRO_EVENT event; al_register_event_source(queue, al_get_keyboard_event_source()); do{ al_wait_for_event(queue, &event); } while (event.type != ALLEGRO_EVENT_KEY_DOWN); //espera para que el usuario aprete una tecla para que el programa siga. int a=0; for(i=0;i<n;i++){ //creación de todas las lineas. for(j=i+1;j<n;j++){ l[a].x0=puntos[i][0]; l[a].y0=puntos[i][1]; l[a].x1=puntos[j][0]; l[a].y1=puntos[j][1]; a++; } } quicksort(l,0,nl-1); // ordenamiento de las lineas para que queden primero las con menor longitud. _linea *sol = (_linea *)malloc(sizeof(_linea)*nl); // conjunto de líneas que forman la solución. int sol_size = 0; for (i=0;i<nl;i++){ //comprobar si cada linea existente se intersecta con las lineas que pertenecen a la solución int flag=1; for(j=0;j<sol_size;j++){ if(inter(l[i],sol[j])==1){ flag=0; j=sol_size; } } if(flag==1){ // si no se intersecta con ninguna linea que sea parte de la solución se guarda como parte de la solución sol[sol_size]=l[i]; al_draw_line(sol[sol_size].x0,SCREEN_H-sol[sol_size].y0, sol[sol_size].x1,SCREEN_H-sol[sol_size].y1, azul, 1); al_flip_display(); sol_size++; } } al_rest(3); al_destroy_display(display); return 0; }
int main() { al_init(); // Start Allegro ALLEGRO_DISPLAY *screen = NULL; // Main display ALLEGRO_EVENT_QUEUE *event_queue = NULL; // Event queue to maintain events ALLEGRO_TIMER *timer = NULL; // Timer to control game fps ALLEGRO_FONT *fontA = NULL; // Initializing screen, event queue and timer screen = al_create_display(SCREEN_W, SCREEN_H); event_queue = al_create_event_queue(); timer = al_create_timer(1.0 / FPS); // Timer set to tick at 60 frames per second al_init_image_addon(); // Initialize Allegro image addon al_install_keyboard(); // Initialize Allegro keyboard al_start_timer(timer); // Start timer al_init_font_addon(); al_init_ttf_addon(); // Register event sources to be handled in the event queue al_register_event_source(event_queue, al_get_display_event_source(screen)); al_register_event_source(event_queue, al_get_timer_event_source(timer)); al_register_event_source(event_queue, al_get_keyboard_event_source()); fontA = al_load_font("arial.ttf", 18, 0); GameManager gameManager; // Object creation gameManager.level1(); // Function call //Main game loop while (!keyboard[KEY_ESCAPE]) // Run while escape key is not pressed { ALLEGRO_EVENT event; // ALLEGRO_EVENT to hold events al_wait_for_event(event_queue, &event); // Wait for events to occur // Display handler // Draw if timer counter has incremented and there are no events to handle // and event queue is empty if (event.type == ALLEGRO_EVENT_TIMER && al_is_event_queue_empty(event_queue)) { gameManager.DrawLevel(screen); al_flip_display(); // Display backbuffer on to the main screen al_clear_to_color(al_map_rgb(255, 0, 255)); // Clear display to black } //Event handlers if (event.type == ALLEGRO_EVENT_TIMER) { gameManager.UpdateLogic(); // Function call } else if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { break; // End game loop on closing display window } else if (event.type == ALLEGRO_EVENT_KEY_DOWN) { gameManager.KeyboardEventUpdate(event, true); // Update routine on key press } else if (event.type == ALLEGRO_EVENT_KEY_UP) { gameManager.KeyboardEventUpdate(event, false); // Update routine on key release } al_draw_textf(fontA, al_map_rgb(238, 105, 29), SCREEN_W / 2, SCREEN_H / 2, ALLEGRO_ALIGN_CENTRE, "GAME OVER Final score %i", score); } // End of Game Loop al_destroy_display(screen); // Destroy display return 0; }
void level_draw() { al_clear_to_color(al_map_rgb(255,255,255)); float weight; if (game.height <= 180) { weight = 1; } else { weight = round(game.height/180.0); } //inversa do tamanho do mapa, pra usar como porcentagem double scaleX = 1.0/mapWidth; double scaleY = 1.0/mapHeight; int t; for (int y = 0; y < mapHeight; y++) { for (int x = 0; x < mapWidth; x++) { t = tilemap[y*mapWidth+x]; if (t == 0) { al_draw_filled_rectangle(px(x*scaleX),py(y*scaleY),px((x+1)*scaleX),py((y+1)*scaleY),al_map_rgb(51,51,51)); } else if (t == 1) { al_draw_filled_rectangle(px(x*scaleX),py(y*scaleY),px((x+1)*scaleX),py((y+1)*scaleY),al_map_rgb(204,51,51)); } else if (t == 2) { al_draw_filled_rectangle(px(x*scaleX),py(y*scaleY),px((x+1)*scaleX),py((y+1)*scaleY),al_map_rgb(51,204,51)); } } } //posição do ponto 0 do gráfico double offsetX = scaleX*(baseX+1); double offsetY = scaleY*(baseY+1+lerp(zeroHeight,zeroHeightPrev,easeIn(zeroHeightTempo))); //desenha os eixos BLENDALPHA(); ALLEGRO_COLOR axisColor = al_map_rgba(255,255,255,51); al_draw_line(px(offsetX),py(0),px(offsetX),py(1),axisColor,weight); double gridPos; int gridOffset; if (functionDir > 0) { al_draw_line(px(offsetX),py(offsetY),px(1),py(offsetY),axisColor,weight); gridOffset = 1; while (1) { gridPos = gridOffset*scaleX+offsetX; if (gridPos > 1) break; gridPos = px(gridPos); al_draw_line(gridPos,py(offsetY-scaleY*.125),gridPos,py(offsetY+scaleY*.125),axisColor,weight); gridOffset++; } } else { al_draw_line(px(0),py(offsetY),px(offsetX),py(offsetY),axisColor,weight); gridOffset = floor(-offsetX/scaleX); while (1) { gridPos = gridOffset*scaleX+offsetX; if (gridOffset >= 0 || gridPos > 1) break; gridPos = px(gridPos); al_draw_line(gridPos,py(offsetY-scaleY*.125),gridPos,py(offsetY+scaleY*.125),axisColor,weight); gridOffset++; } } gridOffset = floor(-offsetY/scaleY); while (1) { if (gridOffset == 0) { gridOffset++; continue; } gridPos = gridOffset*scaleY+offsetY; if (gridPos > 1) break; gridPos = py(gridPos); al_draw_line(px(offsetX-scaleX*.125),gridPos,px(offsetX+scaleX*.125),gridPos,axisColor,weight); gridOffset++; } BLENDDEFAULT(); //plota a função if (weightTempo > 0 && cacheCount > 0) { float t = easeIn(plotTempo); float w = easeOut(weightTempo); ALLEGRO_COLOR plotColor = al_map_rgba(255,255,255,w*255); w = ceil(w*weight); double x,xa; BLENDALPHA(); if (functionDir > 0) { for (x = dottedTempo*.25-.125; x < functionEnd; x += .25) { xa = (x < 0)?0:x; al_draw_line( dx(offsetX+xa*scaleX),dy(offsetY-getValueOnCacheLerp(xa,t)*scaleY), dx(offsetX+(x+.125)*scaleX),dy(offsetY-getValueOnCacheLerp(x+.125,t)*scaleY), plotColor,w ); } } else { for (x = -dottedTempo*.25+.125; x > functionStart; x -= .25) { xa = (x > 0)?0:x; al_draw_line( dx(offsetX+xa*scaleX),dy(offsetY-getValueOnCacheLerp(xa,t)*scaleY), dx(offsetX+(x-.125)*scaleX),dy(offsetY-getValueOnCacheLerp(x-.125,t)*scaleY), plotColor,w ); } } BLENDDEFAULT(); } //textbox float textboxHeight = textboxPos?.8:0; BLENDALPHA(); if (input.captureText) { al_draw_filled_rectangle(px(0),py(textboxHeight),px(1),py(.2+textboxHeight),al_map_rgba(255,255,255,204)); } else { al_draw_filled_rectangle(px(0),py(textboxHeight),px(1),py(.2+textboxHeight),al_map_rgba(255,255,255,153)); } BLENDDEFAULT(); int textboxOffsetX = px(.04); int textboxOffsetY = py(.03+textboxHeight); int selOffset; for (int a = 0; 1; a++) { if (input.captureText) { if (input.captureText && a == input.caretPos && input.caretBlink < .5f) { al_draw_line( textboxOffsetX, textboxOffsetY, textboxOffsetX, textboxOffsetY+al_get_font_line_height(data.font_UbuntuB), al_map_rgb(255,255,255),1 ); } if (input.selectionStart != -1 && input.selectionEnd == a) { BLENDALPHA(); al_draw_filled_rectangle( selOffset, textboxOffsetY, textboxOffsetX, textboxOffsetY+al_get_font_line_height(data.font_UbuntuB), al_map_rgba(51,51,51,51) ); BLENDDEFAULT(); } } if (input.text[a] == '\0') break; if (input.selectionStart == a) { selOffset = textboxOffsetX; } textboxChar[0] = input.text[a]; al_draw_text(data.font_UbuntuB,al_map_rgb(51,51,51),textboxOffsetX,textboxOffsetY,ALLEGRO_ALIGN_LEFT,textboxChar); textboxOffsetX += al_get_text_width(data.font_UbuntuB,textboxChar); } if (errorMsgShow) { al_draw_filled_triangle( px(.0135),py(.1797+textboxHeight), px(.0415),py(.1797+textboxHeight), px(.0275),py(.125+textboxHeight), al_map_rgb(255,204,15) ); al_draw_text(data.font_UbuntuR,al_map_rgb(51,51,51),px(.0275),py(.127+textboxHeight),ALLEGRO_ALIGN_CENTRE,"!"); al_draw_text(data.font_UbuntuR,al_map_rgb(51,51,51),px(.05),py(.125+textboxHeight),ALLEGRO_ALIGN_LEFT,MensagemDoErro[errorMsg]); } if (input.captureText) { al_draw_text(data.font_UbuntuB,al_map_rgb(51,51,51),px(.01),textboxOffsetY,ALLEGRO_ALIGN_LEFT,">"); al_draw_text(data.font_UbuntuR,al_map_rgb(51,51,51),px(.99),py(.125+textboxHeight),ALLEGRO_ALIGN_RIGHT,"tab: inverter - enter: fechar"); } else { al_draw_text(data.font_UbuntuB,al_map_rgb(102,102,102),px(.01),textboxOffsetY,ALLEGRO_ALIGN_LEFT,">"); al_draw_text(data.font_UbuntuR,al_map_rgb(51,51,51),px(.99),py(.125+textboxHeight),ALLEGRO_ALIGN_RIGHT,"backspace: voltar - tab: inverter - enter: abrir"); } }
int demo_initialize(int argc, char * argv[]) { if(!t3f_initialize(640, 480, 60.0, "Paintball Party 2 Tech Demo 2", demo_logic, demo_render, T3F_DEFAULT | T3F_USE_MOUSE | T3F_USE_JOYSTICK)) { return 0; } demo_font = al_load_bitmap_font("demo_font.png"); if(!demo_font) { printf("Failed to load font!\n"); return 0; } t3f_3d_set_projection(&demo_camera.projection, 1.0, 1.0, 320.0, 240.0, 640, 640); t3f_3d_select_projection(&demo_camera.projection); demo_camera.x = 0.0; demo_camera.y = 0.0; demo_camera.z = 0.0; demo_camera.vx = 0; demo_camera.vy = 0; demo_camera.vw = al_get_display_width() / 2; demo_camera.vh = al_get_display_height() / 2; demo_camera.flags = 0; t3f_3d_set_projection(&demo_camera.projection, 0.5, 0.5, 320.0, 240.0, 640, 640); t3f_3d_select_projection(&demo_camera.projection); demo_tileset = t3f_load_tileset("export.ots"); if(!demo_tileset) { return 0; } demo_tilemap = t3f_load_tilemap("export.otm"); if(!demo_tilemap) { return 0; } demo_tilemap->tileset = demo_tileset; demo_collision_tilemap = t3f_load_collision_tilemap("export.ocm"); if(!demo_collision_tilemap) { return 0; } sprite_ani[DEMO_SPRITE_STATE_STAND_RIGHT] = load_animation("mario_sr.ani"); sprite_ani[DEMO_SPRITE_STATE_WALK_RIGHT] = load_animation("mario_wr.ani"); sprite_ani[DEMO_SPRITE_STATE_JUMP_RIGHT] = load_animation("mario_jr.ani"); sprite_ani[DEMO_SPRITE_STATE_FALL_RIGHT] = load_animation("mario_fr.ani"); sprite_ani[DEMO_SPRITE_STATE_DUCK_RIGHT] = load_animation("mario_dr.ani"); sprite_ani[DEMO_SPRITE_STATE_STAND_LEFT] = load_animation("mario_sl.ani"); sprite_ani[DEMO_SPRITE_STATE_WALK_LEFT] = load_animation("mario_wl.ani"); sprite_ani[DEMO_SPRITE_STATE_JUMP_LEFT] = load_animation("mario_jl.ani"); sprite_ani[DEMO_SPRITE_STATE_FALL_LEFT] = load_animation("mario_fl.ani"); sprite_ani[DEMO_SPRITE_STATE_DUCK_LEFT] = load_animation("mario_dl.ani"); if(!sprite_ani) { return 0; } platform_ani = load_animation("platform.ani"); if(!sprite_ani) { return 0; } platform.angle = 0.0; platform.x = 320 + cos(platform.angle) * 48.0; platform.y = 240 + sin(platform.angle) * 48.0; platform.cp = t3f_create_collision_object(0, 0, al_get_bitmap_width(platform_ani->bitmap[0]) * 2, al_get_bitmap_height(platform_ani->bitmap[0]) * 2, 32, 32, 0); platform.sticky = NULL; /* player.x = 0.0; player.y = 0.0; player.cp = t3f_create_collision_object(0, 0, 32, 32, 32, 32, 0); player.sticky = NULL; player.floor = 0; */ player.cp = t3f_create_collision_object(5, 0, 22, 56, 32, 32, 0); player.x = 64.0; player.y = 64.0; player.vx = 0.0; player.vy = 0.0; player.sticky = NULL; player.floor = false; player.state = DEMO_SPRITE_STATE_STAND_RIGHT; player.frame = 0; controller = t3f_create_controller(4); if(!controller) { return 0; } al_clear_to_color(al_map_rgb(255, 0, 0)); al_flip_display(); t3f_bind_controller(controller, DEMO_CONTROLLER_UP); al_clear_to_color(al_map_rgb(0, 255, 0)); al_flip_display(); t3f_bind_controller(controller, DEMO_CONTROLLER_DOWN); al_clear_to_color(al_map_rgb(0, 0, 255)); al_flip_display(); t3f_bind_controller(controller, DEMO_CONTROLLER_LEFT); al_clear_to_color(al_map_rgb(0, 0, 0)); al_flip_display(); t3f_bind_controller(controller, DEMO_CONTROLLER_RIGHT); return 1; }
int main(int argc, char **argv ) { //inits al_init(); al_init_ttf_addon(); al_install_keyboard(); al_install_mouse(); al_install_audio(); al_init_acodec_addon(); al_init_primitives_addon(); al_reserve_samples(1000); al_init_image_addon(); ALLEGRO_KEYBOARD_STATE key; ALLEGRO_MOUSE_STATE mouse; ALLEGRO_DISPLAY *display; al_set_new_display_flags(ALLEGRO_WINDOWED); display = al_create_display(1024, 768); al_hide_mouse_cursor(display); // ALLEGRO_EVENT_QUEUE *event_queue = NULL; ALLEGRO_TIMER *timer = NULL; bool redraw = true; timer = al_create_timer(1.0/fps); event_queue = al_create_event_queue(); //SAMPLES ///OBJECTS cPlayer oPlayer; oPlayer.create(); cLevel oLevel; oLevel.init(); //// al_clear_to_color(al_map_rgb(0,0,0)); al_flip_display(); 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); al_reserve_samples(1000); //RUN while(1<2) { ALLEGRO_EVENT ev; al_wait_for_event(event_queue, &ev); al_get_keyboard_state(&key); al_get_mouse_state(&mouse); al_get_mouse_state_axis(&mouse,0); al_get_mouse_state_axis(&mouse,1); if(ev.type == ALLEGRO_EVENT_TIMER) { //Runny tunny { oLevel.createLevel(); oPlayer.run(&key); //player collision check for(int i = 0;i<oLevel.blocknum;i++) { oPlayer.checkCollision(oLevel.oBlock[i].x,oLevel.oBlock[i].y,&key); } if(al_key_down(&key,ALLEGRO_KEY_ESCAPE)) { return 0; } } redraw = true; } else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { break; } if(redraw && al_is_event_queue_empty(event_queue)) { //draw al_clear_to_color(al_map_rgb(0,0,0)); oPlayer.draw(); oLevel.draw(); ////// redraw = false; // al_flip_display(); } } return 0; };
void Window::cls() { activate(); al_clear_to_color(mBackgroundColor); }