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);
}
