#include <allegro.h>
#include <cmath>
#include <iostream>
#include <ctime>
#include <cstdio>

using namespace std;

/* Funkcja zwalniajaca*/
volatile long speed = 0;
void increment_speed()
{
    speed++;
}
END_OF_FUNCTION(increment_speed);

LOCK_VARIABLE(speed);
LOCK_FUNCTION(increment_speed);

/* Główna struktura */
struct size_obj
{
    int x, y, width, height;
};

class Stone
{
public:
    int pos_x;
    int pos_y;
    BITMAP *Stone = NULL;
public:
    void init()
    {

        srand(time(NULL));
        pos_x = rand() % 599 + 1+100;
        pos_y = rand() % 399 + 1+100;
    }

    void add_stones(BITMAP *Bufor)
    {
    Stone= load_pcx("stone.pcx", default_palette);
    masked_blit(Stone, Bufor, 0, 0, pos_x, pos_y, Stone->w, Stone->h);
    }

    size_obj get_size()
    {
        size_obj temp;
        temp.x = pos_x;
        temp.y = pos_y;
        temp.width = Stone->w;
        temp.height = Stone->h;
        return temp;
    }

};

/*Klasa pocisku*/
class Bullet
{
public:
    int pos_x;
    int pos_y;
    int angle;
    bool active = false;
    BITMAP *Bullet = NULL;
public:
    void init(float tank_x, float tank_y, int tank_angle)
    {
        active = true;
        angle = tank_angle;
        cout << angle;
        pos_x = tank_x + -1.0*abs(0.6*(angle*1.40625-90))+80;
        pos_y = tank_y + -1.0*abs(0.6*(angle*1.40625-180))+80;
        Bullet = load_bmp("bullet.bmp", default_palette);
    }
    void move(BITMAP* Bufor)
    {
        pos_x += sin((angle*1.40625)*M_PI/180.0)*5.0;
        pos_y += cos((angle*1.40625-180.0)*M_PI/180.0)*5.0;
        if(pos_x < 0 || pos_x > 800 || pos_y < 0 || pos_y > 600)
        {
            destroy();
        }
        masked_blit(Bullet, Bufor, 0, 0, pos_x, pos_y, Bullet->w, Bullet->h);
    }
    size_obj get_size()
    {
        size_obj temp;
        temp.x = pos_x;
        temp.y = pos_y;
        temp.width = Bullet->w;
        temp.height = Bullet->h;
        return temp;
    }
    void stop(BITMAP* Bufor)
    {
        masked_blit(Bullet, Bufor, 0, 0, pos_x, pos_y, Bullet->w, Bullet->h);
    }
    void destroy()
    {
        active = false;
    }
};

/* Klasa czołgu*/
class Tank
{
public:
    float pos_x = 0.0;
    float pos_y = 0.0;
    float bfr_pos_x;
    float bfr_pos_y;
    int angle = 0;
    int velocity = 0;
    int counter = 0;
    Bullet TankBullet[2];
    BITMAP *TankBitmap = NULL;
public:
    Tank()
    {
        srand(time(NULL));
        pos_x = rand() % 699 + 1;
        pos_y = rand() % 499 + 1;
    }
    void go_to(BITMAP* Bufor)
    {
        bfr_pos_x = pos_x;
        bfr_pos_y = pos_y;
        pos_x += cos((angle*1.40625+90)*M_PI/180)*velocity;
        pos_y += sin((angle*1.40625+90)*M_PI/180)*velocity;
        if(collision_map())
            back_move();
        rotate_sprite(Bufor, TankBitmap, pos_x, pos_y, itofix(angle));
    }
    void back_move()
    {
        pos_x = bfr_pos_x;
        pos_y = bfr_pos_y;
    }
    bool collision_map()
    {
        return (pos_x < 0 || pos_y < 0 ||pos_x > 800 || pos_y > 600);
    }
    size_obj get_size()
    {
        size_obj temp;
        temp.x = pos_x;
        temp.y = pos_y;
        temp.width = TankBitmap->w;
        temp.height = TankBitmap->h;
        return temp;
    }
    void stop(BITMAP* Bufor)
    {
        rotate_sprite(Bufor, TankBitmap, pos_x, pos_y, itofix(angle));
    }
    void shot()
    {
        for(int i = 0; i <= 1; i++)
            if(!TankBullet[i].active)
            {
                TankBullet[i].init(pos_x, pos_y, angle);
                break;
            }
    }
};

/* Czołg gracza A */
class PlayerTankA :public Tank
{
public:
    PlayerTankA()
    {
        TankBitmap = load_bitmap("TANKA.pcx", default_palette);
    }
    void move(BITMAP* Bufor)
    {
        velocity = 0;
        if (key[KEY_LEFT])
            angle = angle > 0 ? angle - 1: 255;
        else if (key[KEY_RIGHT])
            angle = angle < 255 ? angle + 1: 0;
        else if (key[KEY_UP])
            velocity--;
        else if (key[KEY_DOWN])
            velocity++;

        go_to(Bufor);

        for(int i = 0; i <= 1; i++)
            if(TankBullet[i].active)
                TankBullet[i].move(Bufor);

        counter++;
        if (key[KEY_ENTER] && ((counter == 0) || (counter > 100)))
        {
            counter = 0;
            shot();
        }
    }
};
/* Czołg gracza B*/
class PlayerTankB: public Tank
{
public:
    PlayerTankB()
    {
        TankBitmap = load_bitmap("TANKB.pcx", default_palette);
    }
    void move(BITMAP* Bufor)
    {
        velocity = 0;
        if (key[KEY_A])
            angle = angle > 0 ? angle - 1: 255;
        else if (key[KEY_D])
            angle = angle < 255 ? angle + 1: 0;
        else if (key[KEY_W])
            velocity--;
        else if (key[KEY_S])
            velocity++;

        go_to(Bufor);

        for(int i = 0; i <= 1; i++)
            if(TankBullet[i].active)
                TankBullet[i].move(Bufor);

        counter++;
        if (key[KEY_SPACE] && ((counter == 0) || (counter > 100)))
        {
            counter = 0;
            shot();
        }
    }
};

/*Plansza*/
class Board
{
public:
    int point_red = 0;
    int point_blue = 0;
    char text[64];
    PlayerTankA* TankPlayerRed = new PlayerTankA;
    PlayerTankB* TankPlayerBlue = new PlayerTankB;
    BITMAP *Bufor = NULL;
    Stone* Stones = new Stone;
public:
    Board()
    {
        Bufor = create_bitmap(800, 600);
        while(collision_players())
        {
            delete TankPlayerRed;
            TankPlayerRed = new PlayerTankA;
        }
        draw();
    }
    void draw()
    {
        clear_to_color(Bufor, makecol(101, 156, 45));
        TankPlayerBlue->move(Bufor);
        TankPlayerRed->move(Bufor);
            Stones->init();
            Stones->add_stones(Bufor);

        if(collision_players() || collision_p1_stones() || collision_p2_stones())
        {
            TankPlayerRed->back_move();
            TankPlayerBlue->back_move();
        }

        shoted_red();
        shoted_blue();
        shoted_stone();
        print_text();
        blit(Bufor, screen, 0, 0, 0, 0, 800, 600);
    }
    void print_text()
    {
        sprintf(text, "Player Blue %d", point_blue);
        textout_ex( Bufor, font, text, 10, 10, makecol( 0, 0, 255 ), - 1 );
        sprintf(text, "Player Red %d", point_red);
        textout_ex( Bufor, font, text, 410, 10, makecol( 255, 0, 0 ), - 1 );
    }
    bool collision_players()
    {
        size_obj size_player_blue = TankPlayerBlue->get_size();
        size_obj size_player_red = TankPlayerRed->get_size();
        return collision(size_player_blue, size_player_red);
    }

    bool collision_p1_stones()
    {
        size_obj size_player_red = TankPlayerRed->get_size();
        size_obj size_stone = Stones->get_size();
        return collision(size_player_red, size_stone);
    }

    bool collision_p2_stones()
    {
        size_obj size_player_blue = TankPlayerBlue->get_size();
        size_obj size_stone = Stones->get_size();
        return collision(size_player_blue, size_stone);
    }


    void shoted_red()   //zliczanie punktów
    {
        size_obj size_player_red = TankPlayerRed->get_size();
        for(int i = 0; i <= 1; i++)
            if(TankPlayerBlue->TankBullet[i].active)
                if(collision(size_player_red, TankPlayerBlue->TankBullet[i].get_size()))
                {
                    TankPlayerBlue->TankBullet[i].destroy();
                    point_blue++;
                }

    }
    void shoted_blue()  //zliczanie punktów
    {
        size_obj size_player_blue = TankPlayerBlue->get_size();
        for(int i = 0; i <= 1; i++)
            if(TankPlayerRed->TankBullet[i].active)
                if(collision(size_player_blue, TankPlayerRed->TankBullet[i].get_size()))
                {
                    TankPlayerRed->TankBullet[i].destroy();
                    point_red++;
                }

    }

    void shoted_stone()
    {
        size_obj size_stone = Stones->get_size();
        for(int i = 0; i <= 1; i++)
        {
            if(TankPlayerRed->TankBullet[i].active)
                if(collision(size_stone, TankPlayerRed->TankBullet[i].get_size()))
                {
                    TankPlayerRed->TankBullet[i].destroy();
                }
            if(TankPlayerBlue->TankBullet[i].active)
                if(collision(size_stone, TankPlayerBlue->TankBullet[i].get_size()))
                {
                    TankPlayerBlue->TankBullet[i].destroy();
                }
        }

    }

    bool collision(size_obj obj1, size_obj obj2)
    {
        return (obj1.x < obj2.x + obj2.width &&
        obj1.x + obj1.width > obj2.x &&
        obj1.y < obj2.y + obj2.height &&
        obj1.y + obj1.height > obj2.y);
    }

};


int main()
{

    allegro_init();
    install_timer();
    install_int_ex(increment_speed, BPS_TO_TIMER(200));

    install_keyboard();
    set_color_depth(16);
    set_gfx_mode(GFX_AUTODETECT_WINDOWED, 800, 600, 0, 0);
    clear_to_color(screen, makecol(128, 128, 128));



    Board *BoardGame;
    BoardGame = new Board;
    while (!key[KEY_ESC])
    {
        while(speed > 0)
        {
            BoardGame->draw();
            usleep(1000);
        }
        speed--;
    }
    readkey();
    remove_int(increment_speed);
    allegro_exit();
    return 0;
}
END_OF_MAIN();