Facebook
From ToJa, 6 Years ago, written in Plain Text.
Embed
Download Paste or View Raw
Hits: 257
  1. #include<stdio.h>
  2. #include"conio2.h"
  3.  
  4. /* Uwaga: w docelowym programie należy zadeklarować odpowiednie
  5. stałe, na przykład po to, aby wyeliminować z programu
  6. wartości numeryczne umieszczajac w ich miejsce
  7. dobrze dobrane identyfikatory */
  8. #define POZYCJA_MENU 1
  9. #define POZYCJA_PLANSZY 60
  10. #define PION 4 //przesuniecie planszy w pionie
  11. #define DOMYSLNA_WIELKOSC 12
  12.  
  13. int wyswietlanie_planszy_domyslnej(char plansza[DOMYSLNA_WIELKOSC+2][DOMYSLNA_WIELKOSC+3]);
  14. int sprawdz_regule_jeden(char plansza[DOMYSLNA_WIELKOSC + 2][DOMYSLNA_WIELKOSC + 3], int zn, int x, int y);
  15. int sprawdzanie_reguly_dwa(char plansza[DOMYSLNA_WIELKOSC+ 2][DOMYSLNA_WIELKOSC + 3]);
  16. int sprawdzanie_reguly_dwa_v2(char plansza[DOMYSLNA_WIELKOSC+ 2][DOMYSLNA_WIELKOSC + 3]);
  17. int sprawdzanie_reguly_trzy(char plansza[DOMYSLNA_WIELKOSC + 2][DOMYSLNA_WIELKOSC + 3]);
  18.  
  19. int main() {
  20.         int zn = 0, x = 50, y = 12, attr = 7, back = 0, zero = 0;
  21.         char txt[32];
  22.         bool new_game = false;
  23.         int regula_2;
  24.         char plansza[DOMYSLNA_WIELKOSC+2][DOMYSLNA_WIELKOSC+3]= { { "/------------\\" },
  25.                                                                                                                           { "|   1       1|" },
  26.                                                                                                                           { "| 0      1   |" },
  27.                                                                                                                           { "|     0      |" },
  28.                                                                                                                           { "| 0 1 0 0 0 0|" },
  29.                                                                                                                           { "|1 1    0  1 |" },
  30.                                                                                                                           { "|     0  1   |" },
  31.                                                                                                                           { "|  11    1   |" },
  32.                                                                                                                           { "|0     0    0|" },
  33.                                                                                                                           { "| 1  1     1 |" },
  34.                                                                                                                           { "|  0  0 0    |" },
  35.                                                                                                                           { "|  0  00    0|" },
  36.                                                                                                                           { "|   1  0  1  |" },
  37.                                                                                                                           { "\\------------/" } };
  38.         // jeżeli program jest kompilowany w czystym języku C
  39.         // należy wywołać poniższą linię
  40. //#ifndef __cplusplus
  41.         Conio2_Init();
  42. //#endif
  43.         // settitle ustawia tytuł okienka
  44.         settitle("Anna Pazniewska 172027");
  45.         do {
  46.                 int regJ, regD, regT;
  47.                 regJ = regD = regT = 1;
  48.                 // ustawiamy czarny kolor tła, z którego będziemy
  49.                 // korzystali rysując po ekranie
  50.                 // proszę zerknąć do conio2.h na listę dostępnych kolorów
  51.                 textbackground(BLACK);
  52.                 // czyścimy ekran: wypełniamy spacjami z ustawionym kolrem tła
  53.                 clrscr();
  54.                 // ustawiamy kolor tekstu na jasnoszary (7 == LIGHTGRAY)
  55.                 textcolor(7);
  56.  
  57.                 //najpierw przesuwamy tam gdzie jest domyslnie kursor, zeby pobraly sie wlasciwe x  i y w natepnej isntrukcji
  58.                 gotoxy(x, y);
  59.                 //ta funkcja formatuje tekst i zapisuje, w naszej tablicy txt - zadeklarowana wyzej
  60.                 sprintf(txt, "kursor: x - %d, y - %d", wherex(), wherey());
  61.                 //przesuniecie kursora - musisz wstawic odpowiedni x i y
  62.                 gotoxy(POZYCJA_MENU, 17);
  63.                 //wypisanie tekstu
  64.                 cputs(txt);
  65.                 // przesuwamy kursor do kolumny 55 i wiersza 1
  66.                 // wiersze i kolumny liczymy od 1
  67.                 gotoxy(POZYCJA_MENU,1);
  68.                 // wyświetlamy na ekranie, w miejscu kursora napis
  69.                 // kursor przesuwa się w prawo o długość napisu
  70.                 cputs("Anna Pazniewska 172027");
  71.        
  72.                 gotoxy(POZYCJA_MENU, 3);
  73.                 cputs("strzalki = poruszanie");
  74.  
  75.                 gotoxy(POZYCJA_MENU, 4);
  76.                 cputs("ESC = wyjscie z programu");
  77.  
  78.                 gotoxy(POZYCJA_MENU, 5);
  79.                 cputs("n = nowa gra");
  80.  
  81.                 gotoxy(POZYCJA_MENU, 6);
  82.                 cputs("01 = wypisanie cyfry na plansze");
  83.  
  84.                 gotoxy(POZYCJA_MENU, 7);
  85.                 cputs("o = losowe wypelnienie planszy");
  86.  
  87.                 gotoxy(POZYCJA_MENU, 8);
  88.                 cputs("p  = prosta podpowiedz");
  89.  
  90.                 gotoxy(POZYCJA_MENU, 9);
  91.                 cputs("r = zmiana rozmiaru planszy");
  92.  
  93.                 gotoxy(POZYCJA_MENU, 10);
  94.                 cputs("k = proste sprawdzenie mozliwosci ukonczenia gry");
  95.  
  96.                 gotoxy(POZYCJA_MENU, 11);
  97.                 cputs("d = sprawdzenie reguly");
  98.  
  99.                 gotoxy(POZYCJA_MENU, 12);
  100.                 cputs("a = automatyczna detekcja konca gry");
  101.  
  102.                 gotoxy(POZYCJA_MENU, 13);
  103.                 cputs("j = podswietlenie");
  104.  
  105.                 gotoxy(POZYCJA_MENU, 14);
  106.                 cputs("w = wypelnienie podswietlonych jednoznacznych pol");
  107.  
  108.                 gotoxy(POZYCJA_MENU, 15);
  109.                 cputs("s = zapisanie stanu gry");
  110.  
  111.                 gotoxy(POZYCJA_MENU, 16);
  112.                 cputs("l = odczytanie stanu gry");
  113.  
  114.                 gotoxy(POZYCJA_MENU, 17);
  115.                 cputs("b = pelne sprawdzenie, przykladowe wypelnienie pol");
  116.  
  117.                 gotoxy(POZYCJA_MENU, 18);
  118.                 cputs("spacja = zmiana koloru");
  119.  
  120.                 gotoxy(POZYCJA_MENU, 19);
  121.                 cputs("enter = zmiana koloru tla");
  122.  
  123.                 // wypisujemy na ekranie kod ostatnio naciśniętego klawisza
  124.                 if (zero) sprintf(txt, "kod klawisza: 0x00 0x%02x", zn);
  125.                 else sprintf(txt, "kod klawisza: 0x%02x", zn);
  126.                 gotoxy(POZYCJA_MENU, 20);
  127.                 cputs(txt);
  128.                
  129.                 if(regJ == -1) {
  130.                         gotoxy(POZYCJA_MENU, 25);
  131.                         cputs("Nie spełniona reguła 1");
  132.                 }
  133.                 if(regD == -1) {
  134.                         gotoxy(POZYCJA_MENU, 26);
  135.                         cputs("Nie spełniona reguła 2");
  136.                 }
  137.                 if(regT == -1) {
  138.                         gotoxy(POZYCJA_MENU, 27);
  139.                         cputs("Nie spełniona reguła 3");
  140.                 }
  141.                 // do tego momentu wyswietlanie menu
  142.        
  143.  
  144.                 //tutaj wyswietlanie planszy
  145.                 if(new_game) wyswietlanie_planszy_domyslnej(plansza);
  146.  
  147.                 // rysujemy na ekranie kolorową gwiazdkę
  148.                 gotoxy(x, y);
  149.                 textcolor(attr);
  150.                 textbackground(back);
  151.                 // putch rysuje jeden znak i przesuwa kursor w prawo
  152.                 //putch('*');
  153.  
  154.                 // czekamy na naciśnięcie klawisza i odczytujemy jego kod,
  155.                 // większość kodów klawiszy odpowiada ich znakom, np.
  156.                 // a to 'a', 2 to '2', + to '+', ale niektóre klawisze
  157.                 // specjalne, np. strzałki są zgłaszane jako dwa kolejne znaki,
  158.                 // z których pierwszy jest zerem, np. strzałka w górę
  159.                 // to zero i 'H'
  160.                 zero = 0;
  161.                 zn = getch();
  162.                 // nie chcemy, aby klawisz 'H' działał jako strzałka w górę
  163.                 // więc sprawdzamy, czy pierwszym znakiem było zero
  164.                 if (zn == 0) {
  165.                         zero = 1;               // jeżeli tak, to czytamy
  166.                         zn = getch();           // kolejny znak wiedząc już,
  167.                         if (zn == 0x48) y--;    // że będzie to znak specjalny
  168.                         else if (zn == 0x50) y++;
  169.                         else if (zn == 0x4b) x--;
  170.                         else if (zn == 0x4d) x++;
  171.                 }
  172.                 else if (zn == ' ') attr = (attr + 1) % 16;
  173.                 else if (zn == 0x0d) back = (back + 1) % 16;
  174.                 else if (zn == '0' || zn == '1') {
  175.  
  176.                         regJ = sprawdz_regule_jeden(plansza, zn, wherex(), wherey());
  177.                         regD = sprawdzanie_reguly_dwa_v2(plansza);
  178.                         regT = sprawdzanie_reguly_trzy(plansza);
  179.                        
  180.                         if (regJ == 1 && regD == 1 && regT == 1) {
  181.                                 int y_gdzie = wherey() - PION;
  182.                                 int x_gdzie = wherex() - POZYCJA_PLANSZY;
  183.                                 plansza[y_gdzie][x_gdzie] = zn+2;
  184.                         }
  185.                 }
  186.                 else if (zn == 'n') new_game = true;
  187.                 else if(zn='d') regula_2 = sprawdzanie_reguly_dwa(plansza);
  188.         } while (zn !=27);//0x1b= 27, kod ESC
  189.  
  190.         return 0;
  191. }
  192.  
  193. int wyswietlanie_planszy_domyslnej(char plansza[DOMYSLNA_WIELKOSC + 2][DOMYSLNA_WIELKOSC + 3]){
  194.         //kontrola bledow
  195.         if (plansza == NULL)
  196.                 return -1;
  197.         for (int i = 0; i < DOMYSLNA_WIELKOSC + 2; i++) {
  198.                 gotoxy(POZYCJA_PLANSZY, PION + i);
  199.                 for (int j = 0; j < DOMYSLNA_WIELKOSC + 3; j++) {
  200.                         //jesli wpisane wartosci
  201.                         if (plansza[i][j] == '2' || plansza[i][j] == '3') {
  202.                                 //zmiana koloru
  203.                                 textcolor(5);
  204.                                 putch(plansza[i][j] - 2);
  205.                         }
  206.                         //jesli wygenerowane wartosci
  207.                         else {
  208.                                 //standardowy kolor
  209.                                 textcolor(7);
  210.                                 putch(plansza[i][j]);
  211.                         }
  212.                 }
  213.         }
  214.         //znow zmiana na standardowy
  215.         textcolor(7);
  216.  
  217.         return 1;
  218. }
  219. int sprawdz_regule_jeden(char plansza[DOMYSLNA_WIELKOSC + 2][DOMYSLNA_WIELKOSC + 3], int zn, int x, int y) {
  220.         //najpierw sprawdzamy czy kursor znajduje się w planszy
  221.         if (x > POZYCJA_PLANSZY && x < POZYCJA_PLANSZY + DOMYSLNA_WIELKOSC + 1 && y > PION && y < PION + DOMYSLNA_WIELKOSC + 1) {
  222.                 //teraz sprawdzamy czy wybrane pole jest modyfikowalne
  223.                 y -= PION;
  224.                 x -= POZYCJA_PLANSZY;
  225.                 if (plansza[y][x] != '0' & plansza[y][x] != '1') {
  226.                         //ostatecznie sprawdzamy czy spelniona zostala regula jeden - w zadnym wierszu i zadnej kolumnie obok siebie nie moga wystapic wiecej niz dwie identyczne cyfry
  227.                         //zmienna pomocniczne
  228.                         char buff = plansza[y][x];
  229.                         bool koniec = false;
  230.                         //najpierw wpiszmy w wybrane przez uzytkownika pole, wybrany przez niego znak
  231.                         plansza[y][x] = zn;
  232.  
  233.                         //teraz przechodzimy cala plansze
  234.                         //najpierw sprawdzamy w poziomie
  235.                         for (int i = 1; i < DOMYSLNA_WIELKOSC + 1; i++) {
  236.                                 for (int j = 1; j < DOMYSLNA_WIELKOSC - 1; j++) {
  237.                                         //3 kolejne są zerami
  238.                                         if ((plansza[i][j] == '0' || plansza[i][j] == '2')
  239.                                                 && (plansza[i][j + 1] == '0' || plansza[i][j + 1] == '2')
  240.                                                 && (plansza[i][j + 2] == '0' || plansza[i][j + 2] == '2')) {
  241.                                                 koniec = true;
  242.                                                 break;
  243.                                         }
  244.                                         //3 kolejne sa jedynkami
  245.                                         else if ((plansza[i][j] == '1' || plansza[i][j] == '3')
  246.                                                 && (plansza[i][j + 1] == '1' || plansza[i][j + 1] == '3')
  247.                                                 && (plansza[i][j + 2] == '1' || plansza[i][j + 2] == '3')) {
  248.                                                 koniec = true;
  249.                                                 break;
  250.                                         }
  251.                                 }
  252.  
  253.                                 if (koniec)
  254.                                         break;
  255.                         }
  256.                         //jesli w poziomie nie znaleziono bledu
  257.                         if (!koniec) {
  258.                                 //sprawdzanie w pionie
  259.                                 for (int j = 1; j < DOMYSLNA_WIELKOSC+ 1; j++) {
  260.                                         for (int i = 1; i < DOMYSLNA_WIELKOSC - 1; i++) {
  261.                                                 //3 kolejne są zerami
  262.                                                 if ((plansza[i][j] == '0' || plansza[i][j] == '2')
  263.                                                         && (plansza[i + 1][j] == '0' || plansza[i + 1][j] == '2')
  264.                                                         && (plansza[i + 2][j] == '0' || plansza[i + 2][j] == '2')) {
  265.                                                         koniec = true;
  266.                                                         break;
  267.                                                 }
  268.                                                 //3 kolejne sa jedynkami
  269.                                                 else if ((plansza[i][j] == '1' || plansza[i][j] == '3')
  270.                                                         && (plansza[i + 1][j] == '1' || plansza[i + 1][j] == '3')
  271.                                                         && (plansza[i + 2][j] == '1' || plansza[i + 2][j] == '3')) {
  272.                                                         koniec = true;
  273.                                                         break;
  274.                                                 }
  275.                                         }
  276.                                         if (koniec)
  277.                                                 break;
  278.                                 }
  279.                         }
  280.                         //w poziomie znaleziono blad
  281.                         else {
  282.                                 //usuwamy wczesniej wpisane pole
  283.                                 plansza[y][x] = buff;
  284.                                 return -1;
  285.                         }
  286.  
  287.                         if (koniec) {
  288.                                 plansza[y][x] = buff;
  289.                                 return -1;
  290.                         }
  291.                         else {
  292.                                 plansza[y][x] = buff;
  293.                                 //plansza[y][x] += 2;
  294.                                 return 1;
  295.                         }
  296.  
  297.                 }
  298.                 //inaczej wybrano pole niemodyfikowalne
  299.                 else
  300.                         return -1;
  301.         }
  302.         //jesli poza plansza
  303.         else
  304.                 return -1;
  305. }
  306. int sprawdzanie_reguly_dwa(char plansza[DOMYSLNA_WIELKOSC + 2][DOMYSLNA_WIELKOSC + 3]) {
  307.         int licz_z;
  308.         int licz_j;
  309.         //sprawdzanie w pionie
  310.         for (int i = POZYCJA_PLANSZY + 1; i<POZYCJA_PLANSZY + DOMYSLNA_WIELKOSC + 1; i++) {
  311.                 licz_z = licz_j = 0;
  312.                 for (int j = PION + 1; j<PION + DOMYSLNA_WIELKOSC + 1; j++) {
  313.                         if (plansza[j][i] == '0' || plansza[j][i] == '2') {
  314.                                 licz_z++;
  315.                         }
  316.                         else if (plansza[j][i] == '1' || plansza[j][i] == '3')
  317.                                 licz_j++;
  318.                 }
  319.                 if (licz_z != licz_j)
  320.                         return -1;
  321.         }
  322.         //sprawdzanie w poziomie
  323.         for (int j = PION + 1; j<PION + DOMYSLNA_WIELKOSC + 1; j++) {
  324.                 licz_z = licz_j = 0;
  325.                 for (int i = POZYCJA_PLANSZY + 1; i<POZYCJA_PLANSZY + DOMYSLNA_WIELKOSC + 1; i++) {
  326.                         if (plansza[j][i] == '0' || plansza[j][i] == '2') {
  327.                                 licz_z++;
  328.                         }
  329.                         else if (plansza[j][i] == '1' || plansza[j][i] == '3')
  330.                                 licz_j++;
  331.                 }
  332.                 if (licz_z != licz_j)
  333.                         return -1;
  334.         }
  335.  
  336.         return 1;
  337. }
  338.  
  339.  
  340. int sprawdzanie_reguly_dwa_v2(char plansza[DOMYSLNA_WIELKOSC+ 2][DOMYSLNA_WIELKOSC + 3]) {
  341.        
  342.         int licz_z;
  343.         int licz_j;
  344.         //sprawdzanie w pionie
  345.         for (int i = POZYCJA_PLANSZY + 1; i<POZYCJA_PLANSZY + DOMYSLNA_WIELKOSC + 1; i++) {
  346.                 licz_z = licz_j = 0;
  347.                 for (int j = PION + 1; j<PION + DOMYSLNA_WIELKOSC + 1; j++) {
  348.                         if (plansza[j][i] == '0' || plansza[j][i] == '2') {
  349.                                 licz_z++;
  350.                         }
  351.                         else if (plansza[j][i] == '1' || plansza[j][i] == '3')
  352.                                 licz_j++;
  353.                 }
  354.                 if (licz_z >= DOMYSLNA_WIELKOSC/2 || licz_j >= DOMYSLNA_WIELKOSC/2)
  355.                         return -1;
  356.         }
  357.         //sprawdzanie w poziomie
  358.         for (int j = PION + 1; j<PION + DOMYSLNA_WIELKOSC + 1; j++) {
  359.                 licz_z = licz_j = 0;
  360.                 for (int i = POZYCJA_PLANSZY + 1; i<POZYCJA_PLANSZY + DOMYSLNA_WIELKOSC + 1; i++) {
  361.                         if (plansza[j][i] == '0' || plansza[j][i] == '2') {
  362.                                 licz_z++;
  363.                         }
  364.                         else if (plansza[j][i] == '1' || plansza[j][i] == '3')
  365.                                 licz_j++;
  366.                 }
  367.                 if (licz_z >= DOMYSLNA_WIELKOSC/2 || licz_j >= DOMYSLNA_WIELKOSC/2)
  368.                         return -1;
  369.         }
  370.  
  371.         return 1;
  372. }
  373.  
  374.  
  375. int sprawdzanie_reguly_trzy(char plansza[DOMYSLNA_WIELKOSC + 2][DOMYSLNA_WIELKOSC + 3]) {
  376.  
  377.          bool przerwanie = false;
  378.     //sprawdzanie czy kolumny są takie same
  379.     //ta petla bedzie zmieniala kolumne porownywana - tutaj dochodzimy do przedostatniej
  380.     for(int i = 1; i <= DOMYSLNA_WIELKOSC-1; i++) {
  381.         //ta petla zmienia kolumny z ktorymi porownujemy - tutaj dochodzimy do ostatniej
  382.         for(int i_2 = i+1; i_2 <= DOMYSLNA_WIELKOSC-1; i_2++) {
  383.             //ta petla przemieszcza sie po wierszach - wszystkich
  384.             przerwanie = false;
  385.             for(int j = 1; j <=DOMYSLNA_WIELKOSC-1; j++) {
  386.                 if(plansza[j][i] != plansza[j][i_2]) {
  387.                     przerwanie = true;
  388.                     //wyjscie z 3 petli
  389.                     break;
  390.                 }
  391.             }
  392.             //jesli przeszlismy cale i nie bylo roznych elementow - przerwanie == false
  393.             if(przerwanie == false)
  394.                 //konczymy sprawdzanie - regula nie spelniona
  395.                 return -1;
  396.         }
  397.     }
  398.    
  399.     //sprawdzanie czy wiersze sa takie same
  400.     //ta petla bedzie zmieniala wiersz do porownania - tutaj dochodzimy do przedostatniego
  401.     for(int i = 1; i <= DOMYSLNA_WIELKOSC-1; i++) {
  402.         //ta petla zmienia wiersze z ktorymi porownyjemy - tutaj dochodzimy do ostatniego
  403.         for(int i_2 = i+1; i_2 <= DOMYSLNA_WIELKOSC-1; i_2++) {
  404.             //ta petal przemieszcza sie po kolumnach - wszystkich
  405.             przerwanie = false;
  406.             for(int j = 1; j <= DOMYSLNA_WIELKOSC-1; j++) {
  407.                 if(plansza[i][j] != plansza[i_2][j]) {
  408.                     przerwanie = true;
  409.                     //wyjscie z 3 petli
  410.                     break;
  411.                 }
  412.             }
  413.             //jesli przeszlismy cala i nie bylo roznych elementow - przerwanie == false
  414.             if(przerwanie == false)
  415.                 //konczymy sprawdzanie - regula nie spelniona
  416.                 return -1;
  417.         }
  418.     }
  419.    
  420.     return 1;
  421. }
  422.                
  423.