SHARE
TWEET

Untitled

a guest Nov 19th, 2019 95 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <time.h>
  4.  
  5. //maksymalny rozmiar stringa zdefiniowany dla pozniejszego uzycia
  6. #define MAX_STRING_SIZE 200
  7.  
  8. //ilosc przyciskow w rzedzie i kolumnie do odgadniecia
  9. #define MEMORIES 4
  10.  
  11. //rozmiar przycisku w pixelach
  12. #define MEMORY_BUTTON_SIZE 50
  13.  
  14.  
  15. const char g_szClassName[] = "myWindowClass";
  16.  
  17. HWND stateText, finalText;
  18.  
  19.  
  20. //tablica dwuwymiarowa (przyciskow), ktore klikamy by odgadywac slowa
  21. HWND memory_buttons[MEMORIES][MEMORIES];
  22. //i tablica dwuwymiarowa (intow) przetrzymujaca wylosowane liczby w odpowiednich polach, zadeklarowane globalnie, by miec dostep do nich w calym programie
  23. int randomness[MEMORIES][MEMORIES];
  24.  
  25. //pozycja pierwszego (x,y - rzad, kolumna) wybranego przycisku
  26. int firstChoose[] = { -1, -1 };
  27. //pozycja drugiego (x,y) wybranego przycisku
  28. int secondChoose[] = { -1, -1 };
  29.  
  30. //stałe stringi wyswietlane u gory pokazujace stan odgadnietych liczb
  31. const char state_string1[] = { "Odganiete liczby: [" };
  32. const char state_string2[] = { " / " };
  33. const char state_string3[] = { "]" };
  34.  
  35. //liczba odgadnietych
  36. int memoriesCollected = 0;
  37.  
  38. //flaga sluzaca do sprawdzanai czy chcemy zrobic opoznienie by przytrzymac odkryte liczby
  39. BOOLEAN doDelay = FALSE;
  40.  
  41. //zmienna czasowa/daty przetrzymujaca znacznik czasu przy starcie programu (odejmujemy ją na koniec by uzyskac czas jaki zajelo graczowi odgadniecie wszystkich slow)
  42. clock_t Launch_Time;
  43.  
  44. //metoda wywolujaca opoznienie
  45. void delay(int time)
  46. {
  47.     clock_t start_time = clock();
  48.  
  49.     while (clock() < start_time + time);
  50. }
  51.  
  52. //metoda odswiezajca napis u gory pokazujacy ilosc odgadnietych slow
  53. void RefreshStateText()
  54. {
  55.     char int_string[4];
  56.     sprintf(int_string, "%d", memoriesCollected);
  57.     //zamiana int, ktory przechowuje ilosc odgadnietych na string
  58.     char int_string2[4];
  59.     sprintf(int_string2, "%d", MEMORIES * 2);
  60.     //zamiana int, ktory przechowuje ilosc wszystkich liczb do odgadniecia na string
  61.  
  62.     int sum = strlen(state_string1) + strlen(state_string2) + strlen(state_string3) + strlen(int_string) + strlen(int_string2);
  63.     //wyliczamy jak duzy powinien byc buffor ktory pomiesci zlozonego stringa, zliczamy ilosc liter
  64.     char * buffer = (char*)malloc(sum * sizeof(char));
  65.     //deklarujemy odpowiednia ilosc pamieci
  66.     int i = 0, j = 0;
  67.     for (i = 0; i < strlen(state_string1); ++i, ++j)
  68.     {
  69.         buffer[j] = state_string1[i];
  70.     }
  71.     //przepisanie pierwszego stringa - Odganiete liczby: [
  72.  
  73.     for (i = 0; i < strlen(int_string); ++i, ++j)
  74.     {
  75.         buffer[j] = int_string[i];
  76.     }
  77.  
  78.     for (i = 0; i < strlen(state_string2); ++i, ++j)
  79.     {
  80.         buffer[j] = state_string2[i];
  81.     }
  82.  
  83.     for (i = 0; i < strlen(int_string2); ++i, ++j)
  84.     {
  85.         buffer[j] = int_string2[i];
  86.     }
  87.  
  88.     for (i = 0; i < strlen(state_string3); ++i, ++j)
  89.     {
  90.         buffer[j] = state_string3[i];
  91.     }
  92.     buffer[j] = '\0';
  93.     //zakonczenie stringa bitem zerowym
  94.     SetWindowText(stateText, buffer);
  95.     //przypisanie tekstu do kontrolki tekstowej
  96. }
  97.  
  98. //metoda windowsowa sluzaca do przetwarzania komuniaktow ktore przychodza do okna od uzytkownika a takze tych systemowych
  99. LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  100. {
  101.     switch (msg)
  102.     {
  103.     case WM_CLOSE:
  104.         DestroyWindow(hwnd);
  105.         break;
  106.     case WM_DESTROY:
  107.         PostQuitMessage(0);
  108.         break;
  109.     case WM_COMMAND:
  110.         //sprawdzamy ktory przycisk zostal nacisniety, w tym celu musimy przejsc po calej naszej tablicy dwuwymiarowej w poszukiwaniu odpowiedniego obiektu
  111.         for (int i = 0; i < MEMORIES; ++i)
  112.         {
  113.             for (int j = 0; j < MEMORIES; ++j)
  114.             {
  115.                 if ((HWND)lParam == memory_buttons[i][j])
  116.                 {
  117.                     char buffer[2];
  118.                     sprintf(buffer, "%d", randomness[i][j]);
  119.                     //jesli to on to tworzymy buffer by zamienic int przetrzymywany w randomness na stringa, ktorego pozniej przypiszemy do przycisku
  120.                     SetWindowText(memory_buttons[i][j], buffer);
  121.  
  122.                     EnableWindow(memory_buttons[i][j], FALSE);
  123.                     //dezaktywujemy przycisk, zeby nie mozna go bylo kliknac jeszcze raz
  124.                     if (firstChoose[0] == -1)
  125.                     {
  126.                         //jesli to pierwszy klikniety przycisk to zapisujemy jego wspolrzedne z tablicy
  127.                         firstChoose[0] = i;
  128.                         firstChoose[1] = j;
  129.                     } else {
  130.                         //jesli to drugi klikniety przycisk to zapisujemy jego wspolrzedne z tablicy
  131.                         secondChoose[0] = i;
  132.                         secondChoose[1] = j;
  133.                         doDelay = TRUE;//wymuszamy opoznienie, zeby tekst ktory przypisalismy do przyciskow nam od razu nie zniknal i zebysmy mogli zobaczyc co odkrylismy pod drugim przyciskiem
  134.                     }
  135.                     break;//konczymy petle bo na pewno kliknelismy tylko jeden przycisk
  136.                 }
  137.             }
  138.         }
  139.         break;
  140.     case WM_PAINT:
  141.     {
  142.         //Sekcja odpowiedzialna za rysowanie elementow okna, potrzebna w przypadku gdy uzywamy bitmap
  143.         PAINTSTRUCT ps; // deklaracja struktury
  144.  
  145.         HDC hdc = BeginPaint(hwnd, &ps);
  146.         EndPaint(hwnd, &ps); // zwalniamy hdc
  147.     }
  148.     default:
  149.         return DefWindowProc(hwnd, msg, wParam, lParam);
  150.     }
  151.     return 0;
  152. }
  153.  
  154. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
  155.     LPSTR lpCmdLine, int nCmdShow)
  156. {
  157.  
  158.     WNDCLASSEX wc;
  159.     HWND hwnd;
  160.     MSG Msg;
  161.  
  162.     //Rejestrowanie klasy Window, nadejemy tu okienku wszystkie parametry, takie jak kursor ikonka, tlo, tstyl
  163.     wc.cbSize = sizeof(WNDCLASSEX);
  164.     wc.style = 0;
  165.     wc.lpfnWndProc = WndProc;
  166.     wc.cbClsExtra = 0;
  167.     wc.cbWndExtra = 0;
  168.     wc.hInstance = hInstance;
  169.     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  170.     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  171.     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
  172.     wc.lpszMenuName = NULL;
  173.     wc.lpszClassName = g_szClassName;
  174.     wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
  175.  
  176.     if (!RegisterClassEx(&wc))
  177.     {
  178.         //jesli sie nei udalo zarejstrowac klasy wyrzucamy blad
  179.         MessageBox(NULL, "Window Registration Failed!", "Error!",
  180.             MB_ICONEXCLAMATION | MB_OK);
  181.         return 0;
  182.     }
  183.  
  184.     //Tworzenie Okna
  185.     hwnd = CreateWindowEx(
  186.         WS_EX_CLIENTEDGE,
  187.         g_szClassName,
  188.         "Gra Memory",
  189.         WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
  190.         CW_USEDEFAULT, CW_USEDEFAULT, 400, 400,
  191.         NULL, NULL, hInstance, NULL);
  192.  
  193.     //Tekst powitalny
  194.     HWND hTextWelcome = CreateWindowEx(0, "STATIC", NULL, WS_CHILD | WS_VISIBLE |
  195.         SS_CENTER, 10, 0, 365, 30, hwnd, NULL, hInstance, NULL);
  196.  
  197.     //Tekst pokazujacy ile odgadlismy liczb
  198.     stateText = CreateWindowEx(0, "STATIC", NULL, WS_CHILD | WS_VISIBLE |
  199.         SS_CENTER, 10, 50, 365, 30, hwnd, NULL, hInstance, NULL);
  200.  
  201.     //Tekst koncowy pokazujacy wynik
  202.     finalText = CreateWindowEx(0, "STATIC", NULL, WS_CHILD |
  203.         SS_CENTER, 25, 310, 335, 30, hwnd, NULL, hInstance, NULL);
  204.  
  205.     srand(time(NULL));//inicjalizacja losowosci
  206.  
  207.     //wypelniam -1 zeby bylo wiadomo ze pola sa wolne poniewaz bedziemy losowac liczby od 0 do MEMORIES*2
  208.     for (int i = 0; i < MEMORIES; ++i)
  209.     {
  210.         for (int j = 0; j < MEMORIES; ++j)
  211.         {
  212.             randomness[i][j] = -1;
  213.         }
  214.     }
  215.  
  216.     //wypelnianie tablicy randomness losowymi liczbami
  217.     for (int i = 0; i < MEMORIES; ++i)
  218.     {
  219.         for (int j = 0; j < MEMORIES; ++j)
  220.         {
  221.             int foundCounter = 2; // kazda liczba musi byc dwukrotnie wylosowana (zeby miala pare)
  222.             int r = rand() % (MEMORIES * 2); //dla pola 4x4 powinno byc 8 par
  223.             while (foundCounter == 2)//dopoki nasza wylosowana liczba ma juz 2 powtorzenia probujemy znalezc inna
  224.             {
  225.                 foundCounter = 0;//zerowanie licznika odnalezien wylosowanej liczby w tablicy
  226.                 r = rand() % (MEMORIES * 2);//losowanie nowej
  227.                 //szukam czy nie ma przypadkiem tej liczby
  228.                 for (int k = 0; k < MEMORIES; ++k)//przechodzimy jeszcze raz tablice
  229.                 {
  230.                     for (int l = 0; l < MEMORIES; ++l)
  231.                     {
  232.                         if (randomness[k][l] == r)
  233.                         {
  234.                             ++foundCounter;//jesli odnalezlismy element zwiekszamy licznik
  235.                         }
  236.                     }
  237.                 }
  238.                 if (foundCounter < 2)//jesli udalo sie znalezc liczbe mniej niz 2 razy czyli 1 albo 0 to mozemy ja przypisac w miejsce w tablicy i  tak robimy do skutku
  239.                 {
  240.                     randomness[i][j] = r;
  241.                 }
  242.             }
  243.         }
  244.     }
  245.     int xOffset = 40;//odpowiednia ilosc pixeli w poziomie dla ustawienia na srodku przyciskow do zgadywania
  246.     int yOffset = 45;//odpowiednia ilosc pixeli w pionie dla ustawienia na srodku przyciskow do zgadywania
  247.     for (int i = 0; i < MEMORIES; ++i)
  248.     {
  249.         for (int j = 0; j < MEMORIES; ++j)
  250.         {
  251.             memory_buttons[i][j] = CreateWindowEx(0, "BUTTON", "", WS_CHILD | WS_VISIBLE,
  252.                 xOffset + MEMORY_BUTTON_SIZE + j* MEMORY_BUTTON_SIZE,
  253.                 yOffset + MEMORY_BUTTON_SIZE +i * MEMORY_BUTTON_SIZE,
  254.                 MEMORY_BUTTON_SIZE,
  255.                 MEMORY_BUTTON_SIZE,
  256.                 hwnd, NULL, hInstance, NULL
  257.             );//tworzenie przyciskow  
  258.         }
  259.     }
  260.  
  261.     SetWindowText(hTextWelcome, "GRA MEMORY");//tekst tytulowy na samej gorze
  262.     RefreshStateText();
  263.     Launch_Time = clock();//zapisujemy sobie czas startu by moc go potem odjac od czasu koncowego
  264.  
  265.     if (hwnd == NULL)
  266.     {
  267.         //jesli nie udalo sie stworzyc okna wyrzucamy blad
  268.         MessageBox(NULL, "Window Creation Failed!", "Error!",
  269.             MB_ICONEXCLAMATION | MB_OK);
  270.         return 0;
  271.     }
  272.  
  273.     ShowWindow(hwnd, nCmdShow);//pokazujemy stworzone okienko
  274.     UpdateWindow(hwnd);
  275.  
  276.  
  277.     while (GetMessage(&Msg, NULL, 0, 0) > 0)
  278.     {
  279.         TranslateMessage(&Msg);
  280.         DispatchMessage(&Msg);
  281.  
  282.         //miejsce gdzie odswiezane jest okno wykorzystujemy to miejsce do zawieszenia go na chwile by moc przytrzymac na widoku odkryte liczby
  283.         if (doDelay == TRUE)
  284.         {
  285.             doDelay = FALSE; //po wywolaniu zmieniamy na FALSE by te linijki wykonaly sie jednorazowo
  286.             delay(450);//wywolanie opoznienia 450 milisekund
  287.             if (randomness[secondChoose[0]][secondChoose[1]] == randomness[firstChoose[0]][firstChoose[1]])//sprawdzamy czy pierwsze odgadniecie pokazuje ta sama liczbe co drugie
  288.             {
  289.                 //jesli tak to ukrywamy oba przyciski, zwiekszamy liczbe odgadnietych i odswiezamy tekst mowiacy o stanie odgadnietych
  290.                 ShowWindow(memory_buttons[firstChoose[0]][firstChoose[1]], SW_HIDE);
  291.                 ShowWindow(memory_buttons[secondChoose[0]][secondChoose[1]], SW_HIDE);
  292.                 ++memoriesCollected;
  293.                 RefreshStateText();
  294.             }
  295.             else {
  296.                 //jesli nie to reaktywujemy przyciski, ktore wczesniej wylaczylismy i zmieniamy ich teksty na puste
  297.                 EnableWindow(memory_buttons[firstChoose[0]][firstChoose[1]], TRUE);
  298.                 SetWindowText(memory_buttons[firstChoose[0]][firstChoose[1]], "");
  299.                 EnableWindow(memory_buttons[secondChoose[0]][secondChoose[1]], TRUE);
  300.                 SetWindowText(memory_buttons[secondChoose[0]][secondChoose[1]], "");
  301.             }
  302.             firstChoose[0] = -1;
  303.             firstChoose[1] = -1;
  304.             secondChoose[0] = -1;
  305.             secondChoose[1] = -1;
  306.             //czyscimy zapisane pozycje w przypadku pierwszego wyboru i drugiego
  307.  
  308.             //sprwadzamy czy gra zostala ukonczona
  309.             if (memoriesCollected >= MEMORIES * 2)
  310.             {
  311.                 unsigned long playTime = (clock() - Launch_Time) / 1000; //odejmujemy czas poczatkowy od koncowego i dzielimy przez 1000 by otrzymac sekundy
  312.                 char buffer[MAX_STRING_SIZE];
  313.                 sprintf(buffer, "%ul", playTime);//zamieniamy to na stringa by moc to wypisac
  314.                 char str1[] = { "Gratulacje odkryles wszystkie liczby! Twoj czas to: " };
  315.                 char str2[] = { " sekund!" };
  316.                 int sum = strlen(str1) + strlen(buffer) + strlen(str2);
  317.                 int stringPointer = 0;
  318.                 char * mergedString = (char*)malloc(sum * sizeof(char));
  319.                 //tworzymy buffer do ktorego zlozymy stringi o odpowiedniej dlugosci
  320.                 int i = 0, j = 0;
  321.  
  322.                 for (i = 0; i < strlen(str1); ++i, ++j)
  323.                 {
  324.                     mergedString[j] = str1[i];
  325.                 }
  326.                 for (i = 0; i < strlen(buffer)-1; ++i, ++j)
  327.                 {
  328.                     mergedString[j] = buffer[i];
  329.                 }
  330.                 for (i = 0; i < strlen(str2); ++i, ++j)
  331.                 {
  332.                     mergedString[j] = str2[i];
  333.                 }
  334.                 mergedString[j] = '\0';
  335.                 //zakanczamy stringa i przypisujemy go do tekstu koncowego i pokazujemy go w okienku
  336.                 SetWindowText(finalText, mergedString);
  337.                 ShowWindow(finalText, nCmdShow);
  338.                 MessageBox(hwnd, mergedString, "Wygrana!", MB_ICONINFORMATION);
  339.             }
  340.         }
  341.     }
  342.     return Msg.wParam;
  343. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top