CSE 332 Lab 4: Scrabble Solitaire

Lab dates: Wednesday October 21, Wednesday October 28, and Wednesday November 4, 2009
Due by Friday November 13 at 11:59 pm (note new deadline)
Final grade percentage: 10 percent

Objective:

In the next (and final) lab assignment for the course you will build on these features to allow a user to play a multi-player version of the game, with other live and/or artificial players.

Assignment:

Part I - Readings:

1. The following readings in the optional text books and reference web pages may be useful as reference material while working on this lab assignment.
   • STL pair: Deitel 6th Edition pp. 1088, 1103, 1202; Deitel 7th Edition pp. 946-947
   • STL map: Prata pp. 1095-1102; Deitel 6th Edition pp. 1092-1094; Deitel 7th Edition pp. 950-952
   • C++ classes: Prata pp. 355-358, 445-499, 515-517; Deitel 6th Edition pp. 81-117, 487-557; Deitel 7th Edition pp. 68-102, 395-423, 430-453
   • STL find algorithm: Prata pp. 1103-1104; Deitel 6th Ed. pp. 1071, 1112-1114; Deitel 7th Ed. pp. 929, 970-971; http://www.cppreference.com/wiki/stl/algorithm/find

   • STL http://www.cppreference.com/wiki/stl/algorithm/random_shuffle algorithm: Prata pp. 885-889, 1109, 1114; Deitel 6th Ed. pp. 1071, 1109, 1111; Deitel 7th Ed. pp. 929, 967, 969; http://www.cppreference.com/wiki/stl/algorithm/random_shuffle

   • STL next_permutation algorithm: Prata pp. 933-934, 1116, 1125-1126; Deitel 6th Ed. pp. 1129; Deitel 7th Ed. pp. 986; http://www.cppreference.com/wiki/stl/algorithm/next_permutation

2. The constructor, destructor, operator, accessor, and mutator method examples in the C++ classes lecture slides give an overview of class syntax and structure you may need for this lab.

3. The STL algorithm examples in the C++ C++ functions, classes, and templates lecture slides also may be helpful when implementing parts this lab.

4. Please read the following CSE 332 Programming Guidelines which relevant to the previous labs and please follow them as you implement your solution: A.1-A.17, B.1-B.7, B.9-B.13, B.15, B.16, B.18, B.20-B.23, B.25, B.30, B.33, B.34, C.1-C.9.

   Part II - Program Design and Implementation:

   Note: the details of this assignment are again intentionally somewhat under-specified, leaving you some room to choose what you think is the best way to implement them, as long as what you do is reasonable and you explain your design decisions in comments in the code and in your Readme.txt file.

5. Open up Visual Studio, and create a new Win32 Console Application Visual C++ project for lab 4.
6. Please modify your code from lab 3 that reads in lines from the dictionary file so that it ignores any lines that begin with a //, like the first two lines of the following sorted_dictionary_example.txt file.
7. If you have not done so already in lab 3, please modify your word collection class so that it generates all permutations of all lengths (not just the ones of the same length as the original) that can be created from the letter tiles in the given letter tile collection object, and stores exactly one copy of any that are found in the given dictionary object.

8. Declare an enumerated type for the direction that sequence of letter tiles can be played, that can have either of two values: vertical or horizontal.

9. Declare and define a class to represent a GameBoard with a private member variable that represents a 15 by 15 grid of squares, where each square can have 0 or 1 letter tiles associated with it, and the squares are indexed in the vertical and horizontal dimensions with (0,0) denoting the center of the board, (-7,-7) denoting the bottom left corner of the board, (-7,7) denoting the top left corner of the board, (7,7) denoting the top right corner of the board, and (7,-7) denoting the bottom right corner of the board.

   How you implement the member variable is up to you, but one idea is to use an STL container whose key type is an STL pair of integers and whose data type is a pointer to a letter tile (so that empty squares can be denoted by the pointer being 0), e.g., of type map<pair<int,int>,LetterTile*> >.

   The public interface for this class should be:

   • A default constructor in which the member variable is initialized to have all empty squares;

   • A destructor that if necessary releases dynamically allocated memory and performs other cleanup tasks (if the compiler-supplied destructor is sufficient then you may use it rather than declaring/defining your own, but if you do please put a comment in the class declaration explaining why that is ok to do.

   • A const "print" method that takes a reference to an ostream (that is defaulted to being a reference to cout if no parameter is provided when the method is called) and prints out a 2-dimensional text representation of the board's contents, using spaces for empty squares and the letters of the letter tiles in non-empty squares. For example, one reasonable representation could look like:
     
      765432101234567
7               7
6               6
5               5
4               4
3          SAY  3
2           L   2
1        WOULD  1
0    HELLO      0
1       ARE     1
2        L      2
3        D      3
4               4
5               5
6               6
7               7
 765432101234567


   • A play method that takes a reference to a const dictionary object (as defined in the previous lab assignment), a reference to a const letter tile collection object, a pair of integers representing the starting position from which to play the tiles, and a variable of the enumerated direction type; plays the sequence of tiles on the board according to those inputs, and returns an unsigned integer indicating the number of points the user earned for that play.

     Note that unlike the main method, the return value for this method indicates the score given for the play, so that if an error occurs the method should (after printing out an appropriate error message) return 0 to indicate no points were earned.

     The first play on an empty board must intersect with the square 0,0 and any play on a non-empty board must intersect with at least one existing tile (if not, the method should generate an error message and return 0).

     Assuming the above conditions hold, the method should check for a valid play as follows:

     • Starting at the board location that was given, the play method should concatenate the sequence of letter tiles that will occur if the play is successful. To do that, the method should check the squares of the board in the direction given: from left to right (a correction: this used to say "to the left") for horizontal, and downwards for vertical. If a square is empty, the method should concatenate a copy of the next unused tile from the sequence that was given, or if the square already has a tile in it the method should concatenate a copy of that tile.

     • For example, if the last play on the board shown for the board's print method above had been the sequence "AE" starting at position 0, -1 and proceeding horizontally, the method would have seen an empty square at position 0, -1 and played the 'A' tile there, seen the existing 'R' at position 1, -1 and used it, and seen an empty square at position 2, -1 and played the 'E' tile there, resulting in the new sequence "ARE" (and also the new perpendicular sequence "LA").

     • If the given starting position was invalid, or if the method reaches the edge of the board before all of the tiles in the given sequence were used, the play method should print out an error message and return 0.

     • Once all of the tiles in the sequence that was given have been used, the method should check that all new tile sequences resulting from the play (including any perpendicular to or containing the sequence played) are valid words in the dictionary.

     • For example, if the last play on the board shown for the board's print method above had been "ARE" then the dictionary would need to check both the new sequence "ARE" and the new perpendicular sequence "LA".

     • If any of the new sequences produced by the play are not in the dictionary, the method should generate an appropriate error message and return 0; otherwise, the method should update the board with the newly played tiles, and return the sum of the values of all of the tiles in all of the new sequences produced by the play (for "ARE" and "LA" this would be the sum of the values of the two A's, the E, the L, and the R).

10. In your project's main function:

    • Modify the signature of your main function so that it matches the one shown in the second example given in the C++ program structure and development environment lecture slides (the one that uses the variable names argc and argv).

    • Make sure your main program checks the command line arguments and requires (but accepts in either order) a "-D" or "-d" followed by the name of a dictionary file and a "-T" or "-t" followed by the name of a tile definitions file.

    • As in the previous lab, your program should check whether or not it can open the dictionary file for reading (using an ifstream) and if not it should generate an error message and return a non-zero failure code. Otherwise it should try to open the tile definition file for reading (using an ifstream). If it cannot open the tile definition file for reading it should try to open it for writing (using an ofstream) and output tile definitions into it based on counting and scoring the letters in the dictionary file as you did in the previous lab.

    • As in the previous lab, your program should use the name of the dictionary file to initialize a local Dictionary object in your main function.

    • Use the name of the tile definitions file to initialize a local LetterTileCollection object in your main function. This object will again serve as a pool of tiles from which other collections can be drawn.

    • Initialize another local LetterTileCollection object in your main function, which will serve as the set of tiles used by the person playing the game (the player).

    • Default construct a local GameBoard object (the board) in your main function.

    • Declare a local unsigned integer variable to keep track of the player's score, and initialize that variable to 0.

    • Shuffle the pool object described above and then repeatedly (until the player quits):

      • Move tiles from the pool object into the player's set of tiles so that the player has 7 tiles to work with (or as many as possible if there are not enough left in the pool).

      • Print out the board and below it print the player's tiles (including the letters and their values) and the player's current score.

      • Print out (to cout) a prompt asking whether the player wants to play again and collect the user's reply (from cin). If the user does not want to play again, the program should return 0 to indicate success.

      • If the player does want to play again, the program should prompt the user for (and obtain from cin) the sequence of letters to play, the starting position at which to play the tiles for those letters, and the direction in which to play them. Using those inputs, the program should call the board's play method, add the value returned by that method to the player's score, for a successful play (indicated by the play method returning a value greater than 0) remove the played tiles from the player's collection of tiles and then replace them from the pool, and continue the game.

      • If at any point the user has not quit but the program encounters an error that will not allow it to continue, it should generate an error message and return an approprate non-zero error code.
11. Build your project, and fix any errors or warnings that occur. Please be sure to note all of the different kinds of errors or warnings you ran into (though you don't have to list every instance of each kind) in your ReadMe.txt file. If you were fortunate enough not to run into any errors or warnings, please note that instead, where you would have listed errors or warnings in your ReadMe.txt file.

12. Open up a Windows console (terminal) window and change to the directory where your program's executable file was created by Visual Studio (see the first studio exercises document for more details on this, if you don't remember them).

13. Run the executable program through a series of trials that test it with good coverage of cases involving both well formed and badly formed inputs. For this lab one especially useful test is to check whether the output printed by your program consistently represents the contents of valid dictionary and tile definition files it was given. In your ReadMe.txt file please document which cases you ran (i.e., what the command lines were) and summarize what your program did and whether that is correct behavior, in each case.

14. In your ReadMe.txt file, make sure that your name and the lab number (lab 4) are at the top of the file, and that you've documented whether you ran into any errors or warnings while developing your solution (and if so what they were) and what the executable program did for each of the trials you ran. Be sure to save your changes to your ReadMe.txt file, as well as those to your source (and header) file(s) before preparing your solution zip file.

15. Prepare a zip file that contains your project's source, header, and ReadMe.txt files (except for stdafx.h, stdafx.cpp or other Windows-generated files you did not modify), by:
    • Creating a new lab4 folder on your Windows desktop;
    • Copying the appropriate files (here, ReadMe.txt, and the source and header files where you wrote your code) from Visual Studio into that folder; and then
    • Right-clicking on the folder and selecting the Send To->Compressed (zipped) Folder item in the menu that appears.

    Send the zip file containing your lab 4 solution as an e-mail attachment to the course e-mail account (cse332@cec.wustl.edu) by the submission deadline for this assignment. If you need to make changes to your lab solution you are welcome to send a new zip file, and we will grade the latest one received prior to the deadline (according to the time stamp the server puts on the e-mail).

    Part III - Helpful hints: (optional, worth up to 5% extra credit)

    The goal of this optional part of the assignment is to have you provide an additional feature, which is to suggest another position, direction, and/or sequence of tiles that the player could try if they attempted a play that is not valid:

16. If the user tries to play a sequence with a starting position and direction that does not work, see whether any other combination of starting position and direction with that same sequence would result in a valid play.

    • (case 1) If there is another starting position and/or direction that would result in a valid play, print out a message to the user suggesting they try to play the sequence at that starting location and in that direction.

    • (case 2) If there is no valid play for the sequence given, print out a message suggesting that they try a different sequence.

17. In your readme file, please add a section clearly marked "extra credit" and in it explain how you implemented those features, and also cut and paste output from your game with it printing out the appropriate helpful hint for each of the two cases above.