Змейка в C++ builder 10 Seatle

//---------------------------------------------------------------------------
 
#include <vcl.h>
#include <iostream>
#include <time.h>
#include <random>
#include <cstdlib>
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
TImage *Z[5];
TImage *A1;
 
bool fructvis;
bool Napr;
int Znapr;
 
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
  Napr=true; //горизонтальное перемещение
  Znapr=1;
  A1=Fruit1;
  Z[0]=Image1;
  Z[1]=Image2;
  Z[2]=Image3;
  Z[3]=Image4;
  Z[4]=Image5;
 
  Z[4]->Left=0;
  Z[4]->Top=0;
  Z[4]->Visible=true;
  for (int i = 3; i >=0; i--)
    {
    Z[i]->Left=Z[i+1]->Left+Z[i]->Width;
    Z[i]->Top=Z[i+1]->Top;
    Z[i]->Visible=true;
    }
 
}
 
//---------------------------------------------------------------------------
     //Обработчик нажатия кнопок
//---------------------------------------------------------------------------
void __fastcall TForm1::FormKeyUp(TObject *Sender, WORD &Key, TShiftState Shift)
{
  if (Key==38) //вверх
  {
     Napr=false;
     Znapr=-1;
  } else
  if (Key==40) //вниз
  {
    Napr=false;
    Znapr=1;
  } else
  if (Key==37) //влево
  {
    Napr=true;
    Znapr=-1;
  } else
  if (Key==39) //вправо
  {
    Napr=true;
    Znapr=1;
  }
}
//---------------------------------------------------------------------------
 
 //Обработчик таймера
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
 int Xold,Yold,
    Xnew=Z[0]->Left, Ynew=Z[0]->Top;
  if (Napr) Z[0]->Left+=Znapr*30;
  else Z[0]->Top+=Znapr*30;
  for (int i = 1; i < 5; i++)
  {
    Xold=Z[i]->Left;
    Yold=Z[i]->Top;
    Z[i]->Left=Xnew;
    Z[i]->Top=Ynew;
    Xnew=Xold;
    Ynew=Yold;
  }
}
//---------------------------------------------------------------------------
 
//Таймер на появление фрукта
void __fastcall TForm1::Timer2Timer(TObject *Sender)
{
    int a,b;
    for (int i = 0; i <= 1; i++)
        {
          srand(time(NULL));
          a  = rand () % 20 - 0;
          a = a * 30;
          a = A1->Top;
          srand (time(NULL));
          b = rand () % 20 - 0;
          b = b * 30;
          b = A1->Left;
        }
    A1->Visible=true;
}

#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <vector>
#include <utility>
#include <memory>
#include <deque>
#include <algorithm>
#include <conio.h>
using namespace std;
 
class snake {   
    typedef pair<size_t, size_t> pair_szt;
    deque<shared_ptr<pair_szt>> sn; // сама змейка
    vector<shared_ptr<pair_szt>> pr; // для печати
    vector<shared_ptr<pair_szt>> br; // цели(яблоки)
public:
    snake() {
        size_t lev;
        cout << "\n Enter level from 1 to 30: "; cin >> lev;
        while (!cin.good() || lev < 1 || lev > 30) {
            cin.clear();
            while (cin.get() != '\n');
            cout << " Incorrect input, try again: "; cin >> lev;
        }
 
 
        while (br.size() < lev) {
            size_t i = 2 + rand() % 20, j = 2 + rand() % 70;
            pair_szt w{ i, j };
            if (find_if(br.begin(), br.end(), [w](shared_ptr<pair_szt> &a) ->bool {
                return *a == w;
            }) == br.end())         
                br.emplace_back(make_shared<pair_szt>(w));          
        }
        pr = br;
        lev += 15;
        for (pair<size_t, size_t> ls(3, 4); ls.second < lev; ++ls.second)
            insert(ls);
    }
    pair<bool, bool> insert(pair_szt);
    void pop_back() {
        auto z = sn.back();
        pr.erase(find_if(pr.begin(), pr.end(), [z](shared_ptr<pair_szt> &a) ->bool {
            return *a == *z;
        }));
        sn.pop_back();
    }
    size_t speed() const { return sn.size(); }
    pair_szt front() const { return *sn.front(); }
    vector<shared_ptr<pair_szt>> ret_sn() const { return pr; }
};
//----------------------------------------------------------------------------
class manag {
    typedef pair<size_t, size_t> pair_szt;
    int mv;
public:
    manag() : mv('d') {} // для управления
    pair_szt move(pair_szt poz, int new_mv) {
        if (new_mv != 'a' && new_mv != 'w' && new_mv != 'd' && new_mv != 's')
            new_mv = mv;
        switch (new_mv) {
        case 'd':
            if (mv == 'a')--poz.second;
            else { ++poz.second; mv = new_mv; }
            break;
        case 's':
            if (mv == 'w') --poz.first;
            else { ++poz.first; mv = new_mv; }
            break;
        case 'a':
            if (mv == 'd') ++poz.second;
            else { --poz.second; mv = new_mv; }
            break;
        case 'w':
            if (mv == 's') ++poz.first;
            else { --poz.first; mv = new_mv; }
            break;
        }
        return poz;
    }
    void print(vector<shared_ptr<pair_szt>>) const;
};
//-----------------------------------------------------------------
int main() {
    for (int j = 2; j; --j) {
        for (int i = 0; i < 7; ++i) cout << endl;
        for (int i = 0; i < 20; ++i) cout << ' ';
        cout << (j == 2 ? "Hello Guys!!!" : "Are you ready???))))");
        _sleep(1000);
        system("cls");
    }
    cout << "\n CONTROL!!!\n only English keyboard layout\n up\t'w'\n left\t'a'\n right\t'd'\n down\t's'\n";
    snake sn_k;
    manag cont; 
    cout << " Enter speed snake from 1 to 5: ";
    int ctr = 'd', spd, ln_sn = sn_k.speed() - 1; cin >> spd;
    while (!cin.good() || spd < 1 || spd > 5) {
        cin.clear();
        while (cin.get() != '\n');
        cout << " Incorrect input, from 1 to 5, try again: "; cin >> spd;
    }
    spd = 900 - spd * 100; // задается скорость
    system("cls");
    cont.print(sn_k.ret_sn());
    pair<bool, bool> pb;
    while ((pb = sn_k.insert(cont.move(sn_k.front(), ctr))).first) {    
        if (pb.second) sn_k.pop_back(); 
        if (_kbhit()) 
            ctr = getch();          
        if (ctr == 'p') ctr = getch();
        if (ctr == 'x') { cout << endl; system("pause"); exit(0); }
        _sleep(spd / ((sn_k.speed() - ln_sn) * 1.3)); // вот здесь можно изменить набор скорости змейки
        system("cls");
        
        cont.print(sn_k.ret_sn());
    }
    system("cls");
    for (int i = 0; i < 7; ++i) cout << endl;
    for (int i = 0; i < 20; ++i) cout << ' ';
    cout << "(((( " << (pb.second ? "YOU WIN" : "CRASH") << " ))))\n\n\n\n\n\n\n";
    system("pause");
    return 0;
}
//--------------------------------------------------------------------
pair<bool, bool> snake::insert(pair_szt w) { // вставляет элементы в массивы
    if (!w.first || !w.second || w.first > 23 || w.second > 78 || 
        find_if(sn.begin(), sn.end(), [w](shared_ptr<pair_szt> &a) ->bool {
        return *a == w;
    }) != sn.end()) return{ false, false };
 
    vector<shared_ptr<pair_szt>>::iterator it;
    if ((it = find_if(br.begin(), br.end(), [w](shared_ptr<pair_szt> &a) ->bool {
        return *a == w;
    })) != br.end()) {
        br.erase(it);
        sn.push_front(make_shared<pair_szt>(w));
        if (br.empty()) return{ false, true };      
        return{ true, false };
    }
 
    sn.emplace_front(make_shared<pair_szt>(w. first, w.second));
    pr.push_back(sn.front());   
    sort(pr.begin(), pr.end(), [](shared_ptr<pair_szt> &a, shared_ptr<pair_szt> &b) ->bool {
        if (a->first != b->first)
            return a->first < b->first;
        else
            return a->second < b->second;
    });
    return{ true, true };
}
//-----------------------------------------------------------------
void manag::print(vector<shared_ptr<pair_szt>> snk) const { // печатает
    size_t n_str = 0, b_spc = 0;
    cout << "     to pause press 'p', to exit 'x'";
    for (auto &ptr : snk) {     
        if (n_str < ptr->first) {
            for (size_t i = 0; i < ptr->first - n_str; ++i)
                cout << '\n';
            n_str = ptr->first;
            b_spc = 0;
        }
        if (b_spc < ptr->second) {
            for (size_t i = 1; i < ptr->second - b_spc; ++i)
                cout << ' ';
            b_spc = ptr->second;
        }
        cout << 'o'; 
    }
}