Курсач, выводит ошибку LNK2019

#include <iostream>
#include "math.h"
#include "conio.h"
#include "Windows.h"
#include <vector>
#include <string>
#include <queue>
#include <functional>
#include <cstdlib>
#include <clocale>
using namespace std;
//---------------------------------------------------------------------------------------------------------------------------------------
// отрисовка меню
void ToDrawMenu()
{
    HANDLE hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD position;
    position.X = 35;
    position.Y = 5;
    SetConsoleCursorPosition(hstdout, position);
    std::cout << "1) Заставка." << endl;
    position.X = 35;
    position.Y = 7;
    SetConsoleCursorPosition(hstdout, position);
    std::cout << "2) Калькулятор" << endl;
    position.X = 35;
    position.Y = 9;
    SetConsoleCursorPosition(hstdout, position);
    std::cout << "3) Игра" << endl;
    position.X = 35;
    position.Y = 11;
    SetConsoleCursorPosition(hstdout, position);
    std::cout << "4) Об авторе" << endl;
    position.X = 35;
    position.Y = 13;
    SetConsoleCursorPosition(hstdout, position);
    std::cout << "5)Выход" << endl;
}
 
//---------------------------------------------------------------------------------------------------------------------------------------
// заставка
void ToAnimation()
{
    system("cls");
    int index = 150;
    int delta = 1;
    do {
        HWND hwn = GetConsoleWindow();
        HDC hdc = GetDC(hwn);
        HPEN pen = CreatePen(PS_DASHDOT, 2, RGB(100, 11, 125));
        HBRUSH brush = CreateSolidBrush(RGB(129, 67, 90));
        HPEN pen1 = CreatePen(PS_DASH, 2, RGB(200, 34, 147));
        SelectObject(hdc, pen);
        SelectObject(hdc, brush);
        Ellipse(hdc, 650 - index, 480 - index, 250 + index, 160 + index);
        SelectObject(hdc, pen1);
        Ellipse(hdc, 550 - index, 480 - index, 150 + index, 160 + index);
        if (index > 500)
            delta = -1;
        if (index < 150)
            delta = 1;
        index += delta;
        Sleep(3);
    } while (!_kbhit());
    system("pause");
}
 
//---------------------------------------------------------------------------------------------------------------------------------------
// калькулятор
double Suma(double a1, double a2) {
    double sum = a1 + a2;
    //  std::cout << a1 << "+" << a2 << "=" << sum << endl;
    return sum;
}
double Razno(double a1, double a2) {
    double razn = a1 - a2;
    //  std::cout << a1 << "-" << a2 << "=" << razn << endl;
    return razn;
}
double Proizv(double a1, double a2) {
 
    double proiz = a1 * a2;
    //  std::cout << a1 << "*" << a2 << "=" << proiz << endl;
    return proiz;
}
double Dele(double a1, double a2) {
    double del = a1 / a2;
    //  std::cout << a1 << "/" << a2 << "=" << del << endl;
    return del;
}
 
int Calculate() {
    double a1, a2, res;
    char b;
    setlocale(LC_ALL, "Rus");
    cout << ("Введите два числа:") << endl;
    cin >> a1 >> a2;
    cout << ("Выберите необходимую операцию") << endl;
    cout << ("'+' - cложение") << endl;
    cout << ("'-' - вычитание") << endl;
    cout << ("'/' - деление") << endl;
    cout << ("'*' - умножение") << endl;
    cin >> b;
    switch (b) {
    case '+':
        res = Suma(a1, a2);
        break;
    case '-':
        res = Razno(a1, a2);
        break;
 
    case '*':
        res = Proizv(a1, a2);
        break;
    case '/':
        res = Dele(a1, a2);
        break;
 
    default:
        std::cout << "Выберите из списка предложенных\n";
        system("pause");
        return 1;
    }
    cout << a1 << b << a2 << "=" << res << endl;
    system("pause");
    return 0;
}
//---------------------------------------------------------------------------------------------------------------------------------------
// игра
//-----------------------------------------------------------------------------------------------------------------------
//объявление глобальных переменных
void initgame();
void fulldraw();
void redraw();
void input();
void move_bots(COORD&);
void move_win(COORD&);
void gameover();
void gamewin();
void move_gold(COORD&);
using namespace std;
 
vector<string> world =
{ "##########################",
    "#                        #",
    "#       #      #         #",
    "#       #   G  #         #",
    "#       ##################",
    "#       #      #         #",
    "#   F   #      #         #",
    "#                 F      #",
    "#       #      #         #",
    "#       #      #         #",
    "#       #      #         #",
    "#           P            #",
    "##########################"
};
COORD player; //игрок
COORD gold;   //золото
vector<COORD> foes; //враг
vector<COORD> g;
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 Game()
{
    COORD E = { 12, 3 };
    world[E.Y][E.X] = 'G';
 
    initgame();
    fulldraw();
 
    while (gameplay)
    {
        redraw();
        if (E == player) gamewin();
 
        Sleep(100);
        input();
 
        if (++time_numerator > time_denominator)
        {
            time_numerator -= time_denominator;
            for (auto& foe : foes)
            {
                move_bots(foe);
                if (foe == player)
                    gameover();
            }
            for (auto& G : g)
            {
                move_win(G);
            }
        }
    }
    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 'G':
                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;//выбирает наихудший фактор, чтобы глубже зашнуровать его в очереди
    }
};
 
//-----------------------------------------------------------------------------------------------------------------------
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 move_win(COORD& G)
{
    vector<vector<bool> > visited(world.size(), vector<bool>(world[0].size(),
        false));
    std::priority_queue <astar, std::vector<astar>, best_way > stars;
    visited[G.Y][G.X] = true;
    for (int i = 0; i < 4; ++i)
    {
        int x = G.X + directions[i].X;
        int y = G.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)
        {
            G.X += stars.top().initial_dx;
            G.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)) {} //определяет нажимание кнопки выхода
}
 
//-----------------------------------------------------------------------------------------------------------------------
//выигрыш
void gamewin()
{
    gameplay = false;
    SetConsoleCursorPosition(out, { 30, 10 });
    cout << "GAME Win";
    while (!GetAsyncKeyState(VK_ESCAPE)) {}
}
//---------------------------------------------------------------------------------------------------------------------------------------
// Об авторе
void AboutMe()
{
    system("cls");
    HANDLE hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD position;
    position.X = 30;
    position.Y = 7;
    SetConsoleCursorPosition(hstdout, position);
    cout << "Фамилия : Лисова" << endl;
    position.X = 30;
    position.Y = 10;
    SetConsoleCursorPosition(hstdout, position);
    cout << "Имя : Анастасия" << endl;
    position.X = 30;
    position.Y = 13;
    SetConsoleCursorPosition(hstdout, position);
    cout << "Год и место обучения : 2020 ОмГТУ" << endl;
    position.X = 30;
    position.Y = 16;
    SetConsoleCursorPosition(hstdout, position);
    cout << "Факультет : ФИТиКС" << endl;
    position.X = 30;
    position.Y = 19;
    SetConsoleCursorPosition(hstdout, position);
    cout << "Группа : ПИ-192" << endl;
    system("pause");
}
//---------------------------------------------------------------------------------------------------------------------------------------
// Выход
 
//---------------------------------------------------------------------------------------------------------------------------------------
// Очистка экрана
void SystemClear()
{
    HWND hwn = GetConsoleWindow();
    HDC hdc = GetDC(hwn);
    HPEN pen = CreatePen(PS_DASHDOT, 2, RGB(0, 255, 0));
    HBRUSH brush = CreateSolidBrush(RGB(0, 0, 0));
    SelectObject(hdc, pen);
    SelectObject(hdc, brush);
    Rectangle(hdc, 0, 0, 2000, 2000);
}
//---------------------------------------------------------------------------------------------------------------------------------------
// переходы из меню
void ToViewMenu()
{
    system("cls");
    HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE),
        hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    DWORD result;
    COORD position;
    INPUT_RECORD keyBuff;
    ToDrawMenu();
    ReadConsoleInput(hStdin, &keyBuff, 1, &result);
    switch (keyBuff.Event.KeyEvent.uChar.AsciiChar)
    {
    case '1':
    {
        ToAnimation();
        SystemClear();
        break;
    }
    case '2':
        Calculate();
        SystemClear();
        break;
    case '3':
        Game();
        SystemClear();
        break;
    case '4':
        AboutMe();
        SystemClear();
        break;
 
    case '5':
        exit(0);
        break;
    }
}