Оцените тетрис - C++ - Ответ 6512871

Test_Wi32.cpp : Defines the entry point for the application.
//
#include "stdafx.h"
#include "Test_Wi32.h"
 
#define MAX_LOADSTRING 100
 
// Global Variables:
HINSTANCE hInst;                                // current instance
TCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name
 
#define timer_ms 300
 
typedef struct{
    int r;
    int g;
    int b;
} my_color;
typedef struct{
    int type;
    int orientation;
    my_color color;
    int rf[4];
    int cf[4];
    RECT maxsize;
} tetris_figure;
 
int A_rc_width;
int A_rows;
int A_columns;
int Af[100][100];
my_color Ac[100][100];
 
int TF [7] [4] [2] [4];
tetris_figure cur_f, sle_f;
RECT invalidRect;
int nTimerID, nTimerSec;
bool runTimer, runTimerSec;
bool cur_f_exist;
my_color gametime;
int score;
HWND hwndnextf, hwndSta1, hwndSta2;
 
// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    GameOver(HWND, UINT, WPARAM, LPARAM);
 
void MyDraw(HWND hwnd);
void CALLBACK TimerProc(HWND hwnd, UINT msg, UINT idTimer, DWORD dwTime);
void CALLBACK TimerSecProc(HWND hwnd, UINT msg, UINT idTimer, DWORD dwTime);
LRESULT CALLBACK    PanelProc(HWND, UINT, WPARAM, LPARAM);
void New_figure(void);
void Move_figure(HWND hWnd, char action);
void my_InvalidateWndRect(HWND hWnd, RECT maxsize);
RECT my_maxsize(void);
void StartPause(HWND hWnd);
void Stop(HWND hWnd);
void SettingsDialogBox(HWND hWnd);
LRESULT CALLBACK SettingsDialogProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam );
void RegisterSettingsDialogClass(HWND hWnd);
void SetGameParameters(HWND hWnd);
 
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
 
    // TODO: Place code here.
    MSG msg;
    HACCEL hAccelTable;
 
    // Initialize global strings
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_TEST_WI32, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
    // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow)) return FALSE;
 
    hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_TEST_WI32));
 
    // Main message loop:
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    return (int) msg.wParam;
}
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_TEST_WI32));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_TEST_WI32);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
    return RegisterClassEx(&wcex);
}
 
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    HWND hWnd;
    hInst = hInstance; // Store instance handle in our global variable
 
    WNDCLASSW wc = {0};
    wc.style = 0; //CS_HREDRAW | CS_VREDRAW;
    wc.lpszClassName = L"MainGameWindowClass";
    wc.hInstance     = hInstance;
    wc.hbrBackground = GetSysColorBrush(COLOR_3DFACE);
    wc.lpfnWndProc   = WndProc;
    wc.hCursor       = LoadCursor(0, IDC_ARROW);
    RegisterClassW(&wc);
    hWnd = CreateWindowW(wc.lpszClassName, L"Тетрис",
            WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU  | WS_MINIMIZEBOX,
            10, 10, 10, 10, NULL, NULL, hInstance, NULL);
    if (!hWnd) return FALSE;
 
    int TF_ [7] [4] [2] [4] = {
        {{{0,-1,-1,0},{0,0,-1,-1}},{{0,-1,-1,0},{0,0,-1,-1}},{{0,-1,-1,0},{0,0,-1,-1}},{{0,-1,-1,0},{0,0,-1,-1}}},
        {{{0,-2,-1,1},{0,0,0,0}},{{0,0,0,0},{0,-2,-1,1}},{{0,-2,-1,1},{0,0,0,0}},{{0,0,0,0},{0,-2,-1,1}}},
        {{{0,-1,0,1},{0,-1,-1,0}},{{0,1,1,0},{0,-1,0,1}},{{0,-1,0,1},{0,-1,-1,0}},{{0,1,1,0},{0,-1,0,1}}},
        {{{0,-1,0,1},{0,0,-1,-1}},{{0,0,1,1},{0,-1,0,1}},{{0,-1,0,1},{0,0,-1,-1}},{{0,0,1,1},{0,-1,0,1}}},
        {{{0,-1,-1,1},{0,-1,0,0}},{{0,1,0,0},{0,-1,-1,1}},{{0,-1,1,1},{0,0,0,1}},{{0,0,0,-1},{0,-1,1,1}}},
        {{{0,-1,1,1},{0,0,0,-1}},{{0,0,0,1},{0,-1,1,1}},{{0,-1,-1,1},{0,0,1,0}},{{0,-1,0,0},{0,-1,-1,1}}},
        {{{0,-1,0,1},{0,0,-1,0}},{{0,0,0,1},{0,-1,1,0}},{{0,-1,0,1},{0,0,1,0}},{{0,-1,0,0},{0,0,-1,1}}}
    };
    for (int i=0; i<7; i++) {
        for (int j=0; j<4; j++) {
        for (int k=0; k<2; k++) {
        for (int l=0; l<4; l++) {
            TF[i][j][k][l] = TF_[i][j][k][l];
        }
        }
        }
    }
    A_rc_width = 15;
    A_rows = 30;
    A_columns = 20;
    SetGameParameters(hWnd); 
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
 
    return TRUE;
}
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    WNDCLASSW rwc = {0};
    HBRUSH hbrush = CreateSolidBrush(RGB(255, 255, 255));
 
    switch (message)
    {
    case WM_CREATE:
        RegisterSettingsDialogClass(hWnd);
 
        HMENU hMenubar;
        HMENU hMenu;
        hMenubar = CreateMenu();
        hMenu = CreateMenu();
        AppendMenuW(hMenu, MF_STRING, 1, L"&Установки");
        AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);
        AppendMenuW(hMenu, MF_STRING, 2, L"&Выход");
        AppendMenuW(hMenubar, MF_POPUP, (UINT_PTR)hMenu, L"&Опции");
        SetMenu(hWnd, hMenubar);
 
        rwc.lpszClassName = L"WhitePanelClass";
        rwc.hbrBackground = hbrush;
        rwc.lpfnWndProc   = PanelProc;
        rwc.hCursor       = LoadCursor(0, IDC_ARROW);
        RegisterClassW(&rwc);
        hwndnextf = CreateWindowW(L"WhitePanelClass", NULL, 
            WS_CHILD | WS_VISIBLE,
            0, 0, 0, 0, 
            hWnd, (HMENU) NULL, NULL, NULL);
 
        hwndSta1 = CreateWindowW(L"static", L"00:00",
            WS_CHILD | WS_VISIBLE | WS_BORDER,
            0, 0, 0, 0, 
            hWnd, (HMENU) NULL, NULL, NULL);
 
        hwndSta2 = CreateWindowW(L"static", L"0",
            WS_CHILD | WS_VISIBLE | WS_BORDER,
            0, 0, 0, 0, 
            hWnd, (HMENU) NULL, NULL, NULL);
 
        SetGameParameters(hWnd);
 
        break;
    case WM_COMMAND:
        wmId    = LOWORD(wParam);
        wmEvent = HIWORD(wParam);
        switch (wmId)
        {
        case 1:
            SettingsDialogBox(hWnd);
            break;
        case 3:
            SendMessage(hWnd, WM_CLOSE, 0, 0);
            break;
        }
        break;
    //case WM_ACTIVATE:
    //  RECT ri;
    //  ri.left = 0;
    //  ri.top = 0;
    //  ri.right = A_columns-1;
    //  ri.bottom = A_rows-1;
    //  my_InvalidateWndRect(hWnd, ri);
    //  UpdateWindow(hWnd);
    //  break;
    case WM_KEYDOWN:
        switch (wParam) {
        case VK_LEFT:
            Move_figure(hWnd, 'l');
            break;
        case VK_RIGHT:
            Move_figure(hWnd, 'r');
            break;
        case VK_DOWN:
            Move_figure(hWnd, 'D');
            if (!runTimer) {
                SetTimer(hWnd, nTimerID, timer_ms, (TIMERPROC)TimerProc);
                runTimer = TRUE;
            }
            break;
        case VK_UP:
        case VK_SPACE:
            StartPause(hWnd);
            break;
        //case VK_HOME:
        //case VK_END:
        //case VK_INSERT:
        case VK_DELETE:
            Stop(hWnd);
            break;
        //case VK_F2:
        //default:
        }
        break;
    case WM_LBUTTONDOWN:
        Move_figure(hWnd, 'L');
        break;
    case WM_RBUTTONDOWN:
        Move_figure(hWnd, 'R');
        break;
    case WM_PAINT:
        MyDraw(hWnd);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    }
    return DefWindowProc(hWnd, message, wParam, lParam);
}
LRESULT CALLBACK PanelProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    PAINTSTRUCT ps;
    HDC hdc;
    HBRUSH hBrush;
    HGDIOBJ holdBrush;
    switch(msg)  
    {
    case WM_PAINT:
        if (runTimerSec) {
            hdc = BeginPaint(hWnd, &ps);
            Rectangle(hdc, 0, 0, A_rc_width*4+1, A_rc_width*4+1);
            hBrush = CreateSolidBrush(RGB(sle_f.color.r, sle_f.color.g, sle_f.color.b));
            holdBrush = SelectObject(hdc, hBrush);
            for (int i=0; i<4; i++) {
                Rectangle(hdc, 1+A_rc_width*sle_f.cf[i], 1+A_rc_width*(sle_f.rf[i]), A_rc_width*(sle_f.cf[i]+1), A_rc_width*(sle_f.rf[i]+1));
            }
            SelectObject(hdc, holdBrush);
            DeleteObject(hBrush);
            EndPaint(hWnd, &ps);
        }
        break;
    }
    return DefWindowProc(hWnd, msg, wParam, lParam);
}
 
void CALLBACK TimerProc(HWND hWnd, UINT msg, UINT idTimer, DWORD dwTime)
{   
    // проверяем, надо ли создавать новую фигуру
    bool next_f = (cur_f.maxsize.bottom >= (A_rows-1));
    if (!next_f) for(int i=0; i<4; i++) if (Af[cur_f.rf[i]+1][cur_f.cf[i]]) {next_f = TRUE; break;}
 
    if (next_f) {
        // запоминаем фигуру в таблицу
        for(int i=0; i<4; i++) {
            Af[cur_f.rf[i]][cur_f.cf[i]] = 1;
            Ac[cur_f.rf[i]][cur_f.cf[i]] = cur_f.color;
        }
        // удаляем полностью заполненные строки таблицы
        bool refreshAllTable = FALSE;
        int rows2del[4], ind = 0;
        for(int i=cur_f.maxsize.top; i<=cur_f.maxsize.bottom; i++) {
            bool delrow = TRUE;
            for (int j=0; j<A_columns; j++) {
                if (!Af[i][j]) {delrow = FALSE; break;}
            }
            if (delrow) rows2del[ind++] = i;
        }
        if (ind) {
            score += ind;
            wchar_t buf[20];
            wsprintfW(buf, L"%lu", score);
            SetWindowTextW(hwndSta2, buf);
 
            refreshAllTable = TRUE;
            ind--;
            int delta = 0;
            for(int i=rows2del[ind]; i>=0; i--) {
                int rowrepl = i - delta;
                while ((rows2del[ind] == rowrepl) && (ind >= 0)) {
                    delta++;
                    rowrepl--;
                    ind--;
                }
                for (int j=0; j<A_columns; j++) Af[i][j] = (rowrepl>=0) ? Af[rowrepl][j] : 0;
            }
        }
        // создаем новую фигуру
        //if (New_figure(&sle_f, A_columns/2)) {
 
        cur_f = sle_f;
        cur_f_exist = TRUE;
 
        bool err = FALSE;
        for(int i=0; i<4; i++) {
            cur_f.cf[i] += A_columns/2;
            if (Af[cur_f.rf[i]][cur_f.cf[i]]) {err = TRUE; break;}
        }
        cur_f.maxsize = my_maxsize();
 
        if (!err) {
            New_figure();
            RECT ri = cur_f.maxsize;
            if (refreshAllTable) {
                ri.left = 0;
                ri.top = 0;
                ri.right = A_columns-1;
                ri.bottom = A_rows-1;
            }
            my_InvalidateWndRect(hWnd, ri);
            InvalidateRgn(hwndnextf, NULL, TRUE);
            SendMessage(hwndnextf, WM_PAINT, 0, 0);
        } else {
            KillTimer(hWnd, nTimerID);
            //DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, GameOver);
        }
    } else {
        // двигаем текущую фигуру вниз
        for(int i=0; i<4; i++) cur_f.rf[i]++;
        cur_f.maxsize.top++;
        cur_f.maxsize.bottom++;
 
        RECT ri = cur_f.maxsize;
        ri.top--;
        my_InvalidateWndRect(hWnd, ri);
    }
    //UpdateWindow(hWnd);
    SendMessage(hWnd, WM_PAINT, 0, 0);
}
 
void CALLBACK TimerSecProc(HWND hWnd, UINT msg, UINT idTimer, DWORD dwTime)
{
    gametime.b++;
    if (gametime.b>=60) {gametime.g++; gametime.b = 0;}
    if (gametime.g>=60) {gametime.r++; gametime.g = 0;}
    wchar_t buf[20];
    if (gametime.r) wsprintfW(buf, L"%02u:%02u:%02u", gametime.r, gametime.g, gametime.b);
    else            wsprintfW(buf, L"%02u : %02u", gametime.g, gametime.b);
    SetWindowTextW(hWnd, buf);
}
 
void MyDraw(HWND hwnd)
{
    PAINTSTRUCT ps;
    //RECT r;
    //GetClientRect(hwnd, &r);
    HDC hdc = BeginPaint(hwnd, &ps);
    Rectangle(hdc, 0, 0, A_rc_width*A_columns+1, A_rc_width*A_rows+1);
    
    // рисуем только нужные ячейки матрицы
    for (int i=invalidRect.top; i<=invalidRect.bottom; i++) {
        for (int j=invalidRect.left; j<=invalidRect.right; j++) {
            if (!Af[i][j]) continue;
 
            my_color color = Ac[i][j];
            HBRUSH hBrush = CreateSolidBrush(RGB(color.r, color.g, color.b));
            HGDIOBJ holdBrush = SelectObject(hdc, hBrush);
            Rectangle(hdc, 1+A_rc_width*(j), 1+A_rc_width*(i), A_rc_width*(j+1), A_rc_width*(i+1));
            SelectObject(hdc, holdBrush);
            DeleteObject(hBrush);
        }
    }
    // рисуем фигуру
    if (cur_f_exist) {
        HBRUSH hBrush = CreateSolidBrush(RGB(cur_f.color.r, cur_f.color.g, cur_f.color.b));
        HGDIOBJ holdBrush = SelectObject(hdc, hBrush);
        for (int i=0; i<4; i++) {
            Rectangle(hdc, 1+A_rc_width*cur_f.cf[i], 1+A_rc_width*(cur_f.rf[i]), A_rc_width*(cur_f.cf[i]+1), A_rc_width*(cur_f.rf[i]+1));
        }
        SelectObject(hdc, holdBrush);
        DeleteObject(hBrush);
    }
    EndPaint(hwnd, &ps);
}
void Move_figure(HWND hWnd, char action)
{
    tetris_figure tmp_f = cur_f;
 
    switch (action) {
    case 'l':
        for (int i=0; i<4; i++) cur_f.cf[i]--;
        break;
    case 'r':
        for (int i=0; i<4; i++) cur_f.cf[i]++;
        break;
    case 'L':
        cur_f.orientation = cur_f.orientation++;
        if (cur_f.orientation >= 4) cur_f.orientation = 0;
        for (int i=0; i<4; i++) {
            cur_f.rf[i] = cur_f.rf[0] - TF[cur_f.type][cur_f.orientation][1][i];
            cur_f.cf[i] = cur_f.cf[0] + TF[cur_f.type][cur_f.orientation][0][i];
        }
        break;
    case 'R':
        cur_f.orientation = cur_f.orientation--;
        if (cur_f.orientation < 0) cur_f.orientation = 3;
        for (int i=0; i<4; i++) {
            cur_f.rf[i] = cur_f.rf[0] - TF[cur_f.type][cur_f.orientation][1][i];
            cur_f.cf[i] = cur_f.cf[0] + TF[cur_f.type][cur_f.orientation][0][i];
        }
        break;
    case 'D':
        for (int j=0; j<A_rows; j++) {
            bool stop = FALSE;
            for (int i=0; i<4; i++) {
                if (((cur_f.rf[i] == (A_rows-1))) || (Af[cur_f.rf[i]+1][cur_f.cf[i]])) {
                    stop = TRUE;
                    break;
                }
            }
            if (stop) break;
            for (int i=0; i<4; i++) cur_f.rf[i]++;
        }
        break;
    default:
        return;
    }
    bool err = FALSE;
    for (int i=0; i<4; i++) {
        if ((cur_f.rf[i] < 0) || (cur_f.rf[i] >= A_rows)) {err = TRUE; break;}
        if ((cur_f.cf[i] < 0) || (cur_f.cf[i] >= A_columns)) {err = TRUE; break;}
        if (Af[cur_f.rf[i]][cur_f.cf[i]]) {err = TRUE; break;}
    }
    if (err) {cur_f = tmp_f; return;}
 
    cur_f.maxsize = my_maxsize();
 
    //InvalidateRgn(hWnd, NULL, TRUE);//FALSE);
    RECT ri = cur_f.maxsize;
    ri.left = (ri.left < tmp_f.maxsize.left) ? ri.left : tmp_f.maxsize.left;
    ri.top = (ri.top < tmp_f.maxsize.top) ? ri.top : tmp_f.maxsize.top;
    ri.right = (ri.right > tmp_f.maxsize.right) ? ri.right : tmp_f.maxsize.right;
    ri.bottom = (ri.bottom > tmp_f.maxsize.bottom) ? ri.bottom : tmp_f.maxsize.bottom;
    my_InvalidateWndRect(hWnd, ri);
    SendMessage(hWnd, WM_PAINT, 0, 0);
}
void my_InvalidateWndRect(HWND hWnd, RECT maxsize)
{
    RECT ri;
    ri.left = maxsize.left*A_rc_width;
    ri.top = maxsize.top*A_rc_width;
    ri.right = (maxsize.right+1)*A_rc_width;
    ri.bottom = (maxsize.bottom+1)*A_rc_width;
    InvalidateRect(hWnd, &ri, TRUE);
 
    invalidRect = maxsize;
}
void New_figure()
{
    sle_f.type = rand()%7;
    sle_f.orientation = rand()%4;
    for (int i=0; i<4; i++) {
        sle_f.rf[i] = 1 - TF[sle_f.type][sle_f.orientation][1][i];
        sle_f.cf[i] = 2 + TF[sle_f.type][sle_f.orientation][0][i];
    }
    my_color c;
    c.r = rand()%256;
    c.g = rand()%256;
    c.b = rand()%256;
    sle_f.color = c;
    sle_f.maxsize = my_maxsize();
}
RECT my_maxsize()
{
    RECT maxsize;
    maxsize.left = cur_f.cf[0];
    maxsize.top = cur_f.rf[0];
    maxsize.right = cur_f.cf[0];
    maxsize.bottom = cur_f.rf[0];
    for(int i=1; i<4; i++) {
        if (cur_f.rf[i] < maxsize.top) maxsize.top = cur_f.rf[i];
        if (cur_f.rf[i] > maxsize.bottom) maxsize.bottom = cur_f.rf[i];
        if (cur_f.cf[i] < maxsize.left) maxsize.left = cur_f.cf[i];
        if (cur_f.cf[i] > maxsize.right) maxsize.right = cur_f.cf[i];
    }
    return maxsize;
}
void StartPause(HWND hWnd)
{
    if (runTimerSec) { // пауза/пуск
        if (runTimer) {
            KillTimer(hWnd, nTimerID);
            runTimer = FALSE;
        } else {
            SetTimer(hWnd, nTimerID, timer_ms, (TIMERPROC)TimerProc);
            runTimer = TRUE;
        }
    } else { // новый старт
        FILETIME ft;
        GetSystemTimeAsFileTime(&ft);
        srand(ft.dwLowDateTime);
 
        gametime.r = 0;
        gametime.g = 0;
        gametime.b = 0;
        for (int i=0; i<A_rows; i++) {
            for (int j=0; j<A_columns; j++) Af[i][j] = 0;
        }
        New_figure();
        cur_f = sle_f;
        cur_f_exist = TRUE;
        New_figure();
 
        for(int i=0; i<4; i++) cur_f.cf[i] += A_columns/2;
        cur_f.maxsize = my_maxsize();
 
        RECT ri;
        ri.left = 0;
        ri.top = 0;
        ri.right = A_columns-1;
        ri.bottom = A_rows-1;
        my_InvalidateWndRect(hWnd, ri);
        SendMessage(hWnd, WM_PAINT, 0, 0);
 
        InvalidateRgn(hwndnextf, NULL, TRUE);
        SendMessage(hwndnextf, WM_PAINT, 0, 0);
 
        SetTimer(hwndSta1, nTimerSec, 1000, (TIMERPROC)TimerSecProc);
        runTimerSec = TRUE;
        SetTimer(hWnd, nTimerID, timer_ms, (TIMERPROC)TimerProc);
        runTimer = TRUE;
    }
}
void Stop(HWND hWnd)
{
    if (runTimerSec) { // пауза/пуск
        if (runTimer) {
            KillTimer(hWnd, nTimerID);
            runTimer = FALSE;
        }
        KillTimer(hwndSta1, nTimerSec);
        runTimerSec = FALSE;
    }
}
void SetGameParameters(HWND hWnd)
{
    RECT pos;
    GetWindowRect(hWnd, &pos);
    MoveWindow(hWnd, pos.left, pos.top, A_rc_width*(A_columns + 4) + 15, A_rc_width*A_rows + 50, TRUE);
 
    pos.left = A_rc_width*A_columns + 5;
    pos.top = 0;
    pos.right = A_rc_width*4+1;
    pos.bottom = A_rc_width*4+1;
    MoveWindow(hwndnextf, pos.left, pos.top, pos.right, pos.bottom, TRUE);
    pos.top = pos.bottom + 5;
    //pos.right = pos.right + 50;
    MoveWindow(hwndSta1, pos.left, pos.top, pos.right, 20, TRUE);
    pos.top = pos.top + 25;
    MoveWindow(hwndSta2, pos.left, pos.top, pos.right, 20, TRUE);
}
void RegisterSettingsDialogClass(HWND hWnd) 
{
    WNDCLASSEX wc = {0};
    wc.cbSize           = sizeof(WNDCLASSEX);
    wc.lpfnWndProc      = (WNDPROC) SettingsDialogProc;
    wc.hInstance        = hInst;
    wc.hbrBackground    = GetSysColorBrush(COLOR_3DFACE);
    wc.lpszClassName    = TEXT("DialogClass");
    RegisterClassEx(&wc);
}
void SettingsDialogBox(HWND hWnd)
{
    RECT pos;
    GetWindowRect(hWnd, &pos);
    CreateWindowEx(WS_EX_DLGMODALFRAME | WS_EX_TOPMOST,  TEXT("DialogClass"), TEXT("Параметры"), 
        WS_VISIBLE | WS_SYSMENU | WS_CAPTION , pos.left, pos.top+20, 145, 145, 
        NULL, NULL, hInst,  NULL);
    EnableWindow(hWnd, FALSE);
}
LRESULT CALLBACK SettingsDialogProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    HWND hWndMain = FindWindow(L"MainGameWindowClass", L"Тетрис");
    int wmId, wmEvent;
    static HWND hwndEdit1, hwndEdit2, hwndEdit3;
    wchar_t text[10];
 
    switch(msg)  
    {
    case WM_CREATE:
 
        CreateWindow(TEXT("button"), TEXT("Ok"),    
            WS_VISIBLE | WS_CHILD | WS_BORDER,
            40, 85, 65, 25,        
            hWnd, (HMENU) 1, NULL, NULL);  
 
        CreateWindowW(L"static", L"Высота:", 
            WS_CHILD | WS_VISIBLE,
            10, 10, 60, 20,
            hWnd, (HMENU) NULL, NULL, NULL);
 
        hwndEdit1 = CreateWindowW(L"Edit", NULL, 
            WS_CHILD | WS_VISIBLE | WS_BORDER,
            80, 10, 50, 20,
            hWnd, (HMENU) 2, NULL, NULL);
 
        _itow(A_rows, text, 10);
        SetWindowTextW(hwndEdit1, text);
 
        CreateWindowW(L"static", L"Ширина:", 
            WS_CHILD | WS_VISIBLE,
            10, 35, 60, 20,
            hWnd, (HMENU) NULL, NULL, NULL);
 
        hwndEdit2 = CreateWindowW(L"Edit", NULL, 
            WS_CHILD | WS_VISIBLE | WS_BORDER,
            80, 35, 50, 20,
            hWnd, (HMENU) 3, NULL, NULL);
 
        _itow(A_columns, text, 10);
        SetWindowTextW(hwndEdit2, text);
 
        CreateWindowW(L"static", L"Размер:", 
            WS_CHILD | WS_VISIBLE,
            10, 60, 60, 20,
            hWnd, (HMENU) NULL, NULL, NULL);
 
        hwndEdit3 = CreateWindowW(L"Edit", NULL, 
            WS_CHILD | WS_VISIBLE | WS_BORDER,
            80, 60, 50, 20,
            hWnd, (HMENU) 4, NULL, NULL);
 
        _itow(A_rc_width, text, 10);
        SetWindowTextW(hwndEdit3, text);
 
        break;
    case WM_COMMAND:
        wmId    = LOWORD(wParam);
        wmEvent = HIWORD(wParam);
        switch (wmId)
        {
        case 1:
            GetWindowTextW(hwndEdit1, text, 10);
            A_rows = _wtoi(text);
            GetWindowTextW(hwndEdit2, text, 10);
            A_columns = _wtoi(text);
            GetWindowTextW(hwndEdit3, text, 10);
            A_rc_width = _wtoi(text);
 
            SetGameParameters(hWndMain);
            InvalidateRgn(hWndMain, NULL, TRUE);
            SendMessage(hWndMain, WM_PAINT, 0, 0);
            EnableWindow(hWndMain, TRUE);
 
            DestroyWindow(hWnd);
            break;
        }
        break;
    case WM_CLOSE:
        EnableWindow(hWndMain, TRUE);
        DestroyWindow(hWnd);
        break;       
    }
    return (DefWindowProc(hWnd, msg, wParam, lParam));
}