data编程讲解辅导、辅导Java编程、Java程序设计辅导
解析R语言编程|辅导SPSS
Murder Madness
To implement a prototype of “Murder Madness” (specification follows
below).You will design a solution using CRC cards and UML Class Diagram,
and implement a solution using Java.Feel free to optionally use the Umple
tool for designing models and generating code.
Specification
True to life, the following specification may be incomplete or ambiguous
in parts and in such cases you will have to make reasonable assumptions.
Objective
The game is a detective challenge played by three to four players who move
around a board comprising five estates. The game starts after a murder
has happened in one of the estates. The aim is to deduce the murder
circumstances, i.e., who the murderer was, what weapon they used and in
which estate they committed the murder.
Board The “Murder Madness” board consists of five estates located on
a 24x24 square area.
The four grey areas are inaccessible to players and player cannot go
through estate walls or use a square occupied by another character either.
Estates do not have internal structure; they count as a single square.
There are four starting squares, one per character as shown above.
Characters :There are four characters, one of which (randomly selected
for each game play) is the murderer: Lucilla , Bert, Maline, Percy.
Each player assumes the role of one of these characters.
Weapons There are five weapons in the game, one of which is the murder
weapon: Broom ,Scissors ,Knife ,Shovel ,iPad .Each weapon is
initially placed in an estate chosen at random, such that no two weapons
are in the same estate.
Rules
Every character, weapon and estate is represented by a card in the game.
Before the game starts, one character, one weapon, and one estate card
are selected at random. This selection represents the murder
circumstances, i.e., the “solution” that players need to figure out
during game play.
The remaining weapon, estate and character cards are then combined and
distributed at random to players. Some players may end up with more cards
than others but only at most one more.
Players take turns to roll two dice and move their character a
corresponding number (sum of the dice values) of squares. Diagonal
movement is not allowed and no square can be used twice during one turn.
When a player enters a estate, they do not need to use any remaining moves
they have left. They may then hypothesise about the murder circumstances
by making a guess which comprises the estate they are in, a character and
a weapon. If the named character and weapon named in the guess are not
in that estate yet, they are now moved into the estate.
When a guess is made, each player – using the order Lucilla, Bert, Malina,
Percy, but starting one player after the player making the guess, and
cycling around – attempts to refute the guess. A guess is refuted by
producing a card that matches one of the suggested murder circumstances
(such a card cannot be part of the solution and hence refutes the guess).
A refutation card is only revealed to the player that made the guess and
if a refutation can be made, it must be made.
If a player has multiple refutation cards, it is their choice which one
they pick. If no player can produce a refutation, the named murder
circumstances are a potential solution candidate that may or may not be
used to make a solve attempt later on (by any player).
A solve attempt comprises a character, a weapon, and an estate. If the
solve attempt made by a player exactly matches the actual murder
circumstances, the player wins, otherwise the player is excluded from
making further guesses or solve attempts. This means the player cannot
win the game anymore but will continue to refute guesses by others.
User Interface
Implement an object-oriented program for playing the “Murder Madness”
game. The game interface should be simple and must be text-based. Only
text-based input and output is permitted, i.e., all input/output must
occur via System.in and System.out. You may, of course, use the standard
output to print a text character-based 2D presentation of the game board
using text, location of characters, etc. 1. The program begins by asking
how many players wish to participate. 2. One player is selected to start
at random. 3. At the start of each turn, the program rolls two (virtual)
dice to determine the move distance of the player who’s turn it is by
using the sum of the dice values. The current player then moves their token
to a desired spot on the grid. 4. Once a player has moved, they are
presented with the option of making a guess or a solve attempt. All rules
of the games must be enforced at all times, e.g., only guesses that involve
the estate the current player is in, should be permitted. 5. The program
then repeats steps 3–5 for the next player, unless a player has won or
all players have been eliminated due to incorrect solve attempts.
Assume the game is being played on a tablet and players hand the tablet
back and forth so that only one player at a time can see information meant
only for them, e.g., when refutations are made. The game must print
instructions which player is to receive the tablet at each point in time
and must not reveal secret information to players who are not privy to
that information.
To do:
1. Clear justifications of assumptions made to fill in missing or
ambiguous game specification information.
2. UML Class Diagram:Adequate use of the following: inheritance,
associations, multiplicities, classes, operations, and attributes.
3. CRC Cards: Correct use of the notation and a well-designed distribution
of responsibilities.
4. Correctly implement the given specification of “Murder Madness”.