//спасибо всем кто помагал :)
#define GLFW_DLL//это для glfw
#define START_SHIP_X 0//стартова координата игрока по оси X
#define START_SHIP_Y 0//стартова координата игрока по оси Y
#define START_II_X 2560//стартовая координата искоственного интелекта по оси X
#define START_II_Y 0
#define SIZE_OBJECTS 160//розмер обьектов
#define MAX_POINTS 2560//конец оси X и Y
#define MINIMUM_POINTS 0//начало оси X и Y
#define MAX_ERROR 160//максимальная возвомжная погрешность при поднятии плода
#define MAX_Z_POINTS 1//конец оси Z
#define MINIMUM_Z_POINTS 0//начало оси Z
#define MAX_X_POINTS_BACKGROUND 2560//координаты фона для оси X
#define MINIMUM_X_POINTS_BACKGROUND 0//координаты фона для оси X
#define MAX_Y_POINTS_BACKGROUND 2560//координаты фона на оси Y
#define MINIMUM_Y_POINTS_BACKGROUND 0//координаты фона для оси Y
#define MAX_Y_TEXTURE 1//конец текстуры по оси Y
#define MAX_X_TEXTURE 1//конец текстуры по оси X
#define MINIMUM_Y_TEXTURE 0//начало текстуры по оси Y
#define MINIMUM_X_TEXTURE 0//начало текстуры по оси X

#include <GL/glfw.h>//подключаем glfw... я компилю на MinGW и подключаю такие либы:
#include <GL/glu.h>//glfw.a, glaux.a, libopengl32.a, libglu32.a, glfwdll.a .
#include <stdio.h>//printf ()
#include <GL/gl.h>
#include <GL/glaux.h>//это чисто для загрузки текстур, так как я грзить нормально текстуры не умею :(
#include <dos.h>

GLuint    texture[4];  // Место для текстур
BOOL on_off = "true";//поднят или не поднят плод
BOOL lvl [2561] [2561];
int plodov_sobarno = 0;//кол-во собраных плодов
int plodov_sobrano_ii = 0;

     struct point//структура для координат
     {
         int x;
         int y;
     }point;
//структура для обьектов
     typedef struct object{
     struct point one_points;
     struct point two_points;};

// Загрузка картинки и конвертирование в текстуру
GLvoid loading_textures()//часть этой функции взята из переведенных уроков Nehe: http://pmg.org.ru/nehe/nehe06.htm
{
     //там можна взять неплохое описание этой функции

  // Загрузка картинки
  AUX_RGBImageRec *texture1;
  texture1 = auxDIBImageLoad("textures/background.bmp");//фон

  // Создание текстуры
  glGenTextures(1, &texture[0]);
  glBindTexture(GL_TEXTURE_2D, texture[0]);

  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  glTexImage2D(GL_TEXTURE_2D, 0, 3, texture1->sizeX, texture1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, texture1->data);

  // Загрузка картинки
  AUX_RGBImageRec *texture2;
  texture2 = auxDIBImageLoad("textures/plod.bmp");//плоды, которые мы будем собирать

  // Создание текстуры
  glGenTextures(2, &texture[1]);
  glBindTexture(GL_TEXTURE_2D, texture[1]);

  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  glTexImage2D(GL_TEXTURE_2D, 0, 3, texture2->sizeX, texture2->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, texture2->data);

  // Загрузка картинки
  AUX_RGBImageRec *texture3;
  texture3 = auxDIBImageLoad("textures/I.bmp");//я, ну то есть корабль которым я буду управлять

  // Создание текстуры
  glGenTextures(2, &texture[2]);
  glBindTexture(GL_TEXTURE_2D, texture[2]);

  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  glTexImage2D(GL_TEXTURE_2D, 0, 3, texture3->sizeX, texture3->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, texture3->data);

  // Загрузка картинки
  AUX_RGBImageRec *texture4;
  texture4 = auxDIBImageLoad("textures/II.bmp");//плоды, которые мы будем собирать

  // Создание текстуры
  glGenTextures(2, &texture[3]);
  glBindTexture(GL_TEXTURE_2D, texture[3]);

  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  glTexImage2D(GL_TEXTURE_2D, 0, 3, texture4->sizeX, texture4->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, texture4->data);

}

void plods (struct object *plod)//функция для создания плодов, для нее передаем указатель на структуру плода
{
         plod->one_points.x = rand()%(MAX_POINTS-SIZE_OBJECTS) + MINIMUM_POINTS;//получаем рандомно координаты
         plod->one_points.y = rand()%(MAX_POINTS-SIZE_OBJECTS) + MINIMUM_POINTS;

         plod->two_points.x = plod->one_points.x + SIZE_OBJECTS;//создаем вторые координаты, т.к. у нас обьекты квадратные, мы просто добавляем SIZE_OBJECTS
         plod->two_points.y = plod->one_points.y + SIZE_OBJECTS;
         printf("x=%d,y=%d\n", plod->one_points.x, plod->one_points.y);//выводим координаты в консоль
}

void movement (struct object *ship)//функция управления нашим кораблем
{

     if (glfwGetKey(0x0057))//вперед, клавиша W
     {
         if (ship->two_points.y < MAX_POINTS && lvl [ship->one_points.y + 1] [ship->one_points.x] == "false")//чтобы не заходили за конци карты
         {
             ship->one_points.y = ++ship->one_points.y;
             ship->two_points.y = ++ship->two_points.y;
         }
     }
     if (glfwGetKey (0x0053))//назад, клавиша S
     {
         if (ship->one_points.y > MINIMUM_POINTS && lvl [ship->one_points.y - 1] [ship->one_points.x] == "false")
         {
             ship->one_points.y = --ship->one_points.y;
             ship->two_points.y = --ship->two_points.y;
         }
     }
     if (glfwGetKey(0x0041))//влево, клавиша A
     {
         if (ship->one_points.x > MINIMUM_POINTS && lvl [ship->one_points.y] [ship->one_points.x - 1 ] == "false")
         {
             ship->one_points.x = --ship->one_points.x;
             ship->two_points.x = --ship->two_points.x;
         }
     }
     if (glfwGetKey(0x0044))//вправо, клавиша D
     {
         if (ship->two_points.x < MAX_POINTS && lvl [ship->one_points.y] [ship->one_points.x + 1 ] == "false")
         {
             ship->one_points.x = ++ship->one_points.x;
             ship->two_points.x = ++ship->two_points.x;
         }
     }
}

void keep (struct object ship, struct object plod, struct object ship_ii)//функция по проверке стали ли мы на плод
{
         if (ship.one_points.x >= plod.one_points.x - MAX_ERROR && ship.one_points.x <= plod.one_points.x + MAX_ERROR && ship.one_points.y >= plod.one_points.y - MAX_ERROR && ship.one_points.y <= plod.one_points.y + MAX_ERROR)//если мы стали на координаты плода, изменяем добавляем В :)
         {
             on_off = "true";//отключаем плод
             plodov_sobarno++;//кол-во собраных плодов
         }
         else if (ship_ii.one_points.x >= plod.one_points.x - MAX_ERROR && ship_ii.one_points.x <= plod.one_points.x + MAX_ERROR && ship_ii.one_points.y >= plod.one_points.y - MAX_ERROR && ship_ii.one_points.y <= plod.one_points.y + MAX_ERROR)
         {
             on_off = "true";//отключаем плод
             plodov_sobrano_ii++;//кол-во собраных плодов
         }
}

void movement_ii (struct object *ship_ii, struct object plod)
{
     if (ship_ii->one_points.x > plod.one_points.x && lvl [ship_ii->one_points.y] [ship_ii->one_points.x - 1] == "false")
     {
         ship_ii->one_points.x--;
         ship_ii->two_points.x--;
     }
     else if (ship_ii->one_points.x < plod.one_points.x && lvl [ship_ii->one_points.y] [ship_ii->one_points.x + 1 ] == "false")
     {
         ship_ii->one_points.x++;
         ship_ii->two_points.x++;
     }

     if (ship_ii->one_points.y > plod.one_points.y && lvl [ship_ii->one_points.y - 1] [ship_ii->one_points.x] == "false")
     {
         ship_ii->one_points.y--;
         ship_ii->two_points.y--;
     }
     else if (ship_ii->one_points.y < plod.one_points.y && lvl [ship_ii->one_points.y + 1] [ship_ii->one_points.x] == "false")
     {
         ship_ii->one_points.y++;
         ship_ii->two_points.y++;
     }
}

void load_lvl ()
{
     //здесь будем загружать лвл
     int x = 0;
     int y;
     while(x < 2561)
     {
         y = 0;
         for (; y < 2561; y++)
         {
             lvl[x][y] = "false";
         }

         ++x;
     }
     lvl[1000][1000]= "true";
     printf("%d\n", lvl[1][1000]);

}

void screen ()//выводим все на экран
{
     if (glfwInit())//запускаем glfw, если да делаем окно
     {
         if(glfwOpenWindow(256,256,0,0,0,0,0,0,GLFW_WINDOW))//открываем окно 256*256, если открыли рисуем
         {
             BOOL running = "false";//для проверки открыто ли окно и нажате ли клавиша ESC
             srand((unsigned)time(NULL));//это для rand()
             load_lvl();
             int lvl_x = 0;
             int lvl_y = 0;

             struct object ship;//создаем корабль
             ship.one_points.x=START_SHIP_X;//присваиваем ещё стартовые координаты
             ship.one_points.y=START_SHIP_Y;
             ship.two_points.x=START_SHIP_X + SIZE_OBJECTS;
             ship.two_points.y=START_SHIP_Y + SIZE_OBJECTS;

             struct object ship_ii;
             ship_ii.one_points.x=START_II_X;
             ship_ii.one_points.y=START_II_Y;
             ship_ii.two_points.x=START_II_X + SIZE_OBJECTS;
             ship_ii.two_points.y=START_II_Y + SIZE_OBJECTS;

             struct object plod;//создаем плод
             plods(&plod);//выщитываем новые координаты
             loading_textures();//загружаем все текстуры, потом будем к ним обращятся через их ID

             while(running)//цикл рисования
             {
                 lvl_x=0;

                 glClear( GL_DEPTH_BUFFER_BIT); // Очищаем буфер глубины.
                 glDisable( GL_DEPTH_TEST); // Выключаем буфер глубины, для создания фона

                 glClear(GL_COLOR_BUFFER_BIT);//очистка
                 glLoadIdentity();//сброс
                 glOrtho (MINIMUM_POINTS,MAX_POINTS,MINIMUM_POINTS,MAX_POINTS,MINIMUM_Z_POINTS,MAX_Z_POINTS);//создаем систему координат

                 glBindTexture(GL_TEXTURE_2D, texture[0]);//ищем текстуру фона, следующий полигон будет для фона
                 glEnable(GL_TEXTURE_2D);// Разрешение наложение текстуры
                 glBegin(GL_POLYGON);//рисуем полигон
                     glTexCoord2f(MINIMUM_X_TEXTURE, MINIMUM_Y_TEXTURE);//выставляем вершины текстуры на вершины квадрата
                     glVertex2d(MINIMUM_POINTS, MINIMUM_POINTS);//координаты самих вершин квадрата

                     glTexCoord2f(MINIMUM_X_TEXTURE, MAX_Y_TEXTURE);
                     glVertex2d(MINIMUM_POINTS, MAX_POINTS);

                     glTexCoord2f(MAX_X_TEXTURE, MAX_Y_TEXTURE);
                     glVertex2d(MAX_POINTS,MAX_POINTS);

                     glTexCoord2f(MAX_X_TEXTURE, MINIMUM_Y_TEXTURE);
                     glVertex2d(MAX_POINTS,MINIMUM_POINTS);
                 glEnd();//заканчиваем рисования фона
                 glEnable( GL_DEPTH_TEST); // Включаем буфер глубины и можем нормально рисовать по фону

                 glBindTexture(GL_TEXTURE_2D, texture[1]);//ищем текстуру плода
                 glEnable(GL_TEXTURE_2D);

                 glBindTexture(GL_TEXTURE_2D, texture[1]);//ищем текстуру плода
                 glEnable(GL_TEXTURE_2D);

                 glBegin(GL_POLYGON);//рисуем плод
                         glTexCoord2f(MINIMUM_X_TEXTURE,MINIMUM_Y_TEXTURE);
                         glVertex2d(plod.one_points.x,plod.one_points.y);

                         glTexCoord2f(MINIMUM_X_TEXTURE,MAX_Y_TEXTURE);
                         glVertex2d(plod.one_points.x,plod.two_points.y);

                         glTexCoord2f(MAX_X_TEXTURE,MAX_Y_TEXTURE);
                         glVertex2d(plod.two_points.x,plod.two_points.y);

                         glTexCoord2f(MAX_X_TEXTURE,MINIMUM_Y_TEXTURE);
                         glVertex2d(plod.two_points.x,plod.one_points.y);
                 glEnd();//заканчиваем плод

                 glBindTexture(GL_TEXTURE_2D, texture[2]);//ищем текстуру корабля
                 glEnable(GL_TEXTURE_2D);
                 glBegin(GL_POLYGON);//рисуем корабль
                     glTexCoord2f(MINIMUM_X_TEXTURE,MINIMUM_Y_TEXTURE);
                     glVertex2d(ship.one_points.x,ship.one_points.y);

                     glTexCoord2f(MINIMUM_X_TEXTURE,MAX_Y_TEXTURE);
                     glVertex2d(ship.one_points.x,ship.two_points.y);

                     glTexCoord2f(MAX_X_TEXTURE,MAX_Y_TEXTURE);
                     glVertex2d(ship.two_points.x,ship.two_points.y);

                     glTexCoord2f(MAX_X_TEXTURE,MINIMUM_Y_TEXTURE);
                     glVertex2d(ship.two_points.x,ship.one_points.y);
                 glEnd();//заканчиваем корабль

                 glBindTexture(GL_TEXTURE_2D, texture[3]);//ищем текстуру корабля
                 glEnable(GL_TEXTURE_2D);
                 glBegin(GL_POLYGON);//рисуем корабль
                     glTexCoord2f(MINIMUM_X_TEXTURE,MINIMUM_Y_TEXTURE);
                     glVertex2d(ship_ii.one_points.x,ship_ii.one_points.y);

                     glTexCoord2f(MINIMUM_X_TEXTURE,MAX_Y_TEXTURE);
                     glVertex2d(ship_ii.one_points.x,ship_ii.two_points.y);

                     glTexCoord2f(MAX_X_TEXTURE,MAX_Y_TEXTURE);
                     glVertex2d(ship_ii.two_points.x,ship_ii.two_points.y);

                     glTexCoord2f(MAX_X_TEXTURE,MINIMUM_Y_TEXTURE);
                     glVertex2d(ship_ii.two_points.x,ship_ii.one_points.y);
                 glEnd();//заканчиваем корабль

                  glFlush();//выводим на экран, а не сохраняем в буфер
                  glfwSwapBuffers();

                  if (on_off == "true")//если да
                  {
                      on_off = "false";//включаем плод
                      plods(&plod);//выщитываем новые координаты

                  }

                  movement_ii (&ship_ii,plod);
                  movement(&ship);//ходим, передаем указатель на структуру корабля
                  keep(ship,plod,ship_ii);//проверка подняли ли мы плод

                  running=!glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED);//если окно закрыто, или нажата клавиша Esc - выход

             }

         }

         glfwTerminate();//удаляем
     }
     else
     {
         printf("error: 1. glfwInit");//если glfwInit ошибка, пишем её в консоль
     }
}

int main (int argc, char *argv[])
{
     screen();//рисуем

     printf("\nVy sobrali %d plod(ov)\n", plodov_sobarno);//пишем кол-во плодов после закрытия окна рисования на консоль
     printf("II sobralo %d plod(ov)\n", plodov_sobrano_ii);//пишем кол-во плодов после закрытия окна рисования на консоль

     if (plodov_sobarno > plodov_sobrano_ii)
     {
         printf("\n\n\n                    Vy vyigrali!!!\n\n\n");
     }
     else if (plodov_sobarno < plodov_sobrano_ii)
     {
         printf("\n\n\n                    Vy proigrali!!!\n\n\n");
     }
     else if (plodov_sobarno == plodov_sobrano_ii)
     {
         printf("\n\n\n                    Nichja!!!\n\n\n");
     }

     getch();//для завершения нажмите любую клавишу
     return 0;
}

#include <conio.h>
#include <iostream>
#include <clocale>
#include <ctime>

using namespace std;

char map[25][31];
int napr;
int yaii = 14;
int xaii = 10;
int aiifuel = 10;
int xy = 15 - yaii;
int yx = yaii - 15;
int xy1 = 10 - xaii;
int yx1 = xaii - 10;

int aii()// зделать бензин
{

  if (aiifuel < 6)
  {

      if (yaii < 15)
   {

    yaii++;

   }
   else if (yaii > 15)
   {
    yaii--;
   }

   if (xaii < 10)
   {
    xaii++;
   }
   else if (xaii > 10)
   {
    xaii--;
   }

  }
  else
     napr = rand() % 4;
     map [yaii][xaii] = ' ';
     switch(napr) {
     case 0:
         ++yaii;
         break;
     case 1:
         --yaii;
         break;
     case 2:
         ++xaii;
         break;
     case 3:
         --xaii;
         break;
     }
     map [yaii][xaii] = 'X';
return map [yaii][xaii];
}

int fuel (char map [25][31], int fuel)
{
fuel = fuel - 1;
if (map [15][10] == 'T')
{
fuel = 20;
}

if (fuel == 0)
{
system("cls");
cout << "Вы проиграли!";
exit(0);
}
return fuel;
}

int main()
{
  srand(time(0));
  setlocale(LC_CTYPE,"Russian");

// инициализация массива

  for (int p = 0; p < 23; p++)
  {
   for (int o = 0; o < 30; o++)
   {
map[p][o] = ' ';  
   }
  }

for (int l = 0; l < 30; l = l + 1)
{
map [l][22] = '|';
}
for (int k = 0; k < 22; k = k + 1)
{
map [21][k] = '-';
}
char act;
int bbb;
int x = 15;
int y = 10;
int afuel = 20;

map [10][15] = 'T';
map [15][10] = 'C';
    for (int i = 0; i < 22; i++)
  {
   for (int j = 0; j < 30; j++)
   {
    cout << map[i][j]; // в циклах поэлементно выводится массив
   }
   cout << "\n"; // переход на новую строку после каждого "ряда"
  }
  cout << "Управление - стрелочками, выход - Esc, другой лвл - R.\n";

for (;;)
{
act = _getch();
bbb = static_cast<int>(act);
if (bbb == -32)
{
}
else if (bbb == 114)
{
   system("cls");
  for (int p = 0; p < 23; p++)
  {
   for (int o = 0; o < 30; o++)
   {
map[p][o] = ' ';  
   }
  }

for (int l = 0; l < 30; l = l + 1)
{
map [l][22] = '|';
}
for (int k = 0; k < 22; k = k + 1)
{
map [21][k] = '-';
}

int v = 0;
while (v < 12)
{
v = v + 1;
int n;
int m;
n = rand()%10;
m = rand()%10;
map [n][m] = '0';
}

for (int i = 0; i < 22; i++)
  {
   for (int j = 0; j < 30; j++)
   {
    cout << map[i][j]; // в циклах поэлементно выводится массив
   }
   cout << "\n"; // переход на новую строку после каждого "ряда"
  }
  cout << "Управление - стрелочками, выход - Esc, другой лвл - R.\n";

}
else if (bbb == 27)
{
cout << "Выход";
exit (0);
}
else if (bbb == 75)
{
   system("cls");
   map[y][x] = ' ';
   x = x - 1;
   if (x == -1)
   {
   x = x + 1;
   }
   map [15][10] = 'C';
  afuel = fuel (map, afuel);
    map[y][x] = 'T';  
if (map [yaii][xaii] == 'T')
{
   system("cls");
   cout << "Вы победили";
}
aii();
if (map [y][x] == 'X')
{
   system("cls");
   cout << "Вы проиграли";
}
    for (int i = 0; i < 22; i++)
  {
   for (int j = 0; j < 30; j++)
   {
    cout << map[i][j]; // в циклах поэлементно выводится массив
   }
   cout << "\n"; // переход на новую строку после каждого "ряда"
  }
  cout << "Управление - стрелочками, выход - Esc, другой лвл - R.\n";

}
else if (bbb == 77)
{
   system("cls");
  map[y][x] = ' ';
   x = x + 1;
     if (x == 22)
   {
   x = x - 1;
   }
   map [15][10] = 'C';
   map[y][x] = 'T';
  afuel = fuel (map, afuel);
    map[y][x] = 'T';
if (map [yaii][xaii] == 'T')
{
   system("cls");
   cout << "Вы победили";
}
aii();
if (map [y][x] == 'X')
{
   system("cls");
   cout << "Вы проиграли";
}
  for (int i = 0; i < 22; i++)
  {
   for (int j = 0; j < 30; j++)
   {
    cout << map[i][j]; // в циклах поэлементно выводится массив
   }
   cout << "\n"; // переход на новую строку после каждого "ряда"
  }
     cout << "Управление - стрелочками, выход - Esc, другой лвл - R.\n";
}
else if (bbb == 72)
{
   system("cls");  
  map[y][x] = ' ';
   y = y - 1;
     if (y == -1)
   {
   y = y + 1;
   }
   map [15][10] = 'C';
    map[y][x] = 'T';  
if (map [yaii][xaii] == 'T')
{
   system("cls");
   cout << "Вы победили";
}
aii();
if (map [y][x] == 'X')
{
   system("cls");
   cout << "Вы проиграли";
}
    for (int i = 0; i < 22; i++)
  {
   for (int j = 0; j < 30; j++)
   {
    cout << map[i][j]; // в циклах поэлементно выводится массив
   }
   cout << "\n"; // переход на новую строку после каждого "ряда"
  }
     cout << "Управление - стрелочками, выход - Esc, другой лвл - R.\n";

}
else if (bbb == 80)
{

   system("cls");  
  map[y][x] = ' ';
   y = y++;
       if (y == 21)
   {
   y = y - 1;;
   }
   map [15][10] = 'C';
   map[y][x] = 'T';
  afuel = fuel (map, afuel);
    map[y][x] = 'T';  
if (map [yaii][xaii] == 'T')
{
   system("cls");
   cout << "Вы победили";
}
aii();
if (map [y][x] == 'X')
{
   system("cls");
   cout << "Вы проиграли";
}
    for (int i = 0; i < 22; i++)
  {
   for (int j = 0; j < 30; j++)
   {
    cout << map[i][j]; // в циклах поэлементно выводится массив
   }
   cout << "\n"; // переход на новую строку после каждого "ряда"
  }
     cout << "Управление - стрелочками, выход - Esc, другой лвл - R.\n";
}
else
{
   cout << "Вы нажали неверную клавишу!\n";
}
}

return 0;
}