联系方式

  • QQ:99515681
  • 邮箱:99515681@qq.com
  • 工作时间:8:00-23:00
  • 微信:codinghelp2

您当前位置:首页 >> Java编程Java编程

日期:2021-07-18 10:08

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”.


版权所有:留学生编程辅导网 2020 All Rights Reserved 联系方式:QQ:99515681 电子信箱:99515681@qq.com
免责声明:本站部分内容从网络整理而来,只供参考!如有版权问题可联系本站删除。