cs193p – Assignment #3 Extra Task #2

Please note, this blog entry is from a previous course. You might want to check out the current one.

Add another tab to track the user’s high scores. You will want to use NSUserDefaults to store the high scores permanently. The tab might want to show information like the time the game was played and the game’s duration. It must also be clear which scores were Playing Card matching games and which scores were Set card matching games. Use attributes to highlight certain information (shortest game, highest score, etc.).

Let’s introduce a new model – which we actually borrow from last years course – which manages game results.

Its public interface needs a class method which returns an array of all available game scores, properties to hold the start time (date), the end time (date), the duration of the game, the score, and type of the game (set or playing cards). Finally it needs two helper methods which we will use to sort the game results by score and duration.

+ (NSArray *)allGameResults; // of GameResults
@property (readonly, nonatomic) NSDate *start;
@property (readonly, nonatomic) NSDate *end;
@property (readonly, nonatomic) NSTimeInterval duration;
@property (nonatomic) int score;
@property (strong, nonatomic) NSString *gameType;
- (NSComparisonResult)compareScore:(GameResult *)result;
- (NSComparisonResult)compareDuration:(GameResult *)result;

Because the start and the end date are publicly read only its necessary to make them privately writable:

@property (readwrite, nonatomic) NSDate *start;
@property (readwrite, nonatomic) NSDate *end;

Not so for the duration, because we generate it on the fly:

- (NSTimeInterval)duration
{
    return [self.end timeIntervalSinceDate:self.start];
}

Whenever a the score changes, we save the result to the user defaults (which in user-defaults terminology is called synchronize):

- (void)setScore:(int)score
{
    _score = score;
    self.end = [NSDate date];
    [self synchronize];
}

When we generate a new result the timer will “start running”:

- (id)init
{
    self = [super init];
    if (self) {
        _start = [NSDate date];
        _end = _start;
    }
    return self;
}

Now the “most complicated” part. The results are stored in a dictionary, which uses the start time/date as key (this way no two results will have the same key). Each entry of this dictionary is a property list holding the data of the result.

When synchronizing (equals “saving”) check if we have already data stored, if not create an empty set. Set the current data, put it back into the user defaults and synchronize …

Because it would be bad style otherwise, use constants as keys:

- (void)synchronize
{
    NSMutableDictionary *mutableGameResultsFromUserDefaults = [[[NSUserDefaults standardUserDefaults] dictionaryForKey:ALL_RESULTS_KEY] mutableCopy];
    if (!mutableGameResultsFromUserDefaults)
        mutableGameResultsFromUserDefaults = [[NSMutableDictionary alloc] init];
    mutableGameResultsFromUserDefaults[[self.start description]] = [self asPropertyList];
    [[NSUserDefaults standardUserDefaults] setObject:mutableGameResultsFromUserDefaults
                                              forKey:ALL_RESULTS_KEY];
    [[NSUserDefaults standardUserDefaults] synchronize];
}

The property list is actually just another dictionary, created by a helper method:

- (id)asPropertyList
{
    return @{ START_KEY : self.start, END_KEY : self.end, SCORE_KEY : @(self.score), GAME_KEY : self.gameType };
}

When reading back all results, we use another initialization method to create each single result, based on the stored property list/dictionary:

+ (NSArray *)allGameResults
{
    NSMutableArray *allGameResults = [[NSMutableArray alloc] init];    
    for (id plist in [[[NSUserDefaults standardUserDefaults] 
      dictionaryForKey:ALL_RESULTS_KEY] allValues]) {
        GameResult *result = [[GameResult alloc] initFromPropertyList:plist];
        [allGameResults addObject:result];
    }    
    return allGameResults;
}

The convenience initialization method takes every entry of the property list and fills the result properties:

- (id)initFromPropertyList:(id)plist
{
    self = [self init];
    if (self) {
        if ([plist isKindOfClass:[NSDictionary class]]) {
            NSDictionary *resultDictionary = (NSDictionary *)plist;
            _start = resultDictionary[START_KEY];
            _end = resultDictionary[END_KEY];
            _score = [resultDictionary[SCORE_KEY] intValue];
            _gameType = resultDictionary[GAME_KEY];
            if (!_start || !_end) self = nil;
        }
    }
    return self;
}

… the sorting helper methods just compare the appropriate properties of the results object:

- (NSComparisonResult)compareScore:(GameResult *)result
{
    return [@(self.score) compare:@(result.score)];
}

- (NSComparisonResult)compareDuration:(GameResult *)result
{
    return [@(self.duration) compare:@(result.duration)];
}

The game type needs to be set by the child game-view controllers, thus the parent needs a public property to store (and use it):

@property (strong, nonatomic) NSString *gameType;

Setting this property would be best when initializing the view controller, when its loaded, etc …
But the playing-card view controller has currently only a single method … and I am lazy just set it when creating a deck:

// PlayingCardGameViewController.m
- (Deck *)createDeck
{
    self.gameType = @"Playing Cards";
    ...
}

// SetCardGameViewController.m
- (Deck *)createDeck
{
    self.gameType = @"Set Cards";
    ...
}

The parent class needs a new property to hold the game result, which when instantiated lazily sets also the game type set by its child classes:

#import "GameResult.h"
...
@property (strong, nonatomic) GameResult *gameResult;
...
- (GameResult *)gameResult
{
    if (!_gameResult) _gameResult = [[GameResult alloc] init];
    _gameResult.gameType = self.gameType;
    return _gameResult;
}

Change the score of the game results when the user interface gets updated:

- (void)updateUI
{
    ...
    self.scoreLabel.text = [NSString stringWithFormat:@"Score: %d", self.game.score];
    self.gameResult.score = self.game.score;
    ...
}

… and reset the results, when a new deck is dealt:

- (IBAction)touchDealButton:(UIButton *)sender {
    ...
    self.gameResult = nil;
    ...
}

In storyboard add another view controller, link it to the tab-bar controller, name it and add an appropriate icon, and add a new text view:

Create a new view-controller class (note you might to use a better naming convention than I did to be more constant with the model) and link it to the new view controller previously created in storyboard.

Create an outlet for the text view, and an array to hold the game results (as model for this MVC):

#import "GameResult.h"
...
@property (weak, nonatomic) IBOutlet UITextView *scoresTextView;
@property (strong, nonatomic) NSArray *scores;

When a view will appear on screen (actually when the tab of the view controller gets selected), load all current game results and update the user interface:

- (void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];
    self.scores = [GameResult allGameResults];
    [self updateUI];
}

First create strings from all game results (we use a helper method for that) and use the final text to populate the text view. Then sort the game results using the helper method from the model and colorize the first and last result (which should be the highest and lowest score as well as the shortest and longest game) … the actual colorization is done using another helper method:

- (void)updateUI
{
    NSString *text = @"";
    for (GameResult *result in self.scores) {
        text = [text stringByAppendingString:[self stringFromResult:result]];
    }
    self.scoresTextView.text = text;    
    NSArray *sortedScores = [self.scores sortedArrayUsingSelector:@selector(compareScore:)];
    [self changeScore:[sortedScores firstObject] toColor:[UIColor redColor]];
    [self changeScore:[sortedScores lastObject] toColor:[UIColor greenColor]];
    sortedScores = [self.scores sortedArrayUsingSelector:@selector(compareDuration:)];
    [self changeScore:[sortedScores firstObject] toColor:[UIColor purpleColor]];
    [self changeScore:[sortedScores lastObject] toColor:[UIColor blueColor]];    
}

To create a string from a result it is not only necessary to define a format of where which property should appear, but also to format the dates to be readable:

- (NSString *)stringFromResult:(GameResult *)result
{
    return [NSString stringWithFormat:@"%@: %d, (%@, %gs)\n",
            result.gameType,
            result.score,
            [NSDateFormatter localizedStringFromDate:result.end
                                           dateStyle:NSDateFormatterShortStyle
                                           timeStyle:NSDateFormatterShortStyle],
            round(result.duration)];
}

For the colorization find the string of the result in the text view and change its color attribute:

- (void)changeScore:(GameResult *)result toColor:(UIColor *)color
{
    NSRange range = [self.scoresTextView.text rangeOfString:[self stringFromResult:result]];
    [self.scoresTextView.textStorage addAttribute:NSForegroundColorAttributeName
                                            value:color
                                            range:range];
}

The complete code is available on github.