//Program Updates/Fixes

//Sep 18, 2007. Total wipe of file. Making second version prototype, which
//includes an expanded map array type (struct data types), improved funcionality
//which includes player movement (and yes a player object, and possibly other
//fixes.
#include <iostream>
#include <ctime>
#include <cmath>
#include <stdlib.h>
#include <curses.h>
#include "uniform.h"
#include "uniform.cpp"
#include "stacktype.cpp"
#include "PlayerObject.cpp"

//Amount of rooms in map
#define ROOMLOWERLIMIT 5
#define ROOMUPPERLIMIT 10
//Array "Map Attributes"
#define XLENGTH 40
#define YLENGTH 80

struct MapArrayType
{
    bool        AreaAccess;
    PlayerType  *Player;
};

class MapType
{
    public:

//defualt constructor
MapType();
//destructor
~MapType();
//Post-Condition...Room is created
void    CreateRoom(int,int);
//Post-Condition...Random Number is generated and returned as
//value of function
int     RandomNumberGenerator(int, int);
//Post-Condition...True or False returned as result
bool    CanRoomBeCreated(int, int);
//Post-Condition...Cordinates for the new room are plotted
void    FindNextRoom(int &, int &);
//Post-Condition...A new path within bounds is created
void    CreatePath(int, int);
//Post-Condition...Prints Out MapArrayType
void    PrintMap();

//Post - Condition...User input is captured and sent to validation function
//UserInput Is created, and the user input is stored
void    CaptureInput();

//Change as of Sep 18
//Pre-Condition...Capture Input was called and has altered the data member
//User Input
//Post-Condition...True/False value is returned to determine if the user
//Is able to move to selected spot.
bool    IsInputValid(char);

//Change as of Sep 18
//Pre-Condition...function IsInputValid has been called and returned a true/false
//value
//Post-Condition...either the user moves from one cell to the other, or not and
//an error message is displayed.
void    ProcessInput(char);


private:

int TotalNumberOfRooms;
int RoomLength;
int RoomWidth;
int RoomCounter;

//Stacks to hold old map movements
stackType<int> StackX;
stackType<int> StackY;

//User Related Variables
//Change as of Sep 18
int UserCurrentXPos;
int UserCurrentYPos;


//NEW map Array, based on struct. This "holds" the entire contents of the map.
MapArrayType MapArray[XLENGTH][YLENGTH];
};

//client program
int main()
{
    //Declare local variables
MapType MapGenerator;

char done = 'n';
int  testvar = 1;
MapGenerator.CreateRoom(0,0);
MapGenerator.PrintMap();

while (done == 'n')
{
    if (testvar % 100 == 0)
        {
            clear();
            addstr("Would You Like to Quit Now? ");
            addch('\n');
            addch('\r');
            addstr("Press any but n to quit!");
            refresh();
            //Allow continous input!
            cbreak();
            done = getch();
        }
MapGenerator.CaptureInput();
testvar++;
}
//Turn off terminal color
attroff(COLOR_PAIR(1));
//Refresh output to standard screen!
refresh();
//pause the fing screen!!!
//getch();
//MAY HAVE TO REMOVE THIS LINE!!!
//KILL CURSES TERMINAL MANIUPULATION!
endwin();
return 0;
}

/**************************************************
UPDATE 11/16/2011
MapType::MapType defualt constructor

Changes:

1) Put all constants as define macros
***************************************************/


//defualt Constructor
MapType::MapType()
{



//Set all cells in map to walls
for (int counterx = 0; counterx < XLENGTH; counterx++){
    for (int countery = 0; countery < YLENGTH; countery++)
        {
    MapArray[counterx][countery].AreaAccess = 0;
    MapArray[counterx][countery].Player = NULL ;
        }
    }
}

MapType::~MapType()
{
//Uh...well there aren't any pointers...
}

//RandomNumberGenerator!
int MapType::RandomNumberGenerator(int LowNumber, int HighNumber)
{
//Reseed Random Number Generator
IntitializeSeed();
return Uniform(LowNumber,HighNumber);
}

/**************************************************
UPDATE 11/16/2011
MapType::CanRoomBeCreated

Changes:

1) Put all constants as define macros
***************************************************/


bool MapType::CanRoomBeCreated(int xcoord, int ycoord)
{
//determine if room exceeds the x and y chords of the room
if ((RoomWidth + xcoord > XLENGTH) || (RoomLength + ycoord > YLENGTH))
    {
        return false;
    }
//Determine if this room will colide with another and return false if it does!
else if (RoomWidth >= RoomLength)
    {
                                             for (int i = xcoord,countx = 0;countx < RoomWidth;i++,countx++){
                                             for (int j = ycoord,county = 0; county < RoomLength; j++,county++){
                                             if (MapArray[i][j].AreaAccess == 1){
                                             return false;
                                             }}}
    }
else if (RoomWidth < RoomLength)
    {
                                             for (int i = ycoord,county = 0;county < RoomLength;i++,county++){
                                             for (int j = xcoord,countx = 0; countx < RoomWidth; j++,countx++){
                                             if (MapArray[i][j].AreaAccess == 1){
                                             return false;
                                             }}}
    }
return true;

}
/**************************************************
UPDATE 11/16/2011
MapType::`

Changes:

1) Put all constants as define macros
***************************************************/


void MapType::CreateRoom(int xcoord, int ycoord)
{
     //Find Total Number of rooms
     TotalNumberOfRooms = RandomNumberGenerator(ROOMLOWERLIMIT,ROOMUPPERLIMIT);

    while (TotalNumberOfRooms != RoomCounter){

          //Get new chords for new rooms
          RoomLength = RandomNumberGenerator(ROOMLOWERLIMIT,ROOMUPPERLIMIT);
          RoomWidth = RandomNumberGenerator(ROOMLOWERLIMIT,ROOMUPPERLIMIT);
          FindNextRoom(xcoord,ycoord);
          if ((RoomCounter >= 1) && (CanRoomBeCreated(xcoord,ycoord) == true)){
               //Create new rooms
               //Push new chrds of room onto stacktype

               StackX.Push(xcoord);
               StackY.Push(ycoord);

               //Make Room

               for (int i = 0; i < RoomWidth; i++){
                    for (int j = 0; j < RoomLength; j++){
                         MapArray[xcoord+i][ycoord+j].AreaAccess = 1;
                                            }
                                        }
               RoomCounter++;
               CreatePath(xcoord,ycoord);
    }

    else if ( (RoomCounter < 1) && (CanRoomBeCreated(xcoord,ycoord) == true)){
        //Push Start of room onto stack
        StackX.Push(xcoord);
         StackY.Push(ycoord);
        //Update as of Sep 18
        //Log Players position on map and set starting point
        UserCurrentXPos = xcoord;
        UserCurrentYPos = ycoord;
        //Place Player On Map Object
        MapArray[xcoord][ycoord].Player = new PlayerType;

          //Make Room
          for (int i = 0;i < RoomWidth;i++){
               for (int j = 0; j < RoomLength; j++){
                    MapArray[xcoord+i][ycoord+j].AreaAccess = 1;
                    }
               }
          //Incrament Room Counter
          RoomCounter++;
          }
     }
    return;
}
//Room Finder Function
void MapType::FindNextRoom(int &xcoord, int &ycoord)
{
//Get Randomly generated chords for next room though Random Number Gen Function
xcoord = RandomNumberGenerator(0,XLENGTH);
ycoord = RandomNumberGenerator(0,YLENGTH);

//Randomize if the cords are the same
while(xcoord == ycoord)
ycoord = RandomNumberGenerator(0,80);

return;
}

//Function to draw pathlines between rooms
void MapType::CreatePath(int xcoord, int ycoord)
{
int oldxcoord = 0;
int oldycoord = 0;

//Return previous room chords
oldxcoord = StackX.Top();
oldycoord = StackY.Top();

if ((xcoord == oldxcoord) && (ycoord == oldycoord))
{
  return;
}
//both NEW x and y chords are greater than old ones
else if ((xcoord >= oldxcoord) && (ycoord >= oldycoord))
{
    for (xcoord; xcoord > oldxcoord; xcoord--)
    {
    MapArray[xcoord][ycoord].AreaAccess = 1;
    }
    for (ycoord; ycoord >= oldycoord; ycoord--)
    {
    MapArray[xcoord][ycoord].AreaAccess = 1;
    }
}
//both NEW x and y chords are less than old ones
else if ((xcoord <= oldxcoord) && (ycoord <= oldycoord))
{
    for (xcoord; xcoord < oldxcoord; xcoord++)
    {
    MapArray[xcoord][ycoord].AreaAccess = 1;
    }
    for (ycoord; ycoord < oldycoord; ycoord++)
    {
    MapArray[xcoord][ycoord].AreaAccess = 1;
    }
}

//new and old xcoords are the same, new Y chords are greater or equal to old Y
else if ((xcoord == oldxcoord) && (ycoord >= oldycoord)){
    for (int i = ycoord; ycoord > oldycoord; i--)
    MapArray[xcoord][i].AreaAccess = 1;
}
//xcoords both the same, New Y chord is less than old one
else if ((xcoord == oldxcoord) && (ycoord < oldycoord)){
    for (int i = ycoord; ycoord < oldycoord; i++)
    MapArray[xcoord][i].AreaAccess = 1;
}
//Y chords both the same, Old X greater or equal to new one
else if ((oldycoord == ycoord) && (xcoord >= oldxcoord))
{
     for (int i = xcoord; i > oldxcoord; i++)
     MapArray[i][ycoord].AreaAccess = 1;
}
//ycoords both the same, New X chord is less than old one
else if ((ycoord == oldycoord) && (xcoord < oldxcoord))
{
    for (int i = xcoord; xcoord < oldxcoord; i++)
    MapArray[i][ycoord].AreaAccess = 1;
}
//if newX is less than old X, new Y greater than old y
else if ((xcoord <= oldxcoord) && (ycoord >= oldycoord))
{
     for (xcoord; xcoord < oldxcoord; xcoord++)
        {
        MapArray[xcoord][ycoord].AreaAccess = 1;
        }
  for (ycoord; ycoord > oldycoord; ycoord--)
        {
        MapArray[xcoord][ycoord].AreaAccess = 1;
        }
}
//if newX is greater than than old X, new Y less than than old y
else if ((xcoord > oldxcoord) && (ycoord < oldycoord))
{
for (xcoord; xcoord > oldxcoord; xcoord--)
    {
    MapArray[xcoord][ycoord].AreaAccess = 1;
    }
for (ycoord; ycoord < oldycoord; ycoord++)
    {
  MapArray[xcoord][ycoord].AreaAccess = 1;
    }
}
}
//PrintMap Function
void MapType::PrintMap()
{
//Clear screen
//Keep in mind that curses seems to have a problem with
//Refreshing the terminal screen if we do not send a clear
//macro to the screen buffer.
clear();
//Prepare Terminal for manipulation
initscr();

//Check to see if terminal supports color
if(has_colors() == false)
    {
        endwin();
        printf("Your terminal does not support color \n");
        exit(1);
    }
else
    start_color();

//Select pairs of colors, forground and background
init_pair(1, COLOR_WHITE, COLOR_BLACK);
//Apply Color Set
attron(COLOR_PAIR(1));

//Print out entire map
for (int counterx = 0; counterx < 40; counterx++)
    {
        for (int countery = 0; countery < 80; countery++)
        {
            //IF PLAYER IS ON SPOT!
            if (MapArray[counterx][countery].Player != NULL)
                //Display Player Icon
                addch('@');
            //If cell is WALL
            else if (MapArray[counterx][countery].AreaAccess == 0)
                addch('#');
            //If Spot Is Open for movement (nothing there)
            else if (MapArray[counterx][countery].AreaAccess == 1)
                //Display Open Cell Icon
                addch('.');
        }
        //Knock logical Cursor down to a new line
        addch('\n');
        //Return logical cursor back to left of screen
        addch('\r');
    }
//Turn off terminal color
//attroff(COLOR_PAIR(1));

//Refresh output to standard screen!
refresh();

//pause the fing screen!!!
//getch();
//MAY HAVE TO REMOVE THIS LINE!!!
//KILL CURSES TERMINAL MANIUPULATION!
//endwin();
}
void MapType::CaptureInput()
{
//Declare Variable
char UserInput = ' ';
//Allow Continious Input
cbreak();
//Stop Character Echo
noecho();

//Get User Input Key
UserInput = getch();
//Find out if function is valid.
while (IsInputValid(UserInput) == false ){
clear();
addstr("\nInput is Invalid. Please try again\n");
addstr("\nPress a Key to continue\n");
PrintMap();
UserInput = getch();
}
//Preform Movement
ProcessInput(UserInput);
}

bool MapType::IsInputValid(char UserInput)
{
//If User tries to move to the lower left
if (UserInput == '1')
{
    if (MapArray[UserCurrentXPos+1][UserCurrentYPos-1].AreaAccess == 0)
        return false;
    else
    return true;
}
//If User Tries to move down
else if (UserInput == '2')
{
     if (MapArray[UserCurrentXPos+1][UserCurrentYPos].AreaAccess == 0)
    return false;
     else
    return true;
}
//If user Tries to move to lower right
else if (UserInput == '3')
{
    if (MapArray[UserCurrentXPos+1][UserCurrentYPos+1].AreaAccess == 0)
    return false;
    else
    return true;
}
//If user Tries to move to left
else if (UserInput == '4')
{
    if (MapArray[UserCurrentXPos][UserCurrentYPos-1].AreaAccess == 0)
        return false;
    else
        return true;
}
//If user tries to move right
else if (UserInput == '6')
{
    if (MapArray[UserCurrentXPos][UserCurrentYPos+1].AreaAccess == 0)
        return false;
    else
        return true;
}
//If user tries to move to upper left
else if (UserInput == '7')
{
    if (MapArray[UserCurrentXPos-1][UserCurrentYPos-1].AreaAccess == 0)
        return false;
    else
        return true;
}
//If User tries to move up
else if (UserInput == '8')
{
    if (MapArray[UserCurrentXPos-1][UserCurrentYPos].AreaAccess == 0)
        return false;
    else
        return true;
}
//If User tries to move upper left
else if (UserInput == '9')
{
    if (MapArray[UserCurrentXPos-1][UserCurrentYPos+1].AreaAccess == 0)
        return false;
    else
        return true;
}
//Movement is invalid!!
return false;
}
//If User tries to move upper right
void MapType::ProcessInput(char UserInput)
{
//If user tries to move to lower left
if (UserInput == '1'){
MapArray[UserCurrentXPos+1][UserCurrentYPos-1].Player = MapArray[UserCurrentXPos][UserCurrentYPos].Player;
MapArray[UserCurrentXPos][UserCurrentYPos].Player = NULL;
UserCurrentXPos = UserCurrentXPos++;
UserCurrentYPos = UserCurrentYPos--;
}
//If User Tries to move down
else if (UserInput == '2')
{
MapArray[UserCurrentXPos+1][UserCurrentYPos].Player = MapArray[UserCurrentXPos][UserCurrentYPos].Player;
MapArray[UserCurrentXPos][UserCurrentYPos].Player = NULL;
UserCurrentXPos = UserCurrentXPos++;
}

//If User tries to move to the lower right
else if (UserInput == '3')
{
MapArray[UserCurrentXPos+1][UserCurrentYPos+1].Player = MapArray[UserCurrentXPos][UserCurrentYPos].Player;
MapArray[UserCurrentXPos][UserCurrentYPos].Player = NULL;
UserCurrentXPos = UserCurrentXPos++;
UserCurrentYPos = UserCurrentYPos++;
}
//If user tries to move left
else if (UserInput == '4'){
MapArray[UserCurrentXPos][UserCurrentYPos-1].Player = MapArray[UserCurrentXPos][UserCurrentYPos].Player;
MapArray[UserCurrentXPos][UserCurrentYPos].Player = NULL;
UserCurrentYPos = UserCurrentYPos--;
}
//If user tries to move right
else if (UserInput == '6')
{
MapArray[UserCurrentXPos][UserCurrentYPos+1].Player = MapArray[UserCurrentXPos][UserCurrentYPos].Player;
MapArray[UserCurrentXPos][UserCurrentYPos].Player = NULL;
UserCurrentYPos = UserCurrentYPos++;
}
//If user tries to move upper left
else if (UserInput == '7')
{
MapArray[UserCurrentXPos-1][UserCurrentYPos-1].Player = MapArray[UserCurrentXPos][UserCurrentYPos].Player;
MapArray[UserCurrentXPos][UserCurrentYPos].Player = NULL;
UserCurrentXPos = UserCurrentXPos--;
UserCurrentYPos = UserCurrentYPos--;
}
//If user tries to move up
else if (UserInput == '8')
{
MapArray[UserCurrentXPos-1][UserCurrentYPos].Player = MapArray[UserCurrentXPos][UserCurrentYPos].Player;
MapArray[UserCurrentXPos][UserCurrentYPos].Player = NULL;
UserCurrentXPos = UserCurrentXPos--;
}
//If user tries to move upper right
else if (UserInput == '9')
{
MapArray[UserCurrentXPos-1][UserCurrentYPos+1].Player = MapArray[UserCurrentXPos][UserCurrentYPos].Player;
MapArray[UserCurrentXPos][UserCurrentYPos].Player = NULL;
UserCurrentXPos = UserCurrentXPos--;
UserCurrentYPos = UserCurrentYPos++;
}
PrintMap();
}