API tools faq
paste
Hakunin

RT2815.v1.07

Hakunin
Jan 9th, 2017
108
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.02 KB | None | 0 0
raw download clone embed print report
  1. //Marko Jovanović RT-28/15
  2.  
  3. #include <fstream>
  4. #include <iostream>
  5. #include <string>
  6. #include <stdlib.h>
  7. #include <conio.h>
  8. #include <time.h>
  9. #include <Windows.h>
  10.  
  11.  
  12.  
  13. //svi ovi karakteri predstavljaju različite zidove, komentarisani su zato sto su mi potrebni samo kao beleska
  14. //#define top_left_corner_wall 201 // karakter ╔
  15. //#define top_right_corner_wall 187 // karakter ╗
  16. //#define bottom_left_corner_wall 200 // karakter ╚
  17. //#define bottom_right_corner_wall 188 // karakter ╝
  18. //#define vertical_wall 186 // karakter ║
  19. //#define horizontal_wall 205 // karakter ═
  20. //#define top_junction_wall 202 // karakter ╩
  21. //#define bottom_junction_wall 203 // karakter ╦
  22. //#define left_junction_wall 186 // karakter ╣
  23. //#define right_junction_wall 204 // karakter ╠
  24. //#define junction_wall 206 // karakter ╬
  25.  
  26. //ovi karakteri predstavljaju teren po kome igrač može da se kreće
  27. #define terrain_safe 46 // karakter .
  28. #define terrain_trap 42 // karakter *
  29. #define terrain_exit 44 // karakter ,
  30.  
  31. //ovi  karakteri predstavljaju stvorenja u igri i igrača
  32. #define character_player 33 // karakter !
  33. #define character_merchant 77 // karakter M
  34. #define mob_orc 79 // karakter O
  35. #define mob_troll 84 // karakter T
  36. #define mob_wraith 87 // karakter W
  37. #define mob_zombie 90 // karakter Z
  38.  
  39. #define object_locked_door_vertical 124 // karakter "|", koji prestavlja zaključana vrata(vertikalna)
  40. #define object_locked_door_horizontal char(196) // karakter "─", koji predstavlja zaključana vrata(horizontalna) //karakteri veci od 127 moraju da se forsiraju u char
  41. #define object_lootchest 67 // karakter "C", koji predstavlja kovčeg
  42. #define object_lever 76 // karakter "L", koji predstavlja polugu
  43.  
  44. #define placeholder_wall 43 // karakter "+" ; bice obrisano, predstavlja zid
  45.  
  46. #define LEVEL_HEIGHT 17
  47. #define LEVEL_WIDTH 25
  48.  
  49. //definisanje input tastera
  50.  
  51. #define KEY_UP 72  //taster "strelica gore"
  52. #define KEY_DOWN 80 //taster "strelica dole"
  53. #define KEY_LEFT 75 //taster "strelica levo"
  54. #define KEY_RIGHT 77 //taster "strelica desno"
  55. #define KEY_USE 101 //taster "e"
  56. #define KEY_ATTACK 97 //taster "a"
  57.  
  58.  
  59. using namespace std;
  60.  
  61.  
  62. //funkcija koja proverava da li je jedan objekat uz drugi objekat u igri (traži se "item" oko pozvanih koordinata)
  63. bool check_near(char map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y, int item)
  64. {
  65.     if ((map[x + 1][y]) == item
  66.         || (map[x - 1][y]) == item
  67.         || (map[x][y + 1]) == item
  68.         || (map[x][y - 1]) == item
  69.         || (map[x + 1][y + 1]) == item
  70.         || (map[x - 1][y + 1]) == item
  71.         || (map[x - 1][y + 1]) == item
  72.         || (map[x - 1][y - 1] == item))
  73.         return true;
  74.     else
  75.         return false;
  76. }
  77.  
  78. //funkcija za crtanje mape
  79. void draw_map(char map[LEVEL_HEIGHT][LEVEL_WIDTH],int hp, int max_hp)
  80. {
  81.     cout << "\n";
  82.     for (int i = 0; i<LEVEL_HEIGHT; i++)
  83.     {
  84.         std::cout << "\t\t";
  85.         for (int j = 0; j<LEVEL_WIDTH; j++)
  86.         {
  87.             std::cout << map[i][j];
  88.         }
  89.         std::cout << endl;
  90.     }
  91.     std::cout << "\n\ttrenutno zivota: " << hp << "/" << max_hp << endl;
  92. }
  93.  
  94.  
  95. //funkcija za pomeranje na gore
  96. void move_up(char map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y)
  97. {
  98.     if (map[x - 1][y] == terrain_safe)
  99.     {
  100.         map[x - 1][y] = character_player;
  101.         map[x][y] = terrain_safe;
  102.         x--;
  103.     }
  104. }
  105.  
  106. //funkcija za pomeranje na dole
  107. void move_down(char map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y)
  108. {
  109.     if (map[x + 1][y] == terrain_safe)
  110.     {
  111.         map[x + 1][y] = character_player;
  112.         map[x][y] = terrain_safe;
  113.         x++;
  114.     }
  115.  
  116. }
  117.  
  118. //funkcija za pomeranje na levo
  119. void move_left(char map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y)
  120. {
  121.     if (map[x][y - 1] == terrain_safe)
  122.     {
  123.         map[x][y - 1] = character_player;
  124.         map[x][y] = terrain_safe;
  125.         y--;
  126.     }
  127. }
  128. //funkcija za pomeranje na desno
  129. void move_right(char map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y)
  130. {
  131.     if (map[x][y + 1] == terrain_safe)
  132.     {
  133.         map[x][y + 1] = character_player;
  134.         map[x][y] = terrain_safe;
  135.         y++;
  136.     }
  137. }
  138.  
  139. //funckija za taster e (taster za korišćenje)
  140. void use(char map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y)
  141. {
  142.     //u slucaju da je uz lika iz igre poluga
  143.     if (check_near(map, x, y, object_lever))
  144.     {
  145.         for (int i = 0; i < LEVEL_HEIGHT; i++)
  146.         {
  147.             for (int j = 0; j < LEVEL_WIDTH; j++)
  148.             {
  149.                 if ((map[i][j] == object_locked_door_vertical) | (map[i][j] == object_locked_door_horizontal))
  150.                     map[i][j] = terrain_safe;
  151.             }
  152.         }
  153.     }
  154. }
  155.  
  156.  
  157. //funkcija za utvrđivanje da li je igračev potez
  158. bool player_turn(int count)
  159. {
  160.     count = count % 4;
  161.  
  162.     if (count == 0 || count == 1)
  163.         return true;
  164.     else
  165.         return false;
  166. }
  167.  
  168. //funkcija koja pokrece wraith/duh neprijatelja, TODO: UDARANJE IGRACA KAD JE BLIZU!!
  169. void wraith_ai(char map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y,int px,int py, int &hp)
  170. {
  171.     if (check_near(map, x, y, character_player))
  172.     {
  173.         hp = hp - 10; //TRENUTNA STETA KOJU DUH PRAVI IGRACU
  174.     }
  175.     else
  176.     {
  177.         int r = rand() % 4;
  178.         switch (r)
  179.         {
  180.         case 0:
  181.             if (map[x - 1][y] == terrain_safe)
  182.             {
  183.                 map[x - 1][y] = mob_wraith;
  184.                 map[x][y] = terrain_safe;
  185.                 x--;
  186.             }
  187.             break;
  188.         case 1:
  189.             if (map[x + 1][y] == terrain_safe)
  190.             {
  191.                 map[x + 1][y] = mob_wraith;
  192.                 map[x][y] = terrain_safe;
  193.                 x++;
  194.             }
  195.             break;
  196.         case 2:
  197.             if (map[x][y - 1] == terrain_safe)
  198.             {
  199.                 map[x][y - 1] = mob_wraith;
  200.                 map[x][y] = terrain_safe;
  201.                 y--;
  202.             }
  203.             break;
  204.         case 3:
  205.             if (map[x][y + 1] == terrain_safe)
  206.             {
  207.                 map[x][y + 1] = mob_wraith;
  208.                 map[x][y] = terrain_safe;
  209.                 y++;
  210.             }
  211.             break;
  212.         }
  213.     }
  214. }
  215.  
  216. //funkcija koja pokrece zombie/"zivog mrtvaka" neprijatelja, TODO: UDARANJE IGRACA KAD JE BLIZU!!
  217. void zombie_ai(char map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y, int &px, int &py, int &hp)
  218. {
  219.     if (check_near(map, x, y, character_player))
  220.     {
  221.         hp = hp - 2; //TRENUTNA STETA KOJU ZOMBI PRAVI IGRACU
  222.     }
  223.     else
  224.     {
  225.         if (abs(x - px) == abs(y - py)) //ako su razdaljine razlika (gore-dole i levo-desno) jednake
  226.         {
  227.             if (py < y) //zombi levo
  228.             {
  229.                 if (map[x][y - 1] == terrain_safe)
  230.                 {
  231.                     map[x][y - 1] = mob_zombie;
  232.                     map[x][y] = terrain_safe;
  233.                     y--;
  234.                 }
  235.             }
  236.             else if (py > y) //zombi desno
  237.             {
  238.                 if (map[x][y + 1] == terrain_safe)
  239.                 {
  240.                     map[x][y + 1] = mob_zombie;
  241.                     map[x][y] = terrain_safe;
  242.                     y++;
  243.                 }
  244.             }
  245.  
  246.         }
  247.         else  if (((abs(x - px)) < (abs(y - py))) && (py < y)) //zombi levo
  248.         {
  249.             if (map[x][y - 1] == terrain_safe)
  250.             {
  251.                 map[x][y - 1] = mob_zombie;
  252.                 map[x][y] = terrain_safe;
  253.                 y--;
  254.             }
  255.         }
  256.         else if (((abs(x - px)) < abs((y - py))) && (py > y)) //zombi desno
  257.         {
  258.             if (map[x][y + 1] == terrain_safe)
  259.             {
  260.                 map[x][y + 1] = mob_zombie;
  261.                 map[x][y] = terrain_safe;
  262.                 y++;
  263.             }
  264.         }
  265.         else if (((abs(x - px) > (abs(y - py))) && (px < x))) //zombi gore
  266.         {
  267.             if (map[x - 1][y] == terrain_safe)
  268.             {
  269.                 map[x - 1][y] = mob_zombie;
  270.                 map[x][y] = terrain_safe;
  271.                 x--;
  272.             }
  273.         }
  274.         else if (((abs(x - px) > (abs(y - py))) && (px > x))) // zombi dole
  275.         {
  276.             if (map[x + 1][y] == terrain_safe)
  277.             {
  278.                 map[x + 1][y] = mob_zombie;
  279.                 map[x][y] = terrain_safe;
  280.                 x++;
  281.             }
  282.  
  283.         }
  284.     }
  285. }
  286.  
  287. //funckija koja pokreće orkove, TODO: UDARANJE IGRAČA
  288. void orc_ai(char map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y, int &px, int &py, int &hp)
  289. {
  290.     if (check_near(map, x, y, character_player))
  291.     {
  292.         hp = hp - 4; //TRENUTNA STETA KOJU ORK PRAVI IGRACU
  293.     }
  294.     else
  295.     {
  296.         if (abs(x - px) < 5 && abs(y - py) < 5) //ork se aktivira ako igrač priđe bliže od 4 kocke
  297.         {
  298.             if (abs(x - px) == abs(y - py)) //ako su razdaljine razlika (gore-dole i levo-desno) jednake
  299.             {
  300.                 if (py < y) //ork levo
  301.                 {
  302.                     if (map[x][y - 1] == terrain_safe)
  303.                     {
  304.                         map[x][y - 1] = mob_orc;
  305.                         map[x][y] = terrain_safe;
  306.                         y--;
  307.                     }
  308.                 }
  309.                 else if (py > y) //ork desno
  310.                 {
  311.                     if (map[x][y + 1] == terrain_safe)
  312.                     {
  313.                         map[x][y + 1] = mob_orc;
  314.                         map[x][y] = terrain_safe;
  315.                         y++;
  316.                     }
  317.                 }
  318.  
  319.             }
  320.             else  if (((abs(x - px)) < (abs(y - py))) && (py < y)) //ork levo
  321.             {
  322.                 if (map[x][y - 1] == terrain_safe)
  323.                 {
  324.                     map[x][y - 1] = mob_orc;
  325.                     map[x][y] = terrain_safe;
  326.                     y--;
  327.                 }
  328.             }
  329.             else if (((abs(x - px)) < abs((y - py))) && (py > y)) //ork desno
  330.             {
  331.                 if (map[x][y + 1] == terrain_safe)
  332.                 {
  333.                     map[x][y + 1] = mob_orc;
  334.                     map[x][y] = terrain_safe;
  335.                     y++;
  336.                 }
  337.             }
  338.             else if (((abs(x - px) > (abs(y - py))) && (px < x))) //ork gore
  339.             {
  340.                 if (map[x - 1][y] == terrain_safe)
  341.                 {
  342.                     map[x - 1][y] = mob_orc;
  343.                     map[x][y] = terrain_safe;
  344.                     x--;
  345.                 }
  346.             }
  347.             else if (((abs(x - px) > (abs(y - py))) && (px > x))) //ork dole
  348.             {
  349.                 if (map[x + 1][y] == terrain_safe)
  350.                 {
  351.                     map[x + 1][y] = mob_orc;
  352.                     map[x][y] = terrain_safe;
  353.                     x++;
  354.                 }
  355.  
  356.             }
  357.  
  358.         }
  359.     }
  360. }
  361.  
  362. //funkcija koja pokreće trolove, TODO: UDARANJE IGRAČA
  363. void troll_ai(char map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y, int &px, int &py, int&hp)
  364. {
  365.     if (check_near(map, x, y, character_player))
  366.     {
  367.         hp = hp - 6; //TRENUTNA STETA KOJU PRAVI TROL
  368.     }
  369.     {
  370.         int r = rand() % 4;
  371.         if (abs(x - px) < 3 && abs(y - py) < 3) //ako igrač priđe blize od 3 koraka trol se aktivira
  372.         {
  373.             if (abs(x - px) == abs(y - py)) //ako su razdaljine razlika (gore-dole i levo-desno) jednake
  374.             {
  375.                 if (py < y) //troll levo
  376.                 {
  377.                     if (map[x][y - 1] == terrain_safe)
  378.                     {
  379.                         map[x][y - 1] = mob_troll;
  380.                         map[x][y] = terrain_safe;
  381.                         y--;
  382.                     }
  383.                 }
  384.                 else if (py > y) //troll desno
  385.                 {
  386.                     if (map[x][y + 1] == terrain_safe)
  387.                     {
  388.                         map[x][y + 1] = mob_troll;
  389.                         map[x][y] = terrain_safe;
  390.                         y++;
  391.                     }
  392.                 }
  393.  
  394.             }
  395.             else  if (((abs(x - px)) < (abs(y - py))) && (py < y)) //troll levo
  396.             {
  397.                 if (map[x][y - 1] == terrain_safe)
  398.                 {
  399.                     map[x][y - 1] = mob_troll;
  400.                     map[x][y] = terrain_safe;
  401.                     y--;
  402.                 }
  403.             }
  404.             else if (((abs(x - px)) < abs((y - py))) && (py > y)) //troll desno
  405.             {
  406.                 if (map[x][y + 1] == terrain_safe)
  407.                 {
  408.                     map[x][y + 1] = mob_troll;
  409.                     map[x][y] = terrain_safe;
  410.                     y++;
  411.                 }
  412.             }
  413.             else if (((abs(x - px) > (abs(y - py))) && (px < x))) //troll gore
  414.             {
  415.                 if (map[x - 1][y] == terrain_safe)
  416.                 {
  417.                     map[x - 1][y] = mob_troll;
  418.                     map[x][y] = terrain_safe;
  419.                     x--;
  420.                 }
  421.             }
  422.             else if (((abs(x - px) > (abs(y - py))) && (px > x))) //troll dole
  423.             {
  424.                 if (map[x + 1][y] == terrain_safe)
  425.                 {
  426.                     map[x + 1][y] = mob_troll;
  427.                     map[x][y] = terrain_safe;
  428.                     x++;
  429.                 }
  430.  
  431.             }
  432.  
  433.         }
  434.         else
  435.         {
  436.             switch (r)
  437.             {
  438.             case 0:
  439.                 if (map[x - 1][y] == terrain_safe)
  440.                 {
  441.                     map[x - 1][y] = mob_troll;
  442.                     map[x][y] = terrain_safe;
  443.                     x--;
  444.                 }
  445.                 break;
  446.             case 1:
  447.                 if (map[x + 1][y] == terrain_safe)
  448.                 {
  449.                     map[x + 1][y] = mob_troll;
  450.                     map[x][y] = terrain_safe;
  451.                     x++;
  452.                 }
  453.                 break;
  454.             case 2:
  455.                 if (map[x][y - 1] == terrain_safe)
  456.                 {
  457.                     map[x][y - 1] = mob_troll;
  458.                     map[x][y] = terrain_safe;
  459.                     y--;
  460.                 }
  461.                 break;
  462.             case 3:
  463.                 if (map[x][y + 1] == terrain_safe)
  464.                 {
  465.                     map[x][y + 1] = mob_troll;
  466.                     map[x][y] = terrain_safe;
  467.                     y++;
  468.                 }
  469.                 break;
  470.             }
  471.         }
  472.     }
  473. }
  474.  
  475. int main() {
  476.  
  477.     system("mode 150");
  478.     char  maplogic[LEVEL_HEIGHT][LEVEL_WIDTH];
  479.     int i, j;
  480.     int player_position_x, player_position_y, wraith_position_x, wraith_position_y, zombie_position_x, zombie_position_y;
  481.     int orc_position_x, orc_position_y, troll_position_x, troll_position_y;
  482.     int c, max_health, current_health, turn_count;
  483.     srand(time(NULL));
  484.     // placeholder ucitavanje mape (nivoi ce se ucitavati iz struct),  ovaj deo koda se brise
  485.  
  486. new_game: // labela za pocinjanje nove igre (nadam se da cu smisliti pametniji nacin)
  487.  
  488.     turn_count = 0;
  489.  
  490.     player_position_x = 10;
  491.     player_position_y = 9;
  492.     wraith_position_x = 8;
  493.     wraith_position_y = 22;
  494.     zombie_position_x = 15;
  495.     zombie_position_y = 11;
  496.     orc_position_x = 3;
  497.     orc_position_y = 21;
  498.     troll_position_x = 15;
  499.     troll_position_y = 21;
  500.  
  501.     //struct monster
  502.     //{
  503.     //  int x;
  504.     //  int y;
  505.     //  int hp;
  506.     //};
  507.  
  508.     //monster orc;
  509.     //orc.x = 5;
  510.     //orc.y = 10;
  511.     //orc.hp = 35;
  512.  
  513.     max_health = 60;
  514.     current_health = 60;
  515.  
  516.     for (i = 0; i < LEVEL_HEIGHT; i++)
  517.     {
  518.         for (j = 0; j < LEVEL_WIDTH; j++)
  519.         {
  520.             if (i == player_position_x && j == player_position_y)
  521.                 maplogic[i][j] = character_player;
  522.             else if (i == 0 || j == 0 || i == (LEVEL_HEIGHT - 1) || j == (LEVEL_WIDTH - 1))
  523.                 maplogic[i][j] = placeholder_wall;
  524.             else if (j == 20)
  525.                 maplogic[i][j] = object_locked_door_vertical;
  526.             else if (j == 5 && i == 5)
  527.                 maplogic[i][j] = object_lever;
  528.             else if (j == wraith_position_y && i == wraith_position_x)
  529.                 maplogic[i][j] = mob_wraith;
  530.             else if (j == zombie_position_y && i == zombie_position_x)
  531.                 maplogic[i][j] = mob_zombie;
  532.             else if (j == orc_position_y && i == orc_position_x)
  533.                 maplogic[i][j] = mob_orc;
  534.             else if (j == troll_position_y && i == troll_position_x)
  535.                 maplogic[i][j] = mob_troll;
  536.             else
  537.                 maplogic[i][j] = terrain_safe;
  538.         }
  539.     }
  540.     // sve do ovde se briše
  541.  
  542.     draw_map(maplogic, current_health, max_health);
  543.     std::cout << endl << "\t\tDobrodosli u ranu verziju igre!" << endl << endl << "\tIgrac je u igri predstavljen kao karakter '!' " << endl << "\tKarakter 'L' predstavlja polugu koja otvara vrata,";
  544.     std::cout << "a karakter '|' predstavlja zakljucana vrata." << endl << "\tKontrole su strelice na tastaturi za kretanje, i tasteri 'a' za napad i 'e' za koriscenje okruzenja.";
  545.     std::cout << endl << "\tPridjite uz polugu i stisnite taster 'e'." << " W je bezopasni (za sada) duh koji tumara po mapi" << endl;
  546.     std::cout << "\tZ - je zivi mrtvak/zombi koji prati igraca, O-ork koji prati igraca kada mu pridje na 5 polja,\n\ta T-trol koji ga prati kada igrac pridje na razdaljinu od 3 polja, a tumara ako je dalje.";
  547.     std::cout << endl << endl << "\tUSKORO: oruzija, nivoi, napad/odbrana, load/save opcija i jos...";
  548.  
  549.     while (current_health > 0)
  550.     {
  551.         //ispituje da li je potez igračev;
  552.         if (player_turn(turn_count))
  553.         {
  554.             switch ((c = _getch())) {
  555.             case KEY_UP: //akcija za strelicu gore
  556.                 move_up(maplogic, player_position_x, player_position_y);
  557.                 turn_count++;
  558.                 break;
  559.             case KEY_DOWN: //akcija za strelicu dole
  560.                 move_down(maplogic, player_position_x, player_position_y);
  561.                 turn_count++;
  562.                 break;
  563.             case KEY_LEFT: //akcija za strelicu levo
  564.                 move_left(maplogic, player_position_x, player_position_y);
  565.                 turn_count++;
  566.                 break;
  567.             case KEY_RIGHT: //akcija za strelicu desno
  568.                 move_right(maplogic, player_position_x, player_position_y);
  569.                 turn_count++;
  570.                 break;
  571.             case KEY_USE: //akcija za taster za korišćenje "e"
  572.                 use(maplogic, player_position_x, player_position_y);
  573.                 turn_count++;
  574.                 break;
  575.             case KEY_ATTACK: //akcija za taster za napad "a"
  576.                 turn_count++;
  577.                 //a = rand() % 4 + rand() % 4 + 3;
  578.                 //cout << endl << "napad!!=" << a << endl;
  579.                 break;
  580.             default: //sve ostalo
  581.                 break;
  582.             }
  583.         }
  584.         else
  585.         {
  586.             //U OVOM "ELSE" SE IZVRŠAVAJU POTEZI OD AI NEPRIJATELJA
  587.             //Sleep se koristi da bi igrač mogao videti poteze kompjutera
  588.             Sleep(400);
  589.             wraith_ai(maplogic, wraith_position_x, wraith_position_y, player_position_x, player_position_y, current_health);
  590.             zombie_ai(maplogic, zombie_position_x, zombie_position_y, player_position_x, player_position_y, current_health);
  591.             orc_ai(maplogic, orc_position_x, orc_position_y, player_position_x, player_position_y, current_health);
  592.             troll_ai(maplogic, troll_position_x, troll_position_y, player_position_x, player_position_y, current_health);
  593.             turn_count++;
  594.         }
  595.  
  596.         system("CLS");
  597.         draw_map(maplogic,current_health,max_health);
  598.         std::cout << turn_count;
  599.     }
  600.  
  601.     if(current_health < 0 || current_health == 0) //kada igrac umre
  602.     {
  603.         system("CLS");
  604.         std::cout << "KRAJ IGRE" << endl << "Da li zelite da igrate ponovo? (d/n)" << endl;
  605.         do {
  606.            
  607.                 switch ((c = _getch())) {
  608.                 case 'd':
  609.                     system("CLS");
  610.                     goto new_game; //u slucaju da igrac zeli opet da igra, skace na labelu new_game
  611.                     break;
  612.                 case 'n':
  613.                     system("CLS");
  614.                     std::cout << "\n\n\t\tHvala Vam na igranju" << endl;
  615.                     Sleep(1500);
  616.                     break;
  617.                 }
  618.  
  619.         } while (c != 'd' && c != 'n');
  620.     }
  621.  
  622.    
  623.     return 0;
  624. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!