代写COMP 3023、C++程序设计代做

日期：2024-06-01 10:11

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