FootBall

#include <thread>
#include <mutex>
#include "framework.h"

#include <cmath>
#include <string>
#include <ctime>

using namespace std;

HINSTANCE hInst;                                // текущий экземпляр

                                                //МОИ ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
HWND hWnd;

ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);

//МОИ ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
const int WINDOW_SIZE = 700;
const int rBall = 20;
const int widthGoals = 10;

double xG = WINDOW_SIZE / 2, yG = WINDOW_SIZE / 2 - 200; //кординаты вратаря
double xA = WINDOW_SIZE / 2 - 200, yA = WINDOW_SIZE / 2 + 250; //координаты нападающего
double xD = WINDOW_SIZE / 2, yD = WINDOW_SIZE / 2 - 100; //координаты защитника
double xB = xA, yB = yA - rBall; //координаты мяча

double speedB = 1; //скорость мяча
double speedD = 1; //скорость защитника
double speedA = 1; //скорость нападающего
double speedG = 1; //скорость вратаря

double velXD = 0; double velYD = 0;
double velXA = 0; double velYA = 0;
double velBX = 0; double velBY=0;
char whoOwn = 'a';
const int rOwn = 10;


void DrawPlayerOrBall(HDC hdc, RECT rectClient, int x, int y, char player) {
    int height, width;
    HBRUSH hBrush;

    switch (player) {
    case 'a': {
        hBrush = CreateSolidBrush(RGB(200, 50, 100));
        break;
    }
    case 'g': {
        hBrush = CreateSolidBrush(RGB(50, 100, 100));
        break;
    }
    case 'd': {
        hBrush = CreateSolidBrush(RGB(200, 200, 100));
        break;
    }
    case 'b': {
        hBrush = CreateSolidBrush(RGB(100, 100, 100));
        break;
    }
    default: {
        hBrush = CreateSolidBrush(RGB(200, 150, 100));
        break;
    }
    }

    SelectObject(hdc, hBrush);
    Ellipse(hdc, x - rBall, y - rBall, x + rBall, y + rBall);
    DeleteObject(hBrush);
}

void DrawGoals(HDC hdc, RECT rectClient, int x, int y, int l, int t, int r, int b) {
    HBRUSH hBrush;
    hBrush = CreateSolidBrush(RGB(100, 150, 100));
    SelectObject(hdc, hBrush);
    // int left,     int top,         int right,         int bottom
    Rectangle(hdc, x - l * widthGoals, y - t * widthGoals, x + r * widthGoals, y + b * widthGoals);
    DeleteObject(hBrush);
}
//1 1 57 1
//70
//60 640

void RedrawerThread() {
    while (true) {
        InvalidateRect(hWnd, 0, 1);
        UpdateWindow(hWnd);
        Sleep(30);
    }
}

void MovingDefender(WPARAM wParam) {

    switch (wParam) {
    case VK_LEFT: /* Обрабатывает клавишу LEFT ARROW (Стрелка влево). */
    {
        velXD = -speedD;
        velYD = 0;
        break;
    }
    case VK_RIGHT:/* Обрабатывает клавишу RIGHT ARROW (Стрелка вправо). */
    {
        velXD = speedD;
        velYD = 0;
        break;
    }
    case VK_UP: /* Обрабатывает клавишу UP ARROW (Стрелка вверх). */
    {
        velXD = 0;
        velYD = -speedD;
        break;
    }
    case VK_DOWN: /* Обрабатывает клавишу DOWN ARROW (Стрелка вниз). */
    {
        velXD = 0;
        velYD = speedD;
        break;
    }
    case VK_F1: /* Обрабатывает клавишу DOWN ARROW (Стрелка вниз). */
    {
        if (speedD<=5)
            speedD += 1;
        break;
    }
    case VK_F2: /* Обрабатывает клавишу DOWN ARROW (Стрелка вниз). */
    {
        if (speedD >=1)
            speedD -= 1;

        break;
    }

    default:
        break;
    }
}
void MovingGoalkeeper() {

    if ((sqrt(pow(xG - xB, 2) + pow(yG - yB, 2))) <= 300) {
        if (xG > xB) xG -= speedA;
        else if (xG <= xB) xG += speedA;
    }

}

void MovingAttacker() {
    const double alpha = 1000;
    const double beta = 0.1;
    const double gamma = 1;
    const double delta = 0.1;
    double rdx = xD - xA;
    double rdy = yD - yA;
    double rdsquared = rdx * rdx + rdy * rdy;
    double px = -rdy;
    double py = rdx;
    double fdx = -alpha / rdsquared * rdx + delta / rdsquared * px;
    double fdy = -alpha / rdsquared * rdy + delta / rdsquared * py;
    const double xGate = WINDOW_SIZE / 2;//x координата центра ворот
    const double yGate = WINDOW_SIZE / 4;//y координата центра ворот
    double rgx = xGate - xA;
    double rgy = yGate - yA;
    double rgsquared = rgx * rgx + rgy * rgy;
    double coef = beta + gamma / rgsquared;
    double fgx = coef * rgx;
    double fgy = coef * rgy;
    double fx = fdx + fgx;
    double fy = fdy + fgy;
    double flen = sqrt(fx * fx + fy * fy);
    velXA = fx / flen * speedA;
    velYA = fy / flen * speedA;

    if (sqrt(rgsquared) < 100) {
        const double targetDist = 580;
            double targetX = xGate;
        if (xG > xGate) targetX -= targetDist;
        else targetX += targetDist;
        double kickX = targetX - xB;
        double kickY = yGate - yB;
        double kickDist = sqrt(kickX * kickX + kickY * kickY);
        velBX = kickX / kickDist * speedB;
        velBY = kickY / kickDist * speedB;
        whoOwn = 'n';
    }
}
void MovingBall() {
    if ((sqrt(pow(xD - xB, 2) + pow(yD - yB, 2))) <= rOwn && whoOwn != 'd') whoOwn = 'd';
    if ((sqrt(pow(xA - xB, 2) + pow(yA - yB, 2))) <= rOwn && whoOwn != 'a') whoOwn = 'a';
    if ((sqrt(pow(xG - xB, 2) + pow(yG - yB, 2))) <= rOwn && whoOwn != 'g') whoOwn = 'g';

    switch (whoOwn) {
    case 'd': {
        xB = xD + rBall;
        yB = yD - rBall / 2;
        break;
    }
    case 'a': {
        xB = xA + rBall;
        yB = yA - rBall / 2;
        break;
    }
    case 'g': {
        xB = xG + rBall;
        yB = yG - rBall / 2;
        break;
    }
    default:
        break;
    }

}

void Velocity() {
    while (true) {
        xD += velXD;
        yD += velYD;
        xA += velXA;
        yA += velYA;
        if (whoOwn == 'n') {
            xB += velBX; yB += velBY;
        }
        Sleep(20);
        MovingBall();
        MovingGoalkeeper();
        MovingAttacker();
    }
}
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPWSTR    lpCmdLine,
    _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: Разместите код здесь.

    MyRegisterClass(hInstance);

    // Выполнить инициализацию приложения:
    if (!InitInstance(hInstance, nCmdShow))
    {
        return FALSE;
    }

    MSG msg;
    srand(time(0));
    // Цикл основного сообщения:

    thread TH1(RedrawerThread);
    thread TH2(Velocity);
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    TH1.detach();
    TH2.detach();

    return (int)msg.wParam;
}

ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc = WndProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = NULL;
    wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = L"MyClass";
    wcex.hIconSm = NULL;

    return RegisterClassExW(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    hInst = hInstance; // Сохранить маркер экземпляра в глобальной переменной

    RECT rect;
    rect.left = 0;
    rect.right = WINDOW_SIZE;
    rect.top = 0;
    rect.bottom = WINDOW_SIZE;

    DWORD dwStyle = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
    AdjustWindowRect(&rect, dwStyle, false);


    hWnd = CreateWindowW(L"MyClass", L"Shuttle", dwStyle,
        WINDOW_SIZE / 2, 0, rect.right - rect.left, rect.bottom - rect.top, nullptr, nullptr, hInstance, nullptr);

    if (!hWnd)
    {
        return FALSE;
    }

    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);

    return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_KEYDOWN: {
        MovingDefender(wParam);
        break;

    }
    case WM_KEYUP: {
        velXD = 0;
        velYD = 0;
        break;
    }
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);
        // TODO: Добавьте сюда любой код прорисовки, использующий HDC...
        DrawGoals(hdc, ps.rcPaint, WINDOW_SIZE / 2 - 300, WINDOW_SIZE / 2 - 300, 1, 1, 1, 10);
        DrawGoals(hdc, ps.rcPaint, WINDOW_SIZE / 2 - 300 + 2 * widthGoals, WINDOW_SIZE / 2 - 300, 1, 1, 57, 1);
        DrawGoals(hdc, ps.rcPaint, WINDOW_SIZE / 2 + 300, WINDOW_SIZE / 2 - 300, 1, 1, 1, 10);
        //goalkeeper - вратарь,  defender - защитник, attack - нападающий
        DrawPlayerOrBall(hdc, ps.rcPaint, xB, yB, 'b');
        DrawPlayerOrBall(hdc, ps.rcPaint, xG, yG, 'g');
        DrawPlayerOrBall(hdc, ps.rcPaint, xD, yD, 'd');
        DrawPlayerOrBall(hdc, ps.rcPaint, xA, yA, 'a');

        EndPaint(hWnd, &ps);
    }
    break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}