IFN563 Project Specification

Final design report and implementation
Weight: 30% (single submission)
Due: Friday in Week 6 (28 August 2020)


Overview

This assessment is individual work and all tasks are to be submitted via Blackboard. While
you can discuss the assessment with your tutors and peers, your submissions must be your
own original work.

The objective of this assessment is to gain practical experience with object-oriented software
development through object modelling with design diagrams and applying standard software
design principles and patterns. This understanding is to be demonstrated by creating and
documenting an object-oriented design and implement it using C# for a larger real-world
motivated problem.

Description

You are to provide a reusable framework for two-player board games. To demonstrate that
your framework can be easily adapted to different games, your design must accommodate all
the following games in the same software:
● Gomoku aka Five in a Row. 15x15 board (you can use a smaller board if that helps UI), the
first player forms an unbroken chain of five pieces horizontally, vertically, or diagonally.
● Reversi aka Othello. 8x8 board, the winner makes pieces of their colour constitute a
majority of the pieces on the board at the end of the game.
● Nine Men’s Morris aka Mills. 24-intersections board, the first player leaves the opponent
with fewer than three pieces or no legal moves. To demonstrate the feasibility and
effectiveness of the design, you must implement one of the above games using C# that
corresponds to your design.

Requirements

Your design should extract as much commonality as possible from the different games so that
the framework is extensible and reusable for different games.

Your design should cater for different modes of play, including:
● Human vs Human
● Computer vs Human
With human players, the system must check the validity of moves as they are entered.

With computer play, the user should be able to select amongst a range of possible strategies
and/or levels of difficulty. You should implement at least the following two strategies:
● Random selection of a legal move
● Simple rules without thinking ahead
The only thing the computer is concerned with is the present game state, without thinking any
number of moves ahead. Thus, the computer will go for the currently best move (e.g.
capturing most pieces, or avoid being captured, etc.) without thinking about the consequences
in future moves. This algorithm is game-specific and requires appropriate board scoring
functions, which you should invent and experiment with.

Games should be able to be saved and restored from any state of play. Moves should be
undoable and redoable. A game should be replayable from any position. This requirement
applies to saved games as well (so the history of moves rather than just the current board state
needs to be saved).

You should provide at least a primitive online help system to assist users with the available
commands.


Comments on requirements

The requirements are what you should aim to achieve in your project. Even if you are not
able to implement all features, you should at least cover all requirements in your design.

Some requirements may be vague and open to interpretation. As long as you clearly state any
assumptions you make in your design report, we will accept reasonable interpretations.

The important aspect is that your design for the core structure and functionality of the two-
player board game meets the requirements, in a clear and easily understandable way. You
should steer your design towards a general framework and consider your implementation as a
proof-of-concept of your design, rather than a fully featured, highly intelligent gameplaying
program. Be sure that your implementation must correspond to your design.

Your implementation must be in C# and provide a 2D display (i.e. using either ASCII or
Unicode on a command-line interface) of the game as it is played. Some marks have been
allocated for usability, so be sure that whatever interface you use, the commands are simple
and clear. The screenshot on the left shows a simple example of playing a game of Tic-tactoe
by two human players, displayed in Unicode.





Final design report and implementation(total weight: 30%)


You should only submit one PDF document with no more than 10 pages in length (A4 page
size with 2cm in margins on all sides; 12-point Times New Roman or 11-point Arial font or
something equivalent, and in single space).

Your design report should include:
● a statement of completion (half page), clearly declaring the requirements that have and
haven’t been implemented. This declaration must be complete and accurate, in order to
receive marks for the “Fulfilment of requirements” in the marking criteria.
● an overview of your final design (one page). You should provide a summary of changes
from the preliminary design including both what and why changes were made.
● detailed design documents (at most four pages), including a class diagram, two object
diagrams and two sequence diagrams. You don’t need to provide CRC cards, because they
should be reflected in your class diagram.
● identification and brief justification of design principles and patterns that have been used
(one or two pages). For each design pattern, you should indicate the participating classes (in
design diagrams) and justify its use in your design with a few sentences.
● a brief document on how your program can be executed (at most one page).
● a short summary of classes/interfaces (one page) to be reused from existing libraries and
frameworks. For example, if you use the Collections library, just list the classes you will use,
without any further explanation.

In this project, you will be marked for the simplicity and elegance of design. It is in your best
interest to make your design as neat, clear and understandable as possible. In general, your
detailed design should speak for itself. Only include explanations of your design where your
intentions may not be clear, but this should mostly be covered by the use and justification of
design principles and patterns as requested above.

Implementation source code

You must submit a working implementation including full C# source code. You should zip
all your project files and upload this ZIP file onto IFN563 Blackboard website.

Your class implementations must be strictly faithful to the documented class designs in
your final design report. You do not need to provide a user guide or tutorial, but in your
design report you must clearly document how your program can be executed. The submitted
project files will be compiled and executed from Microsoft Visual Studio installed on QUT
computers. You must make sure that your submitted code can be compiled and run properly
from QUT computer labs (Microsoft Visual Studio 2019 with .NET Core). Uncompilable
or inexecutable source code cannot be marked and will receive zero for
implementation. Plagiarism undermines academic integrity and is not tolerated at QUT.
All submissions may be scanned for code plagiarism against online code repositories.