kellex

SimpleGameKellex

Jul 17th, 2013
276
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 78.98 KB | None | 0 0
  1. #include <cstdlib>
  2. #include <iostream>
  3. #include <conio.h>
  4. #include <windows.h>
  5.  
  6. //http://dis.4chan.org/read/prog/1374070050/1-40
  7.  
  8. void setcolor(unsigned short color)                
  9. {                                                  
  10.     HANDLE hcon = GetStdHandle(STD_OUTPUT_HANDLE);
  11.     SetConsoleTextAttribute(hcon,color);
  12. }
  13.  
  14. using namespace std;
  15.                  
  16. int Gamespeed = 100;
  17. int Level = 1;
  18. int menu = 0;
  19. int Hp = 1;
  20. int MaxHp = 100;
  21. int randnum;
  22. int key;
  23. string input;
  24. bool stopgame = false;
  25. bool running = true;
  26.  
  27. char Map[10][10] = {"#########",
  28.                     "#   #   #",
  29.                     "# # # # #",
  30.                     "# # # # #",
  31.                     "#+# # #+#",
  32.                     "# # # # #",
  33.                     "# # # # #",
  34.                     "# # # # #",
  35.                     "#@# * # #",
  36.                     "#######-#"};
  37.                    
  38. char Map2[18][40] = {
  39.      "#####################################-#",
  40.      "#@       #      # #  *       *  #   # #",
  41.      "# ###### # #++# # #  * *  +  *  # # # #",
  42.      "# ##   # # #### # #    *        # # # #",
  43.      "#    # #   #    # # ## #******* # #   #",
  44.      "###### ##### #### #    #        # #####",
  45.      "#      #          # ## #  ******#     #",
  46.      "# ########## #### #    ##       ####  #",
  47.      "#                       #****** #*    #",
  48.      "##### ############   ## #       #*    #",
  49.      "#     ##             ## # ******#**** #",
  50.      "#     ## +++  #######   #       #*    #",
  51.      "#      #      #######  ######## #* ***#",
  52.      "#      #      #######  *   *    *     #",
  53.      "#      ##     *   *    * * * *  *     #",
  54.      "#     ###     * * * *  * * * *  *     #",
  55.      "#++  +###       *   *    *   *        #",
  56.      "#######################################"};
  57.      
  58. char Map3[18][40] = {
  59.      "#######################################",
  60.      "#@         # # #********##     #      #",
  61.      "########## #   #             # # # ####",
  62.      "#          # #+#        ###### # #    #",
  63.      "###### ##### ###        #    # # #### #",
  64.      "#      #                #        #    #",
  65.      "# ###### # #####********########## ####",
  66.      "#        # #               #          #",
  67.      "########## #               # *##  *## #",
  68.      "#++++#     #  ######::###### *##  *## #",
  69.      "#++++#   ###  #            #          #",
  70.      "#######  ######            ######**####",
  71.      "#             #            #         K#",
  72.      "#   ********  #            #**********#",
  73.      "#   ********  ######::######   +++    #",
  74.      "#   ********       #  #        +++    #",
  75.      "#                  #  #               #",
  76.      "####################--#################"};
  77.  
  78. char Map4[18][40] = {
  79.      "###########                 ###########",
  80.      "#@        #                 #*********#",
  81.      "#         ###################*********#",
  82.      "#                                *****#",
  83.      "#         ###################*** *****#",
  84.      "###########  #   #         ##### ######",
  85.      " #K# #       # # # ####### #   #      #",
  86.      " #*# # ##### # #   #     # # # ###### #",
  87.      " #*# #     #   ##### ### #   #        #",
  88.      " #*# #     #####     ### ##############",
  89.      " #*# ##### ##### #######              #",
  90.      " #*#     #       #    ##########   ####",
  91.      "##*###############          ##### #####",
  92.      "#* *******###################****     #",
  93.      "#*  *   *                     ******* #",
  94.      "#** * * * ########:::######## ******* #",
  95.      "#**   *   #      #   #      #         #",
  96.      "###########      #---#      ###########"};
  97.  
  98. void m1()
  99. {
  100.      for (int y = 0; y < 10; y++)
  101.                    {
  102.                        for (int x = 0; x < 10; x++)
  103.                        {
  104.                            switch(Map[y][x])
  105.                            {                                                
  106.                                             //let make it look cooler
  107.                                             case '#':
  108.                                             {
  109.                                                  //we gonna use ascii characters
  110.                                                  Map[y][x] = 219;
  111.                                             }
  112.                                             case '@':
  113.                                             {
  114.                                                  if (GetAsyncKeyState(VK_UP) != 0)
  115.                                                  {
  116.                                                                              int y2 = (y-1);
  117.                                                                              
  118.                                                                              switch(Map[y2][x])
  119.                                  
  120.                                                                              {
  121.                                                                                                case ' ':
  122.                                                                                                {
  123.                                                                                                     Map[y][x] = ' ';
  124.                                                                                                     y -= 1;
  125.                                                                                                     Map[y2][x] = '@';
  126.                                                                                                }break;
  127.                                                                                                case '-':
  128.                                                                                                {
  129.                                                                                                     Level = 2;    
  130.                                                                                                }break;
  131.                                                                                                case '*':
  132.                                                                                                {
  133.                                                                                                     Hp -= 5;
  134.                                                                                                     Map[y][x] = ' ';
  135.                                                                                                     y -= 1;
  136.                                                                                                     Map[y2][x] = '@';  
  137.                                                                                                }break;
  138.                                                                                                case '+':
  139.                                                                                                {
  140.                                                                                                     Hp += 5;
  141.                                                                                                     Map[y][x] = ' ';
  142.                                                                                                     y -= 1;
  143.                                                                                                     Map[y2][x] = '@';  
  144.                                                                                                }break;
  145.                                                                              }
  146.                                                  }
  147.                                                  
  148.                                                  if (GetAsyncKeyState(VK_DOWN) != 0)
  149.                                                  {
  150.                                                                              int y2 = (y+1);
  151.                                                                              
  152.                                                                              switch(Map[y2][x])
  153.                                                                              {
  154.                                                                                                case ' ':
  155.                                                                                                {
  156.                                                                                                     Map[y][x] = ' ';
  157.                                                                                                     y += 1;
  158.                                                                                                     Map[y2][x] = '@';
  159.                                                                                                }break;
  160.                                                                                                case '-':
  161.                                                                                                {
  162.                                                                                                     Level = 2;    
  163.                                                                                                }break;
  164.                                                                                                case '*':
  165.                                                                                                {
  166.                                                                                                     Hp -= 5;
  167.                                                                                                     Map[y][x] = ' ';
  168.                                                                                                     y += 1;
  169.                                                                                                     Map[y2][x] = '@';
  170.                                                                                                }break;
  171.                                                                                                case '+':
  172.                                                                                                {
  173.                                                                                                     Hp += 5;
  174.                                                                                                     Map[y][x] = ' ';
  175.                                                                                                     y += 1;
  176.                                                                                                     Map[y2][x] = '@';
  177.                                                                                                }break;
  178.                                                                              }
  179.                                                  }
  180.                                                  
  181.                                                  if (GetAsyncKeyState(VK_LEFT) != 0)
  182.                                                  {
  183.                                                                              int x2 = (x-1);
  184.                                                                              
  185.                                                                              switch(Map[y][x2])
  186.                                                                              {
  187.                                                                                                case ' ':
  188.                                                                                                {
  189.                                                                                                     Map[y][x] = ' ';
  190.                                                                                                     x -= 1;
  191.                                                                                                     Map[y][x2] = '@';
  192.                                                                                                }break;
  193.                                                                                                case '-':
  194.                                                                                                {
  195.                                                                                                     Level = 2;    
  196.                                                                                                }break;
  197.                                                                                                case '*':
  198.                                                                                                {
  199.                                                                                                     Hp -= 5;
  200.                                                                                                     Map[y][x] = ' ';
  201.                                                                                                     x -= 1;
  202.                                                                                                     Map[y][x2] = '@';
  203.                                                                                                }break;
  204.                                                                                                case '+':
  205.                                                                                                {
  206.                                                                                                     Hp += 5;
  207.                                                                                                     Map[y][x] = ' ';
  208.                                                                                                     x -= 1;
  209.                                                                                                     Map[y][x2] = '@';
  210.                                                                                                }break;
  211.                                                                              }
  212.                                                  }
  213.                                                  
  214.                                                  if (GetAsyncKeyState(VK_RIGHT) != 0)
  215.                                                  {
  216.                                                                              int x2 = (x+1);
  217.                                                                              
  218.                                                                              switch(Map[y][x2])
  219.                                                                              {
  220.                                                                                                case ' ':
  221.                                                                                                {
  222.                                                                                                     Map[y][x] = ' ';
  223.                                                                                                     x += 1;
  224.                                                                                                     Map[y][x2] = '@';
  225.                                                                                                }break;
  226.                                                                                                case '-':
  227.                                                                                                {
  228.                                                                                                     Level = 2;    
  229.                                                                                                }break;
  230.                                                                                                case '*':
  231.                                                                                                {
  232.                                                                                                     Hp -= 5;
  233.                                                                                                     Map[y][x] = ' ';
  234.                                                                                                     x += 1;
  235.                                                                                                     Map[y][x2] = '@';
  236.                                                                                                }break;
  237.                                                                                                case '+':
  238.                                                                                                {
  239.                                                                                                     Hp += 5;
  240.                                                                                                     Map[y][x] = ' ';
  241.                                                                                                     x += 1;
  242.                                                                                                     Map[y][x2] = '@';
  243.                                                                                                }break;
  244.                                                                              }
  245.                                                  }      
  246.                                             }break;
  247.                            }
  248.                        }
  249.                    }    
  250. }
  251.  
  252. void m2()
  253. {
  254.          for (int y = 0; y < 18; y++)
  255.                    {
  256.                        for (int x = 0; x < 40; x++)
  257.                        {
  258.                            switch(Map2[y][x])
  259.                            {
  260.                                             //let make it look cooler
  261.                                             case '#':
  262.                                             {
  263.                                                  //we gonna use ascii characters
  264.                                                  Map2[y][x] = 219;
  265.                                             }
  266.                                             case '@':
  267.                                             {
  268.                                                  if (GetAsyncKeyState(VK_UP) != 0)
  269.                                                  {
  270.                                                                              int y2 = (y-1);
  271.                                                                              
  272.                                                                              switch(Map2[y2][x])
  273.                                  
  274.                                                                              {
  275.                                                                                                case ' ':
  276.                                                                                                {
  277.                                                                                                     Map2[y][x] = ' ';
  278.                                                                                                     y -= 1;
  279.                                                                                                     Map2[y2][x] = '@';
  280.                                                                                                }break;
  281.                                                                                                case '-':
  282.                                                                                                {
  283.                                                                                                     Level = 3;    
  284.                                                                                                }break;
  285.                                                                                                case '*':
  286.                                                                                                {
  287.                                                                                                     Hp -= 5;
  288.                                                                                                     Map2[y][x] = ' ';
  289.                                                                                                     y -= 1;
  290.                                                                                                     Map2[y2][x] = '@';  
  291.                                                                                                }break;
  292.                                                                                                case '+':
  293.                                                                                                {
  294.                                                                                                     Hp += 5;
  295.                                                                                                     Map2[y][x] = ' ';
  296.                                                                                                     y -= 1;
  297.                                                                                                     Map2[y2][x] = '@';  
  298.                                                                                                }break;
  299.                                                                              }
  300.                                                  }
  301.                                                  
  302.                                                  if (GetAsyncKeyState(VK_DOWN) != 0)
  303.                                                  {
  304.                                                                              int y2 = (y+1);
  305.                                                                              
  306.                                                                              switch(Map2[y2][x])
  307.                                                                              {
  308.                                                                                                case ' ':
  309.                                                                                                {
  310.                                                                                                     Map2[y][x] = ' ';
  311.                                                                                                     y += 1;
  312.                                                                                                     Map2[y2][x] = '@';
  313.                                                                                                }break;
  314.                                                                                                case '-':
  315.                                                                                                {
  316.                                                                                                     Level = 3;    
  317.                                                                                                }break;
  318.                                                                                                case '*':
  319.                                                                                                {
  320.                                                                                                     Hp -= 5;
  321.                                                                                                     Map2[y][x] = ' ';
  322.                                                                                                     y += 1;
  323.                                                                                                     Map2[y2][x] = '@';
  324.                                                                                                }break;
  325.                                                                                                case '+':
  326.                                                                                                {
  327.                                                                                                     Hp += 5;
  328.                                                                                                     Map2[y][x] = ' ';
  329.                                                                                                     y += 1;
  330.                                                                                                     Map2[y2][x] = '@';
  331.                                                                                                }break;
  332.                                                                              }
  333.                                                  }
  334.                                                  
  335.                                                  if (GetAsyncKeyState(VK_LEFT) != 0)
  336.                                                  {
  337.                                                                              int x2 = (x-1);
  338.                                                                              
  339.                                                                              switch(Map2[y][x2])
  340.                                                                              {
  341.                                                                                                case ' ':
  342.                                                                                                {
  343.                                                                                                     Map2[y][x] = ' ';
  344.                                                                                                     x -= 1;
  345.                                                                                                     Map2[y][x2] = '@';
  346.                                                                                                }break;
  347.                                                                                                case '-':
  348.                                                                                                {
  349.                                                                                                     Level = 3;    
  350.                                                                                                }break;
  351.                                                                                                case '*':
  352.                                                                                                {
  353.                                                                                                     Hp -= 5;
  354.                                                                                                     Map2[y][x] = ' ';
  355.                                                                                                     x -= 1;
  356.                                                                                                     Map2[y][x2] = '@';
  357.                                                                                                }break;
  358.                                                                                                case '+':
  359.                                                                                                {
  360.                                                                                                     Hp += 5;
  361.                                                                                                     Map2[y][x] = ' ';
  362.                                                                                                     x -= 1;
  363.                                                                                                     Map2[y][x2] = '@';
  364.                                                                                                }break;
  365.                                                                              }
  366.                                                  }
  367.                                                  
  368.                                                  if (GetAsyncKeyState(VK_RIGHT) != 0)
  369.                                                  {
  370.                                                                              int x2 = (x+1);
  371.                                                                              
  372.                                                                              switch(Map2[y][x2])
  373.                                                                              {
  374.                                                                                                case ' ':
  375.                                                                                                {
  376.                                                                                                     Map2[y][x] = ' ';
  377.                                                                                                     x += 1;
  378.                                                                                                     Map2[y][x2] = '@';
  379.                                                                                                }break;
  380.                                                                                                case '-':
  381.                                                                                                {
  382.                                                                                                     Level = 3;    
  383.                                                                                                }break;
  384.                                                                                                case '*':
  385.                                                                                                {
  386.                                                                                                     Hp -= 5;
  387.                                                                                                     Map2[y][x] = ' ';
  388.                                                                                                     x += 1;
  389.                                                                                                     Map2[y][x2] = '@';
  390.                                                                                                }break;
  391.                                                                                                case '+':
  392.                                                                                                {
  393.                                                                                                     Hp += 5;
  394.                                                                                                     Map2[y][x] = ' ';
  395.                                                                                                     x += 1;
  396.                                                                                                     Map2[y][x2] = '@';
  397.                                                                                                }break;
  398.                                                                              }
  399.                                                  }
  400.                                             }break;
  401.                            }
  402.                        }
  403.                    }    
  404. }
  405.  
  406. void m3()
  407. {
  408.      for (int y = 0; y < 18; y++)
  409.                    {
  410.                        for (int x = 0; x < 40; x++)
  411.                        {
  412.                            switch(Map3[y][x])
  413.                            {
  414.                                             //let make it look cooler
  415.                                             case '#':
  416.                                             {
  417.                                                  //we gonna use ascii characters
  418.                                                  Map3[y][x] = 219;
  419.                                             }
  420.                                             case '@':
  421.                                             {
  422.                                                  if (GetAsyncKeyState(VK_UP) != 0)
  423.                                                  {
  424.                                                                              int y2 = (y-1);
  425.                                                                              
  426.                                                                              switch(Map3[y2][x])
  427.                                  
  428.                                                                              {
  429.                                                                                                case ' ':
  430.                                                                                                {
  431.                                                                                                     Map3[y][x] = ' ';
  432.                                                                                                     y -= 1;
  433.                                                                                                     Map3[y2][x] = '@';
  434.                                                                                                }break;
  435.                                                                                                case '-':
  436.                                                                                                {
  437.                                                                                                     Level = 4;    
  438.                                                                                                }break;
  439.                                                                                                case '*':
  440.                                                                                                {
  441.                                                                                                     Hp -= 5;
  442.                                                                                                     Map3[y][x] = ' ';
  443.                                                                                                     y -= 1;
  444.                                                                                                     Map3[y2][x] = '@';  
  445.                                                                                                }break;
  446.                                                                                                case '+':
  447.                                                                                                {
  448.                                                                                                     Hp += 5;
  449.                                                                                                     Map3[y][x] = ' ';
  450.                                                                                                     y -= 1;
  451.                                                                                                     Map3[y2][x] = '@';  
  452.                                                                                                }break;
  453.                                                                                                case 'K':
  454.                                                                                                {
  455.                                                                                                     key = 1;
  456.                                                                                                     Map3[y][x] = ' ';
  457.                                                                                                     y -= 1;
  458.                                                                                                     Map3[y2][x] = '@';  
  459.                                                                                                }break;
  460.                                                                                                case ':':
  461.                                                                                                {
  462.                                                                                                     if (key >= 1)
  463.                                                                                                     {
  464.                                                                                                     Map3[y][x] = ' ';
  465.                                                                                                     y -= 1;
  466.                                                                                                     Map3[y2][x] = '@';
  467.                                                                                                     }  
  468.                                                                                                }break;
  469.                                                                              }
  470.                                                  }
  471.                                                  
  472.                                                  if (GetAsyncKeyState(VK_DOWN) != 0)
  473.                                                  {
  474.                                                                              int y2 = (y+1);
  475.                                                                              
  476.                                                                              switch(Map3[y2][x])
  477.                                                                              {
  478.                                                                                                case ' ':
  479.                                                                                                {
  480.                                                                                                     Map3[y][x] = ' ';
  481.                                                                                                     y += 1;
  482.                                                                                                     Map3[y2][x] = '@';
  483.                                                                                                }break;
  484.                                                                                                case '-':
  485.                                                                                                {
  486.                                                                                                     Level = 4;    
  487.                                                                                                }break;
  488.                                                                                                case '*':
  489.                                                                                                {
  490.                                                                                                     Hp -= 5;
  491.                                                                                                     Map3[y][x] = ' ';
  492.                                                                                                     y += 1;
  493.                                                                                                     Map3[y2][x] = '@';
  494.                                                                                                }break;
  495.                                                                                                case '+':
  496.                                                                                                {
  497.                                                                                                     Hp += 5;
  498.                                                                                                     Map3[y][x] = ' ';
  499.                                                                                                     y += 1;
  500.                                                                                                     Map3[y2][x] = '@';
  501.                                                                                                }break;
  502.                                                                                                case 'K':
  503.                                                                                                {
  504.                                                                                                     key = 1;
  505.                                                                                                     Map3[y][x] = ' ';
  506.                                                                                                     y += 1;
  507.                                                                                                     Map3[y2][x] = '@';  
  508.                                                                                                }break;
  509.                                                                                                case ':':
  510.                                                                                                {
  511.                                                                                                     if (key >= 1)
  512.                                                                                                     {
  513.                                                                                                     Map3[y][x] = ' ';
  514.                                                                                                     y += 1;
  515.                                                                                                     Map3[y2][x] = '@';
  516.                                                                                                     }  
  517.                                                                                                }break;
  518.                                                                              }
  519.                                                  }
  520.                                                  
  521.                                                  if (GetAsyncKeyState(VK_LEFT) != 0)
  522.                                                  {
  523.                                                                              int x2 = (x-1);
  524.                                                                              
  525.                                                                              switch(Map3[y][x2])
  526.                                                                              {
  527.                                                                                                case ' ':
  528.                                                                                                {
  529.                                                                                                     Map3[y][x] = ' ';
  530.                                                                                                     x -= 1;
  531.                                                                                                     Map3[y][x2] = '@';
  532.                                                                                                }break;
  533.                                                                                                case '-':
  534.                                                                                                {
  535.                                                                                                     Level = 4;    
  536.                                                                                                }break;
  537.                                                                                                case '*':
  538.                                                                                                {
  539.                                                                                                     Hp -= 5;
  540.                                                                                                     Map3[y][x] = ' ';
  541.                                                                                                     x -= 1;
  542.                                                                                                     Map3[y][x2] = '@';
  543.                                                                                                }break;
  544.                                                                                                case '+':
  545.                                                                                                {
  546.                                                                                                     Hp += 5;
  547.                                                                                                     Map3[y][x] = ' ';
  548.                                                                                                     x -= 1;
  549.                                                                                                     Map3[y][x2] = '@';
  550.                                                                                                }break;
  551.                                                                                                case 'K':
  552.                                                                                                {
  553.                                                                                                     key = 1;
  554.                                                                                                     Map3[y][x] = ' ';
  555.                                                                                                     x -= 1;
  556.                                                                                                     Map3[y][x2] = '@';  
  557.                                                                                                }break;
  558.                                                                                                case ':':
  559.                                                                                                {
  560.                                                                                                     if (key >= 1)
  561.                                                                                                     {
  562.                                                                                                     Map3[y][x] = ' ';
  563.                                                                                                     x -= 1;
  564.                                                                                                     Map3[y][x2] = '@';
  565.                                                                                                     }  
  566.                                                                                                }break;
  567.                                                                              }
  568.                                                  }
  569.                                                  
  570.                                                  if (GetAsyncKeyState(VK_RIGHT) != 0)
  571.                                                  {
  572.                                                                              int x2 = (x+1);
  573.                                                                              
  574.                                                                              switch(Map3[y][x2])
  575.                                                                              {
  576.                                                                                                case ' ':
  577.                                                                                                {
  578.                                                                                                     Map3[y][x] = ' ';
  579.                                                                                                     x += 1;
  580.                                                                                                     Map3[y][x2] = '@';
  581.                                                                                                }break;
  582.                                                                                                case '-':
  583.                                                                                                {
  584.                                                                                                     Level = 4;    
  585.                                                                                                }break;
  586.                                                                                                case '*':
  587.                                                                                                {
  588.                                                                                                     Hp -= 5;
  589.                                                                                                     Map3[y][x] = ' ';
  590.                                                                                                     x += 1;
  591.                                                                                                     Map3[y][x2] = '@';
  592.                                                                                                }break;
  593.                                                                                                case '+':
  594.                                                                                                {
  595.                                                                                                     Hp += 5;
  596.                                                                                                     Map3[y][x] = ' ';
  597.                                                                                                     x += 1;
  598.                                                                                                     Map3[y][x2] = '@';
  599.                                                                                                }break;
  600.                                                                                                case 'K':
  601.                                                                                                {
  602.                                                                                                     key = 1;
  603.                                                                                                     Map3[y][x] = ' ';
  604.                                                                                                     x += 1;
  605.                                                                                                     Map3[y][x2] = '@';  
  606.                                                                                                }break;
  607.                                                                                                case ':':
  608.                                                                                                {
  609.                                                                                                     if (key >= 1)
  610.                                                                                                     {
  611.                                                                                                     Map3[y][x] = ' ';
  612.                                                                                                     x += 1;
  613.                                                                                                     Map3[y][x2] = '@';
  614.                                                                                                     }  
  615.                                                                                                }break;
  616.                                                                              }
  617.                                                  }
  618.                                             }break;
  619.                            }
  620.                        }
  621.                    }    
  622. }
  623.  
  624. void m4()
  625. {
  626. for (int y = 0; y < 18; y++)
  627.                    {
  628.                        for (int x = 0; x < 40; x++)
  629.                        {
  630.                            switch(Map4[y][x])
  631.                            {
  632.                                             //let make it look cooler
  633.                                             case '#':
  634.                                             {
  635.                                                  //we gonna use ascii characters
  636.                                                  Map4[y][x] = 219;
  637.                                             }
  638.                                             case '@':
  639.                                             {
  640.                                                  if (GetAsyncKeyState(VK_UP) != 0)
  641.                                                  {
  642.                                                                              int y2 = (y-1);
  643.                                                                              
  644.                                                                              switch(Map4[y2][x])
  645.                                  
  646.                                                                              {
  647.                                                                                                case ' ':
  648.                                                                                                {
  649.                                                                                                     Map4[y][x] = ' ';
  650.                                                                                                     y -= 1;
  651.                                                                                                     Map4[y2][x] = '@';
  652.                                                                                                }break;
  653.                                                                                                case '-':
  654.                                                                                                {
  655.                                                                                                     Level = 5;    
  656.                                                                                                }break;
  657.                                                                                                case '*':
  658.                                                                                                {
  659.                                                                                                     Hp -= 5;
  660.                                                                                                     Map4[y][x] = ' ';
  661.                                                                                                     y -= 1;
  662.                                                                                                     Map4[y2][x] = '@';  
  663.                                                                                                }break;
  664.                                                                                                case '+':
  665.                                                                                                {
  666.                                                                                                     Hp += 5;
  667.                                                                                                     Map4[y][x] = ' ';
  668.                                                                                                     y -= 1;
  669.                                                                                                     Map4[y2][x] = '@';  
  670.                                                                                                }break;
  671.                                                                                                case 'K':
  672.                                                                                                {
  673.                                                                                                     key = 2;
  674.                                                                                                     Map4[y][x] = ' ';
  675.                                                                                                     y -= 1;
  676.                                                                                                     Map4[y2][x] = '@';  
  677.                                                                                                }break;
  678.                                                                                                case ':':
  679.                                                                                                {
  680.                                                                                                     if (key >= 2)
  681.                                                                                                     {
  682.                                                                                                     Map4[y][x] = ' ';
  683.                                                                                                     y -= 1;
  684.                                                                                                     Map4[y2][x] = '@';
  685.                                                                                                     }  
  686.                                                                                                }break;
  687.                                                                              }
  688.                                                  }
  689.                                                  
  690.                                                  if (GetAsyncKeyState(VK_DOWN) != 0)
  691.                                                  {
  692.                                                                              int y2 = (y+1);
  693.                                                                              
  694.                                                                              switch(Map4[y2][x])
  695.                                                                              {
  696.                                                                                                case ' ':
  697.                                                                                                {
  698.                                                                                                     Map4[y][x] = ' ';
  699.                                                                                                     y += 1;
  700.                                                                                                     Map4[y2][x] = '@';
  701.                                                                                                }break;
  702.                                                                                                case '-':
  703.                                                                                                {
  704.                                                                                                     Level = 5;    
  705.                                                                                                }break;
  706.                                                                                                case '*':
  707.                                                                                                {
  708.                                                                                                     Hp -= 5;
  709.                                                                                                     Map4[y][x] = ' ';
  710.                                                                                                     y += 1;
  711.                                                                                                     Map4[y2][x] = '@';
  712.                                                                                                }break;
  713.                                                                                                case '+':
  714.                                                                                                {
  715.                                                                                                     Hp += 5;
  716.                                                                                                     Map4[y][x] = ' ';
  717.                                                                                                     y += 1;
  718.                                                                                                     Map4[y2][x] = '@';
  719.                                                                                                }break;
  720.                                                                                                case 'K':
  721.                                                                                                {
  722.                                                                                                     key = 2;
  723.                                                                                                     Map4[y][x] = ' ';
  724.                                                                                                     y += 1;
  725.                                                                                                     Map4[y2][x] = '@';  
  726.                                                                                                }break;
  727.                                                                                                case ':':
  728.                                                                                                {
  729.                                                                                                     if (key >= 2)
  730.                                                                                                     {
  731.                                                                                                     Map4[y][x] = ' ';
  732.                                                                                                     y += 1;
  733.                                                                                                     Map4[y2][x] = '@';
  734.                                                                                                     }  
  735.                                                                                                }break;
  736.                                                                              }
  737.                                                  }
  738.                                                  
  739.                                                  if (GetAsyncKeyState(VK_LEFT) != 0)
  740.                                                  {
  741.                                                                              int x2 = (x-1);
  742.                                                                              
  743.                                                                              switch(Map4[y][x2])
  744.                                                                              {
  745.                                                                                                case ' ':
  746.                                                                                                {
  747.                                                                                                     Map4[y][x] = ' ';
  748.                                                                                                     x -= 1;
  749.                                                                                                     Map4[y][x2] = '@';
  750.                                                                                                }break;
  751.                                                                                                case '-':
  752.                                                                                                {
  753.                                                                                                     Level = 5;    
  754.                                                                                                }break;
  755.                                                                                                case '*':
  756.                                                                                                {
  757.                                                                                                     Hp -= 5;
  758.                                                                                                     Map4[y][x] = ' ';
  759.                                                                                                     x -= 1;
  760.                                                                                                     Map4[y][x2] = '@';
  761.                                                                                                }break;
  762.                                                                                                case '+':
  763.                                                                                                {
  764.                                                                                                     Hp += 5;
  765.                                                                                                     Map4[y][x] = ' ';
  766.                                                                                                     x -= 1;
  767.                                                                                                     Map3[y][x2] = '@';
  768.                                                                                                }break;
  769.                                                                                                case 'K':
  770.                                                                                                {
  771.                                                                                                     key = 2;
  772.                                                                                                     Map4[y][x] = ' ';
  773.                                                                                                     x -= 1;
  774.                                                                                                     Map4[y][x2] = '@';  
  775.                                                                                                }break;
  776.                                                                                                case ':':
  777.                                                                                                {
  778.                                                                                                     if (key >= 2)
  779.                                                                                                     {
  780.                                                                                                     Map4[y][x] = ' ';
  781.                                                                                                     x -= 1;
  782.                                                                                                     Map4[y][x2] = '@';
  783.                                                                                                     }  
  784.                                                                                                }break;
  785.                                                                              }
  786.                                                  }
  787.                                                  
  788.                                                  if (GetAsyncKeyState(VK_RIGHT) != 0)
  789.                                                  {
  790.                                                                              int x2 = (x+1);
  791.                                                                              
  792.                                                                              switch(Map4[y][x2])
  793.                                                                              {
  794.                                                                                                case ' ':
  795.                                                                                                {
  796.                                                                                                     Map4[y][x] = ' ';
  797.                                                                                                     x += 1;
  798.                                                                                                     Map4[y][x2] = '@';
  799.                                                                                                }break;
  800.                                                                                                case '-':
  801.                                                                                                {
  802.                                                                                                     Level = 5;    
  803.                                                                                                }break;
  804.                                                                                                case '*':
  805.                                                                                                {
  806.                                                                                                     Hp -= 5;
  807.                                                                                                     Map4[y][x] = ' ';
  808.                                                                                                     x += 1;
  809.                                                                                                     Map4[y][x2] = '@';
  810.                                                                                                }break;
  811.                                                                                                case '+':
  812.                                                                                                {
  813.                                                                                                     Hp += 5;
  814.                                                                                                     Map4[y][x] = ' ';
  815.                                                                                                     x += 1;
  816.                                                                                                     Map4[y][x2] = '@';
  817.                                                                                                }break;
  818.                                                                                                case 'K':
  819.                                                                                                {
  820.                                                                                                     key = 2;
  821.                                                                                                     Map4[y][x] = ' ';
  822.                                                                                                     x += 1;
  823.                                                                                                     Map4[y][x2] = '@';  
  824.                                                                                                }break;
  825.                                                                                                case ':':
  826.                                                                                                {
  827.                                                                                                     if (key >= 2)
  828.                                                                                                     {
  829.                                                                                                     Map4[y][x] = ' ';
  830.                                                                                                     x += 1;
  831.                                                                                                     Map4[y][x2] = '@';
  832.                                                                                                     }  
  833.                                                                                                }break;
  834.                                                                              }
  835.                                                  }
  836.                                             }break;
  837.                            }
  838.                        }
  839.                    }
  840. }
  841.  
  842. void gameover()
  843. {
  844.      if (Hp <= 0)
  845.      {
  846.           setcolor(12);
  847.           cout << "\n\n\n###########\n";
  848.           cout << "#GAME OVER#\n";
  849.           cout << "###########\n";
  850.           setcolor(7);
  851.           system("pause >nul");
  852.      }    
  853. }
  854.  
  855. void stat()
  856. {
  857.      cout << "KEY: " << key << "\n";
  858.      cout << "\n\nHP: ";
  859.      setcolor(10); cout << Hp;
  860.      setcolor(7);
  861.      cout << " / ";
  862.      setcolor(12); cout << MaxHp << endl;
  863.      setcolor(7);
  864.      setcolor(10);
  865.      cout << "Level: " << Level;
  866.      setcolor(7);
  867.      Sleep(Gamespeed);
  868. }
  869.  
  870. int main()
  871. {
  872.     while(stopgame == false && menu == 0)
  873.     {
  874.                    menu:
  875.                    system("cls");
  876.                    setcolor(202);
  877.                    cout << "######################################\n";
  878.                    cout << "#                                    #\n";
  879.                    cout << "#            MENU                    #\n";
  880.                    cout << "#                                    #\n";
  881.                    cout << "#       1. Start Game                #\n";
  882.                    cout << "#       2. Level Select              #\n";
  883.                    cout << "#       3. Instructions              #\n";
  884.                    cout << "#       4. EXIT                      #\n";
  885.                    cout << "#                                    #\n";
  886.                    cout << "#                                    #\n";
  887.                    cout << "######################################\n\n";
  888.                    setcolor(7);
  889.                    cout << "Enter a choise: "; setcolor(10); cin >> input; setcolor(7);
  890.                    if(input == "1")
  891.                    {
  892.                             input.clear();
  893.                             goto lvl1;        
  894.                    }
  895.                    if(input == "2")
  896.                    {
  897.                             input.clear();
  898.                             goto lvlselect;        
  899.                    }
  900.                    if(input == "3")
  901.                    {
  902.                             input.clear();
  903.                             goto lvl1;        
  904.                    }
  905.                    if(input == "4")
  906.                    {
  907.                             input.clear();
  908.                             return 0;        
  909.                    }
  910.                    else
  911.                    {
  912.                             setcolor(10);
  913.                             cout << input;
  914.                             cout << " is not an option. Try again...\n";
  915.                             setcolor(7);
  916.                             system("pause >nul");
  917.                             input.clear();
  918.                             goto menu;    
  919.                    }
  920.     }
  921.     lvlselect:
  922.                    system("cls");
  923.                    setcolor(202);
  924.                    cout << "#############################################\n";
  925.                    cout << "#                                           #\n";
  926.                    cout << "#                LevelSelect                #\n";
  927.                    cout << "#                                           #\n";
  928.                    cout << "#    1. level1   5. level5   10. level10    #\n";
  929.                    cout << "#    2. level2   6. level6   11. level11    #\n";
  930.                    cout << "#    3. level3   7. level7   12. level12    #\n";
  931.                    cout << "#    4. level4   8. level8   13. level13    #\n";
  932.                    cout << "#    5. level5   9. level9   14. level14    #\n";
  933.                    cout << "#                                           #\n";
  934.                    cout << "#                 R - Return to main        #\n";
  935.                    cout << "#############################################\n\n";
  936.                    setcolor(7);
  937.                    cout << "Enter a choise: "; setcolor(10); cin >> input; setcolor(7);
  938.                    if(input == "1")
  939.                    {
  940.                             input.clear();
  941.                             goto lvl1;
  942.                    }
  943.                    if(input == "2")
  944.                    {
  945.                             input.clear();
  946.                             goto lvl2;
  947.                    }
  948.                    if(input == "3")
  949.                    {
  950.                             input.clear();
  951.                             goto lvl3;
  952.                    }
  953.                    if(input == "4")
  954.                    {
  955.                             input.clear();
  956.                             goto lvl4;
  957.                    }
  958.                    if(input == "5")
  959.                    {
  960.                             input.clear();
  961.                             goto lvl5;
  962.                    }
  963.                    if(input == "R" | input == "r")
  964.                    {
  965.                             input.clear();
  966.                             goto menu;
  967.                    }
  968.                    else
  969.                    {
  970.                             setcolor(10);
  971.                             cout << input;
  972.                             cout << " is not an option. Try again...\n";
  973.                             setcolor(7);
  974.                             system("pause >nul");
  975.                             input.clear();
  976.                             goto lvlselect;    
  977.                    }
  978.     while(stopgame == false && Level == 1)
  979.     {
  980.                    lvl1:
  981.                    Level = 1;
  982.                    system("cls");        
  983.                    gameover();
  984.                    for(int y = 0; y < 10; y++)
  985.                    {
  986.                        cout << Map[y] << endl;
  987.                    }
  988.                    stat();
  989.                    m1();                  
  990.     }
  991.     while(stopgame == false && Level == 2)
  992.     {
  993.                    lvl2:
  994.                    Level = 2;
  995.                    system("cls");
  996.                    gameover();
  997.                    for(int y = 0; y < 18; y++)
  998.                    {
  999.                        cout << Map2[y] << endl;
  1000.                    }
  1001.                    stat();
  1002.                    m2();                  
  1003.     }
  1004.     while(stopgame == false && Level == 3)
  1005.     {
  1006.                    lvl3:
  1007.                    Level = 3;
  1008.                    system("cls");
  1009.                    gameover();
  1010.                    for(int y = 0; y < 18; y++)
  1011.                    {
  1012.                        cout << Map3[y] << endl;
  1013.                    }
  1014.                    stat();
  1015.                    m3();                  
  1016.     }
  1017.     while(stopgame == false && Level == 4)
  1018.     {
  1019.                    lvl4:
  1020.                    Level = 4;
  1021.                    system("cls");
  1022.                    gameover();
  1023.                    for(int y = 0; y < 18; y++)
  1024.                    {
  1025.                        cout << Map4[y] << endl;
  1026.                    }
  1027.                    stat();
  1028.                    m4();                  
  1029.     }
  1030.     while(stopgame == false && Level == 5)
  1031.     {
  1032.                    lvl5:
  1033.                    Level = 5;
  1034.                    system("cls");
  1035.                    gameover();
  1036.                    for(int y = 0; y < 18; y++)
  1037.                    {
  1038.                        cout << Map4[y] << endl;
  1039.                    }
  1040.                    stat();
  1041.                    m4();
  1042.                    
  1043.     }
  1044.     return 0;
  1045. }
Advertisement
Add Comment
Please, Sign In to add comment