Java代写 | COMP90041: Assignment 3


COMP90041: Assignment 3
This project comes in two parts: 1) the mandatory assignment and 2) a bonus assignment. You
can score 10 out of 10 on the mandatory part and score 2 additional points with two bonus tasks, which
will count toward your overall course grade.
1 Mandatory Assignment
1.1 Introduction
The aim of this project is to add some more advanced features to the system developed in Project B.
The features to be added are:
• Sort the players with more specific rules
• Handling of invalid input via Exceptions
• Write (read) the game statistics into (from) a file, i.e., one which is stored on the hard disk between
executions of Nimsys
• A new type of player – an AI (Artificial Intelligence) player, whose moves are automatically determined by the computer rather than a game user
The system should still operate as specified in Project B, but with additional functionality, due to the
addition of the aforementioned features. Thus, it is advised that you use your Project B solution as a
starting point for implementing Project C.
Knowledge Coverage
• Exceptions
• File I/O operations
• Polymorphism, you may use either inheritance or interface to design the AI player in addition to
the human player
1.2 Requirements
In the following description, all command line displays are put in a box. This is only for easier understanding the format. The box should NOT be printed out by your program, only the contents
in the box should be printed. The command prompt is illustrated below:

c The University of Melbourne 2020 1
1.2.1 Sort the players with more specific rules
In Project B, when two players had the same winning ratio, you were required to sort the players by
username in either ascending alphabetical order or descending alphabetical order.
In this project, the ranking should still be based on the winning ratio first (i.e., the percentage of games won). If there is a tie (two or more players with the same winning ratio), sort all players
by their username in ONLY ascending alphabetical order.
Example Execution:
Suppose we have three players in (username, First Name, Last Name) format as follow: (LS, Luke,
Skywalker), (HS, Han, Solo), (DV, Darth, Vader). They all have the same wining ratio.
1. rank all users (default, i.e., descending order)
0% | 00 games | Darth Vader
0% | 00 games | Han Solo
0% | 00 games | Luke Skywalker
2. rank all users in descending order
$rankings desc
0% | 00 games | Darth Vader
0% | 00 games | Han Solo
0% | 00 games | Luke Skywalker
3. rank all users in ascending order
$rankings asc
0% | 00 games | Darth Vader
0% | 00 games | Han Solo
0% | 00 games | Luke Skywalker
1.2.2 Invalid input handling via Exceptions
The system should check inputs for validity. For this task, you will not be required to implement exception
handling for all possible invalid inputs – just a subset of them. The range of potential invalid inputs
you are required to address by Exceptions (not via if-then statements) are listed below, along with the
required behaviour of your program. Note that some of this input checking was also a requirement in
Project B. Where this is the case, you need to modify your code so that the invalid input is handled via
Exceptions. The rest of the invalid input handling cases described in Project B do not need modification.
• Invalid command – The user enters a command which is not a valid Nimsys command. Here, invalid
command suggests the input command is not among the specified commands, i.e., addplayer,
editplayer, removeplayer, displayplayer resetstats, rankings, startgame, and exit.

c The University of Melbourne 2020 2
$createplayer lskywalker,Skywalker,Luke
‘createplayer’ is not a valid command.
• Invalid number of arguments – The user enters a valid Nimsys command, but does not provide
the correct number of arguments. Note: You only need to check for insufficient number of arguments, and simply ignore any extra arguments, i.e., an insufficient argument count will generate
an Exception while an excessive count will not. Different commands may have different number of
arguments; your program should be able to check invalid number of arguments for all commands.
$addplayer lskywalker
Incorrect number of arguments supplied to command.
• Invalid move (during a game) – The player tries to remove an invalid number of stones from the
game. For the move to be valid, it must be an integer between 1 and N inclusive, where N is
the minimum of the upper bound and the number of stones remaining. Any other inputs (e.g.
fractions, decimals, non-numeric entries) should be detected as invalid.
Example (Upper bound is 3 stones here):
7 stones left: * * * * * * *
Han’s turn – remove how many?
Invalid move. You must remove between 1 and 3 stones.
7 stones left: * * * * * * *
Han’s turn – remove how many?
After implementing the invalid input checking, the scenarios detailed above should not cause your
program to crash – rather, your program should display the appropriate error message, and continue execution, as illustrated in the examples. You may assume that, aside from the cases explicitly mentioned
above, the input to your program will be valid.
1.2.3 The player statistics file
In Project B, no program data are stored to disk, so all player data are lost when exiting the program.
Here, the task is to store these data upon exiting the program, and to restore them on subsequent executions. Thus, if one was to exit your program (using the ‘exit’ command), and then start it again
(by running ‘java Nimsys’ at the shell prompt), your program should be restored to the state it was in
immediately before exiting. That is, it should be as if the program never exited at all.
This can be achieved by storing your player data in a file. At the beginning of the execution of your
program, if the file exists, it is opened and its contents loaded into the system. When your program
exits, this file will be updated with new/modified players, and then closed. If the file does not already
exist, it will need to be created. It is up to you to decide the most appropriate format, e.g., text or
binary, of this file. The name of the file should be players.dat, and it should be stored in the same
directory as your program.

c The University of Melbourne 2020 3
All player information should be stored, i.e., usernames, given / family names, and number of games
played / won. Note that you do not need to store information about games in progress, since a game
should never be in progress when the program exits properly, i.e., via the ‘exit’ command.
1.2.4 The AI (Artificial Intelligence) player
Here, a new type of player is to be added – an AI player. This player type should be controlled by the
program, not by a human player. Aside from this, an AI player should be the same as a human player.
That is, they should have all the same information associated with them (i.e., username, given/family
names, and number of games played/won), and they should be stored in the system and appear in player
lists/rankings, just as human players are. They should also be manipulated via all the same commands
(with the exception of ‘addplayer’, since we now need to indicate whether we are adding a human player
or an AI player to the system – see below).
The only difference between a human player and an AI player is in the way that they make a move.
Instead of prompting for a move to be entered via standard input, the AI player should choose their
own move, based on the state of the game. Thus, the only difference between a human player and an AI
player should be in the method used to make a move. This suggests that the object-oriented principle
of polymorphism should be applied here. Java offers polymorphism via two main avenues – inheritance,
and interfaces. In this case, inheritance is the more appropriate choice. Conceptually speaking, we can
think of human players and AI players as specialized players, i.e., a human player is a player, and an AI
player is a player. They are identical in almost every way, and so most of their attributes and methods
can be inherited – the only exception to this is the method used to make a move, which will need to be
rewritten to act autonomously. You can add an abstract NimPlayer class, which will be used to represent the behaviour/attributes common to both Human and AI players. You can modify your original
NimPlayer class used in Project B to be the new abstract NimPlayer class, and the human player class
(NimHumanPlayer) and AI player class (NimAIPlayer) can extend the abstract player class.
Part of your mark for this project will be based on how well you apply polymorphism in your implementation of the human and the AI player, so it is important that you do use the principle of polymorphism
in your design.
To allow for AI players to be added to the system, you should create a new command – ‘addaiplayer’.
This command should operate in exactly the same way as ‘addplayer’ (refer to Project B for details).
The only difference is that the resulting player is an AI player. Note that all other commands, e.g.,
‘removeplayer’ and ‘editplayer’ should work for both human players and AI players. Provided below is
an example of the use of the ‘addaiplayer’ command:
$addaiplayer artoo,D2,R2
In this task you need to modify the provided to implement the AI player functionality. Note that this file and are provided to you for auto-testing the task of Section 2.6.
You do NOT need to modify the advancedMove() method until you work on the task of Section 2.6.
After implementing the AI player, the ‘startgame’ command should allow games to be started with one
or both players being AI players. The game should proceed exactly as per the Project B spec, except
that when it comes to an AI player’s turn, there should be no reading of input from standard input
– instead, the move should be immediately made by the AI. Provided below is an example execution.
Here, Luke is a human player, and R2 D2 is an AI player:
$startgame 10,3,lskywalker,artoo
Initial stone count: 10

c The University of Melbourne 2020 4
Maximum stone removal: 3
Player 1: Luke Skywalker
Player 2: R2 D2
10 stones left: * * * * * * * * * *
Luke’s turn – remove how many?
7 stones left: * * * * * * *
R2’s turn – remove how many?
5 stones left: * * * * *
Luke’s turn – remove how many?
2 stones left: * *
R2’s turn – remove how many?
1 stones left: *
Luke’s turn – remove how many?
Game Over
R2 D2 wins!
The move an AI player makes given a specific situation shall follow certain strategy such that the victory
is guaranteed for the AI player if it holds the ability to win when the game commences. For details,
please see the following section.
2 Checklist For Solution
• Blank line and whitespace related issues
Make sure in terms of format, your output matches with the expected output on the submission
• File I/O mechanism related issues
Make sure your program runs fine no matter whether the players.dat file exists.
Make sure every exit command triggers data to be written to the players.dat file.
• Polymorphism related issues
Make sure the AI player is implemented using inheritance mechanism.
Make sure you are leveraging the polymorphism to invoke the methods, i.e., using object
declared in parent class to invoke methods overridden in the child class.
If attempting for bonus marks, make sure the advanced game is implemented using either
inheritance or interface mechanism
• Submission issues
Make sure there is only one Scanner object throughout your program.
• Other issues

c The University of Melbourne 2020 5
The wining ratio of players with 0 games is 0.
The maximum number of players can be set as 100.
Collections such as ArrayList are acceptable.
Players are by default sorted according to the lexicographical order of the usernames.
Usernames can be assumed to be all lower-cased.
“What it means when lastMove is a blank String/null in the advanced Nim game? ”
It means that there is no last move and your NimAIPlayer object is to make the first move.
“My code works perfectly on my machine but it does not get any winning ratio in the last test.”
First, check the FAQ items above and make sure you have handled each of them. Second,
make sure that you do not change the Boolean array input parameter in advancedMove().
We just need your move returned as a String, and we will update the Boolean array.
3 Important Notes About Submission
Immediately after you make a submission using the “submit” command, computer automatic test will
be conducted on your program by automatically compiling, running, and comparing your outputs for
several test cases with generated expected outputs. The automatic test will deem your output wrong if
your output does not match the expected output, even if the difference is just having an extra space or
missing a comma. Therefore it is crucial that your output follows exactly the same format shown
in the examples above.
The keyword import is available for you to use standard java packages. However, please DO NOT
use the package keyword to organise your source files into packages. The automatic test system cannot
deal with packages. If you are using Netbeans as the IDE, please be aware that the project name may
automatically be used as the package name. Please remove the line like
package ProjC;
at the beginning of the source files before you submit them to the system.
Please use ONLY ONE Scanner object throughout your program. Otherwise the automatic test will
cause your program to generate exceptions and terminate. The reason is that in the automatic test,
multiple lines of test inputs are sent all together to the program. As the program receives the inputs, it
will pass them all to the currently active Scanner object, leaving the rest Scanner objects nothing to read
and hence cause run-time exception. Therefore it is crucial that your program has only one Scanner
object. Arguments such as “It runs correctly when I do manual test, but fails under automatic test”
will not be accepted.
4 Your Task
Implement the new version of Nimsys in Java according to the above specification. Specifically, it includes
following subtasks:
1. try / catch syntax to detect the listed invalid inputs in Section 1.2.2;
2. file based mechanism for player data as described in Section 1.2.3;
3. the AI player implemented using polymorphism mechanism in Section 1.2.4;
4. See LMS for a detailed marking scheme.

c The University of Melbourne 2020 6
5 Assessment
This project is worth 10% of the total marks for the subject. Remember that there is a 50% hurdle
requirement (i.e. 20/40) for the three projects.
Please note that if you attempt the bonus task, you can get 2 bonus points. Hence, you can score 12 out
of 10 on this assignment. However, the total mark for the three projects cannot exceed 40. The bonus
assignment is a challenging task and it takes time to complete, please allocate your time
The deadline for the project is 5pm, Friday 22 May, 2020. There is a 20% penalty per day for
late submissions. Suppose your project gets a mark of 10 but is submitted within 1 day
after the deadline, then you get 20% penalty and the mark will be 8 after penalty. There
will be no mark for submissions after 5pm 26 May, 2020.
Your Java program will be assessed based on correctness of the output as well as quality of code implementation. See LMS for a detailed marking scheme.
6 Submission
The entry point of your program should be in a class called Nimsys (in a file called Thus,
your program will be invoked via:
java Nimsys
Your Java classes should be stored together in their own directory under your home directory on the
student server. Then, you can submit your work using the following command:
submit COMP90041 projC *.java
For late submissions, use the following command:
submit COMP90041 projC.late *.java
Note that you must submit all Java files you have used for your project, not just
If you submit you code multiple times, the later submission will overwrite the previous one. If you submit
all your java source codes and then modify one source code, you need to submit all of your source codes
again, not just the modified one.
You should then verify your submission using the following command. This will store the verification
information in the file ‘feedback.txt’, which you can then view:
verify COMP90041 projC > feedback.txt
For late submissions, use the following command:
verify COMP90041 projC.late > feedback.txt
You should issue the above commands from within the same directory as where your project files are
stored (to get there you may need to use the cd ‘Change Directory’ command). Note that you can submit
as many times as you like before the deadline.
How you edit, compile and run your Java program is up to you. You are free to use any editor or
development environment. However, you need to ensure that your program compiles and runs
correctly on the student servers.
The test cases used to mark your submissions will be different from the sample tests given. You should
test your program extensively to ensure it is correct for other input values with the same format as the
sample tests.

c The University of Melbourne 2020 7
Submit your program to the student servers a couple of days before the deadline to ensure that they
work (you can still improve your program). “I can’t get my code to work on the student server
but it worked on my Windows machine” is not an acceptable excuse for late submissions.
7 Individual Work
Note well that this project is part of your final assessment, so cheating is not acceptable. Any form of
material exchange, whether written, electronic or any other medium is considered cheating, and so is
the soliciting of help from electronic newsgroups. Providing undue assistance is considered as serious
as receiving it, and in the case of similarities that indicate exchange of more than basic ideas, formal
disciplinary action will be taken for all involved parties. A sophisticated program that undertakes deep
structural analysis of Java code identifying regions of similarity will be run over all submissions in
“compare every pair” mode.

c The University of Melbourne 2020 8


本网站支持淘宝 支付宝 微信支付  paypal等等交易。如果不放心可以用淘宝交易!

E-mail: [email protected]  微信:itcsdx