реализация кл

#include <windows.h>
#include "Classes.h"
#include <math.h>

#define KEY_DOWN(vk_code)((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define PI 3.1415926535

extern HDC hdc;

//
//методы класса Location
//
Location::Location(int _X, int _Y) //конструктор
{
    X = _X;
    Y = _Y;
}

Location::~Location() {} //деструктор

int Location::GetX() //функция получения значения Х
{
    return X;
}

int Location::GetY() //функция получения значения Y
{
    return Y;
}

void Location::SetX(int _X) //функция задания значения Х
{
    X = _X;
}
void Location::SetY(int _Y) //функция задания значения Y
{
    Y = _Y;
}

//
//методы класса Location
//

Point::Point(int _X, int _Y) : Location(_X, _Y) //конструктор
{
    isVisible = false;
}

Point::~Point() {} //деструктор

void Point::Show() //функция отображения точки
{
    isVisible = true;
    SetPixel(hdc, X, Y, RGB(0, 0, 255));
}

void Point::Hide() //функция скрытия точки
{
    isVisible = false;
    SetPixel(hdc, X, Y, RGB(255, 0, 0));
}

void Point::MoveTo(int NewX, int NewY) //функция перемещения точки по новым координатам
{
    Hide();
    X = NewX;
    Y = NewY;
    Show();
}

void Point::Drag(int Step) //функция движения точки
{
    int FigX, FigY;
    FigX = GetX();
    FigY = GetY();

    if (KEY_DOWN(VK_LEFT))
    {
        FigX -= Step;
        MoveTo(FigX, FigY);
    }
    if (KEY_DOWN(VK_RIGHT))
    {
        FigX += Step;
        MoveTo(FigX, FigY);
    }
    if (KEY_DOWN(VK_DOWN))
    {
        FigY += Step;
        MoveTo(FigX, FigY);
    }
    if (KEY_DOWN(VK_UP))
    {
        FigY -= Step;
        MoveTo(FigX, FigY);
    }
}

//
//методы класса Wheel
//

Wheel::Wheel(int _X, int _Y, int _Radius) : Point(_X, _Y) //конструктор
{
    Radius = _Radius;
    Angle = 0.0;
}

Wheel::~Wheel() {} //деструктор

void Wheel::Show() //функция отображения колеса
{
    HPEN pen;
    HBRUSH brush;

    SelectObject(hdc, GetStockObject(HOLLOW_BRUSH));
    pen = CreatePen(PS_SOLID, 3, RGB(0, 0, 0));
    SelectObject(hdc, pen);
    Ellipse(hdc, X - 50 * Radius, Y + 50 * Radius, X + 50 * Radius, Y - 50 * Radius);

    brush = CreateSolidBrush(RGB(0, 0, 0));
    SelectObject(hdc, brush);
    Ellipse(hdc, X - 5 * Radius, Y + 5 * Radius, X + 5 * Radius, Y - 5 * Radius);

    SelectObject(hdc, GetStockObject(HOLLOW_BRUSH));
    pen = CreatePen(PS_SOLID, 3, RGB(0, 0, 0));
    int line = 115 * Radius;
    int lineRadius = line / 2;

    MoveToEx(hdc, X + lineRadius * cos(Angle * PI / 180), Y + lineRadius * sin(Angle * PI / 180), NULL);
    LineTo(hdc, X - lineRadius * cos(Angle * PI / 180), Y - lineRadius * sin(Angle * PI / 180));

    MoveToEx(hdc, X + lineRadius * cos((Angle + 90) * PI / 180), Y + lineRadius * sin((Angle + 90) * PI / 180), NULL);
    LineTo(hdc, X - lineRadius * cos((Angle + 90) * PI / 180), Y - lineRadius * sin((Angle + 90) * PI / 180));

    DeleteObject(pen);
    DeleteObject(brush);
}

void Wheel::Hide() //функция скрытия колеса
{
    HBRUSH rubber = CreateSolidBrush(RGB(243, 243, 243));
    HPEN pen = CreatePen(PS_SOLID, 3, RGB(243, 243, 243));
    SelectObject(hdc, pen);
    SelectObject(hdc, rubber);
    MoveToEx(hdc, X, Y, NULL);
    int line = 115 * Radius;
    int lineRadius = line / 2;

    MoveToEx(hdc, X + lineRadius * cos(Angle * PI / 180), Y + lineRadius * sin(Angle * PI / 180), NULL);
    LineTo(hdc, X - lineRadius * cos(Angle * PI / 180), Y - lineRadius * sin(Angle * PI / 180));

    MoveToEx(hdc, X + lineRadius * cos((Angle + 90) * PI / 180), Y + lineRadius * sin((Angle + 90) * PI / 180), NULL);
    LineTo(hdc, X - lineRadius * cos((Angle + 90) * PI / 180), Y - lineRadius * sin((Angle + 90) * PI / 180));

    DeleteObject(pen);
    DeleteObject(rubber);
}

void Wheel::SetAngle(double _Angle) //функция задания угла
{
    Angle = _Angle;
}

double Wheel::GetAngle() //функция получения угла
{
    return Angle;
}

//
//методы класса Grinder
//

Grinder::Grinder(int _X, int _Y, int _Scale, double _Angle) : Point(_X, _Y), wheel(_X, _Y, _Scale) //конструктор
{
    Scale = _Scale;
    wheel.SetAngle(_Angle);
    isRotating = true;
}

Grinder::~Grinder() {} //деструктор

void Grinder::Vent(HPEN penVent, HBRUSH brushVent) //функция отображения трубы мельницы
{
    //vent
    SelectObject(hdc, penVent);
    SelectObject(hdc, brushVent);
    Rectangle(hdc, X + 440 * Scale, Y + 200 * Scale, X + 460 * Scale, Y + 100 * Scale);
}

void Grinder::Top(HBRUSH brushTop) //функция отображения крыши мельницы
{
    //top
    SelectObject(hdc, brushTop);
    POINT vertices[] = { {X + 400 * Scale, Y + 100 * Scale}, {X + 500 * Scale, Y + 200 * Scale}, {X + 300 * Scale, Y + 200 * Scale} };
    Polygon(hdc, vertices, sizeof(vertices) / sizeof(vertices[0]));
}

void Grinder::Bottom(HBRUSH brushBottom) //функция отображения основания мельницы
{
    //bottom
    SelectObject(hdc, brushBottom);
    Rectangle(hdc, X + 305 * Scale, Y + 200 * Scale, X + 495 * Scale, Y + 320 * Scale);
}


void Grinder::Window(HPEN penWindow, HBRUSH brushWindow) //функция отображения окна мельницы
{
    //window
    SelectObject(hdc, brushWindow);
    Rectangle(hdc, X + 365 * Scale, Y + 230 * Scale, X + 435 * Scale, Y + 290 * Scale);
    SelectObject(hdc, GetStockObject(HOLLOW_BRUSH));
    SelectObject(hdc, penWindow);
    MoveToEx(hdc, X + 400 * Scale, Y + 230 * Scale, NULL);
    LineTo(hdc, X + 400 * Scale, Y + 290 * Scale);
    MoveToEx(hdc, X + 365 * Scale, Y + 260 * Scale, NULL);
    LineTo(hdc, X + 435 * Scale, Y + 260 * Scale);
    MoveToEx(hdc, X, Y, NULL);
}

void Grinder::Outbuilding(HPEN penOutbuilding, HBRUSH brushOutbuilding ) //функция отображения пристройки мельницы
{
    //outbilding
    SelectObject(hdc, brushOutbuilding);
    SelectObject(hdc, penOutbuilding);
    Rectangle(hdc, X + 495 * Scale, Y + 320 * Scale, X + 550 * Scale, Y + 250 * Scale);
}

void Grinder::WheelShow() //функция отображения колеса мельницы
{
    //wheel
    wheel.SetX(X + 525 * Scale);
    wheel.SetY(Y + 300 * Scale);
    wheel.Show();
}

bool Grinder::GetRotation() //функция получения информации о вращении колеса
{
    return isRotating;
}

void Grinder::SetRotation(bool _flag) //функция установки состояния колеса(вращается или нет)
{
    isRotating = _flag;
}

void Grinder::Show() //функция отображения мельницы
{
    isVisible = true;
    HPEN penVent = CreatePen(PS_SOLID, 1, RGB(0, 255, 255));
    HBRUSH brushVent = CreateSolidBrush(RGB(255, 0, 0));
    HBRUSH brushTop = CreateSolidBrush(RGB(0, 0, 255));
    HBRUSH brushBottom = CreateSolidBrush(RGB(255, 155, 0));
    HBRUSH brushWindow = CreateSolidBrush(RGB(155, 0, 255));
    HPEN penWindow = CreatePen(PS_SOLID, 2, RGB(0, 255, 255));
    HBRUSH brushOutbuilding = CreateSolidBrush(RGB(60, 155, 30));
    HPEN penOutbuilding = CreatePen(PS_SOLID, 1, RGB(0, 255, 255));

    Vent(penVent, brushVent);
    Top(brushTop);
    Bottom(brushBottom);
    Window(penWindow, brushWindow);
    Outbuilding(penOutbuilding, brushOutbuilding);
    WheelShow();

    DeleteObject(penVent);
    DeleteObject(brushVent);
    DeleteObject(brushTop);
    DeleteObject(brushBottom);
    DeleteObject(brushWindow);
    DeleteObject(penWindow);
    DeleteObject(brushOutbuilding);
    DeleteObject(penOutbuilding);
}

void Grinder::Hide() //функция скрытия мельниц
{
    HBRUSH rubber = CreateSolidBrush(RGB(243, 243, 243));
    HPEN pen = CreatePen(PS_SOLID, 1, RGB(243, 243, 243));

    SelectObject(hdc, pen);
    SelectObject(hdc, rubber);
    MoveToEx(hdc, X, Y, NULL);
    Rectangle(hdc, X + 300, Y + 100 * Scale, X + 600 * Scale, Y + 360 * Scale);

    DeleteObject(pen);
    DeleteObject(rubber);
}

double Grinder::GetAngleWH() //функция получения информации о текущем угле колеса
{
    return wheel.GetAngle();
}

void Grinder::SetAngleWH(double _Angle) //функция задания текущего угла колеса
{
    wheel.SetAngle(_Angle);
}

//
//методы класса Rock
//

Rock::Rock(int _X, int _Y, int _Scale) : Point(_X, _Y) //конструктор
{
    X = _X;
    Y = _Y;
    Scale = _Scale;
}

Rock::~Rock() {} //деструктор

void Rock::Show() //функция отображения камня
{
    HPEN pen;
    pen = CreatePen(PS_SOLID, 1, RGB(0, 255, 155));
    SelectObject(hdc, pen);
    HBRUSH brush;
    brush = CreateSolidBrush(RGB(155, 0, 0));
    SelectObject(hdc, brush);

    Ellipse(hdc, X - 150 * Scale, Y + 340 * Scale, X - 100 * Scale, Y + 380 * Scale);

    DeleteObject(pen);
    DeleteObject(brush);
}

void Rock::Hide() //функция скрытия камня
{
    isVisible = false;
    HBRUSH rubber = CreateSolidBrush(RGB(0, 125, 255));
    HPEN pen = CreatePen(PS_SOLID, 1, RGB(0, 125, 255));
    SelectObject(hdc, pen);
    SelectObject(hdc, rubber);
    MoveToEx(hdc, X, Y, NULL);

    Ellipse(hdc, X - 150 * Scale, Y + 340 * Scale, X - 100 * Scale, Y + 380 * Scale);

    DeleteObject(pen);
    DeleteObject(rubber);
}

double Rock::GetScale() //функция получения масштаба
{
    return Scale;
}

void Rock::SetScale(double _Scale) //функция получения масштаба
{
    SetScale(_Scale);
}

//
//методы класса Wave
//

Wave::Wave(int _X, int _Y, int _Scale) : Point(_X, _Y) //конструктор
{
    X = _X;
    Y = _Y;
    Scale = _Scale;
}

Wave::~Wave() {} //деструктор

void Wave::Show() //функция отображения волны
{
    HPEN pen;
    pen = CreatePen(PS_SOLID, 1, RGB(0, 255, 255));
    SelectObject(hdc, pen);
    HBRUSH brush;
    MoveToEx(hdc, X, Y, NULL);
    brush = CreateSolidBrush(RGB(0, 0, 255));
    SelectObject(hdc, brush);
    Ellipse(hdc, X - 150 * Scale, Y + 340 * Scale, X - 100 * Scale, Y + 380 * Scale);

    DeleteObject(pen);
    DeleteObject(brush);
}

void Wave::Hide() //функция скрытия волны
{
    isVisible = false;
    HBRUSH rubber = CreateSolidBrush(RGB(0, 125, 255));
    HPEN pen = CreatePen(PS_SOLID, 1, RGB(0, 125, 255));
    SelectObject(hdc, pen);
    SelectObject(hdc, rubber);
    MoveToEx(hdc, X, Y, NULL);
    Ellipse(hdc, X - 150 * Scale, Y + 340 * Scale, X - 100 * Scale, Y + 380 * Scale);
    DeleteObject(pen);
    DeleteObject(rubber);
}

double Wave::GetScale() //функция получения масштаба
{
    return Scale;
}

void Wave::SetScale(double _Scale) //функция задания масштаба
{
    SetScale(_Scale);
}

//
//методы класса Health_mode
//

Health_mode::Health_mode(int _X, int _Y, int _Scale) : Point(_X, _Y) //конструктор
{
    X = _X;
    Y = _Y;
    Scale = _Scale;
}

Health_mode::~Health_mode() {} //деструктор

void Health_mode::Show() //функция отображения модуля здоровья
{
    HPEN pen;
    pen = CreatePen(PS_SOLID, 1, RGB(255, 0, 0));
    SelectObject(hdc, pen);
    HBRUSH brush;
    MoveToEx(hdc, X, Y, NULL);
    brush = CreateSolidBrush(RGB(0, 255, 0));
    SelectObject(hdc, brush);
    Ellipse(hdc, X - 150 * Scale, Y + 340 * Scale, X - 100 * Scale, Y + 380 * Scale);
    DeleteObject(pen);
    DeleteObject(brush);
}

void Health_mode::Hide() //функция скрытия модуля здоровья
{
    isVisible = false;
    HBRUSH rubber = CreateSolidBrush(RGB(0, 125, 255));
    HPEN pen = CreatePen(PS_SOLID, 1, RGB(0, 125, 255));
    SelectObject(hdc, pen);
    SelectObject(hdc, rubber);
    MoveToEx(hdc, X, Y, NULL);
    Ellipse(hdc, X - 150 * Scale, Y + 340 * Scale, X - 100 * Scale, Y + 380 * Scale);
    DeleteObject(pen);
    DeleteObject(rubber);

}

double Health_mode::GetScale() //функция получения масштаба
{
    return Scale;
}

void Health_mode::SetScale(double _Scale) //функция задания масштаба
{
    SetScale(_Scale);
}

//
//методы класса Health_mode
//

River::River(int _X, int _Y, int _Scale) : Point(_X, _Y) //конструктор
{
    X = _X;
    Y = _Y;
    Scale = _Scale;
}

River::~River() {} //деструктор

void River::Show() //функция отображения реки
{
    HBRUSH brush = CreateSolidBrush(RGB(0, 125, 255));
    SelectObject(hdc, brush);
    Rectangle(hdc, X - 290 * Scale, Y + 320 * Scale, X + 660 * Scale, Y + 450 * Scale);
    DeleteObject(brush);
}

void River::Hide() //функция скрытия реки
{
    HBRUSH brush = CreateSolidBrush(RGB(243, 243, 243));
    HPEN pen = CreatePen(PS_SOLID, 3, RGB(243, 243, 243));
    SelectObject(hdc, pen);
    SelectObject(hdc, brush);
    Rectangle(hdc, X - 290 * Scale, Y + 320 * Scale, X + 660 * Scale, Y + 450 * Scale);
    DeleteObject(pen);
    DeleteObject(brush);
}

//
//методы класса Catcher
//

Catcher::Catcher(int _X, int _Y, int _Scale) : Point(_X, _Y)
{
    X = _X;
    Y = _Y;
    Scale = _Scale;
}

Catcher::~Catcher()
{
}

void Catcher::Show() //функция отображения ловца
{
    HPEN pen = CreatePen(PS_SOLID, 2, RGB(0, 0, 0));
    HBRUSH brush = CreateSolidBrush(RGB(215, 225, 0));
    SelectObject(hdc, pen);
    SelectObject(hdc, brush);
    Rectangle(hdc, X - 20 * Scale, Y + 330 * Scale, X + 20 * Scale, Y + 390 * Scale);
    DeleteObject(pen);
    DeleteObject(brush);
}

void Catcher::Hide() //функция скрытия ловца
{
    HBRUSH brush = CreateSolidBrush(RGB(243, 243, 243));
    HPEN pen = CreatePen(PS_SOLID, 3, RGB(243, 243, 243));
    SelectObject(hdc, pen);
    SelectObject(hdc, brush);
    Rectangle(hdc, X - 20 * Scale, Y + 330 * Scale, X + 20 * Scale, Y + 390 * Scale);
    DeleteObject(pen);
    DeleteObject(brush);
}

int Catcher::GetScale() //функция получения масштаба
{
    return Scale;
}

void Catcher::SetScale(int _Scale) //функция задания масштаба
{
    Scale = _Scale;
}