MeehoweCK

Untitled

Mar 8th, 2021
800
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. #include <cstdlib>
  3. #include <ctime>
  4. #include <vector>
  5. #include <conio.h>
  6. #include <fstream>
  7.  
  8. using namespace std;
  9.  
  10. enum class pole
  11. {
  12.     puste, poszukiwacz, mur, skarb, przeciwnik
  13. };
  14.  
  15. enum class stan_gry
  16. {
  17.     otwarta, zwyciestwo, porazka
  18. };
  19.  
  20. stan_gry stan = stan_gry::otwarta;
  21.  
  22. struct wspolrzedne
  23. {
  24.     short i;
  25.     short j;
  26.     short los;
  27. };
  28.  
  29. const short N = 33;
  30. pole plansza[N][N];
  31. wspolrzedne przeciwnicy[10];
  32. wspolrzedne bohater;
  33.  
  34. void ruch_przeciwnikiem(short x)
  35. {
  36.     // sprawdzenie czy wokół danego przeciwnika stoi poszukiwacz:
  37.     if(plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j - 1] == pole::poszukiwacz)
  38.     {
  39.         plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j - 1] = pole::przeciwnik;
  40.         stan = stan_gry::porazka;
  41.         return;
  42.     }
  43.     if(plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j] == pole::poszukiwacz)
  44.     {
  45.         plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j] = pole::przeciwnik;
  46.         stan = stan_gry::porazka;
  47.         return;
  48.     }
  49.     if(plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j + 1] == pole::poszukiwacz)
  50.     {
  51.         plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j + 1] = pole::przeciwnik;
  52.         stan = stan_gry::porazka;
  53.         return;
  54.     }
  55.     if(plansza[przeciwnicy[x].i][przeciwnicy[x].j - 1] == pole::poszukiwacz)
  56.     {
  57.         plansza[przeciwnicy[x].i][przeciwnicy[x].j - 1] = pole::przeciwnik;
  58.         stan = stan_gry::porazka;
  59.         return;
  60.     }
  61.     if(plansza[przeciwnicy[x].i][przeciwnicy[x].j + 1] == pole::poszukiwacz)
  62.     {
  63.         plansza[przeciwnicy[x].i][przeciwnicy[x].j + 1] = pole::przeciwnik;
  64.         stan = stan_gry::porazka;
  65.         return;
  66.     }
  67.     if(plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j - 1] == pole::poszukiwacz)
  68.     {
  69.         plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j - 1] = pole::przeciwnik;
  70.         stan = stan_gry::porazka;
  71.         return;
  72.     }
  73.     if(plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j] == pole::poszukiwacz)
  74.     {
  75.         plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j] = pole::przeciwnik;
  76.         stan = stan_gry::porazka;
  77.         return;
  78.     }
  79.     if(plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j + 1] == pole::poszukiwacz)
  80.     {
  81.         plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j + 1] = pole::przeciwnik;
  82.         stan = stan_gry::porazka;
  83.         return;
  84.     }
  85.  
  86.     // ruch na wolne miejsce:
  87.     vector<wspolrzedne> dostepne_pola;
  88.     wspolrzedne nowe;
  89.     if(plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j - 1] == pole::puste)
  90.     {
  91.         nowe.i = przeciwnicy[x].i - 1;
  92.         nowe.j = przeciwnicy[x].j - 1;
  93.         dostepne_pola.push_back(nowe);
  94.     }
  95.     if(plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j] == pole::puste)
  96.     {
  97.         nowe.i = przeciwnicy[x].i - 1;
  98.         nowe.j = przeciwnicy[x].j;
  99.         dostepne_pola.push_back(nowe);
  100.     }
  101.     if(plansza[przeciwnicy[x].i - 1][przeciwnicy[x].j + 1] == pole::puste)
  102.     {
  103.         nowe.i = przeciwnicy[x].i - 1;
  104.         nowe.j = przeciwnicy[x].j + 1;
  105.         dostepne_pola.push_back(nowe);
  106.     }
  107.     if(plansza[przeciwnicy[x].i][przeciwnicy[x].j - 1] == pole::puste)
  108.     {
  109.         nowe.i = przeciwnicy[x].i;
  110.         nowe.j = przeciwnicy[x].j - 1;
  111.         dostepne_pola.push_back(nowe);
  112.     }
  113.     if(plansza[przeciwnicy[x].i][przeciwnicy[x].j + 1] == pole::puste)
  114.     {
  115.         nowe.i = przeciwnicy[x].i;
  116.         nowe.j = przeciwnicy[x].j + 1;
  117.         dostepne_pola.push_back(nowe);
  118.     }
  119.     if(plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j - 1] == pole::puste)
  120.     {
  121.         nowe.i = przeciwnicy[x].i + 1;
  122.         nowe.j = przeciwnicy[x].j - 1;
  123.         dostepne_pola.push_back(nowe);
  124.     }
  125.     if(plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j] == pole::puste)
  126.     {
  127.         nowe.i = przeciwnicy[x].i + 1;
  128.         nowe.j = przeciwnicy[x].j;
  129.         dostepne_pola.push_back(nowe);
  130.     }
  131.     if(plansza[przeciwnicy[x].i + 1][przeciwnicy[x].j + 1] == pole::puste)
  132.     {
  133.         nowe.i = przeciwnicy[x].i + 1;
  134.         nowe.j = przeciwnicy[x].j + 1;
  135.         dostepne_pola.push_back(nowe);
  136.     }
  137.     if(dostepne_pola.size() > 0)
  138.     {
  139.         // losujemy na które pole ma pójść przeciwnik
  140.         srand(time(nullptr));
  141.         nowe = dostepne_pola[rand() % dostepne_pola.size()];
  142.         plansza[przeciwnicy[x].i][przeciwnicy[x].j] = pole::puste;
  143.         przeciwnicy[x].i = nowe.i;
  144.         przeciwnicy[x].j = nowe.j;
  145.         plansza[przeciwnicy[x].i][przeciwnicy[x].j] = pole::przeciwnik;
  146.     }
  147. }
  148.  
  149. void ruch_przeciwnikow()
  150. {
  151.     for(short i = 0; i < 10; ++i)
  152.         ruch_przeciwnikiem(i);
  153. }
  154.  
  155. void uzupelnij_plansze()
  156. {
  157.     srand(time(nullptr));
  158.     vector<wspolrzedne> puste_pola;
  159.     wspolrzedne nowe;
  160.     for(short i = 0; i < N; ++i)
  161.         for(short j = 0; j < N; ++j)
  162.             if(i == 0 || i == N - 1 || j == 0 || j == N - 1 || ((i-1) * (j-1)) % 2 != 0)
  163.                 plansza[i][j] = pole::mur;
  164.             else
  165.             {
  166.                 plansza[i][j] = pole::puste;
  167.                 nowe.i = i;
  168.                 nowe.j = j;
  169.                 nowe.los = rand();
  170.                 puste_pola.push_back(nowe);
  171.             }
  172.     unsigned n = puste_pola.size();
  173.     for(unsigned i = 0; i < n - 1; ++i)
  174.         for(unsigned j = 0; j < n - i - 1; ++j)
  175.             if(puste_pola[j].los > puste_pola[j + 1].los)
  176.                 swap(puste_pola[j], puste_pola[j + 1]);
  177.     for(unsigned i = 0; i < 10; ++i)
  178.     {
  179.         plansza[puste_pola[i].i][puste_pola[i].j] = pole::przeciwnik;
  180.         przeciwnicy[i].i = puste_pola[i].i;
  181.         przeciwnicy[i].j = puste_pola[i].j;
  182.     }
  183.     plansza[puste_pola[10].i][puste_pola[10].j] = pole::poszukiwacz;
  184.     bohater.i = puste_pola[10].i;
  185.     bohater.j = puste_pola[10].j;
  186.     plansza[puste_pola[11].i][puste_pola[11].j] = pole::skarb;
  187. }
  188.  
  189. void ruch_bohaterem()
  190. {
  191.     // sprawdzamy czy bohater ma siê gdzie ruszyæ:
  192.     vector<wspolrzedne> dostepne_pola;
  193.     wspolrzedne nowe;
  194.     if(plansza[bohater.i - 1][bohater.j] == pole::puste || plansza[bohater.i - 1][bohater.j] == pole::skarb)
  195.     {
  196.         nowe.i = bohater.i - 1;
  197.         nowe.j = bohater.j;
  198.         dostepne_pola.push_back(nowe);
  199.     }
  200.     if(plansza[bohater.i + 1][bohater.j] == pole::puste || plansza[bohater.i + 1][bohater.j] == pole::skarb)
  201.     {
  202.         nowe.i = bohater.i + 1;
  203.         nowe.j = bohater.j;
  204.         dostepne_pola.push_back(nowe);
  205.     }
  206.     if(plansza[bohater.i][bohater.j - 1] == pole::puste || plansza[bohater.i][bohater.j - 1] == pole::skarb)
  207.     {
  208.         nowe.i = bohater.i;
  209.         nowe.j = bohater.j - 1;
  210.         dostepne_pola.push_back(nowe);
  211.     }
  212.     if(plansza[bohater.i][bohater.j + 1] == pole::puste || plansza[bohater.i][bohater.j + 1] == pole::skarb)
  213.     {
  214.         nowe.i = bohater.i;
  215.         nowe.j = bohater.j + 1;
  216.         dostepne_pola.push_back(nowe);
  217.     }
  218.     if(dostepne_pola.size() == 0)
  219.     {
  220.         stan = stan_gry::porazka;
  221.         return;
  222.     }
  223.  
  224.     // w³aœciwy ruch:
  225.     char direction;
  226.     while(true)
  227.     {
  228.         do
  229.         {
  230.             direction = getch();
  231.             direction = toupper(direction);
  232.         }
  233.         while(direction != 'J' && direction != 'K' && direction != 'L' && direction != 'I' && direction != 'Z');
  234.         switch(direction)
  235.         {
  236.         case 'J':   // ruch w lewo
  237.             if(plansza[bohater.i][bohater.j - 1] == pole::puste)
  238.             {
  239.                 plansza[bohater.i][bohater.j - 1] = pole::poszukiwacz;
  240.                 plansza[bohater.i][bohater.j] = pole::mur;
  241.                 bohater.j--;
  242.                 return;
  243.             }
  244.             if(plansza[bohater.i][bohater.j - 1] == pole::skarb)
  245.             {
  246.                 plansza[bohater.i][bohater.j - 1] = pole::poszukiwacz;
  247.                 plansza[bohater.i][bohater.j] = pole::mur;
  248.                 bohater.j--;
  249.                 stan = stan_gry::zwyciestwo;
  250.                 return;
  251.             }
  252.             break;
  253.         case 'K':   // ruch w dol
  254.             if(plansza[bohater.i + 1][bohater.j] == pole::puste)
  255.             {
  256.                 plansza[bohater.i + 1][bohater.j] = pole::poszukiwacz;
  257.                 plansza[bohater.i][bohater.j] = pole::mur;
  258.                 bohater.i++;
  259.                 return;
  260.             }
  261.             if(plansza[bohater.i + 1][bohater.j] == pole::skarb)
  262.             {
  263.                 plansza[bohater.i + 1][bohater.j] = pole::poszukiwacz;
  264.                 plansza[bohater.i][bohater.j] = pole::mur;
  265.                 bohater.i++;
  266.                 stan = stan_gry::zwyciestwo;
  267.                 return;
  268.             }
  269.             break;
  270.         case 'I':   // ruch w gore
  271.             if(plansza[bohater.i - 1][bohater.j] == pole::puste)
  272.             {
  273.                 plansza[bohater.i - 1][bohater.j] = pole::poszukiwacz;
  274.                 plansza[bohater.i][bohater.j] = pole::mur;
  275.                 bohater.i--;
  276.                 return;
  277.             }
  278.             if(plansza[bohater.i - 1][bohater.j] == pole::skarb)
  279.             {
  280.                 plansza[bohater.i - 1][bohater.j] = pole::poszukiwacz;
  281.                 plansza[bohater.i][bohater.j] = pole::mur;
  282.                 bohater.i--;
  283.                 stan = stan_gry::zwyciestwo;
  284.                 return;
  285.             }
  286.             break;
  287.         case 'L':   // ruch w prawo
  288.             if(plansza[bohater.i][bohater.j + 1] == pole::puste)
  289.             {
  290.                 plansza[bohater.i][bohater.j + 1] = pole::poszukiwacz;
  291.                 plansza[bohater.i][bohater.j] = pole::mur;
  292.                 bohater.j++;
  293.                 return;
  294.             }
  295.             if(plansza[bohater.i][bohater.j + 1] == pole::skarb)
  296.             {
  297.                 plansza[bohater.i][bohater.j + 1] = pole::poszukiwacz;
  298.                 plansza[bohater.i][bohater.j] = pole::mur;
  299.                 bohater.j++;
  300.                 stan = stan_gry::zwyciestwo;
  301.                 return;
  302.             }
  303.             break;
  304.         case 'Z':   // zapis gry
  305.             ofstream plik;
  306.             plik.open("gra.txt");
  307.             // zapisywanie pozycji poszukiwacza:
  308.             plik << bohater.i << ' ' << bohater.j << endl;
  309.             // zapisywanie pozycji wrogów:
  310.             for(short i = 0; i < 10; ++i)
  311.                 plik << przeciwnicy[i].i << ' ' << przeciwnicy[i].j << endl;
  312.             // zapisywanie planszy:
  313.             for(short i = 0; i < 33; ++i)
  314.                 for(short j = 0; j < 33; ++j)
  315.                     plik << static_cast<int>(plansza[i][j]) << ' ';
  316.             plik.close();
  317.             cout << "Zapisano gre!\n";
  318.             break;
  319.         }
  320.     }
  321. }
  322.  
  323. void wypisz_plansze()
  324. {
  325.     for(short i = 0; i < N; ++i)
  326.     {
  327.         for(short j = 0; j < N; ++j)
  328.         {
  329.             switch(plansza[i][j])
  330.             {
  331.             case pole::puste:
  332.                 cout << ' ';
  333.                 break;
  334.             case pole::mur:
  335.                 cout << '#';
  336.                 break;
  337.             case pole::poszukiwacz:
  338.                 cout << 'O';
  339.                 break;
  340.             case pole::skarb:
  341.                 cout << 'X';
  342.                 break;
  343.             case pole::przeciwnik:
  344.                 cout << '@';
  345.                 break;
  346.             }
  347.             cout << ' ';
  348.         }
  349.         cout << endl;
  350.     }
  351. }
  352.  
  353. void nowa_gra()
  354. {
  355.     uzupelnij_plansze();
  356.     system("cls");
  357.     wypisz_plansze();
  358.     while(stan == stan_gry::otwarta)
  359.     {
  360.         ruch_bohaterem();
  361.         ruch_przeciwnikow();
  362.         system("cls");      // wyzerowanie konsoli
  363.         wypisz_plansze();
  364.     }
  365.     if(stan == stan_gry::zwyciestwo)
  366.         cout << "Gratulacje! Wygrales/wygralas!\n";
  367.     else
  368.         cout << "Niestety, porazka :(\n";
  369. }
  370.  
  371. void wczytaj_gre(ifstream& plik)
  372. {
  373.     short x;
  374.     plik >> bohater.i >> bohater.j;
  375.     for(short i = 0; i < 10; ++i)
  376.         plik >> przeciwnicy[i].i >> przeciwnicy[i].j;
  377.     for(short i = 0; i < 33; ++i)
  378.         for(short j = 0; j < 33; ++j)
  379.         {
  380.             plik >> x;
  381.             plansza[i][j] = static_cast<pole>(x);
  382.         }
  383.     stan = stan_gry::otwarta;
  384.  
  385.     system("cls");
  386.     wypisz_plansze();
  387.     while(stan == stan_gry::otwarta)
  388.     {
  389.         ruch_bohaterem();
  390.         ruch_przeciwnikow();
  391.         system("cls");      // wyzerowanie konsoli
  392.         wypisz_plansze();
  393.     }
  394.     if(stan == stan_gry::zwyciestwo)
  395.         cout << "Gratulacje! Wygrales/wygralas!\n";
  396.     else
  397.         cout << "Niestety, porazka :(\n";
  398. }
  399.  
  400. int main()
  401. {
  402.     cout << "Witaj w grze!\n";
  403.     cout << "Twoim celem jest dotarcie poszukiwaczem (O) do skarbu (X). Mozesz sie poruszac nastepujaco:\n";
  404.     cout << "\tI - gora\n";
  405.     cout << "\tJ - lewo\n";
  406.     cout << "\tK - dol\n";
  407.     cout << "\tL - prawo\n";
  408.     cout << "\tZ - zapis stanu gry\n";
  409.     cout << "Uwazaj na swoich wrogow (@), ktorzy rowniez sie poruszaja. Kontakt z ktoryms z nich oznacza przegrana!\n";
  410.     cout << "Pamietaj, ze poruszajac sie, zostawiasz za soba mur (#), na ktory nikt nie moze wejsc. Powodzenia!\n";
  411.     ifstream plik;
  412.     plik.open("gra.txt");
  413.     if(plik.good())
  414.     {
  415.         cout << endl;
  416.         cout << "N - nowa gra\n";
  417.         cout << "W - wczytaj zapisana gre\n";
  418.         char komenda;
  419.         do
  420.         {
  421.             komenda = _getch();
  422.             komenda = toupper(komenda);
  423.         } while(komenda != 'N' && komenda != 'W');
  424.         if(komenda == 'N')
  425.             nowa_gra();
  426.         else
  427.             wczytaj_gre(plik);
  428.     }
  429.     else
  430.     {
  431.         cout << "Wcisnij dowolny przycisk, aby rozpoczac gre...";
  432.         _getch();
  433.         nowa_gra();
  434.     }
  435.     return 0;
  436. }
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×