This week only. Pastebin PRO Accounts Christmas Special! Don't miss out!Want more features on Pastebin? Sign Up, it's FREE!
Guest

elixia

By: a guest on Feb 26th, 2013  |  syntax: C++  |  size: 13.78 KB  |  views: 67  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. #include <ncurses.h> //for initscr() ... endwin()
  2. #include <ciso646> //&& = and, ^ = xor, etc.
  3. #include <vector> //for std::vector
  4. #include <cstdlib> //std:: library functions and macros
  5. #include <ctime> //seeding rand()
  6. #include <cmath> //rand()
  7. #include <cstring> //c-style string operations
  8. #include <unistd.h>
  9.  
  10. #define _tab_size__ "     " //my tab size which is five spaces
  11.  
  12. using namespace std;
  13.  
  14. bool validMove(wchar_t, int, int, vector<int>&); //make sure the player can move there
  15. bool validMove(wchar_t, int, vector<int>&, int, int);
  16. void help(); //display help message
  17. bool fight(int&);
  18.  
  19. int main()
  20. {
  21.      printf("\033]0;Elixia\007");
  22.      srand(time(NULL)); //seed rand
  23.  
  24.      vector<int> objCoor(1); //coordinates of the objects to pick up
  25.      vector<int> shopCoor(1);
  26.      int counter, subCounter, turnCounter, noOfObj, playerCoor; //misc int declarations
  27.      int boardSize, currentLevel, winRow, winCol, noOfShops, health; //misc int declarations
  28.      vector<char> board(1); //hold the board
  29.      char playerSymbol;
  30.      wchar_t action;
  31.      bool canMove;
  32.  
  33.      char getSym[] = "Enter Character Symbol"; //shortcut
  34.  
  35.      initscr(); //start the ncurses session
  36.  
  37.      cbreak(); //start reading characters immediately
  38.      noecho(); //don't show the
  39.      keypad(stdscr, TRUE);
  40.      start_color();
  41.      curs_set(0);
  42.  
  43.      init_pair(1, COLOR_RED, COLOR_WHITE);
  44.      init_pair(2, COLOR_GREEN, COLOR_WHITE);
  45.      init_pair(3, COLOR_BLACK, COLOR_WHITE);
  46.      init_pair(4, COLOR_CYAN, COLOR_WHITE);
  47.  
  48.      clear();
  49.      attron(A_UNDERLINE);
  50.      getmaxyx(stdscr, winRow, winCol);
  51.      mvprintw(winRow / 2, (winCol - strlen(getSym)) / 2, "%s", getSym);
  52.      attroff(A_UNDERLINE);
  53.      refresh();
  54.  
  55.      playerSymbol = getch();
  56.  
  57.      currentLevel = 1;
  58.  
  59.      while(true)
  60.      {
  61.           boardSize = 9 + currentLevel;
  62.           board.resize(boardSize * boardSize);
  63.           noOfObj = boardSize / 2;
  64.           objCoor.resize(noOfObj);
  65.           turnCounter = 0;
  66.           noOfShops = noOfObj / 2;
  67.           shopCoor.resize(noOfShops);
  68.           health = 20;
  69.  
  70.           for(counter = 0; counter < boardSize; counter = counter + 1)
  71.                for(subCounter = 0; subCounter < boardSize; subCounter = subCounter + 1)
  72.                     board[subCounter + (counter * boardSize)] = ' ';
  73.  
  74.           playerCoor = rand() % (boardSize * boardSize);
  75.           board[playerCoor] = playerSymbol;
  76.  
  77.           for(counter = 0; counter < noOfObj;)
  78.           {
  79.                objCoor[counter] = rand() % (boardSize * boardSize);
  80.  
  81.                if(board[objCoor[counter]] not_eq ' ')
  82.                     continue;
  83.  
  84.                board[objCoor[counter]] = '@';
  85.                counter = counter + 1;
  86.           }
  87.  
  88.           while(noOfObj > 0)
  89.           {
  90.                clear();
  91.                printw("Level %d Enemies Left: %d Turns: %d\n", currentLevel, noOfObj, turnCounter);
  92.  
  93.                for(counter = 0; counter < boardSize; counter = counter + 1)
  94.                {
  95.                     for(subCounter = 0; subCounter < boardSize; subCounter = subCounter + 1)
  96.                     {
  97.                          if(board[subCounter + (counter * boardSize)] == playerSymbol)
  98.                          {
  99.                               attron(COLOR_PAIR(1));
  100.                               printw("%c", board[subCounter + (counter * boardSize)]);
  101.                               attroff(COLOR_PAIR(1));
  102.                          }
  103.  
  104.                          else if(board[subCounter + (counter * boardSize)] == '@')
  105.                          {
  106.                               attron(COLOR_PAIR(2));
  107.                               printw("%c", board[subCounter + (counter * boardSize)]);
  108.                               attroff(COLOR_PAIR(2));
  109.                          }
  110.  
  111.                          else
  112.                          {
  113.                               attron(COLOR_PAIR(3));
  114.                               printw("%c", board[subCounter + (counter * boardSize)]);
  115.                               attroff(COLOR_PAIR(3));
  116.                          }
  117.  
  118.                          if(subCounter not_eq (boardSize - 1))
  119.                          {
  120.                               attron(COLOR_PAIR(3));
  121.                               printw(" ");
  122.                               attroff(COLOR_PAIR(3));
  123.                          }
  124.                     }
  125.  
  126.                     printw("\n");
  127.                }
  128.  
  129.                refresh();
  130.                action = getch();
  131.  
  132.                canMove = validMove(action, boardSize, playerCoor, objCoor);
  133.  
  134.                switch(action)
  135.                {
  136.                     case 'h':
  137.                          help();
  138.                          break;
  139.  
  140.                     case 'q':
  141.                          endwin();
  142.                          exit(1);
  143.                          break;
  144.  
  145.                     case KEY_UP:
  146.                          if(canMove)
  147.                          {
  148.                               board[playerCoor] = ' ';
  149.                               playerCoor = playerCoor - boardSize;
  150.                               turnCounter = turnCounter + 1;
  151.                          }
  152.  
  153.                          break;
  154.  
  155.                     case KEY_DOWN:
  156.                          if(canMove)
  157.                          {
  158.                               board[playerCoor] = ' ';
  159.                               playerCoor = playerCoor + boardSize;
  160.                               turnCounter = turnCounter + 1;
  161.                          }
  162.  
  163.                          break;
  164.  
  165.                     case KEY_LEFT:
  166.                          if(canMove)
  167.                          {
  168.                               board[playerCoor] = ' ';
  169.                               playerCoor = playerCoor - 1;
  170.                               turnCounter = turnCounter + 1;
  171.                          }
  172.  
  173.                          break;
  174.  
  175.                     case KEY_RIGHT:
  176.                          if(canMove)
  177.                          {
  178.                               board[playerCoor] = ' ';
  179.                               playerCoor = playerCoor + 1;
  180.                               turnCounter = turnCounter + 1;
  181.                          }
  182.  
  183.                          break;
  184.  
  185.                     default:
  186.                          continue;
  187.                }
  188.  
  189.                board[playerCoor] = playerSymbol;
  190.  
  191.                for(counter = 0; counter < noOfObj; counter = counter + 1)
  192.                     if(((playerCoor + 1) == objCoor[counter]) or ((playerCoor - 1) == objCoor[counter])
  193.                          or ((playerCoor + boardSize) == objCoor[counter]) or ((playerCoor - boardSize) == objCoor[counter]))
  194.                     {
  195.                          if(!fight(health))
  196.                          {
  197.                               endwin();
  198.                               exit(1);
  199.                          }
  200.  
  201.                          else
  202.                          {
  203.                               noOfObj = noOfObj - 1;
  204.                               board[objCoor[counter]] = ' ';
  205.                               objCoor.erase(objCoor.begin() + counter);
  206.                          }
  207.                     }
  208.  
  209.                for(counter = 0; counter < noOfObj;)
  210.                {
  211.                     subCounter = rand() % 4;
  212.  
  213.                     switch(subCounter)
  214.                     {
  215.                          case 0:
  216.                               if(validMove(KEY_UP, boardSize, objCoor, objCoor[counter], playerCoor))
  217.                               {
  218.                                    board[objCoor[counter]] = ' ';
  219.                                    objCoor[counter] = objCoor[counter] - boardSize;
  220.                               }
  221.  
  222.                               break;
  223.  
  224.                          case 1:
  225.                               if(validMove(KEY_DOWN, boardSize, objCoor, objCoor[counter], playerCoor))
  226.                               {
  227.                                    board[objCoor[counter]] = ' ';
  228.                                    objCoor[counter] = objCoor[counter] + boardSize;
  229.                               }
  230.  
  231.                               break;
  232.  
  233.                          case 2:
  234.                               if(validMove(KEY_LEFT, boardSize, objCoor, objCoor[counter], playerCoor))
  235.                               {
  236.                                    board[objCoor[counter]] = ' ';
  237.                                    objCoor[counter] = objCoor[counter] - 1;
  238.                               }
  239.  
  240.                               break;
  241.  
  242.                          case 3:
  243.                               if(validMove(KEY_RIGHT, boardSize, objCoor, objCoor[counter], playerCoor))
  244.                               {
  245.                                    board[objCoor[counter]] = ' ';
  246.                                    objCoor[counter] = objCoor[counter] + 1;
  247.                               }
  248.  
  249.                               break;
  250.                     }
  251.  
  252.                     if(!canMove)
  253.                          continue;
  254.  
  255.                     board[objCoor[counter]] = '@';
  256.                     counter = counter + 1;
  257.                }
  258.  
  259.                for(counter = 0; counter < noOfObj; counter = counter + 1)
  260.                     if(((objCoor[counter] + 1) == playerCoor) or ((objCoor[counter] - 1) == playerCoor)
  261.                          or ((objCoor[counter] + boardSize) == playerCoor) or ((objCoor[counter] - boardSize) == playerCoor))
  262.                     {
  263.                          if(!fight(health))
  264.                          {
  265.                               endwin();
  266.                               exit(1);
  267.                          }
  268.  
  269.                          else
  270.                          {
  271.                               noOfObj = noOfObj - 1;
  272.                               board[objCoor[counter]] = ' ';
  273.                               objCoor.erase(objCoor.begin() + counter);
  274.                          }
  275.                     }
  276.           }
  277.  
  278.           clear();
  279.           printw("You Won!!! Do you want to play again (y/n)");
  280.           refresh();
  281.  
  282.           do
  283.           {
  284.                action = getch();
  285.  
  286.                switch(action)
  287.                {
  288.                     case 'n':
  289.                          endwin();
  290.                          exit(1);
  291.                          break;
  292.  
  293.                     default:
  294.                          continue;
  295.                }
  296.           }while(action not_eq 'y');
  297.  
  298.           currentLevel = currentLevel + 1;
  299.      }
  300.  
  301.      endwin();
  302.      return 0;
  303. }
  304.  
  305. bool validMove(wchar_t direction, int boardSize, int playerCoor, vector<int> &objCoor)
  306. {
  307.      int counter;
  308.  
  309.      if(direction == KEY_UP and playerCoor > (boardSize - 1))
  310.      {
  311.           for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
  312.                if((playerCoor - boardSize) == objCoor[counter])
  313.                     return false;
  314.  
  315.           return true;
  316.      }
  317.  
  318.      else if(direction == KEY_DOWN and playerCoor < ((boardSize * boardSize) - boardSize))
  319.      {
  320.           for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
  321.                if((playerCoor + boardSize) == objCoor[counter])
  322.                     return false;
  323.  
  324.           return true;
  325.      }
  326.  
  327.      else if(direction == KEY_LEFT)
  328.      {
  329.           for(counter = 0; counter < boardSize; counter = counter + 1)
  330.                if(playerCoor == (counter * boardSize))
  331.                     return false;
  332.  
  333.           for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
  334.                if((playerCoor - 1) == objCoor[counter])
  335.                     return false;
  336.  
  337.           return true;
  338.      }
  339.  
  340.      else if(direction == KEY_RIGHT)
  341.      {
  342.           for(counter = 0; counter < boardSize; counter = counter + 1)
  343.                if(playerCoor == ((counter * boardSize) + boardSize - 1))
  344.                     return false;
  345.  
  346.           for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
  347.                if((playerCoor + 1) == objCoor[counter])
  348.                     return false;
  349.  
  350.           return true;
  351.      }
  352.  
  353.      return false;
  354. }
  355.  
  356. bool validMove(wchar_t direction, int boardSize, vector<int> &objCoor, int currentObj, int playerCoor)
  357. {
  358.      int counter;
  359.  
  360.      if(direction == KEY_UP and currentObj > (boardSize - 1))
  361.      {
  362.           for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
  363.                if(((currentObj - boardSize) == objCoor[counter]) or (currentObj - boardSize) == playerCoor)
  364.                     return false;
  365.  
  366.           return true;
  367.      }
  368.  
  369.      else if(direction == KEY_DOWN and currentObj < ((boardSize * boardSize) - boardSize))
  370.      {
  371.           for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
  372.                if(((currentObj + boardSize) == objCoor[counter]) or (currentObj + boardSize) == playerCoor)
  373.                     return false;
  374.  
  375.           return true;
  376.      }
  377.  
  378.      else if(direction == KEY_LEFT)
  379.      {
  380.           for(counter = 0; counter < boardSize; counter = counter + 1)
  381.                if(currentObj == (counter * boardSize))
  382.                     return false;
  383.  
  384.           for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
  385.                if(((currentObj - 1) == objCoor[counter]) or (currentObj - 1) == playerCoor)
  386.                     return false;
  387.  
  388.           return true;
  389.      }
  390.  
  391.      else if(direction == KEY_RIGHT)
  392.      {
  393.           for(counter = 0; counter < boardSize; counter = counter + 1)
  394.                if(currentObj == ((counter * boardSize) + boardSize - 1))
  395.                     return false;
  396.  
  397.           for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
  398.                if(((currentObj + 1) == objCoor[counter]) or (currentObj + 1) == playerCoor)
  399.                     return false;
  400.  
  401.           return true;
  402.      }
  403.  
  404.      return false;
  405. }
  406.  
  407. void help()
  408. {
  409.      clear();
  410.      refresh();
  411.      getch();
  412. }
  413.  
  414. bool fight(int &health)
  415. {
  416.      return true;
  417. }
clone this paste RAW Paste Data