联系方式

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

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

日期:2021-02-01 10:44

Informatics 1: Object Oriented Programming

Assignment 1 - Connect Four

Overview

This assignment is about practising the programming concepts taught during the first few weeks of

the course. To hone and demonstrate your skills, you will complete a series of steps to implement

the board game Connect Four (https://en.wikipedia.org/wiki/Connect_Four) in Java. A basic

program structure is provided in the form of incomplete Java classes. The following three sections

describe the features you need to implement for a basic, intermediate and advanced solution. Your

submission will be accompanied by a short technical report in which you describe how your

program works and explain the reasons behind the design decisions you made.

Step 1: Creating a new project with the provided code

? Create a new project called “ConnectFour-<UUN>” in IntelliJ (or your preferred IDE).

? Download the provided code (srcAssignment1.zip) from LEARN.

? Unpack the .java files into the src folder of your project e.g.: ConnectFour-s1234567/src/

Please do not put the code into a package such as: ConnectFour-s1234567/src/main/

Step 2: Familiarise yourself with the provided code

? Study the provided code to get an idea of how the classes fit together. You will not have to

change ConnectFour.java or InputUtil.java. They are there for your convenience, but you will

need to understand how to use them.

? Pay particular attention to which class references an instance of which other class. This, together

with the comments in the provided code, will help you understand the intended flow of control.

? Start forming a plan for how to fill in the missing parts of the program. You can revise this as

you go, but having a high-level plan for how different parts fit together will lead to a cleaner

design with less restructuring and debugging required.

Marks will be awarded out of 100 and count for 20% of your overall grade for Inf1B. Each 20 credit

course is designed to involve around 200 hours of work. Of those, 10 hours have been allotted for

this assignment. Completion time may vary depending on your level of experience and the grade

you are aiming for. While you are encouraged to aim high, attempting the more difficult features is

not a requirement and grades in the upper bands are expected to be rare. Details on marking criteria

can be found in the eponymous section below.

Basic requirements

This section describes the features needed for a basic implementation of Connect Four. The

suggested sequence of steps is intended to guide you towards a solution. A decent attempt will allow

you to pass, without attempting any of the intermediate or advanced features.

Step 3: Model the state of the game

Think about how to represent the state of the board (use the default size of 6 rows and 7 columns)

and whose turn it is. Then add the appropriate fields to Model.java and initialise the variables to

represent the initial state of the game (an empty board, player 1 goes first).

Step 4: Display the board

Open TextView.java and complete the displayBoard method. Think about how you want to display

the pieces belonging to the different players and make sure the board is printed the correct way up.

You should already be able to run the program to check the output.

Step 5: Allow pieces to be played

Implement the makeMove method in Model.java. The provided code already calls this, so you

should see a piece being inserted into column number 1. Make sure the piece is inserted in the

correct position.

Step 6: Implement the game loop

Go to Controller.java and use methods provided by the view and the model to implement the flow of

the game. There is some code here that hints at how the model and view should communicate. You

will need to rearrange and add to this until the two players and take turns to play their pieces. The

model must be updated after every move and the new state of the board must be printed out.

Step 7: Game over

The game should end either when the board is full or when either of the players concedes. Think

about different ways of handling input to allow a player to give up. Detecting the winner is an

intermediate feature.

Step 8: Complete any missing features

Make sure user the user knows whose turn it is and add any missing features to tidy up the game.

Test it and make sure you catch some of the invalid inputs that can crash the game.

Step 9: Write a short report (important!)

Explain your solution and design decisions in a short report covering the following aspects:

? Give a brief, top-level description of the program’s major components and how they fit together.

? How did you represent the board and why did you choose that representation?

? How does the program keep track of which player goes next and how are players represented?

? How did you test and debug your application?

? Which problems did you encounter and how did you solve them?

? Are there any remaining issues? If so, do you have any ideas about how they could be solved?

Intermediate features

Once you are satisfied that you have all basic features working, you can enhance your program by

adding the functionality described here. This will allow you to obtain a mark of up to 69%.

Allow the user to start a new game (easy)

When the current game is over, ask the user(s) if they wish to play again. You will have to reset the

game state and wipe the board.

Variable game settings (moderate)

At the start of a new game, you can enter the desired dimensions of the board (number of rows and

columns). You should also be able to choose how many pieces you have to get in a row to win the

game, so you can play Connect X. Make sure the game can be won.

Enhanced input validation (moderate)

Now that the game settings are variable, you will have to be very careful when validating user

input. It should not be possible to crash the game or make invalid moves.

Automatic win detection (moderate-hard)

Write code to detect when the game is won and declare the winning player.

Report

State which of the intermediate features you have implemented in a separate section of your report.

Then proceed to explaining your design. Describe any difficulties you encountered (whether you

overcame them or not). If there are remaining issues, give some ideas for how they may be fixed.

Advanced features

Possible enhancements are described here. These are only required for a distinction. You may tackle

any, all or suggest your own (provided the complexity is on par with the suggested tasks). Your

report must clearly state which extensions you have attempted and briefly explain your approach

(again use a separate section). A partial solution will give you some credit. In particular, you can

gain credit by explaining any problems or limitations. Ideas for how to fix remaining issues should

also be noted even if you do not have time to implement them.

Play against the computer (variable difficulty)

Implement an NPC (non-player character) that the user can choose to play against (human vs

human must still be possible). This task can be as hard as you like. Start with a simple policy by

which the computer makes arbitrary or random (but valid!) moves. For an improved AI you could:

? Always select a winning move if there is one

? Avoid making moves that allow the opponent to win on their next turn (if possible)

? ...

Save and load the game (hard)

Implement a mechanism by which you can write the state of the game to a file. This file can be

loaded at a later stage to resume the game where you left off.

Research a design pattern

The provided code is based on a design pattern known as Model-View-Controller (MVC). Read up

on this (or another pattern) and include a short summary of it in your report. This should explain

how the pattern is used and what it is good for. The following link is a possible starting point for

your research: https://www.tutorialspoint.com/design_pattern/mvc_pattern.htm

Restrictions

To demonstrate that you can apply the concepts you were taught, your implementation is restricted

to using the basic features of the Java programming language. More specifically, the following rules

are to be observed:

? Do not use any functional language constructs such as lambdas or streams.

? Do not use any collection classes such as lists or maps.

? Do not use any third party libraries.

? Keep all classes in the default package, i.e. no package. This makes marking a lot easier.

You are permitted to use the Java API (with the exception of data structures) and indeed, it is good

practice to reuse existing code rather than reinventing the wheel. It is, however, unlikely you will

need to do so for this assignment unless you attempt advanced features.

Please note that attempting the more difficult features only removes grade capping. It does not

guarantee you a mark in the corresponding range. You still need to fulfil all requirements for the

lower categories. The quality of your code and report are also very important. Specifically, the

following criteria will be taken into account:

? Structure

? A good design should split the task in more manageable chunks (think divide and conquer)

e.g. by a meaningful division of the code into classes (the provided code already does this).

? Modularity and reusability: Classes and methods perform well defined tasks. They can be

seen as building blocks for solving many different problems, not just the task at hand. Long

methods are a symptom of a too problem-specific design.

? Extensibility: New features can be added without redesigning the whole program.

? Robustness

? The program is able to handle errors and invalid/unexpected inputs without crashing.

? Correct use of access level modifiers (public/private) and static to restrict exposure.

? Technical/language proficiency

? Use the appropriate features of your programming language. This means not restricting

yourself to building everything using a few keywords when there is a more elegant solution.

It also means not using a needlessly complex mechanism for solving a simple task.

? Readability (self-documenting code)

? Use descriptive but concise names for variables, methods and classes.

? Class names start with a capital letter, method and variable names with a lower case letter.

? AllNamesAreWrittenInCamelCase

? Exception: Static constants are written in SHOUT_CASE.

? Commenting

? Quantity: Comments should be used where they are useful and nowhere else. Comment as

much as you feel is needed for someone else to be able to understand your code – or to make

sure you yourself can understand it when you come back to it a year later. Do not clutter

really simple bits of code (that are self-documenting) with needless comments.

? Quality: Comments should provide additional insight into what is happening in the code.

They should not just re-state what the code is doing.

The basic requirements correspond to the description of a pass grade (up to 49%).

Intermediate features are required to demonstrated the mastery required for a 2nd class (up to 69%).

You will need to tackle at least one extension to get a distinction (up to 100%).

Code

As a (relative) beginner, your first priority will be to write functionally correct code. However, to

prevent bad habits from developing, you should pay attention to code quality from the very start.

The following briefly explains desirable qualities:

Documentation (i.e. your report)

Having to write a report may seem tedious, but it serves two important purposes. Documenting your

thoughts and justifying why you have chosen a particular design deepens your own understanding.

It also allows you to demonstrating knowledge and ensures that you can still get some credit for that

even if something goes wrong with your code.

Below are (some of the) qualities a good report should have. They may not all be relevant to this

assignment, but are intended to give you an idea of what is important in technical writing. Please do

not worry about your level of English. This is not a (natural) language course and as long as you can

make yourself understood, you will not lose marks.

? Content

? Answer questions directly without beating about the bush.

? Do not just write down everything you know about the topic, stick to what what was asked.

? Provide an insight into your decision making. Your code shows what you did, your report

should explain why you did it. For example, explain why you chose one design over another

e.g. by laying out the alternatives and their advantages/disadvantages.

? Structure

? Break the content down into well labelled sections.

? If you are making an argument, ensure you organise your points into a logical sequence.

? Try to make the text flow by avoiding frequent and abrupt changes of topic.

? Finish with an honest evaluation of your work.

? Writing style

? Should be clear and concise. Make the report as short as possible without cutting essential

details.

? Avoid repetition: Make your point once and make it well, but avoid re-stating it.

Please follow the following steps to submit your work:

1. Save your report as a PDF.

2. Put all .java files (including the provided ones) directly into a single folder called “src”.

It should have no sub-folders and use no packages.

3. Create a single .zip file containing your report and code folder.

4. For instructions on uploading the .zip file, see the Assignment 1 folder on the LEARN page.

Resubmission

You can submit more than once up until the submission deadline. Your last submission before the

deadline will be marked. Once the deadline has passed you can no longer change your submission.


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