Homework Assignment: Sudoku Board

Transcription

1 Homework Assignment: Sudoku Board Back Overview of the project This assignment is part of a larger project to create a Sudoku application. Assignment: Sudoku Board Assignment: Sudoku Model Assignment: Sudoku View Assignment: Sudoku Controller and Integration Assignment: Sudoku Serialization (make up assignment) This will take us about a month to complete. Here is a description of the functionality for the whole project. Objectives Working with Java graphic components and containers Abstraction Design considerations Instructions Download the starting point code, SudokuBase.java. Since this is in a named package, make sure that the directory structure for this package has been created. Remember, the JVM will no be able to find the class if the directory structure is incorrect. Here are some notes about this class: The constructor takes the layout dimensions for a Sudoku board. It stores the dimensions in private final variables: rows, columns, size. There are public accessor (getter methods) for these variables. There are some aspects of the code that we have not discussed yet, as examples: the superclass, java.util.observable and the enum type State. Don't panic! We'll be discussing java.util.observable later in the quarter. For this assignment, you can simply ignore the superclass. That is, it would make no difference to your work if the superclass was java.lang.object. An enum, like State, is a new type (like a new primitive type, almost) with the potential values given within the curly braces. There is a simple example of using the enum type in SudokuStub. There are a number of abstract methods which will support basic functionality in the class. We won't need them right now. However, you'll be filling in several of these as part of the work for next week's assignment. Here is a stubbed out subclass that is not abstract, SudokuStub.java. Note the way that the return values were specified for getrowstate, getcolumnstate, and getregionstate. They use the values from the State enum type. Those values are in the scope of the State type (declared within that type), so the s16/hw sudoku_layout.html 1/11

2 Your tasks: names of the values include the type name State. Complete the SudokuBoard.java class. This class draws the basic board for the Sudoku game, indicating the individual cells and the regions. (The rows and columns don't need any specific indication, being obvious if the layout is good.) Add comments to SudokuBase. This includes documentation support, JavaDoc comments. There should be no substantive code changes to SudokuBase; you are only adding comments. This is to insure that you understand the basic functionality you are working with. Implement the SelectedCell.java interface. This interface supports having an "active" cell in the Sudoku Board. Minimal Version SudokuBoard The primary task for this assignment is creating an object that will display the Sudoku board. This display shall render the cells in a square grid. The different regions of the board shall be indicated by a difference in background color. This is a common way to differentiate the regions, as seen in the Background section of the project overview. Use Color.white and Gainsboro for the different region backgrounds. Gainsboro is one of the named colors for web programming. It is #DCDCDC, or rgb(220, 220, 220). The constructor for SudokuBoard takes a SudokuBase as a parameter. From the SudokuBase object, the size and arrangement of the cells and regions can be determined using the public methods getrows and getcolumns. Of course, you can also use the getsize method. The SudokuBoard constructor shall set the preferred size of the SudokuBoard component based on the size of the board. The cell sizes are specified below. To simplify the display, fix the size of the individual cells to 50x50. Drawing borders around the cells will help make the rows and columns easy to see. For example, if there is a one pixel wide border one pixel in from the edge of the cells, the edges are clean. (The alternation of two pixel wide borders between cells and one pixel wide borders at the edges occurs when cell borders abut. This is unattractive.) Notice that this means that there is a two pixel wide margin between the cells. The board can be completed by drawing another line around the entire board such that there is a two pixel wide border at the edges as well. Here is an example of the 2x3 board with these specifications, and a detail view of the upper right corner of the board. s16/hw sudoku_layout.html 2/11

3 Standard Version SelectedCell The SudokuBoard class shall have methods that will get and set the location of the selected cell. The selected cell will be the currently "active" cell. In a later revision of the assignment, the selected cell indicate the cell whose value is to be changed. Indicate the selected cell by a change in the background color of the selected cell. Use a high contrast color. Yellow is a good choice. To support the selected cell, SudokuBoard shall implement the SelectedCell interface. package csc143.sudoku; public interface SelectedCell { public void setselected(int row, int col); s16/hw sudoku_layout.html 3/11

4 } public int getselectedrow(); public int getselectedcolumn(); As you can see, the selected cell can be set programmatically. Also, clicking on a cell shall select that cell. There shall be at most one selected cell within a SudokuBoard. So, when a cell is selected, any previously selected cell is no longer selected. Note: setselected shall perform input validation. If either the row or col parameter contains an unacceptable value, throw an IllegalArgumentException. Challenge Version The challenge version has two facets: keyboard support for changing the selected cell the algorithm to change between two descriptions of a cells location: row/column and region/ordinal Keyboard Support Notes You will need to make the SudokuBoard able to receive focus to get this to work. (What is focus?) If the requested move would move the selected cell past the boundary of the view, sound the system beep instead of moving the selected cell. There is a method java.awt.toolkit.beep that will cause the system beep to sound. Notice that you can request a copy of the toolkit from any graphic object. For more information, see the documentation for java.awt.component. Coordinate Transform There are many different ways to describe the location of a cell within the board. The obvious ones use coordinates. Probably the most obvious is the row and column numbers. Another reasonable choice is the region number and ordinal locator (first, second, third, within the region). Here is a graphic showing these two coordinate schemes for a 2x3 SudokuBoard, row/column in blue, region/ordinal in red. Implement the CoordinateTransform interface in a package private class named s16/hw sudoku_layout.html 4/11

5 csc143.sudoku.translatecoordinates which is included within the SudokuBoard.java file. This class will need to have a constructor; obviously it is not specified in the interface. Testing code Here is some testing code that you can use. SudokuBoardTest.java creates seven standard Sudoku layouts to check your SudokuBoard component. Notice that the testing code is not in the same package as the code it's testing. This is typical. The testing code is not part of that package, that abstraction. It's utility code that helps with the development. For this testing code, we used a simple scheme of adding.test. into the package name. Here are images created by SudokuBoardTest, if SelectedCell is not implemented: s16/hw sudoku_layout.html 5/11

6 s16/hw sudoku_layout.html 6/11

7 s16/hw sudoku_layout.html 7/11

8 s16/hw sudoku_layout.html 8/11

9 s16/hw sudoku_layout.html 9/11

10 Now, if SelectedCell is implemented, the SudokuBoardTest behaves a bit differently. Here is a video showing the behavior of SudokuBoardTest if SelectedCell is implemented. Report At the end of the Sudoku project, you will write a report in which you describe: how you went about starting this project the design decisions you made what works and what doesn t the surprises or problems you encountered while implementing this application the most important thing(s) you learned from this portion of the assignment what you would do differently next time The design decisions for the second question should include the rationale for such things as: creating a field (why it can't be a local variable), giving a field an access level other than private (why it is directly shared rather than having set and get methods), giving a method an access level other than public or private (why the intermediate access level), essentially, anything that isn't typical "best practices" in programming. The last question, "What would you do differently next time?" is asking about the general principles of software design, implementation, and testing that you learned in the process. It is not asking for specific aspects of this particular project that you would approach differently. The reason for this question is because the theorists say that one of the primary ways we learn is when we reflect upon our experiences. The homework for this class should be a learning experience. Since this is a larger project, it is imperative that you have some notes about this early work. For this part of the assignment, submit your notes for this part of the project. The goal is to have something that you can use to write the written report at the end of the project. Deliverable for the report notes: ASCII text file containing notes. s16/hw sudoku_layout.html 10/11

11 Deliverables Three files: The updated SudokuBoard.java. The updated SudokuBase.java files. JavaDoc comments added. A text file with the notes for the report. (plus algorithm for Challenge level) Note, when you submit the two source code files, these classes are still in the csc143.sudoku package. Do not submit an archive file format, e.g..jar,.zip,.rar, etc. Grading Rubric Functionality: (8 points) Minimal: 5 points SudokuBoard compiles and runs with SudokuBoardTest generates board of the appropriate dimensions appropriate region is arrangement for SudokuBoard Standard: 3 additional points implementation for SelectedCell selected cell displays with a highlight background color selected cell can be set programmatically selected cell can be set by mouse Challenge: 2 additional points algorithm is provided to translate cell coordinates between row columns and region ordinal implemented in SudokuBoard selected cell can be set by keyboard Style: (2 points) Appropriate formatting (vertical alignment, indentation, uniform brace placement) Reasonable naming Documentation: (5 points) JavaDoc comments for public/protected resources with appropriate tags Standard comments (// or /* */) for private or package private resources JavaDoc runs without warnings ASCII text file for report, with appropriate header giving your name and this assignment name and number Reasonable information is included in the report notes Back s16/hw sudoku_layout.html 11/11