CPSC 170 Program 1: Solitaire Scrabble

Overview

In this assignment you will write a simple version of single-user Scrabble. Your program should let the user set the hand size, then show the user a 15x15 Scrabble board with numbered rows and columns and some symbol to indicate that all spaces are empty. Then show the user their hand, and ask them what word they want to play, where they want to play it, and in what direction. Display the updated board, then show the user what tiles they have left, refill their hand with new tiles, and show them their new hand. Repeat until the user asks to quit. For example, the first couple of rounds might look like this:

************ Welcome to Scrabble!! *****************

How many tiles would you like in a hand? 7

   1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 
1  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
2  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
3  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
4  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
5  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
6  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
7  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
8  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
9  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
10 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
11 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
12 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
13 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
14 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
15 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  

Your hand: A  G  H  Q  R  S  W  

Enter word: RAG
Enter row: 3
Enter col: 8
Enter (d)own or (a)cross: d

   1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 
1  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
2  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
3  *  *  *  *  *  *  *  R  *  *  *  *  *  *  *  
4  *  *  *  *  *  *  *  A  *  *  *  *  *  *  *  
5  *  *  *  *  *  *  *  G  *  *  *  *  *  *  *  
6  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
7  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
8  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
9  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
10 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
11 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
12 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
13 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
14 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
15 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  

Remaining tiles:  H  Q  S  W
New hand: D  E  H  Q  S  T  W

Keep playing? (y/n) y

Enter word: HEAD
Enter row: 4
Enter col: 6
Enter (d)own or (a)cross: a

   1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 
1  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
2  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
3  *  *  *  *  *  *  *  R  *  *  *  *  *  *  *  
4  *  *  *  *  *  H  E  A  D  *  *  *  *  *  *  
5  *  *  *  *  *  *  *  G  *  *  *  *  *  *  *  
6  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
7  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
8  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
9  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
10 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
11 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
12 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
13 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
14 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  
15 *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  

Remaining tiles:  Q  S  T  W
New hand: B  D  Q  S  T  V  W

Keep playing? (y/n) n
Bye!

Some important notes:

Your board numbering can be 0-based or 1-based, as you wish, but the row and column the user enters should correspond to the numbering shown.
The tiles should be kept sorted in the hand.
You do not need to do any error checking on the user's plays. In particular, you may assume that:
- the user actually has the letters in the words they play
- the words will fit on the board
- the words link in correctly to words already on the board
If the program runs out of tiles, it should simply stop refilling the hand.

Program Structure

This program is not difficult, but it will take some careful organization. I strongly recommend that you structure your program around the following four classes:

Tiles -- represents the pool of tiles that the hand is drawn from. I will provide this class for you.
- public char deal() -- returns a randomly chosen tile from the pool. If the pool is empty, returns a blank (' ').
For you Scrabble purists, the traditional letter frequency of the pool of tiles is used:
```
A B C D E  F G H I J K L M N O P Q R S T U V W X Y Z
9 2 2 4 12 2 3 2 9 1 1 4 2 6 8 2 1 6 4 6 4 2 2 1 2 1 
```
Hand -- represents the user's hand
- public Hand(int size) -- creates a hand of size tiles.
- public void remove(char c) -- removes tile c from the hand. If c is not in the hand, does nothing.
- public void fill(Tiles tiles) -- takes the tiles and fills (or refills) the hand to its maximum size. I found it useful to have this method call a private method add (char c) that adds a single tile.
- public String toString() -- returns a string containing the tiles in the hand.
Board -- represents the Scrabble board
- public Board() -- creates a 15x15 board and makes every space empty.
- public void print() -- prints the board, nicely formatted. A toString method could be provided instead.
- public void addWord(String word, Hand hand, int row, int col, char direction) -- adds word to the board at the given row, col and direction, and removes the corresponding tiles from the hand. Note that if the word is linking into one or more words already on the board, the existing letters are not removed from the hand.
Scrabble -- creates Board, Hand and Tiles objects and plays the game, asking the user for input until they quit.

Good Advice

START EARLY!! Be sure to leave time to come to me for help.
Write a piece at a time, then test it thoroughly before you move on. For example, you might proceed in the following order:
1. Write the constructor and print method of the Board class. Test it!
2. Write the constructor and fill method of the Hand class. Test it!
3. Write a simple addWord method of the Board class, but don't take the tiles out of the hand -- just put the word on the board.
4. Now write the Scrabble class. Since you're not taking tiles out yet the user will have the same hand on every round, but you'll be able to test adding words across and down.
5. Now write the remove method of the Hand class, and make addWord call it as appropriate.