int main(void){
//allegro variables
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_BITMAP *bg = NULL;
ALLEGRO_TIMER *timer;
//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 INSTALL
//==============================================
al_install_keyboard();
al_init_image_addon();
al_init_font_addon();
al_init_ttf_addon();
al_init_primitives_addon();
// FONT DEL PROGRAMA.
ALLEGRO_FONT *font = al_load_ttf_font("Sarpanch-SemiBold.ttf",30,0 );
// VARIABLES DEL JUEGO ========================
bg = al_load_bitmap("img/sp1.jpg");
SpaceShip nave_jugador;
Enemy enemies1[10];
Enemy enemies2[10];
Enemy enemies3[10];
Enemy enemies4[10];
Enemy jefe1[10];
Bullet bullets[5];
char vidas_char[2];
// INICIALIZAR OBJETOS====================
InitShip(nave_jugador);
InitBullet(bullets, NUM_BULLETS);
InitEnemies(enemies1,ENM1,10,0,220,WIDTH/2);
InitEnemies(enemies2,ENM2,8,50,180,WIDTH/2+100);
InitEnemies(enemies3,ENM3,6,100,140,WIDTH);
InitEnemies(enemies4,ENM4,4,150,100,(WIDTH/2)+100);
InitEnemies(jefe1,JEFE,2,200,60);
//DrawEnemies(enemies,NUM_ENEMIES);
//==============================================
//TIMER INIT AND STARTUP
//==============================================
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);
//AnimacionEntrada(enemies,NUM_ENEMIES);
printf("ya");
int animacion=1;
int movimientos=0;
while(!done){
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
// INFORMACION DEL JUEGO Y BG
// DrawWindowStatus();
al_draw_bitmap(bg, 0, 0, 0);
al_draw_bitmap(nave_jugador.image, 5,440,0);
al_draw_text(font, al_map_rgb(255,255,255), 40,430, 0, "X");
sprintf(vidas_char,"%d",vidas);
al_draw_text(font, al_map_rgb(255,255,255), 60,430, 0, vidas_char);
al_draw_text(font, al_map_rgb(255,255,255), WIDTH/2 - 30, 0,ALLEGRO_ALIGN_CENTRE, "Score");
char vartext[10];
sprintf(vartext,"%d",score);
al_draw_text(font, al_map_rgb(255,255,255), WIDTH/2 + 40, 0, 0, vartext);
//==============================================
//INPUT
//==============================================
if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
done = true;
}
else if(ev.type == ALLEGRO_EVENT_KEY_DOWN){
switch(ev.keyboard.keycode){
case ALLEGRO_KEY_ESCAPE:
done = true;
break;
case ALLEGRO_KEY_LEFT:
keys[LEFT] = true;
break;
case ALLEGRO_KEY_RIGHT:
keys[RIGHT] = true;
break;
case ALLEGRO_KEY_SPACE:
keys[SPACE] = true;
FireBullet(bullets, NUM_BULLETS, nave_jugador);
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_SPACE:
keys[SPACE] = false;
break;
}
}
//==============================================
//GAME UPDATE
//==============================================
else if(ev.type == ALLEGRO_EVENT_TIMER){
render = true;
if(keys[LEFT])
MoveShipLeft(nave_jugador);
else if(keys[RIGHT])
MoveShipRight(nave_jugador);
UpdateBullet(bullets, NUM_BULLETS);
CollideBullet(bullets,NUM_BULLETS,enemies1,NUM_ENEMIES);
CollideBullet(bullets,NUM_BULLETS,enemies2,8);
CollideBullet(bullets,NUM_BULLETS,enemies3,6);
CollideBullet(bullets,NUM_BULLETS,enemies4,4);
CollideBullet(bullets,NUM_BULLETS,jefe1,2);
}
//==============================================
//RENDER
//==============================================
if(render && al_is_event_queue_empty(event_queue))
{
if (animacion==1){
printf("si primero");
movEnemies(enemies1,10,1);
movEnemies(enemies2, 8,1);
movEnemies(enemies3,6,1);
movEnemies(enemies4,4,1);
movEnemies(jefe1,2,1);
animacion=0;
movimientos=1;
}
render = false;
// Dibujar nave
al_draw_bitmap(nave_jugador.image, nave_jugador.x - nave_jugador.w / 2, nave_jugador.y - nave_jugador.h / 2, 0);
// Dibujar Balas
DrawBullet(bullets, NUM_BULLETS);
// Dibuja los enemigos.
DrawEnemies(enemies1,10);
DrawEnemies(enemies2,8);
DrawEnemies(enemies3,6);
DrawEnemies(enemies4,4);
DrawEnemies(jefe1,2);
al_flip_display();
al_clear_to_color(al_map_rgb(0,0,0));
if (movimientos){
movimientos=0;
movEnemies(enemies1,10,2);
movEnemies(enemies2,8,3);
}
}
}
for (int i =0;i<10;i++)
al_destroy_bitmap(enemies1[i].image);
al_destroy_event_queue(event_queue);
al_destroy_timer(timer);
al_destroy_display(display); //destroy our display object
return 0;
}
/* Run our test. */
static void run(void)
{
ALLEGRO_EVENT event;
float x, y;
bool need_draw = true;
while (1) {
/* Perform frame skipping so we don't fall behind the timer events. */
if (need_draw && al_is_event_queue_empty(ex.queue)) {
tick();
need_draw = false;
}
al_wait_for_event(ex.queue, &event);
switch (event.type) {
/* Was the X button on the window pressed? */
case ALLEGRO_EVENT_DISPLAY_CLOSE:
return;
/* Was a key pressed? */
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
return;
break;
/* Is it time for the next timer tick? */
case ALLEGRO_EVENT_TIMER:
need_draw = true;
break;
/* Mouse click? */
case ALLEGRO_EVENT_MOUSE_BUTTON_UP:
x = event.mouse.x;
y = event.mouse.y;
if (x >= ex.BUTTONS_X) {
int button = y / 20;
if (button == 2) ex.image = 0;
if (button == 3) ex.image = 1;
if (button == 4) ex.image = 2;
if (button == 5) ex.image = 3;
if (button == 6) ex.image = 4;
if (button == 7) ex.image = 5;
if (button == 10) ex.mode = 0;
if (button == 11) ex.mode = 1;
if (button == 12) ex.mode = 2;
if (button == 13) ex.mode = 3;
if (button == 14) ex.mode = 4;
if (button == 15) ex.mode = 5;
if (button == 16) ex.mode = 6;
if (button == 17) ex.mode = 7;
if (button == 18) ex.mode = 8;
if (button == 19) ex.mode = 9;
if (button == 20) ex.mode = 10;
}
break;
}
}
}
int main() {
//allegro stuff
ALLEGRO_DISPLAY *al_display;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_EVENT event;
ALLEGRO_TIMER *loop_timer;
int need_draw = 1;
//widgets
ALGUI_DISPLAY *display;
//other
ALGUI_SKIN *skin;
/**** INIT ****/
//init allegro
al_init();
al_install_keyboard();
al_install_mouse();
al_init_image_addon();
al_init_font_addon();
al_init_ttf_addon();
al_init_primitives_addon();
//init algui
algui_init();
/**** CREATE ALLEGRO RESOURCES ****/
//set flags
al_set_new_display_flags(al_get_new_display_flags() | ALLEGRO_GENERATE_EXPOSE_EVENTS | ALLEGRO_RESIZABLE | ALLEGRO_WINDOWED);
//create a al_display
al_display = al_create_display(640, 480);
assert(al_display);
//create timers and events
queue = al_create_event_queue();
loop_timer = al_create_timer(1.0 / 60.0);
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(al_display));
al_register_event_source(queue, al_get_timer_event_source(loop_timer));
/**** CREATE WIDGETS ****/
//create the display widget
display = algui_create_display();
algui_resize_widget(algui_get_display_widget(display), 640, 480);
//skin widgets
skin = algui_load_skin("test/test-skin/test-skin.txt");
algui_skin_widget(algui_get_display_widget(display), skin);
/**** MANAGE EVENTS ****/
//event loop
al_start_timer(loop_timer);
for(;;) {
//wait for event
al_wait_for_event(queue, &event);
switch (event.type) {
//close
case ALLEGRO_EVENT_DISPLAY_CLOSE:
goto END;
//keydown
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) goto END;
algui_dispatch_event(algui_get_display_widget(display), &event);
break;
//redraw
case ALLEGRO_EVENT_DISPLAY_EXPOSE:
need_draw = 1;
break;
//remove the input focus
case ALLEGRO_EVENT_DISPLAY_SWITCH_OUT:
algui_dispatch_event(algui_get_display_widget(display), &event);
need_draw = 1;
break;
//handle timers
case ALLEGRO_EVENT_TIMER:
if (event.timer.source == loop_timer) need_draw = 1;
else algui_dispatch_event(algui_get_display_widget(display), &event);
break;
//dispatch event to the widgets
default:
algui_dispatch_event(algui_get_display_widget(display), &event);
break;
}
if (need_draw && al_is_event_queue_empty(queue)) {
algui_draw_widget(algui_get_display_widget(display));
al_flip_display();
need_draw = false;
}
}
/**** CLEANUP ****/
END:
//cleanup the gui
algui_destroy_widget(algui_get_display_widget(display));
algui_destroy_skin(skin);
algui_cleanup();
//cleanup allegro
al_destroy_timer(loop_timer);
al_destroy_event_queue(queue);
al_destroy_display(al_display);
return 0;
}
int main() {
bool menu = true;
char pontuacao[100];
char vida[100];
ALLEGRO_COLOR font_color;
ALLEGRO_FONT *font,*font2;
ALLEGRO_AUDIO_STREAM *musica = NULL;
camera *cam = camera_inicializa(0);
if(!cam)
erro("erro na inicializacao da camera\n");
int x = 0, y = 0;
int largura = cam->largura;
int altura = cam->altura;
int fps = 0,tempo = 5;
int ndisco = 9;
if(!al_init())
erro("erro na inicializacao do allegro\n");
if(!al_init_image_addon())
erro("erro na inicializacao do adicional de imagem\n");
al_init_font_addon();
al_init_ttf_addon();
font_color = al_map_rgb(0, 0, 0);
font = al_load_ttf_font("Fontes/Blokletters-Viltstift.ttf", 20, 0);
font2 = al_load_ttf_font("Fontes/Blokletters-Viltstift.ttf", 50, 0);
if(!al_init_primitives_addon())
erro("erro na inicializacao do adicional de primitivas\n");
ALLEGRO_TIMER *timer = al_create_timer(1.0 / FPS);
if(!timer)
erro("erro na criacao do relogio\n");
ALLEGRO_DISPLAY *display = al_create_display(2 * largura,altura);
if(!display)
erro("erro na criacao da janela\n");
ALLEGRO_EVENT_QUEUE *queue = al_create_event_queue();
if(!queue)
erro("erro na criacao da fila\n");
if (!al_install_audio())
{
fprintf(stderr, "Falha ao inicializar áudio.\n");
return false;
}
if (!al_init_acodec_addon())
{
fprintf(stderr, "Falha ao inicializar codecs de áudio.\n");
return false;
}
if (!al_reserve_samples(1))
{
fprintf(stderr, "Falha ao alocar canais de áudio.\n");
return false;
}
musica = al_load_audio_stream("Audio/elementary.ogg", 4, 1024);
if(!musica)
erro("Erro na alocação da musica de fundo\n");
al_attach_audio_stream_to_mixer(musica, al_get_default_mixer());
al_set_audio_stream_playing(musica, true);
al_register_event_source(queue, al_get_timer_event_source(timer));
al_register_event_source(queue, al_get_display_event_source(display));
al_start_timer(timer);
unsigned char ***matriz = camera_aloca_matriz(cam);
ALLEGRO_BITMAP *buffer = al_get_backbuffer(display);
ALLEGRO_BITMAP *fundo = al_load_bitmap("Imagens/Elementary2.png");
if(!fundo)
erro("erro ao carregar Elementary.png");
ALLEGRO_BITMAP *esquerda = al_create_sub_bitmap(buffer, 0, 0, largura, altura);
ALLEGRO_BITMAP *direita = al_create_sub_bitmap(buffer, largura, 0, largura, altura);
/**********/
Disco *discos[9];
bool perdeu = false;
carregarDiscos(discos);
int pontos=0,velo = 1;
int aux1 = 1;
int vidas = 10;
int ultimoDisco = 0;
int distance = 0;
int desenhar = 0;
int terminar = 0;
al_set_target_bitmap(esquerda);
al_draw_bitmap(fundo,0,0,0);
while(1) {
ALLEGRO_EVENT event;
al_wait_for_event(queue, &event);
switch(event.type) {
case ALLEGRO_EVENT_TIMER:
desenhar = 1;
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
terminar = 1;
break;
}
if(terminar)
break;
if(desenhar && al_is_event_queue_empty(queue)) {
desenhar = 0;
camera_atualiza(cam);
mediana(cam);
/**********/
al_set_target_bitmap(esquerda);
al_draw_bitmap(fundo,0,0,0);
if(!menu){
while(aux1 <= ndisco){
if(discos[aux1]->status == false){
if(distance > 50 || ultimoDisco==0 ){
printf("%d\n",aux1 );
al_draw_bitmap(discos[aux1]->elemento,discos[aux1]->pos_x,discos[aux1]->pos_y,0);
discos[aux1]->status = true;
distance = 0;
ultimoDisco = aux1;
break;
}else
aux1++;
}else{
discos[aux1]->pos_y+=(10+velo);
al_draw_bitmap(discos[aux1]->elemento,discos[aux1]->pos_x,discos[aux1]->pos_y,0);
aux1++;
}
}
distance = discos[ultimoDisco]->pos_y;
for(aux1 = 1;aux1<ndisco;aux1++){
if(discos[aux1]->pos_x >= x-30 && discos[aux1]->pos_x <= x+30 && discos[aux1]->pos_y >= y-30 && discos[aux1]->pos_y <= y+30){
if(discos[aux1]->tipo == 2){ // Tipo do fogo(Necessario para vencer o jogo)
pontos +=10;
velo += 1;
discos[aux1]->pos_x = rand()%9 * 55;
discos[aux1]->pos_y = 0;
discos[aux1]->status = false;
}else if(discos[aux1]->tipo == 1){ //Tipo da agua(Perde o jogo se destruir esse disco)
discos[aux1]->pos_x = rand()%9 * 55;
discos[aux1]->pos_y = 0;
discos[aux1]->status = false;
al_flip_display();
vidas--;
}else if(discos[aux1]->tipo == 3){//Tipo planta(Aumenta velocidade de queda das peças)
velo *= 2;
discos[aux1]->pos_x = rand()%9 * 55;
discos[aux1]->pos_y = 0;
discos[aux1]->status = false;
}
}else if( discos[aux1]->pos_y > 480){
if(discos[aux1]->tipo == 2){ //Tipo da agua e Planta(Não perde se deixar cair)
discos[aux1]->pos_x = rand()%9 * 55;
discos[aux1]->pos_y = 0;
discos[aux1]->status = false;
al_flip_display();
vidas--;
}else{
discos[aux1]->pos_x = rand()%9 * 55;
discos[aux1]->pos_y = 0;
discos[aux1]->status = false;
}
}
}
aux1 = 1;
sprintf(pontuacao,"PONTUAÇÃO: %d",pontos);
al_draw_text(font, al_map_rgb(255, 255, 255), 50, 5, 0,pontuacao);
sprintf(vida,"VIDAS: %d",vidas);
al_draw_text(font, al_map_rgb(255, 255, 255), 300, 5, 0,vida);
al_flip_display();
}
if(perdeu){
al_draw_text(font2, al_map_rgb(255, 0, 0), 50, 100, 0,"PONTUAÇÃO FINAL");
sprintf(pontuacao,"%d",pontos);
al_draw_text(font2, al_map_rgb(255, 0, 0), 250, 170, 0,pontuacao);
al_flip_display();
al_rest(3);
break;
}
if(vidas == 0){
perdeu = true;
}
if(menu){
if(abrirJogo(x,y,&fps,&tempo,font,font2, font_color)){
fundo = al_load_bitmap("Imagens/galaxia.png");
menu = false;
}
}
cameraRastreia(cam,&x,&y);
al_set_target_bitmap(direita);
camera_copia(cam, cam->quadro, direita);
al_flip_display();
}
}
al_destroy_bitmap(direita);
al_destroy_bitmap(fundo);
al_destroy_bitmap(esquerda);
camera_libera_matriz(cam, matriz);
int fri = 9;
while(fri != 0){
free(discos[fri]);
fri--;
}
al_stop_timer(timer);
al_unregister_event_source(queue, al_get_display_event_source(display));
al_unregister_event_source(queue, al_get_timer_event_source(timer));
al_destroy_event_queue(queue);
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_audio_stream(musica);
al_shutdown_primitives_addon();
al_shutdown_image_addon();
al_uninstall_system();
camera_finaliza(cam);
return EXIT_SUCCESS;
}
/*
Begin game execution
*/
void Tetris::play() {
simplog.writeLog( LOG_INFO, "Tetris started successfully!" );
// Start the timer
al_start_timer( timer );
simplog.writeLog( LOG_VERBOSE, "Timer started" );
// Run loop variables
bool done = false;
bool redraw = true;
double lastTime = al_get_time();
double currentFPS = 0.0;
int frames_done = 1;
ALLEGRO_EVENT event;
// Run loop
while( !done ) {
// Wait for an event to occur
al_wait_for_event( main_queue, &event );
// Redraw only when the timer event is triggered to cap FPS
if( event.type == ALLEGRO_EVENT_TIMER ) {
redraw = true;
} else if( event.type == ALLEGRO_EVENT_DISPLAY_CLOSE ) {
done = true;
}
// Get current time
double currentTime = al_get_time();
// Calculate delta time
double delta = currentTime - lastTime;
// Calculate current FPS
if( delta >= 1.0 ) {
currentFPS = frames_done / delta;
frames_done = 0;
lastTime = currentTime;
}
// Redraw if the timer was triggered, and the event queue is empty
if( redraw && al_is_event_queue_empty( main_queue ) ) {
redraw = false;
// Update and render the current state
bool updateOkay = states->top()->update( delta );
bool renderOkay = states->top()->render();
// Check if update and render completed okay for the current state
if( !updateOkay || !renderOkay ) {
// Delete the current state and pop if off the stack
delete states->top();
states->pop();
// If there are no states left, end the run loop
if( states->empty() ) {
done = true;
}
}
// Print the FPS in the upper left corner
if( showFPS ) {
al_draw_textf( font12, al_map_rgb( 255, 255, 255 ), 0, 0, ALLEGRO_ALIGN_LEFT, "FPS: %.2f", currentFPS );
}
// Flip the display
al_flip_display();
}
// Increment the current frames total
frames_done++;
}
}
void game_loop(void)
{
for (int x = 0; x < 16; x++)
{
//for each y value between 2 and 13
for (int y = 0; y < 16; y++)
{
randX = 6 + (rand() % (int)(12 - 6 + 1));
randY = 0 + (rand() % (int)(3 - 0 + 1));
//drawDungeonTile(randX, randY, x, y);
floorArray [x] [y] [0] = randX;
floorArray [x] [y] [1] = randY;
}
}
player p1;
//(speed, friction, sprint accel, max speed)
//default: p1.setMovement(1.4, .4, 1.8, 4);
p1.setMovement(1.4, .4, 1.8, 4);
p1.setPosition(tileSize * 7, tileSize * 12);
p1.setX(240);
p1.setY(240);
printf("%f, %f \n", p1.getX(), p1.getY());
al_start_timer(timer);
while (!done) {
ALLEGRO_EVENT event;
al_wait_for_event(event_queue, &event);
if (event.type == ALLEGRO_EVENT_TIMER)
{
if(key[keyW] && p1.getY() >= p1.getMaxSpeed() + 1)
{
p1.setDy( p1.getDy() - p1.getSpeed());
}
if(key[keyS] && p1.getY() <= screenH - squareSize - (p1.getMaxSpeed() + 1))
{
p1.setDy( p1.getDy() + p1.getSpeed());
}
if(key[keyA] && p1.getX() >= (p1.getMaxSpeed() + 1))
{
p1.setDx( p1.getDx() - p1.getSpeed());
}
if(key[keyD] && p1.getX() <= screenW - squareSize - (p1.getMaxSpeed() + 1))
{
p1.setDx( p1.getDx() + p1.getSpeed());
}
if(key[keyShift] && (key[keyW] || key[keyA] ||key[keyS] ||key[keyD]))
{
p1.setDx(p1.getDx() * p1.getSprintAccel());
p1.setDy(p1.getDy() * p1.getSprintAccel());
}
if (abs(p1.getDx()) > p1.getMaxSpeed())
{
if(p1.getDx() < 0)
{
p1.setDx( -p1.getMaxSpeed());
}
if(p1.getDx() > 0)
{
p1.setDx( p1.getMaxSpeed());
}
}
//max velocity Y
if (abs(p1.getDy()) > p1.getMaxSpeed())
{
if(p1.getDy() < 0)
{
p1.setDy(-p1.getMaxSpeed());
}
if(p1.getDy() > 0)
{
p1.setDy( p1.getMaxSpeed() );
}
}
redraw = true;
//update_logic();
//update player position
p1.setX(p1.getX() + p1.getDx());
//X axis
//detect and respond to collision with obstacles
p1.setX(playerWallCollisionX(p1.getX(),p1.getDx(),p1.getY(),room111));
p1.setDx(p1.getDx() * p1.getFriction());
//Y axis
p1.setY(p1.getY() + p1.getDy());
p1.setY(playerWallCollisionY(p1.getY(),p1.getDy(),p1.getX(),room111));
p1.setDy(p1.getDy() * p1.getFriction());
if (textCounter)
{
textCounter = textCounter + 1;
if (textCounter == 60)
{
textCounter = 0;
}
}
redraw = true;
}
//key pressed down
else if (event.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch (event.keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
done = true;
case ALLEGRO_KEY_W:
key[keyW] = true;
break;
case ALLEGRO_KEY_A:
key[keyA] = true;
break;
case ALLEGRO_KEY_S:
key[keyS] = true;
break;
case ALLEGRO_KEY_D:
key[keyD] = true;
break;
case ALLEGRO_KEY_LSHIFT:
key[keyShift] = true;
break;
}
}
//key released
else if (event.type == ALLEGRO_EVENT_KEY_UP)
{
switch (event.keyboard.keycode)
{
case ALLEGRO_KEY_W:
key[keyW] = false;
break;
case ALLEGRO_KEY_A:
key[keyA] = false;
break;
case ALLEGRO_KEY_S:
key[keyS] = false;
break;
case ALLEGRO_KEY_D:
key[keyD] = false;
break;
case ALLEGRO_KEY_LSHIFT:
key[keyShift] = false;
break;
}
}
else if(event.type == ALLEGRO_EVENT_MOUSE_AXES || ALLEGRO_EVENT_MOUSE_ENTER_DISPLAY)
{
crosshair_x = event.mouse.x - crosshairSize/2;
crosshair_y = event.mouse.y - crosshairSize/2;
}
if (redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
//Clear screen to green
al_clear_to_color(al_map_rgb(0, 0, 0));
//update_graphics();
//graphics that will always be there
drawDungeon(floorArray,room111);
al_draw_bitmap(playerBitmap, p1.getX(), p1.getY(), 0);
/*
for (int i = 0; i < (sizeof(obstacles)/sizeof(*obstacles)); i++)
{
al_draw_bitmap(block, obstacles[i][0],obstacles[i][1],0);
}
*/
drawObstacles(obstacles,sizeof(obstacles)/sizeof(*obstacles));
al_draw_bitmap(crosshair, crosshair_x, crosshair_y, 0);
al_flip_display();
}
}
}
int main(int argc, char **argv){
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_BITMAP *seletor = NULL;
float tamanho = 25;
float espacamento = SELETOR_SIZE + 19;
float seletor_x = 1174;
float seletor_y = 40;
bool key[4] = { false, false, false, false };
bool redraw = true;
bool doexit = false;
float posicao = 0;
int mapa[770][3];
bool envio[4] = { false, false, false, false };
//Inicia o allegro
al_init();
al_init_image_addon();
al_install_keyboard();
// Inicialização do add-on para uso de fontes
al_init_font_addon();
al_init_ttf_addon();
inicializaBitmaps();
lerConf(mapa);
//Cria a lista de eventos
event_queue = al_create_event_queue();
//Cria o timer
timer = al_create_timer(1.0 / FPS);
//Cria a janela
display = al_create_display(SCREEN_W, SCREEN_H);
//Limpa a janela com a cor preta
al_clear_to_color(al_map_rgb(0, 0, 0));
//Carrega a imagem de fundo na variável
background = al_load_bitmap("img/fundo.png");
//Desenha a imagem de fundo na posição (0,0)
al_draw_bitmap(background, 0, 0, 0);
//Carrega a imagem do seletor na variável
seletor = al_load_bitmap("img/selecao.png");
//Desenha o seletor na posição (1174,40)
al_draw_bitmap(seletor, 1174, 40, 0);
desenhaMapa(mapa, envio);
//Registra os eventos
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_flip_display();
//Inicia o timer
al_start_timer(timer);
//Inicia contagem de tempo para a pergunta aparecer
initClock();
//While do jogo
while(!doexit){
//Aguarda o evento
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
//Se der o tempo do timer, verifica qual tecla foi pressionada e se é possível se mover para a posição de destino
if(ev.type == ALLEGRO_EVENT_TIMER){
if(key[KEY_LEFT] && (posicao == 1 || posicao == 3) && (janela_aberta == 0)) {
seletor_x -= espacamento;
if(posicao == 1)
posicao = 0;
else
posicao = 2;
}
if(key[KEY_RIGHT] && (posicao == 0 || posicao == 2) && (janela_aberta == 0)) {
seletor_x += espacamento;
if(posicao == 0)
posicao = 1;
else
posicao = 3;
}
if(key[KEY_UP] && (posicao == 2 || posicao == 3) && (janela_aberta == 0)) {
seletor_y -= espacamento;
if(posicao == 2)
posicao = 0;
else
posicao = 1;
}
if(key[KEY_DOWN] && (posicao == 0 || posicao == 1) && (janela_aberta == 0)) {
seletor_y += espacamento;
if(posicao == 0)
posicao = 2;
else
posicao = 3;
}
redraw = true;
}
//Se a janela for fechada, termina o jogo
else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
//Se o evento for um tecla pressionada, seta a variável dessa tecla para "true" (pressionada)
else if(ev.type == ALLEGRO_EVENT_KEY_DOWN) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_LEFT:
key[KEY_LEFT] = true;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_RIGHT] = true;
break;
case ALLEGRO_KEY_UP:
key[KEY_UP] = true;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = true;
break;
}
}
//Se o evento for um tecla solta, seta a variável dessa tecla para "false" (caso seja Esc, encerra o programa)
else if(ev.type == ALLEGRO_EVENT_KEY_UP) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_LEFT:
key[KEY_LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_RIGHT] = false;
break;
case ALLEGRO_KEY_ESCAPE:
doexit = true;
break;
case ALLEGRO_KEY_UP:
key[KEY_UP] = false;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = false;
break;
case ALLEGRO_KEY_ENTER:
if (janela_aberta == 0){
if(posicao == 0)
envio[VERMELHO] = true;
else if(posicao == 1)
envio[AZUL] = true;
else if(posicao == 2)
envio[VERDE] = true;
else if(posicao == 3)
envio[AMARELO] = true;
}
}
}
//Redesenha o jogo
if(redraw && al_is_event_queue_empty(event_queue)){
redraw = false;
al_draw_bitmap(background, 0, 0, 0);
desenhaMapa(mapa, envio);
movimento(mapa);
if (janela_aberta == 0){
if (checkClock()){
janela_aberta = 1;
}
}else{
al_draw_bitmap(perguntas, 0, 0, 0);
al_draw_textf(font, al_map_rgb(255, 255, 255), SCREEN_W / 2, 250, ALLEGRO_ALIGN_CENTRE, "%s", texto);
printf("check\n");
initClock();
}
al_draw_bitmap(seletor, seletor_x, seletor_y, 0);
al_flip_display();
}
}
//Destrói os objetos
al_destroy_bitmap(background);
al_destroy_bitmap(seletor);
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
return 0;
}
/** A Menu loopja
* @param menu-re mutato pointer
* @return nincs->void
* @author Pjatacsuk Bence
* @date 2011.10.2
*/
void MenuLoop(Menu* MyMenu)
{
int redraw;
bool MenuLoop = true;
// allapot all;
/* A megfelelõ event források regisztrálása, display,timer,keyboard */
al_register_event_source(MyMenu->event_queue, al_get_display_event_source(MyMenu->display));
al_register_event_source(MyMenu->event_queue, al_get_timer_event_source(MyMenu->timer));
al_register_event_source(MyMenu->event_queue, al_get_keyboard_event_source());
al_start_timer(MyMenu->timer); // timer inditás
redraw = true;
all = newgame;
while(MenuLoop)
{
ALLEGRO_EVENT ev; // allegro event struct
al_wait_for_event(MyMenu->event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
break;
}
else if(ev.type == ALLEGRO_EVENT_KEY_DOWN) //billentyû lenyomás vizsgálata
{
switch(ev.keyboard.keycode)
{
case ALLEGRO_KEY_UP:
case ALLEGRO_KEY_W:
if(all == quit)
{
all = newgame;
}
break;
case ALLEGRO_KEY_DOWN:
case ALLEGRO_KEY_S:
if(all == newgame)
{
all = quit;
}
break;
case ALLEGRO_KEY_ENTER:
if(all == newgame)
{
MenuLoop = false;
}
else if(all = quit)
{
STOP_GAME = 1;
MenuLoop = false;
}
break;
}
}
else {
redraw = true;
}
if(redraw && al_is_event_queue_empty(MyMenu->event_queue))
{
al_draw_bitmap(MyMenu->bg,0,0,0);
if(all == newgame)
{
al_draw_text(MyMenu->font,al_map_rgb(255,128,0),100,200,0,"New Game");
al_draw_text(MyMenu->font,al_map_rgb(203,203,203),100,300,0,"Quit");
}
else
{
al_draw_text(MyMenu->font,al_map_rgb(203,203,203),100,200,0,"New Game");
al_draw_text(MyMenu->font,al_map_rgb(255,128,0),100,300,0,"Quit");
}
al_flip_display();
redraw = false;
}
}
}
static void main_loop(ALLEGRO_DISPLAY *display, ALLEGRO_BITMAP *picture)
{
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_EVENT event;
bool can_draw;
int new_res;
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));
can_draw = true;
while (1) {
if (al_is_event_queue_empty(queue) && can_draw) {
redraw(picture);
}
al_wait_for_event(queue, &event);
if (event.type == ALLEGRO_EVENT_DISPLAY_LOST) {
log_printf("Display lost\n");
can_draw = false;
continue;
}
if (event.type == ALLEGRO_EVENT_DISPLAY_FOUND) {
log_printf("Display found\n");
can_draw = true;
continue;
}
if (event.type != ALLEGRO_EVENT_KEY_CHAR) {
continue;
}
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
break;
}
new_res = cur_res;
if (event.keyboard.unichar == '+' ||
event.keyboard.unichar == ' ' ||
event.keyboard.keycode == ALLEGRO_KEY_ENTER) {
new_res++;
if (new_res >= NUM_RESOLUTIONS)
new_res = 0;
}
else if (event.keyboard.unichar == '-') {
new_res--;
if (new_res < 0)
new_res = NUM_RESOLUTIONS - 1;
}
if (new_res != cur_res) {
cur_res = new_res;
log_printf("Switching to %dx%d... ", res[cur_res].w, res[cur_res].h);
if (al_resize_display(display, res[cur_res].w, res[cur_res].h)) {
log_printf("Succeeded.\n");
}
else {
log_printf("Failed. current resolution: %dx%d\n",
al_get_display_width(display), al_get_display_height(display));
}
}
}
al_destroy_event_queue(queue);
}
void gameloop() {
while (!danmakux.done) {
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if (ev.type == ALLEGRO_EVENT_TIMER) {
redraw = true;
update();
gameLogic();
}
else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
danmakux.done = true;
}
else if (ev.type == ALLEGRO_EVENT_KEY_DOWN) {
if (danmakux.state_playing && !danmakux.state_paused) {
switch (ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
danmakux.player->moveu = true;
break;
case ALLEGRO_KEY_DOWN:
danmakux.player->moved = true;
break;
case ALLEGRO_KEY_LEFT:
danmakux.player->movel = true;
break;
case ALLEGRO_KEY_RIGHT:
danmakux.player->mover = true;
break;
case ALLEGRO_KEY_Z:
danmakux.player->fireFront = 1;
break;
case ALLEGRO_KEY_X:
danmakux.player->fireBack = 1;
break;
case ALLEGRO_KEY_C:
danmakux.player->fireSide = 1;
break;
case ALLEGRO_KEY_LSHIFT:
danmakux.player->focused = true;
break;
case ALLEGRO_KEY_ESCAPE:
break;
}
}
else if (danmakux.state_menu) {
std::stringstream levelno;
std::string level;
switch (ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
danmakux.menuChoice -= 1;
if (danmakux.menuChoice < 0) danmakux.menuChoice = danmakux.menuitems.size()-1;
break;
case ALLEGRO_KEY_DOWN:
danmakux.menuChoice = (danmakux.menuChoice + 1) % danmakux.menuitems.size();
break;
case ALLEGRO_KEY_LEFT:
danmakux.menuChoice -= 1;
if (danmakux.menuChoice < 0) danmakux.menuChoice = danmakux.menuitems.size()-1;
break;
case ALLEGRO_KEY_RIGHT:
danmakux.menuChoice = (danmakux.menuChoice + 1) % danmakux.menuitems.size();
break;
case ALLEGRO_KEY_Z:
switch (danmakux.menuChoice) {
case 0:
clearMenu();
danmakux.state_menu = false;
danmakux.state_playing = true;
danmakux.state_paused = false;
danmakux.state_dialog = false;
levelno << danmakux.currentLevel;
level = "level" + levelno.str();
plyr_load(danmakux.player, "machine");
loadLevel(level);
break;
case 1:
break;
case 2:
danmakux.done = true;
break;
}
break;
case ALLEGRO_KEY_X:
danmakux.menuChoice = 2;
break;
}
}
else if (danmakux.state_paused) {
switch (ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
danmakux.menuChoice -= 1;
if (danmakux.menuChoice < 0) danmakux.menuChoice = danmakux.pauseitems.size()-1;
break;
case ALLEGRO_KEY_DOWN:
danmakux.menuChoice = (danmakux.menuChoice + 1) % danmakux.pauseitems.size();
break;
case ALLEGRO_KEY_LEFT:
danmakux.menuChoice -= 1;
if (danmakux.menuChoice < 0) danmakux.menuChoice = danmakux.pauseitems.size()-1;
break;
case ALLEGRO_KEY_RIGHT:
danmakux.menuChoice = (danmakux.menuChoice + 1) % danmakux.pauseitems.size();
break;
case ALLEGRO_KEY_Z:
break;
case ALLEGRO_KEY_X:
danmakux.fireBomb = true;
break;
}
}
}
else if (ev.type == ALLEGRO_EVENT_KEY_UP) {
if (danmakux.state_playing && !danmakux.state_paused) {
switch (ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
danmakux.player->moveu = false;
break;
case ALLEGRO_KEY_DOWN:
danmakux.player->moved = false;
break;
case ALLEGRO_KEY_LEFT:
danmakux.player->movel = false;
break;
case ALLEGRO_KEY_RIGHT:
danmakux.player->mover = false;
break;
case ALLEGRO_KEY_Z:
danmakux.player->fireFront = 0;
break;
case ALLEGRO_KEY_X:
danmakux.player->fireBack = 0;
break;
case ALLEGRO_KEY_C:
danmakux.player->fireSide = 0;
break;
case ALLEGRO_KEY_LSHIFT:
danmakux.player->focused = false;
break;
}
}
}
if (redraw && al_is_event_queue_empty(event_queue)) {
redrawDisp();
}
}
}
int main(int argc, char **argv){
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
bool redraw = true;
if(!al_init()) {
fprintf(stderr, "failed to initialize allegro!\n");
return -1;
}
timer = al_create_timer(1.0 / FPS);
if(!timer) {
fprintf(stderr, "failed to create timer!\n");
return -1;
}
display = al_create_display(640, 480);
if(!display) {
fprintf(stderr, "failed to create 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(1)
{
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) {
break;
}
if(redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
}
}
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 bouncer_x = SCREEN_W / 2.0 - BOUNCER_SIZE / 2.0;
float bouncer_y = SCREEN_H / 2.0 - BOUNCER_SIZE / 2.0;
bool key[4] = { false, false, false, false };
bool redraw = true;
bool doexit = false;
srand(time(NULL));
if(!al_init()) {
fprintf(stderr, "failed to initialize allegro!\n");
return -1;
}
al_install_keyboard();
al_init_primitives_addon();
timer = al_create_timer(1.0 / FPS);
if(!timer) {
fprintf(stderr, "failed to create timer!\n");
return -1;
}
display = al_create_display(SCREEN_W, SCREEN_H);
if(!display) {
fprintf(stderr, "failed to create display!\n");
al_destroy_timer(timer);
return -1;
}
bouncer = al_create_bitmap(BOUNCER_SIZE, BOUNCER_SIZE);
if(!bouncer) {
fprintf(stderr, "failed to create bouncer bitmap!\n");
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
al_set_target_bitmap(bouncer);
al_clear_to_color(al_map_rgb(255, 255, 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(255,255,0));
al_flip_display();
al_start_timer(timer);
//¡¡QUE EMPIEZE LA FIESTA!!
//¿En qué momento ponemos como verdaderos lo booleanos de las teclas?
while(!doexit)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_TIMER/*?*/) {
//Revisa si se sale de los bordes de la pantalla, pero no sé porqué no lo hace siempre
if(key[KEY_UP] && bouncer_y >= 4.0) {
bouncer_y -= 4.0;
}
if(key[KEY_DOWN] && bouncer_y <= SCREEN_H - BOUNCER_SIZE - 4.0) {
bouncer_y += 4.0;
}
if(key[KEY_LEFT] && bouncer_x >= 4.0) {
bouncer_x -= 4.0;
}
if(key[KEY_RIGHT] && bouncer_x <= SCREEN_W - BOUNCER_SIZE - 4.0) {
bouncer_x += 4.0;
}
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_W:
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;
}
}
else if(ev.type == ALLEGRO_EVENT_KEY_UP) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
key[KEY_UP] = false;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = false;
break;
case ALLEGRO_KEY_LEFT:
key[KEY_LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_RIGHT] = false;
break;
case ALLEGRO_KEY_ESCAPE:
doexit = true;
break;
}
}
if(redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
al_clear_to_color(al_map_rgb(0,0,0));
al_draw_bitmap(bouncer, bouncer_x, bouncer_y, 0);
al_flip_display();
}
}
al_destroy_bitmap(bouncer);
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
return 0;
}
void Mousebinds::update() noexcept
{
m_mouseLeftClick = false;
m_mouseRightClick = false;
m_mouseWheelChange = 0;
if (leftMouseHeld())
{
m_mouseLeftClickHeldDuration++;
}
if (rightMouseHeld())
{
m_mouseRightClickHeldDuration++;
}
while (!al_is_event_queue_empty(m_events))
{
al_get_next_event(m_events, &m_event);
ALLEGRO_EVENT_TYPE ty = m_event.type;
if (ty == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN)
{
m_mouseEvent = m_event.mouse;
//left mouse button
if (m_mouseEvent.button & 1)
{
m_mouseLeftClick = true;
m_mouseLeftClickHeld = true;
m_mouseLeftClickHeldDuration = 0;
//printf("left mouse click at x: %d y: %d\n", m_mouseEvent.x, m_mouseEvent.y);
}
//right mouse button
else if (m_mouseEvent.button & 2)
{
m_mouseRightClick = true;
m_mouseRightClickHeld = true;
m_mouseRightClickHeldDuration = 0;
//printf("right mouse click at x: %d y: %d\n", m_mouseEvent.x, m_mouseEvent.y);
}
}
if (ty == ALLEGRO_EVENT_MOUSE_BUTTON_UP)
{
m_mouseEvent = m_event.mouse;
//left mouse button
if (m_mouseEvent.button & 1)
{
m_mouseLeftClick = false;
m_mouseLeftClickHeld = false;
m_mouseLeftClickHeldDuration = 0;
//printf("left mouse click at x: %d y: %d\n", m_mouseEvent.x, m_mouseEvent.y);
}
//right mouse button
else if (m_mouseEvent.button & 2)
{
m_mouseRightClick = false;
m_mouseRightClickHeld = false;
m_mouseRightClickHeldDuration = 0;
//printf("right mouse click at x: %d y: %d\n", m_mouseEvent.x, m_mouseEvent.y);
}
}
//mouse was moved
if (ty == ALLEGRO_EVENT_MOUSE_AXES)
{
m_mouseEvent = m_event.mouse;
m_mousePos.x = m_mouseEvent.x;
m_mousePos.y = m_mouseEvent.y;
m_mouseWheel = m_mouseEvent.z;
m_mouseWheelChange = m_mouseEvent.dz;
//printf("mouse at x: %d y: %d\n", mouseEvent.x, mouseEvent.y);
}
}
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_BITMAP *bouncer = NULL;
float bouncer_x = SCREEN_W / 2.0 - BOUNCER_SIZE / 2.0;
float bouncer_y = SCREEN_H / 2.0 - BOUNCER_SIZE / 2.0;
bool redraw = true;
if(!al_init()) {
fprintf(stderr, "failed to initialize allegro!\n");
return -1;
}
if(!al_install_mouse()) {
fprintf(stderr, "failed to initialize the mouse!\n");
return -1;
}
timer = al_create_timer(1.0 / FPS);
if(!timer) {
fprintf(stderr, "failed to create timer!\n");
return -1;
}
display = al_create_display(SCREEN_W, SCREEN_H);
if(!display) {
fprintf(stderr, "failed to create display!\n");
al_destroy_timer(timer);
return -1;
}
bouncer = al_create_bitmap(BOUNCER_SIZE, BOUNCER_SIZE);
if(!bouncer) {
fprintf(stderr, "failed to create bouncer bitmap!\n");
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
al_set_target_bitmap(bouncer);
al_clear_to_color(al_map_rgb(255, 0, 255));
al_set_target_bitmap(al_get_backbuffer(display));
event_queue = al_create_event_queue();
if(!event_queue) {
fprintf(stderr, "failed to create event_queue!\n");
al_destroy_bitmap(bouncer);
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_register_event_source(event_queue, al_get_mouse_event_source());
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
al_start_timer(timer);
while(1)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_TIMER) {
redraw = true;
}
else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
else if(ev.type == ALLEGRO_EVENT_MOUSE_AXES ||
ev.type == ALLEGRO_EVENT_MOUSE_ENTER_DISPLAY) {
bouncer_x = ev.mouse.x;
bouncer_y = ev.mouse.y;
}
else if(ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP) {
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(bouncer, bouncer_x, bouncer_y, 0);
al_flip_display();
}
}
al_destroy_bitmap(bouncer);
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
return 0;
}
void do_highscores(int score)
{
read_scores();
ResourceManager& rm = ResourceManager::getInstance();
Input *input = (Input *)rm.getData(RES_INPUT);
ALLEGRO_FONT *sm_font = (ALLEGRO_FONT *)rm.getData(RES_SMALLFONT);
ALLEGRO_FONT *big_font = (ALLEGRO_FONT *)rm.getData(RES_LARGEFONT);
bool is_high = score >= highScores[NUM_SCORES-1].score;
bool entering = is_high;
double bail_time = al_get_time() + 8;
int letter_num = 0;
char name[4] = " ";
int character = 0;
double next_input = al_get_time();
double spin_start = 0;
int spin_dir = 1;
for (;;) {
/* Catch close button presses */
ALLEGRO_EVENT_QUEUE *events = ((DisplayResource *)rm.getResource(RES_DISPLAY))->getEventQueue();
while (!al_is_event_queue_empty(events)) {
ALLEGRO_EVENT event;
al_get_next_event(events, &event);
#ifdef ALLEGRO_IPHONE
if (event.type == ALLEGRO_EVENT_DISPLAY_HALT_DRAWING || event.type == ALLEGRO_EVENT_DISPLAY_SWITCH_OUT) {
switch_game_out(event.type == ALLEGRO_EVENT_DISPLAY_HALT_DRAWING);
}
else if (event.type == ALLEGRO_EVENT_DISPLAY_RESUME_DRAWING || event.type == ALLEGRO_EVENT_DISPLAY_SWITCH_IN) {
switch_game_in();
}
#else
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
exit(0);
#endif
}
input->poll();
if (entering && al_get_time() > next_input) {
float lr = input->lr();
if (lr != 0) {
if (lr < 0) {
character--;
if (character < 0)
character = 25;
spin_dir = 1;
}
else if (lr > 0) {
character++;
if (character >= 26)
character = 0;
spin_dir = -1;
}
next_input = al_get_time()+0.2;
my_play_sample(RES_FIRESMALL);
spin_start = al_get_time();
}
if (input->b1() && letter_num < 3) {
name[letter_num] = 'A' + character;
letter_num++;
if (letter_num >= 3) {
entering = false;
bail_time = al_get_time()+8;
insert_score(name, score);
write_scores();
}
next_input = al_get_time()+0.2;
my_play_sample(RES_FIRELARGE);
}
}
else if (!entering) {
if (al_get_time() > bail_time) {
return;
}
else if (input->b1() && al_get_time() > next_input) {
al_rest(0.250);
return;
}
}
al_rest(0.010);
#ifdef ALLEGRO_IPHONE
if (switched_out) {
continue;
}
#endif
al_clear_to_color(al_map_rgb(0, 0, 0));
if (entering) {
float a = ALLEGRO_PI*3/2;
float ainc = ALLEGRO_PI*2 / 26;
double elapsed = al_get_time() - spin_start;
if (elapsed < 0.1) {
a += (elapsed / 0.1) * ainc * spin_dir;
}
float scrh = BB_H / 2 - 32;
float h = al_get_font_line_height(sm_font);
for (int i = 0; i < 26; i++) {
int c = character + i;
if (c >= 26)
c -= 26;
char s[2];
s[1] = 0;
s[0] = 'A' + c;
int x = BB_W/2 + (cos(a) * scrh) - al_get_text_width(sm_font, s);
int y = BB_H/2 + (sin(a) * scrh) - h/2;
al_draw_textf(sm_font, i == 0 ? al_map_rgb(255, 255, 0) : al_map_rgb(200, 200, 200), x, y, 0, "%s", s);
a += ainc;
}
char tmp[4] = { 0, };
for (int i = 0; i < 3 && name[i] != ' '; i++) {
tmp[i] = name[i];
}
al_draw_textf(big_font, al_map_rgb(0, 255, 0), BB_W/2, BB_H/2-20, ALLEGRO_ALIGN_CENTRE, "%s", tmp);
al_draw_text(sm_font, al_map_rgb(200, 200, 200), BB_W/2, BB_H/2-20+5+al_get_font_line_height(big_font), ALLEGRO_ALIGN_CENTRE, "high score!");
}
else {
int yy = BB_H/2 - al_get_font_line_height(big_font)*NUM_SCORES/2;
for (int i = 0; i < NUM_SCORES; i++) {
al_draw_textf(big_font, al_map_rgb(255, 255, 255), BB_W/2-10, yy, ALLEGRO_ALIGN_RIGHT, "%s", highScores[i].name);
al_draw_textf(big_font, al_map_rgb(255, 255, 0), BB_W/2+10, yy, ALLEGRO_ALIGN_LEFT, "%d", highScores[i].score);
yy += al_get_font_line_height(big_font);
}
}
#ifdef ALLEGRO_IPHONE
input->draw();
#endif
al_flip_display();
}
}
int
main (int argc, char **argv)
{
Pelota pelota[N];
srand (time (NULL));
iniciar_allegro ();
for (int i = 0; i < N; i++)
pelota[i].set_dibujo (bm);
while (1)
{ /* Buzz Lightyear */
ALLEGRO_EVENT ev;
ALLEGRO_TIMEOUT timeout;
al_init_timeout (&timeout, 0.06);
bool get_event = al_wait_for_event_until (event_queue, &ev, &timeout);
if (get_event)
{
if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
break;
if (ev.type == ALLEGRO_EVENT_TIMER)
redraw = true;
if (ev.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch (ev.keyboard.keycode)
{
case ALLEGRO_KEY_UP:
tecla[KEY_UP] = true;
break;
case ALLEGRO_KEY_DOWN:
tecla[KEY_DOWN] = true;
break;
case ALLEGRO_KEY_LEFT:
tecla[KEY_LEFT] = true;
break;
case ALLEGRO_KEY_RIGHT:
tecla[KEY_RIGHT] = true;
break;
}
}
if (ev.type == ALLEGRO_EVENT_KEY_UP)
{
switch (ev.keyboard.keycode)
{
case ALLEGRO_KEY_UP:
tecla[KEY_UP] = false;
break;
case ALLEGRO_KEY_DOWN:
tecla[KEY_DOWN] = false;
break;
case ALLEGRO_KEY_LEFT:
tecla[KEY_LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
tecla[KEY_RIGHT] = false;
break;
case ALLEGRO_KEY_LSHIFT:
sprite_number++;
break;
}
}
}
/* Actualizar las coordenadas de la pelota */
if (tecla[KEY_UP])
pelota.change_vy (-DELTA);
if (tecla[KEY_DOWN])
pelota.change_vy (DELTA);
if (tecla[KEY_LEFT])
pelota.change_vx (-DELTA);
if (tecla[KEY_RIGHT])
pelota.change_vx (DELTA);
for (int i = 0; i < N; i++)
pelota[i].actualizate ();
if (redraw && al_is_event_queue_empty (event_queue))
{
al_clear_to_color (al_map_rgb (0, 0, 0));
al_draw_bitmap (bm2, 0, 0, 0);
for (int i = 0; i < N; i++)
al_draw_bitmap (pelota[i].get_dibujo (), pelota[i].get_x () + 450,
pelota[i].get_y () + 450, 0);
al_flip_display ();
redraw = false;
}
}
destruir_allegro ();
return 0;
}
void game_loop(void)
{
bool redraw = true;
al_start_timer(timer);
int windowWidth = al_get_display_width(display);
int windowHeight = al_get_display_height(display);
User user{};
user.user_x = windowWidth/2;
int level_nr = 1;
LevelData level(create_level(60, level_nr, true));
ALLEGRO_KEYBOARD_STATE kbd_state;
double start_time = 0;
double time_last = 0;
double time_curr = 0;
double elapsed_time = 0;
double elapsed_time_unadjusted = 0;
bool death = false;
int finished_level = 5;
int num_kills = 0;
while (!done)
{
auto& opponents = level.opponents;
ALLEGRO_EVENT event;
al_wait_for_event(event_queue, &event);
if (event.type == ALLEGRO_EVENT_TIMER)
{
//done = main_loop.tick();
redraw = true;
time_curr = al_get_time();
double dt = time_curr - time_last;
dt = std::min(dt, 0.2);
elapsed_time_unadjusted += dt;
elapsed_time = elapsed_time_unadjusted - start_time;
for (auto& opponent : opponents)
{
if (!opponent.active && elapsed_time >= opponent.time)
{
opponent.active = true;
opponent.x = opponent.direction == Direction::LEFT ? windowWidth - 100 : 100;
}
else if (opponent.active)
{
int sign = opponent.direction == Direction::LEFT ? -1 : 1;
opponent.x += sign*opponent.speed*dt;
}
}
for (int i = 0; i < opponents.size(); i++)
{
auto& opponent = opponents[i];
if (opponent.active && overlaps(user.user_x, opponent.x, user.rect_size))
{
user.user_shape = opponent.is_shapeshifter ? opponent.shape : user.user_shape;
if (opponent.shape != user.user_shape)
{
death = true;
}
else
{
num_kills++;
}
opponents.erase(opponents.begin() + i);
i--;
}
}
al_get_keyboard_state(&kbd_state);
bool left = al_key_down(&kbd_state,ALLEGRO_KEY_LEFT) || al_key_down(&kbd_state, ALLEGRO_KEY_A);
bool right = al_key_down(&kbd_state,ALLEGRO_KEY_RIGHT) || al_key_down(&kbd_state, ALLEGRO_KEY_D);
if (left && !right)
{
user.user_x = user.user_x - user.user_speed*dt;
}
else if (!left && right)
{
user.user_x = user.user_x + user.user_speed*dt;
}
user.user_x = std::max(100.0 + 2*user.rect_size, user.user_x);
user.user_x = std::min(static_cast<double>(windowWidth) - 100.0 -(2*user.rect_size), user.user_x);
time_last = time_curr;
}
else if (event.type == ALLEGRO_EVENT_KEY_DOWN) {
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
done = true;
}
{
//main_loop.key_pressed(event.keyboard.keycode);
}
}
else if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
done = true;
}
if (redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
al_clear_to_color(ColorScheme::color_bg());
Drawing::draw_all(windowWidth, windowHeight, user, opponents);
if (level.first_level)
{
Drawing::draw_tutorial_texts(font, ColorScheme::color1(), windowWidth/2 , windowHeight/5, elapsed_time);
}
else if (level_nr != finished_level)
{
Drawing::draw_level_texts(font, ColorScheme::color1(), windowWidth/2, windowHeight/5, level_nr, elapsed_time);
}
else
{
Drawing::draw_credits(font, ColorScheme::color1(), windowWidth/2, windowHeight/5);
}
al_flip_display();
}
if (death)
{
if (level_nr == 1)
level = create_level(60, level_nr, false);
else
level = create_level(60, level_nr, false);
user = User{};
user.user_x = windowWidth/2;
start_time = al_get_time();
death = false;
num_kills = 0;
}
else if (opponents.empty())
{
level_nr++;
level = create_level(60, level_nr, false);
user = User{};
user.user_x = windowWidth/2;
start_time = al_get_time();
death = false;
num_kills = 0;
}
}
}
int main(){
/*Game Settings*/
State state = STARTED;
int render = 0;
ALLEGRO_DISPLAY *display;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_TIMER *timer;
ALLEGRO_FONT *pixelate;
ALLEGRO_BITMAP *back1;
ALLEGRO_BITMAP *back2;
ALLEGRO_BITMAP *space;
ALLEGRO_BITMAP *logo;
struct Background bg1;
struct Background bg2;
struct Background bgspace;
al_init();
display = al_create_display(800, 600);
al_set_window_position(display, 100, 100);
al_set_window_title(display, "GaliType - Grupo 6");
al_init_font_addon();
al_init_ttf_addon();
al_init_image_addon();
al_install_keyboard();
back1 = al_load_bitmap("back1.png");
back2 = al_load_bitmap("back2.png");
space = al_load_bitmap("space.jpg");
logo = al_load_bitmap("logo.png");
initBack(&bg1, 0, 0, 1.5, -1, 800, 600, back1);
initBack(&bg2, 0, 0, 1, -1, 800, 600, back2);
initBack(&bgspace, 0, 0, 0.5, -1, 1000, 600, space);
queue = al_create_event_queue();
timer = al_create_timer(1.0 / 60);
al_register_event_source(queue, al_get_timer_event_source(timer));
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_display_event_source(display));
pixelate = al_load_ttf_font("Pixelate.ttf", 30, 0);
al_start_timer(timer);
while (state != FINISHED){
ALLEGRO_EVENT ev;
al_wait_for_event(queue, &ev);
if (ev.type == ALLEGRO_EVENT_KEY_DOWN){
if (state == STARTED){
switch (ev.keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
state = FINISHED;
break;
case ALLEGRO_KEY_ENTER:
state = SELECT_DIFFICULTY;
break;
}
}
if (state == SELECT_DIFFICULTY){
switch (ev.keyboard.keycode){
case ALLEGRO_KEY_1:
case ALLEGRO_KEY_PAD_1:
startGame(EASY);
break;
case ALLEGRO_KEY_2:
case ALLEGRO_KEY_PAD_2:
startGame(MEDIUM);
break;
case ALLEGRO_KEY_3:
case ALLEGRO_KEY_PAD_3:
startGame(HARD);
break;
case ALLEGRO_KEY_4:
case ALLEGRO_KEY_PAD_4:
startGame(TYPING_MASTER);
break;
case ALLEGRO_KEY_ESCAPE:
state = STARTED;
break;
}
}
}
else if (ev.type == ALLEGRO_EVENT_TIMER)
{
updateBack(&bg1);
updateBack(&bg2);
updateBack(&bgspace);
render = 1;
}
else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE){
state = FINISHED;
}
if (render == 1 && al_is_event_queue_empty(queue))
{
render = 0;
drawBack(&bgspace);
drawBack(&bg1);
drawBack(&bg2);
al_draw_bitmap(logo, 50, 25, 0);
if (state == STARTED){
al_draw_text(pixelate, al_map_rgb(255, 255, 255), 50, 250, 0, "Get ready to type...");
al_draw_text(pixelate, al_map_rgb(255, 255, 255), 50, 350, 0, "Press Enter to start a new game");
al_draw_text(pixelate, al_map_rgb(255, 255, 255), 50, 450, 0, "Press Esc to exit.");
}
if (state == SELECT_DIFFICULTY){
al_draw_text(pixelate, al_map_rgb(255, 255, 255), 50, 250, 0, "Select difficulty:");
al_draw_text(pixelate, al_map_rgb(255, 255, 255), 50, 300, 0, "1. Easy");
al_draw_text(pixelate, al_map_rgb(255, 255, 255), 50, 350, 0, "2. Medium");
al_draw_text(pixelate, al_map_rgb(255, 255, 255), 50, 400, 0, "3. Hard");
al_draw_text(pixelate, al_map_rgb(255, 255, 255), 50, 450, 0, "4. Typing Boss");
al_draw_text(pixelate, al_map_rgb(255, 255, 255), 50, 500, 0, "Press Esc to return...");
}
al_flip_display();
al_clear_to_color(al_map_rgb(0, 0, 0));
}
}
al_destroy_bitmap(back1);
al_destroy_bitmap(back2);
al_destroy_bitmap(space);
al_destroy_bitmap(logo);
al_destroy_font(pixelate);
al_destroy_display(display);
return 0;
}
void loopGame()
{
bool fin = true;
bool key[KEY_MAX]={0};
while(fin) {
ALLEGRO_EVENT event = {0};
al_wait_for_event(queue, &event);
switch (event.type) {
case ALLEGRO_EVENT_DISPLAY_CLOSE:
fin = false;
break;
case ALLEGRO_EVENT_KEY_DOWN:
switch (event.keyboard.keycode) {
case ALLEGRO_KEY_UP:
key[KEY_UP] = true;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = true;
break;
case ALLEGRO_KEY_A:
key[KEY_A] = true;
break;
case ALLEGRO_KEY_Q:
key[KEY_Q] = true;
break;
}
break;
case ALLEGRO_EVENT_KEY_UP:
switch (event.keyboard.keycode) {
case ALLEGRO_KEY_UP:
key[KEY_UP] = false;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = false;
break;
case ALLEGRO_KEY_A:
key[KEY_A] = false;
break;
case ALLEGRO_KEY_Q:
key[KEY_Q] = false;
break;
}
break;
case ALLEGRO_EVENT_TIMER:
player1.y -= key[KEY_UP] * 10;
player1.y += key[KEY_DOWN] * 10;
if(mode == MULTI)
{
player2.y -= key[KEY_A] * 10;
player2.y += key[KEY_Q] * 10;
}
ball.x += ball.dx;
ball.y += ball.dy;
if(mode == SOLO)
playComputer();
if(al_is_event_queue_empty(queue))
drawWorld();
break;
}
}
}
int main(int argc, char **argv){
struct Movil nave;
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_BITMAP *sprites = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
bool key[4] = { false, false, false, false };
bool redraw = true;
bool doexit = false;
/* Alegro startup */
if(!al_init()) {
al_show_native_message_box(display, "Error", "Error", "Failed to initialize allegro!",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
if(!al_init_image_addon()) {
al_show_native_message_box(display, "Error", "Error", "Failed to initialize al_init_image_addon!",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
if(!al_install_keyboard()){
al_show_native_message_box(display, "Error", "Error", "Failed to initialize al_init_image_addon!",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
return 0;
};
/* Alegro artifact creation */
display = al_create_display(SCREEN_W, SCREEN_H);
if(!display) {
al_show_native_message_box(display, "Error", "Error", "Failed to initialize display!",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
timer = al_create_timer(1.0 / FPS);
if(!timer) {
al_show_native_message_box(display, "Error", "Error", "failed to create timer!\n",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
return -1;
}
event_queue = al_create_event_queue();
if(!event_queue) {
al_show_native_message_box(display, "Error", "Error", "failed to create event_queue!\n",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
/* stitching */
sprites = al_load_bitmap("images/xenon2_sprites.png");
if(!sprites) {
al_show_native_message_box(display, "Error", "Error", "Failed to load sprites!",
NULL, ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
return 0;
}
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(timer));
/* Init game objects */
init(sprites, &nave);
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
al_start_timer(timer);
/* Game loop */
while(!doexit){
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)
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;
}
} else if (ev.type == ALLEGRO_EVENT_KEY_UP) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
key[KEY_UP] = false;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = false;
break;
case ALLEGRO_KEY_LEFT:
key[KEY_LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_RIGHT] = false;
break;
case ALLEGRO_KEY_ESCAPE:
doexit = true;
break;
}
}
update_physics(key, &nave);
if(redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
//al_draw_bitmap(sprites,200,200,0);
al_draw_bitmap(nave.img, 100, 100, 0);
al_flip_display();
}
}
/* Housekeeping */
al_rest(2);
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
al_destroy_bitmap(sprites);
return 0;
}
int main(int argc, char **argv){
//tela
ALLEGRO_DISPLAY *display = NULL;
//fila de eventos detectados pelo Allegro (ex: tecla que foi apertada, clique do mouse etc)
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
//temporizador: quando FPS = 10, a cada 0.1 segundos o tempo passa de t para t+1 e a fila de eventos detecta
ALLEGRO_TIMER *timer = NULL;
//figura do passaro
ALLEGRO_BITMAP *bird = NULL;
//variavel que indica se eh para redesenhar o passaro
bool redraw = true;
//------------------------------ rotinas de inicializacao -------------------------
//inicializa o allegro. Se nao conseguir, imprime na tela uma msg de erro.
if(!al_init()) {
fprintf(stderr, "failed to initialize allegro!\n");
return -1;
}
//inicializa o temporizador com a taxa de 1 quadro a cada 0.1 segundos. Se nao conseguir, imprime na tela uma msg de erro.
timer = al_create_timer(1.0 / FPS);
if(!timer) {
fprintf(stderr, "failed to create timer!\n");
return -1;
}
//inicializa a tela. Se nao conseguir, imprime na tela uma msg de erro.
display = al_create_display(SCREEN_W, SCREEN_H);
if(!display) {
fprintf(stderr, "failed to create display!\n");
al_destroy_timer(timer);
return -1;
}
//inicializar o modulo de imagens
al_init_image_addon();
//carregar a figura .jpg na variavel bird
bird = al_load_bitmap("Angry-Bird.jpg");
//se nao conseguiu achar o arquivo, imprime uma msg de erro
if(!bird) {
fprintf(stderr, "failed to create bird bitmap!\n");
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
//largura e altura da figura do passaro
float largura_passaro = al_get_bitmap_width(bird);
float altura_passaro = al_get_bitmap_height(bird);
//posicao x e y inicial do passaro na tela
float bird_x = 0;
float bird_y = SCREEN_H / 2.0 - altura_passaro / 2.0;
//variacao de x e y ao longo do tempo
float bird_dx = 1.0, bird_dy = 0.0;
//criar a fila de eventos
event_queue = al_create_event_queue();
//se nao conseguiu criar a fila de eventos
if(!event_queue) {
fprintf(stderr, "failed to create event_queue!\n");
al_destroy_bitmap(bird);
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
//registrar mudancas na tela dentro da fila de eventos, isto e, sempre que a tela mudar, um evento ocorrerah
al_register_event_source(event_queue, al_get_display_event_source(display));
//coloca o timer na fila de eventos, isto e, sempre que o tempo passar, um evento eh gerado
al_register_event_source(event_queue, al_get_timer_event_source(timer));
//limpa a tela e coloca o fundo preto, cor: rgb(0,0,0) = preto
al_clear_to_color(al_map_rgb(0,0,0));
//reinicializa a tela
al_flip_display();
//inicia o temporizador
al_start_timer(timer);
//enquanto a posicao x do passaro for menor que a largura da tela
while(bird_x < SCREEN_W)
{
//variavel do tipo evento
ALLEGRO_EVENT ev;
//a variavel ev recebe o primeiro evento da fila de eventos
al_wait_for_event(event_queue, &ev);
//se for um evento de timer, ou seja, se foi o tempo que passou de t para t+1
if(ev.type == ALLEGRO_EVENT_TIMER) {
//incrementa as posicoes x e y do passaro com o seu deslocamento dx e dy
bird_x += bird_dx;
bird_y += bird_dy;
//como eu movi o passaro, preciso redesenhar ele (remova essa linha e veja o que acontece)
redraw = true;
}
//se o evento for o fechamento da tela (clicando no x no canto superior direito)
else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE ) {
//paro de executar o while
break;
}
//se for para eu redesenhar a tela e nao tenho mais nenhum evento para ler
if(redraw && al_is_event_queue_empty(event_queue)) {
//nao preciso redesenhar
redraw = false;
//limpo a tela
al_clear_to_color(al_map_rgb(0,0,0));
//desenho o passaro na nova posicao
al_draw_bitmap(bird, bird_x, bird_y, 0);
//dou um refresh na tela
al_flip_display();
}
} //fim while
//rotinas de fim de jogo
al_destroy_bitmap(bird);
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
return 0;
}
int main(void)
{
bool done = false; // Variavel booleana para identificar se o programa terminou de ser executado
bool redraw = true; // Enquanto essa variavel for verdadeira, ira ser desenhado algo na tela
bool desenha = true;
int draw[5]= {0, 0, 0, 0, 0};
int pos_x = WIDTH / 2;
int pos_y = HEIGHT / 2;
int timer_tiros = 0;
int timer_energy = 0;
int timer_heats = 0;
int timer_tamenho_heat = 0;
int timer_componente = 0;
int count = 0;
Gamer(gamer);
Zone zone[LINHAS][COLUNAS];
Bullet bullets[NUM_BULLETS+1];
Energy energy[NUM_ENERGYS+1];
Heat heats[NUM_HEAT+1];
Zombie zombie[NUM_ZOMBIES];
Battery battery[NUM_BATTERY];
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_FONT *font18 = NULL;
ALLEGRO_FONT *font_maior = NULL;
ALLEGRO_BITMAP *resistor = NULL;
ALLEGRO_BITMAP *capacitor = NULL;
ALLEGRO_BITMAP *indutor = NULL;
ALLEGRO_BITMAP *diodo = NULL;
ALLEGRO_BITMAP *bateria = NULL;
ALLEGRO_BITMAP *protoboard = NULL;
ALLEGRO_BITMAP *fogo = NULL;
ALLEGRO_BITMAP *zombie_bitmap = NULL;
ALLEGRO_BITMAP *ataque_eletromagnetico = NULL;
ALLEGRO_BITMAP *energia_capacitor = NULL;
ALLEGRO_BITMAP *logo = NULL;
if(!al_init()) //initialize Allegro
return -1;
display = al_create_display(WIDTH, HEIGHT); //create our display object
if(!display) //test display object
return -1;
al_init_primitives_addon();
al_install_keyboard();
al_init_font_addon();
al_init_ttf_addon();
al_install_mouse();
al_init_image_addon();
resistor = al_load_bitmap("Resistor.png");
capacitor = al_load_bitmap("Capacitor.png");
indutor = al_load_bitmap("Indutor.png");
diodo = al_load_bitmap("Diodo.png");
bateria = al_load_bitmap("Bateria.png");
protoboard = al_load_bitmap("Protoboard.png");
fogo = al_load_bitmap("fogo_resistor/fire1.png");
zombie_bitmap = al_load_bitmap("Zombie.png");
ataque_eletromagnetico = al_load_bitmap("eletromagnetismo.jpg");
energia_capacitor = al_load_bitmap("energia_capacitor.png");
logo = al_load_bitmap("logo_EvsZ.jpg");
al_convert_mask_to_alpha(resistor, al_map_rgb(255, 0, 255));
al_convert_mask_to_alpha(capacitor, al_map_rgb(255, 0, 255));
al_convert_mask_to_alpha(indutor, al_map_rgb(255, 0, 255));
al_convert_mask_to_alpha(diodo, al_map_rgb(255, 0, 255));
al_convert_mask_to_alpha(bateria, al_map_rgb(255, 0, 255));
al_convert_mask_to_alpha(zombie_bitmap, al_map_rgb(255, 255, 255));
al_convert_mask_to_alpha(ataque_eletromagnetico, al_map_rgb(255, 255, 255));
event_queue = al_create_event_queue();
timer = al_create_timer(1.0 / FPS);
InitGamer(gamer);
InitZone(zone, LINHAS, COLUNAS);
InitBullet(bullets, NUM_BULLETS+1);
InitHeat(heats, NUM_HEAT+1);
InitZombie(zombie, NUM_ZOMBIES);
InitEnergy(energy, NUM_ENERGYS+1);
InitBattery(battery, NUM_BATTERY);
font18 = al_load_font("arial.ttf", 18, 0);
font_maior = al_load_font("arial.ttf", 24, 0);
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_timer_event_source(timer));
al_register_event_source(event_queue, al_get_display_event_source(display));
al_hide_mouse_cursor(display);
al_start_timer(timer);
while(!done)
{
ALLEGRO_EVENT ev;
/*===============================================================================================================================================*/
if(state == MENU)
{
al_wait_for_event(event_queue, &ev);
al_draw_bitmap(logo, WIDTH / 2 - 145, HEIGHT - 500, 0);
al_draw_text(font18, al_map_rgb(255, 255, 255), WIDTH / 2, HEIGHT / 2, ALLEGRO_ALIGN_CENTRE, "Os Zombies querem roubar seu diploma, proteja-o");
al_draw_text(font18, al_map_rgb(0, 255, 255), WIDTH / 2, HEIGHT / 2 + 100, ALLEGRO_ALIGN_CENTRE, "Pressione Space para jogar");
al_draw_text(font_maior, al_map_rgb(0, 255, 0), WIDTH / 2, HEIGHT / 2 + 150, ALLEGRO_ALIGN_CENTRE, "Tecla 1 = Resistor Tecla 2 = Capacitor Tecla 3 = Indutor Tecla 4 = Diodo");
if(ev.type == ALLEGRO_EVENT_KEY_DOWN)
if(ev.keyboard.keycode == ALLEGRO_KEY_SPACE)
state = PLAYING;
if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
done = true;
al_flip_display();
}
/*===============================================================================================================================================*/
if(state == PLAYING)
{
al_wait_for_event(event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
done = true;
if(ev.type == ALLEGRO_EVENT_TIMER)
{
redraw = true;
for(int i = 0; i < LINHAS; i++)
for(int j=0; j<COLUNAS; j++)
if(zone[i][j].x < pos_x &&
zone[i][j].x + ZONEX > pos_x &&
zone[i][j].y < pos_y &&
zone[i][j].y + ZONEY > pos_y)
if(desenha)
if(zone[i][j].draw == 0)
{
if(keys[KEY_1] && gamer.energy >= 100)
{
zone[i][j].draw = draw[1];
gamer.energy -=100;
draw[1] = 0;
}
if(keys[KEY_2] && gamer.energy >= 50)
{
zone[i][j].draw = draw[2];
gamer.energy -=50;
draw[2] = 0;
}
if(keys[KEY_3] && gamer.energy >= 100)
{
zone[i][j].draw = draw[3];
gamer.energy -=100;
draw[3] = 0;
}
if(keys[KEY_4] && gamer.energy >= 100)
{
zone[i][j].draw = draw[4];
gamer.energy -=100;
draw[4] = 0;
}
}
timer_battery_speed++;
timer_battery_start++;
if(timer_battery_start >= 360) // diminui a frequencia com que nasce uma bateria nova
{
StartBattery(battery, NUM_BATTERY);
timer_battery_start = 0;
}
if(timer_battery_speed >= 2) // reduz um pouco a velocidade da bateria
{
UpdateBattery(battery, NUM_BATTERY);
timer_battery_speed = 0;
}
timer_heats++;
for(int i=0; i<LINHAS; i++)
for(int j=0; j<COLUNAS; j++)
if(zone[i][j].draw == 1)
if(timer_heats >= 200)
{
FireHeat(heats, NUM_HEAT+1, zone);
timer_heats = 0;
}
timer_energy++;
timer_energy_cap_death++;
for(int i=0; i<LINHAS; i++)
for(int j=0; j<COLUNAS; j++)
if(zone[i][j].draw == 2)
{
if(timer_energy >= 420)
{
CreateEnergy(energy, NUM_ENERGYS+1, zone);
timer_energy = 0;
}
}
timer_tiros++;
for(int i=0; i<LINHAS; i++)
for(int j=0; j<COLUNAS; j++)
if(zone[i][j].draw == 3)
if(timer_tiros >= 200) // faz os Electronics atirarem numa velocidade constante
{
FireBullet(bullets, NUM_BULLETS+1, zone);
timer_tiros = 0;
}
timer_zombie_start++;
timer_zombie_speed++;
timer_dificuldade++;
if(timer_zombie_start >= 3)
{
StartZombie(zombie, NUM_ZOMBIES);
timer_zombie_start = 0;
}
if(dificuldade >20 && dificuldade <=500)
{
if(timer_dificuldade >= 300)
{
dificuldade -= 30;
timer_dificuldade = 0;
}
}
if(timer_zombie_speed >= 3)
{
UpdateZombie(zombie, NUM_ZOMBIES);
timer_zombie_speed = 0;
}
UpdateBullet(bullets, NUM_BULLETS+1);
CollideBullet(bullets, NUM_BULLETS, zombie, NUM_ZOMBIES, gamer);
CollideHeat(heats, NUM_HEAT, zombie, NUM_ZOMBIES, gamer, timer_tamenho_heat);
CollideZone(zone, LINHAS, COLUNAS, zombie, NUM_ZOMBIES);
CollideZoneDiodo(zone, LINHAS, COLUNAS, zombie, NUM_ZOMBIES);
for(int i = 0; i < NUM_ENERGYS; i++)
if(energy[i].live)
if(energy[i].x - energy[i].boundx < pos_x &&
energy[i].x + energy[i].boundx > pos_x &&
energy[i].y - energy[i].boundy < pos_y &&
energy[i].y + energy[i].boundy > pos_y)
{
energy[i].live = false;
gamer.energy += 25;
}
}
else if(ev.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch(ev.keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
done = true;
break;
case ALLEGRO_KEY_1:
keys[KEY_1] = true;
break;
case ALLEGRO_KEY_2:
keys[KEY_2] = true;
break;
case ALLEGRO_KEY_3:
keys[KEY_3] = true;
break;
case ALLEGRO_KEY_4:
keys[KEY_4] = true;
break;
}
}
else if(ev.type == ALLEGRO_EVENT_KEY_UP)
{
switch(ev.keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
done = true;
break;
case ALLEGRO_KEY_1:
keys[KEY_1] = false;
break;
case ALLEGRO_KEY_2:
keys[KEY_2] = false;
break;
case ALLEGRO_KEY_3:
keys[KEY_3] = false;
break;
case ALLEGRO_KEY_4:
keys[KEY_4] = false;
break;
}
}
else if(ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN)
{
if (ev.mouse.button & 2)
done = true;
}
else if(ev.type == ALLEGRO_EVENT_MOUSE_AXES)
{
pos_x = ev.mouse.x;
pos_y = ev.mouse.y;
CaptureBattery(battery, NUM_BATTERY, ev.mouse.x, ev.mouse.y, gamer);
}
timer_componente++;
if(timer_componente >= 10)
{
if(keys[KEY_1])
draw[1] = 1;
if(keys[KEY_2])
draw[2] = 2;
if(keys[KEY_3])
draw[3] = 3;
if(keys[KEY_4])
draw[4] = 4;
}
if(redraw && al_is_event_queue_empty(event_queue))
{
redraw = false;
DrawZone(zone, LINHAS, COLUNAS, resistor, capacitor, indutor, diodo);
DrawBullet(bullets, NUM_BULLETS+1, ataque_eletromagnetico);
DrawEnergy(energy, NUM_ENERGYS+1, energia_capacitor);
DrawZombie(zombie, NUM_ZOMBIES, zombie_bitmap);
DrawBattery(battery, NUM_BATTERY, bateria);
timer_tamenho_heat++;
DrawHeat(heats, NUM_HEAT+1, timer_tamenho_heat, fogo);
if(timer_tamenho_heat > 80)
for(int i=0; i<NUM_HEAT; i++)
{
heats[i].live = false;
timer_tamenho_heat = 0;
}
al_draw_filled_rectangle(pos_x, pos_y, pos_x + 10, pos_y + 10, al_map_rgb(0, 0, 0));
count++;
al_draw_textf(font18, al_map_rgb(255, 0, 0), WIDTH*13/16, 85, 0, "Time: %i", count/60);
al_draw_textf(font18, al_map_rgb(255, 0, 0), WIDTH*13/300, 85, 0, "Energy: %i", gamer.energy);
al_draw_textf(font18, al_map_rgb(255, 0, 0), WIDTH*13/25, 85, 0, "Score: %i", gamer.score);
al_flip_display();
al_draw_bitmap(protoboard, 0, 0, 0);
}
}
/*================================================================================================================================================*/
if(state == GAMEOVER)
{
al_wait_for_event(event_queue, &ev);
al_clear_to_color(al_map_rgb(0,0,0));
al_draw_text(font18, al_map_rgb(255, 168, 255), WIDTH / 2, HEIGHT / 2, ALLEGRO_ALIGN_CENTRE, "Os Zombies roubaram seu diploma");
al_draw_text(font18, al_map_rgb(255, 255, 255), WIDTH / 2, HEIGHT / 2 +40, ALLEGRO_ALIGN_CENTRE, "Pressione Space para sair");
al_draw_textf(font_maior, al_map_rgb(255, 0, 0), WIDTH*13/28, 85, 0, "Score: %i", gamer.score);
al_flip_display();
if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
done = true;
if(ev.type == ALLEGRO_EVENT_KEY_DOWN)
if(ev.keyboard.keycode == ALLEGRO_KEY_SPACE)
{
al_destroy_event_queue(event_queue);
al_destroy_timer(timer);
al_destroy_font(font18);
al_destroy_bitmap(resistor);
al_destroy_bitmap(capacitor);
al_destroy_bitmap(indutor);
al_destroy_bitmap(diodo);
al_destroy_bitmap(bateria);
al_destroy_bitmap(protoboard);
al_destroy_bitmap(zombie_bitmap);
al_destroy_display(display);
}
}
}
return 0;
}
int main(int argc, const char **argv){
// Variables
ALLEGRO_DISPLAY *ventana = NULL;
ALLEGRO_EVENT_QUEUE *mensajes = NULL;
ALLEGRO_TIMER *alarma = NULL;
bool dibujar = true;
struct Nave nave[N];
srand(time(NULL));
srand48(time(NULL));
al_init();
// Crear:
ventana = al_create_display(SW, SH);
mensajes = al_create_event_queue();
alarma = al_create_timer(1/60.);
al_register_event_source(mensajes,
al_get_display_event_source(ventana));
al_register_event_source(mensajes,
al_get_timer_event_source(alarma));
iniciar(nave);
al_set_target_bitmap(al_get_backbuffer(ventana));
al_start_timer(alarma);
while(1) {
ALLEGRO_EVENT ev;
al_wait_for_event(mensajes, &ev);
if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
break;
if (ev.type == ALLEGRO_EVENT_TIMER)
dibujar = true;
if (dibujar && al_is_event_queue_empty(mensajes) ){
dibujar = false;
recalcular_posiciones(nave);
al_clear_to_color(al_map_rgb(0,0,0));
for (int i=0; i<N; i++)
al_draw_bitmap(nave[i].img, nave[i].x, nave[i].y, 0);
al_flip_display();
}
// Miro los eventos
// Si cierran la ventan
// salgo del bucle
// Si se cumple el tiempo:
// repintar
// Si repintar
// No repintar
// Mover el cuadrado
// Pintar
}
al_destroy_timer(alarma);
al_destroy_display(ventana);
al_destroy_event_queue(mensajes);
return EXIT_SUCCESS;
}
//int main(int argc, char **argv)
int main(int, char **)
{
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
Entity *player = new Entity();
//bool key[4] = { false, false, false, false };
int mvkeys[2] = { 0, 0 };
bool redraw = true;
bool doexit = false;
if(!al_init())
{
fprintf(stderr, "failed to initialize allegro!\n");
return -1;
}
if(!al_init_image_addon())
{
fprintf(stderr, "failed to initialize image addon!\n");
return -1;
}
if(!al_install_keyboard())
{
fprintf(stderr, "failed to initialize the keyboard!\n");
return -1;
}
//--Calculate how long each frame should last in milliseconds, then create
// a timer which ticks at that interval
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;
}
//--Create a camera object for everything to use
fprintf(stderr, "Creating camera\n");
Camera* camera = new Camera();
//--Initialize player entity
player->init(display,camera);
//player.init(display,sprite_x,sprite_y);
//if (player->generate_bitmap() == -1) return -1;
player->set_pos(SCREEN_W/2.0-SPRITE_W/2.0,SCREEN_H/2.0-SPRITE_H/2.0);
MapManager* mapmanager = new MapManager(camera, player);
mapmanager->add_map("data/levels/testmap.tmx");
mapmanager->set_active_map("data/levels/testmap.tmx");
//mapmanager->reset_camera(0,64);
player->set_mapmanager(mapmanager);
//fprintf(stderr, "Tileset for ID %i is %s\n",52,mapmanager->get_active_map()->get_tileset_for_id(19)->name);
//TileMap *testmap = new TileMap("data/levels/outside.tmx");
event_queue = al_create_event_queue();
if(!event_queue)
{
fprintf(stderr, "failed to create event_queue!\n");
delete player;
delete mapmanager;
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);
//--Game Logic--//
if(ev.type == ALLEGRO_EVENT_TIMER)
{
mapmanager->update();
player->update(mvkeys);
//player->updatealt(mvkeys, key);
redraw = true;
}
else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
break;
}
//--Store keypress info
else if(ev.type == ALLEGRO_EVENT_KEY_DOWN)
{
//printf("\n\nKEYCODE: %i\n\n", ev.keyboard.keycode);
switch(ev.keyboard.keycode)
{
case ALLEGRO_KEY_UP:
//key[KEY_UP] = true;
mvkeys[3] = 1;
break;
case ALLEGRO_KEY_DOWN:
//key[KEY_DOWN] = true;
mvkeys[4] = 1;
break;
case ALLEGRO_KEY_LEFT:
//key[KEY_LEFT] = true;
if (!mvkeys[0])
{
mvkeys[0] = ALLEGRO_KEY_LEFT;
}
else
{
//mvkeys[1] = ALLEGRO_KEY_LEFT;
mvkeys[1] = mvkeys[0];
mvkeys[0] = ALLEGRO_KEY_LEFT;
}
break;
case ALLEGRO_KEY_RIGHT:
//key[KEY_RIGHT] = true;
if (!mvkeys[0])
{
mvkeys[0] = ALLEGRO_KEY_RIGHT;
}
else
{
//mvkeys[1] = ALLEGRO_KEY_RIGHT;
mvkeys[1] = mvkeys[0];
mvkeys[0] = ALLEGRO_KEY_RIGHT;
}
break;
}
}
else if(ev.type == ALLEGRO_EVENT_KEY_UP)
{
switch(ev.keyboard.keycode)
{
case ALLEGRO_KEY_UP:
//key[KEY_UP] = false;
mvkeys[3] = 0;
break;
case ALLEGRO_KEY_DOWN:
//key[KEY_DOWN] = false;
mvkeys[4] = 0;
break;
case ALLEGRO_KEY_LEFT:
//key[KEY_LEFT] = false;
if (mvkeys[0] == ALLEGRO_KEY_LEFT)
{
mvkeys[0] = mvkeys[1];
mvkeys[1] = 0;
}
else if (mvkeys[1] == ALLEGRO_KEY_LEFT)
{
mvkeys[1] = 0;
}
break;
case ALLEGRO_KEY_RIGHT:
//key[KEY_RIGHT] = false;
if (mvkeys[0] == ALLEGRO_KEY_RIGHT)
{
mvkeys[0] = mvkeys[1];
mvkeys[1] = 0;
}
else if (mvkeys[1] == ALLEGRO_KEY_RIGHT)
{
mvkeys[1] = 0;
}
break;
case ALLEGRO_KEY_ESCAPE:
doexit = true;
break;
}
}
//printf("\n[%i, %i]\n\n", mvkeys[0], mvkeys[1]);
//--The screen has updated and needs to be redrawn
//--Draw Logic--//
if(redraw && al_is_event_queue_empty(event_queue))
{
redraw = false;
al_clear_to_color(al_map_rgb(50,50,50));
mapmanager->drawbg();
player->draw();
mapmanager->drawmg();
mapmanager->drawfg();
al_flip_display();
}
}
//--You could let Allegro do this automatically, but it's allegedly faster
// if you do it manually
delete player;
//delete testmap;
delete mapmanager;
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
return 0;
}
int main () {
ALLEGRO_DISPLAY *display;
ALLEGRO_EVENT_QUEUE *eventQueue;
ALLEGRO_TIMER *timer;
bool done = false;
al_init();
display = al_create_display(1280, 720);
al_set_window_title(display, "IsoWorld");
eventQueue = al_create_event_queue();
timer = al_create_timer(1.0/constFps);
al_init_primitives_addon();
al_install_keyboard();
al_init_image_addon();
al_register_event_source(eventQueue, al_get_display_event_source(display));
al_register_event_source(eventQueue, al_get_timer_event_source(timer));
al_register_event_source(eventQueue, al_get_keyboard_event_source());
bool redraw = false;
enum Keys { key_up, key_down, key_left, key_right };
Map map("Examples/ex1.map");
al_clear_to_color(al_map_rgb(0, 0, 0));
al_start_timer(timer);
while (!done) {
ALLEGRO_EVENT ev;
al_wait_for_event(eventQueue, &ev);
if (ev.type == ALLEGRO_EVENT_TIMER) {
redraw = true;
} else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
done = true;
} else if (ev.type == ALLEGRO_EVENT_KEY_DOWN) {
switch (ev.keyboard.keycode) {
case ALLEGRO_KEY_Q:
case ALLEGRO_KEY_ESCAPE:
done = true;
break;
default:
break;
}
} else if (ev.type == ALLEGRO_EVENT_KEY_UP) {
}
if (redraw && al_is_event_queue_empty(eventQueue)) {
redraw = false;
al_clear_to_color(al_map_rgb_f(0.0, 0.0, 0.0));
map.Draw();
al_draw_line(0, 720/2, 1280, 720/2, al_map_rgb(255,0,0),1);
al_draw_line(1280/2, 0, 1280/2, 720, al_map_rgb(255,0,0),1);
al_flip_display();
}
}
al_destroy_timer(timer);
al_destroy_event_queue(eventQueue);
al_destroy_display(display);
}
int main(int argc, char **argv)
{
//--------------------------------------------------------------------------------------------------------------------------------
#pragma region "Variable Initialization"
const float FPS = 60;
int screenw = 900;
int screenh = 650;
float bounce = 32;
float bouncer_x = screenw / 2.0 - bounce / 2.0;
float bouncer_y = screenh / 2.0 - bounce / 2.0;
float wall1_x = 30.0;
float wall1_y = 40.0;
float wall1_w = 30.0;
float wall1_h = 30.0;
bool key[4] = { false, false, false, false };
bool redraw = true;
bool exiting = false;
bool menu = false;
enum MYKEYS
{
KEY_UP, KEY_DOWN, KEY_LEFT, KEY_RIGHT
};
pac game;
game.setpacmanx(bouncer_x);
game.setpacmany(bouncer_y);
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_BITMAP *bouncer = NULL;
ALLEGRO_BITMAP *wall1 = NULL;
#pragma endregion
//--------------------------------------------------------------------------------------------------------------------------------
#pragma region "System Protection"
// Begining Initialization
// Checks if Allegro is initialized
if (!al_init()) {
fprintf(stderr, "failed to initialize allegro!\n");
return -1;
}
//Checks if keyboard is initialized
if (!al_install_keyboard()) {
fprintf(stderr, "failed to initialize the keyboard!\n");
return -1;
}
//Checks if mouse is initialized
if (!al_install_mouse()) {
fprintf(stderr, "failed to initialize the mouse!\n");
return -1;
}
//Intializes timer to fps and then checks if there is a timer
timer = al_create_timer(1.0 / FPS);
if (!timer) {
fprintf(stderr, "failed to create timer!\n");
return -1;
}
//checks if there is a display
display = al_create_display(screenw , screenh);
if (!display) {
fprintf(stderr, "failed to create display!\n");
return -1;
}
al_init_font_addon();
al_init_ttf_addon();
ALLEGRO_FONT *font = al_load_ttf_font("DroidSans.ttf", 36, 0);
ALLEGRO_FONT *font2 = al_load_ttf_font("DroidSans.ttf", 12, 0);
if (!font){
fprintf(stderr, "Could not load 'pirulen.ttf'.\n");
return -1;
}
bouncer = al_create_bitmap(bounce, bounce);
if (!bouncer) {
fprintf(stderr, "failed to create bouncer bitmap!\n");
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
wall1 = al_create_bitmap(wall1_w, wall1_h);
if (!bouncer) {
fprintf(stderr, "failed to create bouncer bitmap!\n");
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
al_init_image_addon();
ALLEGRO_DISPLAY_MODE disp_data;
al_get_display_mode(al_get_num_display_modes() - 1, &disp_data);
al_set_target_bitmap(bouncer);
al_clear_to_color(al_map_rgb(255, 0, 0));
al_set_target_bitmap(al_get_backbuffer(display));
al_set_target_bitmap(wall1);
al_clear_to_color(al_map_rgb(0, 0, 255));
al_set_target_bitmap(al_get_backbuffer(display));
event_queue = al_create_event_queue();
if (!event_queue) {
fprintf(stderr, "failed to create event_queue!\n");
al_destroy_bitmap(bouncer);
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
#pragma endregion
//--------------------------------------------------------------------------------------------------------------------------------
#pragma region "Event Initialization"
al_register_event_source(event_queue, al_get_display_event_source(display)); //display event handler
al_register_event_source(event_queue, al_get_timer_event_source(timer)); //time envent handler
al_register_event_source(event_queue, al_get_keyboard_event_source()); //keyboard event handler
al_register_event_source(event_queue, al_get_mouse_event_source()); //mouse event handler
al_clear_to_color(al_map_rgb(0, 0, 0));
al_flip_display();
al_start_timer(timer);
#pragma endregion
//--------------------------------------------------------------------------------------------------------------------------------
#pragma region "Simple Menu"
while (!menu)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if (ev.type == ALLEGRO_EVENT_KEY_UP) {
if (ev.type == ALLEGRO_EVENT_KEY_UP) {
switch (ev.keyboard.keycode) {
case ALLEGRO_KEY_ENTER:
menu = true;
break;
}
}
}
else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
if (redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
al_clear_to_color(al_map_rgb(255, 255, 255));
al_draw_text(font, al_map_rgb(0, 0, 0), screenw / 2, (screenh / 2), ALLEGRO_ALIGN_CENTRE, "Press Enter to Start");
al_flip_display();
}
}
#pragma endregion
//--------------------------------------------------------------------------------------------------------------------------------
#pragma region "Driver Program"
while (!exiting)
{
#pragma region "Timer Events"
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if (ev.type == ALLEGRO_EVENT_TIMER) {
if(key[KEY_UP] && game.getpacmany() >= 4.0) {
game.uppacman();
}
if (key[KEY_DOWN] && game.getpacmany() <= screenh - bounce - 4.0) {
game.downpacman();
}
if (key[KEY_LEFT] && game.getpacmanx() >= 4.0) {
game.leftpacman();
}
if (key[KEY_RIGHT] && game.getpacmany() <= screenw - bounce - 4.0) {
game.rightpacman();
}
redraw = true;
}
// "Closes the Window When Pressing X button"
else if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
#pragma endregion
#pragma region "Checks for when key was pressed down"
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;
}
}
#pragma endregion
#pragma region "Checks for when key was released"
else if (ev.type == ALLEGRO_EVENT_KEY_UP) {
switch (ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
key[KEY_UP] = false;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = false;
break;
case ALLEGRO_KEY_LEFT:
key[KEY_LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_RIGHT] = false;
break;
case ALLEGRO_KEY_ESCAPE:
exiting = true;
break;
case ALLEGRO_KEY_Q:
exiting = true;
break;
//Full screen when f is pressed
case ALLEGRO_KEY_F:
if (screenw != disp_data.width)
{
al_set_new_display_flags(ALLEGRO_FULLSCREEN);
display = al_create_display(disp_data.width, disp_data.height);
screenw = disp_data.width;
screenh = disp_data.height;
wall1_x = 2 * (screenw / 10);
wall1_y = (screenh / screenh) + 50 * (screenh / screenh);
}
break;
//Normal screen when n is pressed
case ALLEGRO_KEY_N:
if (screenw != 640)
{
al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
display = al_create_display(640, 480);
screenw = 640;
screenh = 480;
}
break;
}
}
#pragma endregion
#pragma region "Redraw Objects"
if (redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
al_clear_to_color(al_map_rgb(0, 0, 0));
al_draw_bitmap(wall1, wall1_x, wall1_y, 0);
al_draw_bitmap(bouncer, game.getpacmanx(), game.getpacmany(), 0);
al_draw_text(font2, al_map_rgb(255, 0, 0), screenw / 2, (screenh / screenh), ALLEGRO_ALIGN_CENTRE, "Moving a Square");
al_flip_display();
}
#pragma endregion
}
#pragma endregion
//--------------------------------------------------------------------------------------------------------------------------------
#pragma region "Destroyers"
al_destroy_bitmap(bouncer);
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
#pragma endregion
return 0;
}
static void mainloop(void)
{
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_TIMER *timer;
float *buf;
double pitch = 440;
int i, si;
int n = 0;
bool redraw = false;
for (i = 0; i < N; i++) {
frequency[i] = 22050 * pow(2, i / (double)N);
stream[i] = al_create_audio_stream(4, SAMPLES_PER_BUFFER, frequency[i],
ALLEGRO_AUDIO_DEPTH_FLOAT32, ALLEGRO_CHANNEL_CONF_1);
if (!stream[i]) {
abort_example("Could not create stream.\n");
return;
}
if (!al_attach_audio_stream_to_mixer(stream[i], al_get_default_mixer())) {
abort_example("Could not attach stream to mixer.\n");
return;
}
}
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
for (i = 0; i < N; i++) {
al_register_event_source(queue,
al_get_audio_stream_event_source(stream[i]));
}
#ifdef ALLEGRO_POPUP_EXAMPLES
if (textlog) {
al_register_event_source(queue, al_get_native_text_log_event_source(textlog));
}
#endif
log_printf("Generating %d sine waves of different sampling quality\n", N);
log_printf("If Allegro's resampling is correct there should be little variation\n", N);
timer = al_create_timer(1.0 / 60);
al_register_event_source(queue, al_get_timer_event_source(timer));
al_register_event_source(queue, al_get_display_event_source(display));
al_start_timer(timer);
while (n < 60 * frequency[0] / SAMPLES_PER_BUFFER * N) {
ALLEGRO_EVENT event;
al_wait_for_event(queue, &event);
if (event.type == ALLEGRO_EVENT_AUDIO_STREAM_FRAGMENT) {
for (si = 0; si < N; si++) {
buf = al_get_audio_stream_fragment(stream[si]);
if (!buf) {
continue;
}
for (i = 0; i < SAMPLES_PER_BUFFER; i++) {
double t = samplepos[si]++ / (double)frequency[si];
buf[i] = sin(t * pitch * ALLEGRO_PI * 2) / N;
}
if (!al_set_audio_stream_fragment(stream[si], buf)) {
log_printf("Error setting stream fragment.\n");
}
n++;
log_printf("%d", si);
if ((n % 60) == 0)
log_printf("\n");
}
}
if (event.type == ALLEGRO_EVENT_TIMER) {
redraw = true;
}
if (event.type == ALLEGRO_EVENT_KEY_DOWN &&
event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
break;
}
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
#ifdef ALLEGRO_POPUP_EXAMPLES
if (event.type == ALLEGRO_EVENT_NATIVE_DIALOG_CLOSE) {
break;
}
#endif
if (redraw &&al_is_event_queue_empty(queue)) {
ALLEGRO_COLOR c = al_map_rgb(0, 0, 0);
int i;
al_clear_to_color(al_map_rgb_f(1, 1, 1));
for (i = 0; i < 640; i++) {
al_draw_pixel(i, 50 + waveform[i] * 50, c);
}
al_flip_display();
redraw = false;
}
}
for (si = 0; si < N; si++) {
al_drain_audio_stream(stream[si]);
}
log_printf("\n");
al_destroy_event_queue(queue);
}
static int do_gui(const std::vector<Widget *>& widgets, unsigned int selected)
{
ResourceManager& rm = ResourceManager::getInstance();
ALLEGRO_BITMAP *bg = (ALLEGRO_BITMAP *)rm.getData(RES_BACKGROUND);
Input *input = (Input *)rm.getData(RES_INPUT);
ALLEGRO_BITMAP *logo = (ALLEGRO_BITMAP *)rm.getData(RES_LOGO);
int lw = al_get_bitmap_width(logo);
int lh = al_get_bitmap_height(logo);
#ifndef ALLEGRO_IPHONE
ALLEGRO_FONT *myfont = (ALLEGRO_FONT *)rm.getData(RES_SMALLFONT);
#endif
bool redraw = true;
for (;;) {
/* Catch close button presses */
ALLEGRO_EVENT_QUEUE *events = ((DisplayResource *)rm.getResource(RES_DISPLAY))->getEventQueue();
while (!al_is_event_queue_empty(events)) {
ALLEGRO_EVENT event;
al_get_next_event(events, &event);
#ifdef ALLEGRO_IPHONE
if (event.type == ALLEGRO_EVENT_DISPLAY_HALT_DRAWING || event.type == ALLEGRO_EVENT_DISPLAY_SWITCH_OUT) {
switch_game_out(event.type == ALLEGRO_EVENT_DISPLAY_HALT_DRAWING);
}
else if (event.type == ALLEGRO_EVENT_DISPLAY_RESUME_DRAWING || event.type == ALLEGRO_EVENT_DISPLAY_SWITCH_IN) {
switch_game_in();
}
#else
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
exit(0);
#endif
}
input->poll();
#if defined ALLEGRO_IPHONE
float ud;
if (is_joypad_connected()) {
ud = input->ud();
}
else {
ud = input->lr();
}
#else
float ud = input->ud();
#endif
if (ud < 0 && selected) {
selected--;
my_play_sample(RES_FIRELARGE);
al_rest(0.200);
}
else if (ud > 0 && selected < (widgets.size()-1)) {
selected++;
my_play_sample(RES_FIRELARGE);
al_rest(0.200);
}
if (input->b1()) {
if (!widgets[selected]->activate())
return selected;
}
#ifndef ALLEGRO_IPHONE
if (input->esc())
return -1;
#endif
redraw = true;
#ifdef ALLEGRO_IPHONE
if (switched_out) {
redraw = false;
}
#endif
al_rest(0.010);
if (!redraw) {
continue;
}
al_clear_to_color(al_map_rgb_f(0, 0, 0));
/* draw */
float h = al_get_bitmap_height(bg);
float w = al_get_bitmap_width(bg);
al_draw_bitmap(bg, (BB_W-w)/2, (BB_H-h)/2, 0);
al_draw_bitmap(logo, (BB_W-lw)/2, (BB_H-lh)/4, 0);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
#ifndef ALLEGRO_IPHONE
al_draw_textf(myfont, al_map_rgb(255, 255, 0), BB_W/2, BB_H/2, ALLEGRO_ALIGN_CENTRE, "z/y to start");
#endif
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
for (unsigned int i = 0; i < widgets.size(); i++) {
widgets[i]->render(i == selected);
}
#ifdef ALLEGRO_IPHONE
input->draw();
#endif
al_flip_display();
}
}
int main(int argc, const char *argv[])
{
GLuint pid;
ALLEGRO_DISPLAY *d;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_EVENT event;
ALLEGRO_TIMER *timer;
int frames = 0;
double start;
bool limited = true;
if (argc > 1 && 0 == strcmp(argv[1], "-nolimit")) {
limited = false;
}
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
open_log();
al_set_new_display_flags(ALLEGRO_OPENGL);
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 4, ALLEGRO_SUGGEST);
d = al_create_display(WINDOW_W, WINDOW_H);
if (!d) {
abort_example("Unable to open a OpenGL display.\n");
}
if (al_get_display_option(d, ALLEGRO_SAMPLE_BUFFERS)) {
log_printf("With multisampling, level %i\n", al_get_display_option(d, ALLEGRO_SAMPLES));
}
else {
log_printf("Without multisampling.\n");
}
al_install_keyboard();
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(d));
if (limited) {
timer = al_create_timer(1/60.0);
al_register_event_source(queue, al_get_timer_event_source(timer));
al_start_timer(timer);
}
else {
timer = NULL;
}
if (al_get_opengl_extension_list()->ALLEGRO_GL_ARB_multisample) {
glEnable(GL_MULTISAMPLE_ARB);
}
if (!al_get_opengl_extension_list()->ALLEGRO_GL_ARB_vertex_program) {
abort_example("This example requires a video card that supports "
" the ARB_vertex_program extension.\n");
}
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glDisable(GL_CULL_FACE);
/* Setup projection and modelview matrices */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, WINDOW_W/(float)WINDOW_H, 0.1, 100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* Position the camera to look at our mesh from a distance */
gluLookAt(0.0f, 20.0f, -45.0f, 0.0f, 0.0f, 0.0f, 0, 1, 0);
create_mesh();
/* Define the vertex program */
glEnable(GL_VERTEX_PROGRAM_ARB);
glGenProgramsARB(1, &pid);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, pid);
glGetError();
if (al_get_opengl_extension_list()->ALLEGRO_GL_NV_vertex_program2_option) {
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(program_nv), program_nv);
}
else {
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(program), program);
}
/* Check for errors */
if (glGetError()) {
const char *pgm = al_get_opengl_extension_list()->ALLEGRO_GL_NV_vertex_program2_option
? program_nv : program;
GLint error_pos;
const GLubyte *error_str = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
abort_example("Error compiling the vertex program:\n%s\n\nat "
"character: %i\n%s\n", error_str, (int)error_pos,
pgm + error_pos);
}
start = al_get_time();
while (1) {
if (limited) {
al_wait_for_event(queue, NULL);
}
if (!al_is_event_queue_empty(queue)) {
while (al_get_next_event(queue, &event)) {
switch (event.type) {
case ALLEGRO_EVENT_DISPLAY_CLOSE:
goto done;
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
goto done;
break;
}
}
}
draw_mesh();
al_flip_display();
frames++;
}
done:
log_printf("%.1f FPS\n", frames / (al_get_time() - start));
glDeleteProgramsARB(1, &pid);
al_destroy_event_queue(queue);
al_destroy_display(d);
close_log(true);
return 0;
}
int main(int argc, char **argv){
/*declaramos nave como una estructura tipo móvil, q está definida
* en el archivo "physics.h"*/
struct Movil nave;
/*creamos las variables de allegro, que son punteros
* apuntando a NULL, de momento*/
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_BITMAP *sprites = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
bool key[4] = {false, false, false,false};//Array para las teclas, todos a false
bool redraw = true;
bool do_exit = false;
/* Inicializamos allegro */
if(!al_init()) {
al_show_native_message_box (
display,
"Error",
"Error",
"Failed to initialize allegro!",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
/* Inicializamos añadido de imágenes */
if(!al_init_image_addon()) {
al_show_native_message_box (
display,
"Error",
"Error",
"Failed to initialize al_init_image_addon!",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
ni /* Inicializamos el teclado */
if(!al_install_keyboard()) {
al_show_native_message_box (
display,
"Error",
"Error",
"Failed to initialize al_init_image_addon!",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return 0;
};
/* Alegro artifact creation
* del display, timer, cola eventos y sprites*/
display = al_create_display(SCREEN_W, SCREEN_H);
if(!display) {
al_show_native_message_box(
display,
"Error",
"Error",
"Failed to initialize display!",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
return 0;
}
timer = al_create_timer(1.0 / FPS);
if(!timer) {
al_show_native_message_box(
display,
"Error",
"Error",
"failed to create timer!\n",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
return 0;
}
event_queue = al_create_event_queue();
if(!event_queue) {
al_show_native_message_box(
display,
"Error",
"Error",
"failed to create event_queue!\n",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
al_destroy_timer(timer);
return 0;
}
sprites = al_load_bitmap("images/xenon2_sprites.png");
al_convert_mask_to_alpha(sprites, al_map_rgb(255,0,255));
if(!sprites) {
al_show_native_message_box(
display,
"Error",
"Error",
"Failed to load sprites!",
NULL,
ALLEGRO_MESSAGEBOX_ERROR);
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
return 0;
}
/* registramos todos los eventos provenientes de la pantalla
* el keyboard y el temporizador*/
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(timer));
/* Init es una funcion definida como extern el "physics.h" , que le meto
* los sprites, que es el bitmap de la nave, y &nave, que es una dirección
* de memoria donde hemos declarado nave como estructura*/
init(sprites, &nave);
al_start_timer(timer);
while(!doexit){
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)
break;
/* éste bloque funciona con el evento KEY_DOWN, y cuando apretamos
* cualquier tecla, se registra el avento KEY_DOWN q corresponda */
else if (ev.type == ALLEGRO_EVENT_KEY_DOWN) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
key[KEY_THROTTLE] = true;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_BRAKE] = true;
break;
case ALLEGRO_KEY_LEFT:
key[KEY_ROTATE_LEFT] = true;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_ROTATE_RIGHT] = true;
break;
}
/* Éste bloque funciona con el evento KEY_UP, cuando soltamos
* la tecla se registra el evento KEY_DOWN correspondiente.*/
} else if (ev.type == ALLEGRO_EVENT_KEY_UP) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_UP:
key[KEY_THROTTLE] = false;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_BRAKE] = false;
break;
case ALLEGRO_KEY_LEFT:
key[KEY_ROTATE_LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_ROTATE_RIGHT] = false;
break;
case ALLEGRO_KEY_ESCAPE:
doexit = true;
break;
}
}
if(redraw && al_is_event_queue_empty(event_queue)) {
redraw = false;
update_physics(key, &nave);
al_clear_to_color(al_map_rgb(0,0,0));
// al_draw_bitmap(sprites,200,200,0);
al_draw_bitmap(nave.img[2 + (int) (nave.v.x / ROLL) ],
SCREEN_W / 2 + nave.r.x,
SCREEN_H - 50 - nave.r.y,
0);
al_flip_display();
}
}
/* DEstrucción de los artefactos */
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
al_destroy_bitmap(sprites);
return 0;
}
