API tools faq
paste
Advertisement
Jaden11

C++[Lua] --test

Jaden11
Feb 10th, 2015
428
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Lua 17.57 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <conio.h>
  3. #include <windows.h>
  4. #include <ctime>
  5. #include <vector>
  6.  
  7. class game
  8. {
  9. private:
  10.     std::vector <int> fake;
  11.     char map[1800];
  12.     int x;//COORDINATES
  13.     int c;
  14.     int speed;
  15.     int points ;
  16.     int CurrentLevel;
  17.     bool check;
  18. public:
  19.     game()
  20.     {
  21.         x = 1940;
  22.         speed = 215;
  23.         check = 0;
  24.         points = 0;
  25.     }
  26.     void PrepareGraphics();
  27.     void graphics();
  28.     void LevelMenu();
  29.     void Levels();
  30.     void LOGIC();
  31.     void gameover();
  32.     friend void cls();
  33.     friend void sp();
  34.     friend void s();
  35. };
  36. void cls()
  37. {
  38.     HANDLE hOut;
  39.     COORD Position;
  40.  
  41.     hOut = GetStdHandle(STD_OUTPUT_HANDLE);
  42.  
  43.     Position.X = 0;
  44.     Position.Y = 0;
  45.     SetConsoleCursorPosition(hOut, Position);
  46. }
  47. void game::Levels() //Just minimize this function
  48. ////////////////////////////////////////////////////////////////////////////*//
  49. {
  50.     speed-=20;
  51.     for(int a = 0;a < 1800;a++)
  52.     {
  53.         map[a] = ' ';           //CLEAN IT FIRST
  54.     }
  55.     switch(CurrentLevel)
  56.     {
  57.     case 1://///////////////////////////////////////////////////////////////*//
  58.     for(int b = 0;b < 26;b++)
  59.     {
  60.         map[b + 7] = char(253);
  61.     }
  62.     for(int b = 0;b < 26;b++)
  63.     {
  64.         map[b + 47] = char(253);
  65.     }
  66.     for(int b = 0;b < 26;b++)
  67.     {
  68.         map[b + 87] = char(253);
  69.     }
  70.     for(int b = 0;b < 26;b++)
  71.     {
  72.         map[b + 127] = char(253);
  73.     }
  74.     for(int b = 0;b < 26;b++)
  75.     {
  76.         map[b + 167] = char(253);
  77.     }
  78.     for(int b = 0;b < 26;b++)
  79.     {
  80.         map[b + 207] = char(253);
  81.     }
  82.     break;
  83.     case 2://///////////////////////////////////////////////////////////////*//
  84.     for(int b = 0;b < 26;b++)
  85.     {
  86.         map[b + 7] = char(253);
  87.     }
  88.     for(int b = 0;b < 26;b++)
  89.     {
  90.         map[b + 47] = char(253);
  91.     }
  92.     for(int b = 0;b < 26;b++)
  93.     {
  94.         map[b + 87] = char(253);
  95.     }
  96.     for(int b = 0;b < 26;b++)
  97.     {
  98.         map[b + 127] = char(253);
  99.     }
  100.     for(int b = 0;b < 26;b++)
  101.     {
  102.         map[b + 167] = char(253);
  103.     }
  104.     for(int b = 0;b < 26;b++)
  105.     {
  106.         map[b + 207] = char(253);
  107.     }
  108.     for(int b = 0;b < 40;b++)
  109.     {
  110.         map[b + 240] = char(253);
  111.     }
  112.     for(int b = 0;b < 40;b++)
  113.     {
  114.         map[b + 280] = char(253);
  115.     }
  116.     break;
  117.     case 3://///////////////////////////////////////////////////////////////*//
  118.     for(int b = 0;b < 30;b++)
  119.     {
  120.         map[b + 5] = char(253);
  121.     }
  122.     for(int b = 0;b < 30;b++)
  123.     {
  124.         map[b + 45] = char(253);
  125.     }
  126.     for(int b = 0;b < 30;b++)
  127.     {
  128.         map[b + 85] = char(253);
  129.     }
  130.     for(int b = 0;b < 30;b++)
  131.     {
  132.         map[b + 125] = char(253);
  133.     }
  134.     for(int b = 0;b < 30;b++)
  135.     {
  136.         map[b + 165] = char(253);
  137.     }
  138.     for(int b = 0;b < 30;b++)
  139.     {
  140.         map[b + 205] = char(253);
  141.     }
  142.     for(int b = 0;b < 40;b++)
  143.     {
  144.         map[b + 240] = char(253);
  145.     }
  146.     for(int b = 0;b < 40;b++)
  147.     {
  148.         map[b + 280] = char(253);
  149.     }
  150.     for(int b = 0;b < 40;b++)
  151.     {
  152.         map[b + 320] = char(253);
  153.     }
  154.     break;
  155.     case 4://///////////////////////////////////////////////////////////////*//
  156.     for(int b = 0;b < 34;b++)
  157.     {
  158.         map[b + 3] = char(253);
  159.     }
  160.     for(int b = 0;b < 34;b++)
  161.     {
  162.         map[b + 43] = char(253);
  163.     }
  164.     for(int b = 0;b < 34;b++)
  165.     {
  166.         map[b + 83] = char(253);
  167.     }
  168.     for(int b = 0;b < 34;b++)
  169.     {
  170.         map[b + 123] = char(253);
  171.     }
  172.     for(int b = 0;b < 34;b++)
  173.     {
  174.         map[b + 163] = char(253);
  175.     }
  176.     for(int b = 0;b < 34;b++)
  177.     {
  178.         map[b + 203] = char(253);
  179.     }
  180.     for(int b = 0;b < 40;b++)
  181.     {
  182.         map[b + 240] = char(253);
  183.     }
  184.     for(int b = 0;b < 40;b++)
  185.     {
  186.         map[b + 280] = char(253);
  187.     }
  188.     for(int b = 0;b < 40;b++)
  189.     {
  190.         map[b + 320] = char(253);
  191.     }
  192.     for(int b = 0;b < 40;b++)
  193.     {
  194.         map[b + 360] = char(253);
  195.     }
  196.     break;
  197.     case 5://///////////////////////////////////////////////////////////////*//
  198.  
  199.     for(int b = 0;b < 38;b++)
  200.     {
  201.         map[b + 1] = char(253);
  202.     }
  203.     for(int b = 0;b < 38;b++)
  204.     {
  205.         map[b + 41] = char(253);
  206.     }
  207.     for(int b = 0;b < 38;b++)
  208.     {
  209.         map[b + 81] = char(253);
  210.     }
  211.     for(int b = 0;b < 38;b++)
  212.     {
  213.         map[b + 121] = char(253);
  214.     }
  215.     for(int b = 0;b < 38;b++)
  216.     {
  217.         map[b + 161] = char(253);
  218.     }
  219.     for(int b = 0;b < 38;b++)
  220.     {
  221.         map[b + 201] = char(253);
  222.     }
  223.     for(int b = 0;b < 40;b++)
  224.     {
  225.         map[b + 240] = char(253);
  226.     }
  227.     for(int b = 0;b < 40;b++)
  228.     {
  229.         map[b + 280] = char(253);
  230.     }
  231.     for(int b = 0;b < 40;b++)
  232.     {
  233.         map[b + 320] = char(253);
  234.     }
  235.     break;
  236.     case 6://///////////////////////////////////////////////////////////////*//
  237.     for(int b = 0;b < 34;b++)
  238.     {
  239.         map[b + 3] = char(253);
  240.     }
  241.     for(int b = 0;b < 34;b++)
  242.     {
  243.         map[b + 43] = char(253);
  244.     }
  245.     for(int b = 0;b < 34;b++)
  246.     {
  247.         map[b + 83] = char(253);
  248.     }
  249.     for(int b = 0;b < 34;b++)
  250.     {
  251.         map[b + 123] = char(253);
  252.     }
  253.     for(int b = 0;b < 34;b++)
  254.     {
  255.         map[b + 163] = char(253);
  256.     }
  257.     for(int b = 0;b < 34;b++)
  258.     {
  259.         map[b + 203] = char(253);
  260.     }
  261.     for(int b = 0;b < 40;b++)
  262.     {
  263.         map[b + 240] = char(253);
  264.     }
  265.     for(int b = 0;b < 40;b++)
  266.     {
  267.         map[b + 280] = char(253);
  268.     }
  269.     for(int b = 0;b < 40;b++)
  270.     {
  271.         map[b + 320] = char(253);
  272.     }
  273.     for(int b = 0;b < 40;b++)
  274.     {
  275.         map[b + 360] = char(253);
  276.     }
  277.     for(int b = 0;b < 40;b++)
  278.     {
  279.         map[b + 400] = char(253);
  280.     }
  281.     break;
  282.     case 7://///////////////////////////////////////////////////////////////*//
  283.     for(int b = 0;b < 40;b++)
  284.     {
  285.         map[b] = char(253);
  286.     }
  287.     for(int b = 0;b < 40;b++)
  288.     {
  289.         map[b + 40] = char(253);
  290.     }
  291.     for(int b = 0;b < 40;b++)
  292.     {
  293.         map[b + 80] = char(253);
  294.     }
  295.     for(int b = 0;b < 40;b++)
  296.     {
  297.         map[b + 120] = char(253);
  298.     }
  299.     for(int b = 0;b < 40;b++)
  300.     {
  301.         map[b + 160] = char(253);
  302.     }
  303.     for(int b = 0;b < 40;b++)
  304.     {
  305.         map[b + 200] = char(253);
  306.     }
  307.     for(int b = 0;b < 40;b++)
  308.     {
  309.         map[b + 240] = char(253);
  310.     }
  311.     for(int b = 0;b < 40;b++)
  312.     {
  313.         map[b + 280] = char(253);
  314.     }
  315.     for(int b = 0;b < 40;b++)
  316.     {
  317.         map[b + 320] = char(253);
  318.     }
  319.     for(int b = 0;b < 40;b++)
  320.     {
  321.         map[b + 360] = char(253);
  322.     }
  323.     break;
  324.     case 8://///////////////////////////////////////////////////////////////*//
  325.     for(int b = 0;b < 40;b++)
  326.     {
  327.         map[b] = char(253);
  328.     }
  329.     for(int b = 0;b < 40;b++)
  330.     {
  331.         map[b + 40] = char(253);
  332.     }
  333.     for(int b = 0;b < 40;b++)
  334.     {
  335.         map[b + 80] = char(253);
  336.     }
  337.     for(int b = 0;b < 40;b++)
  338.     {
  339.         map[b + 120] = char(253);
  340.     }
  341.     for(int b = 0;b < 40;b++)
  342.     {
  343.         map[b + 160] = char(253);
  344.     }
  345.     for(int b = 0;b < 40;b++)
  346.     {
  347.         map[b + 200] = char(253);
  348.     }
  349.     for(int b = 0;b < 40;b++)
  350.     {
  351.         map[b + 240] = char(253);
  352.     }
  353.     for(int b = 0;b < 40;b++)
  354.     {
  355.         map[b + 280] = char(253);
  356.     }
  357.     for(int b = 0;b < 40;b++)
  358.     {
  359.         map[b + 320] = char(253);
  360.     }
  361.     for(int b = 0;b < 40;b++)
  362.     {
  363.         map[b + 360] = char(253);
  364.     }
  365.     for(int b = 0;b < 40;b++)
  366.     {
  367.         map[b + 400] = char(253);
  368.     }
  369.     for(int b = 0;b < 40;b++)
  370.     {
  371.         map[b + 440] = char(253);
  372.     }
  373.     for(int b = 0;b < 40;b++)
  374.     {
  375.         map[b + 480] = char(253);
  376.     }
  377.     break;
  378.     case 9://///////////////////////////////////////////////////////////////*//
  379.     for(int b = 0;b < 40;b++)
  380.     {
  381.         map[b] = char(253);
  382.     }
  383.     for(int b = 0;b < 40;b++)
  384.     {
  385.         map[b + 40] = char(253);
  386.     }
  387.     for(int b = 0;b < 40;b++)
  388.     {
  389.         map[b + 80] = char(253);
  390.     }
  391.     for(int b = 0;b < 40;b++)
  392.     {
  393.         map[b + 120] = char(253);
  394.     }
  395.     for(int b = 0;b < 40;b++)
  396.     {
  397.         map[b + 160] = char(253);
  398.     }
  399.     for(int b = 0;b < 40;b++)
  400.     {
  401.         map[b + 200] = char(253);
  402.     }
  403.     for(int b = 0;b < 40;b++)
  404.     {
  405.         map[b + 240] = char(253);
  406.     }
  407.     for(int b = 0;b < 40;b++)
  408.     {
  409.         map[b + 280] = char(253);
  410.     }
  411.     for(int b = 0;b < 40;b++)
  412.     {
  413.         map[b + 320] = char(253);
  414.     }
  415.     for(int b = 0;b < 40;b++)
  416.     {
  417.         map[b + 360] = char(253);
  418.     }
  419.     for(int b = 0;b < 40;b++)
  420.     {
  421.         map[b + 400] = char(253);
  422.     }
  423.     for(int b = 0;b < 20 ;b++)
  424.     {
  425.         map[400 + 2 * b] = char(253);
  426.     }
  427.     for(int b = 0;b < 20 ;b++)
  428.     {
  429.         map[440 + 2 * b] = char(253);
  430.     }
  431.     break;
  432.     case 10://///////////////////////////////////////////////////////////////*//
  433.     for(int b = 0;b < 40;b++)
  434.     {
  435.         map[b] = char(253);
  436.     }
  437.     for(int b = 0;b < 40;b++)
  438.     {
  439.         map[b + 40] = char(253);
  440.     }
  441.     for(int b = 0;b < 40;b++)
  442.     {
  443.         map[b + 80] = char(253);
  444.     }
  445.     for(int b = 0;b < 40;b++)
  446.     {
  447.         map[b + 120] = char(253);
  448.     }
  449.     for(int b = 0;b < 40;b++)
  450.     {
  451.         map[b + 160] = char(253);
  452.     }
  453.     for(int b = 0;b < 40;b++)
  454.     {
  455.         map[b + 200] = char(253);
  456.     }
  457.     for(int b = 0;b < 40;b++)
  458.     {
  459.         map[b + 240] = char(253);
  460.     }
  461.     for(int b = 0;b < 40;b++)
  462.     {
  463.         map[b + 280] = char(253);
  464.     }
  465.     for(int b = 0;b < 40;b++)
  466.     {
  467.         map[b + 320] = char(253);
  468.     }
  469.     for(int b = 0;b < 40;b++)
  470.     {
  471.         map[b + 360] = char(253);
  472.     }
  473.     for(int b = 0;b < 40;b++)
  474.     {
  475.         map[b + 400] = char(253);
  476.     }
  477.     for(int b = 0;b < 20 ;b++)
  478.     {
  479.         map[400 + 2 * b] = char(253);
  480.     }
  481.     for(int b = 0;b < 20 ;b++)
  482.     {
  483.         map[440 + 2 * b] = char(253);
  484.     }
  485.     for(int b = 0;b < 20 ;b++)
  486.     {
  487.         map[480 + 2 * b] = char(253);
  488.     }
  489.     for(int b = 0;b < 20 ;b++)
  490.     {
  491.         map[520 + 2 * b] = char(253);
  492.     }
  493.     for(int b = 0;b < 20 ;b++)
  494.     {
  495.         map[560 + 2 * b] = char(253);
  496.     }
  497.     break;
  498.     case 11:
  499.         for(int b = 0;b < 40;b++)
  500.     {
  501.         map[b] = char(253);
  502.     }
  503.     for(int b = 0;b < 40;b++)
  504.     {
  505.         map[b + 40] = char(253);
  506.     }
  507.     for(int b = 0;b < 40;b++)
  508.     {
  509.         map[b + 80] = char(253);
  510.     }
  511.     for(int b = 0;b < 40;b++)
  512.     {
  513.         map[b + 120] = char(253);
  514.     }
  515.     for(int b = 0;b < 40;b++)
  516.     {
  517.         map[b + 160] = char(253);
  518.     }
  519.     for(int b = 0;b < 40;b++)
  520.     {
  521.         map[b + 200] = char(253);
  522.     }
  523.     for(int b = 0;b < 40;b++)
  524.     {
  525.         map[b + 240] = char(253);
  526.     }
  527.     for(int b = 0;b < 40;b++)
  528.     {
  529.         map[b + 280] = char(253);
  530.     }
  531.     for(int b = 0;b < 40;b++)
  532.     {
  533.         map[b + 320] = char(253);
  534.     }
  535.     for(int b = 0;b < 40;b++)
  536.     {
  537.         map[b + 360] = char(253);
  538.     }
  539.     for(int b = 0;b < 40;b++)
  540.     {
  541.         map[b + 400] = char(253);
  542.     }
  543.     for(int b = 0;b < 20 ;b++)
  544.     {
  545.         map[400 + 2 * b] = char(253);
  546.     }
  547.     for(int b = 0;b < 20 ;b++)
  548.     {
  549.         map[440 + 2 * b] = char(253);
  550.     }
  551.     for(int b = 0;b < 20 ;b++)
  552.     {
  553.         map[480 + 2 * b] = char(253);
  554.     }
  555.     for(int b = 0;b < 20 ;b++)
  556.     {
  557.         map[520 + 2 * b] = char(253);
  558.     }
  559.     for(int b = 0;b < 20 ;b++)
  560.     {
  561.         map[560 + 2 * b] = char(253);
  562.     }
  563.     break;
  564.  
  565.     default:
  566.         system("cls");
  567.         std::cout << "CONGRULATIONS ";
  568.         Sleep(5000);
  569.         }
  570. PrepareGraphics();
  571. }
  572. //////////////////////////////////////////////////////////////////////////
  573. void sp(int spalva)
  574. {
  575.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), spalva);
  576. }
  577. void game::LevelMenu()
  578. {
  579.     std::cout <<"CONTROLS: > ^ < for moving and  1 / 2  for shooting...";
  580.     Sleep(4500);
  581.     system("cls");
  582.     system("color a5");
  583.     sp(481);
  584.     std::cout << "CHOOSE YOUR LEVEL:";
  585.     std::cout <<"1." << std::endl;
  586.     std::cout <<"2." << std::endl;
  587.     std::cout <<"3." << std::endl;
  588.     std::cout <<"4." << std::endl;
  589.     std::cout <<"5." << std::endl;
  590.     std::cout <<"6." << std::endl;
  591.     std::cout <<"7." << std::endl;
  592.     std::cout <<"8." << std::endl;
  593.     std::cout <<"9." << std::endl;
  594.     std::cout <<"10."<< std::endl;
  595.     std::cout <<"11."<< std::endl;
  596.     int y;
  597.     while(y > 12 || y < 1)
  598.     {
  599.         std::cin >> y;
  600.     }
  601.     if(y == 1)
  602.     {
  603.         CurrentLevel = 1;
  604.         speed = 215;
  605.     }
  606.     else if(y == 2)
  607.     {
  608.         CurrentLevel = 2;
  609.         speed = 195;
  610.     }
  611.     else if(y == 3)
  612.     {
  613.         CurrentLevel = 3;
  614.         speed = 175;
  615.     }
  616.     else if(y == 4)
  617.     {
  618.         CurrentLevel = 4;
  619.         speed = 155;
  620.     }
  621.     else if(y == 5)
  622.     {
  623.         CurrentLevel = 5;
  624.         speed = 135;
  625.     }
  626.     else if(y == 6)
  627.     {
  628.         CurrentLevel = 6;
  629.         speed = 115;
  630.     }
  631.     else if(y == 7)
  632.     {
  633.         CurrentLevel = 7;
  634.         speed = 95;
  635.     }
  636.     else if(y == 8)
  637.     {
  638.         CurrentLevel = 8;
  639.         speed = 75;
  640.     }
  641.     else if(y == 9)
  642.     {
  643.         CurrentLevel = 9;
  644.         speed = 55;
  645.     }
  646.     else if(y == 10)
  647.     {
  648.         CurrentLevel = 10;
  649.         speed =35 ;
  650.     }
  651.     else if(y == 11)
  652.     {
  653.         CurrentLevel = 11;
  654.         speed = 28;
  655.     }
  656.     std::cout << "GET READY.";
  657.     Sleep(2500);
  658.     Levels();
  659. }
  660.  
  661. void game::PrepareGraphics()
  662. {
  663.     x = 1140;
  664.     map[x] = 'H';
  665.     graphics();
  666. }
  667.  
  668. void game::graphics()
  669. {
  670.     c = 0;
  671.     for(int CheckingForWin = 0;CheckingForWin < 40;CheckingForWin++)
  672.     {
  673.         if(map[CheckingForWin] == ' ')
  674.         {
  675.             c++;
  676.         }
  677.     }
  678.     if(c == 40)
  679.     {
  680.         CurrentLevel++;
  681.         std::cout << "Congrulations,you have passed this level\n,let's try another one!";
  682.         Sleep(4000);
  683.         Levels();
  684.     }
  685.     std::cout << std::endl;
  686.     for(int k = 0;k < 40;k++ )
  687.     {
  688.         std::cout << char(219);
  689.     }
  690.     std::cout << std::endl;
  691.  
  692.     for(int u = 0;u < 1800;u++)
  693.     {
  694.         if(u!= 0 && u % 40 == 0)
  695.         {
  696.             std::cout << std::endl;
  697.         }
  698.         /////////////////////////////////////
  699.         /////////////////////////////////////
  700.         /////////////////////////////////////
  701.         if(map[u + 40] == char(173))
  702.         {
  703.             map[u + 40] = ' ';
  704.             if(map[u]!=char(253))
  705.             {
  706.                 map[u] = char(173);
  707.             }
  708.             else
  709.             {
  710.                 map[u] = ' ';
  711.                 points++;
  712.             }
  713.         }
  714.         else if(u <= 39 && map[u] == char(173))
  715.         {
  716.             map[u] = ' ';
  717.         }
  718.         if(map[u] == char(253) && map[u + 40 ] != char(253))
  719.         {
  720.             c = rand() % speed + 1;
  721.             if(c == 5)
  722.             {
  723.                 map[u + 40] = 'o';
  724.             }
  725.         };
  726.         if(map[u] == 'o')
  727.         {
  728.             for(unsigned int g = 0;g != fake.size();g++)
  729.             {
  730.                     if(fake[g] == u)
  731.                     {
  732.                         g = fake.size() - 1;
  733.                         check = 1;
  734.                     }
  735.             }
  736.             if(!check)
  737.             {
  738.                 map[u] = ' ';
  739.                 if(x == u + 40)
  740.                 {
  741.                     gameover();
  742.                 }
  743.                 map[u + 40] = 'o';
  744.                 fake.push_back(u + 40);
  745.             }
  746.         };
  747.         check = 0;
  748.         std::cout << map[u];
  749.     }
  750.     for(int h = 1760;h < 1800;h++)
  751.     {
  752.         if(map[h] == 'o')
  753.         {
  754.             map[h] = ' ';
  755.         }
  756.     }
  757.     fake.clear();
  758.     std::cout << std::endl;
  759.     for(int k = 0;k < 40;k++ )
  760.     {
  761.         std::cout << char(219);
  762.     }
  763.     std::cout << std::endl;
  764.     std::cout << "\n\n\n\n            Points:" << points;
  765.     LOGIC();
  766. }
  767.  
  768. void game::gameover()
  769. {
  770.     system("cls");
  771.     std::cout <<"GG,YOU'VE JUST LOSE!";
  772.     std::cout <<"You scored " << points << " points\n";
  773.     Sleep(2000);
  774.     std::cout <<"Restarting...";
  775.     Sleep(2000);
  776.     system("cls");
  777.     system("color a5");
  778.     sp(481);
  779.     LevelMenu();
  780. }
  781. void game::LOGIC()
  782. {
  783.              if (GetAsyncKeyState(VK_LEFT))
  784.         {
  785.             if(x % 40 != 0)
  786.             {
  787.                 if(map[x - 1] == 'o')
  788.                 {
  789.                     gameover();
  790.                 };
  791.                 x--;
  792.                 map[x + 1] = ' ';
  793.                 map[x] = 'H';
  794.             }
  795.         }
  796.         else if (GetAsyncKeyState(VK_RIGHT))
  797.         {
  798.             if((x + 1) % 40 != 0)
  799.             {
  800.                 if(map[x + 1] == 'o')
  801.                 {
  802.                     gameover();
  803.                 };
  804.                 x++;
  805.                 map[x - 1] = ' ';
  806.                 map[x] = 'H';
  807.             }
  808.         }
  809.         else if (GetAsyncKeyState(VK_UP))
  810.         {
  811.             if(x > 480)
  812.             {
  813.                 x-=40;
  814.                 map[x+40] = ' ';
  815.                 map[x] = 'H';
  816.             }
  817.         }
  818.         else if (GetAsyncKeyState(VK_DOWN))
  819.         {
  820.             if(x < 1760 )
  821.             {
  822.                 x+=40;
  823.                 map[x - 40] = ' ';
  824.                 map[x] = 'H';
  825.             }
  826.         }
  827.         else{}
  828.         if(_kbhit())
  829.         {
  830.             char l = _getch();
  831.             if(l == '1' || l == '2')
  832.             {
  833.                 map[x - 40] = char(173);
  834.             };
  835.         }
  836.     cls();
  837.     graphics();
  838. }
  839.  
  840. int main()
  841. {
  842.     system("color a5");
  843.     sp(481);
  844.     srand((unsigned)time(0));
  845.     game *memb;
  846.     memb = new game;
  847.     memb->LevelMenu();
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!