#include <Windows.h>
#include <windowsx.h>
#include <Shlwapi.h>
#include <atlimage.h>
#include <gdiplus.h>
#include <iostream>
#include <math.h>
using Gdiplus::Color;
using Gdiplus::Point;
using Gdiplus::Rect;
using Gdiplus::Status;
using Gdiplus::ImageLockMode;
using Gdiplus::PixelFormat;
using Gdiplus::BitmapData;
using Gdiplus::GdiplusStartupInput;
using Gdiplus::GdiplusStartupOutput;
using Gdiplus::GdiplusStartup;
using Gdiplus::GdiplusShutdown;
using Gdiplus::Image;
using Gdiplus::Bitmap;
using Gdiplus::Graphics;
using std::cout;
using std::endl;
using std::cin;
#define cxscreen GetSystemMetrics(SM_CXSCREEN)
#define cyscreen GetSystemMetrics(SM_CYSCREEN)
#define countof _countof
#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
class BGRA { public: byte B, G, R, A; BGRA(byte b = 0, byte g = 0, byte r = 0, byte a = 0) : B(b), G(g), R(r), A(a) {} };
class BGR { public: byte B, G, R; BGR(byte b = 0, byte g = 0, byte r = 0) : B(b), G(g), R(r) {} };
//class RGBA { public: byte R, G, B, A; RGBA(byte r = 0, byte g = 0, byte b = 0, byte a = 0) : R(r), G(g), B(b), A(a) {} };
//class RGB { public: byte R, G, B; RGB(byte r = 0, byte g = 0, byte b = 0) : R(r), G(g), B(b) {} };
enum
{
	colors_order_BGRA,
	colors_order_BGR,
	colors_order_RGBA,
	colors_order_RGB
};
bool game_is_paused = false;
USHORT dibsection_width = cxscreen / 2,
	   dibsection_height = cyscreen / 2,
	   StretchBlt_x_dest = 0, StretchBlt_y_dest = 0, StretchBlt_w_dest = dibsection_width, StretchBlt_h_dest = dibsection_height;
UINT dibsection_number_of_colors = dibsection_width * dibsection_height, dibsection_index = 0;
HBITMAP hDibSection = nullptr;
BGRA* dibsection_colors = nullptr;
HDC dibsection_hdc = CreateCompatibleDC(nullptr);
BITMAPINFO bitmap_info = {0};
HANDLE hMessenger = nullptr, hRenderer = nullptr;
ULONG64 fps = 0, fps_counter = 0;
char fpstr[21] = {'\0'};
byte fpstr_len = 0;
HMENU hMenu = CreateMenu(), hMenuAbout = CreatePopupMenu();
//bool is_world_infinite = true;
enum menu_item
{
	menu_item_resize_done,
	menu_item_hide_menu_and_enter_fullscreen_mode,
	menu_item_enter_exit_fullscreen_mode,
	menu_item_set_size,
	menu_item_pause_resume,
	menu_item_hide,
	menu_item_stretch_to_fill_the_entire_whole_window_s_client_keep_aspect_ratio_while_resizing,
	menu_item_about,
	menu_item_close_button_just_does_what_it_does,
	menu_item_close_button_is_either_disabled_or_hidden,
	menu_item_close_button_asks_before_it_does_what_it_does,
	menu_item_close_button_just_shows_a_message_box,
	menu_item_close_button_does_nothing,
	menu_item_maximize_box_just_does_what_it_does,
	menu_item_maximize_box_is_either_disabled_or_hidden,
	menu_item_maximize_box_asks_before_it_does_what_it_does,
	menu_item_maximize_box_just_shows_a_message_box,
	menu_item_maximize_box_does_nothing,
	menu_item_minimize_box_just_does_what_it_does,
	menu_item_minimize_box_is_either_disabled_or_hidden,
	menu_item_minimize_box_asks_before_it_does_what_it_does,
	menu_item_minimize_box_just_shows_a_message_box,
	menu_item_minimize_box_does_nothing,
	menu_item_resize_done_command_is_disabled,
	menu_item_resize_done_commands_are_hidden,
	menu_item_set_map_size,
	menu_item_map_is_immense
};
enum
{
	Gdiplus_Bitmap_constructor = 0,
	Gdiplus_Bitmap_FromFile_static_member_function = 1
};
enum
{
	Gdiplus_Image_constructor = 1,
	Gdiplus_Image_FromFile_static_member_function = 2
};
enum { CImage_Load_member_function = 1 };
enum
{
	LoadImageA_function = 1,
	LoadImageW_function = 2
};
#define if_prefered_use_first_load_image_method switch (first_load_image_with) \
{ \
	case LoadImageA_function: to_load_the_image_file_use = 0; goto load_the_image_file_now; \
	case LoadImageW_function: mbstowcs(widefilename, filename, sizeof(filename)); to_load_the_image_file_use = 1; goto load_the_image_file_now; \
}
#define if_prefered_use_second_load_image_method switch (second_load_image_with) \
{ \
	case CImage_Load_member_function: to_load_the_image_file_use = 2; goto load_the_image_file_now; \
}
#define if_prefered_use_third_load_image_method switch (third_load_image_with) \
{ \
	case Gdiplus_Image_constructor: mbstowcs(widefilename, filename, sizeof(filename)); to_load_the_image_file_use = 3; goto load_the_image_file_now; \
	case Gdiplus_Image_FromFile_static_member_function: mbstowcs(widefilename, filename, sizeof(filename)); to_load_the_image_file_use = 4; goto load_the_image_file_now; \
}
#define use_last_resort_load_image_method switch (last_resort_load_image_with) \
{ \
	default: \
	case Gdiplus_Bitmap_constructor: mbstowcs(widefilename, filename, sizeof(filename)); to_load_the_image_file_use = 5; goto load_the_image_file_now; \
	case Gdiplus_Bitmap_FromFile_static_member_function: mbstowcs(widefilename, filename, sizeof(filename)); to_load_the_image_file_use = 6; goto load_the_image_file_now; \
}
enum
{
	first_load_image_method,
	second_load_image_method,
	third_load_image_method,
	last_resort_load_image_method
};
enum sprite_id
{
	empty_id,
	block_id,
	start_id,
	end_id,
	outside_id,
	standing_right_id,
	standing_down_id,
	standing_left_id,
	standing_up_id,
	walking_right_id,
	walking_down_id,
	walking_left_id,
	walking_up_id,
	running_right_id,
	running_down_id,
	running_left_id,
	running_up_id
};
enum timer_id_event
{
	timer_id_event_every_second,
	timer_id_event_empty_animator,
	timer_id_event_outside_animator,
	timer_id_event_character_animator
};
char* names_of_images_to_load[] = { "empty", "block", "start", "end", "outside",
									"standing right", "standing down", "standing left", "standing up",
									"walking right", "walking down", "walking left", "walking up",
									"running right", "running down", "running left", "running up" };
byte numbers_of_frames[countof(names_of_images_to_load)] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
frame_index_of_empty = 0,
frame_index_of_outside = 0,
character_id = standing_up_id,
frame_index_of_character = 0;
LONG64 view_x = 0, view_y = 0, character_x = 0, character_y = 0, character_speed = 5;
double view_w = 10.0, view_h = 10.0, zoom_speed = 0.1;
ULONG64 square_w = 0, square_h = 0, camera_speed = 3, num_rows = 0, num_cols = 0;
bool IsBounded = false, *map = nullptr;
void put_remove_block_at(LONG64 x = 0, LONG64 y = 0)
{
	if (IsBounded)
		map[y * num_cols + x] = !map[y * num_cols + x];
	else
	{
	}
}
enum Direction
{
	Direction_Undefined,
	Direction_Right,
	Direction_Down,
	Direction_Left,
	Direction_Up
};
class PathSquare
{
	public:
	bool collectible;
	Direction direction;
	PathSquare(bool collectible = true, Direction direction = Direction_Undefined) : collectible(collectible), direction(direction) {};
};
PathSquare* path_squares = nullptr;
class HeapItem
{
	public:
	LONG64 x, y;
	ULONG64 distance;
	HeapItem(LONG64 x = 0, LONG64 y = 0, ULONG64 distance = 0) : x(x), y(y), distance(distance) {}
};
HeapItem* heap_of_points = nullptr;
ULONG64 HeapCount = 0, HeapCapacity = 0, whenever_heap_array_is_full_reallocate_and_grow_it_by = 2;
bool whenever_heap_array_is_full_reallocate_and_multiply_its_capacity = true, heap_points_are_stored_on_an_array = true;
bool add_point_to_heap(LONG64 x = 0, LONG64 y = 0, LONG64 tx = 1, LONG64 ty = 1)
{
	if (heap_points_are_stored_on_an_array)
	{
		if (HeapCount == HeapCapacity)
		{
			if (whenever_heap_array_is_full_reallocate_and_multiply_its_capacity)
			{
				if (whenever_heap_array_is_full_reallocate_and_grow_it_by == 1)
					return true;
				HeapItem* new_array = new HeapItem[HeapCapacity * whenever_heap_array_is_full_reallocate_and_grow_it_by];
				CopyMemory(new_array, heap_of_points, HeapCapacity * sizeof(HeapItem));
				delete[] heap_of_points;
				heap_of_points = new_array;
				HeapCapacity *= whenever_heap_array_is_full_reallocate_and_grow_it_by;
			}
			else
			{
				if (whenever_heap_array_is_full_reallocate_and_grow_it_by == 0)
					return true;
				HeapItem* new_array = new HeapItem[HeapCapacity + whenever_heap_array_is_full_reallocate_and_grow_it_by];
				CopyMemory(new_array, heap_of_points, HeapCapacity * sizeof(HeapItem));
				delete[] heap_of_points;
				heap_of_points = new_array;
				HeapCapacity += whenever_heap_array_is_full_reallocate_and_grow_it_by;
			}
		}
		heap_of_points[HeapCount].x = x;
		heap_of_points[HeapCount].y = y;
		heap_of_points[HeapCount].distance = (tx - x) * (tx - x) + (ty - y) * (ty - y);
		ULONG64 pos = HeapCount++;
		while (pos > 0 && heap_of_points[(pos - 1) / 2].distance > heap_of_points[pos].distance)
		{
			HeapItem temp = heap_of_points[pos];
			heap_of_points[pos] = heap_of_points[(pos - 1) / 2];
			heap_of_points[(pos - 1) / 2] = temp;
			pos = (pos - 1) / 2;
		}
	}
	else
	{
	}
	return false;
}
bool heap_of_points_capacity_is_always_equals_to_map_size = true,
	 empty_heap_whenever_calculation_is_done = true,
	 clear_path_on_failure = true, clear_path_after_done_moving_over_it = true, path_already_cleared = true,
	 memory_allocate_and_deallocate_path_squares_instead_of_clearing_them = false,
	 memory_deallocate_heap_of_points_whenever_emptying_it = false,
	 currently_moving_over_route = false, walk_over_route = true,
	 calculate_route_function_fails_if_heap_of_points_is_full = false,
	 calculate_route_function_fails_if_unable_to_add_points_to_heap_anymore = true;
#define memory_allocate_heap_of_points_by_size_of_map heap_of_points_capacity_is_always_equals_to_map_size
#define path_squares_is_always_allocated (memory_allocate_and_deallocate_path_squares_instead_of_clearing_them == false)
#define path_squares_is_allocated_only_when_necessary memory_allocate_and_deallocate_path_squares_instead_of_clearing_them
#define heap_of_points_is_always_allocated (memory_deallocate_heap_of_points_whenever_emptying_it == false)
#define heap_of_points_is_allocated_only_when_necessary memory_deallocate_heap_of_points_whenever_emptying_it
class HeapNode : public HeapItem
{
	public:
	HeapNode *next, *prev, *left, *right, *parent;
	HeapNode(LONG64 x = 0, LONG64 y = 0, ULONG64 distance = 0,
	HeapNode* next = nullptr, HeapNode* prev = nullptr, HeapNode* left = nullptr, HeapNode* right = nullptr, HeapNode* parent = nullptr) : HeapItem(x, y, distance),
	next(next), prev(prev), left(left), right(right), parent(parent) {}
};
bool calculate_route(LONG64 x = 0, LONG64 y = 0, LONG64 tx = 1, LONG64 ty = 1)
{
	if (IsBounded)
	{
		if (path_squares_is_allocated_only_when_necessary)
			path_squares = new PathSquare[num_rows * num_cols];
		else
		{
			if (path_already_cleared == false)
				for (UINT i = 0; i < num_rows * num_cols; i++)
				{
					path_squares[i].collectible = true;
					path_squares[i].direction = Direction_Undefined;
				}
			else
				path_already_cleared = false;
		}
		if (heap_points_are_stored_on_an_array)
		{
			if (empty_heap_whenever_calculation_is_done == false)
			{
				HeapCount = 0;
				if (heap_of_points_is_allocated_only_when_necessary)
				{
					heap_of_points = new HeapItem[heap_of_points_capacity_is_always_equals_to_map_size ? num_cols * num_rows : 1];
					HeapCapacity = heap_of_points_capacity_is_always_equals_to_map_size ? num_cols * num_rows : 1;
				}
			}
			path_squares[y * num_cols + x].collectible = false;
			while (x != tx || y != ty)
			{
				if (x > 0 && map[y * num_cols + x - 1] == false && path_squares[y * num_cols + x - 1].collectible)
				{
					if ((calculate_route_function_fails_if_heap_of_points_is_full && HeapCount == HeapCapacity) ||
						(calculate_route_function_fails_if_unable_to_add_points_to_heap_anymore && add_point_to_heap(x - 1, y, tx, ty)))
							return true;
					path_squares[y * num_cols + x - 1].collectible = false;
					path_squares[y * num_cols + x - 1].direction = Direction_Right;
				}
				if (y > 0 && map[(y - 1) * num_cols + x] == false && path_squares[(y - 1) * num_cols + x].collectible)
				{
					if ((calculate_route_function_fails_if_heap_of_points_is_full && HeapCount == HeapCapacity) ||
						(calculate_route_function_fails_if_unable_to_add_points_to_heap_anymore && add_point_to_heap(x, y - 1, tx, ty)))
							return true;
					path_squares[(y - 1) * num_cols + x].collectible = false;
					path_squares[(y - 1) * num_cols + x].direction = Direction_Down;
				}
				if (x + 1 < num_cols && map[y * num_cols + x + 1] == false && path_squares[y * num_cols + x + 1].collectible)
				{
					if ((calculate_route_function_fails_if_heap_of_points_is_full && HeapCount == HeapCapacity) ||
						(calculate_route_function_fails_if_unable_to_add_points_to_heap_anymore && add_point_to_heap(x + 1, y, tx, ty)))
							return true;
					path_squares[y * num_cols + x + 1].collectible = false;
					path_squares[y * num_cols + x + 1].direction = Direction_Left;
				}
				if (y + 1 < num_rows && map[(y + 1) * num_cols + x] == false && path_squares[(y + 1) * num_cols + x].collectible)
				{
					if ((calculate_route_function_fails_if_heap_of_points_is_full && HeapCount == HeapCapacity) ||
						(calculate_route_function_fails_if_unable_to_add_points_to_heap_anymore && add_point_to_heap(x, y + 1, tx, ty)))
							return true;
					path_squares[(y + 1) * num_cols + x].collectible = false;
					path_squares[(y + 1) * num_cols + x].direction = Direction_Up;
				}
				if (HeapCount == 0)
				{
					if (clear_path_on_failure)
					{
						for (UINT i = 0; i < num_rows * num_cols; i++)
						{
							path_squares[i].collectible = true;
							path_squares[i].direction = Direction_Undefined;
						}
						path_already_cleared = true;
					}
					return true;
				}
				//if (heap_of_points->x - x == 1)
				//	path_squares[y * num_cols + x].direction = Direction_Right;
				//else if (heap_of_points->x - x == -1)
				//	path_squares[y * num_cols + x].direction = Direction_Left;
				//else if (heap_of_points->y - y == 1)
				//	path_squares[y * num_cols + x].direction = Direction_Down;
				//else if (heap_of_points->y - y == -1)
				//	path_squares[y * num_cols + x].direction = Direction_Up;
				x = heap_of_points->x;
				y = heap_of_points->y;
				switch (path_squares[y * num_cols + x].direction)
				{
					case Direction_Left: path_squares[y * num_cols + x - 1].direction = Direction_Right; break;
					case Direction_Up: path_squares[(y - 1) * num_cols + x].direction = Direction_Down; break;
					case Direction_Right: path_squares[y * num_cols + x + 1].direction = Direction_Left; break;
					case Direction_Down: path_squares[(y + 1) * num_cols + x].direction = Direction_Up; break;
				}
				*heap_of_points = heap_of_points[--HeapCount];
				ULONG64 pos = 0;
				while (2 * pos + 1 < HeapCount)
				{
					if (2 * pos + 2 >= HeapCount || heap_of_points[2 * pos + 1].distance < heap_of_points[2 * pos + 2].distance)
					{
						if (heap_of_points[pos].distance > heap_of_points[2 * pos + 1].distance)
						{
							HeapItem temp = heap_of_points[pos];
							heap_of_points[pos] = heap_of_points[2 * pos + 1];
							heap_of_points[2 * pos + 1] = temp;
							pos = 2 * pos + 1;
						}
						else
							break;
					}
					else
					{
						if (heap_of_points[pos].distance > heap_of_points[2 * pos + 2].distance)
						{
							HeapItem temp = heap_of_points[pos];
							heap_of_points[pos] = heap_of_points[2 * pos + 2];
							heap_of_points[2 * pos + 2] = temp;
							pos = 2 * pos + 2;
						}
						else
							break;
					}
				}
			}
			path_squares[y * num_cols + x].direction = Direction_Undefined;
		}
		else
		{
			if (empty_heap_whenever_calculation_is_done == false)
			{
				HeapCount = 0;
				for (HeapNode *c = (HeapNode*)heap_of_points, *n = c ? c->next : nullptr; c; c = n, n = n ? n->next : nullptr)
					delete c;
				heap_of_points = nullptr;
			}
		}
	}
	else
	{
		if (heap_points_are_stored_on_an_array)
		{
		}
		else
		{
		}
	}
	if (empty_heap_whenever_calculation_is_done)
	{
		HeapCount = 0;
		if (heap_points_are_stored_on_an_array)
		{
			if (memory_deallocate_heap_of_points_whenever_emptying_it && heap_of_points)
			{
				delete[] heap_of_points;
				heap_of_points = nullptr;
			}
		}
		else
		{
			for (HeapNode *c = (HeapNode*)heap_of_points, *n = c ? c->next : nullptr; c; c = n, n = n ? n->next : nullptr)
				delete c;
			heap_of_points = nullptr;
		}
	}
	return false;
}
LRESULT CALLBACK WinProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
	static RECT previous_window_rect = {0};
	static bool process_wm_size_message = false;
	switch (Msg)
	{
		case WM_COMMAND:
		if (HIWORD(wParam) == 0)
		{
			switch (LOWORD(wParam))
			{
				case menu_item_resize_done:
				process_wm_size_message = false;
				if (GetWindowLongPtr(hWnd, GWL_STYLE) & WS_SIZEBOX)
				{
					ModifyMenu(hMenu, menu_item_resize_done, MF_ENABLED, menu_item_resize_done, "Resize");
					if (IsMaximized(hWnd))
						EnableMenuItem(hMenu, menu_item_resize_done, MF_DISABLED | MF_GRAYED);
					SuspendThread(hRenderer);
					SetWindowLongPtr(hWnd, GWL_STYLE, GetWindowLongPtr(hWnd, GWL_STYLE) & ~WS_SIZEBOX);
					DeleteBitmap(hDibSection);
					RECT client_rect = {0};
					GetClientRect(hWnd, &client_rect);
					char first_letter[2] = {'\0'};
					GetMenuString(hMenu, menu_item_stretch_to_fill_the_entire_whole_window_s_client_keep_aspect_ratio_while_resizing, first_letter, sizeof(first_letter), MF_BYCOMMAND);
					if (*first_letter == 'K')
					{
						dibsection_width = client_rect.right;
						dibsection_height = client_rect.bottom;
						StretchBlt_x_dest = 0;
						StretchBlt_y_dest = 0;
						StretchBlt_w_dest = dibsection_width;
						StretchBlt_h_dest = dibsection_height;
					}
					else
					{
						StretchBlt_h_dest = client_rect.bottom;
						StretchBlt_w_dest = dibsection_width * StretchBlt_h_dest / dibsection_height;
						if (StretchBlt_w_dest < client_rect.right)
						{
							StretchBlt_y_dest = 0;
							StretchBlt_x_dest = 0;//(client_rect.right - StretchBlt_w_dest) / 2;
						}
						else
						{
							StretchBlt_w_dest = client_rect.right;
							StretchBlt_h_dest = dibsection_height * StretchBlt_w_dest / dibsection_width;
							StretchBlt_x_dest = 0;
							StretchBlt_y_dest = 0;//(client_rect.bottom - StretchBlt_h_dest) / 2;
						}
						dibsection_width = StretchBlt_w_dest;
						dibsection_height = StretchBlt_h_dest;
						process_wm_size_message = false;
						RECT window_rect = { 0, 0, dibsection_width, dibsection_height };
						AdjustWindowRect(&window_rect, WS_CAPTION, (BOOL)GetMenu(hWnd));
						SetWindowPos(hWnd, nullptr, 0, 0, window_rect.right - window_rect.left, window_rect.bottom - window_rect.top, SWP_NOMOVE | SWP_NOZORDER);
						RECT new_client_rect = {0,0,0,0};
						GetClientRect(hWnd, &new_client_rect);
						if (new_client_rect.right != dibsection_width || new_client_rect.bottom != dibsection_height)
							MessageBox(hWnd, "The new dibsection does not fit to the new client area of thw window! The bottom and/or right sides of the image are clipped! This happened because the new dibsection is extremely tiny!", "Warning", MB_ICONWARNING | MB_OK);
					}
					dibsection_number_of_colors = dibsection_width * dibsection_height;
					bitmap_info.bmiHeader.biWidth = dibsection_width;
					bitmap_info.bmiHeader.biHeight = -dibsection_height;
					hDibSection = CreateDIBSection(nullptr, &bitmap_info, DIB_RGB_COLORS, (void**)&dibsection_colors, nullptr, 0);
					SelectBitmap(dibsection_hdc, hDibSection);
					dibsection_index = 0;
					ResumeThread(hRenderer);
				}
				else
				{
					SetWindowLongPtr(hWnd, GWL_STYLE, GetWindowLongPtr(hWnd, GWL_STYLE) | WS_SIZEBOX);
					ModifyMenu(hMenu, menu_item_resize_done, MF_ENABLED, menu_item_resize_done, "Done");
				}
				break;
				case menu_item_set_size:
				game_is_paused = true;
				ShowWindow(GetConsoleWindow(), SW_SHOW);
				SwitchToThisWindow(GetConsoleWindow(), true);
				if (GetWindowLongPtr(hWnd, GWL_STYLE) & WS_SIZEBOX)
				{
					RECT client_rect = {0};
					GetClientRect(hWnd, &client_rect);
					cout << "current window's client width = " << client_rect.right << endl;
					cout << "current window's client height = " << client_rect.bottom << endl;
					cout << endl;
					cout << "new window's client width = ";
					cin >> client_rect.right;
					cout << "new window's client height = ";
					cin >> client_rect.bottom;
					system("cls");
					AdjustWindowRect(&client_rect, WS_CAPTION, true);
					process_wm_size_message = false;
					SetWindowPos(hWnd, nullptr, 0, 0, client_rect.right - client_rect.left, client_rect.bottom - client_rect.top, SWP_NOMOVE | SWP_NOZORDER);
				}
				else
				{
					dibsection_index = 0;
					cout << "current dibsection width = " << dibsection_width << endl;
					cout << "current dibsection height = " << dibsection_height << endl;
					cout << endl;
					cout << "new dibsection width = ";
					cin >> dibsection_width;
					cout << "new dibsection height = ";
					cin >> dibsection_height;
					system("cls");
					dibsection_number_of_colors = dibsection_width * dibsection_height;
					DeleteBitmap(hDibSection);
					bitmap_info.bmiHeader.biWidth = dibsection_width;
					bitmap_info.bmiHeader.biHeight = -dibsection_height;
					hDibSection = CreateDIBSection(nullptr, &bitmap_info, DIB_RGB_COLORS, (void**)&dibsection_colors, nullptr, 0);
					SelectBitmap(dibsection_hdc, hDibSection);
					{
						RECT new_window_rect = { 0, 0, dibsection_width, dibsection_height }, new_client_rect = {0};
						AdjustWindowRect(&new_window_rect, WS_CAPTION, true);
						process_wm_size_message = false;
						SetWindowPos(hWnd, nullptr, 0, 0, new_window_rect.right - new_window_rect.left, new_window_rect.bottom - new_window_rect.top, SWP_NOMOVE | SWP_NOZORDER);
						GetClientRect(hWnd, &new_client_rect);
						if (new_client_rect.right != dibsection_width || new_client_rect.bottom != dibsection_height)
							MessageBox(hWnd, "The new dibsection does not fit to the new client area of the window! The bottom and/or right sides of the image are clipped! This happened because the new dibsection is extremely tiny", "Warning", MB_ICONWARNING | MB_OK);
					}
				}
				ShowWindow(GetConsoleWindow(), SW_HIDE);
				SwitchToThisWindow(hWnd, true);
				game_is_paused = false;
				ResumeThread(hRenderer);
				break;
				case menu_item_enter_exit_fullscreen_mode:
				case menu_item_hide_menu_and_enter_fullscreen_mode:
				if (GetWindowLongPtr(hWnd, GWL_STYLE) & WS_BORDER)
				{
					GetWindowRect(hWnd, &previous_window_rect);
					if (LOWORD(wParam) == menu_item_hide_menu_and_enter_fullscreen_mode)
					{
						process_wm_size_message = false;
						SetMenu(hWnd, nullptr);
					}
					else
						ModifyMenu(hMenu, menu_item_enter_exit_fullscreen_mode, MF_ENABLED, menu_item_enter_exit_fullscreen_mode, "Exit fullscreen mode");
					SetWindowLongPtr(hWnd, GWL_STYLE, (GetWindowLongPtr(hWnd, GWL_STYLE) & ~WS_BORDER) & ~WS_CAPTION);
					process_wm_size_message = true;
					SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, cxscreen, cyscreen, 0);
				}
				else
				{
					if (LOWORD(wParam) == menu_item_hide_menu_and_enter_fullscreen_mode && GetMenu(hWnd))
					{
						process_wm_size_message = true;
						SetMenu(hWnd, nullptr);
					}
					else
					{
						SetWindowLongPtr(hWnd, GWL_STYLE, (GetWindowLongPtr(hWnd, GWL_STYLE) | WS_BORDER) | WS_CAPTION);
						if (LOWORD(wParam) == menu_item_hide_menu_and_enter_fullscreen_mode)
						{
							process_wm_size_message = false;
							SetMenu(hWnd, hMenu);
						}
						else
							ModifyMenu(hMenu, menu_item_enter_exit_fullscreen_mode, MF_ENABLED, menu_item_enter_exit_fullscreen_mode, "Enter fullscreen mode");
						process_wm_size_message = true;
						SetWindowPos(hWnd, nullptr, previous_window_rect.left, previous_window_rect.top,
						previous_window_rect.right - previous_window_rect.left,
						previous_window_rect.bottom - previous_window_rect.top, 0);
					}
				}
				break;
				case menu_item_stretch_to_fill_the_entire_whole_window_s_client_keep_aspect_ratio_while_resizing:
				{
					char first_letter[2] = {'\0'};
					GetMenuString(hMenu, menu_item_stretch_to_fill_the_entire_whole_window_s_client_keep_aspect_ratio_while_resizing,
								  first_letter, sizeof(first_letter), MF_BYCOMMAND);
					if (*first_letter == 'S')
						ModifyMenu(hMenu, menu_item_stretch_to_fill_the_entire_whole_window_s_client_keep_aspect_ratio_while_resizing, MF_BYCOMMAND,
								   menu_item_stretch_to_fill_the_entire_whole_window_s_client_keep_aspect_ratio_while_resizing,
								   "Keep aspect ratio while resizing");
					else
						ModifyMenu(hMenu, menu_item_stretch_to_fill_the_entire_whole_window_s_client_keep_aspect_ratio_while_resizing, MF_BYCOMMAND,
								   menu_item_stretch_to_fill_the_entire_whole_window_s_client_keep_aspect_ratio_while_resizing,
								   "Stretch to fill the entire/whole window's client while resizing");
				}
				break;
				case menu_item_hide: process_wm_size_message = true; SetMenu(hWnd, nullptr); break;
				case menu_item_set_map_size:
				game_is_paused = true;
				ShowWindow(GetConsoleWindow(), SW_SHOW);
				SwitchToThisWindow(GetConsoleWindow(), true);
				cout << "cols = ";
				cin >> num_cols;
				cout << "rows = ";
				cin >> num_rows;
				system("cls");
				if (IsBounded)
				{
					if (map)
						delete[] map;
					if (path_squares)
						delete[] path_squares;
					map = new bool[num_cols * num_rows];
					if (currently_moving_over_route || path_squares_is_always_allocated)
						path_squares = new PathSquare[num_cols * num_rows];
					if (heap_of_points_capacity_is_always_equals_to_map_size)
					{
						if (heap_of_points)
						{
							if (heap_points_are_stored_on_an_array)
								delete[] heap_of_points;
							else for (HeapNode *c = (HeapNode*)heap_of_points, *n = c ? c->next : nullptr; c; c = n, n = n ? n->next : nullptr)
								delete c;
						}
						if (heap_points_are_stored_on_an_array)
							heap_of_points = new HeapItem[num_cols * num_rows];
					}
				}
				else
				{
					IsBounded = true;
				}
				EnableMenuItem(hMenu, menu_item_map_is_immense, MF_ENABLED);
				ShowWindow(GetConsoleWindow(), SW_HIDE);
				ResumeThread(hRenderer);
				break;
				case menu_item_map_is_immense:
				if (IsBounded)
				{
					if (map)
					{
						delete[] map;
						map = nullptr;
					}
					if (path_squares)
					{
						delete[] path_squares;
						path_squares = nullptr;
					}
				}
				else
				{
				}
				IsBounded = false;
				EnableMenuItem(hMenu, menu_item_map_is_immense, MF_DISABLED | MF_GRAYED);
				break;
			}
			DrawMenuBar(hWnd);
		}
		break;
		case WM_SIZING:
		InvalidateRect(hWnd, nullptr, true);
		{
			RECT client_rect = {0};
			GetClientRect(hWnd, &client_rect);
			char first_letter[2] = {'\0'};
			GetMenuString(hMenu, menu_item_stretch_to_fill_the_entire_whole_window_s_client_keep_aspect_ratio_while_resizing, first_letter, sizeof(first_letter), MF_BYCOMMAND);
			if (*first_letter == 'K')
			{
				StretchBlt_x_dest = 0;
				StretchBlt_y_dest = 0;
				StretchBlt_w_dest = client_rect.right;
				StretchBlt_h_dest = client_rect.bottom;
			}
			else
			{
				StretchBlt_h_dest = client_rect.bottom;
				StretchBlt_w_dest = dibsection_width * StretchBlt_h_dest / dibsection_height;
				if (StretchBlt_w_dest <= client_rect.right)
				{
					StretchBlt_y_dest = 0;
					StretchBlt_x_dest = (client_rect.right - StretchBlt_w_dest) / 2;
				}
				else
				{
					StretchBlt_w_dest = client_rect.right;
					StretchBlt_h_dest = dibsection_height * StretchBlt_w_dest / dibsection_width;
					StretchBlt_x_dest = 0;
					StretchBlt_y_dest = (client_rect.bottom - StretchBlt_h_dest) / 2;
				}
			}
		}
		break;
		case WM_SIZE:
		InvalidateRect(hWnd, nullptr, true);
		if (process_wm_size_message && (wParam == SIZE_MAXIMIZED || wParam == SIZE_RESTORED) && (GetWindowLongPtr(hWnd, GWL_STYLE) & WS_SIZEBOX) == false)
		{
			process_wm_size_message = false;
			game_is_paused = true;
			DeleteBitmap(hDibSection);
			char first_letter[2] = {'\0'};
			GetMenuString(hMenu, menu_item_stretch_to_fill_the_entire_whole_window_s_client_keep_aspect_ratio_while_resizing, first_letter, sizeof(first_letter), MF_BYCOMMAND);
			if (*first_letter == 'K')
			{
				dibsection_width = LOWORD(lParam);
				dibsection_height = HIWORD(lParam);
				StretchBlt_x_dest = 0;
				StretchBlt_y_dest = 0;
				StretchBlt_w_dest = dibsection_width;
				StretchBlt_h_dest = dibsection_height;
			}
			else
			{
				StretchBlt_h_dest = HIWORD(lParam);
				StretchBlt_w_dest = dibsection_width * StretchBlt_h_dest / dibsection_height;
				if (StretchBlt_w_dest <= LOWORD(lParam))
				{
					StretchBlt_y_dest = 0;
					StretchBlt_x_dest = (LOWORD(lParam) - StretchBlt_w_dest) / 2;
				}
				else
				{
					StretchBlt_w_dest = LOWORD(lParam);
					StretchBlt_h_dest = dibsection_height * StretchBlt_w_dest / dibsection_width;
					if (StretchBlt_h_dest <= HIWORD(lParam))
					{
						StretchBlt_x_dest = 0;
						StretchBlt_y_dest = (HIWORD(lParam) - StretchBlt_h_dest) / 2;
					}
					else
					{
						StretchBlt_x_dest = 0;
						StretchBlt_y_dest = 0;
						StretchBlt_w_dest = LOWORD(lParam);
						StretchBlt_h_dest = HIWORD(lParam);
					}
				}
				dibsection_width = StretchBlt_w_dest;
				dibsection_height = StretchBlt_h_dest;
			}
			dibsection_number_of_colors = dibsection_width * dibsection_height;
			square_w = dibsection_width / view_w;
			square_h = dibsection_height / view_h;
			bitmap_info.bmiHeader.biWidth = dibsection_width;
			bitmap_info.bmiHeader.biHeight = -dibsection_height;
			hDibSection = CreateDIBSection(nullptr, &bitmap_info, DIB_RGB_COLORS, (void**)&dibsection_colors, nullptr, 0);
			dibsection_index = 0;
			SelectBitmap(dibsection_hdc, hDibSection);
			game_is_paused = false;
			ResumeThread(hRenderer);
		}
		break;
		case WM_KEYDOWN:
		switch (wParam)
		{
			case VK_ESCAPE:
			if ((GetWindowLongPtr(hWnd, GWL_STYLE) & WS_BORDER) == false && GetMenu(hWnd) == nullptr)
			{
				char first_letter[2] = {'\0'};
				GetMenuString(hMenu, menu_item_resize_done, first_letter, sizeof(first_letter), MF_BYCOMMAND);
				if (*first_letter == 'R' && IsMaximized(hWnd))
					EnableMenuItem(hMenu, menu_item_resize_done, MF_DISABLED | MF_GRAYED);
				else
					EnableMenuItem(hMenu, menu_item_resize_done, MF_ENABLED);
				SetWindowLongPtr(hWnd, GWL_STYLE, (GetWindowLongPtr(hWnd, GWL_STYLE) | (*first_letter == 'R' ? WS_BORDER : WS_SIZEBOX)) | WS_CAPTION);
				process_wm_size_message = false;
				SetMenu(hWnd, hMenu);
				process_wm_size_message = true;
				SetWindowPos(hWnd, nullptr, previous_window_rect.left, previous_window_rect.top,
				previous_window_rect.right - previous_window_rect.left,
				previous_window_rect.bottom - previous_window_rect.top, 0);
				process_wm_size_message = true;
			}
			break;
			case VK_BACK:
			process_wm_size_message = true;
			SetMenu(hWnd, hMenu);
			DrawMenuBar(hWnd);
			{
				char first_letter[2] = {'\0'};
				GetMenuString(hMenu, menu_item_resize_done, first_letter, sizeof(first_letter), MF_BYCOMMAND);
				if (*first_letter == 'R' && (IsMaximized(hWnd) || (GetWindowLongPtr(hWnd, GWL_STYLE) & WS_BORDER) == false))
					EnableMenuItem(hMenu, menu_item_resize_done, MF_DISABLED | MF_GRAYED);
				else
					EnableMenuItem(hMenu, menu_item_resize_done, MF_ENABLED);
			}
			break;
		}
		break;
		case WM_RBUTTONDOWN:
		if (GET_X_LPARAM(lParam) >= StretchBlt_x_dest && GET_Y_LPARAM(lParam) >= StretchBlt_y_dest &&
			GET_X_LPARAM(lParam) < StretchBlt_x_dest + StretchBlt_w_dest &&
			GET_Y_LPARAM(lParam) < StretchBlt_y_dest + StretchBlt_h_dest)
		{
			USHORT x = (GET_X_LPARAM(lParam) - StretchBlt_x_dest) * dibsection_width / StretchBlt_w_dest,
				   y = (GET_Y_LPARAM(lParam) - StretchBlt_y_dest) * dibsection_height / StretchBlt_h_dest;
			put_remove_block_at((view_x + x) / square_w - (view_x + x < 0),
								(view_y + y) / square_h - (view_y + y < 0));
		}
		break;
		case WM_LBUTTONDOWN:
		if (GET_X_LPARAM(lParam) >= StretchBlt_x_dest && GET_Y_LPARAM(lParam) >= StretchBlt_y_dest &&
			GET_X_LPARAM(lParam) < StretchBlt_x_dest + StretchBlt_w_dest &&
			GET_Y_LPARAM(lParam) < StretchBlt_y_dest + StretchBlt_h_dest)
		{
			USHORT x = (GET_X_LPARAM(lParam) - StretchBlt_x_dest) * dibsection_width / StretchBlt_w_dest,
				   y = (GET_Y_LPARAM(lParam) - StretchBlt_y_dest) * dibsection_height / StretchBlt_h_dest;
			game_is_paused = true;
			Sleep(100);
			calculate_route(character_x / square_w - (character_x < 0),
							character_y / square_h - (character_y < 0),
							(view_x + x) / square_w - (view_x + x < 0),
							(view_y + y) / square_h - (view_y + y < 0));
			game_is_paused = false;
			ResumeThread(hRenderer);
		}
		break;
		case WM_MOUSEHWHEEL:
		view_w += GET_WHEEL_DELTA_WPARAM(wParam) / WHEEL_DELTA * zoom_speed;
		view_h += GET_WHEEL_DELTA_WPARAM(wParam) / WHEEL_DELTA * zoom_speed;
		square_w = dibsection_width / view_w;
		square_h = dibsection_height / view_h;
		break;
		case WM_SYSCOMMAND:
		if (wParam == SC_MAXIMIZE)
		{
			char first_letter[2] = {'\0'};
			GetMenuString(hMenu, menu_item_resize_done, first_letter, sizeof(first_letter), MF_BYCOMMAND);
			if (*first_letter == 'R')
				EnableMenuItem(hMenu, menu_item_resize_done, MF_DISABLED | MF_GRAYED);
		}
		else if (wParam == SC_RESTORE)
			EnableMenuItem(hMenu, menu_item_resize_done, MF_ENABLED);
		if (wParam == SC_MAXIMIZE || wParam == SC_RESTORE)
			process_wm_size_message = true;
		default: return DefWindowProc(hWnd, Msg, wParam, lParam);
	}
}
DWORD WINAPI Renderer(LPVOID lpParameter)
{
	HWND hWnd = (HWND)lpParameter;
	char filename[MAX_PATH] = {'\0'};
	WCHAR* widenames_of_images_to_load[] = { L"empty", L"block", L"start", L"end", L"outside",
											 L"standing right", L"standing down", L"standing left", L"standing up",
											 L"walking right", L"walking down", L"walking left", L"walking up",
											 L"running right", L"running down", L"running left", L"running up" },
	widefilename[MAX_PATH] = {L'\0'};
	BITMAP BITMAPs[countof(names_of_images_to_load)] = {{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0},{0}};
	CImage CImages[countof(names_of_images_to_load)] = {};
	BGRA* Colors[countof(names_of_images_to_load)] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
	//BGRA* BGRAs[countof(names_of_images_to_load)] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
	//BGR* BGRs[countof(names_of_images_to_load)] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
	UINT numbers_of_colors[countof(names_of_images_to_load)] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
	USHORT frames_widths[countof(names_of_images_to_load)] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
		   frames_heights[countof(names_of_images_to_load)] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
	byte bits_per_pixels[countof(names_of_images_to_load)] = { 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32 },
		 ColorsOrder[countof(names_of_images_to_load)] = { colors_order_BGRA, colors_order_BGRA, colors_order_BGRA, colors_order_BGRA, colors_order_BGRA, colors_order_BGRA, colors_order_BGRA, colors_order_BGRA, colors_order_BGRA,
														   colors_order_BGRA, colors_order_BGRA, colors_order_BGRA, colors_order_BGRA, colors_order_BGRA, colors_order_BGRA, colors_order_BGRA },
	first_load_image_with = 0/*LoadImageA_function*/,
	second_load_image_with = 0/*CImage_Load_member_function*/,
	third_load_image_with = 0/*Gdiplus_Image_constructor*/,
	last_resort_load_image_with = Gdiplus_Bitmap_constructor,
	to_load_the_image_file_use = 0,
	to_load_bmp_files_use = first_load_image_method,
	to_load_gif_files_use = second_load_image_method,
	to_load_jpeg_files_use = second_load_image_method,
	to_load_png_files_use = second_load_image_method,
	to_load_tiff_files_use = second_load_image_method,
	to_load_emf_files_use = third_load_image_method;
	//as_much_as_possible_load_images_with = LoadImageA_function;
	GetModuleFileName(nullptr, filename, sizeof(filename));
	PathRemoveFileSpec(filename);
	FILE* FilePtr = nullptr;
	PathAppend(filename, "first load image with.txt");
	if (fopen_s(&FilePtr, filename, "r") == 0)
	{
		char c = getc(FilePtr);
		if (isdigit(c))
			first_load_image_with = c - '0';
		else
		{
			char s[100] = {'\0'};
			byte i = 0;
			for (i = 0; i < sizeof(s) - 1 && (isalpha(c) || isspace(c) || c == '_'); i++)
			{
				s[i] = c;
				c = getc(FilePtr);
			}
			s[i] = '\0';
		}
		fclose(FilePtr);
	}
	PathRemoveFileSpec(filename);
	PathAppend(filename, "second load image with.txt");
	if (fopen_s(&FilePtr, filename, "r") == 0)
	{
		char c = getc(FilePtr);
		if (isdigit(c))
			second_load_image_with = c - '0';
		else
		{
			char s[100] = {'\0'};
			byte i = 0;
			for (i = 0; i < sizeof(s) - 1 && (isalpha(c) || isspace(c) || c == '_'); i++)
			{
				s[i] = c;
				c = getc(FilePtr);
			}
			s[i] = '\0';
		}
		fclose(FilePtr);
	}
	PathRemoveFileSpec(filename);
	PathAppend(filename, "third load image with.txt");
	if (fopen_s(&FilePtr, filename, "r") == 0)
	{
		char c = getc(FilePtr);
		if (isdigit(c))
			third_load_image_with = c - '0';
		else
		{
			char s[100] = {'\0'};
			byte i = 0;
			for (i = 0; i < sizeof(s) - 1 && (isalpha(c) || isspace(c) || c == '_'); i++)
			{
				s[i] = c;
				c = getc(FilePtr);
			}
			s[i] = '\0';
		}
		fclose(FilePtr);
	}
	PathRemoveFileSpec(filename);
	PathAppend(filename, "last resort load image with.txt");
	if (fopen_s(&FilePtr, filename, "r") == 0)
	{
		char c = getc(FilePtr);
		if (isdigit(c))
			last_resort_load_image_with = c - '0';
		else
		{
			char s[100] = {'\0'};
			byte i = 0;
			for (i = 0; i < sizeof(s) - 1 && (isalpha(c) || isspace(c) || c == '_'); i++)
			{
				s[i] = c;
				c = getc(FilePtr);
			}
			s[i] = '\0';
		}
		fclose(FilePtr);
	}
	PathRemoveFileSpec(filename);
	PathAppend(filename, "to load bmp files use.txt");
	if (fopen_s(&FilePtr, filename, "r") == 0)
	{
		char c = getc(FilePtr);
		if (isdigit(c))
			to_load_bmp_files_use = c - '0';
		else
		{
			char s[100] = {'\0'};
			byte i = 0;
			for (i = 0; i < sizeof(s) - 1 && (isalpha(c) || isspace(c) || c == '_'); i++)
			{
				s[i] = c;
				c = getc(FilePtr);
			}
			s[i] = '\0';
		}
		fclose(FilePtr);
	}
	PathRemoveFileSpec(filename);
	PathAppend(filename, "to load gif files use.txt");
	if (fopen_s(&FilePtr, filename, "r") == 0)
	{
		char c = getc(FilePtr);
		if (isdigit(c))
			to_load_gif_files_use = c - '0';
		else
		{
			char s[100] = {'\0'};
			byte i = 0;
			for (i = 0; i < sizeof(s) - 1 && (isalpha(c) || isspace(c) || c == '_'); i++)
			{
				s[i] = c;
				c = getc(FilePtr);
			}
			s[i] = '\0';
		}
		fclose(FilePtr);
	}
	PathRemoveFileSpec(filename);
	PathAppend(filename, "to load jpeg files use.txt");
	if (fopen_s(&FilePtr, filename, "r") == 0)
	{
		char c = getc(FilePtr);
		if (isdigit(c))
			to_load_jpeg_files_use = c - '0';
		else
		{
			char s[100] = {'\0'};
			byte i = 0;
			for (i = 0; i < sizeof(s) - 1 && (isalpha(c) || isspace(c) || c == '_'); i++)
			{
				s[i] = c;
				c = getc(FilePtr);
			}
			s[i] = '\0';
		}
		fclose(FilePtr);
	}
	PathRemoveFileSpec(filename);
	PathAppend(filename, "to load png files use.txt");
	if (fopen_s(&FilePtr, filename, "r") == 0)
	{
		char c = getc(FilePtr);
		if (isdigit(c))
			to_load_png_files_use = c - '0';
		else
		{
			char s[100] = {'\0'};
			byte i = 0;
			for (i = 0; i < sizeof(s) - 1 && (isalpha(c) || isspace(c) || c == '_'); i++)
			{
				s[i] = c;
				c = getc(FilePtr);
			}
			s[i] = '\0';
		}
		fclose(FilePtr);
	}
	PathRemoveFileSpec(filename);
	PathAppend(filename, "to load tiff files use.txt");
	if (fopen_s(&FilePtr, filename, "r") == 0)
	{
		char c = getc(FilePtr);
		if (isdigit(c))
			to_load_tiff_files_use = c - '0';
		else
		{
			char s[100] = {'\0'};
			byte i = 0;
			for (i = 0; i < sizeof(s) - 1 && (isalpha(c) || isspace(c) || c == '_'); i++)
			{
				s[i] = c;
				c = getc(FilePtr);
			}
			s[i] = '\0';
		}
		fclose(FilePtr);
	}
	PathRemoveFileSpec(filename);
	PathAppend(filename, "to load emf files use.txt");
	if (fopen_s(&FilePtr, filename, "r") == 0)
	{
		char c = getc(FilePtr);
		if (isdigit(c))
			to_load_emf_files_use = c - '0';
		else
		{
			char s[100] = {'\0'};
			byte i = 0;
			for (i = 0; i < sizeof(s) - 1 && (isalpha(c) || isspace(c) || c == '_'); i++)
			{
				s[i] = c;
				c = getc(FilePtr);
			}
			s[i] = '\0';
		}
		fclose(FilePtr);
	}
	PathRemoveFileSpec(filename);

	//PathAppend(filename, "as much as possible load images with.txt");
	//FILE* FilePtr = nullptr;
	//if (fopen_s(&FilePtr, filename, "r") == 0)
	//{
	//	char c = getc(FilePtr);
	//	if (isdigit(c))
	//		as_much_as_possible_load_images_with = c - '0';
	//	else
	//	{
	//		char input_string[100] = {'\0'};
	//		byte i = 0;
	//		for (i = 0; i < sizeof(input_string) && c != '\n' && c != '\r' && c != '\0' && c != EOF; i++)
	//			input_string[i] = c;
	//		input_string[i] = '\0';
	//		if (strcmp(input_string, "Gdiplus Bitmap constructor") == 0)
	//		as_much_as_possible_load_images_with = Gdiplus_Bitmap_constructor;
	//   else if (strcmp(input_string, "Gdiplus Bitmap FromFile static member function") == 0)
	//		as_much_as_possible_load_images_with = Gdiplus_Bitmap_FromFile_static_member_function;
	//   else if (strcmp(input_string, "Gdiplus Image constructor") == 0)
	//		as_much_as_possible_load_images_with = Gdiplus_Image_constructor;
	//   else if (strcmp(input_string, "Gdiplus Image FromFile static member function") == 0)
	//		as_much_as_possible_load_images_with = Gdiplus_Image_FromFile_static_member_function;
	//   else if (strcmp(input_string, "CImage Load member function") == 0)
	//	    as_much_as_possible_load_images_with = CImage_Load_member_function;
	//   else if (strcmp(input_string, "LoadImageW function") == 0)
	//	    as_much_as_possible_load_images_with = LoadImageW_function;
	//   else
	//	    as_much_as_possible_load_images_with = LoadImageA_function;
	//	}
	//	fclose(FilePtr);
	//}
	//PathRemoveFileSpec(filename);
	//GetModuleFileNameW(nullptr, widefilename, countof(widefilename));
	//PathRemoveFileSpecW(widefilename);

	ULONG_PTR token = 0;
	GdiplusStartupInput gsi;
	GdiplusStartup(&token, &gsi, nullptr);
	for (byte i = 0; i < countof(names_of_images_to_load); i++)
	{
		PathAppend(filename, names_of_images_to_load[i]);
		strcat_s(filename, " number of frames.txt");
		if (fopen_s(&FilePtr, filename, "r") == 0)
		{
			fscanf_s(FilePtr, "%hhu", numbers_of_frames + i);
			fclose(FilePtr);
		}
		PathRemoveFileSpec(filename);
		PathAppend(filename, names_of_images_to_load[i]);
		PathAddExtension(filename, ".bmp");
		if (PathFileExists(filename))
			switch (to_load_bmp_files_use)
			{
				default:
				case first_load_image_method: if_prefered_use_first_load_image_method
				case second_load_image_method: if_prefered_use_second_load_image_method
				case third_load_image_method: if_prefered_use_third_load_image_method
				case last_resort_load_image_method: use_last_resort_load_image_method
			}
		PathRemoveExtension(filename);
		PathAddExtension(filename, ".gif");
		if (PathFileExists(filename))
			switch (to_load_gif_files_use)
			{
				default:
				case second_load_image_method: if_prefered_use_second_load_image_method
				case third_load_image_method: if_prefered_use_third_load_image_method
				case last_resort_load_image_method: use_last_resort_load_image_method
			}
		PathRemoveExtension(filename);
		PathAddExtension(filename, ".jpg");
		if (PathFileExists(filename))
			switch (to_load_jpeg_files_use)
			{
				default:
				case second_load_image_method: if_prefered_use_second_load_image_method
				case third_load_image_method: if_prefered_use_third_load_image_method
				case last_resort_load_image_method: use_last_resort_load_image_method
			}
		PathRemoveExtension(filename);
		PathAddExtension(filename, ".jpeg");
		if (PathFileExists(filename))
			switch (to_load_jpeg_files_use)
			{
				default:
				case second_load_image_method: if_prefered_use_second_load_image_method
				case third_load_image_method: if_prefered_use_third_load_image_method
				case last_resort_load_image_method: use_last_resort_load_image_method
			}
		PathRemoveExtension(filename);
		PathAddExtension(filename, ".png");
		if (PathFileExists(filename))
			switch (to_load_png_files_use)
			{
				default:
				case second_load_image_method: if_prefered_use_second_load_image_method
				case third_load_image_method: if_prefered_use_third_load_image_method
				case last_resort_load_image_method:	use_last_resort_load_image_method
			}
		PathRemoveExtension(filename);
		PathAddExtension(filename, ".tiff");
		if (PathFileExists(filename))
			switch (to_load_tiff_files_use)
			{
				default:
				case second_load_image_method: if_prefered_use_second_load_image_method
				case third_load_image_method: if_prefered_use_third_load_image_method
				case last_resort_load_image_method: use_last_resort_load_image_method
			}
		PathRemoveExtension(filename);
		PathAddExtension(filename, ".emf");
		if (PathFileExists(filename))
			switch (to_load_emf_files_use)
			{
				default:
				case third_load_image_method: if_prefered_use_third_load_image_method
				case last_resort_load_image_method: use_last_resort_load_image_method
			}
		PathRemoveExtension(filename);
		PathAddExtension(filename, ".wmf");
		if (PathFileExists(filename))
			use_last_resort_load_image_method
		PathRemoveExtension(filename);
		PathAddExtension(filename, ".exif");
		if (PathFileExists(filename))
			use_last_resort_load_image_method
		else
		{
			char text[200] = {'\0'};
			sprintf_s(text, "There is no \"%s\" image file in module's directory! Please add one now and then click on the \"Retry\" button or \"Cancel\" button to exit now!", names_of_images_to_load[i]);
			if (MessageBox(hWnd, text, "Warning", MB_ICONWARNING | MB_RETRYCANCEL) == IDRETRY)
			{
				PathRemoveFileSpec(filename);
				i--;
				continue;
			}
			else
				ExitProcess(0);
		}
		load_the_image_file_now:
		switch (to_load_the_image_file_use)
		{
			case 0:
			case 1:
			{
				HBITMAP hBitmap = (HBITMAP)(to_load_the_image_file_use ?
								  LoadImageW(nullptr, widefilename, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE) :
								  LoadImage(nullptr, filename, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE));
				GetObject(hBitmap, sizeof(BITMAP), BITMAPs + i);
				DeleteBitmap(hBitmap);
				frames_widths[i] = BITMAPs[i].bmWidth;
				frames_heights[i] = BITMAPs[i].bmHeight / numbers_of_frames[i];
				numbers_of_colors[i] = frames_widths[i] * frames_heights[i];
				bits_per_pixels[i] = BITMAPs[i].bmBitsPixel;
				ColorsOrder[i] = BITMAPs[i].bmBitsPixel == 32 ? colors_order_BGRA : colors_order_BGR;
				Colors[i] = (BGRA*)BITMAPs[i].bmBits;
			}
			break;
			case 2:
			CImages[i].Load(filename);
			frames_widths[i] = CImages[i].GetWidth();
			frames_heights[i] = CImages[i].GetHeight() / numbers_of_frames[i];
			numbers_of_colors[i] = frames_widths[i] * frames_heights[i];
			bits_per_pixels[i] = CImages[i].GetBPP();
			ColorsOrder[i] = CImages[i].GetBPP() == 24 ? colors_order_BGR : colors_order_BGRA;
			//Bits[i] = (byte*)CImages[i].GetBits() - (numbers_of_colors[i] - frames_widths[i]) * CImages[i].GetBPP() / 8;
			{
				HBITMAP hBitmap = CImages[i];
				if (CImages[i].GetBPP() == 24)
					Colors[i] = (BGRA*)new BGR[numbers_of_colors[i] * numbers_of_frames[i]];
				else
					Colors[i] = new BGRA[numbers_of_colors[i] * numbers_of_frames[i]];
				GetBitmapBits(hBitmap, numbers_of_colors[i] * numbers_of_frames[i] * (CImages[i].GetBPP() / 8), Colors[i]);
				//GetObject(hBitmap, sizeof(BITMAP), BITMAPs + i);
				//Bits[i] = BITMAPs[i].bmBits;
				DeleteBitmap(hBitmap);
			}
			CImages[i].Destroy();
			break;
			case 3:
			{
				Image image(widefilename);
				frames_widths[i] = image.GetWidth();
				frames_heights[i] = image.GetHeight() / numbers_of_frames[i];
				numbers_of_colors[i] = frames_widths[i] * frames_heights[i];
				HBITMAP hBitmap = CreateCompatibleBitmap(nullptr, image.GetWidth(), image.GetHeight());
				HDC hDC = CreateCompatibleDC(nullptr);
				SelectBitmap(hDC, hBitmap);
				Graphics graphics(hDC);
				graphics.DrawImage(&image, 0, 0);
				DeleteDC(hDC);
				switch (image.GetPixelFormat())
				{
					case PixelFormat24bppRGB:
					bits_per_pixels[i] = 24;
					ColorsOrder[i] = colors_order_RGB;
					//Bits[i] = (BGRA*)new RGB[image.GetWidth() * image.GetHeight()];
					//GetBitmapBits(hBitmap, image.GetWidth() * image.GetHeight() * sizeof(RGB), Bits[i]);
					break;
				}
				DeleteBitmap(hBitmap);
			}
			break;
			case 4:
			{
				Image* image = Image::FromFile(widefilename);
				frames_widths[i] = image->GetWidth();
				frames_heights[i] = image->GetHeight() / numbers_of_frames[i];
				numbers_of_colors[i] = frames_widths[i] * frames_heights[i];
				HBITMAP hBitmap = CreateCompatibleBitmap(nullptr, image->GetWidth(), image->GetHeight());
				HDC hDC = CreateCompatibleDC(nullptr);
				SelectBitmap(hDC, hBitmap);
				Graphics graphics(hDC);
				graphics.DrawImage(image, 0, 0);
				switch (image->GetPixelFormat())
				{
					case PixelFormat24bppRGB:
					bits_per_pixels[i] = 24;
					ColorsOrder[i] = colors_order_RGB;
					//Bits[i] = (BGRA*)new RGB[image->GetWidth() * image->GetHeight()];
					//GetBitmapBits(hBitmap, image->GetWidth() * image->GetHeight() * sizeof(RGB), Bits[i]);
					break;
				}
				delete image;
				DeleteDC(hDC);
				//Colors[i] = new Color[frames_widths[i] * frames_heights[i] * numbers_of_frames[i]];
				//GetBitmapBits(hBitmap, frames_widths[i] * frames_heights[i] * numbers_of_frames[i] * sizeof(Color), Colors[i]);
				DeleteBitmap(hBitmap);
			}
			break;
			case 5:
			{
				Bitmap bitmap(widefilename);
				frames_widths[i] = bitmap.GetWidth() /*+ 1*/;
				frames_heights[i] = bitmap.GetHeight() / numbers_of_frames[i];
				numbers_of_colors[i] = frames_widths[i] * frames_heights[i];
				//HBITMAP hBitmap = nullptr;
				//bitmap.GetHBITMAP(0, &hBitmap);
				Colors[i] = new BGRA[numbers_of_colors[i] * numbers_of_frames[i]];
				//GetBitmapBits(hBitmap, numbers_of_colors[i] * sizeof(BGRA), Bits[i]);
				//DeleteBitmap(hBitmap);
				bits_per_pixels[i] = 32;
				ColorsOrder[i] = colors_order_BGRA;
				//switch (bitmap.GetPixelFormat())
				//{
				//	case PixelFormat24bppRGB:
				//	bits_per_pixels[i] = 24;
				//	ColorsOrder[i] = colors_order_RGB;
				//	Bits[i] = new RGB[numbers_of_colors[i] * numbers_of_frames[i]];
				//	break;
				//}
				Rect rect(0, 0, (INT)bitmap.GetWidth(), (INT)bitmap.GetHeight());
				BitmapData bd = {0};
				/*switch /*if*/ /*(*/bitmap.LockBits(&rect, ImageLockMode::ImageLockModeRead, PixelFormat32bppRGB, &bd); /*!= Status::Ok*//*)*/
				//{
				//	MessageBox(hWnd, "Gdiplus Bitmap LockBits failed!", "Error", MB_ICONERROR | MB_OK);
				//	ExitProcess(0);
				//}
				//{
				//	default:
				//	case Status::AccessDenied: MessageBox(hWnd, "Gdiplus Bitmap LockBits failed! Reason: Access Denied!", "Error", MB_ICONERROR | MB_OK); ExitProcess(0);
				//	case Status::FileNotFound: MessageBox(hWnd, "Gdiplus Bitmap LockBits failed! Reason: File Not Found!", "Error", MB_ICONERROR | MB_OK); ExitProcess(0);
				//	case Status::GdiplusNotInitialized: MessageBox(hWnd, "Gdiplus Bitmap LockBits failed! Reason: Gdiplus Not Initialized!", "Error", MB_ICONERROR | MB_OK); ExitProcess(0);
				//	case Status::GenericError: MessageBox(hWnd, "Gdiplus Bitmap LockBits failed! Reason: Generic Error!", "Error", MB_ICONERROR | MB_OK); ExitProcess(0);
				//	case Status::InsufficientBuffer: MessageBox(hWnd, "Gdiplus Bitmap LockBits failed! Reason: Insufficient Buffer!", "Error", MB_ICONERROR | MB_OK); ExitProcess(0);
				//	case Status::InvalidParameter: MessageBox(hWnd, "Gdiplus Bitmap LockBits failed! Reason: Invalid Parameter!", "Error", MB_ICONERROR | MB_OK); ExitProcess(0);
				//	case Status::Aborted: MessageBox(hWnd, "Gdiplus Bitmap LockBits failed! Reason: Aborted!", "Error", MB_ICONERROR | MB_OK); ExitProcess(0);
				//	case Status::NotImplemented: MessageBox(hWnd, "Gdiplus Bitmap LockBits failed! Reason: Not Implemented!", "Error", MB_ICONERROR | MB_OK); ExitProcess(0);
				//	case Status::ObjectBusy: MessageBox(hWnd, "Gdiplus Bitmap LockBits failed! Reason: Object Busy!", "Error", MB_ICONERROR | MB_OK); ExitProcess(0);
				//	case Status::OutOfMemory: MessageBox(hWnd, "Gdiplus Bitmap LockBits failed! Reason: Out Of Memory!", "Error", MB_ICONERROR | MB_OK); ExitProcess(0);
				//	case Status::Ok: break;
				//}
				CopyMemory(Colors[i], bd.Scan0, bd.Stride * bd.Height);
				//Bits[i] = bd.Scan0;
				/*if (*/bitmap.UnlockBits(&bd);/* != Status::Ok)*/
				//{
				//	MessageBox(hWnd, "Gdiplus Bitmap UnlockBits failed!", "Error", MB_ICONERROR | MB_OK);
				//	ExitProcess(0);
				//}
			}
			break;
			case 6:
			{
				Bitmap* bitmap = Bitmap::FromFile(widefilename);
				frames_widths[i] = bitmap->GetWidth();
				frames_heights[i] = bitmap->GetHeight() / numbers_of_frames[i];
				numbers_of_colors[i] = frames_widths[i] * frames_heights[i];
				switch (bitmap->GetPixelFormat())
				{
					case PixelFormat24bppRGB:
					bits_per_pixels[i] = 24;
					ColorsOrder[i] = colors_order_RGB;
					break;
				}
				Rect rect = { 0, 0, (INT)bitmap->GetWidth(), (INT)bitmap->GetHeight() };
				BitmapData bd;
				bitmap->LockBits(&rect, ImageLockMode::ImageLockModeRead, bitmap->GetPixelFormat(), &bd);
				Colors[i] = (BGRA*)bd.Scan0;
				bitmap->UnlockBits(&bd);
				delete bitmap;
			}
			break;
		}
		PathRemoveFileSpec(filename);
	}
	GdiplusShutdown(token);

	HDC window_hdc = GetDC(hWnd);
	RECT client_rect = {0};
	LONG64 view_x = 0, view_y = 0;
	square_w = dibsection_width / view_w;
	square_h = dibsection_height / view_h;
	//byte keys[256] = {0};
	start:
	while (IsWindow(hWnd))
	{
		if (game_is_paused)
			SuspendThread(GetCurrentThread());
		for (dibsection_index = 0; dibsection_index < dibsection_number_of_colors; dibsection_index++)
		{
			if (game_is_paused)
				goto start;
			USHORT x = dibsection_index % dibsection_width,
				   y = dibsection_index / dibsection_width;
			if (view_x + x >= character_x && view_y + y >= character_y && view_x + x <= character_x + square_w && view_y + y <= character_y + square_h &&
				Colors[character_id][frame_index_of_character * numbers_of_colors[character_id] +
				(view_y + y - character_y) * frames_heights[character_id] / square_h * frames_widths[character_id] +
				(view_x + x - character_x) * frames_widths[character_id] / square_w].A)
				dibsection_colors[dibsection_index] = Colors[character_id][frame_index_of_character * numbers_of_colors[character_id] +
				(view_y + y - character_y) * frames_heights[character_id] / square_h * frames_widths[character_id] +
				(view_x + x - character_x) * frames_widths[character_id] / square_w];
			else if (IsBounded == false || (view_x + x >= 0 && view_y + y >= 0 && view_x + x < square_w * num_cols && view_y + y < square_h * num_rows))
			{
				if (map[((view_y + y) / square_h - (view_y + y < 0)) * num_cols + (view_x + x) / square_w - (view_x + x < 0)])
				{
					USHORT sx = (view_x + x >= 0 ? (view_x + x) % square_w : square_w + (view_x + x) % square_w) * frames_widths[block_id] / square_w,
						   sy = (view_y + y >= 0 ? (view_y + y) % square_h : (view_y + y) % square_h) * frames_heights[block_id] / square_h;
					dibsection_colors[dibsection_index] = Colors[block_id][sy * frames_heights[block_id] + sx];
				}
				else
				{
					USHORT sx = (view_x + x >= 0 ? (view_x + x) % square_w : square_w + (view_x + x) % square_w) * frames_widths[empty_id] / square_w,
						   sy = (view_y + y >= 0 ? (view_y + y) % square_h : (view_y + y) % square_h) * frames_heights[empty_id] / square_h;
					dibsection_colors[dibsection_index] = Colors[empty_id][frame_index_of_empty * numbers_of_colors[empty_id] + sy * frames_widths[empty_id] + sx];
				}
			}
			else
			{
				USHORT sx = (view_x + x >= 0 ? (view_x + x) % square_w : square_w + (view_x + x) % square_w) * frames_widths[outside_id] / square_w,
					   sy = (view_y + y >= 0 ? (view_y + y) % square_h : (view_y + y) % square_h) * frames_heights[outside_id] / square_h;
				dibsection_colors[dibsection_index] = Colors[outside_id][frame_index_of_outside * numbers_of_colors[outside_id] + sy * frames_widths[outside_id] + sx];
			}
		}
		TextOut(dibsection_hdc, 10, 10, fpstr, fpstr_len);
		if (GetWindowLongPtr(hWnd, GWL_STYLE) & WS_SIZEBOX)
			StretchBlt(window_hdc, StretchBlt_x_dest, StretchBlt_y_dest, StretchBlt_w_dest, StretchBlt_h_dest, dibsection_hdc, 0, 0, dibsection_width, dibsection_height, SRCCOPY);
		else
			BitBlt(window_hdc, StretchBlt_x_dest, StretchBlt_y_dest, dibsection_width, dibsection_height, dibsection_hdc, 0, 0, SRCCOPY);
		fps_counter++;
		//GetKeyboardState(keys);
		if (GetForegroundWindow() == hWnd)
		{
			if (GetAsyncKeyState(VK_LEFT))
				view_x -= camera_speed;
			if (GetAsyncKeyState(VK_UP))
				view_y -= camera_speed;
			if (GetAsyncKeyState(VK_RIGHT))
				view_x += camera_speed;
			if (GetAsyncKeyState(VK_DOWN))
				view_y += camera_speed;
		}
		LONG64 x = character_x / square_w - (character_x < 0), y = character_y / square_h - (character_y < 0);
		switch (path_squares[y * num_cols + x].direction)
		{
			case Direction_Right: character_id = walking_right_id; character_x += character_speed; break;
			case Direction_Down: character_id = walking_down_id; character_y += character_speed; break;
			case Direction_Left: character_id = walking_left_id; character_x -= character_speed; break;
			case Direction_Up: character_id = walking_up_id; character_y -= character_speed; break;
			case Direction_Undefined:
			default: switch (character_id)
			{
				case walking_right_id: frame_index_of_character = 0; character_id = standing_right_id;
				if (IsBounded)
				{
					if (path_squares_is_allocated_only_when_necessary)
					{
						delete[] path_squares;
						path_squares = nullptr;
					}
					else if (clear_path_after_done_moving_over_it)
					{
						for (ULONG64 i = 0; i < num_cols * num_rows; i++)
						{
							path_squares[i].collectible = true;
							path_squares[i].direction = Direction_Undefined;
						}
						path_already_cleared = true;
					}
				}
				else
				{
				}
				break;
				case walking_down_id: frame_index_of_character = 0; character_id = standing_down_id;
				if (IsBounded)
				{
					if (path_squares_is_allocated_only_when_necessary)
					{
						delete[] path_squares;
						path_squares = nullptr;
					}
					else if (clear_path_after_done_moving_over_it)
					{
						for (ULONG64 i = 0; i < num_cols * num_rows; i++)
						{
							path_squares[i].collectible = true;
							path_squares[i].direction = Direction_Undefined;
						}
						path_already_cleared = true;
					}
				}
				else
				{
				}
				break;
				case walking_left_id: frame_index_of_character = 0; character_id = standing_left_id;
				if (IsBounded)
				{
					if (path_squares_is_allocated_only_when_necessary)
					{
						delete[] path_squares;
						path_squares = nullptr;
					}
					else if (clear_path_after_done_moving_over_it)
					{
						for (ULONG64 i = 0; i < num_cols * num_rows; i++)
						{
							path_squares[i].collectible = true;
							path_squares[i].direction = Direction_Undefined;
						}
						path_already_cleared = true;
					}
				}
				else
				{
				}
				break;
				case walking_up_id: frame_index_of_character = 0; character_id = standing_up_id;
				if (IsBounded)
				{
					if (path_squares_is_allocated_only_when_necessary)
					{
						delete[] path_squares;
						path_squares = nullptr;
					}
					else if (clear_path_after_done_moving_over_it)
					{
						for (ULONG64 i = 0; i < num_cols * num_rows; i++)
						{
							path_squares[i].collectible = true;
							path_squares[i].direction = Direction_Undefined;
						}
						path_already_cleared = true;
					}
				}
				else
				{
				}
				break;
			}
		}
	}
	return 0;
}
void CALLBACK every_second(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime)
{
	fps = fps_counter;
	fps_counter = 0;
	if (fps >= 60)
		SetTextColor(dibsection_hdc, 0xFFFFFF);
	else if (fps >= 45)
		SetTextColor(dibsection_hdc, 0x00FF00);
	else if (fps >= 30)
		SetTextColor(dibsection_hdc, 0x00FFFF);
	else if (fps >= 15)
		SetTextColor(dibsection_hdc, 0x0099FF);
	else
		SetTextColor(dibsection_hdc, 0x0000FF);
	sprintf_s(fpstr, "%llu", fps);
	fpstr_len = strlen(fpstr);
}
void CALLBACK empty_animator(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime) { frame_index_of_empty = (frame_index_of_empty + 1) % numbers_of_frames[empty_id]; }
void CALLBACK character_animator(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime) { frame_index_of_character = (frame_index_of_character + 1) % numbers_of_frames[character_id]; }
void CALLBACK outside_animator(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime) { frame_index_of_outside = (frame_index_of_outside + 1) % numbers_of_frames[outside_id]; }
void main()
{
	hMessenger = GetCurrentThread();
	char filename[MAX_PATH] = {'\0'};
	GetModuleFileName(nullptr, filename, sizeof(filename));
	PathRemoveFileSpec(filename);
	PathAppend(filename, "initial size.txt");
	FILE* FilePtr = nullptr;
	if (fopen_s(&FilePtr, filename, "r") == 0)
	{
		fscanf_s(FilePtr, "%u%u", &dibsection_width, &dibsection_height);
		dibsection_number_of_colors = dibsection_width * dibsection_height;
		StretchBlt_w_dest = dibsection_width;
		StretchBlt_h_dest = dibsection_height;
		fclose(FilePtr);
	}
	PathRemoveFileSpec(filename);
	PathAppend(filename, "map.txt");
	if (fopen_s(&FilePtr, filename, "r") == 0)
	{
		IsBounded = getc(FilePtr) - '0';
		if (IsBounded)
		{
			fscanf_s(FilePtr, "%u%u", &num_cols, &num_rows);
			map = new bool[num_cols * num_rows];
			if (path_squares_is_always_allocated)
				path_squares = new PathSquare[num_cols * num_rows];
			if (heap_of_points_is_always_allocated)
				heap_of_points = new HeapItem[num_cols * num_rows];
			HeapCount = 0;
			HeapCapacity = num_cols * num_rows;
			ZeroMemory(map, num_cols * num_rows);
		}
		else
		{
		}
		fclose(FilePtr);
	}
	system("Title route calculator");
	system("color 0F");
	ShowWindow(GetConsoleWindow(), SW_HIDE);
	RECT init_wnd_rect = { 0, 0, dibsection_width, dibsection_height};
	AdjustWindowRect(&init_wnd_rect, WS_CAPTION, true);
	init_wnd_rect.right -= init_wnd_rect.left;
	init_wnd_rect.bottom -= init_wnd_rect.top;
	AppendMenu(hMenu, MF_ENABLED, menu_item_resize_done, "Resize");
	AppendMenu(hMenu, MF_ENABLED, menu_item_hide_menu_and_enter_fullscreen_mode, "Hide menu and enter fullscreen mode");
	AppendMenu(hMenu, MF_ENABLED, menu_item_enter_exit_fullscreen_mode, "Enter fullscreen mode");
	AppendMenu(hMenu, MF_ENABLED, menu_item_set_size, "Set Size");
	AppendMenu(hMenu, MF_ENABLED, menu_item_pause_resume, "Pause");
	AppendMenu(hMenu, MF_ENABLED, menu_item_hide, "Hide");
	AppendMenu(hMenu, MF_ENABLED, menu_item_stretch_to_fill_the_entire_whole_window_s_client_keep_aspect_ratio_while_resizing, "Stretch to fill the entire/whole window's client while resizing");
	AppendMenu(hMenu, MF_POPUP, (UINT_PTR)hMenuAbout, "About");
	AppendMenu(hMenuAbout, MF_DISABLED | MF_GRAYED, 0, "Close button");
	AppendMenu(hMenuAbout, MF_CHECKED | MFT_RADIOCHECK, menu_item_close_button_just_does_what_it_does, "just does what it does");
	AppendMenu(hMenuAbout, MF_UNCHECKED, menu_item_close_button_is_either_disabled_or_hidden, "it is either disabled or hidden");
	AppendMenu(hMenuAbout, MF_UNCHECKED, menu_item_close_button_asks_before_it_does_what_it_does, "it asks before it does what it does");
	AppendMenu(hMenuAbout, MF_UNCHECKED, menu_item_close_button_just_shows_a_message_box, "just shows a message box");
	AppendMenu(hMenuAbout, MF_UNCHECKED, menu_item_close_button_does_nothing, "it does nothing");
	AppendMenu(hMenuAbout, MF_DISABLED | MF_GRAYED, 0, "Maximize box");
	AppendMenu(hMenuAbout, MF_CHECKED | MFT_RADIOCHECK, menu_item_maximize_box_just_does_what_it_does, "just does what it does");
	AppendMenu(hMenuAbout, MF_UNCHECKED, menu_item_maximize_box_is_either_disabled_or_hidden, "it is either disabled or hidden");
	AppendMenu(hMenuAbout, MF_UNCHECKED, menu_item_maximize_box_asks_before_it_does_what_it_does, "it asks before it does what it does");
	AppendMenu(hMenuAbout, MF_UNCHECKED, menu_item_maximize_box_just_shows_a_message_box, "just shows a message box");
	AppendMenu(hMenuAbout, MF_UNCHECKED, menu_item_maximize_box_does_nothing, "it does nothing");
	AppendMenu(hMenuAbout, MF_DISABLED | MF_GRAYED, 0, "Minimize box");
	AppendMenu(hMenuAbout, MF_CHECKED | MFT_RADIOCHECK, menu_item_maximize_box_just_does_what_it_does, "just does what it does");
	AppendMenu(hMenuAbout, MF_UNCHECKED, menu_item_minimize_box_is_either_disabled_or_hidden, "it is either disabled or hidden");
	AppendMenu(hMenuAbout, MF_UNCHECKED, menu_item_minimize_box_asks_before_it_does_what_it_does, "it asks before it does what it does");
	AppendMenu(hMenuAbout, MF_UNCHECKED, menu_item_minimize_box_just_shows_a_message_box, "just shows a message box");
	AppendMenu(hMenuAbout, MF_UNCHECKED, menu_item_minimize_box_does_nothing, "it does nothing");
	AppendMenu(hMenuAbout, MF_DISABLED | MF_GRAYED, 0, "Resize/Done");
	AppendMenu(hMenuAbout, MF_DISABLED | MF_GRAYED, 0, "Enter fullscreen mode");
	AppendMenu(hMenuAbout, MF_DISABLED | MF_GRAYED, 0, "Set Size");
	AppendMenu(hMenuAbout, MF_DISABLED | MF_GRAYED, 0, "Pause/Resume");
	AppendMenu(hMenuAbout, MF_DISABLED | MF_GRAYED, 0, "Hide");
	AppendMenu(hMenu, MF_ENABLED, menu_item_set_map_size, "set map size");
	AppendMenu(hMenu, MF_ENABLED, menu_item_map_is_immense, "map is immense");
	HWND hWnd = CreateWindow("mdiclient", "route calculator", WS_SYSMENU | WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_VISIBLE,
	(cxscreen - init_wnd_rect.right) / 2,
	(cyscreen - init_wnd_rect.bottom) / 2, init_wnd_rect.right, init_wnd_rect.bottom, nullptr, hMenu, nullptr, nullptr);
	//RECT client_rect = {0};
	//GetClientRect(hWnd, &client_rect);
	//if (client_rect.right != dibsection_width || client_rect.bottom != dibsection_height)
	//	MessageBox(hWnd, "Window client area was initialized badly!", "Warning", MB_ICONWARNING | MB_OK);
	SetWindowLongPtr(hWnd, GWL_WNDPROC, (LONG)&WinProc);
	bitmap_info.bmiHeader.biBitCount = 32;
	bitmap_info.bmiHeader.biClrImportant = 0;
	bitmap_info.bmiHeader.biClrUsed = 0;
	bitmap_info.bmiHeader.biCompression = BI_RGB;
	bitmap_info.bmiHeader.biHeight = -dibsection_height;
	bitmap_info.bmiHeader.biPlanes = 1;
	bitmap_info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bitmap_info.bmiHeader.biSizeImage = 0;
	bitmap_info.bmiHeader.biWidth = dibsection_width;
	bitmap_info.bmiHeader.biXPelsPerMeter = 0;
	bitmap_info.bmiHeader.biYPelsPerMeter = 0;
	hDibSection = CreateDIBSection(nullptr, &bitmap_info, DIB_RGB_COLORS, (void**)&dibsection_colors, nullptr, 0);
	SelectBitmap(dibsection_hdc, hDibSection);
	SetStretchBltMode(dibsection_hdc, HALFTONE);
	SetBkMode(dibsection_hdc, TRANSPARENT);
	hRenderer = CreateThread(nullptr, 0, &Renderer, hWnd, 0, nullptr);
	SetTimer(hWnd, timer_id_event_every_second, 1000, &every_second);
	SetTimer(hWnd, timer_id_event_empty_animator, 100, &empty_animator);
	SetTimer(hWnd, timer_id_event_character_animator, 100, &character_animator);
	SetTimer(hWnd, timer_id_event_outside_animator, 100, &outside_animator);
	MSG msg = {0};
	while (GetMessage(&msg, hWnd, 0, 0) > 0)
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	Sleep(1000);
	DeleteDC(dibsection_hdc);
	DeleteBitmap(hDibSection);
	KillTimer(hWnd, 0);
}