联系方式

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

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

日期:2020-11-14 11:57

Page 1 of 6

Instructions:

? Read the SubmissionProcedures.PDF and the Standards.java carefully BEFORE you start.

? Let me know about any typos, clarifications, or questions you may have right away. Do not wait.

? Read the whole assignment before you start.

? Start right away. The sooner you get stuck, the sooner you can get help to get un-stuck.

Assignment overview

Learning outcomes:

You will be working with multi-dimensional arrays and StdDraw (Graphics) for this assignment. I will be providing

you with a GameController which handles the game logic and input, a Board which holds the pieces as well as

the start of a TestClass to help you with testing (you should extend this to add additional testing however). I will

also provide you with a starter ChessPiece class which you will extend.

Additional Notes:

Read Standards.java and SubmissionGuidelines.PDF Carefully & before you start.

Please provide detailed commenting!!!

Assignment Notes & Tips:

Be sure to read the assignment carefully. Include a readme.txt document that specifies the latest commit that will

compile and run. This assignment is as much about learning formatting, commenting, testing, and refactoring

practices as it is about Java. Do not skip steps. Make sure you are testing as you go.

Start early. Read the assignment fully before beginning. We will go through it in the first class after it has been handed

out. That is your chance to ask questions. Seriously, start early. I know you are busy, but it is much easier if you get

stuck early and can get help troubleshooting.

Notes on Academic Misconduct:

Your code should be done entirely by you. Any suspicion of Academic Misconduct or plagiarism will be fully

investigated and can lead to serious academic penalties including 0 on the assignment for a first office, or an F in the

course. Third offences could lead to expulsion from ICM. If you have any questions as to what qualifies as Academic

Misconduct, please discuss it with me.

General Notes:

We will be upgrading our previous Checkers game into a Chess game. Along the way, we will add the ability to read a

board state into a file, properly handle our exceptions and see a useful application of subclasses. We will also practice

operations on multi-dimensional arrays.

Keep an eye out for opportunities to reuse existing code and reduce duplication. Do not be afraid to refactor and

clean up your code from time to time. It will save you time in the long run if it is organized and logical.

Page 2 of 6

You should not change anything in ChessPiece (especially removing private), GameController (other than

uncommenting one line to read from a file instead) or Board. You will have to access what you need in the subclass

using appropriate subclassing techniques.

Phase 0: (Not Optional)

When you first start your project, before writing any code, you will create a new git repo in the same folder. You

should ignore any .class files, or any files associated with your text editor (basically ignore every file type that

appears other then .java or .txt).

Create a new local git repo, then make your first commit here, which will simply be the .gitignore file that was

created with a message (such as "Initial commit" with a list of the types of files ignored.

*Note: It might be a good idea to back up your progress as you go in case you run into issues with git. I just

select the whole project folder and put it in a .zip folder. This will give you a snapshot of your code at that

place and time.

Phase 1: Creating the pieces

To start, we must create our pieces. Create the following new classes : Pawn, Castle, Knight, Bishop, Queen, King

Each of these will be a subclass of ChessPiece.

Provide two constructors for each. The first will accept (String newColor, Board theBoard) and will set the name of

the piece automatically (eg. "Pawn", "Queen"... ) while the second will accept (String name, String newColor, Board

theBoard). Both should be using the constructor in ChessPiece to properly set the values (rather than creating new

variables). You should be able to recycle some code if you are clever about it.

Once the constructors are working (and tested in your test file!) you should provide correct graphics references to

each piece (the png file name). Initialize the graphics variables in ChessPiece as part of the Constructors' process.

At this point, you should be able to load up the pieces of the board and have them appear on the board.

Test your board to make sure it is working.

Phase 2: Adding file reading

Create a new class BoardLoader. This will be responsible for loading a file representing a Board into an actual Board.

Provide the following methods in BoardLoader.

a) public static void loadBoardState(Board theBoard, String fileName)

This accepts both a reference of the board to be initialized as well as the file name to load from. It will

handle the other methods.

Page 3 of 6

b) private static String[][] parseFile(String fileName)

Load the file from disk and return the contents as a 2D array. Each Row will represent one line in the file

while each Col will contain a single token. Be mindful that the files contain the board size at the beginning.

You can skip this (for now) but do not modify the files.

? Tip: Be careful that the white and black positions do not get switched, it should look the same as the

file.

c) private static void loadPiecesFromString(Board targetBoard, String[][] boardCodes)

Accept a 2D array of type String with all the board codes and load the pieces into the board from this.

d) private static ChessPiece loadChessPiece(Board targetBoard, String code)

Creates and returns a single ChessPiece given a String code.

The boards look like this:

BC BN BB BK BQ BB BN BC

BP BP BP BP BP BP BP BP

E E E E E E E E

E E E E E E E E

E E E E E E E E

E E E E E E E E

WP WP WP WP WP WP WP WP

WC WN WB WQ WK WB WN WC

The first Char of each Token is the Color (or E for Empty).

The second is the position

C = Castle

N = Knight

B = Bishop

K = King

Q = Queen

P = Pawn

? Note: String folder = ".\\Boards\\"; // use this to load from the folder. Don't change the layout of the

files. Load them from the correct location. This may work slightly differently depending on your IDE.

? Other note: I have put these different tasks in separate methods to assist with testing so take advantage of it.

Page 4 of 6

Phase 3: Movement and isValidMove

Provide an overriding version of the isValidMove method for each of the subclasses of ChessPiece from Phase 1.

Each will be different depending on the type of piece. I suggest you work out some strategies on paper before you

start coding.

isValidMove lets us know if a proposed move is valid or not. We give it the current position and the goal position

and it will test whether that move can be made (true) or not (false).

Tackle these in any order you like.

Rules:

? Pawn: Can move one tile forward (towards opponent) but cannot capture OR can capture one tile diagonally

forward but only if an opposing piece is there. Pawn is one of the simplest but can only move in the direction

of its color so you will need to handle this separately. Its diagonal attack action is also only valid if there is an

opposing piece there.

? Knight: Can jump over other pieces and travel 2 horizontal spaces and 1 vertical space OR 1 horizontal

space and 2 vertical spaces (in any direction).

? King: Can travel 1 tile in any direction

? Bishop: Can travel n tiles diagonally but cannot "jump" over other pieces

? Castle: Can travel n tiles either horizontally or vertically (one or the other) but cannot "jump" over other

pieces.

? Queen: Can travel n tiles either horizontally, vertically, or diagonally but cannot "jump" over other pieces.

o *n tiles – just means as many tiles as you want in a given direction.

Some tips/hints:

? King is probably the easiest and a good place to start.

? Knight is the only piece that can jump over others. The rest you will have to check for other pieces being in

the way. Detecting other pieces blocking your path is probably the most difficult part.

? Note the similarities between the way pieces move. Can you use this to your advantage somehow?

? A piece can capture an opposing piece but not its own team.

At this point you should make sure you test your code well to ensure everything is working correctly. The methods

drawSelectedForSingleMove and drawSelectedForAllValidMoves are very useful for visualizing whether

your moves are being calculated correctly or not. They will draw green squares on the board if the move is valid / for

all valid moves. See the TestClass I started for you for examples (I expect you to extend and improve on this).

Refactoring checklist:

? Double check the spelling and case (methods are lowercase, classes are Uppercase) against the

assignment doc. It may not seem important but when I run my test classes, this will break all my marking

code. Not a good start to things.

? Make sure all of your variables are private. Most methods can be public for now.

? Make sure you have appropriate accessor methods for what you need.

o Not every variable will need access outside of the class, so think about which ones do.

? Add a comment header at the top of each Class file explaining what it does

? Add a comment above each method explaining what it does. It is also useful to include usage instructions or

useful notes. "Crashes on numbers below 0" for example.

? Make sure your method names make sense and are free of typos.

? Organize your variables so that they are grouped with related variables.

? Just read through your code, add any questions or notes you might have in comments.

? Remove any redundant code (leftover stuff that is not being used).

? Be careful what you remove. Make sure you test again afterwards.

? Never assume it will work without testing it. Small changes can have large effects.

That is all. Congratulations, you are done!

Before handing in your files:

? Revisit all your classes, improving the commenting and formatting.

? Include additional testing in your TestClass.java including edge cases.

? Include a Readme.txt file that includes clear instructions on how to run your code, student name and ID,

and any outstanding issues (i.e. bugs, things that were not sufficiently completed or other notes ) I will be

looking for the Readme.txt file when marking so do not skip it.

I give quite a few marks for the quality, formatting, commenting and general quality of the code. Don't skip this.

Phase 4 (Optional):

I will give you some bonus marks if you go above and beyond the given scope or adding extra features. You should

make sure the rest of the assignment is done first though as the bonus marks will be minor compared to the rest of

the assignment marks. Make sure your new additions DON'T break any of the functionality asked for in the

assignment document. For example having pawns have the additional space they can move on the first turn, detecting

a "check" (not mate) state, showing a graphic when you win/lose or allowing the pawn to change into a different

piece upon reaching the other side (similar to checkers) would all be good chess rules that we are currently leaving

out.





Page 5 of 5


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

python代写
微信客服:codinghelp