API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 22nd, 2019
111
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 18.42 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <string>
  3. #include <cstdlib>
  4. #include <ctime>
  5. #include "NaudokSitaDar.h"
  6.  
  7. const int B_AUKSTIS = 11;
  8. const int B_PLOTIS = 11;
  9. const int LAIVU_KIEKIS = 5;
  10.  
  11. int GRID[B_AUKSTIS][B_PLOTIS];
  12. int ishit = 0;
  13. int ZTLL = 0;
  14.  
  15.  
  16. const char vanduo = '~';
  17. const char hit = 'X';
  18. const char laivas = 'O';
  19. const char miss = '/';
  20.  
  21. struct POINT
  22. {
  23.     int X;
  24.     int Y;
  25. };
  26.  
  27. struct LAIVAS
  28. {
  29.     std::string pavadinimas;
  30.     int ilgis;
  31.     POINT onGrid[5];
  32.     bool hitFLAG[5];
  33.  
  34. } ship[LAIVU_KIEKIS];
  35.  
  36. struct ZAIDEJAS
  37. {
  38.     char LENTA[B_AUKSTIS][B_PLOTIS];
  39. } zaidejas[3];
  40.  
  41. enum DIRECTION { HORIZONTAL, VERTICAL };
  42.  
  43. struct PLACESHIPS
  44. {
  45.     DIRECTION direction;
  46.     LAIVAS LaivoTipas;
  47. };
  48.  
  49. bool gameRunning = false;
  50. PLACESHIPS ZaidejasStatoLaivus(int);
  51. PLACESHIPS PCStatoLaivus(int);
  52.  
  53.  
  54. class Bendra
  55. {
  56. public:
  57.  
  58.     Bendra() {}
  59.  
  60.     ~Bendra() {}
  61.  
  62.     bool GameOverCheck(int enemyPLAYER)
  63.     {
  64.         bool winner = true;
  65.         //Loopas per priešininko lentą tikrinantis ar turi laivų.
  66.         for (int w = 0; w < B_PLOTIS; ++w)
  67.         {
  68.             for (int h = 0; h < B_AUKSTIS; ++h)
  69.             {
  70.                 if (zaidejas[enemyPLAYER].LENTA[w][h] == laivas)
  71.                 {
  72.                     winner = false;
  73.                     return winner;
  74.                 }
  75.             }
  76.         }
  77.         return winner;
  78.     }
  79.  
  80.     void LAUKAS(int thisPlayer)
  81.     {
  82.         std::cout << "Žaidėjo " << thisPlayer << "'Žaidimo lenta\n";
  83.         std::cout << "----------------------\n";
  84.         std::cout << "         ";
  85.         for (int p = 0; p <= B_PLOTIS; ++p)
  86.         {
  87.             if (p < 10)
  88.                 std::cout << p << "  ";
  89.             else if (p >= 10 && p != B_PLOTIS)
  90.                 std::cout << p << " ";
  91.             if (p == B_PLOTIS)
  92.                 std::cout << "X";
  93.         }
  94.         std::cout << std::endl;
  95.         for (int a = 0; a < B_AUKSTIS; ++a)
  96.         {
  97.             for (int p = 0; p < B_PLOTIS; ++p)
  98.             {
  99.  
  100.                 if (p == 0)
  101.                     std::cout << a << "\t";
  102.                 if (p < 10 && p == 0)
  103.                     std::cout << " ";
  104.                 if (gameRunning == false)
  105.                     std::cout << zaidejas[thisPlayer].LENTA[p][a] << "  ";
  106.                 if (gameRunning == true && zaidejas[thisPlayer].LENTA[p][a] != laivas)
  107.                 {
  108.                     std::cout << zaidejas[thisPlayer].LENTA[p][a] << "  ";
  109.                 }
  110.                 else if (gameRunning == true && zaidejas[thisPlayer].LENTA[p][a] == laivas)
  111.                 {
  112.                     std::cout << vanduo << "  ";
  113.                 }
  114.  
  115.                 if (p == B_PLOTIS - 1)
  116.                     std::cout << "\n";
  117.             }
  118.         }
  119.     }
  120.  
  121.     virtual void NAUJAS_LAUKAS()
  122.     {
  123.         for (int zaid = 1; zaid < 3; ++zaid)
  124.         {
  125.             for (int p = 0; p < B_PLOTIS; ++p)
  126.             {
  127.                 for (int a = 0; a < B_AUKSTIS; ++a)
  128.                 {
  129.                     zaidejas[zaid].LENTA[p][a] = vanduo;
  130.                     std::cout << zaidejas[zaid].LENTA[p][a];//užpildomas tuščias žaidėjo laukas
  131.                 }
  132.             }
  133.         }
  134.     }
  135.  
  136.     virtual void NAUJI_LAIVAI()
  137.     {
  138.         ship[0].pavadinimas = "Pirmas";
  139.         ship[0].ilgis = 1;
  140.         ship[1].pavadinimas = "Antras";
  141.         ship[1].ilgis = 2;
  142.         ship[2].pavadinimas = "Trecias";
  143.         ship[2].ilgis = 3;
  144.         ship[3].pavadinimas = "Ketvirtas";
  145.         ship[3].ilgis = 4;
  146.         ship[4].pavadinimas = "Penktas";
  147.         ship[4].ilgis = 5;
  148.     }
  149. };
  150.  
  151. class Zaidejas : public Bendra
  152. {
  153. private:
  154.  
  155. public:
  156.  
  157.     Zaidejas() {}
  158.  
  159.     ~Zaidejas() {}
  160.  
  161.     bool UserInputAttack(int& x, int& y, int theplayer, int enemyPlayer)
  162.     {
  163.         std::cout << std::endl << "Zaidėjas " << theplayer << ", Įveskite kordinates norėdami užpulti x&y: ";
  164.         bool goodInput = false;
  165.         std::cin >> x >> y;
  166.         if (zaidejas[enemyPlayer].LENTA[x][y] == miss)
  167.             return goodInput;//
  168.         if (zaidejas[enemyPlayer].LENTA[x][y] == hit)
  169.             return goodInput;//
  170.         if (x < 0 || x >= B_PLOTIS)
  171.             return goodInput;//Tikrina ar įvestos koordinatės atitinka ribas ir ar jau ten nėra šovęs.
  172.         if (y < 0 || y >= B_AUKSTIS)
  173.             return goodInput;//
  174.         goodInput = true;
  175.         return goodInput;
  176.     }
  177.  
  178.     void PRADZIA()
  179.     {
  180.         for (int zaid = 1; zaid < 3; ++zaid)
  181.         {
  182.             for (int thisShip = 0; thisShip < LAIVU_KIEKIS; ++thisShip)
  183.             {
  184.                 system("cls");
  185.                 LAUKAS(zaid);
  186.                 std::cout << "\n";
  187.                 std::cout << "Instrukcija (Žaidėjas " << zaid << ")\n\n";
  188.                 std::cout << "Čia tau reikės sudelioti laivus.  Kaip dėlioti laivus parodyta apačioje:\n";
  189.                 std::cout << "Į kurią pusę žiūrės laivas (0:Horizontaliai,1:Verticaliai), X (Viršuje) koordinatės, Y (kairėje) koordinatės\n";
  190.                 std::cout << "Pavyzdys: 0 7 2    Tai padės laivo pradžią į tašką X:7 Y:2 horizontaliai\n\n";
  191.                 std::cout << "Laivo pavadinimas: " << ship[thisShip].pavadinimas << " Kurio ilgis: " << ship[thisShip].ilgis << "\n";
  192.                 std::cout << "Kur norite statyti laivą? ";
  193.  
  194.                 PLACESHIPS aLaivas;
  195.                 aLaivas.LaivoTipas.onGrid[0].X = -1;
  196.  
  197.                 while (aLaivas.LaivoTipas.onGrid[0].X == -1)
  198.                 {
  199.                     aLaivas = ZaidejasStatoLaivus(zaid);//nueina į metodą kuriame tikrina laivo stovėjimo salygas.
  200.                 }
  201.  
  202.                 aLaivas.LaivoTipas.ilgis = ship[thisShip].ilgis;
  203.                 aLaivas.LaivoTipas.pavadinimas = ship[thisShip].pavadinimas;
  204.                 zaidejas[zaid].LENTA[aLaivas.LaivoTipas.onGrid[0].X][aLaivas.LaivoTipas.onGrid[0].Y] = laivas;
  205.  
  206.                 for (int i = 1; i < aLaivas.LaivoTipas.ilgis; ++i)//Laivų statymas
  207.                 {
  208.                     if (aLaivas.direction == HORIZONTAL)
  209.                     {
  210.                         aLaivas.LaivoTipas.onGrid[i].X = aLaivas.LaivoTipas.onGrid[i - 1].X + 1;
  211.                         aLaivas.LaivoTipas.onGrid[i].Y = aLaivas.LaivoTipas.onGrid[i - 1].Y;
  212.                     }
  213.                     if (aLaivas.direction == VERTICAL)
  214.                     {
  215.                         aLaivas.LaivoTipas.onGrid[i].Y = aLaivas.LaivoTipas.onGrid[i - 1].Y + 1;
  216.                         aLaivas.LaivoTipas.onGrid[i].X = aLaivas.LaivoTipas.onGrid[i - 1].X;
  217.                     }
  218.                     zaidejas[zaid].LENTA[aLaivas.LaivoTipas.onGrid[i].X][aLaivas.LaivoTipas.onGrid[i].Y] = laivas;
  219.                 }
  220.             }//Laivu loopas
  221.             ZTLL = 0;//Keičia laivus statant žmogui, nusinulina, kai baigia statyti pirmas žaidėjas.
  222.         }//zaidejo loopas
  223.     }
  224.  
  225.     void GAMEON()
  226.     {
  227.         gameRunning = true;
  228.         int thisPlayer = 1;
  229.  
  230.         do
  231.         {
  232.             //rodome abu laukus todėl, kad laivai nėra rodomi ir gali tiesiog matyti vienas kito laukus visą laiką.
  233.             int enemyPlayer;
  234.             if (thisPlayer == 1)
  235.                 enemyPlayer = 2;
  236.             if (thisPlayer == 2)
  237.                 enemyPlayer = 1;
  238.             system("cls");
  239.             LAUKAS(1);
  240.             LAUKAS(2);
  241.  
  242.             //Gauname koordinates iš žaidėju
  243.             bool goodInput = false;
  244.             int x, y;
  245.             while (goodInput == false)
  246.             {
  247.                 goodInput = UserInputAttack(x, y, thisPlayer, enemyPlayer);
  248.             }
  249.  
  250.             //Tikriname ar yra laivas ir jei taip tai parodome, kad pataikė, o jei nėra, parodome kad nepataikė
  251.             if (zaidejas[enemyPlayer].LENTA[x][y] == laivas)
  252.             {
  253.                 zaidejas[enemyPlayer].LENTA[x][y] = hit;
  254.                 ishit = 1;
  255.             }
  256.             if (zaidejas[enemyPlayer].LENTA[x][y] == vanduo)
  257.             {
  258.                 zaidejas[enemyPlayer].LENTA[x][y] = miss;
  259.                 ishit = 0;
  260.             }
  261.             //Tikriname ar žaidimo niekas nelaimėjo
  262.             int aWin = GameOverCheck(enemyPlayer);
  263.             if (aWin != 0)
  264.             {
  265.                 gameRunning = false;
  266.                 break;
  267.             }
  268.             //TIkriname ar žaidėjas pataikė, jei ne, tada keičiasi ėjimai
  269.             thisPlayer = (thisPlayer == 1 && ishit != 1) ? thisPlayer : enemyPlayer;
  270.         } while (gameRunning);
  271.  
  272.         system("cls");
  273.         std::cout << "\n\n Sveikinimai!!!  Žaidėjas " << thisPlayer << " LAIMĖJO ŽAIDIMĄ!\n\n\n\n";
  274.     }
  275.  
  276. };
  277. class Kompiuteris : public Zaidejas  //kompiuterio stuff
  278. {
  279.  
  280. private:
  281.  
  282.     int hx, hy, sy, sx;
  283.  
  284. public:
  285.  
  286.     Kompiuteris() : hx(0), hy(0), sx(0), sy(0) {}
  287.     Kompiuteris(int) : hx(0), hy(0), sx(0), sy(0) {}
  288.     Kompiuteris(int, int) : hx(0), hy(0), sx(0), sy(0) {}
  289.     ~Kompiuteris() {}
  290.  
  291.     void pcpradzia()
  292.     {
  293.         for (int thisShip = 0; thisShip < LAIVU_KIEKIS; ++thisShip)
  294.         {
  295.             system("cls");
  296.             LAUKAS(2);
  297.             PLACESHIPS aLaivas;
  298.             aLaivas.LaivoTipas.onGrid[0].X = -1;
  299.             while (aLaivas.LaivoTipas.onGrid[0].X == -1)
  300.             {
  301.                 aLaivas = PCStatoLaivus(2);//kompiuteris stato random laivus
  302.             }
  303.             aLaivas.LaivoTipas.ilgis = ship[thisShip].ilgis;
  304.             aLaivas.LaivoTipas.pavadinimas = ship[thisShip].pavadinimas;
  305.             zaidejas[2].LENTA[aLaivas.LaivoTipas.onGrid[0].X][aLaivas.LaivoTipas.onGrid[0].Y] = laivas;
  306.             for (int i = 1; i < aLaivas.LaivoTipas.ilgis; ++i)
  307.             {
  308.                 if (aLaivas.direction == HORIZONTAL)
  309.                 {
  310.                     aLaivas.LaivoTipas.onGrid[i].X = aLaivas.LaivoTipas.onGrid[i - 1].X + 1;
  311.                     aLaivas.LaivoTipas.onGrid[i].Y = aLaivas.LaivoTipas.onGrid[i - 1].Y;
  312.                 }
  313.                 if (aLaivas.direction == VERTICAL)
  314.                 {
  315.                     aLaivas.LaivoTipas.onGrid[i].Y = aLaivas.LaivoTipas.onGrid[i - 1].Y + 1;
  316.                     aLaivas.LaivoTipas.onGrid[i].X = aLaivas.LaivoTipas.onGrid[i - 1].X;
  317.                 }
  318.                 zaidejas[2].LENTA[aLaivas.LaivoTipas.onGrid[i].X][aLaivas.LaivoTipas.onGrid[i].Y] = laivas;
  319.             }
  320.         }
  321.         ZTLL = 0;
  322.     }
  323.  
  324.     void vspcPRADZIA()  //žaidėjas stato vs pc laivus
  325.     {
  326.         for (int thisShip = 0; thisShip < LAIVU_KIEKIS; ++thisShip)
  327.         {
  328.             system("cls");
  329.             LAUKAS(1);
  330.  
  331.             std::cout << "\n";
  332.             std::cout << "Tavo instrukcija\n\n";
  333.             std::cout << "Čia tau reikės sudelioti laivus.  Kaip dėlioti laivus parodyta apačioje:\n";
  334.             std::cout << "Į kurią pusę žiūrės laivas (0:Horizontaliai,1:Verticaliai), X (Viršuje) koordinatės, Y (kairėje) koordinatės\n";
  335.             std::cout << "Pavyzdys: 0 7 2    Tai padės laivo pradžią į tašką X:7 Y:2 horizontaliai\n\n";
  336.             std::cout << "Laivo pavadinimas: " << ship[thisShip].pavadinimas << " Kurio ilgis: " << ship[thisShip].ilgis << "\n";
  337.             std::cout << "Kur norite statyti laivą? ";
  338.  
  339.             PLACESHIPS aLaivas;
  340.  
  341.             aLaivas.LaivoTipas.onGrid[0].X = -1;
  342.  
  343.             while (aLaivas.LaivoTipas.onGrid[0].X == -1)
  344.             {
  345.                 aLaivas = ZaidejasStatoLaivus(1);//žaidėjas stato laivus
  346.             }
  347.  
  348.             aLaivas.LaivoTipas.ilgis = ship[thisShip].ilgis;
  349.             aLaivas.LaivoTipas.pavadinimas = ship[thisShip].pavadinimas;
  350.             zaidejas[1].LENTA[aLaivas.LaivoTipas.onGrid[0].X][aLaivas.LaivoTipas.onGrid[0].Y] = laivas;
  351.  
  352.             for (int i = 1; i < aLaivas.LaivoTipas.ilgis; ++i)
  353.             {
  354.                 if (aLaivas.direction == HORIZONTAL)
  355.                 {
  356.                     aLaivas.LaivoTipas.onGrid[i].X = aLaivas.LaivoTipas.onGrid[i - 1].X + 1;
  357.                     aLaivas.LaivoTipas.onGrid[i].Y = aLaivas.LaivoTipas.onGrid[i - 1].Y;
  358.                 }
  359.                 if (aLaivas.direction == VERTICAL)
  360.                 {
  361.                     aLaivas.LaivoTipas.onGrid[i].Y = aLaivas.LaivoTipas.onGrid[i - 1].Y + 1;
  362.                     aLaivas.LaivoTipas.onGrid[i].X = aLaivas.LaivoTipas.onGrid[i - 1].X;
  363.                 }
  364.                 zaidejas[1].LENTA[aLaivas.LaivoTipas.onGrid[i].X][aLaivas.LaivoTipas.onGrid[i].Y] = laivas;
  365.             }
  366.         }//Laivu loopas
  367.         ZTLL = 0;
  368.     }
  369.     void pcGAMEON()
  370.     {
  371.         gameRunning = true;
  372.         int thisPlayer = 1;
  373.         do
  374.         {
  375.             //Rodome abi lentas, kad matytu kur šaudo kompiuteris ir kur šaudo jis pats.
  376.             //Laivai nėra rodomi.
  377.             int enemyPlayer;
  378.             if (thisPlayer == 1)
  379.                 enemyPlayer = 2;
  380.             if (thisPlayer == 2)
  381.                 enemyPlayer = 1;
  382.             system("cls");
  383.             LAUKAS(thisPlayer);
  384.             LAUKAS(enemyPlayer);
  385.  
  386.             int x, y;
  387.             //Priklauso kas atakuoja, iš ten ir ims Input'a
  388.             if (thisPlayer == 1)//žaidėjas
  389.             {
  390.                 bool goodInput = false;
  391.                 while (goodInput == false)
  392.                 {
  393.                     goodInput = UserInputAttack(x, y, thisPlayer, enemyPlayer);//Jei žaidėjas, tai jis pats turės įrašyti input'a
  394.                 }
  395.                 //tikrina ar pataikė ar ne
  396.                 if (zaidejas[enemyPlayer].LENTA[x][y] == laivas)
  397.                 {
  398.                     zaidejas[enemyPlayer].LENTA[x][y] = hit;
  399.                     ishit = 1;
  400.                 }
  401.                 if (zaidejas[enemyPlayer].LENTA[x][y] == vanduo)
  402.                 {
  403.                     zaidejas[enemyPlayer].LENTA[x][y] = miss;
  404.                     ishit = 0;
  405.                 }
  406.             }
  407.  
  408.             if (thisPlayer == 2)//čia kompiuteris
  409.             {
  410.                 bool goodInput = false;
  411.                 while (goodInput == false)
  412.                 {
  413.                     goodInput = PcInputAttack(hx, hy, thisPlayer, enemyPlayer);//Kompiuteris automatiškai šaudo
  414.                 }
  415.                 //tikrina ar pataikė ar ne
  416.                 if (zaidejas[enemyPlayer].LENTA[hx][hy] == laivas)
  417.                 {
  418.                     zaidejas[enemyPlayer].LENTA[hx][hy] = hit;
  419.                     ishit = 1;
  420.                 }
  421.                 if (zaidejas[enemyPlayer].LENTA[hx][hy] == vanduo)
  422.                 {
  423.                     zaidejas[enemyPlayer].LENTA[hx][hy] = miss;
  424.                     ishit = 0;
  425.                 }
  426.             }
  427.  
  428.             //tikrina ar žaidimas nepasibaigė
  429.             int aWin = GameOverCheck(enemyPlayer);
  430.             if (aWin != 0)
  431.             {
  432.                 gameRunning = false;
  433.                 break;
  434.             }
  435.             //Alternatyva tarp žaidėjų
  436.             thisPlayer = (ishit == 1) ? thisPlayer : enemyPlayer;
  437.         } while (gameRunning);
  438.  
  439.         system("cls");
  440.         if (thisPlayer == 1)
  441.             std::cout << "\n\nSVEIKINIMAI !!!  JŪS ĮVEIKĖTE KOMPIUTERĮ!\n\n\n\n";
  442.         else
  443.             std::cout << "Dėje jūs pralaimėjote, o kompiuteris laimėjo žaidimą!" << std::endl;
  444.     }
  445.     bool PcInputAttack(int& hx, int& hy, int theplayer, int enemyPlayer)
  446.     {
  447.         int bandymas = 0;
  448.         int px = sx - 1;
  449.         int py = sy - 1;
  450.         if (sx == 0)
  451.             px = 0;
  452.         if (sy == 0)
  453.             py = 0;
  454.         for (int i = py; i <= py + 2; i++)//Tikrina ar aplink šautą tašką yra laivų
  455.         {
  456.             for (int j = px; j <= px + 2; j++)
  457.             {
  458.                 if (zaidejas[enemyPlayer].LENTA[j][i] == laivas)
  459.                 {
  460.                     bandymas++;
  461.                 }
  462.             }
  463.         }
  464.         if (zaidejas[enemyPlayer].LENTA[hx][hy] == hit) //Jei pataikė, žiūri kur yra kitas laivas
  465.         {
  466.             bool goodInput = false;
  467.             int px = hx - 1;
  468.             int py = hy - 1;
  469.             if (hx == 0)
  470.                 px = 0;
  471.             if (hy == 0)
  472.                 py = 0;
  473.             for (int i = py; i <= py + 2; i++)
  474.             {
  475.                 for (int j = px; j <= px + 2; j++)
  476.                 {
  477.                     if (zaidejas[enemyPlayer].LENTA[j][i] == laivas)
  478.                     {
  479.                         hx = j;
  480.                         hy = i;
  481.                         goodInput = true;
  482.                         return goodInput;
  483.                         break;
  484.                     }
  485.                 }
  486.             }
  487.             hx = rand() % B_PLOTIS;
  488.             hy = rand() % B_AUKSTIS;
  489.         }
  490.         else if (zaidejas[enemyPlayer].LENTA[sx][sy] == hit && bandymas != 0)// jei buvo pataikyta į laivą ir dar yra aplinkui laivų, šaus į tą laivą.
  491.         {
  492.             bool goodInput = false;
  493.             int px = sx - 1;
  494.             int py = sy - 1;
  495.             if (sx == 0)
  496.                 px = 0;
  497.             if (sy == 0)
  498.                 py = 0;
  499.             for (int i = py; i <= py + 2; i++)
  500.             {
  501.                 for (int j = px; j <= px + 2; j++)
  502.                 {
  503.                     if (zaidejas[enemyPlayer].LENTA[j][i] == laivas)
  504.                     {
  505.                         hx = j;
  506.                         hy = i;
  507.                         goodInput = true;
  508.                         return goodInput;
  509.                         break;
  510.                     }
  511.                 }
  512.             }
  513.             hx = rand() % B_PLOTIS;
  514.             hy = rand() % B_AUKSTIS;
  515.         }
  516.         else//Jei nė viena salyga netinka, sugalvos random koordinates
  517.         {
  518.             bool goodInput = false;
  519.             hx = rand() % B_PLOTIS;
  520.             hy = rand() % B_AUKSTIS;
  521.             if (zaidejas[enemyPlayer].LENTA[hx][hy] == miss && zaidejas[enemyPlayer].LENTA[hx][hy] == hit)
  522.                 return goodInput;
  523.             if (hx < 0 || hx >= B_PLOTIS)
  524.                 return goodInput;
  525.             if (hy < 0 || hy >= B_AUKSTIS)
  526.                 return goodInput;
  527.             if (zaidejas[enemyPlayer].LENTA[hx][hy] == laivas)
  528.             {
  529.                 sx = hx;
  530.                 sy = hy;
  531.             }
  532.             goodInput = true;
  533.             return goodInput;
  534.         }
  535.     }
  536. };
  537. int main()
  538. {
  539.     srand( time( NULL ) );
  540.  
  541.     Zaidejas Z;
  542.     Kompiuteris PC;
  543.  
  544.     int a;
  545.  
  546.     std::cout << "Prieš ką norite žaisti?" << std::endl;
  547.     std::cout << "Spauskite 1 norėdami žaisti žaidėjas prieš žaidėją." << std::endl;
  548.     std::cout << "Spauskite 2 norėdami žaisti prieš kompiuterį." << std::endl;
  549.     std::cin >> a;
  550.  
  551.     if (a == 1)
  552.     {
  553.         Z.NAUJI_LAIVAI();
  554.         Z.NAUJAS_LAUKAS();
  555.         Z.PRADZIA();
  556.         Z.GAMEON();
  557.     }
  558.     else
  559.     {
  560.         PC.NAUJI_LAIVAI();
  561.         PC.NAUJAS_LAUKAS();
  562.         PC.vspcPRADZIA();
  563.         PC.pcpradzia();
  564.         PC.pcGAMEON();
  565.     }
  566. }
  567.  
  568.  
  569. PLACESHIPS ZaidejasStatoLaivus( int zaid )
  570. {
  571.     int d, x, y;
  572.     int laikx, laiky, yraLaivu = 0;
  573.     yraLaivu = 0;
  574.     PLACESHIPS tmp;
  575.     tmp.LaivoTipas.onGrid[0].X = -1;
  576.     std::cin >> d >> x >> y;
  577.     if (d != 0 && d != 1)
  578.     {
  579.         std::cout << "Įvedėte neteisingą -d- reikšmę" << std::endl;
  580.         return tmp;
  581.     }
  582.     if (d == 0)
  583.     {
  584.         int prax = x - 1;
  585.         int pray = y - 1;
  586.  
  587.         int galasx = ship[ZTLL].ilgis + 2 + prax;
  588.         int galasy = pray + 3;
  589.  
  590.         if (x - 1 < 0)
  591.             prax = 0;
  592.         if (y - 1 < 0)
  593.             pray = 0;
  594.  
  595.         if (galasy > B_AUKSTIS)
  596.             galasy = B_AUKSTIS;
  597.         if (galasx > B_PLOTIS)
  598.             galasx = B_PLOTIS;
  599.  
  600.         for (int i = pray; i < galasy; i++)//tikrina ar yra laivų šalia
  601.         {
  602.             for (int j = prax; j < galasx; j++)
  603.             {
  604.                 if (zaidejas[zaid].LENTA[j][i] == laivas)
  605.                 {
  606.                     yraLaivu++;
  607.                 }
  608.             }
  609.         }
  610.         if (yraLaivu != 0)
  611.         {
  612.             std::cout << "Negalite čia statyti laivo, nes arti yra kitas laivas." << std::endl;
  613.             return tmp;
  614.         }
  615.         if (x < 0 || x > B_PLOTIS - ship[ZTLL].ilgis)
  616.         {
  617.             std::cout << "Laivas išlenda X koordinatėje." << std::endl;
  618.             return tmp;
  619.         };
  620.         if (y < 0 || y > B_AUKSTIS)
  621.         {
  622.             std::cout << "Laivas išlenda Y koordinatėje." << std::endl;
  623.             return tmp;
  624.         };
  625.     }
  626.     if (d == 1)
  627.     {
  628.         int prax = x - 1;
  629.         int pray = y - 1;
  630.         int galasy = ship[ZTLL].ilgis + 2 + pray;
  631.         int galasx = prax + 3;
  632.         if (x == 0)
  633.             prax = 0;
  634.         if (y == 0)
  635.             pray = 0;
  636.         if (galasy > B_AUKSTIS)
  637.             galasy = B_AUKSTIS;
  638.         if (galasx > B_PLOTIS)
  639.             galasx = B_PLOTIS;
  640.         for (int i = prax; i < galasx; i++)//tikrina artimus laivus
  641.         {
  642.             for (int j = pray; j < galasy; j++)
  643.             {
  644.                 if (zaidejas[zaid].LENTA[i][j] == laivas)
  645.                 {
  646.                     yraLaivu++;
  647.                 }
  648.             }
  649.         }
  650.         if (yraLaivu != 0)
  651.         {
  652.             std::cout << "Negalite čia statyti laivo, nes arti yra kitas laivas." << std::endl;
  653.             return tmp;
  654.         }
  655.         if (x < 0 || x > B_PLOTIS)
  656.         {
  657.             std::cout << "Laivas išlenda X koordinatėje." << std::endl;
  658.             return tmp;
  659.         }
  660.         if (y < 0 || y > B_AUKSTIS - ship[ZTLL].ilgis)
  661.         {
  662.             std::cout << "Laivas išlenda Y koordinatėje." << std::endl;
  663.             return tmp;
  664.         }
  665.     }
  666.     tmp.direction = (DIRECTION)d;
  667.     tmp.LaivoTipas.onGrid[0].X = x;
  668.     tmp.LaivoTipas.onGrid[0].Y = y;
  669.     ZTLL++;
  670.     return tmp;
  671. }
  672.  
  673. PLACESHIPS PCStatoLaivus(int zaid)
  674. {
  675.     int d, x, y;
  676.     int laikx, laiky, yraLaivu = 0;
  677.  
  678.     d = rand() % 2;
  679.     x = rand() % B_PLOTIS;
  680.     y = rand() % B_AUKSTIS;
  681.     yraLaivu = 0;
  682.  
  683.     PLACESHIPS tmp;
  684.     tmp.LaivoTipas.onGrid[0].X = -1;
  685.     if (d != 0 && d != 1)
  686.         return tmp;
  687.     if (d == 0)
  688.     {
  689.         int prax = x - 1;
  690.         int pray = y - 1;
  691.         int galasx = ship[ZTLL].ilgis + 2 + prax;
  692.         int galasy = pray + 3;
  693.         if (x - 1 < 0)
  694.             prax = 0;
  695.         if (y - 1 < 0)
  696.             pray = 0;
  697.         if (galasy > B_AUKSTIS)
  698.             galasy = B_AUKSTIS;
  699.         if (galasx > B_PLOTIS)
  700.             galasx = B_PLOTIS;
  701.         for (int i = pray; i < galasy; i++)
  702.         {
  703.             for (int j = prax; j < galasx; j++)
  704.             {
  705.                 if (zaidejas[zaid].LENTA[j][i] == laivas)
  706.                 {
  707.                     yraLaivu++;
  708.                 }
  709.             }
  710.         }
  711.         if (yraLaivu != 0)
  712.             return tmp;
  713.         if (x < 0 || x > B_PLOTIS - ship[ZTLL].ilgis)
  714.             return tmp;
  715.         if (y < 0 || y > B_AUKSTIS)
  716.             return tmp;
  717.     }
  718.     if (d == 1)
  719.     {
  720.         int prax = x - 1;
  721.         int pray = y - 1;
  722.         int galasy = ship[ZTLL].ilgis + 2 + pray;
  723.         int galasx = prax + 3;
  724.         if (x - 1 < 0)
  725.             prax = 0;
  726.         if (y - 1 < 0)
  727.             pray = 0;
  728.         if (galasy > B_AUKSTIS)
  729.             galasy = B_AUKSTIS;
  730.         if (galasx > B_PLOTIS)
  731.             galasx = B_PLOTIS;
  732.         for (int i = prax; i < galasx; i++)
  733.         {
  734.             for (int j = pray; j < galasy; j++)
  735.             {
  736.                 if (zaidejas[zaid].LENTA[i][j] == laivas)
  737.                 {
  738.                     yraLaivu++;
  739.                 }
  740.             }
  741.         }
  742.         if (yraLaivu != 0)
  743.             return tmp;
  744.         if (x < 0 || x > B_PLOTIS)
  745.             return tmp;
  746.         if (y < 0 || y > B_AUKSTIS - ship[ZTLL].ilgis)
  747.             return tmp;
  748.     }
  749.     tmp.direction = (DIRECTION)d;
  750.     tmp.LaivoTipas.onGrid[0].X = x;
  751.     tmp.LaivoTipas.onGrid[0].Y = y;
  752.     ZTLL++;
  753.     return tmp;
  754. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!