API tools faq
paste
Hakunin

RT2815.v1.06

Hakunin
Jan 8th, 2017
104
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 14.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
  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 179 // karakter "|", koji prestavlja zaključana vrata(vertikalna)
  40. #define object_locked_door_horizontal 196 // karakter "─", koji predstavlja zaključana vrata(horizontalna)
  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(int 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(int map[LEVEL_HEIGHT][LEVEL_WIDTH])
  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 << (char)map[i][j];
  88.         }
  89.         std::cout << endl;
  90.     }
  91. }
  92.  
  93.  
  94. //funkcija za pomeranje na gore
  95. void move_up(int map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y)
  96. {
  97.     if (map[x - 1][y] == terrain_safe)
  98.     {
  99.         map[x - 1][y] = character_player;
  100.         map[x][y] = terrain_safe;
  101.         x--;
  102.     }
  103. }
  104.  
  105. //funkcija za pomeranje na dole
  106. void move_down(int map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y)
  107. {
  108.     if (map[x + 1][y] == terrain_safe)
  109.     {
  110.         map[x + 1][y] = character_player;
  111.         map[x][y] = terrain_safe;
  112.         x++;
  113.     }
  114.  
  115. }
  116.  
  117. //funkcija za pomeranje na levo
  118. void move_left(int map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y)
  119. {
  120.     if (map[x][y - 1] == terrain_safe)
  121.     {
  122.         map[x][y - 1] = character_player;
  123.         map[x][y] = terrain_safe;
  124.         y--;
  125.     }
  126. }
  127. //funkcija za pomeranje na desno
  128. void move_right(int map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y)
  129. {
  130.     if (map[x][y + 1] == terrain_safe)
  131.     {
  132.         map[x][y + 1] = character_player;
  133.         map[x][y] = terrain_safe;
  134.         y++;
  135.     }
  136. }
  137.  
  138. //funckija za taster e (taster za korišćenje)
  139. void use(int map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y)
  140. {
  141.     //u slucaju da je uz lika iz igre poluga
  142.     if (check_near(map, x, y, object_lever))
  143.     {
  144.         for (int i = 0; i < LEVEL_HEIGHT; i++)
  145.         {
  146.             for (int j = 0; j < LEVEL_WIDTH; j++)
  147.             {
  148.                 if ((map[i][j] == object_locked_door_vertical) | (map[i][j] == object_locked_door_horizontal))
  149.                     map[i][j] = terrain_safe;
  150.             }
  151.         }
  152.     }
  153. }
  154.  
  155.  
  156. //funkcija za utvrđivanje da li je igračev potez
  157. bool player_turn(int count)
  158. {
  159.     count = count % 4;
  160.  
  161.     if (count == 0 || count == 1)
  162.         return true;
  163.     else
  164.         return false;
  165. }
  166.  
  167. //funkcija koja pokrece wraith/duh neprijatelja, TODO: UDARANJE IGRACA KAD JE BLIZU!!
  168. void wrath_ai(int map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y)
  169. {
  170.     int r = rand() % 4;
  171.     switch (r)
  172.     {
  173.     case 0:
  174.         if (map[x - 1][y] == terrain_safe)
  175.         {
  176.             map[x - 1][y] = mob_wraith;
  177.             map[x][y] = terrain_safe;
  178.             x--;
  179.         }
  180.         break;
  181.     case 1:
  182.         if (map[x + 1][y] == terrain_safe)
  183.         {
  184.             map[x + 1][y] = mob_wraith;
  185.             map[x][y] = terrain_safe;
  186.             x++;
  187.         }
  188.         break;
  189.     case 2:
  190.         if (map[x][y - 1] == terrain_safe)
  191.         {
  192.             map[x][y - 1] = mob_wraith;
  193.             map[x][y] = terrain_safe;
  194.             y--;
  195.         }
  196.         break;
  197.     case 3:
  198.         if (map[x][y + 1] == terrain_safe)
  199.         {
  200.             map[x][y + 1] = mob_wraith;
  201.             map[x][y] = terrain_safe;
  202.             y++;
  203.         }
  204.         break;
  205.     }
  206. }
  207.  
  208. //funkcija koja pokrece zombie/"zivog mrtvaka" neprijatelja, TODO: UDARANJE IGRACA KAD JE BLIZU!!
  209. void zombie_ai(int map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y, int &px, int &py)
  210. {
  211.     if (abs(x - px) == abs(y - py)) //ako su razdaljine razlika (gore-dole i levo-desno) jednake
  212.     {
  213.         if (py < y) //zombi levo
  214.         {
  215.             if (map[x][y - 1] == terrain_safe)
  216.             {
  217.                 map[x][y - 1] = mob_zombie;
  218.                 map[x][y] = terrain_safe;
  219.                 y--;
  220.             }
  221.         }
  222.         else if (py> y) //zombi desno
  223.         {
  224.             if (map[x][y + 1] == terrain_safe)
  225.             {
  226.                 map[x][y + 1] = mob_zombie;
  227.                 map[x][y] = terrain_safe;
  228.                 y++;
  229.             }
  230.         }
  231.  
  232.     }
  233.     else  if (((abs(x - px)) < (abs(y - py))) && (py < y)) //zombi levo
  234.     {
  235.         if (map[x][y - 1] == terrain_safe)
  236.         {
  237.             map[x][y - 1] = mob_zombie;
  238.             map[x][y] = terrain_safe;
  239.             y--;
  240.         }
  241.     }
  242.     else if (((abs(x - px)) < abs((y - py))) && (py > y)) //zombi desno
  243.     {
  244.         if (map[x][y + 1] == terrain_safe)
  245.         {
  246.             map[x][y + 1] = mob_zombie;
  247.             map[x][y] = terrain_safe;
  248.             y++;
  249.         }
  250.     }
  251.     else if (((abs(x - px) > (abs(y - py))) && (px < x))) //zombi gore
  252.     {
  253.         if (map[x - 1][y] == terrain_safe)
  254.         {
  255.             map[x - 1][y] = mob_zombie;
  256.             map[x][y] = terrain_safe;
  257.             x--;
  258.         }
  259.     }
  260.     else if (((abs(x - px) >(abs(y - py))) && (px > x))) // zombi dole
  261.     {
  262.         if (map[x + 1][y] == terrain_safe)
  263.         {
  264.             map[x + 1][y] = mob_zombie;
  265.             map[x][y] = terrain_safe;
  266.             x++;
  267.         }
  268.  
  269.     }
  270.  
  271. }
  272.  
  273. //funckija koja pokreće orkove, TODO: UDARANJE IGRAČA
  274. void orc_ai(int map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y, int &px, int &py)
  275. {
  276.     if (abs(x - px) < 5 && abs(y - py) < 5) //ork se aktivira ako igrač priđe bliže od 4 kocke
  277.     {
  278.         if (abs(x - px) == abs(y - py)) //ako su razdaljine razlika (gore-dole i levo-desno) jednake
  279.         {
  280.             if (py < y) //ork levo
  281.             {
  282.                 if (map[x][y - 1] == terrain_safe)
  283.                 {
  284.                     map[x][y - 1] = mob_orc;
  285.                     map[x][y] = terrain_safe;
  286.                     y--;
  287.                 }
  288.             }
  289.             else if (py> y) //ork desno
  290.             {
  291.                 if (map[x][y + 1] == terrain_safe)
  292.                 {
  293.                     map[x][y + 1] = mob_orc;
  294.                     map[x][y] = terrain_safe;
  295.                     y++;
  296.                 }
  297.             }
  298.  
  299.         }
  300.         else  if (((abs(x - px)) < (abs(y - py))) && (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 (((abs(x - px)) < abs((y - py))) && (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.         else if (((abs(x - px) > (abs(y - py))) && (px < x))) //ork gore
  319.         {
  320.             if (map[x - 1][y] == terrain_safe)
  321.             {
  322.                 map[x - 1][y] = mob_orc;
  323.                 map[x][y] = terrain_safe;
  324.                 x--;
  325.             }
  326.         }
  327.         else if (((abs(x - px) >(abs(y - py))) && (px > x))) //ork dole
  328.         {
  329.             if (map[x + 1][y] == terrain_safe)
  330.             {
  331.                 map[x + 1][y] = mob_orc;
  332.                 map[x][y] = terrain_safe;
  333.                 x++;
  334.             }
  335.  
  336.         }
  337.  
  338.     }
  339. }
  340.  
  341. //funkcija koja pokreće trolove, TODO: UDARANJE IGRAČA
  342. void troll_ai(int map[LEVEL_HEIGHT][LEVEL_WIDTH], int &x, int &y, int &px, int &py)
  343. {
  344.     int r = rand() % 4;
  345.     if (abs(x - px) < 3 && abs(y - py) < 3) //ako igrač priđe blize od 3 kocke trol se aktivira
  346.     {
  347.         if (abs(x - px) == abs(y - py)) //ako su razdaljine razlika (gore-dole i levo-desno) jednake
  348.         {
  349.             if (py < y) //troll levo
  350.             {
  351.                 if (map[x][y - 1] == terrain_safe)
  352.                 {
  353.                     map[x][y - 1] = mob_troll;
  354.                     map[x][y] = terrain_safe;
  355.                     y--;
  356.                 }
  357.             }
  358.             else if (py> y) //troll desno
  359.             {
  360.                 if (map[x][y + 1] == terrain_safe)
  361.                 {
  362.                     map[x][y + 1] = mob_troll;
  363.                     map[x][y] = terrain_safe;
  364.                     y++;
  365.                 }
  366.             }
  367.  
  368.         }
  369.         else  if (((abs(x - px)) < (abs(y - py))) && (py < y)) //troll levo
  370.         {
  371.             if (map[x][y - 1] == terrain_safe)
  372.             {
  373.                 map[x][y - 1] = mob_troll;
  374.                 map[x][y] = terrain_safe;
  375.                 y--;
  376.             }
  377.         }
  378.         else if (((abs(x - px)) < abs((y - py))) && (py > y)) //troll desno
  379.         {
  380.             if (map[x][y + 1] == terrain_safe)
  381.             {
  382.                 map[x][y + 1] = mob_troll;
  383.                 map[x][y] = terrain_safe;
  384.                 y++;
  385.             }
  386.         }
  387.         else if (((abs(x - px) > (abs(y - py))) && (px < x))) //troll gore
  388.         {
  389.             if (map[x - 1][y] == terrain_safe)
  390.             {
  391.                 map[x - 1][y] = mob_troll;
  392.                 map[x][y] = terrain_safe;
  393.                 x--;
  394.             }
  395.         }
  396.         else if (((abs(x - px) >(abs(y - py))) && (px > x))) //troll dole
  397.         {
  398.             if (map[x + 1][y] == terrain_safe)
  399.             {
  400.                 map[x + 1][y] = mob_troll;
  401.                 map[x][y] = terrain_safe;
  402.                 x++;
  403.             }
  404.  
  405.         }
  406.        
  407.     }
  408.     else
  409.     {
  410.         switch (r)
  411.         {
  412.         case 0:
  413.             if (map[x - 1][y] == terrain_safe)
  414.             {
  415.                 map[x - 1][y] = mob_troll;
  416.                 map[x][y] = terrain_safe;
  417.                 x--;
  418.             }
  419.             break;
  420.         case 1:
  421.             if (map[x + 1][y] == terrain_safe)
  422.             {
  423.                 map[x + 1][y] = mob_troll;
  424.                 map[x][y] = terrain_safe;
  425.                 x++;
  426.             }
  427.             break;
  428.         case 2:
  429.             if (map[x][y - 1] == terrain_safe)
  430.             {
  431.                 map[x][y - 1] = mob_troll;
  432.                 map[x][y] = terrain_safe;
  433.                 y--;
  434.             }
  435.             break;
  436.         case 3:
  437.             if (map[x][y + 1] == terrain_safe)
  438.             {
  439.                 map[x][y + 1] = mob_troll;
  440.                 map[x][y] = terrain_safe;
  441.                 y++;
  442.             }
  443.             break;
  444.         }
  445.     }
  446. }
  447.  
  448. int main() {
  449.  
  450.     system("mode 150");
  451.     int i, j, maplogic[LEVEL_HEIGHT][LEVEL_WIDTH];
  452.     int player_position_x, player_position_y, wraith_position_x, wraith_position_y, zombie_position_x, zombie_position_y;
  453.     int orc_position_x, orc_position_y, troll_position_x, troll_position_y;
  454.     int c, turn_count = 0;
  455.     srand(time(NULL));
  456.  
  457.     // placeholder ucitavanje mape (nivoi ce se ucitavati iz struct),  ovaj deo koda se brise
  458.     player_position_x = 10;
  459.     player_position_y = 9;
  460.     wraith_position_x = 8;
  461.     wraith_position_y = 22;
  462.     zombie_position_x = 15;
  463.     zombie_position_y = 11;
  464.     orc_position_x = 3;
  465.     orc_position_y = 21;
  466.     troll_position_x = 15;
  467.     troll_position_y = 21;
  468.     for (i = 0; i < LEVEL_HEIGHT; i++)
  469.     {
  470.         for (j = 0; j < LEVEL_WIDTH; j++)
  471.         {
  472.             if (i == player_position_x && j == player_position_y)
  473.                 maplogic[i][j] = character_player;
  474.             else if (i == 0 || j == 0 || i == (LEVEL_HEIGHT - 1) || j == (LEVEL_WIDTH - 1))
  475.                 maplogic[i][j] = placeholder_wall;
  476.             else if (j == 20)
  477.                 maplogic[i][j] = object_locked_door_vertical;
  478.             else if (j == 5 && i == 5)
  479.                 maplogic[i][j] = object_lever;
  480.             else if (j == wraith_position_y && i == wraith_position_x)
  481.                 maplogic[i][j] = mob_wraith;
  482.             else if (j == zombie_position_y && i == zombie_position_x)
  483.                 maplogic[i][j] = mob_zombie;
  484.             else if (j == orc_position_y && i == orc_position_x)
  485.                 maplogic[i][j] = mob_orc;
  486.             else if (j == troll_position_y && i == troll_position_x)
  487.                 maplogic[i][j] = mob_troll;
  488.             else
  489.                 maplogic[i][j] = terrain_safe;
  490.         }
  491.     }
  492.     // sve do ovde se briše
  493.  
  494.     draw_map(maplogic);
  495.     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,";
  496.     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.";
  497.     std::cout << endl << "\tPridjite uz polugu i stisnite taster 'e'." << " W je bezopasni (za sada) duh koji tumara po mapi" << endl;
  498.     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.";
  499.     std::cout << endl << endl << "\tUSKORO: oruzija, nivoi, napad/odbrana, load/save opcija i jos...";
  500.  
  501.     while (1)
  502.     {
  503.         //ispituje da li je potez igračev;
  504.         if (player_turn(turn_count))
  505.         {
  506.             switch ((c = _getch())) {
  507.             case KEY_UP: //akcija za strelicu gore
  508.                 move_up(maplogic, player_position_x, player_position_y);
  509.                 turn_count++;
  510.                 break;
  511.             case KEY_DOWN: //akcija za strelicu dole
  512.                 move_down(maplogic, player_position_x, player_position_y);
  513.                 turn_count++;
  514.                 break;
  515.             case KEY_LEFT: //akcija za strelicu levo
  516.                 move_left(maplogic, player_position_x, player_position_y);
  517.                 turn_count++;
  518.                 break;
  519.             case KEY_RIGHT: //akcija za strelicu desno
  520.                 move_right(maplogic, player_position_x, player_position_y);
  521.                 turn_count++;
  522.                 break;
  523.             case KEY_USE: //akcija za taster za korišćenje "e"
  524.                 use(maplogic, player_position_x, player_position_y);
  525.                 turn_count++;
  526.                 break;
  527.             case KEY_ATTACK: //akcija za taster za napad "a"
  528.                 turn_count++;
  529.                 //a = rand() % 4 + rand() % 4 + 3;
  530.                 //cout << endl << "napad!!=" << a << endl;
  531.                 break;
  532.             default: //sve ostalo
  533.                 break;
  534.             }
  535.         }
  536.         else
  537.         {
  538.             //U OVOM "ELSE" SE IZVRŠAVAJU POTEZI OD AI NEPRIJATELJA
  539.             //Sleep služi da bi igrač mogao videti poteze kompijutera
  540.             Sleep(400);
  541.             wrath_ai(maplogic, wraith_position_x, wraith_position_y);
  542.             zombie_ai(maplogic, zombie_position_x, zombie_position_y, player_position_x, player_position_y);
  543.             orc_ai(maplogic, orc_position_x, orc_position_y, player_position_x, player_position_y);
  544.             troll_ai(maplogic, troll_position_x, troll_position_y, player_position_x, player_position_y);
  545.             turn_count++;
  546.         }
  547.  
  548.         system("CLS");
  549.         draw_map(maplogic);
  550.         std::cout << turn_count;
  551.     }
  552.  
  553.     system("pause");
  554.     return 0;
  555. }
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!