Gra napisana w Allegro 5 nie chce się uruchamiać na niektórych komputerach

#include <allegro5/allegro5.h>
#include <allegro5/allegro_image.h>
#include <iostream>
#include <conio.h>
#include <allegro5/allegro_audio.h>
#include <allegro5/allegro_acodec.h>
#include <allegro5/allegro_primitives.h>
#include <allegro5/allegro_font.h>
#include <allegro5/allegro_ttf.h>



using namespace std;

ALLEGRO_MOUSE_STATE mouse;

#define wysokosc(a) al_get_bitmap_height(a)
#define szerokosc(a) al_get_bitmap_width(a)

#include "statek.h"
#include "banner.h"

#define mx mouse.x
#define my mouse.y
#define mb mouse.buttons



void obsluga_klawiszy( ALLEGRO_EVENT & ev );

void menu();
void menu_pauza();
void wybor_statku();
void wybor_mapki();

const double FPS = 1500;
enum KEYS { KEY_LEFT, KEY_RIGHT, KEY_UP, KEY_DOWN, KEY_W, KEY_A, KEY_S, KEY_D, KEY_SPACE, KEY_PAD_0, KEY_ESC, KEY_ENTER };
bool key[ 10 ];
bool doexit = false;

ALLEGRO_BITMAP * tlo = NULL;


statek red( statek::red );
statek blue( statek::blue );

int main()
{
   
   
    al_init();
    al_install_keyboard();
    al_install_mouse();
    al_init_primitives_addon();
    al_init_font_addon();
    al_init_ttf_addon();
   
    ALLEGRO_FONT * font = al_load_ttf_font( "arial.ttf", 72, 0 );
   
    al_set_new_display_flags( ALLEGRO_FULLSCREEN | ALLEGRO_RESIZABLE );
    ALLEGRO_DISPLAY * display = al_create_display( 1920, 1080 );
   
   
    ALLEGRO_EVENT_QUEUE * event_queue = al_create_event_queue();
    ALLEGRO_TIMER * timer = al_create_timer( 1.0 / FPS );
   
    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_register_event_source( event_queue, al_get_mouse_event_source() );
   
   
   
    al_install_audio();
    al_init_acodec_addon();
    al_reserve_samples( 1 );
   
    ALLEGRO_SAMPLE * bang = al_load_sample( "sound/shot.wav" );
   
   
    al_init_image_addon();
   
   
   
   
    al_get_mouse_state( & mouse );
   
   
    menu();
    wybor_statku();
    wybor_mapki();
   
   
   
   
   
    red.x = 0;
    red.y = 0;
    blue.x = 0;
    blue.y = 885;
   
   
    bool redraw = false;
    bool dzwiek_red = 0;
    bool dzwiek_blue = 0;
   
   
   
   
    ALLEGRO_BITMAP * red_p_load1 = al_load_bitmap( "models/red_p_load1.png" );
    ALLEGRO_BITMAP * red_p_load2 = al_load_bitmap( "models/red_p_load2.png" );
    ALLEGRO_BITMAP * red_p_load3 = al_load_bitmap( "models/red_p_load3.png" );
   
    ALLEGRO_BITMAP * blue_p_load1 = al_load_bitmap( "models/blue_p_load1.png" );
    ALLEGRO_BITMAP * blue_p_load2 = al_load_bitmap( "models/blue_p_load2.png" );
    ALLEGRO_BITMAP * blue_p_load3 = al_load_bitmap( "models/blue_p_load3.png" );
   
   
   
    al_start_timer( timer );
   
   
   
    while( true )
    {
        al_get_mouse_state( & mouse );
       
        ALLEGRO_EVENT ev;
        al_wait_for_event( event_queue, & ev );
       
       
        obsluga_klawiszy( ev );
       
        if( ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE )
             break;
       
        else if( ev.type == ALLEGRO_EVENT_TIMER )
        {
            if( key[ KEY_LEFT ] )
                 blue.x--;
           
            if( key[ KEY_RIGHT ] )
                 blue.x++;
           
            if( key[ KEY_A ] )
                 red.x--;
           
            if( key[ KEY_D ] )
                 red.x++;
           
           
           
            if( dzwiek_blue )
            {
                if( blue.type != 1 )
                     al_play_sample( bang, 1.0, 0.0, 1.5, ALLEGRO_PLAYMODE_ONCE, NULL ); //1.5
                else
                     al_play_sample( bang, 1.0, 0.0, 5, ALLEGRO_PLAYMODE_ONCE, NULL ); // 8
               
                dzwiek_blue = 0;
            }
           
            if( dzwiek_red )
            {
                if( red.type != 1 )
                     al_play_sample( bang, 1.0, 0.0, 1.5, ALLEGRO_PLAYMODE_ONCE, NULL ); //1.5
                else
                     al_play_sample( bang, 1.0, 0.0, 5, ALLEGRO_PLAYMODE_ONCE, NULL ); // 8
               
                dzwiek_red = 0;
               
            }
           
           
           
           
            redraw = true;
           
           
        }
       
       
       
        if( redraw && al_is_event_queue_empty( event_queue ) )
        {
           
            al_draw_bitmap( tlo, 0, 0, false );
           
           
           
            cout << "Red = " << red.ile_do_konca << "\tBlue = " << blue.ile_do_konca << "\r";
           
            al_draw_filled_rectangle( 0, 20, red.hp, 9, al_map_rgb( 200, 0, 0 ) );
            al_draw_filled_rectangle( 0, 1060, blue.hp, 1071, al_map_rgb( 0, 0, 255 ) );
           
           
            if( !key[ KEY_LEFT ] && !key[ KEY_RIGHT ] || key[ KEY_LEFT ] && key[ KEY_RIGHT ] )
                 al_draw_bitmap( blue.basic, blue.x, blue.y, 0 );
            else if( key[ KEY_LEFT ] )
                 al_draw_bitmap( blue.lewo, blue.x, blue.y, 0 );
            else if( key[ KEY_RIGHT ] )
                 al_draw_bitmap( blue.prawo, blue.x, blue.y, 0 );
           
           
            if( !key[ KEY_A ] && !key[ KEY_D ] || key[ KEY_A ] && key[ KEY_D ] )
                 al_draw_bitmap( red.basic, red.x, red.y, 0 );
            else if( key[ KEY_A ] )
                 al_draw_bitmap( red.lewo, red.x, red.y, 0 );
            else if( key[ KEY_D ] )
                 al_draw_bitmap( red.prawo, red.x, red.y, 0 );
           
            if( key[ KEY_ESC ] )
                 menu_pauza();
           
           
            //=========================================================================================================================================================
            //========================================================================================================================================================= 
           
           
            if( key[ KEY_SPACE ] && red.type != 3 )
                 red.strzal = true;
           
           
           
           
            if( key[ KEY_SPACE ] && red.type == 3 )
            {
                red.ladowanie = 1;
               
               
                if( red.frame < 500 )
                {
                    al_draw_bitmap( red_p_load1, red.x, red.y, false );
                   
                }
               
                else if( red.frame >= 500 && red.frame < 1400 )
                {
                    al_draw_bitmap( red_p_load2, red.x, red.y, false );
                   
                }
                else if( red.frame >= 1400 )
                {
                    al_draw_bitmap( red_p_load3, red.x, red.y, false );
                   
                }
               
               
               
                if( red.sila_strzalu < 700 )
                     red.sila_strzalu++;
               
                red.frame++;
               
                red.aktualizuj_pocisk();
            }
           
           
           
           
           
            if( !key[ KEY_SPACE ] && red.type == 3 && red.ladowanie )
            {
                red.strzal = 1;
                red.ladowanie = 0;
                red.frame = 0;
               
            }
           
           
           
           
            red.shot();
           
           
           
           
           
            //=========================================================================================================================================================
            //=========================================================================================================================================================         
           
            if( key[ KEY_PAD_0 ] && blue.type != 3 )
                 blue.strzal = true;
           
            if( key[ KEY_PAD_0 ] && blue.type == 3 )
            {
                blue.ladowanie = 1;
               
               
                if( blue.frame < 500 )
                {
                    al_draw_bitmap( blue_p_load1, blue.x, blue.y, false );
                   
                }
               
                else if( blue.frame >= 500 && blue.frame < 1400 )
                {
                    al_draw_bitmap( blue_p_load2, blue.x, blue.y, false );
                   
                }
                else if( blue.frame >= 1400 )
                {
                    al_draw_bitmap( blue_p_load3, blue.x, blue.y, false );
                   
                }
               
               
               
                if( blue.sila_strzalu < 700 )
                     blue.sila_strzalu++;
               
                blue.frame++;
               
                blue.aktualizuj_pocisk();
            }
           
           
           
           
           
            if( !key[ KEY_PAD_0 ] && blue.type == 3 && blue.ladowanie )
            {
                blue.strzal = 1;
                blue.ladowanie = 0;
                blue.frame = 0;
               
            }
           
            blue.shot();
           
           
            //=========================================================================================================================================================
            //========================================================================================================================================================= 
           
           
           
           
            if( blue.x2 >= red.x - red.w + 110 && blue.x2 <= red.x + red.w - 65 && blue.h <= 100 && blue.ile_do_konca < 67 ) // 100  // +65  -65
            {
               
                dzwiek_blue = 1;
                al_draw_bitmap( red.bum, red.x, red.y, 0 );
                red.hp -= blue.sila_strzalu;
                blue.ile_do_konca++;
               
               
               
            }
           
            if( red.x2 >= blue.x - red.w + 110 && red.x2 <= blue.x + blue.w - 65 && red.h >= 900 && red.ile_do_konca < 67 )
            {
                dzwiek_red = 1;
                al_draw_bitmap( blue.bum, blue.x, blue.y, 0 );
                blue.hp -= red.sila_strzalu;
                red.ile_do_konca++;
            }
           
           
            al_flip_display();
        }
    }
   
   
    al_destroy_display( display );
    al_destroy_timer( timer );
    al_destroy_event_queue( event_queue );
   
    return 0;
   
   
   
}


void menu()
{
    ALLEGRO_BITMAP * w_odpal = al_load_bitmap( "banners/odpal.bmp" );
    ALLEGRO_BITMAP * w_wyjdz = al_load_bitmap( "banners/wyjdz.bmp" );
   
    ALLEGRO_BITMAP * odpal_L = al_load_bitmap( "banners/odpal_l.bmp" );
    ALLEGRO_BITMAP * wyjdz_L = al_load_bitmap( "banners/wyjdz_l.bmp" );
   
    banner odpal( w_odpal );
    banner wyjdz( w_wyjdz );
   
   
   
    while( true ) //*****************************************************************************menu
    {
        al_clear_to_color( al_map_rgb( 255, 255, 255 ) );
       
       
        odpal.wyswietl( 300, 50 );
        wyjdz.wyswietl( 550, 700 );
       
       
       
       
        odpal.light( odpal_L );
        wyjdz.light( wyjdz_L );
       
       
        if( odpal.click() )
        {
            break;
        }
       
        else if( wyjdz.click() )
        {
            exit( 1 );
           
        }
       
       
        al_get_mouse_state( & mouse );
        al_flip_display();
       
       
       
       
       
       
    }
}


void menu_pauza()
{
    bool click = 0;
   
   
   
   
    ALLEGRO_BITMAP * w_kontynuuj = al_load_bitmap( "banners/kontynuuj.bmp" );
    ALLEGRO_BITMAP * kontynuuj_L = al_load_bitmap( "banners/kontynuuj_l.bmp" );
   
    ALLEGRO_BITMAP * w_jeszcze_raz = al_load_bitmap( "banners/jeszcze_raz.bmp" );
    ALLEGRO_BITMAP * jeszcze_raz_L = al_load_bitmap( "banners/jeszcze_raz_l.bmp" );
   
    ALLEGRO_BITMAP * w_statek = al_load_bitmap( "banners/statek.bmp" );
    ALLEGRO_BITMAP * statek_L = al_load_bitmap( "banners/statek_l.bmp" );
   
    ALLEGRO_BITMAP * w_mapa = al_load_bitmap( "banners/mapa.bmp" );
    ALLEGRO_BITMAP * mapa_L = al_load_bitmap( "banners/mapa_l.bmp" );
   
    ALLEGRO_BITMAP * w_wyjdz = al_load_bitmap( "banners/wyjdz.bmp" );
    ALLEGRO_BITMAP * wyjdz_L = al_load_bitmap( "banners/wyjdz_l.bmp" );
   
    banner kontynuuj( w_kontynuuj );
    banner jeszcze_raz( w_jeszcze_raz );
    banner statek( w_statek );
    banner mapa( w_mapa );
    banner wyjdz( w_wyjdz );
   
    int srodek = 1920 / 2 - szerokosc( w_kontynuuj ) / 2;
   
   
    while( true ) //menu2
    {
        al_clear_to_color( al_map_rgb( 255, 255, 255 ) );
       
        kontynuuj.wyswietl( srodek, 50 );
        jeszcze_raz.wyswietl( srodek, 400 );
        wyjdz.wyswietl( srodek, 800 );
        statek.wyswietl( 100, 400 );
        mapa.wyswietl( 1500, 400 );
       
       
       
       
        mapa.light( mapa_L );
        statek.light( statek_L );
        kontynuuj.light( kontynuuj_L );
        jeszcze_raz.light( jeszcze_raz_L );
        wyjdz.light( wyjdz_L );
       
        if( mapa.click() )
             click = 1;
       
       
        if( statek.click() )
        {
            red.x = 0;
            blue.x = 1800;
            blue.wygrana = 0;
            red.wygrana = 0;
            red.hp = 1920;
            blue.hp = 1920;
           
            wybor_statku();
            return;
        }
       
       
       
        if( kontynuuj.click() )
             return;
       
        if( jeszcze_raz.click() )
        {
            red.x = 0;
            blue.x = 1800;
            blue.wygrana = 0;
            red.wygrana = 0;
            red.hp = 1920;
            blue.hp = 1920;
            return;
        }
       
        if( wyjdz.click() )
        {
            exit( 0 );
           
        }
       
        if( click && mb == 0 )
        {
            red.x = 0;
            blue.x = 1800;
            blue.wygrana = 0;
            red.wygrana = 0;
            red.hp = 1920;
            blue.hp = 1920;
           
            wybor_mapki();
            return;
        }
       
        al_get_mouse_state( & mouse );
        al_flip_display();
       
    }
}


void wybor_statku()
{
    ALLEGRO_BITMAP * red1 = al_load_bitmap( "models/red_b.png" );
    ALLEGRO_BITMAP * red2 = al_load_bitmap( "models/red_d.png" );
    ALLEGRO_BITMAP * red3 = al_load_bitmap( "models/red_p.png" );
    ALLEGRO_BITMAP * blue1 = al_load_bitmap( "models/blue_b.png" );
    ALLEGRO_BITMAP * blue2 = al_load_bitmap( "models/blue_d.png" );
    ALLEGRO_BITMAP * blue3 = al_load_bitmap( "models/blue_p.png" );
   
   
    bool zaznaczone_rb = 0;
    bool zaznaczone_rd = 0;
    bool zaznaczone_rp = 0;
    bool zaznaczone_bb = 0;
    bool zaznaczone_bd = 0;
    bool zaznaczone_bp = 0;
   
    bool zaz_red = 0;
    bool zaz_blue = 0;
   
   
   
    ALLEGRO_BITMAP * w_zatwierdz = al_load_bitmap( "banners/zatwierdz.bmp" );
    ALLEGRO_BITMAP * zatwierdz_l = al_load_bitmap( "banners/zatwierdz_l.bmp" );
    ALLEGRO_BITMAP * zatwierdz_n = al_load_bitmap( "banners/zatwierdz_n.bmp" );
   
    ALLEGRO_BITMAP * w_red_next = al_load_bitmap( "banners/red_next.png" );
    ALLEGRO_BITMAP * red_next_l = al_load_bitmap( "banners/red_next_l.png" );
    banner red_next( w_red_next );
   
    ALLEGRO_BITMAP * w_red_back = al_load_bitmap( "banners/red_back.png" );
    ALLEGRO_BITMAP * red_back_l = al_load_bitmap( "banners/red_back_l.png" );
    banner red_back( w_red_back );
   
   
    ALLEGRO_BITMAP * w_blue_next = al_load_bitmap( "banners/blue_next.png" );
    ALLEGRO_BITMAP * blue_next_l = al_load_bitmap( "banners/blue_next_l.png" );
    banner blue_next( w_blue_next );
   
    ALLEGRO_BITMAP * w_blue_back = al_load_bitmap( "banners/blue_back.png" );
    ALLEGRO_BITMAP * blue_back_l = al_load_bitmap( "banners/blue_back_l.png" );
    banner blue_back( w_blue_back );
   
    banner zatwierdz( w_zatwierdz );
   
   
   
    ALLEGRO_BITMAP * banner_basic = al_load_bitmap( "banners/banner_basic.png" );
    ALLEGRO_BITMAP * banner_red = al_load_bitmap( "banners/banner_red.bmp" );
    ALLEGRO_BITMAP * banner_blue = al_load_bitmap( "banners/banner_blue.bmp" );
   
    ALLEGRO_BITMAP * hangar = al_load_bitmap( "maps/hangar.bmp" );
    ALLEGRO_BITMAP * hangar_gora = al_load_bitmap( "maps/hangar_gora.bmp" );
    ALLEGRO_BITMAP * hangar_srodek = al_load_bitmap( "maps/hangar_srodek.bmp" );
    ALLEGRO_BITMAP * hangar_dol = al_load_bitmap( "maps/hangar_dol.bmp" );
   
    ALLEGRO_BITMAP * hangar_gora2 = al_load_bitmap( "maps/hangar_gora.bmp" );
    ALLEGRO_BITMAP * hangar_dol2 = al_load_bitmap( "maps/hangar_dol.bmp" );
   
   
   
    banner r_basic( banner_basic );
    banner b_basic( banner_basic );
   
   
   
    int x1 = 0, x2 = 0, x3 = 0;
   
    bool przesun_gora = 0;
    bool przesun_gora_back = 0;
    bool przesun_dol = 0;
    bool przesun_dol_back = 0;
   
    bool rozwin = 0;
   
    int gdzie_x;
    int gdzie_y;
   
    bool redraw = false;
   
   
    ALLEGRO_EVENT_QUEUE * event_queue = al_create_event_queue();
    ALLEGRO_TIMER * timer = al_create_timer( 1.0 / FPS );
   
   
    al_register_event_source( event_queue, al_get_timer_event_source( timer ) );
    al_register_event_source( event_queue, al_get_keyboard_event_source() );
   
   
   
   
    al_start_timer( timer );
   
   
    while( true )
    {
       
       
        ALLEGRO_EVENT ev;
        al_wait_for_event( event_queue, & ev );
       
        obsluga_klawiszy( ev );
       
        if( ev.type == ALLEGRO_EVENT_TIMER )
        {
            //***********************************************RED*********************************************
           
            if( red_next.click() && x1 == 0 )
                 przesun_gora = 1;
           
            if( przesun_gora )
                 x1--;
           
            if( x1 == - 1920 )
                 przesun_gora = 0;
           
           
           
           
            if( red_back.click() && x1 == - 1920 )
                 przesun_gora_back = 1;
           
            if( przesun_gora_back )
                 x1++;
           
            if( x1 == 0 )
                 przesun_gora_back = 0;
           
           
            //***********************************************BLUE**************************************************   
           
            if( blue_next.click() && x3 == 0 )
                 przesun_dol = 1;
           
            if( przesun_dol )
                 x3--;
           
            if( x3 == - 1920 )
                 przesun_dol = 0;
           
           
           
            if( blue_back.click() && x3 == - 1920 )
                 przesun_dol_back = 1;
           
            if( przesun_dol_back )
                 x3++;
           
            if( x3 == 0 )
                 przesun_dol_back = 0;
           
            redraw = true;
        }
       
       
       
       
        if( redraw && al_is_event_queue_empty( event_queue ) )
        {
           
           
            al_clear_to_color( al_map_rgb( 255, 255, 255 ) );
           
            al_draw_bitmap( hangar_gora, x1, 0, false );
            al_draw_bitmap( hangar_srodek, x2, wysokosc( hangar_gora ), false );
            al_draw_bitmap( hangar_dol, x3, wysokosc( hangar_gora ) + wysokosc( hangar_srodek ), false );
           
            al_draw_bitmap( hangar_gora2, 1920 + x1, 0, false );
            al_draw_bitmap( hangar_dol2, 1920 + x3, wysokosc( hangar_gora ) + wysokosc( hangar_srodek ), false );
           
           
            al_draw_bitmap( banner_basic, x1 + 225, 180, false );
            al_draw_bitmap( red2, x1 + 245, 200, false );
           
            al_draw_bitmap( banner_basic, x1 + 425 + szerokosc( red2 ), 180, false );
            al_draw_bitmap( red1, x1 + 445 + szerokosc( red2 ), 180 - 15, false );
           
            al_draw_bitmap( banner_basic, x1 + 600 + szerokosc( red1 ) + szerokosc( red2 ), 180, false );
            al_draw_bitmap( red3, x1 + 625 + szerokosc( red2 ) + szerokosc( red1 ) - 58, 180 - 15, false );
           
           
           
           
            al_draw_bitmap( banner_basic, x3 + 225, 860 - szerokosc( blue2 ), false );
            al_draw_bitmap( blue2, x3 + 245, 880 - szerokosc( blue2 ), false );
           
            al_draw_bitmap( banner_basic, x3 + 425 + szerokosc( blue2 ), 860 - szerokosc( blue2 ), false );
            al_draw_bitmap( blue1, x3 + 445 + szerokosc( blue2 ), 860 - szerokosc( blue2 ) - 25, false );
           
            al_draw_bitmap( banner_basic, x3 + 600 + szerokosc( blue2 ) + szerokosc( blue1 ), 860 - szerokosc( blue2 ), false );
            al_draw_bitmap( blue3, x3 + 625 + szerokosc( blue2 ) + szerokosc( blue1 ) - 57, 860 - szerokosc( blue2 ) - 25, false );
           
           
           
            red_next.wyswietl( 1650, 180 );
            red_next.light( red_next_l );
            red_back.wyswietl( 0, 180 );
            red_back.light( red_back_l );
           
           
           
           
            blue_next.wyswietl( 1650, 860 - wysokosc( blue2 ) );
            blue_next.light( blue_next_l );
            blue_back.wyswietl( 0, 860 - wysokosc( blue2 ) );
            blue_back.light( blue_back_l );
           
           
           
           
           
            if( zaz_red && zaz_blue )
                 zatwierdz.wyswietl( 1500, 450 );
            else
                 al_draw_bitmap( zatwierdz_n, 1500, 450, false );
           
            zatwierdz.light( zatwierdz_l );
           
           
           
           
           
            if( zatwierdz.click() )
                 break;
           
           
           
           
           
            if( r_basic.czy_na( x1 + 600 + szerokosc( red1 ) + szerokosc( red2 ), 180 ) || zaznaczone_rp )
            {
                al_draw_bitmap( banner_red, x1 + 600 + szerokosc( red1 ) + szerokosc( red2 ), 180, false );
                al_draw_bitmap( red3, x1 + 625 + szerokosc( red1 ) + szerokosc( red2 ) - 58, 180 - 15, false );
               
                if( mouse.buttons == 1 )
                {
                   
                   
                    zaznaczone_rp = 1;
                    zaznaczone_rb = 0;
                    zaznaczone_rd = 0;
                    red.type = 3;
                   
                    zaz_red = 1;
                }
            }
           
           
            if( b_basic.czy_na( 600 + szerokosc( blue2 ) + szerokosc( blue1 ), 860 - szerokosc( blue2 ) ) || zaznaczone_bp )
            {
                al_draw_bitmap( banner_blue, x3 + 600 + szerokosc( blue2 ) + szerokosc( blue1 ), 860 - szerokosc( blue2 ), false );
                al_draw_bitmap( blue3, x3 + 625 + szerokosc( blue2 ) + szerokosc( blue1 ) - 57, 860 - szerokosc( blue2 ) - 25, false );
               
                if( mouse.buttons == 1 )
                {
                   
                   
                    zaznaczone_bp = 1;
                    zaznaczone_bb = 0;
                    zaznaczone_bd = 0;
                    blue.type = 3;
                   
                    zaz_blue = 1;
                }
            }
           
           
           
           
           
           
            if( r_basic.czy_na( 225, 180 ) || zaznaczone_rd )
            {
               
                al_draw_bitmap( banner_red, x1 + 225, 180, false );
                al_draw_bitmap( red2, x1 + 245, 200, false );
               
               
               
                if( mouse.buttons == 1 )
                {
                    zaznaczone_rd = 1;
                    zaznaczone_rb = 0;
                    zaznaczone_rp = 0;
                    red.type = 1;
                   
                   
                    zaz_red = 1;
                   
                }
               
               
               
            }
           
           
           
           
            if( r_basic.czy_na( 425 + szerokosc( red2 ), 180 ) || zaznaczone_rb )
            {
               
                al_draw_bitmap( banner_red, x1 + 425 + szerokosc( red2 ), 180, false );
                al_draw_bitmap( red1, x1 + 445 + szerokosc( red2 ), 180 - 15, false );
               
                if( mouse.buttons == 1 )
                {
                    zaznaczone_rb = 1;
                    zaznaczone_rd = 0;
                    zaznaczone_rp = 0;
                    red.type = 2;
                    //red.wczytaj_statek( statek::bazooka );
                    zaz_red = 1;
                    //play_sample( klik, 255, 127, 1000, 0 );
                }
               
               
            }
           
           
           
           
            if( r_basic.czy_na( 225, 860 - szerokosc( blue2 ) ) || zaznaczone_bd )
            {
               
                al_draw_bitmap( banner_blue, x3 + 225, 860 - szerokosc( blue2 ), false );
                al_draw_bitmap( blue2, x3 + 245, 880 - szerokosc( blue2 ), false );
               
                if( mouse.buttons == 1 )
                {
                    zaznaczone_bd = 1;
                    zaznaczone_bb = 0;
                    zaznaczone_bp = 0;
                    blue.type = 1;
                    //blue.wczytaj_statek( statek::fighter );
                    zaz_blue = 1;
                    //play_sample( klik, 255, 127, 1000, 0 );
                }
               
               
            }
           
           
           
            if( r_basic.czy_na( 425 + szerokosc( blue2 ), 860 - szerokosc( blue2 ) ) || zaznaczone_bb )
            {
               
                al_draw_bitmap( banner_blue, x3 + 425 + szerokosc( blue2 ), 860 - szerokosc( blue2 ), false );
                al_draw_bitmap( blue1, x3 + 445 + szerokosc( blue2 ), 860 - szerokosc( blue2 ) - 25, false );
               
               
                if( mouse.buttons == 1 )
                {
                    zaznaczone_bb = 1;
                    zaznaczone_bd = 0;
                    zaznaczone_bp = 0;
                    blue.type = 2;
                    zaz_blue = 1;
                   
                }
               
               
            }
           
           
           
            if( key[ KEY_ENTER ] )
                 break;
           
            al_get_mouse_state( & mouse );
            al_flip_display();
           
           
        }
       
       
    }
   
   
   
    al_destroy_bitmap( red1 );
    al_destroy_bitmap( red2 );
    al_destroy_bitmap( red3 );
    al_destroy_bitmap( blue1 );
    al_destroy_bitmap( blue2 );
    al_destroy_bitmap( blue3 );
    al_destroy_bitmap( w_zatwierdz );
    al_destroy_bitmap( zatwierdz_l );
    al_destroy_bitmap( zatwierdz_n );
   
    al_destroy_bitmap( w_red_next );
    al_destroy_bitmap( red_next_l );
    al_destroy_bitmap( w_red_back );
    al_destroy_bitmap( red_back_l );
   
    al_destroy_bitmap( w_blue_next );
    al_destroy_bitmap( blue_next_l );
    al_destroy_bitmap( w_blue_back );
    al_destroy_bitmap( blue_back_l );
   
   
   
   
    red.wczytaj_statek();
    blue.wczytaj_statek();
   
   
}


void wybor_mapki()
{
    ALLEGRO_BITMAP * basic_min = al_load_bitmap( "maps/tlo_basic_min.bmp" );
    ALLEGRO_BITMAP * desert_min = al_load_bitmap( "maps/tlo_desert_min.bmp" );
    ALLEGRO_BITMAP * nether_min = al_load_bitmap( "maps/tlo_nether_min.bmp" );
   
    ALLEGRO_BITMAP * basic_min2 = al_load_bitmap( "maps/tlo_basic_min2.bmp" );
    ALLEGRO_BITMAP * desert_min2 = al_load_bitmap( "maps/tlo_desert_min2.bmp" );
    ALLEGRO_BITMAP * nether_min2 = al_load_bitmap( "maps/tlo_nether_min2.bmp" );
   
   
   
    int mapka;
   
    bool click = 0;
    bool czy_z_menu = 1;
   
    int im = 0;
   
   
    while( true )
    {
        al_clear_to_color( al_map_rgb( 255, 255, 255 ) );
        al_draw_bitmap( basic_min, 150, 350, false );
        al_draw_bitmap( desert_min, 200 + szerokosc( basic_min ), 350, false );
        al_draw_bitmap( nether_min, 250 + szerokosc( basic_min ) + szerokosc( desert_min ), 350, false );
       
       
        if( mx >= 150 && mx <= 150 + szerokosc( basic_min ) && my >= 350 && my <= 350 + wysokosc( basic_min ) )
        {
            al_draw_bitmap( basic_min2, 115, 350, false );
            if( mb == 1 )
            {
                mapka = 1;
                break;
            }
        }
       
       
        if( mx >= 200 + szerokosc( basic_min ) && mx <= 200 + szerokosc( basic_min ) + szerokosc( desert_min ) && my >= 350 && my <= 350 + wysokosc( desert_min ) )
        {
            al_draw_bitmap( desert_min2, 165 + szerokosc( basic_min ), 350, false );
            if( mb == 1 )
            {
                mapka = 2;
                break;
            }
        }
       
       
        if( mx >= 250 + szerokosc( basic_min ) + szerokosc( desert_min ) && mx <= 250 + szerokosc( basic_min ) + szerokosc( desert_min ) + szerokosc( nether_min ) && my >= 350 && my <= 350 + wysokosc( nether_min ) )
        {
            al_draw_bitmap( nether_min2, 215 + szerokosc( basic_min ) + szerokosc( nether_min ), 350, false );
            if( mb == 1 )
            {
                if( !czy_z_menu )
                     click = 1;
               
            }
           
        }
       
       
        if( click && mb == 0 )
        {
            mapka = 3;
            break;
        }
       
       
       
        im++;
        if( im == 50 )
             czy_z_menu = 0;
       
       
        al_get_mouse_state( & mouse );
        al_flip_display();
    }
   
   
   
   
   
    al_destroy_bitmap( basic_min );
    al_destroy_bitmap( desert_min );
    al_destroy_bitmap( nether_min );
   
    al_destroy_bitmap( basic_min2 );
    al_destroy_bitmap( desert_min2 );
    al_destroy_bitmap( nether_min2 );
   
    switch( mapka )
    {
    case 1:
        tlo = al_load_bitmap( "maps/tlo_basic.bmp" );
        break;
       
    case 2:
        tlo = al_load_bitmap( "maps/tlo_desert.bmp" );
        break;
       
    case 3:
        tlo = al_load_bitmap( "maps/tlo_nether.bmp" );
        break;
       
    }
}


void obsluga_klawiszy( ALLEGRO_EVENT & ev )
{
    if( ev.type == ALLEGRO_EVENT_KEY_DOWN )
    {
        switch( ev.keyboard.keycode )
        {
        case ALLEGRO_KEY_DOWN:
            key[ KEY_DOWN ] = true;
            break;
           
        case ALLEGRO_KEY_UP:
            key[ KEY_UP ] = true;
            break;
           
        case ALLEGRO_KEY_RIGHT:
            key[ KEY_RIGHT ] = true;
            break;
           
        case ALLEGRO_KEY_LEFT:
            key[ KEY_LEFT ] = true;
            break;
           
        case ALLEGRO_KEY_W:
            key[ KEY_W ] = true;
            break;
           
        case ALLEGRO_KEY_A:
            key[ KEY_A ] = true;
            break;
           
        case ALLEGRO_KEY_S:
            key[ KEY_S ] = true;
            break;
           
        case ALLEGRO_KEY_D:
            key[ KEY_D ] = true;
            break;
           
        case ALLEGRO_KEY_SPACE:
            key[ KEY_SPACE ] = true;
            break;
           
        case ALLEGRO_KEY_PAD_0:
            key[ KEY_PAD_0 ] = true;
            break;
           
        case ALLEGRO_KEY_ESCAPE:
            key[ KEY_ESC ] = true;
            break;
           
        case ALLEGRO_KEY_ENTER:
            key[ KEY_ENTER ] = true;
            break;
           
        }
    }
    else if( ev.type == ALLEGRO_EVENT_KEY_UP )
    {
        switch( ev.keyboard.keycode )
        {
        case ALLEGRO_KEY_DOWN:
            key[ KEY_DOWN ] = false;
            break;
           
        case ALLEGRO_KEY_UP:
            key[ KEY_UP ] = false;
            break;
           
        case ALLEGRO_KEY_RIGHT:
            key[ KEY_RIGHT ] = false;
            break;
           
        case ALLEGRO_KEY_LEFT:
            key[ KEY_LEFT ] = false;
            break;
           
        case ALLEGRO_KEY_W:
            key[ KEY_W ] = false;
            break;
           
        case ALLEGRO_KEY_A:
            key[ KEY_A ] = false;
            break;
           
        case ALLEGRO_KEY_S:
            key[ KEY_S ] = false;
            break;
           
        case ALLEGRO_KEY_D:
            key[ KEY_D ] = false;
            break;
           
        case ALLEGRO_KEY_SPACE:
            key[ KEY_SPACE ] = false;
            break;
           
        case ALLEGRO_KEY_PAD_0:
            key[ KEY_PAD_0 ] = false;
            break;
           
        case ALLEGRO_KEY_ESCAPE:
            key[ KEY_ESC ] = false;
            break;
           
        case ALLEGRO_KEY_ENTER:
            key[ KEY_ENTER ] = false;
            break;
           
        }
    }
}

#ifndef STATEK_H
#define STATEK_H

#include <allegro5/allegro.h>
#include <allegro5/allegro_image.h>
#include <string>
#include <iostream>

using namespace std;

class statek
{
   
    #define wysokosc(a) al_get_bitmap_height(a)
    #define szerokosc(a) al_get_bitmap_width(a)
public:
   
   
    enum kolor { red, blue };
   
    statek( kolor p )
    {
        k = p;
        strzal = false;
        ladowanie = false;
        frame = 0;
        sila_strzalu = 0;
        hp = 1920;
        wygrana = 0;
        ile_do_konca = 0;
    }
   
   
   
    void wczytaj_statek();
   
    void aktualizuj_pocisk()
    {
        if( frame < 500 )
             bullet = bullet1;
        else if( frame >= 500 && frame < 1400 )
             bullet = bullet2;
        else if( frame >= 1400 )
             bullet = bullet3;
       
    }
   
    void shot();
   
   
    ALLEGRO_BITMAP * basic;
    ALLEGRO_BITMAP * lewo;
    ALLEGRO_BITMAP * prawo;
    ALLEGRO_BITMAP * bum;
    ALLEGRO_BITMAP * bullet;
   
    ALLEGRO_BITMAP * bullet1, * bullet2, * bullet3;
   
   
   
   
   
    kolor k;
   
   
   
private:
    string sciezka;
    string sciezka_lewo;
    string sciezka_prawo;
    string sciezka_bum;
    string sciezka_bullet;
   
   
    void skladaj_sciezke();
   
public:
   
    int x, y;
    bool strzal;
    double h;
    int h2;
    int x2;
    int w;
    bool ladowanie;
    int frame;
    int sila_strzalu;
    int hp;
    short int type;
    bool wygrana;
    int ile_do_konca;
   
   
   
};
#endif

#include <allegro5/allegro.h>
#include <allegro5/allegro_image.h>
#include <iostream>

using namespace std;

#include "statek.h"


void statek::shot()
{
    if( strzal && type == 1 )
    {
        if( h == h2 )
        {
           
            x2 = x;
            h += 5;
            ile_do_konca = 0;
           
        }
       
        al_draw_bitmap( bullet, x2 + 30, h, 0 );
       
        if( k == red )
             h += 2;
        else
             h -= 2;
       
        if( h >= 1080 )
        {
            h = h2;
            strzal = false;
        }
       
    }
   
    //===================================================================================================
    //===================================================================================================
   
    if( strzal && type != 3 )
    {
        if( h == h2 )
        {
           
            x2 = x;
            if( type == 1 )
                 h -= 15;
            else if( type == 2 )
            {
               
                h += 38;
                x2 += 15;
            }
           
            ile_do_konca = 0;;
        }
       
        al_draw_bitmap( bullet, x2 + 100, h, false );
       
        if( k == red )
        {
           
           
            if( type == 1 )
                 h += 2;
            else
                 h += 1.5;
           
        }
        else
        {
           
            if( type == 1 )
                 h -= 2;
            else
                 h -= 1.5;
           
        }
       
        if( h >= 1080 && k == red || h <= 0 && k == blue )
        {
            h = h2;
            strzal = 0;
        }
       
       
    }
   
    //=================================================================================================
    //=================================================================================================
   
    if( strzal && type == 3 )
    {
        if( h == h2 )
        {
           
            x2 = x;
            h += 15;
            ile_do_konca = 0;
        }
       
        if( bullet == bullet3 )
             al_draw_bitmap( bullet, x2 + 110, h, false );
        else
             al_draw_bitmap( bullet, x2 + 120, h, false );
       
        if( k == red )
             h += 2;
        else
             h -= 2;
       
       
        if( h >= 1080 && k == red || h <= 0 && k == blue )
        {
            h = h2;
            strzal = 0;
            sila_strzalu = 0;
        }
       
    }
}





void statek::skladaj_sciezke()
{
   
    sciezka = "models/";
    if( k == red )
         sciezka += "red";
    else if( k == blue )
         sciezka += "blue";
   
   
   
    if( type == 1 )
         sciezka += "_d";
    else if( type == 2 )
         sciezka += "_b";
    else if( type == 3 )
         sciezka += "_p";
   
    sciezka_lewo = sciezka + "_lewo.png";
    sciezka_prawo = sciezka + "_prawo.png";
    sciezka_bum = sciezka + "_bum.png";
    sciezka_bullet = sciezka + "_bullet.png";
    sciezka = sciezka + ".png";
   
   
}



void statek::wczytaj_statek()
{
   
   
    if( type == 4 )
    {
        sciezka = "mob.png";
        sciezka_lewo = "mob_lewo.png";
        sciezka_prawo = "mob_prawo.png";
        sciezka_bum = "mob_bum.png";
        sciezka_bullet = "red_d_bullet.png";
    }
   
    else
         skladaj_sciezke();
   
   
   
   
    basic = al_load_bitmap( sciezka.c_str() );
    lewo = al_load_bitmap( sciezka_lewo.c_str() );
    prawo = al_load_bitmap( sciezka_prawo.c_str() );
    bum = al_load_bitmap( sciezka_bum.c_str() );
    bullet = al_load_bitmap( sciezka_bullet.c_str() );
   
    if( !basic )
         cout << "\nNie moge wczytac basic!";
   
    if( !lewo )
         cout << "\nNie moge wczytac lewo!";
   
    if( !prawo )
         cout << "\nNie moge wczytac prawo!";
   
    if( !bum )
         cout << "\nNie moge wczytac bum!";
   
    if( !bullet && type != 3 )
         cout << "\nNie moge wczytac bullet!\n";
   
    if( type == 3 )
    {
        if( k == red )
        {
            bullet1 = al_load_bitmap( "models/red_bullet_load1.png" );
            bullet2 = al_load_bitmap( "models/red_bullet_load2.png" );
            bullet3 = al_load_bitmap( "models/red_bullet_load3.png" );
        }
        else if( k == blue )
        {
            bullet1 = al_load_bitmap( "models/blue_bullet_load1.png" );
            bullet2 = al_load_bitmap( "models/blue_bullet_load2.png" );
            bullet3 = al_load_bitmap( "models/blue_bullet_load3.png" );
        }
    }
   
    if( type == 1 )
         sila_strzalu = 3;
   
    if( type == 2 )
         sila_strzalu = 3;
   
   
   
   
   
    if( k == red )
    {
        h = al_get_bitmap_height( basic ) - 30;
        h2 = h;
        w = al_get_bitmap_width( basic );
    }
   
    else if( k == blue )
    {
        h = 1080 - al_get_bitmap_height( basic );
        h2 = h;
        w = al_get_bitmap_width( basic );
    }
}

#ifndef BANNER_H
#define BANNER_H


#include <iostream>
#include <allegro5/allegro.h>
#include <allegro5/allegro_image.h>

using namespace std;


class banner
{
public:
    banner( ALLEGRO_BITMAP * bitmapa ) { bmp = bitmapa; }
   
   
   
    void wyswietl( int x, int y )
    {
        x1 = x;
        y1 = y;
        al_draw_bitmap( bmp, x, y, 0 );
    }
   
    void wyswietl()
    {
        al_draw_bitmap( bmp, x1, y1, 0 );
    }
   
   
   
   
    void light( ALLEGRO_BITMAP * bmp_l )
    {
       
        if( mouse.x >= x1 && mouse.x <= x1 + al_get_bitmap_width( bmp ) && mouse.y >= y1 && mouse.y <= y1 + al_get_bitmap_height( bmp ) )
             al_draw_bitmap( bmp_l, x1, y1, 0 );
       
    }
   
    bool czy_na()
    {
        if( mouse.x >= x1 && mouse.x <= x1 + al_get_bitmap_width( bmp ) && mouse.y >= y1 && mouse.y <= y1 + al_get_bitmap_height( bmp ) )
             return true;
        else
             return false;
       
    }
   
    bool czy_na( int x, int y )
    {
        if( mouse.x >= x && mouse.x <= x + al_get_bitmap_width( bmp ) && mouse.y >= y && mouse.y <= y + al_get_bitmap_height( bmp ) )
             return true;
        else
             return false;
       
    }
   
   
   
    bool click()
    {
        if( mouse.x >= x1 && mouse.x <= x1 + al_get_bitmap_width( bmp ) && mouse.y >= y1 && mouse.y <= y1 + al_get_bitmap_height( bmp ) && mouse.buttons == 1 )
             return true;
        else
             return false;
       
    }
   
   
   
private:
    ALLEGRO_BITMAP * bmp;
    ALLEGRO_BITMAP * bufor;
    int * mx, * my, * mb;
   
public:
    int x1, y1;
   
   
};

#endif