MeehoweCK

Untitled

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