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 

請(qǐng)加QQ：99515681  郵箱：99515681@qq.com   WX：codinghelp