/*<DOC> Description Description Description (jamais 2 sans 3) */

drawSetOffset(5, 5);
draw_point(10, 12); // revient sans la première fonction appelée à faire draw_point(10 + 5, 12 + 5) ce qui est PAS BEAU.

#define FEN_X 640
#define FEN_Y 480

void warp(float &x, float &y)
{
    if (x < -16)
        x = FEN_X+16;
    if (y < -16)
        y = FEN_Y+16;
    if (y > FEN_Y+16)
        y = -16;
    if (x > FEN_X+16)
        x = -16;
}

class Object
{
    public:
    Object(float x=0, float y=0, float len=1, float dir=0, float angle=0)
    {
        this->x = x;
        this->y = y;
        this->dir = dir;
        this->angle = angle;
        this->speed = len;
    }
   
    void move()
    {
        this->x += lengthdir_x(speed, dir);
        this->y += lengthdir_y(speed, dir);
    }
   
    float getX() const  { return x; }
    float getY() const  { return y; }
    float getAngle() const  { return angle; }
   
    void setAngle(float angle)
    {
        if (angle > 360)
            angle -= 360;
        else if (angle < 0)
            angle += 360;
       
        this->angle = angle;
    }
   
    void setDir(float dir)  { this->dir = dir; }
    float getDir() const  { return dir; }
   
    protected:
    float x, y;
    float angle, speed, dir;
};

class Vaisseau : public Object
{
    public :
    Vaisseau(float x=0, float y=0, float angle=0)
            : Object(x,y,2,angle) {}
   
    void update()
    {
        draw_set_color(c_aqua);
        draw_primitive_begin(pr_lineloop);
          draw_vertex_lengthdir(x, y, 20, angle);
          draw_vertex_lengthdir(x, y, 10, angle + 135);
          draw_vertex_lengthdir(x, y, 10, angle - 135);
        draw_primitive_end();
       
        draw_primitive_begin(pr_linelist);
          draw_vertex_lengthdir(x, y, 0, 0);
          draw_vertex_lengthdir(x, y, 20, angle);
          draw_vertex_lengthdir(x, y, 0, 0);
          draw_vertex_lengthdir(x, y, 10, angle + 135);
          draw_vertex_lengthdir(x, y, 0, 0);
          draw_vertex_lengthdir(x, y, 10, angle - 135);
        draw_primitive_end();
       
        if (keyboard_check(vk_up)) {
            dir = angle;
            move();
        }
        if (keyboard_check(vk_down)) {
            dir = angle+180;
            move();
        }
        warp(x, y);
    }
};

class Tir : public Object
{
    public:
    Tir(float x=0, float y=0, float angle=0) : Object(x,y,5,angle)
    {
        this->x_previous = x;
        this->y_previous = y;
        this->time = 60;
    }
   
    int getTime() const  { return time; }
   
    void update()
    {
        draw_set_color(c_aqua);
        draw_primitive_begin(pr_linelist);
          draw_vertex(x, y);
          draw_vertex(x_previous, y_previous);
        draw_primitive_end();
       
        warp(x, y);
       
        x_previous = x;
        y_previous = y;
       
        time -= 1;
    }
   
    private:
    float x_previous;
    float y_previous;
    int time;
};

class Particle : public Object
{
    public:
    Particle()
    {
        deps = 5;
    }
   
    void set()
    {
        x = short(random(FEN_X));
        y = short(random(FEN_Y));
        depx = short(random(2))-1;
        depy = short(random(2))-1;
    }
   
    void update()
    {
        draw_primitive_begin(pr_pointlist);
        draw_set_color(c_aqua);
        draw_vertex(x, y);
        draw_primitive_end();
       
        if (deps == 0)
        {
            x += depx;
            y += depy;
            deps = 5;
        }
        deps -= 1;

        warp(x, y);
    }
   
    private:
    float depx, depy;
    int deps;
};

class Asteroid : public Object
{
    public:
    Asteroid(float x=0, float y=0, float angle =0) : Object(x,y,1,angle)
    {
        this->dir = 0;
    }
   
    void set()
    {
        x = short(random(FEN_X));
        y = short(random(FEN_Y));
        angle = short(random(360));
        dir = short(random(360));
        speed = 1;
        turn = random(3)-1;
        size = 1;
    }
   
    void create_dest()
    {
        angle = short(random(360));
        dir = short(random(360));
        speed = 1;
        turn = random(3)-1;
    }
   
    float getSize() const  { return size; }
    void setSize(float size)  { this->size = size; }
   
    float distanceCenter(float x, float y) const
    {
        return sqrt(sqr(x-this->x)+sqr(y-this->y));
    }
   
    bool inBox(float x, float y) const
    {
        if (x>this->x-15*size && x<this->x+15*size && y>this->y-15*size && y<this->y+15*size)
            return true;
        return false;
    }
   
    void update()
    {
        draw_set_color(c_aqua);
        draw_primitive_begin(pr_lineloop);
          draw_vertex_lengthdir(x, y, size*22, angle+20);
          draw_vertex_lengthdir(x, y, size*10, angle+45);
          draw_vertex_lengthdir(x, y, size*20, angle+100);
          draw_vertex_lengthdir(x, y, size*15, angle+170);
          draw_vertex_lengthdir(x, y, size*17, angle-135);
          draw_vertex_lengthdir(x, y, size*15, angle-50);
        draw_primitive_end();
       
        angle += 0.5*turn;
        warp(x, y);
    }
   
    private:
    float speed;
    float turn;
    float size;
};

class Morceau : public Object
{
    public :
    Morceau(float x=0, float y=0) : Object(x,y,1,0)
    {
        this->size = random(1)+1;
    }
   
    void setSize(float size)  { this->size = size; }
    float getSize() const  { return size; }
   
    void decSize()  { size -= 0.1; }
   
    void update()
    {
        draw_set_color(c_aqua);
        draw_primitive_begin(pr_linelist);
          draw_vertex_lengthdir(x, y, size*5, angle);
          draw_vertex_lengthdir(x, y, size*5, angle+180);
        draw_primitive_end();
        angle++;
    }
   
    private:
    float size;
};

window_set_size(FEN_X, FEN_Y);

vector<Tir> tirs;
vector<Particle> particles(100);
vector<Asteroid> asteroides(10);
vector<Morceau> morceaux;

Vaisseau vaisseau(150,150);

bool canshot = true;
int shotdelay = 10;

for (int i=0; i<particles.size(); i++)
{
    particles[i].set();
}

for (int i=0; i<asteroides.size(); i++)
{
    asteroides[i].set();
    asteroides[i].setSize(random(2)+0.5);
}

draw_clear(0);

if (keyboard_check(vk_left))
    vaisseau.setAngle(vaisseau.getAngle()+5);

if (keyboard_check(vk_right))
    vaisseau.setAngle(vaisseau.getAngle()-5);

if (keyboard_check(vk_space) && canshot && tirs.size() < 5)
{
    Tir tir(vaisseau.getX(), vaisseau.getY(), vaisseau.getAngle());
    tirs.push_back(tir);
    canshot = false;
}

if (keyboard_check('E'))
{
    Asteroid astero;
    astero.set();
    astero.setSize(random(2)+0.5);
    asteroides.push_back(astero);
}

if (canshot == false)
{
    shotdelay -= 1;
}

if (shotdelay == 0)
{
    canshot = true;
    shotdelay = 10;
}

vaisseau.update();

for (int i=0; i<tirs.size(); i++)
{
    tirs[i].move();
    tirs[i].update();
   
    bool destroyed = false;
   
    for (int j=0; j<asteroides.size(); j++)
    {
        if (asteroides[j].inBox(tirs[i].getX(), tirs[i].getY()))
        {
            for (int k=0; k<10; k++)
            {
                Morceau morc(asteroides[j].getX(), asteroides[j].getY());
                morc.setSize(1+random(1)+asteroides[j].getSize());
                morc.setDir(random(360));
                morceaux.push_back(morc);
            }
           
            Asteroid tmp(asteroides[j].getX(), asteroides[j].getY());
            tmp.setSize(asteroides[j].getSize()/2);
           
           
            tirs.erase(tirs.begin()+i);
            asteroides.erase(asteroides.begin()+j);
            destroyed = true;
           
            if(tmp.getSize() >= 0.3)
            {
                tmp.create_dest();
                asteroides.push_back(tmp);
                tmp.create_dest();
                asteroides.push_back(tmp);
            }
        }
    }
   
    if (!destroyed && tirs[i].getTime() == 0)
    {
        tirs.erase(tirs.begin()+i);
    }
}

for (int i=0; i<particles.size(); i++)
{
    particles[i].update();
}

for (int i=0; i<asteroides.size(); i++)
{
    asteroides[i].move();
    asteroides[i].update();
}

for (int i=0; i<morceaux.size(); i++)
{
    morceaux[i].move();
    morceaux[i].decSize();
    morceaux[i].update();
   
    if (morceaux[i].getSize()<=0)
    {
        morceaux.erase(morceaux.begin()+i);
    }
}