The Game of “Choice”

Many early computer games were text-based games were the player is given a set of circumstances and asked to make a choice. Good choices had pleasant outcomes and poor choices would have consequences up to and including getting a “Game Over”. These games would use random generators to decide whether the player was successful or not.

One of the most popular games of this genre was “The Oregon Trail”:

The Oregon Trail is a text-based (Links to an external site.) strategy video game (Links to an external site.) in which the player, as the leader of a wagon train, controls a group journeying down the Oregon Trail (Links to an external site.) from Independence, Missouri (Links to an external site.) to Oregon City, Oregon (Links to an external site.) in 1847. The player purchases supplies, then plays through approximately twelve rounds of decision making, each representing two weeks on the trail. Each round begins with the player being told their current distance along the trail, and the date, along with their current supplies. Supplies consist of food, bullets, clothing, miscellaneous supplies, and cash, each given as a number. They are given the option to hunt for food, and in some rounds to stop at a fort to purchase supplies, and then choose how much food to consume that round. The game closes the round by randomly selecting one or two events and weather conditions. The events include storms damaging supplies, wagons breaking down, and attacks by wild animals or “hostile riders”; weather conditions can slow down the rate of travel, which can result in additional rounds needed to reach Oregon.[1] (Links to an external site.)[2] (Links to an external site.)

When hunting, or when attacked, the game prompts the player to type a word—”BANG” in the original version, or a randomly selected word like “BANG” or “POW” in later versions—with misspellings resulting in no effect. When hunting, typing the word slowly results in less food being gathered than for fast typing. The game ends when the player reaches Oregon, or if they die along the trail; death can occur due to an attack or by running out of supplies. Running out of food results in starvation, while lack of clothing in cold weather, low levels of food, or random events such as snakebite or a hunting accident lead to illness; this results in death if the player does not have miscellaneous supplies for minor or regular illnesses, or cannot afford a doctor in the case of serious illnesses. (The Oregon Trail (1971 video game), 2018)

The Project

You will be creating a knock off version of the game Oregon trail. You will give the player a base amount of money. The player is then given the option to buy supplies. Your game will run for at least 5 rounds. Each round, the player will use up certain supplies. Lack of these supplies could cause problems with players life; for example, no food means low health or starvation.

Each round will also present a random circumstance that may occur. Player will be given options on what to do during the round. The outcome for each choice will be randomized to be successful or fail. Rewards for success and consequences for failure will depend on choices made.

This will be a complete program with Title screen, game menu, and clean formatting of text. You will also include a test driver for developer testing and debugging.

Flowchart for final program will look something like this:

Part 1 – Program Framework

Game Project Part 1

Program Framework

For this part of your project you should create framework for your Game driver and Test driver. This starts with a main menu with options to either run the game or run the test. For now the both the game and test options will execute a function place holder.

Setting up your main menu.

You should have an interactive menu which gives you the following options:

1. Play Game
2. Test Functionality
3. Quit

Play game will currently run a game function place holder which says something like “Game Coming soon”.

Test Functionality should run a separate place holder function for which outputs something like “Test Function placeholder”

Quit should obviously quit the program.

Your main menu function should also have a validation to prevent incorrect input.

This is a sample of what your program should look like at this point.

Global Functions

Build a global function that will be used with your program. I recommend building a function that returns a random number.

Now you should build a test function, one that will run the global function you created so you can make sure it works. For example, if your function test the random number function it should look something like this:

void testRandomRoll()

{

clearScreen();

std::cout << “Your Random number is ” << RandomRoll() << std::endl;

pauseScreen();

}

Notice the test program takes no input and returns no value. It runs the function and gives an output that you can validate. This is solely for developer testing of specific functions.

In the test driver function, create a menu with option to run each test function. As you create new functions you should add a test function and add it to the menu.

Object Building

Create the player class. It should have the attributes you need. For example:

class Player

{

public:

Player();//Constructor

//Health interface

void addHealth(int);

void takeHealth(int);

int getHealth() const;

//Gold interface

int getGold() const;

void addGold(int);

void takeGold(int);

void displayStatus() const;

~Player();//Destructor

private:

std::string name;

int maxHealth;

int health;

int gold;

};

This is just an example. Your Player class will probably have more to it.

You can create a test function that will create a Player object and run through testing the functions of the object.

You can also create an event class for building your events. The event class objects should control the individual event rounds.

Part 4 – Putting it together

The Game engine is the next piece. When the user chooses to play the game from the main menu, you should introduce the game. The intro should describe what your game is; describe the story and give overall objective of game. After this the player will be given some initial options to start the game. These options could be starting supplies, player name or any other types of conditions that may or may not be relevant to the outcome of the game.

Next the game should go into the event rounds. Minimum of 12 rounds when the game is complete. To start though, just run one round make sure it works, then add another round. Once you have a couple rounds in there, add the rest.

Remember the event loop should end early if the player has game ending condition like zero health.

When your game ends it should return you to the main menu.

Requirements

The project has the following requirements to be graded

These need to be present

• Player Object
• Event Object (extra Points)
• Title Screen
• Test Driver
  • Used to test object creation and functions
  • Should be menu driven
• Game Driver
  • In game menu
  • Explain Story
  • Starting options
  • Follow Workflow
    • Present Event
    • Input choice
    • Results
    • Go to next event
  • Game over Conditions
  • End game story

Coding Standards and Formatting

• Program Should run
• Code is Readable
• Logic is clean
• Header File Setup

For bonus points, have a file system to load data from.