辅导 COMP 3023、C++程序设计讲解
COMP 3023 Design Patterns with C++
Assignment 1 COMP 3023
Introduction
In this individual assignment, you have been tasked by your client to create a command-line based
simulation game in C++. In the game the player controls a team of devoted robots working for the
company. Following the orders of the player, the robots have to perform dangerous exploration
missions in hazardous locations in order to collect scrap. The scrap can then be sold to reach quota
and unlock items that will increase the robot’s ability to work. Should the robots fail to meet the
quota in time, they will be shut down. The goal of the player is to manage assets (money, items,
robots and scrap) to keep the robots running for as long as possible.
Assignment and submission requirements
The assignment has the following requirements. Failing to address any of these requirements will
result in deducted marks.
1. The assignment must be submitted via CloudCampus.
2. You must the full source code and be written in C++.
3. It must build and run from Visual Studio 2022 on Windows.
4. The code must be compressed using the common ZIP compression.
5. The functioning executable must run from command line under Windows 10 or higher.
6. The output needs to be in English
Game overview
The game is a single-player asset management game, where the player tries to stay alive for as long
as possible. To do so, the player must meet a certain quota every 4 game days (also called a cycle).
Money is made by sending robots to locations where scrap can be collected, and then selling this
scrap later on.
Every day, the player chooses a location and orders robots to go on expeditions in an attempt to
collect scrap. Once the player chooses to leave the location, a new day begins. The player can also
choose to travel home where the collected scrap can be sold for cash.
The player does not control robots. Instead, they choose the number of robots they wish to send on
exploration missions, and a chanced-based simulation determines how much scrap is collected and
how many robots make it back.
At the beginning of each day, 4 robots are available. When landed on the location, robots may die
during expeditions. If all 4 robots are broken, the player is forced to leave the location and a new day
begins. Robots that broke during the day are repaired at the beginning of the next day so that all 4
robots are available again.
The player should also pay attention to the weather of the location they land on. At the beginning of
each day, the weather of each location is randomized. The weather will directly affect expedition
simulation parameters such as the amount of scrap that can be collected by robots, and/or the
survival chance of robots. To achieve all of these actions, the player uses a simple command system. All commands start with a
word (e.g. “land”, “leave”, etc.) and may be followed by any number of arguments.
Example session
1. A typical session would proceed as follows:
2. The player starts the game. They begin with a cargo value of $0 (no scrap), an initial balance
of $50, a first quota of $150, and no items. Day 1 starts, and the player at home.
3. The player uses the “locations” command to see what locations are available and what is
their current weather conditions.
4. The player makes a choice and uses the “route” command followed by the name of the
location they wish to route to select a location. They may use this command as many times
as they wish.
5. Once they made up their mind, the player uses the “start” command, which marks the
beginning of the landed phase.
6. The player begins the landed phase with 4 robots alive. They use the “send” command,
followed by the number of robots they wish to send to start an expedition.
7. A simulation algorithm takes over and determines the number of robots that make it back
alive as well as how much scrap they bring back based on parameters such as the chosen
location and items bought.
8. The player is told about the result of the expedition (e.g. “N robots made it back and brought
$X worth of scrap”). That scrap is added to the cargo value (and not to the balance). From
there, the player can re-use the “send” command as long as at least one robot is functioning.
If, however, all robots breakdown as part of an expedition, all the cargo is lost, and the player
leaves the location immediately.
9. When the player feels like they’ve collected enough scrap, they can use the “leave”
command to go back home. This will bring the current day to an end and start the next one,
with all 4 robots working again.
10. At that point, the player would typically repeat operations from step 2, 3, 4 or 5 up to 9.
11. Alternatively, if they’d like to sell the collected scrap for cash, they can choose to navigate to
home using the “route home” command.
12. On the corporation location, the player would use the “sell” command, either on its own to
sell all of their, or followed by an amount to sell only a fraction of it. This will effectively
convert to scrap into usable money (in other words, the cargo value is transferred to their
balance).
13. When done, the player uses the “leave” command, which would also mark the end of that
day.
14. At the end of every 4 days, the player is expected to meet quota (reach the predefined cash
threshold). Only the balance is considered, which means that the scrap must be sold before
the end of the 4th day. If they fail to do so, the game displays the number of days they have
survived before exiting. If they succeed, a new 4-day cycle begins with an increased quota.
The quota amount is not deducted from the player’s balance.
Implementation
Your assignment must design and implement at least the following classes:
Game — The Game object drives the game. The Game object:
• Is responsible for initialising a new game.
• Is responsible for defining the locations & items available to the game.
• Is responsible for showing the welcome screen.
• Is responsible for running the 4-day cycle loop and the day loops.
• Is responsible for reading, parsing and dispatching commands.
• Is responsible for handling the following commands:
o START
o LEAVE
o EXIT
• Is responsible for keeping track of the balance.
• Is responsible for keeping track of the location currently being orbited or landed on.
• Is responsible for keeping track of the game phase (orbiting or landing).
• Is responsible for keeping track of the cargo value.
• Is responsible for keeping track of alive employees.
• Holds the item manager, the location manager and the game’s random number generator
instance.
Location manager — Manages the locations and handles the related commands. The location
manager:
Keeps (a) data structure(s) containing all the locations defined by the Game, keeping the registration
order (e.g. the order in which locations have been defined).
Handles the following commands:
LOCATIONS
ROUTE
When implementing the location manager, we suggest having a function that will be called by
“Game” to register a location:
void registerLocation(AbstractLocation* location);
AbstractLocation — Represents the base type of a location in the game. The AbstractLocation class
should be an abstract class so that differences between the corporation location and other locations
can be handled properly. A location should:
• Have a name
• Contain an description for the weather conditions it is currently experiencing.
• Handle the following commands:
o SEND
o SELL
• Print a welcome message that will be displayed after reaching the location
When implementing AbstractLocation, define an enum for weather conditions: (Clear, Flooded,
Eclisped, Stormy). Add a function that returns its name:
const std::string& name() const;
Have a function that will be called by the game when a day begins:
virtual void onDayBegin(Game& g);
Have functions that handle the SELL and SEND commands:
virtual void sellCargo(Game& g, int amount) = 0;
virtual void sendEmployees(Game& g, int count) = 0;
Hints and tips
Random number generation. C++’s random number generation is relatively complex. It features
different number generators and its syntax is a bit uncanny. To use it, make sure to create a single
number generator instance that you will re-use everywhere in your code. For that, we will use
mt19937 (MT19937 is one of many random number generator implementation):
#include std::mt19937
myGenerator(std::random_device{}());
You can then generate a random int between A and B (both inclusive) using the following code:
std::uniform_int_distribution intDistribution(A, B);
int myRandomNumber = intDistribution(myGenerator);
Similarly, you can generate a random float between 0.0 and 1.0 (1.0 excluded) using the following
code:
std::uniform_real_distribution realDistribution; float
myRandomNumber = realDistribution(myGenerator);
Simulation algorithm
The following pseudocode calculate and returns the outcome of an expedition:
numOperators = 4
robotSurvivalChance = robotsBaseSurvivalChance *
survivalChanceMultiplier
deadRobots = 0
REPEAT numRobots TIMES:
revenue = randomIntBetween(minScrapValue * scrapValueMultplier,
maxScrapValue *
scrapValueMultplier)
IF randomFloat01() < RobotsurvivalChance:
//This robot made it out alive
totalRevenue = totalRevenue + revenue
ELSE
totalRevenue = totalRevenue + revenue * lootRecoveryMultiplier deadRobots = deadRobots + 1
END IF
END REPEAT
RETURN deadRobots, totalRevenue