Game is a class declared in the Game.h file. The Game class is the engine behind the elevators project, and will be the main object used for how users interact with the program.

Member data

Member Functions

Many member functions have been written for you. Please refer to their RME’s for use reference.

You will be writing the implementations for the following functions:


     * Requires: nothing
     * Modifies: cout, isAIMode, building, satisfactionIndex
     * Effects:  if game input file is not open, exits with status 1
     *           sets isAIMode
     *           prints game start prompt
     *           else reads events from game input file
     *           if event is happening on current turn, updates building 
     *           with event else prints building and checks if game has 
     *           ended, if it hasn't yet, gets user (player or AI) move, 
     *           and updates building with move.
    void playGame(bool isAIModeIn, ifstream &gameFile);

IMPORTANT NOTE: For this function, the autograder is expecting operations in the order specified by the RME and this page.

We have provided a stub that will play a random game of Elevators. You will modify this function to fulfill the RME. This function should be the last one you implement.

Start with the following steps from the RME:

  1. If the game input file is not open, exit with status 1. To exit with status 1, use the exit() standard library function.
  2. Set isAIMode to the parameter isAIModeIn.
  3. Call Game::printGameStartPrompt(): This will alert the user that the game will begin, and will display the menu options available during the Game.
  4. Call Game::initGame(): This will initialize the Game by loading in the initial data from gameFile.

After the initial steps above, the game will play by the list of steps below. The input file will have lines describing when people will be spawned. The user will play the game as these files are read and the people are spawned. After all the people have spawned, the user can continue playing the game. To do this:

  1. While there is another line in gameFile:
    1. Create a Person using that line
    2. Determine which tick the Person will be spawned
    3. Have the user play the game until that tick has finished
    4. Spawn the person
  2. Until the game is over:
    1. Have the user play the game

Here are the steps to have the user play the game:

  1. Make a call to prettyPrintBuilding on the building member variable with cout as the parameter argument
  2. Make a call to printSatisfaction on the satisfactionIndex member variable with cout and false as the parameter arguments
  3. Check to see if the game has ended (we’ve given you the checkForGameEnd() function for this)
  4. Ask the user for a Move (we’ve provided a member function for this)
  5. Apply the inputted Move (we’ve provided a member function for this)


* Requires: pickupFloorNum is the floor the pickup move was called on
* Modifies: nothing
* Effects: determines if pickupList is a valid
*          list of people to pick up
bool isValidPickupList(const string& pickupList, const int pickupFloorNum) const;

This function is called when the user decides to pick up people on a floor. The game gives the user an opportunity to select which people currently on that floor they would like to pick up, then calls this function to verify that the user’s selection is valid. Because there are a maximum of 10 people per floor, every index should be a single digit - i.e., there is no floor index 10, only 0 through 9.

An example pickupList: "0135"

“I choose the people at indices 0, 1, 3, and 5 to pickup”

A pickupList is valid if it meets the following conditions:

  1. There are no duplicate indices present in pickupList
  2. Each element of pickupList is a digit in the range '0' through '9'
  3. The length of the pickupList is less than or equal to the capacity of an elevator
  4. The maximum value pointed to by an index of pickupList must be strictly less than the number of people on the floor pointed to by pickupFloorNum
  5. Each person represented by an index in pickupList must be going in the same direction relative to pickupFloorNum

Function Table

The table below provides an outline of which other functions each function should call, if any. The functions listed here do not include any library functions you may wish to use. Please look at the starter code section of the spec to see which libraries you are allowed to use.

Note: although default constructors are listed, you might not explicitly call them:

Person p; // The default constructor was implicitly called
Person p = Person(); // The default constructor was explicitly called
Function Other functions it should call
playGame() Game::printGameStartPrompt(), Game::initGame(), Person::Person() (default, non-default), Person::getTurn(), Building::getTime(), Building::prettyPrintBuilding(), SatisfactionIndex::printSatisfaction(), Game::checkForGameEnd(), Game::getMove(), Game::update(), Building::spawnPerson()
isValidPickupList() Building::getFloorByFloorNum(), Floor::getNumPeople(), Floor::getPersonByIndex(), Person::getTargetFloor()