classes cpp

#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);
}

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

GrinderDamage::GrinderDamage(int _X, int _Y, int _Scale, double _Angle) : Grinder(_X, _Y, _Scale, _Angle)
{

}

GrinderDamage::~GrinderDamage() {}

void GrinderDamage::Vent(HPEN penVent, HBRUSH brushVen)
{
	return;
}

//
//методы класса 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 + 680 * Scale, Y + 470 * 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;
}