Игра с перемещением персонажа и врагов

#include <iostream> 
#include <vector>
#include <string>
#include <queue>
#include <functional>
#include <Windows.h>
void initgame();
void fulldraw();
void redraw();
void input();
void move_bots(COORD&);
void gameover();
using namespace std;
vector<string> world = {
    "##########################",
    "#                        #",
    "#       #      #         #",
    "#       #   T  #         #",
    "#       ##################",
    "#       #      #         #",
    "#   F   #      #         #",
    "#                 F      #",
    "#       #      #         #",
    "#       #      #         #",
    "#       #      #         #",
    "#           P            #",
    "##########################"
};
COORD player;
COORD gold;
vector<COORD> foes;
HANDLE out;
const COORD directions[] = { {0,1}, {1,0},{0,-1}, {-1,0} };
int time_numerator, time_denominator;
bool gameplay = true;
bool operator ==(COORD left, COORD right)
{
    return left.X == right.X && left.Y == right.Y;
}
bool operator !=(COORD left, COORD right)
{
    return left.X != right.X || left.Y != right.Y;
}
int main() {
 
 
    initgame();
    fulldraw();
    while (gameplay)
    {
        redraw();
        Sleep(100);
        input();
        
        if (++time_numerator > time_denominator)
        {
            time_numerator -= time_denominator;
            for (auto& foe : foes)
            {
                move_bots(foe);
                if (foe == player)
                    gameover();
            }
        }
    }
    return 0;
}
void input() {
    if (GetAsyncKeyState(VK_UP) && world[player.Y - 1][player.X] == ' ')
        --player.Y;
    if (GetAsyncKeyState(VK_DOWN) && world[player.Y + 1][player.X] == ' ')
        ++player.Y;
    if (GetAsyncKeyState(VK_LEFT) && world[player.Y][player.X-1] == ' ')
        --player.X;
    if (GetAsyncKeyState(VK_RIGHT) && world[player.Y][player.X + 1] == ' ')
        ++player.X;
    for (auto& foe : foes)
        if (foe == player)
            gameover();
}
void redraw() {
    static COORD p = { 1,1 }, g = { 1,1 };
    static vector<COORD> f;
    if (player != p) {
        SetConsoleCursorPosition(out, p);
        cout << " ";
        p = player;
        SetConsoleCursorPosition(out, p);
        cout << "P";
    }
    if (gold != g) {
        SetConsoleCursorPosition(out, g);
        cout << " ";
        g = gold;
        SetConsoleCursorPosition(out, g);
        cout << "G";
    }
    for (int i=0; i<foes.size(); ++i)
        if (i >= f.size()) {
            f.push_back(foes[i]);
            SetConsoleCursorPosition(out, foes[i]);
            cout << "F";
        }
        else if (f[i]!=foes[i]) {
            SetConsoleCursorPosition(out, f[i]);
            cout << " ";
            f[i] = foes[i];
            SetConsoleCursorPosition(out, f[i]);
            cout << "F";
        }
}
void fulldraw() {
    SetConsoleCursorPosition(out, { 0,0 });
    for (auto row : world)
        cout << row << endl;
}
void initgame() 
{
    out = GetStdHandle(STD_OUTPUT_HANDLE);
    time_numerator = 3;
    time_denominator= 5;
    for (SHORT i=0; i<world.size(); ++i)
        for (SHORT j=0; j<world[i].size(); ++j)
            switch (world[i][j])
            {
            case 'T':
                gold = { j, i };
                world[i][j] = ' ';
                break;
            case 'P':
                player = { j, i };
                world[i][j] = ' ';
                break;
            case 'F':
                foes.push_back({ j, i });
                world[i][j] = ' ';
                break;
            default:
                break;
            }
}
struct astar {
    int x, y;
    int dist;
    int initial_dx, initial_dy;
};
struct best_way
{
    constexpr bool operator()(const astar& left, const astar& right) const
    {
        return left.dist > right.dist;//chooses the worst factor in order to lace it deeper in the queue
    }
};
void move_bots(COORD& foe) {
    vector<vector<bool> > visited(world.size(), vector<bool>(world[0].size(), false));
    std::priority_queue <astar, std::vector<astar>, best_way > stars;
    visited[foe.Y][foe.X] = true;
    for (int i = 0; i < 4; ++i)
    {
        int x = foe.X + directions[i].X;
        int y = foe.Y + directions[i].Y;
        if (world[y][x] == ' ' && !visited[y][x])
        {
            astar new_node = {  x, y, 0 , directions[i].X,  directions[i].Y};
            new_node.dist = abs(new_node.x - player.X) + abs(new_node.y - player.Y);
            stars.push(new_node);
            visited[y][x] = true;
        }
 
    }
    while (!stars.empty())
    {
        if (stars.top().x == player.X && stars.top().y == player.Y)
        {
            foe.X += stars.top().initial_dx;
            foe.Y += stars.top().initial_dy;
            return;
        }
        astar root = stars.top();
        stars.pop();
        for (int i = 0; i < 4; ++i)
        {
            int x = root.x + directions[i].X;
            int y = root.y + directions[i].Y;
            if (world[y][x] == ' ' && !visited[y][x])
            {
                astar new_node = {x, y, 0, root.initial_dx,  root.initial_dy };
                new_node.dist = abs(new_node.x - player.X) + abs(new_node.y - player.Y);
                stars.push(new_node);
                visited[y][x] = true;
            }
 
        }
 
    }
}
void gameover(){
    gameplay = false;
    SetConsoleCursorPosition(out, { 30, 10 });
    cout << "GAME OVER";
    while (!GetAsyncKeyState(VK_ESCAPE)) {}
}