CS计算机代考程序代写 interpreter CS246 SPRING 2021 PROJECT – CONSTRUCTOR CS246, SPRING 2021

where is the current builder, is the colour of the builder is proposing to trade
with, is the resource is offering and is the resource is requesting.

After the prompt, player responds. The response from is either “yes” or “no”. If “yes”,
gains one and loses one , while gains one and
loses one . Otherwise, neither players’ resources change.

3.5.5 Tile Distribution

The value and resource associated with each tile is read from a file at the beginning of the game. By default, the file that
is read is named layout.txt from the current directory. (If the file isn’t present, the player needs to use the -random
command-line argument.) A command-line option can be given to change the file that will be read. The format of the file is
described in the Board Layout (3.8) section.

There is also a command-line option to generate a random resource allocation on the board layout i.e. the board will
always have the same shape, but the resource placement may change. When randomly generated, the board consists of the
following resources: 3 WIFI, 3 HEAT, 4 BRICK, 4 ENERGY, 4 GLASS, and 1 PARK. The values on the board will have the
distribution of one tile with value 2, one tile with the value 12, one tile with the value 7 (the Park), and two tiles each for the
values: 3, 4, 5, 6, 8, 9, 10, and 11. Note that this makes it possible to have a board with two tiles with the same value. The tile
with PARK does not display a value.

For example, suppose a 2 was rolled with the board in Figure 3. There is only one tile on the board that has the value 2
and it has the resource BRICK. The residences on the tile are 20, 21, 26, 27, 32, 33. Each builder who has completed one of
these residences receives some BRICK resources. The number of BRICK they receive is dependent on the type of residence
they have built (one for basement, two for house, and three for tower). If a builder has completed multiple residences on a
single tile, they receive the resource(s) for each residence.

Page 6 of 13

CS246 SPRING 2021 PROJECT – CONSTRUCTOR CS246, SPRING 2021

After the resources are distributed, print the following line for each builder who gained resources, in the order of builder
number:

Builder gained:

followed by the line:

for each resource they received from the dice roll.
If no builders gained resources from the roll, output

No builders gained resources.

3.6 Moving Geese
Geese initially start on the Park tile since it doesn’t generate any resources. When a seven is rolled, the current builder moves
the geese to any tile on the board. (The geese may not be placed on the tile on which they were previously.) Any builder with
10 or more resources will automatically lose half of their total resources (rounded down) to the geese. The resources lost are
chosen at random and the overall process is described below. For each builder who loses resources, output:

Builder loses resources to the geese. They lose:

followed by the line:

for each resource lost.
The active builder is prompted:

Choose where to place the GEESE.

The builder responds with the number of any tile except where the GEESE is currently placed. The current builder then
steals a random resource from one builder who has a residence on the tile to where the geese are moved.

If there are any players which can be stolen from, the following is output:

Builder can choose to steal from [builders].

where is the active builder and [builders] is a comma separated list of those builders, represented by their
colour, who have residences on the tile where the geese were placed, have a non-zero number of resources, and are not the
active player. The builders should be printed in the order of player number.

The active builder is prompted:

Choose a builder to steal from.

The active builder responds with the colour of the builder from whom they want to steal a random resource. Exactly one
resource is chosen. The probability of stealing/losing each type of resource is the number of the resource the builder being
stolen from has, divided by the total number of resources the builder being stolen from has.

After a resource is stolen, the following is output:

Builder steals from builder .

If the tile has no builders who can be stolen from, the following is output:

Builder has no builders to steal from.

Page 7 of 13

CS246 SPRING 2021 PROJECT – CONSTRUCTOR CS246, SPRING 2021

The display is updated with the word GEESE being added below the value of the tile that the geese were placed on. If the
geese were previously on a tile, the word GEESE is removed from that tile.

After handling the geese, the active player completes their turn as normal.
For example, consider Figure 2. Say builder Blue has 5 HEAT, Red has no resources, Orange has 11 BRICK, and Yellow

has 3 GLASS. Now Blue rolls a 7. The program outputs:

Builder Orange loses 5 resources to the geese. They lose:
5 BRICK
Choose where to place the GEESE.

Blue inputs 9 to place the GEESE on tile 9. The program outputs:

Builder Blue can choose to steal from Yellow.
Choose a builder to steal from.

Blue inputs Yellow. The program outputs:

Builder Blue steals GLASS from builder Yellow.

Now Blue has 1 GLASS, 5 HEAT, Red has no resources, Orange has 6 BRICK, and Yellow has 2 GLASS.

3.7 Saving a Game
When a game is saved, the following information is printed to a file in the following order:

A description of each line follows.
is the identity of the builder whose turn it will be when the game starts.
A builder’s data is printed out as follows:

r h

where is the number of each road, separated by one space, and is the list of residences that
have been built, each represented as a pair. Each pair in the list represents the vertex of the residence followed by the letter
representing the residence on it.

For example, the row

1 2 1 2 3 r 16 36 19 h 10 B 15 T 27 H

would be the output for a player with 1 BRICK, 2 ENERGY, 1 GLASS, 2 HEAT, 3 WIFI, the roads 16, 36 and 19 and
residences at vertices 10 (a basement), 15 (a tower) and 27 (a house).

is described in section 3.8.
is a number between 0 and 18 representing the tile that contains the geese. Traditionally, geese would start on

the Park tile since that tile produces no resources. It is up to you whether they are initially displayed or not before a 7 is rolled.

Page 8 of 13

CS246 SPRING 2021 PROJECT – CONSTRUCTOR CS246, SPRING 2021

3.8 Board Layout
For loading and saving a board layout, the following format will be used.

The resources will be printed in the order of the resources on the board with 0 representing BRICK, 1 representing
ENERGY, 2 representing GLASS, 3 representing HEAT, 4 representing WIFI, and 5 representing PARK with each resource
being followed by its value

For example, the board in Figure 3 is

0 3 1 10 3 5 1 4 5 7 3 10 2 11 0 3 3 8 0 2 0 6 1 8 4 12 1 5 4 11 2 4 4 6 2 9 2 9

Note that in the provided files, a tile for PARK will always be followed by the number 7 even though it doesn’t have a value
associated.

While the board is symmetric, it is not symmetric enough to allow an easy formula for the relationship between tiles, edges
and vertices. You will therefore need to come up with some reasonable approach to handle this.

4 Gameplay
There are four distinct stages in the game, during which input should be handled differently.

4.1 Beginning of Game
At the beginning of the game, each builder chooses two initial basements to build. The basements will be chosen by builders
in the order Blue, Red, Orange, Yellow, Yellow, Orange, Red, Blue.

Each builder is prompted with the statement:

Builder , where do you want to build a basement?

Each builder responds with a number that represents a valid vertex.
Once a valid vertex has been entered, prompt the next builder. Once all builders have placed their two basements, print the

updated board and begin the game.

4.2 Beginning of Turn
At the beginning of a turn, display the board and print the following:

Builder ’s turn.

followed by the status of the builder. A builder can then enter any of the following three commands:

Command Description
load sets the dice of the current builder to be loaded dice
fair sets the dice of the current builder to be fair dice
roll rolls the current builder’s dice. This ends the ”Beginning of the turn” phase and moves the builder to ”During the turn”.

4.3 During the Turn
During the turn, a builder can input any of the following commands:

Page 9 of 13

CS246 SPRING 2021 PROJECT – CONSTRUCTOR CS246, SPRING 2021

Command Description
board prints the current board
status prints the current status of all builders in order from builder 0 to 3
residences prints the residences the current builder has currently completed
build-road attempts to builds the road at
build-res attempts to builds a basement at
improve attempts to improve the residence at
trade attempts to trade with builder giving one resource of type and receiving one

resource of type
next passes control onto the next builder in the game. This ends the ”During the Turn” phase.
save saves the current game state to
help prints out the list of commands

The help command prints the following

Valid commands:
board
status
residences
build-road
build-res
improve
trade
next
save
help

4.4 End of Game
The game ends when a builder has a total of at least 10 building points. The first builder to have 10 building points is the
winner. At this point, the builders are prompted:

Would you like to play again?

If the response is “yes”, the game starts over from the beginning. If the response is “no”, the game exits.

4.5 Handling Input
When waiting for a response from standard input, the program prints ‘¿ ’.

If a builder attempts to improve or build a residence, or build a road, and the space is invalid (for any reason), output:

You cannot build here.

If a builder attempts to build anything and they do not have the required resources, output:

You do not have enough resources.

If an unrecognized command is entered, output:

Invalid command.

If the game receives an end-of-file signal at any point, the game ends with no winner, and saves the current game state to
backup.sv.

Page 10 of 13

CS246 SPRING 2021 PROJECT – CONSTRUCTOR CS246, SPRING 2021

5 Command-line Interface
Note: Command-line options are important to implement as they aid in easy testing of the correctness of your program.
Programs which do not implement all command line options will not be fully tested and will receive low marks.

Your program must support the following options on the command line:

Command Description
-seed xxx sets the random number generator’s seed to xxx. If you don’t set the seed, you always get the same random sequence every time

you run the program. It is good for testing, but not much fun.
-load xxx loads the game saved in file xxx. You may assume that the file being loaded was saved as a valid game state as described in the

Saving section. Note: loading from a saved file will be heavily used during the testing of the project and should be
considered a priority while implementing the project.

-board xxx loads the game with the board specified in the file xxx instead of using random generation. This file will contain the order of the tiles
for the game as described in the saving the game section. The number of each tile present does not have to match the random
generation. e.g. it is valid to have a board which is entirely WIFI resources with the value 122.

-random-board starts a game with a randomly generated board.

The command-line options can be given in any order. Note that -board and -load are contradictory commands to each
other. Similarly, if a game is being loaded or a custom layout is being used, -random-board is ignored and the layout
specified in the saved game or custom layout is used instead.

6 Questions
These questions are to be answered as described in the project guidelines.pdf. We recommend reading and thinking about
these questions while you are designing you project.

You must answer questions 1 and 2, AND any 3 of questions 3-7.

1. You have to implement the ability to choose between randomly setting up the resources of the board and reading the
resources used from a file at runtime. What design pattern could you use to implement this feature? Did you use this
design pattern? Why or why not?

2. You must be able to switch between loaded and fair dice at run-time. What design pattern could you use to implement
this feature? Did you use this design pattern? Why or why not?

3. We have defined the game of Constructor to have a specific board layout and size. Suppose we wanted to have different
game modes (e.g. hexagonal tiles, a graphical display, different sized board for a different numbers of players). What
design pattern would you consider using for all of these ideas?

4. At the moment, all Constructor players are humans. However, it would be nice to be able to allow a human player to
quit and be replaced by a computer player. If we wanted to ensure that all player types alway followed a legal sequence
of actions during their turn, what design pattern would you use? Explain your choice.

5. What design pattern would you use to allow the dynamic change of computer players, so that your game could support
computer players that used different strategies, and were progressively more advanced/smarter/aggressive?

6. Suppose we wanted to add a feature to change the tiles’ production once the game has begun. For example, being able
to improve a tile so that multiple types of resources can be obtained from the tile, or reduce the quantity of resources
produced by the tile over time. What design pattern(s) could you use to facilitate this ability?

7. Did you use any exceptions in your project? If so, where did you use them and why? If not, give an example of a place
that it would make sense to use exceptions in your project and explain why you didn’t use them.

Page 11 of 13

CS246 SPRING 2021 PROJECT – CONSTRUCTOR CS246, SPRING 2021

7 If Things Go Wrong
If you run into trouble and find yourself unable to complete the entire project, please do your best to submit something that
works, even if it doesn’t solve the entire project. For example:

• only one housing type exists

• does not recognize the full command syntax

• building points are not calculated correctly

You will get a higher mark for fully implementing some of the requirements than for a program that attempts all of the
requirements, but doesn’t run.

A well-documented, well-designed program that has all of the deficiencies listed above, but still runs, can still potentially
earn a passing grade.

8 Plan for the Worst
Even the best programmers have bad days, and the simplest pointer error can take hours to track down. So be sure to have a
plan of attack in place that maximizes your chances of always at least having a working program to submit. Prioritize your
goals to maximize what you can demonstrate at any given time. One of the first things you should probably do is write a
routine to draw the game board (probably a Board class with an overloaded friend operator<<). It can start out blank, and become more sophisticated as you add features. You should also do the command interpreters early, so that you can interact with your program. You can then add commands one-by-one, and separately work on supporting the full command syntax. Take the time to work on a test suite at the same time as you are writing your project. Although we are not asking you to submit a test suite, having one on hand will speed up the process of verifying your implementation. Note that for testing purposes, it is more important to have the non-randomized features, e.g. loaded dice, reading a saved game from a file, working than the randomized features, e.g. fair dice, random generation. You will be asked to submit a plan, with projected completion dates and divided responsibilities, as part of your documen- tation for Due Date 1. 9 If Things Go Well If you complete the entire project, you can earn up to 10% extra credit for implementing extra features. These must be outlined in your design document, and markers will judge the value of your extra features. 10 A Note on Random Generation To complete this project, you will require the random generation (or rather, pseudo-random) of numbers. See the provided shuffle.cc for an example of declaring a random number generator that is used to randomly shuffle a vector of integers. The random number generator is seeded once with the (possibly global variable) seed, and then used in std::shuffle. Games that are started with the same seed value have the same sequences of random numbers generated. Due Dates Due Date 1: Due on due date 1 is your plan of attack, plan.pdf, and initial UML diagram, uml.pdf, for your implemen- tation of Constructor on Marmoset, CS246_PROJECT. Due Date 2: Due on due date 2 is your actual implementation of Constructor. All .h, .cc and any other files needed for your project to compile and run should be included in constructor.zip. The ZIP file must contain a suitable Makefile such that typing make will compile your code and produce an executable named constructor. In addi- tion, your constructor.zip must also contain demo.pdf and all necessary files to run your demo (such as saved input, Page 12 of 13 CS246 SPRING 2021 PROJECT – CONSTRUCTOR CS246, SPRING 2021 either with a fixed seed or loaded game files, but not the program executable, which will be compiled from the files submitted in constructor.zip), uml-final.pdf and design.pdf to the appropriate place on Marmoset, CS246_PROJECT. If you have implemented any bonus features, make sure that your submitted demo plan includes a list of all of the described bonus features, and how to run the game to see the effect of the bonus features. See project guidelines.pdf for instructions about what should be included in your plan of attack and final design document. Page 13 of 13 The Game of Constructor Gameplay Overview Game Components Board Tiles Geese Vertices Housing Details Edges Roads Builders Dice Loaded Dice Fair Dice Game Rules Building Residences Improving Residences Building Roads Turn Order Resources Printing Resources Obtaining Resources Using Resources Trading Resources Tile Distribution Moving Geese Saving a Game Board Layout Gameplay Beginning of Game Beginning of Turn During the Turn End of Game Handling Input Command-line Interface Questions If Things Go Wrong Plan for the Worst If Things Go Well A Note on Random Generation