#include <cmath>
#include <iostream>
#include <GL/glut.h>

using namespace std;

#define OBJECT_COUNT 100
#define SPEED 0.5f
#define TIME 0.02
#define MAX_HEIGHT 10

struct object
{
    float x, z;
     float r, g, b;
};

object objects[OBJECT_COUNT];
int count = OBJECT_COUNT;
float px = 0.0f, pz = 0.0f,py=0.0,cpx=px,cpy=py,cpz=pz;
float size = 1.0f;
bool ok=0,xok=0;
float raz=0.0;
float v;

void draw_cone(float r, float h, int n)
{
    float a;

    a = 2.0f * 3.1415f / n;

    glBegin(GL_TRIANGLES);

    for (int i = 0; i < n; ++i)
    {
        glVertex3f(0.0f, 0.0f, 0.0f);
        glVertex3f(r * cos(a * i), 0.0f, r * sin(a * i));
        glVertex3f(r * cos(a * (i + 1)), 0.0f, r * sin(a * (i + 1)));
         glVertex3f(0.0f, h, 0.0f);
        glVertex3f(r * cos(a * i), 0.0f, r * sin(a * i));
        glVertex3f(r * cos(a * (i + 1)), 0.0f, r * sin(a * (i + 1)));
    }

    glEnd();
}

void draw_cube(float w, float h, float d)
 {
    w /= 2;
    h /= 2;
    d /= 2;

    glBegin(GL_QUADS);
        glVertex3f(-w, -h, -d);
        glVertex3f( w, -h, -d);
        glVertex3f( w,  h, -d);
        glVertex3f(-w,  h, -d);

         glVertex3f(-w, -h,  d);
        glVertex3f( w, -h,  d);
        glVertex3f( w,  h,  d);
        glVertex3f(-w,  h,  d);

        glVertex3f(-w,  h, -d);
        glVertex3f( w,  h, -d);
        glVertex3f( w,  h,  d);
         glVertex3f(-w,  h,  d);

        glVertex3f(-w, -h, -d);
        glVertex3f( w, -h, -d);
        glVertex3f( w, -h,  d);
        glVertex3f(-w, -h,  d);

        glVertex3f(-w, -h, -d);
        glVertex3f(-w,  h, -d);
         glVertex3f(-w,  h,  d);
        glVertex3f(-w, -h,  d);

        glVertex3f( w, -h, -d);
        glVertex3f( w,  h, -d);
        glVertex3f( w,  h,  d);
        glVertex3f( w, -h,  d);
    glEnd();
 }

void obstacol(int w , int h , int d)
 {
     glPushMatrix();
     h+=1.0;

     glTranslatef(w , h , d);
     draw_cube(2 , 2 , 2);
     if(px-size/2<=w+1  && px+size/2>=w-1 && pz-size/2<=d+1 && pz+size/2>=d-1 && py<1.0+h)
     {
        px=cpx;
        pz=cpz;
   //     cout<<"sebi";
     }
     if(px-size/2<=w+1  && px+size/2>=w-1 && pz-size/2<=d+1 && pz+size/2>=d-1 && py-0.01<1.0+h && v<0)
    {
        py=1.0+h+0.01;
        v=0;
        xok=1;
        cout <<"sebi";

    }




     glPopMatrix();
 }

 void obstacole()
 {
     for(int i=1;i<=5;i+=2)
     {
         for(int j=1;j<=5;j+=2)
         {
             obstacol(i , 0.0 , j);
         }
     }
     obstacol(3.0 , 2.0 , 3.0);
 }



void draw_plane(float w, float d)
{
    glBegin(GL_QUADS);
        glVertex3f(-w / 2, 0.0f, -d / 2);
        glVertex3f( w / 2, 0.0f, -d / 2);
        glVertex3f( w / 2, 0.0f,  d / 2);
        glVertex3f(-w / 2, 0.0f,  d / 2);
     glEnd();
}

void render()
{
    for (int i = 0; i < count; ++i)
    {
        float dx = abs(px - objects[i].x);
        float dz = abs(pz - objects[i].z);
        float d = sqrt(dx * dx + dz * dz);

        if (d < 2.0+size/2 + raz && py-raz<2.0)
        {
            objects[i] = objects[count - 1];
            count--;
            size += 0.2f;

        }
    }

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0f, 800.0 / 600.0, 0.1f, 100.0f);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(
      px - 10.0f, 10.0f+size/2, pz + 10.0f+size,
       px, py, pz,
      0.0f, 1.0f, 0.0f
    );

    glColor3f(0.0f, 1.0f, 0.0f);
    draw_plane(100.0f, 100.0f);
    for (int i = 0; i < count; ++i)
    {
        glPushMatrix();
        glTranslatef(objects[i].x, 0.0f, objects[i].z);
        glColor3f(
             objects[i].r,
            objects[i].g,
            objects[i].b
        );
        draw_cone(2.0f, 2.0f, 16);
        glPopMatrix();
    }

    obstacole();

    glPushMatrix();
    glTranslatef(px, 1.5f * size+py, pz);
    glColor3f(1.0f, 0.0f, 0.0f);
     draw_cube(1.0f * size, 3.0f* size, 1.0f* size);
    glPopMatrix();

    if(xok)
    {
        v=v-10*TIME;
        cpy=py;
        py=py+v*TIME;

        if(py<0){
            xok=0;
            py=0;
        }
    }

    if(ok){
        if(size>1.0){
            raz+=0.075;
            size-=0.03;
            glColor3f(1.0 , 1.0 , 1.0);
            glTranslatef(px , py, pz);
            glutWireSphere(raz,20,20);

        }
        else{
            raz=0.0;
            ok=0;
        }
    }



    glutSwapBuffers();
}

void mouse(int button , int state , int x , int y)
{
    if(button==GLUT_LEFT_BUTTON && state==GLUT_DOWN  )
    {
        xok=1;
        v=MAX_HEIGHT;
    }
}

void keyboard(unsigned char key, int x, int y)
 {
     cpx=px;
     cpz=pz;
    switch (key)
    {
        case 'w':
        {
            if(px<50-size/2)
            {
            px += SPEED;}

            break;
        }
        case 's':
        {
            if(px>-50+size/2)
            {
            px -= SPEED;}

            break;
         }
        case 'a':
        {
            if(pz>-50+size/2)
            {
            pz -= SPEED;}

            break;
        }
        case 'd':
        {
            if(pz<50-size/2)
            {
            pz += SPEED;}

            break;
        }
         case 'q':
        {
            exit(0);
            break;
        }
         case ' ':
         {
             raz=size/2;
             ok=1;
             break;
         }

    }
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitWindowSize(800, 600);
     glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGBA);
    glutCreateWindow("HELLO!");
    glutFullScreen();

    glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
    glDepthFunc(GL_LEQUAL);
    glEnable(GL_DEPTH_TEST);

    for (int i = 0; i < count; ++i)
    {
        objects[i].x = (rand() % 50000) / 1000.0f * 2.0f - 50.0f;
        objects[i].z = (rand() % 50000) / 1000.0f * 2.0f - 50.0f;

        objects[i].r = (rand() % 100) / 100.0f;
         objects[i].g = (rand() % 100) / 100.0f;
        objects[i].b = (rand() % 100) / 100.0f;
    }

    glutKeyboardFunc(keyboard);
    glutMouseFunc(mouse);
    glutDisplayFunc(render);
    glutIdleFunc(render);
    glutMainLoop();
     return 0;
}