Игра

// Snake V2.0.cpp: определяет точку входа для приложения.
//
 
#include "stdafx.h"
#include "Snake V2.0.h"
 
#define MAX_LOADSTRING 100
 
# include <iostream>
# include <Windows.h>
# include <vector>
# include <conio.h>
# include <time.h>
using namespace std;
 
# define scale 50
 
class Element
{
public:
    virtual ~Element() = 0{};
};
 
class Square : public Element
{
public:
    int state; // 0 - empty, 1 - wall, 2 - star
    Square(int isWall_)
    {
        state = isWall_;
    };
};
 
class Snake : public Element
{
public:
    int x;
    int y;
    Snake(int x_, int y_)
    {
        x = x_;
        y = y_;
    };
};
 
class Support
{
public:
    Element*** map;
    vector<Snake*>snake;
 
    HBRUSH* brush;
 
 
    int width, height;
    int direction; //0-left,1-right,2-up,3-down
    bool play;
    bool needStar;
 
    Support(int width_, int height_, int sX, int sY)
    {
        int i = 0;
        int j = 0;
 
        direction = 0;
 
        width = width_;
        height = height_;
 
        map = new Element**[height];
        for (i = 0; i < height; i++)
            map[i] = new Element*[width];
 
        for (i = 0; i < height; i++)
            for (j = 0; j < width; j++)
            {
                if (i == 0 || j == 0 || i == height - 1 || j == width - 1)
                    map[i][j] = new Square(1);
                else
                    map[i][j] = new Square(0);
            }
 
            snake.push_back(new Snake(sX, sY));
 
            brush = new HBRUSH[4];
 
            brush[0] = CreateSolidBrush(RGB(190, 190, 190));
            brush[1] = CreateSolidBrush(RGB(255, 245, 238));
            brush[2] = CreateSolidBrush(RGB(154, 255, 154));
            brush[3] = CreateSolidBrush(RGB(131, 111, 255));
 
            play = true;
            needStar = true;
    };
 
    bool condition(int x_, int y_)
    {
        if (dynamic_cast <Square*>(map[y_][x_])->state == 1)
            return true;
 
        for (int i = 0; i < snake.size(); i++)
        {
            if (x_ == snake.at(i)->x && y_ == snake.at(i)->y)
                return true;
        }
        return false;
    }
 
    void generateStar()
    {
        int x = 0;
        int y = 0;
 
        do
        {
            x = rand() % width;
            y = rand() % height;
        } while (condition(x, y));
 
        needStar = false;
        dynamic_cast <Square*>(map[y][x])->state = 2;
    }
 
    void gotoxy(int x, int y)
    {
        COORD pos;
        pos.X = x;
        pos.Y = y;
        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
    }
 
    bool checkNextMove()
    {
        int oX = snake.front()->x;
        int oY = snake.front()->y;
 
        switch (direction)
        {
        case 0: if (dynamic_cast<Square*>(map[oY][oX - 1])->state == 1) return 0; break;
        case 1: if (dynamic_cast<Square*>(map[oY][oX + 1])->state == 1) return 0; break;
        case 2: if (dynamic_cast<Square*>(map[oY - 1][oX])->state == 1) return 0; break;
        case 3: if (dynamic_cast<Square*>(map[oY + 1][oX])->state == 1) return 0; break;
        default: break;
        }
 
        switch (direction)
        {
        case 0: oX = oX - 1; break;
        case 1: oX = oX + 1; break;
        case 2: oY = oY - 1; break;
        case 3: oY = oY + 1; break;
        default: break;
        }
 
        for (int i = snake.size() - 1; i >= 1; i--)
        {
            if (snake.at(i)->x == oX && snake.at(i)->y == oY)
                return 0;
        }
        return 1;
    }
 
    void setDirection(WPARAM key)
    {
        switch (key)
        {
        case VK_LEFT://влево 
            direction = 0;
            break;
        case VK_RIGHT://вправо
            direction = 1;
            break;
        case VK_UP://вверх
            direction = 2;
            break;
        case VK_DOWN://вниз
            direction = 3;
            break;
        }
        //_flushall();
    }
 
    bool checkStar(int x_, int y_)
    {
        if (dynamic_cast<Square*>(map[y_][x_])->state == 2)
        {
            dynamic_cast<Square*>(map[y_][x_])->state = 0;
            needStar = true;
            return true;
        }
        else return false;
    }
 
    void move()
    {
        if (checkNextMove())
        {
            bool grow = checkStar(snake.front()->x,snake.front()->y);
 
            int tX, tY;
            tX = tY = 0;
 
            if (grow)
            {
                tX = snake.back()->x;
                tY = snake.back()->y;
            }
 
            for (int i = snake.size() - 1; i >= 1; i--)
            {
                snake.at(i)->x = snake.at(i - 1)->x;
                snake.at(i)->y = snake.at(i - 1)->y;
            }
 
            if (grow)
            {
                snake.push_back(new Snake(tX, tY));
            }
 
            switch (direction)
            {
                case 0: snake.front()->x--; break;
                case 1: snake.front()->x++; break;
                case 2: snake.front()->y--; break;
                case 3: snake.front()->y++; break;
                default: break;
            }
        }
        else
            play = false;
    }
    void draw(HDC* dc)
    {
        /////Draw map
        for (int i = 0; i < height; i++)
        {
            for (int j = 0; j < width; j++)
            {
                if (dynamic_cast<Square*>(map[i][j])->state == 1)
                {
                    SelectObject(*dc, brush[0]);
                    Rectangle(*dc, j*scale, i*scale, j*scale + scale, i*scale + scale);
                }
                else if (dynamic_cast<Square*>(map[i][j])->state == 0)
                {
                    SelectObject(*dc, brush[1]);
                    Rectangle(*dc, j*scale, i*scale, j*scale + scale, i*scale + scale);
                }
                else if (dynamic_cast<Square*>(map[i][j])->state == 2)
                {
                    SelectObject(*dc, brush[2]);
                    Rectangle(*dc, j*scale, i*scale, j*scale + scale, i*scale + scale);
                }
            }
        }
 
        SelectObject(*dc, brush[3]);
        ////Draw Snake
        for (int i = snake.size() - 1; i >= 0; i--)
        {
            Rectangle(*dc, snake.at(i)->x*scale, snake.at(i)->y*scale, snake.at(i)->x*scale + scale, snake.at(i)->y*scale + scale);
        }
    }
};
 
// Глобальные переменные:
HINSTANCE hInst;                                // текущий экземпляр
TCHAR szTitle[MAX_LOADSTRING];                  // Текст строки заголовка
TCHAR szWindowClass[MAX_LOADSTRING];            // имя класса главного окна
////////////////////////
Support* s;
///////////////////////
 
 
// Отправить объявления функций, включенных в этот модуль кода:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
 
int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPTSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
 
    // TODO: разместите код здесь.
    MSG msg;
    HACCEL hAccelTable;
 
    // Инициализация глобальных строк
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_SNAKEV20, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
    // Выполнить инициализацию приложения:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }
 
    hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_SNAKEV20));
 
    // Цикл основного сообщения:
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    return (int) msg.wParam;
}
 
 
 
//
//  ФУНКЦИЯ: MyRegisterClass()
//
//  НАЗНАЧЕНИЕ: регистрирует класс окна.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;
 
    wcex.cbSize = sizeof(WNDCLASSEX);
 
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_SNAKEV20));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_SNAKEV20);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
    return RegisterClassEx(&wcex);
}
 
//
//   ФУНКЦИЯ: InitInstance(HINSTANCE, int)
//
//   НАЗНАЧЕНИЕ: сохраняет обработку экземпляра и создает главное окно.
//
//   КОММЕНТАРИИ:
//
//        В данной функции дескриптор экземпляра сохраняется в глобальной переменной, а также
//        создается и выводится на экран главное окно программы.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;
 
   hInst = hInstance; // Сохранить дескриптор экземпляра в глобальной переменной
 
   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
 
   if (!hWnd)
   {
      return FALSE;
   }
 
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
 
   return TRUE;
}
 
//
//  ФУНКЦИЯ: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  НАЗНАЧЕНИЕ:  обрабатывает сообщения в главном окне.
//
//  WM_COMMAND  - обработка меню приложения
//  WM_PAINT    -Закрасить главное окно
//  WM_DESTROY   - ввести сообщение о выходе и вернуться.
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    PAINTSTRUCT ps;
    HDC hdc, hlpdc;
 
    switch (message)
    {
    case WM_COMMAND:
        wmId    = LOWORD(wParam);
        wmEvent = HIWORD(wParam);
        // Разобрать выбор в меню:
        switch (wmId)
        {
        case IDM_ABOUT:
            DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
            break;
        case IDM_EXIT:
            DestroyWindow(hWnd);
            break;
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
        break;
    case WM_KEYDOWN:
        s->setDirection(wParam);
        break;
    case WM_CREATE:
        srand(time(0));
 
        s = new Support(10, 10, 4, 4);
        s -> generateStar();
 
        break;
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
        
        if (s -> play)
        {
            PatBlt(hdc, 0, 0, 800, 600, WHITENESS);
 
            if (s->needStar)
                s->generateStar();
 
            s -> move();
            s -> draw(&hdc);
            
        }
        else
        {
            PostQuitMessage(0);
        }
 
        EndPaint(hWnd, &ps);
        Sleep(300);
        InvalidateRect(hWnd, 0, 0);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}
 
// Обработчик сообщений для окна "О программе".
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;
 
    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}