int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *displays[2];
ALLEGRO_MONITOR_INFO *info;
int adapter_count;
int x, y;
ALLEGRO_FONT *myfont;
ALLEGRO_EVENT_QUEUE *events;
ALLEGRO_EVENT event;
int i;
(void)argc;
(void)argv;
srand(time(NULL));
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_install_mouse();
al_init_font_addon();
al_init_image_addon();
adapter_count = al_get_num_video_adapters();
info = malloc(adapter_count * sizeof(ALLEGRO_MONITOR_INFO));
for (i = 0; i < adapter_count; i++) {
al_get_monitor_info(i, &info[i]);
}
x = ((info[0].x2 - info[0].x1) / 3) - (W / 2);
y = ((info[0].y2 - info[0].y1) / 2) - (H / 2);
al_set_new_window_position(x, y);
displays[0] = al_create_display(W, H);
x *= 2;
al_set_new_window_position(x, y);
displays[1] = al_create_display(W, H);
if (!displays[0] || !displays[1]) {
abort_example("Could not create displays.\n");
}
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
myfont = al_load_font("data/fixed_font.tga", 0, 0);
if (!myfont) {
abort_example("Could not load font.\n");
}
events = al_create_event_queue();
al_register_event_source(events, al_get_mouse_event_source());
al_register_event_source(events, al_get_display_event_source(displays[0]));
al_register_event_source(events, al_get_display_event_source(displays[1]));
for (;;) {
for (i = 0; i < 2; i++) {
al_set_target_backbuffer(displays[i]);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
if (i == 0)
al_clear_to_color(al_map_rgb(255, 0, 255));
else
al_clear_to_color(al_map_rgb(155, 255, 0));
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
al_draw_textf(myfont, al_map_rgb(0, 0, 0), 50, 50, ALLEGRO_ALIGN_CENTRE, "Click me..");
al_flip_display();
}
if (al_wait_for_event_timed(events, &event, 1)) {
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
else if (event.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) {
int a = rand() % adapter_count;
int w = info[a].x2 - info[a].x1;
int h = info[a].y2 - info[a].y1;
int margin = 20;
x = margin + info[a].x1 + (rand() % (w - W - margin));
y = margin + info[a].y1 + (rand() % (h - H - margin));
al_set_window_position(event.mouse.display, x, y);
}
}
}
al_destroy_event_queue(events);
al_destroy_display(displays[0]);
al_destroy_display(displays[1]);
free(info);
return 0;
}
void gdp_selchar(){
// Carregando o arquivo de fonte
ALLEGRO_FONT *fonte = al_load_font(".//Fonts//font_menu.ttf", 100, 0);
ALLEGRO_BITMAP *image = al_load_bitmap(".//Images//select.png");
ALLEGRO_SAMPLE *musicsel= al_load_sample(".//Songs//Menu//musicsel.ogg");
ALLEGRO_SAMPLE *musicconfirm= al_load_sample(".//Songs//Menu//musicconfirm.ogg");
int options = 4,i;
char **texto = calloc(options,sizeof(char*));
texto[0] = "James";
texto[1] = "Julios";
texto[2] = "Japa";
texto[3] = "Gauss";
char *confirm = ">";
int nopcao = 0,nposicao = 120,nitensmenu = 3,nespaco = 80;
while(true){
al_wait_for_event(event_queue, &evento);
if(gdp_readclose()){
break;
}
if(evento.type == ALLEGRO_EVENT_KEY_DOWN){
if(evento.keyboard.keycode == ALLEGRO_KEY_DOWN){
al_play_sample(musicsel, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, NULL);
nopcao++;
}
if(evento.keyboard.keycode == ALLEGRO_KEY_UP){
al_play_sample(musicsel, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, NULL);
nopcao--;
}
if(evento.keyboard.keycode == ALLEGRO_KEY_ENTER){
al_play_sample(musicconfirm, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, NULL);
al_rest(1.0);
opchar = nopcao;
break;
}
}
if(nopcao>nitensmenu)
nopcao = nitensmenu;
if(nopcao<=0)
nopcao = 0;
if(gdp_readtime() && al_is_event_queue_empty(event_queue)){
gdp_clear();
// imagem de fundo
al_draw_scaled_bitmap(image,
0, 0,
al_get_bitmap_width(image),
al_get_bitmap_height(image),
0,
0,
wigth,
height,
0
);
// menu
for(i=0;i<options;i++)
al_draw_textf(fonte, al_map_rgb(0, 0, 0), wigth / 2, nposicao+nespaco*i, ALLEGRO_ALIGN_CENTRE, "%s", texto[i]);
// selecao
al_draw_textf(fonte, al_map_rgb(0, 0, 0), (wigth / 2)-230, nposicao+nopcao*nespaco, ALLEGRO_ALIGN_LEFT, "%s", confirm);
al_flip_display();
}
}
free(texto);
al_destroy_sample(musicsel);
al_destroy_sample(musicconfirm);
al_destroy_bitmap(image);
al_destroy_font(fonte);
opchar++;
}
int main(int argc, char *argv[])
{
if(!al_init())
{
fprintf(stderr, "Failed to initialize allegro!\n");
return -1;
}
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
bool redraw = true;
timer = al_create_timer(1.0 / FPS);
if(!timer)
{
fprintf(stderr, "failed to create the timer.\n");
return -1;
}
display = al_create_display(1024, 768);
if(!display)
{
fprintf(stderr, "Failed to create the display.\n");
al_destroy_timer(timer);
return -1;
}
event_queue = al_create_event_queue();
if(!event_queue)
{
fprintf(stderr, "failed to create event queue.\n");
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
al_start_timer(timer);
while(true)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_TIMER)
redraw = true;
else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
fprintf(stderr, "display closed\n");
break;
}
if(redraw && al_is_event_queue_empty(event_queue))
{
redraw = false;
al_clear_to_color(al_map_rgb(99, 99, 99));
al_flip_display();
}
}
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
return 0;
}
void outputArray (pixel **array, int altura, int largura, int indice, int player_x, int player_x2, int player_y, int player_y2, int tamPixel) {
ALLEGRO_COLOR terra = al_map_rgb(110, 60, 40); /* Cores */
ALLEGRO_COLOR agua = al_map_rgb(51, 153, 255);
ALLEGRO_COLOR ilha = al_map_rgb(6, 96, 0);
ALLEGRO_COLOR canoa = al_map_rgb(51, 51, 51);
int i, j;
int ilha0 = 999999, ilhaf = 0; /* Variáveis que guardam o começo de uma ilha e o final dela */
int playerSize = tamPixel + largura*0.1;
if(playerSize > 30) playerSize = 30;
al_clear_to_color(agua);
for (i = 0; i < altura; i ++) { /* Imprime uma linha de cada vez */
int TMargemEsquerda = margemEsquerda(array[(i+indice)%altura]); /* Os tamanhos das margens */
int TMargemDireita = margemDireita(array[(i+indice)%altura], largura);
/* Desenha a margem esquerda */
al_draw_filled_rectangle(0, tamPixel*i, tamPixel*(TMargemEsquerda - 2), tamPixel*(i+1), terra);
j = TMargemEsquerda - 2;
/* Desenha o encontro da terra com a água, criando triângulos ou retângulos conforme necessário */
if (tipo(&array[(i+indice+1)%altura][j+2]) == TERRA) { /* Se a linha de baixo era maior */
al_draw_filled_rectangle(tamPixel*j, tamPixel*i, tamPixel*(j+1), tamPixel*(i+1), terra);
j++;
al_draw_filled_triangle(tamPixel*j, tamPixel*i, tamPixel*j, tamPixel*(i+1), tamPixel*(j+1), tamPixel*(i+1), terra);
}
else if (tipo(&array[(i+indice+1)%altura][j+1]) == TERRA) { /* Se era igual */
al_draw_filled_rectangle(tamPixel*j, tamPixel*i, tamPixel*(j+1), tamPixel*(i+1), terra);
j++;
}
else { /* Se era menor */
al_draw_filled_triangle(tamPixel*j, tamPixel*i, tamPixel*(j+1), tamPixel*i, tamPixel*j, tamPixel*(i+1), terra);
j++;
}
/* Descobre onde começa e termina a ilha */
for (j = TMargemEsquerda; j < largura - TMargemDireita - 2; j++)
if (tipo(&array[(i+indice)%altura][j]) == TERRA) {
if (j < ilha0)
ilha0 = j;
if (j > ilhaf)
ilhaf = j;
}
if (ilhaf != 0) /* Se existe uma ilha, desenha primeiro as duas partes de água, depois ela em cima */
al_draw_filled_rounded_rectangle(tamPixel*ilha0,tamPixel*i,tamPixel*(ilhaf+1),tamPixel*(i+1),3,3, ilha);
ilha0 = 999999; /* Reseta os valores */
ilhaf = 0;
/* Desenha o segundo encontro da água com a terra */
if (tipo(&array[(i+indice+1)%altura][j+2]) == AGUA) {
j++;
al_draw_filled_triangle(tamPixel*j, tamPixel*i, tamPixel*(j+1), tamPixel*i, tamPixel*(j+1), tamPixel*(i+1), terra);
}
else if (tipo(&array[(i+indice+1)%altura][j+1]) == AGUA) {
j++;
al_draw_filled_rectangle(tamPixel*j, tamPixel*i, tamPixel*(j+1), tamPixel*(i+1), terra);
}
else {
al_draw_filled_triangle(tamPixel*(j+1), tamPixel*(i+1), tamPixel*(j+1), tamPixel*i, tamPixel*j, tamPixel*(i+1), terra);
j++;
al_draw_filled_rectangle(tamPixel*j, tamPixel*i, tamPixel*(j+1), tamPixel*(i+1), terra);
}
/* Desenha a margem direita */
al_draw_filled_rectangle(tamPixel*(largura - TMargemDireita), tamPixel*i, tamPixel*(largura), tamPixel*(i+1), terra);
}
/* Desenha o jogador na posição correta */
/*al_draw_filled_ellipse(player_x, player_y, playerSize/3, playerSize, canoa);*/
al_draw_line(player_x, player_y, player_x2, player_y2, canoa, 5.0);
/* Coloca tudo o que foi desenhado na tela */
al_flip_display();
}
int
main(void)
{
asteroids.lives = START_LIVES;
asteroids.display = NULL;
asteroids.timer = NULL;
asteroids.event_queue = NULL;
SHIP *ship;
bool redraw = true;
bool quit = false;
bool key[7] = { false };
seed_rand();
atexit(shutdown);
if(!init())
exit(EXIT_FAILURE);
if((asteroids.high_score = get_config_value("high_score")) == NULL)
asteroids.high_score = "0";
asteroids.level = level_create(0, 0);
if(!(ship = ship_create()))
exit(EXIT_FAILURE);
al_flip_display();
al_start_timer(asteroids.timer);
while(!quit) {
ALLEGRO_EVENT ev;
al_wait_for_event(asteroids.event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_TIMER) {
/* start game */
if(asteroids.level->number == 0 && key[KEY_S]) {
start();
continue;
}
/* are we out of asteroids to destroy? */
if(list_length(asteroids.level->asteroids) == 0)
asteroids.level = level_next(asteroids.level);
/* update objects */
ship = ship_update(ship, key, asteroids.timer);
explosions_update();
asteroids.level = level_update(asteroids.level, ship, key, asteroids.timer);
/* ship->asteroid collisions. */
check_ship_asteroid_collisions(ship, asteroids.level->asteroids);
/* ship[missile] -> asteroid collisions. */
check_ship_missile_asteroid_collisions(asteroids.level, ship);
/* ship[missile] -> saucer collisions. */
check_ship_missile_saucer_collisions(asteroids.level, ship);
/* saucer[missile] -> ship collisions. */
check_saucer_missile_ship_collisions(asteroids.level, ship);
/* saucer[missile] -> asteroid collisions. */
check_saucer_missile_asteroids_collisions(asteroids.level);
/* saucer->asteroid collisions. */
check_saucer_asteroid_collisions(asteroids.level);
redraw = true;
} else if(ev.type == ALLEGRO_EVENT_KEY_DOWN) {
keydown(ev, key);
quit = key[KEY_ESCAPE];
} else if(ev.type == ALLEGRO_EVENT_KEY_UP) {
keyup(ev, key);
ship->fire_debounce = key[KEY_SPACE];
ship->hyper_debounce = key[KEY_LCONTROL];
}
if(redraw && al_is_event_queue_empty(asteroids.event_queue)) {
redraw = false;
al_clear_to_color(al_map_rgb(BLACK));
level_draw(asteroids.level);
draw_lives();
draw_high_score();
animation_draw_list(asteroids.explosions);
if(asteroids.level->number == 0) {
draw_home();
al_flip_display();
continue;
}
if(asteroids.lives > 0) {
ship_draw(ship, key[KEY_UP]);
missile_draw_list(ship->missiles);
} else {
if(ship->explosion)
ship_draw(ship, false);
draw_gameover();
}
al_flip_display();
}
};
/* FIXME: cleanup */
if(asteroids.timer != NULL)
al_destroy_timer(asteroids.timer);
if(asteroids.event_queue != NULL)
al_destroy_event_queue(asteroids.event_queue);
if(asteroids.display != NULL)
al_destroy_display(asteroids.display);
LIST *head = list_first(asteroids.level->asteroids);
while(head != NULL) {
ASTEROID *rock = (ASTEROID *) head->data;
asteroid_free(rock);
head = head->next;
}
ship_free(ship);
al_destroy_bitmap(asteroids.lives_sprite);
ship_shutdown();
missile_shutdown();
asteroid_shutdown();
explosion_shutdown();
al_uninstall_keyboard();
exit(EXIT_SUCCESS);
}
int main(void)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_TIMER *timer;
ALLEGRO_EVENT_QUEUE *queue;
int redraw = 0, i;
bool quit = false;
if (!al_init()) {
abort_example("Could not initialise Allegro\n");
return 1;
}
al_init_primitives_addon();
al_install_mouse();
al_init_image_addon();
al_init_font_addon();
al_init_ttf_addon();
srand(time(NULL));
white = al_map_rgba_f(1, 1, 1, 1);
display = al_create_display(640, 480);
if (!display) {
abort_example("Could not create display\n");
return 1;
}
al_set_window_title(display, "Allegro Logo Generator");
al_install_keyboard();
/* Read logo parameters from logo.ini (if it exists). */
config = al_load_config_file("logo.ini");
if (!config)
config = al_create_config();
for (i = 0; param_names[i]; i++) {
char const *value = al_get_config_value(config, "logo", param_names[i]);
if (value)
strncpy(param_values[i], value, sizeof(param_values[i]));
}
font = al_load_font("data/DejaVuSans.ttf", 12, 0);
if (!font) {
abort_example("Could not load font\n");
return 1;
}
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_mouse_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 (!quit) {
ALLEGRO_EVENT event;
al_wait_for_event(queue, &event);
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
break;
if (event.type == ALLEGRO_EVENT_KEY_CHAR) {
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
quit = true;
}
else if (event.keyboard.keycode == ALLEGRO_KEY_ENTER) {
if (editing) {
regenerate = true;
editing = false;
}
else {
cursor = 0;
editing = true;
}
}
else if (event.keyboard.keycode == ALLEGRO_KEY_UP) {
if (selection > 0) {
selection--;
cursor = 0;
editing = false;
}
}
else if (event.keyboard.keycode == ALLEGRO_KEY_DOWN) {
if (param_names[selection + 1]) {
selection++;
cursor = 0;
editing = false;
}
}
else {
int c = event.keyboard.unichar;
if (editing) {
if (c >= 32) {
ALLEGRO_USTR *u = al_ustr_new(param_values[selection]);
al_ustr_set_chr(u, cursor, c);
cursor++;
al_ustr_set_chr(u, cursor, 0);
strncpy(param_values[selection], al_cstr(u),
sizeof param_values[selection]);
al_ustr_free(u);
}
}
else {
if (c == 'r')
randomize();
if (c == 's')
save();
}
}
}
if (event.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) {
if (event.mouse.button == 1) {
mouse_click(event.mouse.x, event.mouse.y);
}
}
if (event.type == ALLEGRO_EVENT_TIMER)
redraw++;
if (redraw && al_is_event_queue_empty(queue)) {
redraw = 0;
render();
al_flip_display();
}
}
/* Write modified parameters back to logo.ini. */
for (i = 0; param_names[i]; i++) {
al_set_config_value(config, "logo", param_names[i],
param_values[i]);
}
al_save_config_file("logo.ini", config);
al_destroy_config(config);
return 0;
}
int main(int argc, char** argv)
{
time_t t;
srand((unsigned) time(&t));
if (!al_init())
{
std::cout << "Failed to start Allegro.";
return -1;
}
if (!al_init_image_addon())
{
std::cout << "Failed to start Allegro Imagea person who gives information to the police or to some other authority about the bad behavior or criminal activity of someone else Addon.\n";
return -1;
}
if (!al_init_primitives_addon())
{
std::cout << "Failed to start Allegro Primitives Addon.\n";
return -1;
}
if (!al_init_font_addon())
{
std::cout << "Failed to start Allegro Font Addon.\n";
return -1;
}
if (!al_init_ttf_addon())
{
std::cout << "Failed to start Allegro TTF Addon.\n";
return -1;
}
ALLEGRO_DISPLAY* main_window = al_create_display(800, 600);
if (!main_window)
{
std::cout << "Failed to create display.";
return -1;
}
ALLEGRO_EVENT_QUEUE* eq = al_create_event_queue();
if (!eq)
{
std::cout << "Failed to create event queue.";
return -1;
}
ALLEGRO_TIMER* fps_timer = al_create_timer(1.0 / 60);
if (!fps_timer)
{
std::cout << "Failed to create timer.";
return -1;
}
ALLEGRO_TIMER* count_timer = al_create_timer(1.0);
if (!count_timer)
{
std::cout << "Failed to create count timer.";
return -1;
}
if (!al_install_keyboard())
{
std::cout << "Failed to install keyboard.";
return -1;
}
if (!al_install_mouse() || !al_set_mouse_cursor(main_window, al_create_mouse_cursor(al_load_bitmap("resources/sprites/UI/cursor/clicker.png"), 16, 31)))
{
std::cout << "Failed to install mouse.";
return -1;
}
al_register_event_source(eq, al_get_timer_event_source(fps_timer));
al_register_event_source(eq, al_get_timer_event_source(count_timer));
al_register_event_source(eq, al_get_keyboard_event_source());
al_register_event_source(eq, al_get_mouse_event_source());
al_register_event_source(eq, al_get_display_event_source(main_window));
Game base;
if (!base.init())
{
std::cout << "Failed to initialise game! Quitting...\n";
return -1;
}
bool ready_to_draw = false;
bool ready_to_draw_fps = false;
al_start_timer(fps_timer);
al_start_timer(count_timer);
int fps_count = 0;
ALLEGRO_FONT* fps_font = al_load_ttf_font("resources/fonts/MontereyFLF.ttf", 11, 0);
if (!fps_font)
{
std::cout << "Failed to load font for fps counter!";
return -1;
}
while (true)
{
while (!al_event_queue_is_empty(eq))
{
ALLEGRO_EVENT ev;
al_get_next_event(eq, &ev);
if (ev.type == ALLEGRO_EVENT_TIMER)
{
if (ev.timer.source == fps_timer)
{
ready_to_draw = true;
}
else if (ev.timer.source == count_timer)
{
ready_to_draw_fps = true;
}
}
else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
std::cout << "Safely quitting.";
al_destroy_display(main_window);
al_destroy_event_queue(eq);
al_destroy_timer(fps_timer);
return 0;
}
else if (ev.type == ALLEGRO_EVENT_KEY_DOWN)
{
if (ev.keyboard.keycode == ALLEGRO_KEY_ESCAPE) //current keyboard input section
{
std::cout << "Safely quitting.";
al_destroy_display(main_window);
al_destroy_event_queue(eq);
al_destroy_timer(fps_timer);
return 0;
}
}
base.runEvents(ev);
}
if (ready_to_draw)
{
fps_count++;
base.runLogic();
base.runDisplay();
char buffer[25];
if (ready_to_draw_fps)
{
sprintf(buffer, "%d", fps_count);
fps_count = 0;
ready_to_draw_fps = false;
}
al_draw_text(fps_font, al_map_rgb(0,255,0), 5, 5, 0, buffer);
al_flip_display();
ready_to_draw = false;
}
}
}
int main(int argc, char const *argv[])
{
const int FPS = 60;
const int MAX_BULLETS = 10;
const int MAX_ASTEROIDS = 10;
const int MAX_EXPLOSIONS = 10;
srand(time(NULL));
int done = 0;
int redraw = 1;
if(!al_init())
{
al_show_native_message_box(NULL, "Error", "Error",
"Could not initialize Allegro 5.", 0, ALLEGRO_MESSAGEBOX_ERROR);
return -1;
}
ALLEGRO_DISPLAY *display = al_create_display(screen_width, screen_height);
if(!display)
{
al_show_native_message_box(NULL, "Error", "Error",
"Could not create display.", 0, ALLEGRO_MESSAGEBOX_ERROR);
return -1;
}
ALLEGRO_EVENT_QUEUE *event_queue = al_create_event_queue();
if(!event_queue)
{
al_show_native_message_box(display, "Error", "Error",
"Could not create event queue.", 0, ALLEGRO_MESSAGEBOX_ERROR);
return -1;
}
ALLEGRO_TIMER *timer = al_create_timer(1.0/FPS);
if(!timer)
{
al_show_native_message_box(display, "Error", "Error",
"Could not create timer.", 0, ALLEGRO_MESSAGEBOX_ERROR);
return -1;
}
if(!al_install_keyboard())
{
al_show_native_message_box(display, "Error", "Error",
"Could not install keyboard.", 0, ALLEGRO_MESSAGEBOX_ERROR);
return -1;
}
if(!al_install_mouse())
{
al_show_native_message_box(display, "Error", "Error",
"Could not install mouse.", 0, ALLEGRO_MESSAGEBOX_ERROR);
return -1;
}
if(!al_init_image_addon())
{
al_show_native_message_box(display, "Error", "Error",
"Could not initialize image addon.", 0, ALLEGRO_MESSAGEBOX_ERROR);
return -1;
}
if(!al_init_primitives_addon())
{
al_show_native_message_box(display, "Error", "Error",
"Could not initialize primitives addon.", 0, ALLEGRO_MESSAGEBOX_ERROR);
}
al_init_font_addon(); // for whatever reason this function is void returning
if(!al_init_ttf_addon())
{
al_show_native_message_box(display, "Error", "Error",
"Could not initialize ttf addon.", 0, ALLEGRO_MESSAGEBOX_ERROR);
}
al_hide_mouse_cursor(display);
al_register_event_source(event_queue, al_get_mouse_event_source());
al_register_event_source(event_queue, al_get_keyboard_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));
ALLEGRO_FONT *font18 = al_load_font("Arial.ttf", 18, 0);
int prev_x = screen_width, prev_y = screen_height;
int fps_counter = 0;
int fps_counter2 = 0;
int i, j, k;
struct spaceship ship;
init_ship(&ship);
struct bullet bullets[MAX_BULLETS];
for(i = 0; i < MAX_BULLETS; i++)
{
init_bullet(&bullets[i]);
}
struct asteroid asteroids[MAX_ASTEROIDS];
for(i = 0; i < MAX_ASTEROIDS; i++)
{
init_asteroid(&asteroids[i]);
}
struct explosion explosions[MAX_EXPLOSIONS];
for(i = 0; i < MAX_EXPLOSIONS; i++)
{
init_explosion(&explosions[i]);
}
al_start_timer(timer);
while(!done)
{
ALLEGRO_EVENT event;
al_wait_for_event(event_queue, &event);
if(event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
done = 1;
}
if(event.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch(event.keyboard.keycode)
{
case ALLEGRO_KEY_Q:
done = 1;
break;
case ALLEGRO_KEY_ESCAPE:
done = 1;
break;
}
}
if(event.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN)
{
if(event.mouse.button & 1)
{
for(i = 0; i < MAX_BULLETS; i++)
{
if(!bullets[i].live)
{
fire_bullet(&bullets[i], ship);
break;
}
}
}
}
if(event.type == ALLEGRO_EVENT_MOUSE_AXES ||
event.type == ALLEGRO_EVENT_MOUSE_ENTER_DISPLAY)
{
set_ship_coordinates(&ship, event.mouse.x, event.mouse.y);
}
if(event.type == ALLEGRO_EVENT_TIMER)
{
if(ship.x > prev_x)
{
ship.sprite.dir_horizontal = RIGHT;
}
else if(ship.x == prev_x)
{
ship.sprite.dir_horizontal = CENTER;
}
else if(ship.x < prev_x)
{
ship.sprite.dir_horizontal = LEFT;
}
if(ship.y > prev_y)
{
ship.sprite.dir_vertical = BACK;
}
else if(ship.y == prev_y)
{
ship.sprite.dir_vertical = NEUTRAL;
}
else if(ship.y < prev_y)
{
ship.sprite.dir_vertical = FORWARD;
}
if(++fps_counter >= FPS / 5)
{
fps_counter = 0;
prev_x = ship.x;
prev_y = ship.y;
}
if(++fps_counter2 >= 2 * FPS)
{
for(i = 0; i < MAX_ASTEROIDS; i++)
{
if(!asteroids[i].live)
{
start_asteroid(&asteroids[i]);
break;
}
}
fps_counter2 = 0;
}
for(i = 0; i < MAX_BULLETS; i++)
{
if(bullets[i].live)
{
update_bullet(&bullets[i]);
}
}
for(i = 0; i < MAX_ASTEROIDS; i++)
{
if(asteroids[i].live)
{
update_asteroid(&asteroids[i], &ship);
}
}
for(i = 0; i < MAX_EXPLOSIONS; i++)
{
if(explosions[i].live)
{
update_explosion(&explosions[i]);
}
}
update_ship_boundaries(&ship);
for(i = 0; i < MAX_BULLETS; i++)
{
if(bullets[i].live)
{
for(j = 0; j < MAX_ASTEROIDS; j++)
{
if(asteroids[j].live)
{
if(bullet_and_asteroid_collision(bullets[i], asteroids[j]))
{
bullets[i].live = 0;
asteroids[j].live = 0;
ship.score += 20;
for(k = 0; k < MAX_EXPLOSIONS; k++)
{
if(!explosions[k].live)
{
start_explosion(&explosions[k], bullets[i].x, bullets[i].y);
break;
}
}
}
}
}
}
}
for(i = 0; i < MAX_ASTEROIDS; i++)
{
if(asteroids[i].live)
{
if(ship_and_asteroid_collision(ship, asteroids[i]))
{
asteroids[i].live = 0;
for(k = 0; k < MAX_EXPLOSIONS; k++)
{
if(!explosions[k].live)
{
start_explosion(&explosions[k], ship.x, ship.y);
break;
}
}
ship.lives--;
}
}
}
if(!ship.lives)
{
done = true;
}
redraw = 1;
}
if(redraw)
{
redraw = 0;
draw_ship_sprite(ship.sprite, ship.x, ship.y);
for(i = 0; i < MAX_BULLETS; i++)
{
if(bullets[i].live)
{
draw_bullet(bullets[i]);
}
}
for(i = 0; i < MAX_ASTEROIDS; i++)
{
if(asteroids[i].live)
{
draw_asteroid(asteroids[i]);
}
}
for(i = 0; i < MAX_EXPLOSIONS; i++)
{
if(explosions[i].live)
{
draw_explosion(explosions[i]);
}
}
al_draw_textf(font18, al_map_rgb(255, 255, 255), 50, 5, 0,
"Score: %d ", ship.score); // I have no idea why it doesn't print the S...
al_draw_textf(font18, al_map_rgb(255, 255, 255), 50, 25, 0,
"Lives: %d", ship.lives);
al_flip_display();
al_clear_to_color(al_map_rgb(0, 0, 0));
}
}
for(i = 0; i < MAX_ASTEROIDS; i++)
{
destroy_asteroid(&asteroids[i]);
}
for(i = 0; i < MAX_EXPLOSIONS; i++)
{
destroy_explosion(&explosions[i]);
}
destroy_sprite(&ship.sprite);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
al_destroy_timer(timer);
al_destroy_font(font18);
return 0;
}
static void tick(void)
{
draw();
al_flip_display();
}
int main(void) {
initialize();
int nva = al_get_num_video_adapters();
assert(nva);
ALLEGRO_MONITOR_INFO aminfo;
al_get_monitor_info(0, &aminfo);
screen_w = aminfo.x2 - aminfo.x1 + 1;
screen_h = aminfo.y2 - aminfo.y1 + 1;
ALLEGRO_DISPLAY *display = al_create_display(screen_w, screen_h);
ALLEGRO_EVENT_QUEUE *evqueue = al_create_event_queue();
ALLEGRO_TIMER *fps_timer = al_create_timer(1.0 / 120.0);
al_set_display_flag(display, ALLEGRO_FULLSCREEN_WINDOW, true);
if (!display) {
printf("Failed to create display!\n");
exit(EXIT_FAILURE);
}
al_register_event_source(evqueue, al_get_keyboard_event_source());
al_register_event_source(evqueue, al_get_mouse_event_source());
al_register_event_source(evqueue, al_get_display_event_source(display));
al_register_event_source(evqueue, al_get_timer_event_source(fps_timer));
al_start_timer(fps_timer);
////////////////////////////////////////////////////////////////////////////////////////////////
// Local Variables
////////////////////////////////////////////////////////////////////////////////////////////////
//#ifdef DEBUG
float fps = 0, delta_time = 0, current_time = 0, last_time = al_get_time();
//#endif //DEBUG
bool render = true, executing = true;
unsigned int spawn_counter = 0;
Assets* assets = new Assets();
Stage stage = Menu;
Stats stats;
Button *play = new Button("Play", assets->fnt_menu, screen_w / 2, 300, [&stage, &stats]() -> void {
stage = Game;
stats.start_time = al_get_time();
}),
*leaderboard = new Button("Leaderboard", assets->fnt_menu, screen_w / 2, 400, [&stage]() -> void {
stage = Leaderboard;
}),
*options = new Button("Options", assets->fnt_menu, screen_w / 2, 500, [&stage]() -> void {
stage = Options;
}),
*quit = new Button("Quit", assets->fnt_menu, screen_w / 2, 600, [&executing]() -> void {
executing = false;
});
b2Vec2 gravity(0.0f, 0.0f);
b2World world(gravity);
Projectile *player = new Projectile(assets->png_player, &world, screen_w / 2, screen_h - 200);
std::vector<Projectile*> Meteors;
////////////////////////////////////////////////////////////////////////////////////////////////
// Game Loop
////////////////////////////////////////////////////////////////////////////////////////////////
while (executing) {
ALLEGRO_EVENT event;
al_wait_for_event(evqueue, &event);
//#ifdef DEBUG
current_time = al_get_time();
delta_time = current_time - last_time;
fps = 1/(delta_time);
last_time = current_time;
//#endif //DEBUG
world.Step(delta_time, 8, 3);
switch (event.type) { // HANDLE ALLEGRO EVENTS
case ALLEGRO_EVENT_TIMER:
render = true;
if (stage == Game) spawn_counter++;
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
executing = false;
break;
case ALLEGRO_EVENT_KEY_DOWN:
executing = event.keyboard.keycode != ALLEGRO_KEY_ESCAPE;
switch(event.keyboard.keycode) {
case ALLEGRO_KEY_A:
case ALLEGRO_KEY_LEFT:
if (stage == Game) player->Velocity.x = -5;
break;
case ALLEGRO_KEY_D:
case ALLEGRO_KEY_RIGHT:
if (stage == Game) player->Velocity.x = 5;
break;
}
break;
case ALLEGRO_EVENT_KEY_UP:
if (stage == Game) {
player->Velocity.x = 0;
player->Velocity.y = 0;
}
break;
default: break;
}
switch (stage) { // UPDATE
case Menu:
play->Update(&event);
leaderboard->Update(&event);
options->Update(&event);
quit->Update(&event);
break;
case Game:
if (player->m_body->GetPosition().x < 1) player->m_body->SetTransform(b2Vec2(screen_w - 2, player->m_body->GetPosition().y), 0);
if (player->m_body->GetPosition().x > screen_w - 1) player->m_body->SetTransform(b2Vec2(2, player->m_body->GetPosition().y), 0);
if (spawn_counter > 75) {
spawn_counter = 0;
ALLEGRO_BITMAP *meteor_png;
switch (rand() % 4) { // Size
case 0:
switch (rand() % 4) { // Selection
case 0:
meteor_png = rand() % 2 ? assets->png_meteor_brown_big1 : assets->png_meteor_grey_big1;
break;
case 1:
meteor_png = rand() % 2 ? assets->png_meteor_brown_big2 : assets->png_meteor_grey_big2;
break;
case 2:
meteor_png = rand() % 2 ? assets->png_meteor_brown_big3 : assets->png_meteor_grey_big3;
break;
case 3:
meteor_png = rand() % 2 ? assets->png_meteor_brown_big4 : assets->png_meteor_grey_big4;
break;
default: break;
}
break;
case 1:
switch (rand() % 2) { // Selection
case 0:
meteor_png = rand() % 2 ? assets->png_meteor_brown_med1 : assets->png_meteor_grey_med1;
break;
case 1:
meteor_png = rand() % 2 ? assets->png_meteor_brown_med2 : assets->png_meteor_grey_med2;
break;
default: break;
}
break;
case 2:
switch (rand() % 2) { // Selection
case 0:
meteor_png = rand() % 2 ? assets->png_meteor_brown_small1 : assets->png_meteor_grey_small1;
break;
case 1:
meteor_png = rand() % 2 ? assets->png_meteor_brown_small2 : assets->png_meteor_grey_small2;
break;
default: break;
}
break;
case 3:
switch (rand() % 2) { // Selection
case 0:
meteor_png = rand() % 2 ? assets->png_meteor_brown_tiny1 : assets->png_meteor_grey_tiny1;
break;
case 1:
meteor_png = rand() % 2 ? assets->png_meteor_brown_tiny2 : assets->png_meteor_grey_tiny2;
break;
default: break;
}
break;
default: break;
}
auto it = Meteors.end();
Projectile *meteor = new Projectile(meteor_png, &world, rand() % screen_w, -75);
meteor->Velocity = b2Vec2(-5 + (rand() % 10), rand() % 15);
Meteors.insert(it, meteor);
}
for (std::vector<Projectile*>::iterator it = Meteors.begin(); it != Meteors.end(); ++it) {
if (((*it)->m_body->GetPosition().x >= screen_w + 500 || (*it)->m_body->GetPosition().x <= -500) ||
((*it)->m_body->GetPosition().y >= screen_h + 500 || (*it)->m_body->GetPosition().y <= -500) ||
(((*it)->m_body->GetTransform().p.x == 0.0) && (*it)->m_body->GetTransform().p.y == 0.0)) {
delete *it;
Meteors.erase(it);
}
}
player->Update(&event);
for (auto& x : Meteors) {
x->Update(&event);
}
break;
case Leaderboard:
break;
case Options:
break;
case End:
break;
default: break;
}
if (render && al_is_event_queue_empty(evqueue)) {
render = false;
al_clear_to_color(al_map_rgb(0, 0, 0));
al_set_target_bitmap(al_get_backbuffer(display));
for (float x = 0; x < screen_w; x += al_get_bitmap_width(assets->png_background)) {
for (float y = 0; y < screen_h; y += al_get_bitmap_height(assets->png_background)) {
al_draw_bitmap(assets->png_background, x, y, 0);
}
}
#ifdef DEBUG
//al_draw_textf(assets->fnt_menu, al_map_rgb(255, 0, 255), 10, 5, ALLEGRO_ALIGN_LEFT, "Debug");
//al_draw_textf(assets->fnt_menu, al_map_rgb(255, 0, 255), 10, 35, ALLEGRO_ALIGN_LEFT, "FPS: %i", (int)fps);
//al_draw_textf(assets->fnt_menu, al_map_rgb(255, 0, 255), 10, 65, ALLEGRO_ALIGN_LEFT, "Meteor Count: %i", Meteors.size());
#endif // DEBUG
switch (stage) { // RENDER
default: break;
case Menu:
al_draw_text(assets->fnt_title, al_map_rgb(255, 255, 255), screen_w/2, 100, ALLEGRO_ALIGN_CENTRE, "SPACE SHOOTER III");
play->Render();
leaderboard->Render();
options->Render();
quit->Render();
break;
case Game:
player->Render();
for (auto& x : Meteors) {
x->Render();
}
break;
case Leaderboard:
break;
case Options:
break;
case End:
break;
}
al_flip_display();
}
render = false;
}
////////////////////////////////////////////////////////////////////////////////////////////////
// Deinitialization
////////////////////////////////////////////////////////////////////////////////////////////////
delete player;
al_unregister_event_source(evqueue, al_get_keyboard_event_source());
al_unregister_event_source(evqueue, al_get_mouse_event_source());
al_unregister_event_source(evqueue, al_get_display_event_source(display));
al_unregister_event_source(evqueue, al_get_timer_event_source(fps_timer));
al_destroy_display(display);
al_destroy_event_queue(evqueue);
al_destroy_timer(fps_timer);
delete assets;
shutdown();
return EXIT_SUCCESS;
}
void AllegroDisp::FlipBuffers()
{
al_flip_display();
}
/* Function: al_create_display
*/
ALLEGRO_DISPLAY *al_create_display(int w, int h)
{
ALLEGRO_SYSTEM *system;
ALLEGRO_DISPLAY_INTERFACE *driver;
ALLEGRO_DISPLAY *display;
ALLEGRO_EXTRA_DISPLAY_SETTINGS *settings;
int flags;
system = al_get_system_driver();
driver = system->vt->get_display_driver();
if (!driver) {
ALLEGRO_ERROR("Failed to create display (no display driver)\n");
return NULL;
}
display = driver->create_display(w, h);
if (!display) {
ALLEGRO_ERROR("Failed to create display (NULL)\n");
return NULL;
}
ASSERT(display->vt);
settings = &display->extra_settings;
flags = settings->required | settings->suggested;
if (!(flags & (1 << ALLEGRO_AUTO_CONVERT_BITMAPS))) {
settings->settings[ALLEGRO_AUTO_CONVERT_BITMAPS] = 1;
}
display->min_w = 0;
display->min_h = 0;
display->max_w = 0;
display->max_h = 0;
display->use_constraints = false;
display->vertex_cache = 0;
display->num_cache_vertices = 0;
display->cache_enabled = false;
display->vertex_cache_size = 0;
display->cache_texture = 0;
al_identity_transform(&display->projview_transform);
display->default_shader = NULL;
_al_vector_init(&display->display_invalidated_callbacks, sizeof(void *));
_al_vector_init(&display->display_validated_callbacks, sizeof(void *));
display->render_state.write_mask = ALLEGRO_MASK_RGBA | ALLEGRO_MASK_DEPTH;
display->render_state.depth_test = false;
display->render_state.depth_function = ALLEGRO_RENDER_LESS;
display->render_state.alpha_test = false;
display->render_state.alpha_function = ALLEGRO_RENDER_ALWAYS;
display->render_state.alpha_test_value = 0;
_al_vector_init(&display->bitmaps, sizeof(ALLEGRO_BITMAP*));
if (settings->settings[ALLEGRO_COMPATIBLE_DISPLAY]) {
al_set_target_bitmap(al_get_backbuffer(display));
}
else {
ALLEGRO_DEBUG("ALLEGRO_COMPATIBLE_DISPLAY not set\n");
_al_set_current_display_only(display);
}
if (display->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
display->default_shader = _al_create_default_shader(display->flags);
if (!display->default_shader) {
al_destroy_display(display);
return NULL;
}
al_use_shader(display->default_shader);
}
/* Clear the screen */
if (settings->settings[ALLEGRO_COMPATIBLE_DISPLAY]) {
al_clear_to_color(al_map_rgb(0, 0, 0));
/* TODO:
* on iphone, don't kill the initial splashscreen - in fact, it's also
* annoying in linux to have an extra black frame as first frame and I
* suppose we never really want it
*/
#if 0
al_flip_display();
#endif
}
if (settings->settings[ALLEGRO_AUTO_CONVERT_BITMAPS]) {
/* We convert video bitmaps to memory bitmaps when the display is
* destroyed, so seems only fair to re-convertt hem when the
* display is re-created again.
*/
al_convert_memory_bitmaps();
}
return display;
}
int main(int argc, char* argv [])
{
al_init();
al_init_primitives_addon();
al_install_keyboard();
al_init_image_addon();
ALLEGRO_CONFIG *configFile = al_load_config_file("data/config/config.ini");
if (configFile == NULL)
{
al_show_native_message_box(NULL, "A fatal error has ocurred!",
"The configuration file has not been found!",
"Be sure to always have a valid conf.ini in /data/config/ for the program to work...", "Understood", ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
std::string dispW = al_get_config_value(configFile, "DISPLAY", "RESX");
std::string dispH = al_get_config_value(configFile, "DISPLAY", "RESY");
std::string fullscreenMode = al_get_config_value(configFile, "DISPLAY", "FULLSCREEN");
int iDispW = stoi(dispW);
int iDispH = stoi(dispH);
bool bfullscreenMode = stoi(fullscreenMode);
assert(iDispW < 5000 && iDispW > 0);
assert(iDispH < 5000 && iDispH > 0);
if (bfullscreenMode == true)
al_set_new_display_flags(ALLEGRO_FULLSCREEN);
ALLEGRO_DISPLAY *display = al_create_display(iDispW, iDispH);
if (display == NULL)
{
al_show_native_message_box(NULL, "A fatal error has ocurred!",
"Display creation failed!",
"The resolution selected is not supported by your screen/video card...", "Understood", ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
al_clear_to_color(al_map_rgb(255, 0, 0));
al_flip_display();
bool done = false;
bool redraw = false;
ALLEGRO_TIMER *timer = al_create_timer(1.0 / 60.0);
ALLEGRO_EVENT_QUEUE *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));
//**********************
ALLEGRO_BITMAP *test = al_load_bitmap("data/background.png");
int x = 320, y = 240;
Vec2D size(40.0f, 40.0f);
TestObject gameObject(Vec2D(10.0f, 10.0f));
gameObject.AddComponent(new RenderComponent());
gameObject.AddComponent(new PhysicsComponent(size, size, size, true));
//*********************
al_start_timer(timer);
//newManager.AddComponent(new PhysicsComponent(Vec2D(), Vec2D(), Vec2D(5.0f, 10.0f), false));
while (!done)
{
ALLEGRO_EVENT ev;
al_wait_for_event(queue, &ev);
switch (ev.type)
{
case ALLEGRO_EVENT_TIMER:
redraw = true;
gameObject.Update();
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
done = true;
break;
case ALLEGRO_EVENT_KEY_DOWN:
if (ev.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
{
done = true;
}
//************
else
{
// NOTHING
}
//************
break;
default:
break;
}
if (redraw && al_is_event_queue_empty(queue))
{
redraw = false;
al_clear_to_color(al_map_rgb(0, 0, 0));
al_draw_bitmap(test, 0, 0, NULL);
//PhysicsComponent *test = (PhysicsComponent*) newManager.GetComponentByType(COMP_PHYSICS);
//Vec2D pos = test->GetPosition();
al_draw_filled_circle(x, y, 89, al_map_rgb(255, 0, 255));
al_flip_display();
}
}
al_destroy_config(configFile);
al_destroy_display(display);
al_destroy_event_queue(queue);
al_destroy_timer(timer);
}
//Render for States
void
state_render ()
{
if (state_switched)
return;
if (state_terminated)
return;
state_to_render = 1;
state_to_force_render = 0;
//To Set up for Transition Render
if (state_trans_curf >= 0)
{
if (rbufferorig == NULL)
rbufferorig = al_clone_bitmap (rbuffer);
if (transrbuffer == NULL)
transrbuffer = al_clone_bitmap (rbuffer);
}
//Common for All Games
al_set_target_bitmap (rbuffer);
handlers[state].proc_render ();
//Transition Render
if (state_trans_curf >= 0 && state_trans_curf < state_trans_totf && strans
&& rbufferorig && transrbuffer)
{
strans (rbufferorig, rbuffer, transrbuffer, state_trans_curf++,
state_trans_totf);
state_to_force_render = 1;
}
//To Destroy Transition
if (strans && (state_trans_curf >= state_trans_totf))
{
trans_stop ();
state_to_force_render = 1;
}
//Switch Modes
if (state_to_switch_render)
init_screen ();
//This is Because of GUI.
state_to_force_render = 1;
if (state_to_force_render || state_to_switch_render || state_to_render)
{
//Render to Screen
al_set_target_backbuffer (screen);
if (transrbuffer)
blit (transrbuffer, 0, 0, 0, 0, xres, yres, 0);
else
blit (rbuffer, 0, 0, 0, 0, xres, yres, 0);
gui_render ();
#ifdef LINUX
//VSync helped remove bad artifacts in Linux
al_wait_for_vsync ();
#endif //LINUX
al_flip_display ();
}
state_to_switch_render = 0;
}
void engine_run(struct State *s)
{
int redraw = FALSE;
if (engine_active)
{
return;
}
change_state(s, NULL);
// Generate display events
al_register_event_source(engine.event_queue,
al_get_display_event_source(engine.display));
// Timer events
al_register_event_source(engine.event_queue,
al_get_timer_event_source(engine.timer));
// Keyboard events
al_register_event_source(engine.event_queue,
al_get_keyboard_event_source());
// Mouse events
al_register_event_source(engine.event_queue,
al_get_mouse_event_source());
al_start_timer(engine.timer);
engine_active = TRUE;
// Main game loop
while (engine_active)
{
ALLEGRO_EVENT event;
al_wait_for_event(engine.event_queue, &event);
// Event processing
engine.states[current_state]->_events(&event, &engine.sm);
// If the close button was pressed...
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
engine_active = FALSE;
break;
}
else if (event.type == ALLEGRO_EVENT_KEY_DOWN)
{
keys[event.keyboard.keycode] = TRUE;
// F4 key will toggle full-screen
if (event.keyboard.keycode == ALLEGRO_KEY_F4)
{
al_stop_timer(engine.timer);
if (al_get_display_flags(engine.display)
& ALLEGRO_FULLSCREEN_WINDOW)
{
al_toggle_display_flag(engine.display,
ALLEGRO_FULLSCREEN_WINDOW, 0);
}
else
{
al_toggle_display_flag(engine.display,
ALLEGRO_FULLSCREEN_WINDOW, 1);
}
aspect_ratio_transform();
al_start_timer(engine.timer);
}
}
else if (event.type == ALLEGRO_EVENT_KEY_UP)
{
keys[event.keyboard.keycode] = FALSE;
}
else if (event.type == ALLEGRO_EVENT_TIMER)
{
engine.states[current_state]->_update(&engine.sm);
redraw = TRUE;
}
if (redraw && engine_active
&& al_is_event_queue_empty(engine.event_queue))
{
redraw = FALSE;
if (MAINCONF->buffer)
{
al_set_target_bitmap(engine.buffer);
}
else
{
al_set_target_backbuffer(engine.display);
}
al_clear_to_color(engine.bg_color);
engine.states[current_state]->_draw(&engine.sm);
if (MAINCONF->buffer)
{
al_set_target_backbuffer(engine.display);
al_clear_to_color(C_BLACK);
al_draw_bitmap(engine.buffer, 0, 0, 0);
}
al_flip_display();
}
}
while (loaded_count > 0)
{
engine.loaded_states[--loaded_count]->_free();
}
al_destroy_display(engine.display);
al_destroy_timer(engine.timer);
al_destroy_event_queue(engine.event_queue);
al_destroy_font(font);
if (MAINCONF->buffer)
{
al_destroy_bitmap(engine.buffer);
}
}
/*
Main Loop running the project engine. Cycles through an infinite loop while States are still running.
Pushes in the first state of main menu of the editor application and it will cycle through the States registered events
Then it will perform that States keypress method and mouse activity method.
If a states resulting processing will decide that the state is no longer needed. EG: closing current map or option menu it will push or pop the State stack and destroy/dispose/clean those objects from memory.
If those State directions have not been triggered. The game will run the current states Update(game logic) method and then run the Draw method
*/
void EditorEngine::Run()
{
ALLEGRO_EVENT ev;
while(currentState_->GetRunning()){
al_wait_for_event(currentState_->GetEventQueue(),&ev);
currentState_->SetEvent(&ev);
currentState_->KeyPress();
currentState_->MouseActivity();
if(currentState_->GetStateDirection() == STATEDIRECTION::PUSH){
PushState();
continue;
}
else if(currentState_->GetStateDirection() == STATEDIRECTION::POP){
PopState();
continue;
}
else if(currentState_->GetStateDirection() == STATEDIRECTION::POPPUSH){
PopPushState();
continue;
}
else if(currentState_->GetStateDirection() == STATEDIRECTION::POPTOFIRST){
PopStateToFirst();
continue;
}
if(currentState_->GetEvent()->type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
//close window if display is closed via X in top right corner
currentState_->SetRunning(false);
}
currentState_->Update();
if(currentState_->GetRedraw() && al_is_event_queue_empty(currentState_->GetEventQueue()))
{
currentState_->SetRedraw(false);
currentState_->Draw();
//bread and butter
char text[20];
sprintf(text, "%f", ev.timer.timestamp);
al_draw_text(currentState_->GetFont(), chosenColorText_,
settings_->GetScreenWidth()-al_get_text_width(currentState_->GetFont(), text),
settings_->GetScreenHeight() - Constants::TileSize(), ALLEGRO_ALIGN_LEFT, text);
al_flip_display();
al_clear_to_color(chosenColor_);//clears color to dark green to remove all back image
}
/*
Get state done or not
if done == true delete current state and Set new state
if not done and state change push new state to stack
if neither do normal again (-2 default)
*/
//Get keypress state
//mmm change state
}
}
// The main Allegro loop, all input handling, animation and drawing is done here
_Bool main_loop(void)
{
// Flag for drawing
_Bool needredraw = true;
// Declare primitive data types
float old_time = 0.0, current_time = 0, dt = 0;
while(!data->exit)
{
if(needredraw && al_event_queue_is_empty(data->queue) && al_event_queue_is_empty(data->queue2))
{
// Clear, draw, flip
al_clear_to_color(data->background_color);
render();
if(get_fps_status())
al_draw_textf(data->font, data->text_color, 0, res_height-30, 0, "fps: %.2f", 1/dt);
al_flip_display();
needredraw = false;
}
// Block until an event enters the queue
al_wait_for_event(data->queue, &(data->event));
while(!al_event_queue_is_empty(data->queue2))
{
al_get_next_event(data->queue2, &(data->event2));
switch(data->event2.type)
{
case ALLEGRO_EVENT_DISPLAY_CLOSE:
{
// If x button is pressed on window
data->exit = true;
data->gamestarted = false;
}
break;
case ALLEGRO_EVENT_DISPLAY_RESIZE:
{
al_acknowledge_resize(data->event2.display.source);
scale(res_width, res_height);
}
break;
case ALLEGRO_EVENT_MOUSE_AXES:
{
// Stores the mouse's new position and change in position
mouseaxes(&(data->event2.mouse));
}
case ALLEGRO_EVENT_MOUSE_BUTTON_DOWN:
{
// Stores the mouse button pressed
mousedown(&(data->event2.mouse));
}
break;
case ALLEGRO_EVENT_MOUSE_BUTTON_UP:
{
// Stores the mouse button released
mouseup(&(data->event2.mouse));
}
break;
case ALLEGRO_EVENT_KEY_DOWN:
{
// Stores keydown keycode into keycode array for processing
keydown(&(data->event2.keyboard));
}
break;
case ALLEGRO_EVENT_KEY_UP:
{
// Stores keycode into keycode array for processing
keyup(&(data->event2.keyboard));
}
break;
default:
break;
}
}
switch (data->event.type)
{
case ALLEGRO_EVENT_TIMER:
{
// Determine the change in time between frames, in seconds
current_time = al_current_time();
dt = current_time-old_time;
// If the computer lags for some reason, don't penalize the player
// Cap dt at 0.5 seconds
if(dt > 0.25)
{
dt = 0.25;
}
// Handle Mouse and Keyboard events and Button Events
buttoncheck(&buttonhandler, data);
keycheck(&keyhandler, data);
mousecheck(&mousehandler, data);
keyupdate();
mouseupdate();
// Check if data->quit has been set before updating and drawing
if(data->exit) break;
// Update the game, always
update();
// Skip drawing frames if computer lags
if(current_time - data->event.timer.timestamp <= 1.0/al_get_display_refresh_rate(data->display))
{
needredraw = true;
}
// Make the time at this frame the old time, for the next frame
old_time = current_time;
}
break;
default:
break;
}
}
return true;
}
int main( int argc, char* argv[] )
{
ALLEGRO_EVENT e;
ALLEGRO_TIMER* t;
int64_t framesToUpdate = 0;
if( !al_init() )
{
return -1;
}
al_init_font_addon();
if( !al_install_keyboard() || !al_install_mouse() || !al_init_primitives_addon() || !al_init_ttf_addon() || !al_init_image_addon() )
{
return -1;
}
#if NETWORK_SUPPORT != 0
if( !install_network() )
{
return -1;
}
#endif
#if HTTP_SUPPORT
if( !install_http() )
{
return -1;
}
#ifdef PANDORA
Downloads = new HttpManager(2);
#else
Downloads = new HttpManager(6);
#endif
#endif
#if EXIT_IF_NO_AUDIO != 0
if( !al_install_audio() || !al_init_acodec_addon() )
{
return -1;
}
voice = al_create_voice(44100, ALLEGRO_AUDIO_DEPTH_INT16, ALLEGRO_CHANNEL_CONF_2);
if (!voice)
return 1;
mixer = al_create_mixer(44100, ALLEGRO_AUDIO_DEPTH_FLOAT32, ALLEGRO_CHANNEL_CONF_2);
if (!mixer)
return 1;
if (!al_attach_mixer_to_voice(mixer, voice))
return 1;
#else
if( al_install_audio() )
{
if( al_init_acodec_addon() )
{
voice = al_create_voice(44100, ALLEGRO_AUDIO_DEPTH_INT16, ALLEGRO_CHANNEL_CONF_2);
if( voice != 0 )
{
mixer = al_create_mixer(44100, ALLEGRO_AUDIO_DEPTH_FLOAT32, ALLEGRO_CHANNEL_CONF_2);
if( mixer != 0 )
al_attach_mixer_to_voice(mixer, voice);
}
}
}
#endif // EXIT_IF_NO_AUDIO
// Random number is guarenteed to be random
srand( 5 );
GameStack = new StageStack();
CurrentConfiguration = new Configuration();
if( CurrentConfiguration->FullScreen )
al_set_new_display_flags( ALLEGRO_FULLSCREEN_WINDOW );
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
bool foundMode = false;
int fallbackW = 640;
int fallbackH = 480;
if( CurrentConfiguration->ForceResolution )
{
foundMode = true;
} else {
for( int modeIdx = 0; modeIdx < al_get_num_display_modes(); modeIdx++ )
{
if( al_get_display_mode( modeIdx, &ScreenMode ) != NULL )
{
if( ScreenMode.width == CurrentConfiguration->ScreenWidth && ScreenMode.height == CurrentConfiguration->ScreenHeight )
{
foundMode = true;
} else {
fallbackW = ScreenMode.width;
fallbackH = ScreenMode.height;
}
}
if( foundMode )
break;
}
}
if( foundMode )
{
Screen = al_create_display( CurrentConfiguration->ScreenWidth, CurrentConfiguration->ScreenHeight );
} else {
Screen = al_create_display( fallbackW, fallbackH );
CurrentConfiguration->ScreenWidth = fallbackW;
CurrentConfiguration->ScreenHeight = fallbackH;
}
al_hide_mouse_cursor( Screen );
t = al_create_timer( 1.0 / SCREEN_FPS );
if( t == NULL )
Quit = true;
al_start_timer( t );
EventQueue = al_create_event_queue();
al_register_event_source( EventQueue, al_get_display_event_source( Screen ) );
al_register_event_source( EventQueue, al_get_keyboard_event_source() );
al_register_event_source( EventQueue, al_get_mouse_event_source() );
al_register_event_source( EventQueue, al_get_timer_event_source( t ) );
#if NETWORK_SUPPORT != 0
al_register_event_source( EventQueue, get_network_event_source() );
#endif
#if HTTP_SUPPORT
Downloads->urlDownloads = CurrentConfiguration->MaxConcurrentDownloads;
al_register_event_source( EventQueue, get_http_event_source() );
#endif
Fonts = new FontManager();
Images = new ImageManager();
Audio = new SoundManager();
al_set_blender( ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA );
GameStack->Push( (Stage*)new BootUp() );
while( !Quit )
{
if( GameStack->IsEmpty() )
{
Quit = true;
} else {
while( al_get_next_event( EventQueue, &e ) )
{
#if HTTP_SUPPORT
Downloads->Event( &e );
#endif
switch( e.type )
{
case ALLEGRO_EVENT_DISPLAY_CLOSE:
Quit = true;
break;
case ALLEGRO_EVENT_JOYSTICK_CONFIGURATION:
al_reconfigure_joysticks();
break;
case ALLEGRO_EVENT_TIMER:
if( e.timer.source == t )
framesToUpdate++;
else if( !GameStack->IsEmpty() )
GameStack->Current()->Event( &e );
break;
default:
if( !GameStack->IsEmpty() )
GameStack->Current()->Event( &e );
switch( e.type )
{
#if HTTP_SUPPORT
case ALLEGRO_EVENT_HTTP:
#endif
#if NETWORK_SUPPORT
case ALLEGRO_EVENT_NETWORK_CONNECTION:
case ALLEGRO_EVENT_NETWORK_RECEIVEPACKET:
case ALLEGRO_EVENT_NETWORK_DISCONNECTION:
#endif
case ALLEGRO_EVENT_BUTTON_CLICK:
case ALLEGRO_EVENT_MOUSEEX_MOVE:
case ALLEGRO_EVENT_MOUSEEX_DOWN:
case ALLEGRO_EVENT_MOUSEEX_UP:
case ALLEGRO_EVENT_MOUSEEX_CLICK:
case ALLEGRO_EVENT_MOUSEEX_DOUBLECLICK:
case ALLEGRO_EVENT_MOUSEEX_BOXED:
case ALLEGRO_EVENT_MOUSEEX_WHEEL:
al_unref_user_event( &e.user );
break;
}
break;
}
}
if( framesToUpdate > 0 )
{
for( int frmUp = 0; frmUp < framesToUpdate; frmUp++ )
{
if( !GameStack->IsEmpty() )
GameStack->Current()->Update();
}
framesToUpdate = 0;
}
al_clear_to_color( al_map_rgb( 128, 128, 128 ) );
if( !GameStack->IsEmpty() )
GameStack->Current()->Render();
al_flip_display();
Images->Tidy();
Fonts->Tidy();
Audio->Tidy();
}
}
while( !GameStack->IsEmpty() )
{
GameStack->Pop();
}
delete Downloads;
delete Fonts;
delete Images;
delete Audio;
al_destroy_event_queue( EventQueue );
al_destroy_display( Screen );
#if HTTP_SUPPORT
uninstall_http();
#endif
#if NETWORK_SUPPORT != 0
uninstall_network();
#endif
al_uninstall_keyboard();
al_uninstall_mouse();
al_shutdown_primitives_addon();
al_shutdown_ttf_addon();
al_shutdown_image_addon();
al_uninstall_audio();
al_shutdown_font_addon();
return 0;
}
int main( void ) {
ALLEGRO_DISPLAY *display;
ALLEGRO_KEYBOARD_STATE key_state;
Point stars[3][NUM_STARS/3];
float speeds[3] = { 0.0001f, 0.05f, 0.15f };
ALLEGRO_COLOR colors[3];
long start, now, elapsed, frame_count;
int total_frames = 0;
double program_start;
double length;
int layer, star;
if (!al_init()) {
abort_app("Could not init Allegro.\n");
return 1;
}
al_install_keyboard();
display = al_create_display(WIDTH, HEIGHT);
if (!display) {
abort_app("Could not create display.\n");
return 1;
}
colors[0] = al_map_rgba(255, 100, 255, 128);
colors[1] = al_map_rgba(255, 100, 100, 255);
colors[2] = al_map_rgba(100, 100, 255, 255);
for (layer = 0; layer < 3; layer++) {
for (star = 0; star < NUM_STARS/3; star++) {
Point *p = &stars[layer][star];
p->x = rand() % WIDTH;
p->y = rand() % HEIGHT;
}
}
start = al_get_time() * 1000;
now = start;
elapsed = 0;
frame_count = 0;
program_start = al_get_time();
while (1) {
if (frame_count < (1000/TARGET_FPS)) {
frame_count += elapsed;
}
else {
int X, Y;
frame_count -= (1000/TARGET_FPS);
al_clear_to_color(al_map_rgb(0, 0, 0));
for (star = 0; star < NUM_STARS/3; star++) {
Point *p = &stars[0][star];
al_draw_pixel(p->x, p->y, colors[0]);
}
al_lock_bitmap(al_get_backbuffer(display), ALLEGRO_PIXEL_FORMAT_ANY, 0);
for (layer = 1; layer < 3; layer++) {
for (star = 0; star < NUM_STARS/3; star++) {
Point *p = &stars[layer][star];
// put_pixel ignores blending
al_put_pixel(p->x, p->y, colors[layer]);
}
}
/* Check that dots appear at the window extremes. */
X = WIDTH - 1;
Y = HEIGHT - 1;
al_put_pixel(0, 0, al_map_rgb_f(1, 1, 1));
al_put_pixel(X, 0, al_map_rgb_f(1, 1, 1));
al_put_pixel(0, Y, al_map_rgb_f(1, 1, 1));
al_put_pixel(X, Y, al_map_rgb_f(1, 1, 1));
al_unlock_bitmap(al_get_backbuffer(display));
al_flip_display();
total_frames++;
}
now = al_get_time() * 1000;
elapsed = now - start;
start = now;
for (layer = 0; layer < 3; layer++) {
for (star = 0; star < NUM_STARS/3; star++) {
Point *p = &stars[layer][star];
p->y -= speeds[layer] * elapsed;
if (p->y < 0) {
p->x = rand() % WIDTH;
p->y = HEIGHT;
}
}
}
al_rest(0.001);
al_get_keyboard_state(&key_state);
if (al_key_down(&key_state, ALLEGRO_KEY_ESCAPE))
break;
}
length = al_get_time() - program_start;
if (length != 0) {
printf("%d FPS\n", (int)(total_frames / length));
}
al_destroy_display(display);
return 0;
}
int main(int argc, char const *argv[])
{
int i = 0;
int t = 1;
int n_mostros = 5;
bool click = false;
bool nova_horda = true;
bool render = false;
bool torre_mouse = false;
char a;
char b;
int r;
int l;
Sistema sistema;
Torre torre[10];
Tiro tiro[10];
Monstro monstro[n_mostros];
Coord coordenada[A*B];
//Declara�ao vair�veis allegro
ALLEGRO_DISPLAY *janela = NULL; //Vari�vel para a janela
ALLEGRO_EVENT_QUEUE *fila_eventos = NULL; // '' para eventos
ALLEGRO_BITMAP *imagem = NULL; // '' para imagem
ALLEGRO_TIMER *timer = NULL; // '' para o tempo (fps)
ALLEGRO_FONT *fonte = NULL; // '' para fonte
//Inicializa o allegro, mouse e add-ons
al_init();
al_install_mouse();
al_init_primitives_addon();
al_init_image_addon();
al_init_font_addon();
al_init_ttf_addon();
a_coord(coordenada, fonte);
init_horda(monstro, n_mostros);
init_system(sistema);
initTorre(torre, tiro, t-1);
//Atribui atributos às variáveis allegro
janela = al_create_display(LARGURA_TELA, ALTURA_TELA);
fila_eventos = al_create_event_queue();
imagem = al_load_bitmap("virus.png");
timer = al_create_timer(1.0 / fps);
fonte = al_load_font("arial.ttf", 12, 0); //Fonte DejaVu
//Inicializa o mouse e tempo
al_set_system_mouse_cursor(janela, ALLEGRO_SYSTEM_MOUSE_CURSOR_DEFAULT);
al_start_timer(timer);
al_install_keyboard();
init_fail(janela, fonte, fila_eventos, imagem, timer); //Fun�ao de teste
//Regista os eventos da janela, mouse e timer na vari�vel de eventos (fila_eventos)
al_register_event_source(fila_eventos, al_get_display_event_source(janela));
al_register_event_source(fila_eventos, al_get_mouse_event_source());
al_register_event_source(fila_eventos, al_get_keyboard_event_source());
al_register_event_source(fila_eventos, al_get_timer_event_source(timer));
al_clear_to_color(al_map_rgb(235, 235, 235)); //Limpa a tela
al_flip_display(); //Atualiza a tela
//Loop principal
while (!GameOver)
{
ALLEGRO_EVENT evento; //Variavel para eventos
al_wait_for_event(fila_eventos, &evento);
if(evento.type == ALLEGRO_EVENT_TIMER) //Evento de renderiza�ao
{
i++;
render = true;
FireTiro(tiro, torre, monstro, t-1);
UpdateTiro(tiro, monstro, t-1);
update_horda(monstro, mapa, n_mostros);
colisao_horda(tiro, monstro, n_mostros);
}
if (evento.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
GameOver = true;
}
else if(evento.type == ALLEGRO_EVENT_MOUSE_AXES)
{
pos_x = evento.mouse.x;
pos_y = evento.mouse.y;
a = coordenada[(pos_x/l_celula)].letra[0];
b = coordenada[(pos_x/l_celula)].letra[1];
l = coordenada[(pos_y/a_celula)].numero;
r = conversao_coordenadas(coordenada, a, b);
}
else if(evento.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN)
{
if (mapa[pos_y/a_celula][pos_x/l_celula] == 9)
{
torre_mouse = true;
torre[t].in_mouse = true;
}
if(torre_mouse && !click)
{
if (mapa[pos_y/a_celula][pos_x/l_celula] != 9)
{
mapa[pos_y/a_celula][pos_x/l_celula] = 10;
torre_mouse = false;
torre[t].in_mouse = false;
t++;
}
}
click = !click;
}
else if(evento.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch(evento.keyboard.keycode)
{
case ALLEGRO_KEY_SPACE:
start_horda(monstro, n_mostros);
break;
}
}
else if(render && al_is_event_queue_empty(fila_eventos))
{
render = false;
coor_matrix(mapa, coordenada, fonte);
al_draw_textf(fonte, al_map_rgb(0, 0, 0), LARGURA_TELA/4, 50, ALLEGRO_ALIGN_CENTRE, "Taxa de Frames: %i", i);
al_draw_textf(fonte, al_map_rgb(0, 0, 0), pos_x, pos_y, ALLEGRO_ALIGN_LEFT, " x:%i y:%i", pos_x, pos_y);
draw_horda(monstro, n_mostros, imagem);
if(torre_mouse)
{
draw_tower(r, l, torre, t);
}
drawTiro(tiro, t-1);
al_flip_display();
al_clear_to_color(al_map_rgb(255,255,255));
}
}
destroy_al(janela, fonte, fila_eventos, imagem, timer); //Destroi as vari�veis allegro
return 0;
}
int main(void)
{
//variables
int width = 640;
int height = 480;
bool done = false;
int x = width / 2;
int y = height / 2;
const int maxFrame = 8;
int curFrame = 0;
int frameCount = 0;
int frameDelay = 5;
//allegro variable
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer;
ALLEGRO_BITMAP *image[maxFrame];
//program init
if (!al_init()) //initialize Allegro
return -1;
display = al_create_display(width, height); //create our display object
if (!display) //test display object
return -1;
//addon init
al_install_keyboard();
al_init_image_addon();
image[0] = al_load_bitmap("./images/dragon/fliegt e0000.bmp");
image[1] = al_load_bitmap("./images/dragon/fliegt e0001.bmp");
image[2] = al_load_bitmap("./images/dragon/fliegt e0002.bmp");
image[3] = al_load_bitmap("./images/dragon/fliegt e0003.bmp");
image[4] = al_load_bitmap("./images/dragon/fliegt e0004.bmp");
image[5] = al_load_bitmap("./images/dragon/fliegt e0005.bmp");
image[6] = al_load_bitmap("./images/dragon/fliegt e0006.bmp");
image[7] = al_load_bitmap("./images/dragon/fliegt e0007.bmp");
for (int i = 0; i < maxFrame; i++)
al_convert_mask_to_alpha(image[i], al_map_rgb(106, 76, 48));
event_queue = al_create_event_queue();
timer = al_create_timer(1.0 / 60);
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_start_timer(timer);
while (!done)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if (ev.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch (ev.keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
done = true;
break;
case ALLEGRO_KEY_LEFT:
break;
case ALLEGRO_KEY_RIGHT:
break;
case ALLEGRO_KEY_UP:
break;
case ALLEGRO_KEY_DOWN:
break;
}
}
else if (ev.type == ALLEGRO_EVENT_TIMER)
{
if (++frameCount >= frameDelay)
{
if (++curFrame >= maxFrame)
curFrame = 0;
frameCount = 0;
}
}
al_draw_bitmap(image[curFrame], x, y, 0);
al_flip_display();
al_clear_to_color(al_map_rgb(0, 0, 0));
}
for (int i = 0; i < maxFrame; i++)al_destroy_bitmap(image[i]);
al_destroy_event_queue(event_queue);
al_destroy_display(display); //destroy our display object
return 0;
}
int main(void)
{
ALLEGRO_TIMER *timer;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_MONITOR_INFO info;
int w = 640, h = 480;
bool done = false;
bool need_redraw = true;
bool background = false;
if (!al_init()) {
abort_example("Failed to init Allegro.\n");
return 1;
}
if (!al_init_image_addon()) {
abort_example("Failed to init IIO addon.\n");
return 1;
}
al_init_font_addon();
if (!al_init_ttf_addon()) {
abort_example("Failed to init TTF addon.\n");
return 1;
}
al_get_num_video_adapters();
al_get_monitor_info(0, &info);
#ifdef ALLEGRO_IPHONE
al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
#endif
al_set_new_display_option(ALLEGRO_SUPPORTED_ORIENTATIONS,
ALLEGRO_DISPLAY_ORIENTATION_ALL, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_DEPTH_SIZE, 8, ALLEGRO_SUGGEST);
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
example.display = al_create_display(w, h);
if (!example.display) {
abort_example("Error creating display.\n");
return 1;
}
if (!al_install_keyboard()) {
abort_example("Error installing keyboard.\n");
return 1;
}
example.font = al_load_font("data/DejaVuSans.ttf", 40, 0);
if (!example.font) {
abort_example("Error loading data/DejaVuSans.ttf\n");
return 1;
}
example.font2 = al_load_font("data/DejaVuSans.ttf", 12, 0);
if (!example.font2) {
abort_example("Error loading data/DejaVuSans.ttf\n");
return 1;
}
example.mysha = al_load_bitmap("data/mysha.pcx");
if (!example.mysha) {
abort_example("Error loading data/mysha.pcx\n");
return 1;
}
example.obp = al_load_bitmap("data/obp.jpg");
if (!example.obp) {
abort_example("Error loading data/obp.jpg\n");
return 1;
}
init();
timer = al_create_timer(1.0 / FPS);
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_timer_event_source(timer));
al_register_event_source(queue, al_get_display_event_source(example.display));
al_start_timer(timer);
while (!done) {
ALLEGRO_EVENT event;
w = al_get_display_width(example.display);
h = al_get_display_height(example.display);
if (!background && need_redraw && al_is_event_queue_empty(queue)) {
double t = -al_get_time();
redraw();
t += al_get_time();
example.direct_speed_measure = t;
al_flip_display();
need_redraw = false;
}
al_wait_for_event(queue, &event);
switch (event.type) {
case ALLEGRO_EVENT_KEY_CHAR:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
done = true;
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
done = true;
break;
case ALLEGRO_EVENT_DISPLAY_HALT_DRAWING:
background = true;
al_acknowledge_drawing_halt(event.display.source);
break;
case ALLEGRO_EVENT_DISPLAY_RESUME_DRAWING:
background = false;
break;
case ALLEGRO_EVENT_DISPLAY_RESIZE:
al_acknowledge_resize(event.display.source);
break;
case ALLEGRO_EVENT_TIMER:
update();
need_redraw = true;
break;
}
}
return 0;
}
void engine_run(struct State *first)
{
int redraw = FALSE;
if (engine_active)
{
puts("WARNING: Calling game_run() more than once");
return;
}
change_state(first);
// Generate display events
al_register_event_source(engine.event_queue,
al_get_display_event_source(engine.display));
// Timer events
al_register_event_source(engine.event_queue,
al_get_timer_event_source(engine.timer));
// Keyboard events
al_register_event_source(engine.event_queue, al_get_keyboard_event_source());
al_start_timer(engine.timer);
engine_active = TRUE;
// Main game loop
while (engine_active)
{
ALLEGRO_EVENT event;
al_wait_for_event(engine.event_queue, &event);
// Event processing
engine.states[current_state]->_events(&event);
// If the close button was pressed...
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
engine_active = FALSE;
break;
}
else if (event.type == ALLEGRO_EVENT_KEY_DOWN)
{
keys[event.keyboard.keycode] = TRUE;
// Escape key will end the game
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
{
engine_active = FALSE;
break;
}
}
else if (event.type == ALLEGRO_EVENT_KEY_UP)
{
keys[event.keyboard.keycode] = FALSE;
}
else if (event.type == ALLEGRO_EVENT_TIMER)
{
engine.states[current_state]->_update();
redraw = TRUE;
}
if (redraw && al_event_queue_is_empty(engine.event_queue))
{
redraw = FALSE;
al_set_target_backbuffer(engine.display);
al_clear_to_color(engine.bg_color);
engine.states[current_state]->_draw();
al_flip_display();
}
}
while (current_state >= 0)
{
engine.states[current_state--]->_end();
}
al_destroy_display(engine.display);
al_destroy_timer(engine.timer);
al_destroy_event_queue(engine.event_queue);
al_destroy_font(font);
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_BITMAP *tapl = NULL;
ALLEGRO_BITMAP *tapr = NULL;
ALLEGRO_BITMAP *bounce = NULL;
float tapl_x = 0.0;
float tapl_y = SCREEN_H / 2.0 - TAP_HEIGHT / 2.0;
float tapr_x = SCREEN_W - TAP_WIDTH - 1.0;
float tapr_y = SCREEN_H / 2.0 - TAP_HEIGHT / 2.0;
float bounce_x = SCREEN_W / 2.0 - BOUNCE_SIZE / 2.0;
float bounce_y = SCREEN_H / 2.0 - BOUNCE_SIZE / 2.0;
float bounce_dx = -4.0, bounce_dy = 4.0;
bool key[6] = { false, false, false, false, false, false };
bool redraw = true;
bool doexit = false;
if(!al_init()) { //iniciando o allegro
fprintf(stderr, "failed to initialize allegro!\n");
return -1;
}
if(!al_install_keyboard()) { //instalando o teclado
fprintf(stderr, "failed to initialize the keyboard!\n");
return -1;
}
timer = al_create_timer(1.0 / FPS); //criando temporizador (FPS)
display = al_create_display(SCREEN_W, SCREEN_H); //criando o display
tapl = al_create_bitmap(TAP_WIDTH, TAP_HEIGHT); //criando o rebatedor esquerdo (vermelho)
tapr = al_create_bitmap(TAP_WIDTH, TAP_HEIGHT); //criando o rebatedor direito (azul)
bounce = al_create_bitmap(BOUNCE_SIZE, BOUNCE_SIZE); //criando a bounce (branco)
//setando cores dos bitmaps
al_set_target_bitmap(tapl); //setando o target pro rebatedor esquerdo
al_clear_to_color(al_map_rgb(255, 0, 0)); //setando a cor do target (rebatedor esquerdo)
al_set_target_bitmap(tapr); //setando o target pro rebatedor direito
al_clear_to_color(al_map_rgb(0, 0, 255)); //setando a cor do target (rebatedor direito)
al_set_target_bitmap(bounce); //setando o target pra bounce
al_clear_to_color(al_map_rgb(255, 255, 255)); //setando a cor do target
al_set_target_bitmap(al_get_backbuffer(display)); //setando o target pro display
event_queue = al_create_event_queue(); //iniciando o leitor de eventos
al_register_event_source(event_queue, al_get_display_event_source(display)); //registrando os eventos do display
al_register_event_source(event_queue, al_get_timer_event_source(timer)); //registrando os eventos do temporizador
al_register_event_source(event_queue, al_get_keyboard_event_source()); //registrando os eventos do teclado
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
al_start_timer(timer);
while(!doexit) {
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if(key[KEY_ENTER]) {
redraw = true;
}
if(key[KEY_P]) {
redraw = false;
}
if(ev.type == ALLEGRO_EVENT_TIMER) {
if(redraw == true){
if(
bounce_x - bounce_dx < tapl_x + (TAP_WIDTH + 14.0)&&
bounce_x + bounce_dx > tapl_x - TAP_WIDTH &&
bounce_y - bounce_dy < tapl_y + TAP_HEIGHT &&
bounce_y + bounce_dy > tapl_y - TAP_HEIGHT
)
{
bounce_dx = bounce_dx + 1;
}
if(
bounce_x - bounce_dx < tapr_x + (TAP_WIDTH + 0.0)&&
bounce_x + bounce_dx > tapr_x - (TAP_WIDTH + 15.0)&&
bounce_y - bounce_dy < tapr_y + TAP_HEIGHT &&
bounce_y + bounce_dy > tapr_y - TAP_HEIGHT
)
{
bounce_dx -= 11;
}
if(bounce_x < 0) {
al_destroy_timer(timer);
}
if(bounce_x > SCREEN_W - BOUNCE_SIZE) {
al_destroy_timer(timer);
}
if(bounce_y < 0 || bounce_y > SCREEN_H - BOUNCE_SIZE) { //aqui rebate normal no eixo da altura
bounce_dy = -bounce_dy;
}
bounce_x += bounce_dx;
bounce_y += bounce_dy;
if(key[KEY_W] && tapl_y >= 4.0) {
tapl_y -= 4.0;
}
if(key[KEY_S] && tapl_y <= SCREEN_H - TAP_HEIGHT - 4.0) {
tapl_y += 4.0;
}
if(key[KEY_UP] && tapr_y >= 4.0) {
tapr_y -= 4.0;
}
if(key[KEY_DOWN] && tapr_y <= SCREEN_H - TAP_HEIGHT - 4.0) {
tapr_y += 4.0;
}
}
}
else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
else if(ev.type == ALLEGRO_EVENT_KEY_DOWN) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_W:
key[KEY_W] = true;
break;
case ALLEGRO_KEY_S:
key[KEY_S] = true;
break;
case ALLEGRO_KEY_UP:
key[KEY_UP] = true;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = true;
break;
case ALLEGRO_KEY_P:
key[KEY_ENTER] = false;
key[KEY_P] = true;
break;
case ALLEGRO_KEY_ENTER:
key[KEY_P] = false;
key[KEY_ENTER] = true;
break;
}
}
else if(ev.type == ALLEGRO_EVENT_KEY_UP) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_W:
key[KEY_W] = false;
break;
case ALLEGRO_KEY_S:
key[KEY_S] = false;
break;
case ALLEGRO_KEY_UP:
key[KEY_UP] = false;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = false;
break;
case ALLEGRO_KEY_ESCAPE:
doexit = true;
break;
}
}
if(redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
al_clear_to_color(al_map_rgb(0,0,0));
al_draw_bitmap(tapl, tapl_x, tapl_y, 0);
al_draw_bitmap(tapr, tapr_x, tapr_y, 0);
al_draw_bitmap(bounce, bounce_x, bounce_y, 0);
al_flip_display();
}
}
al_destroy_bitmap(tapl);
al_destroy_bitmap(tapr);
al_destroy_bitmap(bounce);
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
return 0;
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_BITMAP *bouncer = NULL;
float angle = 0;
float length = 0;
float vel_x, vel_y;
float bouncer_x = SCREEN_W / 2.0 - BOUNCER_SIZE_Y / 2.0;
float bouncer_y = SCREEN_H / 2.0 - BOUNCER_SIZE_Y / 2.0;
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;
}
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_X,BOUNCER_SIZE_Y);
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(0, 0, 0));
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());
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
al_start_timer(timer);
while(!doexit)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_TIMER) {
if(key[KEY_UP] && length < 15) {
length += 1;
}
else if(length > 0) {
length -= 0.1;
}
if(key[KEY_DOWN] && length > 0) {
length -= 1;
}
if(key[KEY_LEFT]) {
angle = (angle - 0.1);
}
if(key[KEY_RIGHT]) {
angle = (angle + 0.1);
}
if(key[KEY_SPACE]) {
}
vel_x = length * cos(angle);
vel_y = length * sin(angle);
bouncer_x += vel_x;
bouncer_y += vel_y;
redraw = true;
}
else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
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_SPACE:
key[KEY_SPACE] = 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_SPACE:
key[KEY_SPACE] = false;
break;
case ALLEGRO_KEY_ESCAPE:
doexit = true;
break;
}
}
if(redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
al_clear_to_color(al_map_rgb(240,240,240));
al_draw_rotated_bitmap(bouncer, BOUNCER_SIZE_X / 2, BOUNCER_SIZE_Y / 2, bouncer_x, bouncer_y, angle, angle);
al_flip_display();
}
}
al_destroy_bitmap(bouncer);
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
return 0;
}
void gui_window_update (int lifes)
{
gui_river_heart(lifes);
al_flip_display();
}
void gdp_intro(){
ALLEGRO_BITMAP *image = NULL;
ALLEGRO_FONT *fonte = al_load_font(".//Fonts//font_intro.TTF", 20, 0);
// musica de fundo
ALLEGRO_SAMPLE *music = al_load_sample(".//Songs//Intro//intro_music.ogg");
al_play_sample(music, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_LOOP, NULL);
// narrador
ALLEGRO_SAMPLE *narrative = al_load_sample(".//Songs//Intro//intro_narrative.ogg");
al_play_sample(narrative, 2.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, NULL);
char* ConfigFile = "Configs//Intro.txt";
char* mold = "lin%i";
char* cLine = NULL, *cLineAux=NULL;
double speed = gdp_files_quick_getfloat(ConfigFile,"speed_text");
int space = 45, xi=0, i=0;
int lines = gdp_files_quick_getint(ConfigFile,"num_lines");
char **texto = calloc(lines,sizeof(char*));
double posicao = 0,limite = -height-(space*lines);
for(xi=0;xi<lines;xi++)
{
cLine = calloc(10,sizeof(char*));
sprintf(cLine,mold,xi+1);
cLineAux = gdp_files_quick_getstring(ConfigFile, cLine);
texto[xi] = cLineAux;
free(cLine);
}
while(true){
al_wait_for_event(event_queue, &evento);
if(gdp_readclose()){
break;
}
if(evento.type == ALLEGRO_EVENT_KEY_DOWN){
break;
}
if(gdp_readtime() && al_is_event_queue_empty(event_queue)){
gdp_clear();
for(i=0;i<lines;i++)
al_draw_textf(fonte, al_map_rgb(255, 255, 255), wigth / 2, (int)height+posicao+(space*i) ,ALLEGRO_ALIGN_CENTRE, "%s", texto[i]);
al_flip_display();
posicao -= speed;
if(posicao < limite)
break;
}
}
free(texto);
al_destroy_bitmap(image);
al_destroy_sample(music);
al_destroy_sample(narrative);
al_destroy_font(fonte);
}
void Pause_Menu::show()
{
bool paused = true;
while (paused)
{
this->draw();
al_flip_display();
ALLEGRO_EVENT e;
al_wait_for_event(m_event, &e);
if (e.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch(m_controls->get_control(e.keyboard.keycode))
{
case Controls::NONE:
break;
case Controls::PLAYER_1_LEFT:
case Controls::PLAYER_2_LEFT:
case Controls::PLAYER_3_LEFT:
case Controls::PLAYER_4_LEFT:
if (m_selection == 1)
{
if (m_move_sound_down) al_play_sample(m_move_sound_down, 2.5*m_sound_effects_level*0.1, 0.0, 1.2, ALLEGRO_PLAYMODE_ONCE, NULL);
m_selection = 0;
}
break;
case Controls::PLAYER_1_RIGHT:
case Controls::PLAYER_2_RIGHT:
case Controls::PLAYER_3_RIGHT:
case Controls::PLAYER_4_RIGHT:
if (m_selection == 0)
{
if (m_move_sound_up) al_play_sample(m_move_sound_down, 2.5*m_sound_effects_level*0.1, 0.0, 1.2, ALLEGRO_PLAYMODE_ONCE, NULL);
m_selection = 1;
}
break;
case Controls::PLAYER_1_CONFIRM:
case Controls::PLAYER_2_CONFIRM:
case Controls::PLAYER_3_CONFIRM:
case Controls::PLAYER_4_CONFIRM:
if (m_move_sound_up) al_play_sample(m_move_sound_down, 2.5*m_sound_effects_level*0.1, 0.0, 1.5, ALLEGRO_PLAYMODE_ONCE, NULL);
if (m_selection == 0) //No
paused = false;
else //Yes
{
paused = false;
*m_quit = true;
*m_hide_standing = true;
*m_rounds = m_total_rounds;
}
break;
case Controls::PLAYER_1_CANCEL:
case Controls::PLAYER_2_CANCEL:
case Controls::PLAYER_3_CANCEL:
case Controls::PLAYER_4_CANCEL:
paused = false;
break;
default:
break;
}
}
}
}
int main(int argc, char *argv[])
{
// -------- VARIÁVEIS DO JOGO --------
ALLEGRO_EVENT_QUEUE *fila_eventos = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_FONT *font20 = NULL;
ALLEGRO_SAMPLE *ataque = NULL;
ALLEGRO_SAMPLE *morte_inimigo = NULL;
ALLEGRO_SAMPLE *morte_personagem = NULL;
ALLEGRO_SAMPLE *hit = NULL;
ALLEGRO_SAMPLE *item = NULL;
ALLEGRO_AUDIO_STREAM *musica = NULL;
ALLEGRO_AUDIO_STREAM *track_menu = NULL;
ALLEGRO_BITMAP *start = NULL;
bool fim = false;
bool menu = true;
int flag = 0;
bool desenha = true;
bool game_over = false;
bool teclas[] = {false, false, false, false, false, false, false};
int i;
int dificuldade;
// ___________________________________
// -------- INICIALIZAÇÃO DE OBJETOS --------
dificuldade = 0;
Personagem personagem_principal;
Projetil* balas = new Projetil [NUM_BALAS];
Projetil* balas_2 = new Projetil [NUM_BALAS];
Inimigo* inimigos = new Inimigo[NUM_INIMIGOS];
Inimigo* inimigos2 = new Inimigo [NUM_INIMIGOS];
Coracao* coracoes = new Coracao[NUM_ITENS];
Speed* speed = new Speed[NUM_ITENS];
ItemPontos* pontos = new ItemPontos[NUM_ITENS];
Estrelas estrelas_pf[NUM_PLANOS][NUM_ESTRELAS];
Selecionar select;
// __________________________________________
// -------- INICIALIZAÇÃO DA ALLEGRO E DO DISPLAY --------
ALLEGRO_DISPLAY *display = NULL;
if (!al_init())
{
al_show_native_message_box(NULL, "AVISO!", "ERRO!", "ERRO AO INICIALIZAR A ALLEGRO!", NULL, ALLEGRO_MESSAGEBOX_ERROR);
return -1;
}
display = al_create_display(LARGURA_T, ALTURA_T);
if (!display)
{
al_show_native_message_box(NULL, "AVISO!", "ERRO!", "ERRO AO CRIAR O DISPLAY!", NULL, ALLEGRO_MESSAGEBOX_ERROR);
return -1;
}
al_set_window_title(display, "Cosmos Guardian");
// ____________________________________________________
// -------- INICIALIZAÇÃO DE ADDONS E INSTALAÇÕES --------
al_init_primitives_addon();
al_install_keyboard();
al_init_image_addon();
al_init_font_addon();
al_init_ttf_addon();
al_install_audio();
al_init_acodec_addon();
al_reserve_samples(100);
// _______________________________________________________
// -------- CRIAÇÃO DE FILAS E DEMAIS DISPOSITIVOS --------
fila_eventos = al_create_event_queue();
timer = al_create_timer(1.0 / FPS);
font20 = al_load_font("BADABB__.ttf", 20, 0);
// ________________________________________________________
// -------- REGISTRO DE SOURCES --------
al_register_event_source(fila_eventos, al_get_display_event_source(display));
al_register_event_source(fila_eventos, al_get_keyboard_event_source());
al_register_event_source(fila_eventos, al_get_timer_event_source(timer));
// _____________________________________
// -------- FUNÇÕES INICIAIS --------
srand(time(NULL));
personagem_principal.InitPersonagem();
select.InitSelecionar();
//Inicialização de projeteis
for (i = 0; i < NUM_BALAS; i++)
{
balas[i].InitBalas();
balas_2[i].InitBalas();
}
//Inicialização de inimigos
for (i = 0; i < NUM_INIMIGOS; i++)
{
inimigos[i].InitInimigo(7, 46, 85, 1 , 0);
inimigos2[i].InitInimigo(3, 55, 94, 3, 0);
}
//Inicialização de itens
for (i = 0; i < NUM_ITENS; i++)
{
coracoes[i].InitItem();
speed[i].InitItem();
pontos[i].InitItem();
}
//Inicialização do Plano de Fundo
InitPlanoFundo(estrelas_pf, NUM_PLANOS, NUM_ESTRELAS);
//Setando Sons e Imagens
select.bmp = al_load_bitmap("select.png");
ataque = al_load_sample("laser.wav");
morte_inimigo = al_load_sample("dead.wav");
morte_personagem = al_load_sample("death.wav");
hit = al_load_sample("hit.wav");
item = al_load_sample("item.wav");
musica = al_load_audio_stream("trilha_sonora.ogg", 4, 1024);
track_menu = al_load_audio_stream("menu.ogg", 4, 1024);
personagem_principal.bmp = al_load_bitmap("ship.png");
for (i = 0; i < NUM_BALAS; i++)
{
balas[i].bmp = al_load_bitmap("bala.png");
balas_2[i].bmp = al_load_bitmap("bala.png");
}
for (i = 0; i < NUM_INIMIGOS; i++){
inimigos[i].bmp = al_load_bitmap("enemyRed.png");
inimigos2[i].bmp = al_load_bitmap("enemyWhite.png");
}
start = al_load_bitmap("start.jpg");
for (i = 0; i < NUM_ITENS; i++){
coracoes[i].imagem = al_load_bitmap("heart.png");
speed[i].imagem = al_load_bitmap("speed.png");
pontos[i].imagem = al_load_bitmap("pontos.png");
}
// __________________________________
// ----------------- LOOP PRINCIPAL -----------------
al_start_timer(timer);
while(!fim)
{
ALLEGRO_EVENT ev;
al_wait_for_event(fila_eventos, &ev);
// -------- EVENTOS E LÓGICA DO JOGO --------
if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
fim = true;
}
else if(ev.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch(ev.keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
fim = true;
break;
case ALLEGRO_KEY_UP:
teclas[CIMA] = true;
break;
case ALLEGRO_KEY_DOWN:
teclas[BAIXO] = true;
break;
case ALLEGRO_KEY_LEFT:
teclas[ESQUERDA] = true;
break;
case ALLEGRO_KEY_RIGHT:
teclas[DIREITA] = true;
break;
case ALLEGRO_KEY_SPACE:
teclas[ESPACO] = true;
AtiraBalas(balas, NUM_BALAS, personagem_principal, personagem_principal.y + 12);
AtiraBalas(balas_2, NUM_BALAS, personagem_principal, personagem_principal.y + 70);
al_play_sample(ataque, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, NULL);
break;
case ALLEGRO_KEY_ENTER:
teclas[ENTER] = true;
break;
case ALLEGRO_KEY_BACKSPACE:
teclas[BACKSPACE] = true;
break;
}
}
else if (ev.type == ALLEGRO_EVENT_KEY_UP)
{
switch(ev.keyboard.keycode)
{
case ALLEGRO_KEY_UP:
teclas[CIMA] = false;
break;
case ALLEGRO_KEY_DOWN:
teclas[BAIXO] = false;
break;
case ALLEGRO_KEY_LEFT:
teclas[ESQUERDA] = false;
break;
case ALLEGRO_KEY_RIGHT:
teclas[DIREITA] = false;
break;
case ALLEGRO_KEY_ENTER:
teclas[ENTER] = false;
break;
case ALLEGRO_KEY_BACKSPACE:
teclas[BACKSPACE] = false;
break;
}
}
else if (ev.type == ALLEGRO_EVENT_TIMER)
{
desenha = true;
if (teclas[CIMA])
personagem_principal.MoveCima();
if (teclas[BAIXO])
personagem_principal.MoveBaixo(ALTURA_T);
if (teclas[ESQUERDA])
personagem_principal.MoveEsquerda();
if (teclas[DIREITA])
personagem_principal.MoveDireita(LARGURA_T);
if (teclas[ESPACO])
{
for (i = 0; i < NUM_BALAS; i++)
{
balas[i].AtualizaBalas(0);
balas_2[i].AtualizaBalas(0);
}
}
// Movimentação no menu
if(menu)
{
al_attach_audio_stream_to_mixer(track_menu, al_get_default_mixer());
al_set_audio_stream_playing(track_menu, true);
if (teclas[CIMA] && select.y!=235)
select.y -= 70;
if (teclas[BAIXO] && select.y!=305)
select.y += 70;
if (teclas[ENTER] && select.y==235)
{
menu = false;
al_set_audio_stream_playing(track_menu, false);
}
}
// Acontecimentos do Jogo
if(!game_over && !menu)
{
al_attach_audio_stream_to_mixer(musica, al_get_default_mixer());
al_set_audio_stream_playing(musica, true);
AtualizaPlanoFundo(estrelas_pf, NUM_PLANOS, NUM_ESTRELAS);
{
//Gera e atualiza inimigos
for (i = 0; i < NUM_INIMIGOS; i++)
{
inimigos[i].GeraInimigos();
inimigos2[i].GeraInimigos();
inimigos[i].AtualizaInimigos();
inimigos[i].InimigoColidido(personagem_principal, hit);
inimigos2[i].AtualizaInimigos();
inimigos2[i].InimigoColidido(personagem_principal, hit);
}
}
//Checa colisões de projeteis
BalaColidida(balas, NUM_BALAS, inimigos, NUM_INIMIGOS, personagem_principal, dificuldade, morte_inimigo);
BalaColidida(balas_2, NUM_BALAS, inimigos, NUM_INIMIGOS, personagem_principal, dificuldade, morte_inimigo);
BalaColidida(balas, NUM_BALAS, inimigos2, NUM_INIMIGOS, personagem_principal, dificuldade, morte_inimigo);
BalaColidida(balas_2, NUM_BALAS, inimigos2, NUM_INIMIGOS, personagem_principal, dificuldade, morte_inimigo);
// Faz os testes relacionado aos itens
for (i = 0; i < NUM_ITENS; i++)
{
coracoes[i].GeraItens(inimigos[i]);
coracoes[i].AtualizaItens();
coracoes[i].ItemColidido(personagem_principal, item);
speed[i].GeraItens(inimigos[i]);
speed[i].AtualizaItens();
speed[i].ItemColidido(personagem_principal, item);
pontos[i].GeraItens(inimigos[i]);
pontos[i].AtualizaItens();
pontos[i].ItemColidido(personagem_principal, item);
}
if ((dificuldade+1)%16 == 0) // Dificuldade aumenta a cada 15 pontos.
{
for (i = 0; i < NUM_INIMIGOS; i++){
inimigos[i].velocidade++;
inimigos2[i].velocidade++;
}
dificuldade = 0;
}
if (personagem_principal.vidas <= 0)
{
al_play_sample(morte_personagem, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, NULL);
game_over = true;
}
}
// Reinicializa o jogo
else if (!menu)
{
al_set_audio_stream_playing(musica, false);
if (teclas[ENTER])
{
al_destroy_audio_stream(musica);
personagem_principal.InitPersonagem();
for (i = 0; i < NUM_BALAS; i++)
{
balas[i].InitBalas();
balas_2[i].InitBalas();
}
for (i = 0; i < NUM_INIMIGOS; i++)
{
inimigos[i].InitInimigo(7, 46, 85, 1 , 0);
inimigos2[i].InitInimigo(3, 55, 94, 3, 0);
}
for (i = 0; i < NUM_ITENS; i++)
{
coracoes[i].InitItem();
speed[i].InitItem();
pontos[i].InitItem();
}
personagem_principal.bmp = al_load_bitmap("ship.png");
musica = al_load_audio_stream("trilha_sonora.ogg", 4, 1024);
for (i = 0; i < NUM_BALAS; i++)
{
balas[i].bmp = al_load_bitmap("bala.png");
balas_2[i].bmp = al_load_bitmap("bala.png");
}
for (i = 0; i < NUM_INIMIGOS; i++)
{
inimigos[i].bmp = al_load_bitmap("enemyRed.png");
inimigos2[i].bmp = al_load_bitmap("enemyWhite.png");
coracoes[i].imagem = al_load_bitmap("heart.png");
speed[i].imagem = al_load_bitmap("heart.png");
}
game_over = false;
}
}
}
// _________________________________________
// ---------------- DESENHO ----------------
if(desenha && al_is_event_queue_empty(fila_eventos))
{
desenha = false;
// Desenhos da Tela do Menu
if(menu)
{
al_draw_bitmap(start, 0, 0, 0);
if (select.ativo)
al_draw_bitmap(select.bmp, select.x, select.y, 0);
if (teclas[ENTER] && flag == 0)
{
flag = 1;
teclas[BACKSPACE] = false;
select.ativo = false;
start = al_load_bitmap("como_jogar.jpg");
al_draw_bitmap(start, 0, 0, 0);
}
else if (teclas[BACKSPACE] && flag == 1)
{
flag = 0;
select.ativo = true;
start = al_load_bitmap("start.jpg");
al_draw_bitmap(start, 0, 0, 0);
}
}
// Jogo normal, desenho de todos os objetos
if(!game_over && !menu)
{
DesenhaPlanoFundo(estrelas_pf, NUM_PLANOS, NUM_ESTRELAS);
personagem_principal.DesenhaPersonagem();
for (i = 0; i < NUM_BALAS; i++)
{
balas[i].DesenhaBalas();
balas_2[i].DesenhaBalas();
}
for (i = 0; i < NUM_INIMIGOS; i++){
inimigos[i].DesenhaInimigos();
inimigos2[i].DesenhaInimigos();
}
for (i = 0; i < NUM_ITENS; i++)
{
coracoes[i].DesenhaItens();
speed[i].DesenhaItens();
pontos[i].DesenhaItens();
}
al_draw_textf(font20, al_map_rgb(255, 255, 255), 0, 0, 0, "VIDAS: %d / PONTOS: %d", personagem_principal.vidas, personagem_principal.pontos);
}
//Tela de fim de jogo
else if (!menu)
{
al_draw_textf(font20, al_map_rgb(255, 255, 255), LARGURA_T / 2, ALTURA_T / 2, ALLEGRO_ALIGN_CENTRE, "FIM DE JOGO. SEUS PONTOS FORAM: %d. TECLE ENTER PARA JOGAR NOVAMENTE OU ESC PARA SAIR DO JOGO.", personagem_principal.pontos);
}
al_flip_display();
al_clear_to_color(al_map_rgb(0, 0, 0));
}
// _________________________________________
}
// _________________________________________________
// -------- FINALIZAÇÕES DO PROGRAMA --------
delete[] inimigos;
delete[] inimigos2;
delete[] balas;
delete[] balas_2;
delete[] coracoes;
delete[] speed;
delete[] pontos;
al_destroy_bitmap(start);
al_destroy_sample(ataque);
al_destroy_sample(morte_inimigo);
al_destroy_sample(morte_personagem);
al_destroy_sample(hit);
al_destroy_sample(item);
al_destroy_audio_stream(musica);
al_destroy_audio_stream(track_menu);
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_font(font20);
al_destroy_event_queue(fila_eventos);
//___________________________________________
return 0;
}
int main(int argc, char **argv)
{
bool done = false;
bool render = false;
float gameTime = 0;
int frames = 0;
int gameFPS = 0;
float evTimer = 0;
tractor = new Tractor();
Xml = new xml();
int state = -1;
ALLEGRO_BITMAP *icon;
ALLEGRO_BITMAP *map = NULL;
ALLEGRO_BITMAP *panel = NULL;
ALLEGRO_BITMAP *tractorImage = NULL;
ALLEGRO_BITMAP *titleImage = NULL;
ALLEGRO_BITMAP *lostImage = NULL;
ALLEGRO_SAMPLE *titleSong = NULL;
ALLEGRO_SAMPLE *gameSong = NULL;
ALLEGRO_SAMPLE *lostSong = NULL;
ALLEGRO_SAMPLE *cash = NULL;
ALLEGRO_BITMAP *L1 = NULL;
ALLEGRO_BITMAP *L2 = NULL;
ALLEGRO_BITMAP *L3 = NULL;
ALLEGRO_BITMAP *L4 = NULL;
ALLEGRO_BITMAP *L5 = NULL;
ALLEGRO_BITMAP *L6 = NULL;
ALLEGRO_BITMAP *L7 = NULL;
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_DISPLAY_MODE disp_data;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer;
ALLEGRO_FONT *font;
ALLEGRO_FONT *score;
if (!al_init())
return -1;
al_install_keyboard();
al_install_mouse();
al_init_image_addon();
al_init_font_addon();
al_init_ttf_addon();
al_init_primitives_addon();
al_install_audio();
al_init_acodec_addon();
al_get_display_mode(al_get_num_display_modes() - 1, &disp_data);
//al_set_new_display_flags(ALLEGRO_FULLSCREEN);
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_REQUIRE);
display = al_create_display(disp_data.width, disp_data.height);
icon = al_load_bitmap("icon.png");
al_set_display_icon(display, icon);
float sx = (float)disp_data.width / WIDTH;
float sy = (float)disp_data.height / HEIGHT;
ALLEGRO_TRANSFORM trans;
al_identity_transform(&trans);
al_scale_transform(&trans, sx, sy);
al_use_transform(&trans);
if (!display)
return -1;
font = al_load_font("arial.ttf", 20, 0);
score = al_load_font("score.ttf", 45, 0);
al_reserve_samples(15);
map = al_load_bitmap("map2.png");
panel = al_load_bitmap("panel.png");
L1 = al_load_bitmap("l1.png");
L2 = al_load_bitmap("l2.png");
L3 = al_load_bitmap("l3.png");
L4 = al_load_bitmap("l4.png");
L5 = al_load_bitmap("l5.png");
L6 = al_load_bitmap("l6.png");
L7 = al_load_bitmap("l7.png");
Background *Map = new Background(map);
objects.push_back(Map);
TextBox *Task = new TextBox;
Field *field1 = new Field(L1, L2, L3, L4, L5, L6, L7, 50, 50);
objects.push_back(field1);
Field *field2 = new Field(L1, L2, L3, L4, L5, L6, L7, 450, 50);
objects.push_back(field2);
Field *field3 = new Field(L1, L2, L3, L4, L5, L6, L7, 50, 450);
objects.push_back(field3);
Field *field4 = new Field(L1, L2, L3, L4, L5, L6, L7, 450, 450);
objects.push_back(field4);
tractorImage = al_load_bitmap("tractor.png");
cash = al_load_sample("cash.ogg");
tractor->Init(tractorImage, cash);
objects.push_back(tractor);
titleImage = al_load_bitmap("screen_Title.png");
lostImage = al_load_bitmap("screen_Lost.png");
titleScreen = new Background(titleImage);
lostScreen = new Background(lostImage);
titleSong = al_load_sample("title.ogg");
gameSong = al_load_sample("game.ogg");
lostSong = al_load_sample("lost.ogg");
songInstance = al_create_sample_instance(titleSong);
al_set_sample_instance_playmode(songInstance, ALLEGRO_PLAYMODE_LOOP);
songInstance2 = al_create_sample_instance(gameSong);
al_set_sample_instance_playmode(songInstance2, ALLEGRO_PLAYMODE_LOOP);
songInstance3 = al_create_sample_instance(lostSong);
al_set_sample_instance_playmode(songInstance3, ALLEGRO_PLAYMODE_LOOP);
al_attach_sample_instance_to_mixer(songInstance, al_get_default_mixer());
al_attach_sample_instance_to_mixer(songInstance2, al_get_default_mixer());
al_attach_sample_instance_to_mixer(songInstance3, al_get_default_mixer());
ChangeState(state, TITLE);
event_queue = al_create_event_queue();
timer = al_create_timer(1.0 / 60);
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
al_start_timer(timer);
gameTime = al_current_time();
while (!done)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if (ev.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch (ev.keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
done = true;
break;
case ALLEGRO_KEY_LEFT:
keys[LEFT] = true;
break;
case ALLEGRO_KEY_RIGHT:
keys[RIGHT] = true;
break;
case ALLEGRO_KEY_UP:
keys[UP] = true;
break;
case ALLEGRO_KEY_DOWN:
keys[DOWN] = true;
break;
case ALLEGRO_KEY_ENTER:
keys[ENTER] = true;
if (state == TITLE)
ChangeState(state, PLAYING);
else if (state == PLAYING && Task->CheckText())
{
TextBox *text = new TextBox();
text->SetText(Task->Send());
history.push_back(text);
for (iter2 = history.begin(); iter2 != history.end(); iter2++)
{
if ((*iter2)->GetY() < 400)
{
delete (*iter2);
iter2 = history.erase(iter2);
}
(*iter2)->UpdateY();
}
Xml->interpreter(Task->GetLast(), tractor);
TextBox *txtxml = new TextBox();
txtxml->SetText(Xml->wyslij());
history.push_back(txtxml);
for (iter2 = history.begin(); iter2 != history.end(); iter2++)
{
if ((*iter2)->GetY() < 300)
{
delete (*iter2);
iter2 = history.erase(iter2);
}
(*iter2)->UpdateY();
}
}
else if (state == LOST)
ChangeState(state, PLAYING);
break;
case ALLEGRO_KEY_TAB:
keys[TAB] = true;
if (state == PLAYING)
{
Task->SetStatus();
if (Task->GetStatus())
{
TextBox *text = new TextBox();
text->SetText("Konsola zostala wlaczona");
history.push_back(text);
}
else
{
TextBox *text = new TextBox();
text->SetText("Konsola zostala wylaczona");
history.push_back(text);
}
for (iter2 = history.begin(); iter2 != history.end(); iter2++)
{
if ((*iter2)->GetY() < 300)
{
delete (*iter2);
iter2 = history.erase(iter2);
}
(*iter2)->UpdateY();
}
setTimer(evTimer);
}
tractor->Sell();
break;
case ALLEGRO_KEY_SPACE:
keys[SPC] = true;
if (state == PLAYING)
Task->Add(" ");
break;
case ALLEGRO_KEY_BACKSPACE:
if (state == PLAYING && Task->CheckText())
Task->Backspace();
break;
case ALLEGRO_KEY_COMMA:
keys[COM] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add(",");
break;
case ALLEGRO_KEY_0:
numb[N0] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("0");
break;
case ALLEGRO_KEY_1:
numb[N1] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("1");
break;
case ALLEGRO_KEY_2:
numb[N2] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("2");
break;
case ALLEGRO_KEY_3:
numb[N3] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("3");
break;
case ALLEGRO_KEY_4:
numb[N4] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("4");
break;
case ALLEGRO_KEY_5:
numb[N5] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("5");
break;
case ALLEGRO_KEY_6:
numb[N6] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("6");
break;
case ALLEGRO_KEY_7:
numb[N7] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("7");
break;
case ALLEGRO_KEY_8:
numb[N8] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("8");
break;
case ALLEGRO_KEY_9:
numb[N9] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("9");
break;
case ALLEGRO_KEY_A:
letters[A] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("a");
break;
case ALLEGRO_KEY_B:
letters[B] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("b");
break;
case ALLEGRO_KEY_C:
letters[C] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("c");
break;
case ALLEGRO_KEY_D:
letters[D] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("d");
break;
case ALLEGRO_KEY_E:
letters[E] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("e");
break;
case ALLEGRO_KEY_F:
letters[F] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("f");
break;
case ALLEGRO_KEY_G:
letters[G] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("g");
break;
case ALLEGRO_KEY_H:
letters[H] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("h");
break;
case ALLEGRO_KEY_I:
letters[I] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("i");
break;
case ALLEGRO_KEY_J:
letters[J] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("j");
break;
case ALLEGRO_KEY_K:
letters[K] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("k");
break;
case ALLEGRO_KEY_L:
letters[L] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("l");
break;
case ALLEGRO_KEY_M:
letters[M] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("m");
break;
case ALLEGRO_KEY_N:
letters[N] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("n");
break;
case ALLEGRO_KEY_O:
letters[O] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("o");
break;
case ALLEGRO_KEY_P:
letters[P] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("p");
break;
case ALLEGRO_KEY_Q:
letters[Q] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("q");
break;
case ALLEGRO_KEY_R:
letters[R] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("r");
break;
case ALLEGRO_KEY_S:
letters[S] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("s");
break;
case ALLEGRO_KEY_T:
letters[T] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("t");
break;
case ALLEGRO_KEY_U:
letters[U] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("u");
break;
case ALLEGRO_KEY_V:
letters[V] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("v");
break;
case ALLEGRO_KEY_W:
letters[W] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("w");
break;
case ALLEGRO_KEY_X:
letters[X] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("x");
break;
case ALLEGRO_KEY_Y:
letters[Y] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("y");
break;
case ALLEGRO_KEY_Z:
letters[Z] = true;
if (state == PLAYING && Task->GetStatus())
Task->Add("z");
break;
}
}
else if (ev.type == ALLEGRO_EVENT_KEY_UP)
{
switch (ev.keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
done = true;
break;
case ALLEGRO_KEY_LEFT:
keys[LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
keys[RIGHT] = false;
break;
case ALLEGRO_KEY_UP:
keys[UP] = false;
break;
case ALLEGRO_KEY_DOWN:
keys[DOWN] = false;
break;
case ALLEGRO_KEY_ENTER:
keys[ENTER] = false;
break;
case ALLEGRO_KEY_TAB:
keys[TAB] = false;
break;
case ALLEGRO_KEY_BACKSPACE:
keys[BSPC] = false;
break;
case ALLEGRO_KEY_COMMA:
keys[COM] = false;
break;
case ALLEGRO_KEY_0:
numb[N0] = false;
break;
case ALLEGRO_KEY_1:
numb[N1] = false;
break;
case ALLEGRO_KEY_2:
numb[N2] = false;
break;
case ALLEGRO_KEY_3:
numb[N3] = false;
break;
case ALLEGRO_KEY_4:
numb[N4] = false;
break;
case ALLEGRO_KEY_5:
numb[N5] = false;
break;
case ALLEGRO_KEY_6:
numb[N6] = false;
break;
case ALLEGRO_KEY_7:
numb[N7] = false;
break;
case ALLEGRO_KEY_8:
numb[N8] = false;
break;
case ALLEGRO_KEY_9:
numb[N9] = false;
break;
case ALLEGRO_KEY_A:
letters[A] = false;
break;
case ALLEGRO_KEY_B:
letters[B] = false;
break;
case ALLEGRO_KEY_C:
letters[C] = false;
break;
case ALLEGRO_KEY_D:
letters[D] = false;
break;
case ALLEGRO_KEY_E:
letters[E] = false;
break;
case ALLEGRO_KEY_F:
letters[F] = false;
break;
case ALLEGRO_KEY_G:
letters[G] = false;
break;
case ALLEGRO_KEY_H:
letters[H] = false;
break;
case ALLEGRO_KEY_I:
letters[I] = false;
break;
case ALLEGRO_KEY_J:
letters[J] = false;
break;
case ALLEGRO_KEY_K:
letters[K] = false;
break;
case ALLEGRO_KEY_L:
letters[L] = false;
break;
case ALLEGRO_KEY_M:
letters[M] = false;
break;
case ALLEGRO_KEY_N:
letters[N] = false;
break;
case ALLEGRO_KEY_O:
letters[O] = false;
break;
case ALLEGRO_KEY_P:
letters[P] = false;
break;
case ALLEGRO_KEY_Q:
letters[Q] = false;
break;
case ALLEGRO_KEY_R:
letters[R] = false;
break;
case ALLEGRO_KEY_S:
letters[S] = false;
break;
case ALLEGRO_KEY_T:
letters[T] = false;
break;
case ALLEGRO_KEY_U:
letters[U] = false;
break;
case ALLEGRO_KEY_V:
letters[V] = false;
break;
case ALLEGRO_KEY_W:
letters[W] = false;
break;
case ALLEGRO_KEY_X:
letters[X] = false;
break;
case ALLEGRO_KEY_Y:
letters[Y] = false;
break;
case ALLEGRO_KEY_Z:
letters[Z] = false;
break;
}
}
else if (ev.type == ALLEGRO_EVENT_TIMER)
{
render = true;
frames++;
if (al_current_time() - gameTime >= 1)
{
gameTime = al_current_time();
gameFPS = frames;
frames = 0;
}
if (state == PLAYING)
{
if (keys[UP])
{
if (Map->GetY() + Map->frameHeight > disp_data.height)
{
for (iter = objects.begin(); iter != objects.end(); ++iter)
{
(*iter)->SetY((*iter)->GetY() - 10);
}
tractor->SetDistY((tractor->GetDistY() - 10));
}
}
else if (keys[DOWN])
{
if (Map->GetY() < 0)
{
for (iter = objects.begin(); iter != objects.end(); ++iter)
{
(*iter)->SetY((*iter)->GetY() + 10);
}
tractor->SetDistY(tractor->GetDistY() + 10);
}
}
if (keys[LEFT])
{
if (Map->GetWidth() > (disp_data.width - al_get_bitmap_width(panel)))
{
for (iter = objects.begin(); iter != objects.end(); ++iter)
{
(*iter)->SetX((*iter)->GetX() - 10);
}
tractor->SetDistX(tractor->GetDistX() - 10);
}
}
else if (keys[RIGHT])
{
if (Map->GetX() < 0)
{
for (iter = objects.begin(); iter != objects.end(); ++iter)
{
(*iter)->SetX((*iter)->GetX() + 10);
}
tractor->SetDistX(tractor->GetDistX() + 10);
}
}
for (iter = objects.begin(); iter != objects.end(); ++iter)
(*iter)->Update();
if (tractor->GetStatus())
tractor->Move();
field1->Change_Field();
field1->Grow_Field();
field2->Change_Field();
field2->Grow_Field();
field3->Change_Field();
field3->Grow_Field();
field4->Change_Field();
field4->Grow_Field();
field1->Action_On_Field(tractor);
field2->Action_On_Field(tractor);
field3->Action_On_Field(tractor);
field4->Action_On_Field(tractor);
if (!tractor->Get_Iminwork()){
Xml->ZKolejki(field1, field2, field3, field4, tractor);
if (Xml->wyslij() != ""){
TextBox *txtxml = new TextBox();
txtxml->SetText(Xml->wyslij());
history.push_back(txtxml);
for (iter2 = history.begin(); iter2 != history.end(); iter2++)
{
if ((*iter2)->GetY() < 300)
{
delete (*iter2);
iter2 = history.erase(iter2);
}
(*iter2)->UpdateY();
}
}
}
if (evTimer < 60)
{
evTimer += 0.1;
}
else
{
if (tractor->GetPodpowiedz() == 0)
{
Xml->podpowiedz(field1, field2, field3, field4, tractor);
evTimer = 0;
TextBox *txtxml = new TextBox();
txtxml->SetText(Xml->wyslij());
history.push_back(txtxml);
for (iter2 = history.begin(); iter2 != history.end(); iter2++)
{
if ((*iter2)->GetY() < 300)
{
delete (*iter2);
iter2 = history.erase(iter2);
}
(*iter2)->UpdateY();
}
}
}
}
if (tractor->GetMoney() <= 0)
ChangeState(state, LOST);
}
for (iter = objects.begin(); iter != objects.end();)
{
if (!(*iter)->GetAlive())
{
delete (*iter);
iter = objects.erase(iter);
}
else
iter++;
}
if (render && al_is_event_queue_empty(event_queue))
{
render = false;
if (state == TITLE)
{
titleScreen->Render();
}
else if (state == PLAYING)
{
for (iter = objects.begin(); iter != objects.end(); ++iter)
(*iter)->Render();
al_draw_bitmap(panel, WIDTH - al_get_bitmap_width(panel), 0, 0);
al_draw_textf(font, al_map_rgb(255, 255, 255), Task->GetX(), Task->GetY(), 0, Task->ShowText());
for (iter2 = history.begin(); iter2 != history.end(); iter2++)
{
al_draw_textf(font, al_map_rgb(255, 255, 255), (*iter2)->GetX(), (*iter2)->GetY(), 0, (*iter2)->ShowText());
}
if (tractor->GetHealth() < 20)
al_draw_textf(score, RED, WIDTH - 430, 15, 0, "%i", tractor->GetHealth());
else
al_draw_textf(score, BLACK, WIDTH - 430, 15, 0, "%i", tractor->GetHealth());
if (tractor->GetFuel() < 20)
al_draw_textf(score, RED, WIDTH - 260, 15, 0, "%i", tractor->GetFuel());
else
al_draw_textf(score, BLACK, WIDTH - 260, 15, 0, "%i", tractor->GetFuel());
if (tractor->GetMoney() < 200)
al_draw_textf(score, RED, WIDTH - 400, 100, 0, "%i", tractor->GetMoney());
else
al_draw_textf(score, BLACK, WIDTH - 400, 100, 0, "%i", tractor->GetMoney());
al_draw_textf(score, BLACK, WIDTH - 70, 15, 0, "%i", tractor->GetWater());
for (int j = 0; j < 5; j++)
{
al_draw_textf(font, BLACK, WIDTH - 170, 85 + j * 20, 0, "%i", tractor->GetSupply(0, j));
}
for (int j = 0; j < 5; j++)
{
al_draw_textf(font, BLACK, WIDTH - 150, 85 + j * 20, 0, "%i", tractor->GetSupply(1, j));
}
al_draw_textf(font, al_map_rgb(255, 0, 255), 5, 5, 0, "FPS: %i", WIDTH - al_get_bitmap_width(panel) /*gameFPS*/);
}
else if (state == LOST)
lostScreen->Render();
al_flip_display();
al_clear_to_color(al_map_rgb(0, 0, 0));
}
}
for (iter = objects.begin(); iter != objects.end();)
{
(*iter)->Destroy();
delete (*iter);
iter = objects.erase(iter);
}
for (iter2 = history.begin(); iter2 != history.end();)
{
(*iter2)->Destroy();
delete (*iter2);
iter2 = history.erase(iter2);
}
//tractor->Destroy();
Task->Destroy();
titleScreen->Destroy();
lostScreen->Destroy();
delete titleScreen;
delete lostScreen;
al_destroy_sample(cash);
al_destroy_sample_instance(songInstance);
al_destroy_sample_instance(songInstance2);
al_destroy_sample_instance(songInstance3);
al_destroy_font(score);
al_destroy_font(font);
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
al_destroy_display(display);
return 0;
}