Facebook
From Marcin, 3 Years ago, written in Plain Text.
Embed
Download Paste or View Raw
Hits: 134
  1. #include <iostream>
  2. #include <vector>
  3. #include <queue>
  4. #include <stack>
  5. #include <windows.h>
  6. #include <ctime>
  7. using namespace std;
  8.  
  9. const int MAX_MAP_LENGTH = 13;  // Długość planszy
  10.  
  11. enum block_type {
  12.         NORMAL,
  13.         EXTRA_POINT,
  14.         DELETE_ROW,
  15.         EMPTY
  16. };
  17.  
  18. class block {
  19. private:
  20.         block_type type_;
  21.  
  22. public:
  23.         explicit block(block_type type = NORMAL) : type_(type) {}
  24.  
  25.         string display()
  26.         {
  27.                 switch (type_)
  28.                 {
  29.                 case NORMAL: return " #### ";
  30.                 case EXTRA_POINT: return " #+1# ";
  31.                 case DELETE_ROW: return " #--# ";
  32.                 case EMPTY: return "      ";
  33.                 default: throw ("Nie ma takiego bloczka");
  34.                 }
  35.         }
  36. };
  37.  
  38.  
  39.  
  40. // Losowanie rodzaju bloczka   
  41. block generate_random_block()
  42. {
  43.         int rand_ = rand() % 100;
  44.         if (rand_ < 15) return block(EXTRA_POINT);
  45.         else if (rand_ < 25) return block(DELETE_ROW);
  46.         else return block(NORMAL);
  47. }
  48. // Generowanie mapy
  49. void generate_map(vector<queue<block>>& map, int& k, int& b)
  50. {
  51.         for (int i = 0; i < k; i++)
  52.         {
  53.                 map.push_back(queue<block>());
  54.                 for (int j = 0; j < b; j++)
  55.                         map[i].push(generate_random_block());
  56.         }
  57. }
  58.  
  59. void delete_map(vector<queue<block>>& map, int& k, int& b)
  60. {
  61.        
  62.         for (int i = 0; i < k; i++)
  63.         {
  64.                 map.pop_back();
  65.                 for (int l = 0; l < map.size(); l++)
  66.                 {
  67.                         while (!map[l].empty())
  68.                         {
  69.                         map[l].pop();
  70.                         }
  71.                 }
  72.         }
  73. }
  74.  
  75. void getData(vector<queue<block>>& map ,int& k, int& b, int& n, int& r)
  76. {
  77.         system("CLS");
  78.         delete_map(map, k, b);
  79.         cout << endl << "Podaj liczbe kolumn: ";
  80.         cin >> k;
  81.         cout << endl << "Podaj liczbe bloczkow w kolumnie: ";
  82.         cin >> b;
  83.         cout << endl << "Podaj zakres randomowej szybkosci posuwania planszy: ";
  84.         cin >> n;
  85.         cout << endl << "Podaj wartosc startowa posuwania plaszy: ";
  86.         cin >> r;
  87.         cout << endl;
  88.         generate_map(map, k, b);
  89. }
  90.  
  91. void show_map(vector<queue<block>> b)
  92. {
  93.         stack<block> swaped;
  94.  
  95.         for (int k = 0; k < b.size(); k++)
  96.         {
  97.                 while (!b[k].empty())
  98.                 {
  99.                         swaped.push(b[k].front());
  100.                         b[k].pop();
  101.                 }
  102.  
  103.                 while (!swaped.empty())
  104.                 {
  105.                         b[k].push(swaped.top());
  106.                         swaped.pop();
  107.                 }
  108.         }
  109.  
  110.         for (int i = 0; i < MAX_MAP_LENGTH; i++)
  111.         {
  112.                 for (int j = 0; j < b.size(); j++)
  113.                         if (!b[j].empty())
  114.                         {
  115.                                 cout << b[j].front().display();
  116.                                 b[j].pop();
  117.                         }
  118.                         else cout << "      ";
  119.                 cout << endl;
  120.         }
  121. }
  122.  
  123. void instrukcja() {
  124.         cout << "#### Blok za 1pkt" << endl;
  125.         cout << "#+1# Blok za 2pkt" << endl;
  126.         cout << "#--# Blok usuwajacy caly wiersz" << endl;
  127.         system("pause");
  128. }
  129.  
  130. // Dodanie wiersza
  131. void add_row(vector<queue<block>>& blocks_)
  132. {
  133.         for (int i = 0; i < blocks_.size(); i++)
  134.         {
  135.                 blocks_[i].push(generate_random_block());
  136.         }
  137. }
  138. // Usunięcie wiersza (BONUS)
  139. void delete_row(vector<queue<block>>& map)
  140. {
  141.         for (int i = 0; i < map.size(); i++)
  142.                 if (!map[i].empty())
  143.                         map[i].pop();
  144. }
  145. // Usunięcie wybranego bloku
  146. void remove_block(vector<queue<block>>& map, int& points, int column, int k)
  147. {
  148.         if (!map[column].empty() and column < k)
  149.         {
  150.                 string removed_block = map[column].front().display();
  151.                 if (removed_block == " #--# ")
  152.                 {
  153.                         delete_row(map);                // Usunięcie wiersza (BONUS)
  154.                         ++points;
  155.                 }
  156.                 else if (removed_block == " #+1# ")
  157.                 {
  158.                         map[column].pop();
  159.                         points += 2;    // Dodatkowy punkt (BONUS)
  160.                 }
  161.                 else
  162.                 {
  163.                         map[column].pop();      // Usunięcie wybranego bloczku
  164.                         ++points;
  165.                 }
  166.         }
  167.  
  168. }
  169.  
  170. // Sprawdzenie przegrania
  171. bool check_end(vector<queue<block>> map, int points)
  172. {
  173.                 for (int i = 0; i < map.size(); i++)
  174.                 {
  175.                         if (map[i].size() > MAX_MAP_LENGTH)
  176.                         {
  177.                                 cout << "Ups! Przegrales :( Zdobyles " << points << " punktow." << endl;
  178.                                 system("pause");
  179.                                 return true;
  180.                         }
  181.                 }
  182.                 return false;
  183. }
  184.  
  185. // Sprawdzenie wygrania
  186. bool check_win(vector<queue<block>> map, int points)
  187. {
  188.         bool win;
  189.         win = false;
  190.         for (int i = 0; i < map.size(); i++)
  191.         {
  192.                 if (map[i].empty()) win = true;
  193.                 else
  194.                 {
  195.                         win = false;
  196.                         break;
  197.                 };
  198.         }
  199.         if (win)
  200.         {
  201.                 system("CLS");
  202.                 show_map(map);
  203.                 cout << "Brawo! Wygrales :) Zdobyles " << points << " punktow." << endl;
  204.                 system("pause");
  205.                 return true;
  206.  
  207.         }
  208.         else return false;
  209. }
  210. void game_loop(vector<queue<block>> map, int k, int b, int n, int r)
  211. {
  212.         int points = 0;         // Zdobyte punkty
  213.         int new_row = r + rand() % n;
  214.         int column;
  215.         do
  216.         {
  217.                 system("CLS");
  218.                 show_map(map);
  219.                 cout << "Zdobyte punkty: " << points << endl;
  220.                 cin >> column;
  221.                 remove_block(map, points, column - 1, k);
  222.                 new_row--;
  223.                 Sleep(50);
  224.                 if (new_row == 0)
  225.                 {
  226.                         new_row = r + rand() % n;
  227.                         add_row(map);
  228.                 }
  229.         } while ((!check_win(map, points)) and (!check_end(map,points)));
  230.  
  231.        
  232. }
  233. void pisz_menu(int nr)
  234. {
  235.         system("CLS");
  236.         switch (nr)
  237.         {
  238.         case 1: {
  239.                 cout << endl;
  240.                 cout << "MENU glowne" << endl;
  241.                 cout << "----------------------" << endl;
  242.                 cout << "1 - Start Gry " << endl;
  243.                 cout << "2 - Ustawienia" << endl;
  244.                 cout << "3 - Instrukcja" << endl;
  245.                 cout << "0 - koniec pracy" << endl;
  246.                 cout << "> ";
  247.                 break;
  248.         }
  249.         }
  250. }
  251. void menu_main(vector<queue<block>> map, int& k, int& b, int& n, int& r)
  252. {
  253.         int wybor;
  254.  
  255.         do {
  256.                 pisz_menu(1);
  257.                 cin >> wybor;
  258.                 switch (wybor)
  259.                 {
  260.                 case 1:  game_loop(map, k, b, n, r);
  261.                         break;
  262.                 case 2: getData(map,k, b, n, r);
  263.                         break;
  264.                 case 3: instrukcja();
  265.                         break;
  266.                 }
  267.         } while (wybor != 0);
  268. }
  269.  
  270. int main()
  271. {
  272.         srand(time(NULL));
  273.         int k = 7;                              // kolumny
  274.         int b = 5;                              // liczba bloczków w kolumnie
  275.         int n = 5;                      // zakres szybkości dodawania bloczków
  276.         int r = 10;                             // zmienna do dodawania bloczków
  277.  
  278.         vector< queue<block> > map;
  279.  
  280.         generate_map(map, k, b);
  281.         menu_main(map, k, b, n, r);
  282.  
  283. }