import java.nio.*;
import java.util.*;

import org.lwjgl.*;
import org.lwjgl.opengl.*;
import org.lwjgl.util.vector.*;
import org.lwjgl.input.*;
import org.lwjgl.util.glu.*;

public class Main {

    // вызываем Random
    Random r = new Random();

    // вызываем Elements

    // создаем rotate
    float rotation = 0;

    // время прыжка
    final double TIME_STEP = 1 / 90.;
    // гравитация
    final double GRAVITY = 0.5;
    boolean jumping;
    double yPosition;
    double yVelocity;

    private Vector3f position = null;
    private float yaw = 0.0f;
    private float pitch = 0.0f;

    // в конструкторе мы создаем координаты позиции камеры X, Y и Z
    public Main(float x, float y, float z) {
     position = new Vector3f(x, y, z);
    }

    // пока ничего не указываем
    public Main() {
    }

    // уклон от курса
    public void yaw(float amount) {
     yaw += amount;
    }

    // делаем подачу
    public void pitch(float amount) {
     pitch -= amount;
    }

    // в этом методе мы создаем управление камеры
    public void walkForward(float distance) {
     position.x -= distance * (float) Math.sin(Math.toRadians(yaw));
     position.z += distance * (float) Math.cos(Math.toRadians(yaw));

     // делаем так, чтобы камера не выходила за пределы этих координат 75 -75
     if (position.x > 75) {
      position.x = 75;
     }
     if (position.x < -75) {
      position.x = -75;
     }
     if (position.z > 75) {
      position.z = 75;
     }
     if (position.z < -75) {
      position.z = -75;
     }
    }

    public void walkBackwards(float distance) {
     position.x += distance * (float) Math.sin(Math.toRadians(yaw));
     position.z -= distance * (float) Math.cos(Math.toRadians(yaw));
     if (position.x > 75) {
      position.x = 75;
     }
     if (position.x < -75) {
      position.x = -75;
     }
     if (position.z > 75) {
      position.z = 75;
     }
     if (position.z < -75) {
      position.z = -75;
     }
    }

    public void strafeLeft(float distance) {
     position.x -= distance * (float) Math.sin(Math.toRadians(yaw - 90));
     position.z += distance * (float) Math.cos(Math.toRadians(yaw - 90));
     if (position.x > 75) {
      position.x = 75;
     }
     if (position.x < -75) {
      position.x = -75;
     }
     if (position.z > 75) {
      position.z = 75;
     }
     if (position.z < -75) {
      position.z = -75;
     }
    }

    public void strafeRight(float distance) {
     position.x -= distance * (float) Math.sin(Math.toRadians(yaw + 90));
     position.z += distance * (float) Math.cos(Math.toRadians(yaw + 90));
     if (position.x > 75) {
      position.x = 75;
     }
     if (position.x < -75) {
      position.x = -75;
     }
     if (position.z > 75) {
      position.z = 75;
     }
     if (position.z < -75) {
      position.z = -75;
     }
    }

    // прыжок
    public void jump(float distance) {
     position.y -= distance * (float) Math.cos(Math.toRadians(yaw + 90));
     if (position.y > 0) {
      position.y = 0;
     }
    }

    public void lookThrough() {
     // вражение камеры в разные стороны
     GL11.glRotatef(pitch, 1.0f, 0.0f, 0.0f);
     GL11.glRotatef(yaw, 0.0f, 0.1f, 0.0f);
     GL11.glTranslatef(position.x, position.y, position.z);
    }

    // игра работает
    private static boolean gameRunning = true;
    // ширина окна
    private static int targetWidth = 800;
    // высота окна
    private static int targetHeight = 600;

    // полноэкранный режим
    private static void initDisplay(boolean fullscreen) {

     DisplayMode chosenMode = null;

     try {
      DisplayMode[] modes = Display.getAvailableDisplayModes();

      for (int i = 0; i < modes.length; i++) {
       if ((modes[i].getWidth() == targetWidth)
         && (modes[i].getHeight() == targetHeight)) {
        chosenMode = modes[i];
        break;
       }
      }
     } catch (LWJGLException e) {
      Sys.alert("Error", "Unable to determine display modes.");
      System.exit(0);
     }

     if (chosenMode == null) {
      Sys.alert("Error", "Unable to find appropriate display mode.");
      System.exit(0);
     }

     try {
      Display.setDisplayMode(chosenMode);
      Display.setFullscreen(fullscreen);
      Display.setTitle("Название игры");
      Display.create();

     } catch (LWJGLException e) {
      Sys.alert("Error", "Unable to create display.");
      System.exit(0);
     }
    }

    // это по моему самое главное, что должно быть в хорошей игре
    // здесь вы можете изменять освещение, шейдеры, все что вам только захочется
    // только и опыт здесь нужен=)
    private static boolean initGL() {
     GL11.glMatrixMode(GL11.GL_PROJECTION);
     GL11.glLoadIdentity();
     GLU.gluPerspective(/* искажение 3D */45.0f, ((float) /*
                     * это число должно
                     * совпадать с
                     * размерами ширины
                     * окна
                     */800)
       / ((float) /*
           * это число должно совпадать с размерами высоты
           * окна
           */600), 0.1f,
     /* дальность видимости */10000000000000000000.0f);
     GL11.glMatrixMode(GL11.GL_MODELVIEW);
     GL11.glLoadIdentity();

     // создаем освещение объектов
     GL11.glShadeModel(GL11.GL_SMOOTH);
     GL11.glClearDepth(1.0f);
     GL11.glEnable(GL11.GL_DEPTH_TEST);
     GL11.glDepthFunc(GL11.GL_LEQUAL);
     GL11.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);

     // здесь указывается цвет освещения
     // можете изменять числа, экспериментируйте=)
     float lightAmbient[] = { 0.5f, 0.5f, 0.5f, 10.0f };   
                     // Values
     float lightDiffuse[] = { 0.5f, 0.5f, 0.5f, 10.0f };   
                     // Values
     float lightPosition[] = { 0.5f, 0.5f, 0.5f, 10.0f };

     ByteBuffer temp = ByteBuffer.allocateDirect(16);
     temp.order(ByteOrder.nativeOrder());
     GL11.glLight(GL11.GL_LIGHT1, GL11.GL_AMBIENT, (FloatBuffer) temp
       .asFloatBuffer().put(lightAmbient).flip()); // Setup The Ambient
                     // Light
     GL11.glLight(GL11.GL_LIGHT1, GL11.GL_DIFFUSE, (FloatBuffer) temp
       .asFloatBuffer().put(lightDiffuse).flip()); // Setup The Diffuse
                     // Light
     GL11.glLight(GL11.GL_LIGHT1, GL11.GL_POSITION, (FloatBuffer) temp
       .asFloatBuffer().put(lightPosition).flip()); // Position The
                     // Light
     GL11.glEnable(GL11.GL_LIGHT1);

     return true;
    }

    private void run() {
     // указываем, где должна появится камера X, Y, Z
     Main camera = new Main(10, -100, -10);

     float dx = 0.0f;
     float dy = 2.0f;
     float dt = 5.0f;

     float mouseSensitivity = 0.15f;
     float movementSpeed = 10.0f;

     // скрытие пиктограммы мыши
     Mouse.setGrabbed(true);
     while (gameRunning) {
      render();
      Display.update();
      dt = 0.0015f;
      dx = Mouse.getDX();
      dy = Mouse.getDY();

      camera.yaw(dx * mouseSensitivity);
      camera.pitch(-dy * mouseSensitivity);

      // вперед
      if (Keyboard.isKeyDown(Keyboard.KEY_W))// move forward
      {
       camera.walkForward(movementSpeed * dt);
      }
      // назад
      if (Keyboard.isKeyDown(Keyboard.KEY_S))// move backwards
      {
       camera.walkBackwards(movementSpeed * dt);
      }
      // влево
      if (Keyboard.isKeyDown(Keyboard.KEY_A))// strafe left
      {
       camera.strafeLeft(movementSpeed * dt);
      }
      // вправо
      if (Keyboard.isKeyDown(Keyboard.KEY_D))// strafe right
      {
       camera.strafeRight(movementSpeed * dt);
      }
      // W+SHIFT ускорение вперед
      if (Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
       camera.walkForward(movementSpeed * dt + 0.005f);
      }
      // прыжок
      if (Keyboard.isKeyDown(Keyboard.KEY_SPACE)) {
       camera.jump(0);
      }

      while (Keyboard.next()) {
       if (Keyboard.getEventKeyState()) {
        if (Keyboard.getEventKey() == Keyboard.KEY_SPACE
          && !jumping) {
         jumping = true;
         yVelocity = -3;
        }
       }
      }

      if (camera.position.y > 0) {
       jumping = false;
       yVelocity = 0;
      }

      camera.position.y += yVelocity * TIME_STEP;
      yVelocity += GRAVITY * TIME_STEP;

      GL11.glLoadIdentity();
      camera.lookThrough();

      // что произойдет, когда окно будет закрыто
      if (Display.isCloseRequested()) {
       gameRunning = false;
       Display.destroy();
       System.exit(0);
      }
      // при нажатии ESC, окно будет закрыто
      if (Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {
       Display.destroy();
       System.exit(0);
      }
     }
    }

    private void elements() {
     el.setColorBlock(/* сторона X */20,/* сторона Y */25,/* сторона Z */20,/*
                     * цвет
                     * X
                     * -красный
                     */1, /*
                     * цвет
                     * Y
                     * -
                     * зеленый
                     */
       1, /* цвет Z-синий */1, /* перемещение в сторону X */10, /*
                     * не
                     * перемещаем
                     * в
                     * сторону
                     * Y
                     */0, /*
                     * перемещаем
                     * в
                     * сторону
                     * Z
                     */
       5, rotation, /* вращение в сторону X */1, /* вращение в сторону Y */
       1, /* вращение в сторону Z */1);
    }

    private void render() {
     // очиска буффера
     GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
     // поменяйте glDisable на glEnable, чтобы включить освещение
     // все станет серым, в следующем уроке я буду показывать, как загрузить
     // текстуру.
     GL11.glDisable(GL11.GL_LIGHTING);

     // вращение
     rotation += 0.005f;

     // создание куба

GL11.glBegin(GL11.GL_QUADS);  
GL11.glTranslatef(-centerX, centerY, -centerZ);  
GL11.glTexCoord2f(0, 0);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(1, 0);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(1, 1);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(0, 1);  
GL11.glVertex3f(-2, 2, -2);  
// Bottom  
GL11.glTexCoord2f(0, 0);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(1, 0);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(1, 1);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(0, 1);  
GL11.glVertex3f(-2, 2, -2);  
// One side  
GL11.glTexCoord2f(0, 0);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(1, 0);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(1, 1);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(0, 1);  
GL11.glVertex3f(-2, 2, -2);  
// Moar sides  
GL11.glTexCoord2f(0, 0);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(1, 0);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(1, 1);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(0, 1);  
GL11.glVertex3f(-2, 2, -2);  
// Last side  
GL11.glTexCoord2f(0, 0);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(1, 0);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(1, 1);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(0, 1);  
GL11.glVertex3f(-2, 2, -2);  
// Real last side  
GL11.glTexCoord2f(0, 0);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(1, 0);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(1, 1);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glTexCoord2f(0, 1);  
GL11.glVertex3f(-2, 2, -2);  
GL11.glEnd();
    }

    public static void main(String[] args) {
     Main main = new Main();
     initDisplay(false);
     initGL();
     main.run();
    }
}