elixia

#include <ncurses.h> //for initscr() ... endwin()
#include <ciso646> //&& = and, ^ = xor, etc.
#include <vector> //for std::vector
#include <cstdlib> //std:: library functions and macros
#include <ctime> //seeding rand()
#include <cmath> //rand()
#include <cstring> //c-style string operations
#include <unistd.h>

#define _tab_size__ "     " //my tab size which is five spaces

using namespace std;

bool validMove(wchar_t, int, int, vector<int>&); //make sure the player can move there
bool validMove(wchar_t, int, vector<int>&, int, int);
void help(); //display help message
bool fight(int&);

int main()
{
     printf("\033]0;Elixia\007");
     srand(time(NULL)); //seed rand

     vector<int> objCoor(1); //coordinates of the objects to pick up
     vector<int> shopCoor(1);
     int counter, subCounter, turnCounter, noOfObj, playerCoor; //misc int declarations
     int boardSize, currentLevel, winRow, winCol, noOfShops, health; //misc int declarations
     vector<char> board(1); //hold the board
     char playerSymbol;
     wchar_t action;
     bool canMove;

     char getSym[] = "Enter Character Symbol"; //shortcut

     initscr(); //start the ncurses session

     cbreak(); //start reading characters immediately
     noecho(); //don't show the
     keypad(stdscr, TRUE);
     start_color();
     curs_set(0);

     init_pair(1, COLOR_RED, COLOR_WHITE);
     init_pair(2, COLOR_GREEN, COLOR_WHITE);
     init_pair(3, COLOR_BLACK, COLOR_WHITE);
     init_pair(4, COLOR_CYAN, COLOR_WHITE);

     clear();
     attron(A_UNDERLINE);
     getmaxyx(stdscr, winRow, winCol);
     mvprintw(winRow / 2, (winCol - strlen(getSym)) / 2, "%s", getSym);
     attroff(A_UNDERLINE);
     refresh();

     playerSymbol = getch();

     currentLevel = 1;

     while(true)
     {
          boardSize = 9 + currentLevel;
          board.resize(boardSize * boardSize);
          noOfObj = boardSize / 2;
          objCoor.resize(noOfObj);
          turnCounter = 0;
          noOfShops = noOfObj / 2;
          shopCoor.resize(noOfShops);
          health = 20;

          for(counter = 0; counter < boardSize; counter = counter + 1)
               for(subCounter = 0; subCounter < boardSize; subCounter = subCounter + 1)
                    board[subCounter + (counter * boardSize)] = ' ';

          playerCoor = rand() % (boardSize * boardSize);
          board[playerCoor] = playerSymbol;

          for(counter = 0; counter < noOfObj;)
          {
               objCoor[counter] = rand() % (boardSize * boardSize);

               if(board[objCoor[counter]] not_eq ' ')
                    continue;

               board[objCoor[counter]] = '@';
               counter = counter + 1;
          }

          while(noOfObj > 0)
          {
               clear();
               printw("Level %d Enemies Left: %d Turns: %d\n", currentLevel, noOfObj, turnCounter);

               for(counter = 0; counter < boardSize; counter = counter + 1)
               {
                    for(subCounter = 0; subCounter < boardSize; subCounter = subCounter + 1)
                    {
                         if(board[subCounter + (counter * boardSize)] == playerSymbol)
                         {
                              attron(COLOR_PAIR(1));
                              printw("%c", board[subCounter + (counter * boardSize)]);
                              attroff(COLOR_PAIR(1));
                         }

                         else if(board[subCounter + (counter * boardSize)] == '@')
                         {
                              attron(COLOR_PAIR(2));
                              printw("%c", board[subCounter + (counter * boardSize)]);
                              attroff(COLOR_PAIR(2));
                         }

                         else
                         {
                              attron(COLOR_PAIR(3));
                              printw("%c", board[subCounter + (counter * boardSize)]);
                              attroff(COLOR_PAIR(3));
                         }

                         if(subCounter not_eq (boardSize - 1))
                         {
                              attron(COLOR_PAIR(3));
                              printw(" ");
                              attroff(COLOR_PAIR(3));
                         }
                    }

                    printw("\n");
               }

               refresh();
               action = getch();

               canMove = validMove(action, boardSize, playerCoor, objCoor);

               switch(action)
               {
                    case 'h':
                         help();
                         break;

                    case 'q':
                         endwin();
                         exit(1);
                         break;

                    case KEY_UP:
                         if(canMove)
                         {
                              board[playerCoor] = ' ';
                              playerCoor = playerCoor - boardSize;
                              turnCounter = turnCounter + 1;
                         }

                         break;

                    case KEY_DOWN:
                         if(canMove)
                         {
                              board[playerCoor] = ' ';
                              playerCoor = playerCoor + boardSize;
                              turnCounter = turnCounter + 1;
                         }

                         break;

                    case KEY_LEFT:
                         if(canMove)
                         {
                              board[playerCoor] = ' ';
                              playerCoor = playerCoor - 1;
                              turnCounter = turnCounter + 1;
                         }

                         break;

                    case KEY_RIGHT:
                         if(canMove)
                         {
                              board[playerCoor] = ' ';
                              playerCoor = playerCoor + 1;
                              turnCounter = turnCounter + 1;
                         }

                         break;

                    default:
                         continue;
               }

               board[playerCoor] = playerSymbol;

               for(counter = 0; counter < noOfObj; counter = counter + 1)
                    if(((playerCoor + 1) == objCoor[counter]) or ((playerCoor - 1) == objCoor[counter])
                         or ((playerCoor + boardSize) == objCoor[counter]) or ((playerCoor - boardSize) == objCoor[counter]))
                    {
                         if(!fight(health))
                         {
                              endwin();
                              exit(1);
                         }

                         else
                         {
                              noOfObj = noOfObj - 1;
                              board[objCoor[counter]] = ' ';
                              objCoor.erase(objCoor.begin() + counter);
                         }
                    }

               for(counter = 0; counter < noOfObj;)
               {
                    subCounter = rand() % 4;

                    switch(subCounter)
                    {
                         case 0:
                              if(validMove(KEY_UP, boardSize, objCoor, objCoor[counter], playerCoor))
                              {
                                   board[objCoor[counter]] = ' ';
                                   objCoor[counter] = objCoor[counter] - boardSize;
                              }

                              break;

                         case 1:
                              if(validMove(KEY_DOWN, boardSize, objCoor, objCoor[counter], playerCoor))
                              {
                                   board[objCoor[counter]] = ' ';
                                   objCoor[counter] = objCoor[counter] + boardSize;
                              }

                              break;

                         case 2:
                              if(validMove(KEY_LEFT, boardSize, objCoor, objCoor[counter], playerCoor))
                              {
                                   board[objCoor[counter]] = ' ';
                                   objCoor[counter] = objCoor[counter] - 1;
                              }

                              break;

                         case 3:
                              if(validMove(KEY_RIGHT, boardSize, objCoor, objCoor[counter], playerCoor))
                              {
                                   board[objCoor[counter]] = ' ';
                                   objCoor[counter] = objCoor[counter] + 1;
                              }

                              break;
                    }

                    if(!canMove)
                         continue;

                    board[objCoor[counter]] = '@';
                    counter = counter + 1;
               }

               for(counter = 0; counter < noOfObj; counter = counter + 1)
                    if(((objCoor[counter] + 1) == playerCoor) or ((objCoor[counter] - 1) == playerCoor)
                         or ((objCoor[counter] + boardSize) == playerCoor) or ((objCoor[counter] - boardSize) == playerCoor))
                    {
                         if(!fight(health))
                         {
                              endwin();
                              exit(1);
                         }

                         else
                         {
                              noOfObj = noOfObj - 1;
                              board[objCoor[counter]] = ' ';
                              objCoor.erase(objCoor.begin() + counter);
                         }
                    }
          }

          clear();
          printw("You Won!!! Do you want to play again (y/n)");
          refresh();

          do
          {
               action = getch();

               switch(action)
               {
                    case 'n':
                         endwin();
                         exit(1);
                         break;

                    default:
                         continue;
               }
          }while(action not_eq 'y');

          currentLevel = currentLevel + 1;
     }

     endwin();
     return 0;
}

bool validMove(wchar_t direction, int boardSize, int playerCoor, vector<int> &objCoor)
{
     int counter;

     if(direction == KEY_UP and playerCoor > (boardSize - 1))
     {
          for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
               if((playerCoor - boardSize) == objCoor[counter])
                    return false;

          return true;
     }

     else if(direction == KEY_DOWN and playerCoor < ((boardSize * boardSize) - boardSize))
     {
          for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
               if((playerCoor + boardSize) == objCoor[counter])
                    return false;

          return true;
     }

     else if(direction == KEY_LEFT)
     {
          for(counter = 0; counter < boardSize; counter = counter + 1)
               if(playerCoor == (counter * boardSize))
                    return false;

          for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
               if((playerCoor - 1) == objCoor[counter])
                    return false;

          return true;
     }

     else if(direction == KEY_RIGHT)
     {
          for(counter = 0; counter < boardSize; counter = counter + 1)
               if(playerCoor == ((counter * boardSize) + boardSize - 1))
                    return false;

          for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
               if((playerCoor + 1) == objCoor[counter])
                    return false;

          return true;
     }

     return false;
}

bool validMove(wchar_t direction, int boardSize, vector<int> &objCoor, int currentObj, int playerCoor)
{
     int counter;

     if(direction == KEY_UP and currentObj > (boardSize - 1))
     {
          for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
               if(((currentObj - boardSize) == objCoor[counter]) or (currentObj - boardSize) == playerCoor)
                    return false;

          return true;
     }

     else if(direction == KEY_DOWN and currentObj < ((boardSize * boardSize) - boardSize))
     {
          for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
               if(((currentObj + boardSize) == objCoor[counter]) or (currentObj + boardSize) == playerCoor)
                    return false;

          return true;
     }

     else if(direction == KEY_LEFT)
     {
          for(counter = 0; counter < boardSize; counter = counter + 1)
               if(currentObj == (counter * boardSize))
                    return false;

          for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
               if(((currentObj - 1) == objCoor[counter]) or (currentObj - 1) == playerCoor)
                    return false;

          return true;
     }

     else if(direction == KEY_RIGHT)
     {
          for(counter = 0; counter < boardSize; counter = counter + 1)
               if(currentObj == ((counter * boardSize) + boardSize - 1))
                    return false;

          for(counter = 0; counter < (boardSize / 2); counter = counter + 1)
               if(((currentObj + 1) == objCoor[counter]) or (currentObj + 1) == playerCoor)
                    return false;

          return true;
     }

     return false;
}

void help()
{
     clear();
     refresh();
     getch();
}

bool fight(int &health)
{
     return true;
}