Introduction

The goal of this assignment is to allow students to demonstrate their understanding of the features of the C++ language through the design and development of a simple console-based game. To achieve this goal the student will be required to complete the following steps:

  • Design a simple interactive game (can be based on an existing game)
  • Develop code to implement this game design (primarily your own, original code)
  • Test your implemented game for functionality and bugs, and
  • Document the design/implementation/testing process as well as a user/start-up guide.

There are two key dimensions to this assignment: (1) a demonstration of the software design and development process used by the student; and (2) the completed game that meets a minimum set of requirements. The assignment will require the submission of all documentation and source code for the game.

The following sections detail both the required/expected features of the game and the required documentation. A breakdown of marks to be awarded to each component is also given.

Demonstration of C++ Proficiency

To achieve the goal of demonstrating a sufficient understanding of the C++ language, the submitted game software must contain appropriate examples of the following C++ mechanisms and features:

  • Demonstration of C++ programming (standard/basic) features. Appropriate use of:
    • variable, constant and enumerator types
    • loops and branch statements
    • functions and modularisation
    • appropriate use of references to variables and functions
  • Demonstration of basic OO programming principles. Appropriate use of:
    • class declarations to represent game and/or program entities
    • object instantiation and use
  • Console and File I/O – appropriate use of:
    • standard Library input/output streams
    • accessing external data files for either input or output
  • Rigorous error checking and handling through:
    • validation of input data
    • error checking/validation of function arguments
    • error checking of function return values

Game Concept

The style and setting for this game is left up to you. The type of game you choose must be sufficient to demonstrate the programming features listed above. Our recommendation is for you to constrain your software to a console application using ASCII characters (text) for display. Games suited to this format may include: an adventure game; a simple simulation/strategy game; or a maze/platform style game.

Game Suggestion – Dice game ‘Pigs’

Pigs is a dice game of chance which involves two players trying to be the first to reach a score of 100 to win. The basic rules of the game ‘pigs’ is described below (as taken from Pig (dice) Wikipedia page):

Each turn, a player repeatedly rolls a die until either a 1 is rolled or the player holds and scores the sum of the rolls (i.e. the turn total). At any time during a player's turn, the player is faced with two options:
• roll – If the player rolls a
o 1: the player scores nothing and it becomes the next player's turn.
o 2 - 6: the number is added to the player's turn total and the player's turn continues.
• hold – The turn total is added to the player's score and it becomes the next player's turn.
The first player to score 100 or more points wins.

As you can see there are few rules to the game are and the gameplay is quite simple. An example of the playing of this game, showing only one round – that is each player having one turn – is shown below (also taken from Pig (dice) Wikipedia page):

For example, the first player, Ann, begins a turn with a roll of 5. Ann could hold and score 5 points, but chooses to roll again. Ann rolls a 2, and could hold with a turn total of 7 points, but chooses to roll again. Ann rolls a 1, and must end her turn without scoring. The next player, Bob, rolls the sequence 4-5-3-5-5, after which he chooses to hold, and adds his turn total of 22 points to his score.

The game pigs has a number of variations including the use of two dice. This could be implemented in your program through a menu choice ‘Options’ which sets the games parameters (i.e., number of dice, number of players, special Pig number [default is 1], or the winning score to end the game [default 100]).

Examples
The following are simple animated examples (using javascript and flash respectively). In your solution you are expected to only provide a text-based solution. These examples are only provided to support your understanding of how to play the game pigs:
• http://cs.gettysburg.edu/projects/pig/piggame.html
• http://scratch.mit.edu/projects/Paddle2See/1479420.

Other Suggested Games

Some online examples of text-adventure like games that can be used for ‘inspiration’, include:

  • Hammurabi http://www.hammurabigame.com/hammurabi-game.php
  • Zork http://thcnet.net/error/index.php
  • Star Trek http://www.vavasour.ca/jeff/level1/entry6_preview.html

Also, think of some traditional games that may be used for inspiration:

  • Cluedo http://en.wikipedia.org/wiki/Cluedo
  • Risk http://en.wikipedia.org/wiki/Risk_(game)
  • Battleship http://en.wikipedia.org/wiki/Battleship_game

Card and dice games may also be considered:

  • Cards – blackjack
  • Yacht (dice game) http://en.wikipedia.org/wiki/Yacht_(dice_game)

Word/text based games may also be considered:

  • Hangman
  • Word jumbles
  • Word find
PLEASE NOTE:
1) These games are only provided to give you some suggested ideas/themes, please feel free in creating a game of your choice – the requirement is that it must meet the generic features and functionality listed below!
2) Some of the games listed above require two players; in such cases it is not expected that students implement a complex “AI” computer opponent. It is sufficient for the second player can be controlled: manually using a different set of keys (or for each player to have a turn to provide input), or use of random moves/choices as performed in the lecture example of Tic-Tac-Toe.

Required Game Features/Functionality

In providing the required features (listed in the Demonstration of C++ Proficiency section above), the game must also support the following set of programming & gameplay features:

  • Game Software Features
    • Implementation of an appropriate game loop
    • Changeable game states based on user input
  • Basic/Simple User Interface
    • Accepts user input via keyboard input as commands/directions
    • Is able to display/present the current game state in simple text based form (either as descriptive text or simple ASCII graphics)
  • Multiple game (software) states
    • At least 3 game states – (1) menu/start; (2) play; and (3) end game states.
  • A single, playable level
    • This may take the form of a single map/region/level/etc.
  • Associated menu items:
    • Options – allow the user to modify configurable features of the game (i.e., number of dice used, number of players, difficulty level)
    • Instructions – present the player with a description on how to play the game, with the objective and user input detailed.
    • Credits/software development process – a description on the design and development of the application. Present details on the variables used, the structure of your program (flow of execution) and the a reflection on the development process highlighting any issues you faced and how you over come them.
  • File input/output
    • Loading of data related to the game (e.g., maps, a level, or descriptive text)
    • Loading & Saving of a high-score (like) data
  • Features appropriate to the game genre
    • Dialogue to engage the player (interesting/funny) for an RPG style game
    • Potentially dynamic/random text (e.g., for a text adventure game)

Optional Game Features/Functionality

Additional features that you may wish to include for an additional 10% ‘bonus marks’ include:

  • Use of dynamic memory allocation & pointers
  • Advanced object oriented features such as hierarchies, polymorphism, etc.
  • Use of log/error streams for debugging purposes
  • Multiple levels (game play advances once a level is completed):
    • Levels have varied content (entities) or difficulties, for example: Level 1 – a single map, Level 2 – 2 maps (passing through a doorway leads you onto the 2nd map), 5 maps in a cross pattern (centre map, with maps above/below and left/right)
  • Inventory – with collectable items. This will enable gameplay mechanisms such as:
    • Collection of game items (e.g., gold, money, keys, swords, armour, etc.)
    • Ordering of items (e.g., you need to collect the key before opening the chest)
Academic Honesty!
It is not our intention to break the school's academic policy. Projects posted are only used as a reference and should not be submitted as is. We are not held liable for any misuse of the solutions. Please see the frequently asked questions page for further questions and inquiries.
Kindly fill out the form. Please provide a valid email address and we'll get back to you in less than 24 hours. We will be sending an invoice through PayPal upon confirmation. We are a non profit organization however we need an amount to keep this organization running, and to be able to complete our research and development.