Before we head over to Interface Builder to actually create our user interface, we want to declare the actions and outlets that we'll need to connect once we get there. While we're in the header file, we'll also declare the rest of the methods we'll be using, as well as some constants and enumerations to make our code easier to read.

Single-click TicTacToeViewController.h and make the following changes:

#import <UIKit/UIKit.h>
#import <GameKit/GameKit.h>

#define kTicTacToeSessionID     @"com.apress.TicTacToe.session"
#define kTicTacToeArchiveKey    @"com.apress.TicTacToe"

typedef enum GameStates {

kGameStateBeginning,
    kGameStateRollingDice,
    kGameStateMyTurn,
    kGameStateOpponentTurn,
    kGameStateInterrupted,
    kGameStateDone
} GameState;

typedef enum BoardSpaces {
    kUpperLeft = 1000, kUpperMiddle, kUpperRight,
    kMiddleLeft, kMiddleMiddle, kMiddleRight,
    kLowerLeft, kLowerMiddle, kLowerRight
} BoardSpace;

typedef enum PlayerPieces {
    kPlayerPieceUndecided,
    kPlayerPieceO,
    kPlayerPieceX
} PlayerPiece;

@class TicTacToePacket;
@interface TicTacToeViewController : UIViewController
@interface TicTacToeViewController : UIViewController <GKPeerPickerControllerDelegate,
GKSessionDelegate, UIAlertViewDelegate> {
    UIButton    *newGameButton;
    UILabel     *feedbackLabel;

    GKSession   *session;
    NSString    *peerID;

    GameState   state;

    NSInteger   myDieRoll;
    NSInteger   opponentDieRoll;

    PlayerPiece piece;
    UIImage     *xPieceImage;
    UIImage     *oPieceImage;

    BOOL        dieRollReceived;
    BOOL        dieRollAcknowledged;

}
@property(nonatomic, retain) IBOutlet UIButton *newGameButton;
@property(nonatomic, retain) IBOutlet UILabel *feedbackLabel;

@property(nonatomic, retain) GKSession    *session;
@property(nonatomic, copy)   NSString     *peerID;

@property(nonatomic, retain) UIImage *xPieceImage;
@property(nonatomic, retain) UIImage *oPieceImage;

- (IBAction)newGameButtonPressed;
- (IBAction)gameSpacePressed:(id)sender;

- (void)resetBoard;
- (void)startNewGame;
- (void)resetDieState;
- (void)sendPacket:(TicTacToePacket *)packet;
- (void)sendDieRoll;
- (void)checkForGameEnd;
@end

The first thing we need to do is import the GameKit headers so that the compiler knows about the objects and methods from GameKit:

#import <GameKit/GameKit.h>

Next, we define two constants. One will be our session identifier, which GameKit will use to make sure we connect only to devices running the same program. The other is an archiving key that we will use when packaging data to send to the other node.

#define kTicTacToeSessionID     @"com.apress.TicTacToe.session"
#define kTicTacToeArchiveKey    @"com.apress.TicTacToe"

Adding networking to even a simple application creates a fair bit of complexity, because network communications are asynchronous. You can't make any assumptions about the order that data will be received. To help us keep track of where we are, we define an enum with a bunch of different game states that identify what's going on right now in our game:

typedef enum GameStates {
    kGameStateBeginning,
    kGameStateRollingDice,
    kGameStateMyTurn,
    kGameStateOpponentTurn,
    kGameStateInterrupted,
    kGameStateDone
} GameState;

When a game has not yet begun, the state will be kGameStateBeginning. After the devices connect, or when a new game is started, the two nodes will negotiate who goes first by each generating a random number, which is equivalent to flipping a coin or rolling a die in real life. When who goes first is being negotiated, the state is kGameStateRollingDice. When it's our turn to make a move, the state will be kGameStateMyTurn, and when it's the opponent's turn, the state will be kGameStateOpponentTurn. If the connection is interrupted for any reason, we'll set the state to kGameStateInterrupted. Finally, if there are no more possible moves or a player gets three in a row, the state will move to kGameStateDone.

Next, we define another enumeration to refer to each of the spaces on the board by their tag:

typedef enum BoardSpaces {
    kUpperLeft = 1000, kUpperMiddle, kUpperRight,
    kMiddleLeft, kMiddleMiddle, kMiddleRight,
    kLowerLeft, kLowerMiddle, kLowerRight
} BoardSpace;

In tic-tac-toe, the player who goes first is O, and the other player is X. To identify who is X and who is O, we have one more enumeration:

typedef enum PlayerPieces {
    kPlayerPieceUndecided,
    kPlayerPieceO,
    kPlayerPieceX
} PlayerPiece;

After that, we tell the compiler that there is a class called TicTacToePacket. This class doesn't exist yet, but we'll write it shortly. A @class declaration doesn't cause the compiler to look for the class' header file—it's just a promise that a class really exists, so it's okay to declare it this way before actually creating or writing the class.

@class TicTacToePacket;

Our controller class needs to conform to a few protocols. Our controller will be the delegate of the peer picker, the session. We'll also be using alert views to inform the user when there's a problem, so we conform our class to the three protocols used to define the delegate methods for each of these jobs.

@interface TicTacToeViewController : UIViewController <GKPeerPickerControllerDelegate, GKSessionDelegate, UIAlertViewDelegate> {

If you look at the interface in Figures 8-1 and 8-4, you can see that there's a button for starting a game, as well as a label that's used to tell users if it's their turn, or if they've won or lost. We need instance variables for outlets to both of those:

UIButton    *newGameButton;
    UILabel     *feedbackLabel;

We also need instance variables for the GameKit session and to hold the peer identifier of the one connected node.

GKSession   *session;
    NSString    *peerID;

A moment ago, we defined an enumeration with the various game states, but we need an instance variable to keep track of the current state:

GameState   state;

Because we don't know whether we will roll the die or receive our opponent's die roll first, we need variables to hold them both. Once we have both, we can compare them and start the game:

NSInteger   myDieRoll;
    NSInteger   opponentDieRoll;

Once we know who goes first, we can store whether we're O or X in this instance variable:

PlayerPiece piece;

We'll also load both of the images representing the two game pieces when our view is loaded, and keep a reference to them in these pointers:

UIImage     *xPieceImage;

UIImage     *oPieceImage;

Finally, we have two more Booleans to keep track of whether we've received the opponent's die roll and whether our opponent has acknowledged receipt of ours. We don't want to begin the game until we have both die rolls and we know our opponent has both as well. When both of these are YES, we'll know it's time to start the actual game play:

BOOL        dieRollReceived;
    BOOL        dieRollAcknowledged;
}

Next, we define properties for our outlets, as well as some of our instance variables:

@property(nonatomic, retain) IBOutlet UIButton *newGameButton;
@property(nonatomic, retain) IBOutlet UILabel *feedbackLabel;

@property(nonatomic, retain) GKSession *session;
@property(nonatomic, copy)   NSString  *peerID;

@property(nonatomic, retain) UIImage *xPieceImage;
@property(nonatomic, retain) UIImage *oPieceImage;

And, finally, we declare our action methods and a bunch of other methods that we'll need in our game. We'll discuss the specific methods in more detail when we implement our controller later, after we design our user interface.

- (IBAction)newGameButtonPressed;
- (IBAction)gameSpacePressed:(id)sender;
- (void)resetBoard;
- (void)startNewGame;
- (void)resetDieState;
- (void)sendPacket:(TicTacToePacket *)packet;
- (void)sendDieRoll;
- (void)checkForGameEnd;
@end

Save this file.

Now, expand the Resources folder in the Groups & Files pane, if it's not already expanded, and double-click TicTacToeViewController.xib to open Interface Builder.

Once Interface Builder is open, look in the library for an Image View and drag that to the window labeled View. Because it's the first object you're adding to the view, it should resize to take up the full view. Place it so that it fills the entire view, and then press

Next, drag a Round Rect Button from the library over to the top of the view. The exact placement doesn't matter yet. After it's placed, use the attribute inspector to change the button type from Rounded Rect to Custom. In the Image field of the attribute inspector, select wood_button.png, and then press

Figure 8.10. Your interface after sizing and placing the button

Control-drag from File's Owner to the button and select the newGameButton outlet. Then Control-drag from the button back to File's Owner, and select the newGameButtonPressed action.

Look again in the library for a Label, and drag it to the view. Place the label in the top of the view so it runs from the left blue margin to the right blue margin horizontally, and from the top blue margin down to just above the tic-tac-toe board. It will overlap the button we just added, and that's okay, because the label will display text only when the button isn't visible. Use the attribute inspector to center the text, and the font palette (

Control-drag from File's Owner to the new label and select the feedbackLabel outlet.

Now, we need to add a button for each of the nine game spaces and assign them each a tag value so that our code will have a way to identify which space on the board each button represents. Drag nine Round Rect Buttons to the view, and use the attribute inspector to change their type to Custom. Use the size inspector to place them in the locations specified in Table 8-1, and use the attribute inspector to assign them the listed tag value. Here's one shortcut to consider: Create one, set its size and attributes, and then start making copies.

Once you have the buttons in place, Control-drag from each of the nine buttons to File's Owner and select the gameSpacePressed: action.

Finally, save the nib, and then quit Interface Builder.

Once you're back in Xcode, single-click the Classes folder in the Groups & Files pane, and select New File... from the File menu. Select the Objective-C class template, with NSObject selected for the Subclass of pop-up menu. We're going to create the class that will be used to send information back and forth between the two nodes, so name this file TicTacToePacket.m and make sure the Also create "TicTacToePacket.h" check box is checked.

Once the files are created, single-click TicTacToePacket.h and replace its contents with the following:

#import <Foundation/Foundation.h>
#import "TicTacToeViewController.h"

#define dieRoll() (arc4random() % 1000000)
#define kDiceNotRolled  INT_MAX

typedef enum PacketTypes {
    kPacketTypeDieRoll,         // used to determine who goes first
    kPacketTypeAck,             // used to acknowledge die roll packet receipt
    kPacketTypeMove,            // used to send information about a player's move
    kPacketTypeReset,           // used to inform the peer that we're starting over
} PacketType;

@interface TicTacToePacket : NSObject <NSCoding> {
    PacketType  type;
    NSUInteger  dieRoll;
    BoardSpace  space;
}
@property PacketType type;
@property NSUInteger dieRoll;
@property BoardSpace space;
- (id)initWithType:(PacketType)inType
    dieRoll:(NSUInteger)inDieRoll
    space:(BoardSpace)inSpace;
- (id)initDieRollPacket;
- (id)initDieRollPacketWithRoll:(NSUInteger)inDieRoll;
- (id)initMovePacketWithSpace:(BoardSpace)inSpace;
- (id)initAckPacketWithDieRoll:(NSUInteger)inDieRoll;
- (id)initResetPacket;
@end

Much of this code should be fairly intuitive. We define a macro for generating a random number to resolve who goes first. It generates a number between 0 and 999,999. We're using a large number here so that the chance of both devices rolling the same value (which would require a reroll) will be extremely low. We also define a constant that will identify when the die has not yet been rolled. Remember that we're storing both our die roll and our opponent's die roll in NSInteger instance variables. On the iPhone, NSInteger is the same as an int. We use the value INT_MAX to identify when those values have not yet been determined. INT_MAX is the largest value that an int can hold on the platform. Since the largest number our dieRoll() macro will generate is 999,999, we can safely use INT_MAX to identify when a die hasn't been rolled, because INT_MAX equals 2,147,483,647 on current iPhones. If INT_MAX ever changes, it will likely get bigger, not smaller.

#define dieRoll() (arc4random() % 1000000)
#define kDiceNotRolled  INT_MAX

We define an enum with each of the different types of packets we'll need to send to the other node:

typedef enum PacketTypes {
    kPacketTypeDieRoll,         // used to determine who goes first
    kPacketTypeAck,             // used to acknowledge die roll packet receipt
    kPacketTypeMove,            // used to send information about a player's move
    kPacketTypeReset,           // used to inform the peer that we're starting over
} PacketType;

In our class definition, we have only three instance variables: one to identify the type of packet and two others to hold information that might need to be sent as part of that packet. The only other pieces of information we ever need to send are the results of a die roll and which space on the game board a player placed an X or O. We also conform our class to the NSCoding protocol so that we can archive it into an NSData instance to send through the GameKit session:

@interface TicTacToePacket : NSObject <NSCoding> {
    PacketType  type;
    NSUInteger  dieRoll;

BoardSpace  space;
}

We expose all three instance variables using properties:

@property PacketType type;
@property NSUInteger dieRoll;
@property BoardSpace space;

And we declare a handful of init methods for creating the different types of packets we will send:

- (id)initWithType:(PacketType)inType
    dieRoll:(NSUInteger)inDieRoll
    space:(BoardSpace)inSpace;
- (id)initDieRollPacket;
- (id)initDieRollPacketWithRoll:(NSUInteger)inDieRoll;
- (id)initMovePacketWithSpace:(BoardSpace)inSpace;
- (id)initAckPacketWithDieRoll:(NSUInteger)inDieRoll;
- (id)initResetPacket;
@end

Save TicTacToePacket.h.

Next, switch over to TicTacToePacket.m and replace the contents of the file with this new version:

#import "TicTacToePacket.h"

@implementation TicTacToePacket
@synthesize type;
@synthesize dieRoll;
@synthesize space;

#pragma mark -
- (id)initWithType:(PacketType)inType dieRoll:(NSUInteger)inDieRoll space:(BoardSpace)inSpace {
   if (self = [super init]) {
       type = inType;
       dieRoll = inDieRoll;
       space = inSpace;
   }
    return self;
}

- (id)initDieRollPacket {
    int roll = dieRoll();
    return [self initWithType:kPacketTypeDieRoll dieRoll:roll space:0];
}

- (id)initDieRollPacketWithRoll:(NSUInteger)inDieRoll {
    return [self initWithType:kPacketTypeDieRoll dieRoll:inDieRoll space:0];
}

- (id)initMovePacketWithSpace:(BoardSpace)inSpace{
    return [self initWithType:kPacketTypeMove dieRoll:0 space:inSpace];
}

- (id)initAckPacketWithDieRoll:(NSUInteger)inDieRoll {

return [self initWithType:kPacketTypeAck dieRoll:inDieRoll space:0];
}

- (id)initResetPacket {
    return [self initWithType:kPacketTypeReset dieRoll:0 space:0];
}

#pragma mark -
- (NSString *)description {
    NSString *typeString = nil;
    switch (type) {
        case kPacketTypeDieRoll:
            typeString = @"Die Roll";
            break;
        case kPacketTypeMove:
            typeString = @"Move";
            break;
        case kPacketTypeAck:
            typeString = @"Ack";
            break;
        case kPacketTypeReset:
            typeString = @"Reset";
        default:
            break;
    }
    return [NSString stringWithFormat:@"%@ (dieRoll: %d / space: %d)", typeString,
        dieRoll, space];
}

#pragma mark -
#pragma mark NSCoder (Archiving)
- (void)encodeWithCoder:(NSCoder *)coder {
    [coder encodeInt:[self type] forKey:@"type"];
    [coder encodeInteger:[self dieRoll] forKey:@"dieRoll"];
    [coder encodeInt:[self space] forKey:@"space"];
}

- (id)initWithCoder:(NSCoder *)coder  {
    if (self = [super init]) {
        [self setType:[coder decodeIntForKey:@"type"]];
        [self setDieRoll:[coder decodeIntegerForKey:@"dieRoll"]];
        [self setSpace:[coder decodeIntForKey:@"space"]];
    }
    return self;
}

@end

TicTacToePacket is a fairly straightforward class. There shouldn't be anything in its implementation that you haven't seen before. Save TicTacToePacket.m. Next, we'll write our view controller and finish up our application.

Single-click TicTacToeViewController.m. There's a lot of code to write in this controller class, so let's just replace this file with the following version:

#import "TicTacToeViewController.h"
#import "TicTacToePacket.h"

@implementation TicTacToeViewController

#pragma mark -
#pragma mark Synthesized Properties
@synthesize newGameButton;
@synthesize feedbackLabel;
@synthesize session;
@synthesize peerID;
@synthesize xPieceImage;
@synthesize oPieceImage;
#pragma mark -
#pragma mark Game-Specific Methods

- (IBAction)newGameButtonPressed {
    dieRollReceived = NO;
    dieRollAcknowledged = NO;

    newGameButton.hidden = YES;
    GKPeerPickerController *picker = [[GKPeerPickerController alloc] init];

    picker.delegate = self;

    [picker show];
}

- (IBAction)gameSpacePressed:(id)sender {
    UIButton *buttonPressed = (UIButton *)sender;
    if (state == kGameStateMyTurn &&
        [buttonPressed imageForState:UIControlStateNormal] == nil) {
        [buttonPressed setImage:(piece == kPlayerPieceO) ? oPieceImage : xPieceImage
            forState:UIControlStateNormal];
        feedbackLabel.text = NSLocalizedString(@"Opponent's Turn",
            @"Opponent's Turn");
        state = kGameStateOpponentTurn;

        TicTacToePacket *packet = [[TicTacToePacket alloc]
            initMovePacketWithSpace:buttonPressed.tag];
        [self sendPacket:packet];
        [packet release];

        [self checkForGameEnd];
    }
}

- (void)startNewGame {
    [self resetBoard];
    [self sendDieRoll];
}

- (void)resetBoard {
    for (int i = kUpperLeft; i <= kLowerRight; i++) {
        UIButton *oneButton = (UIButton *)[self.view viewWithTag:i];
        [oneButton setImage:nil forState:UIControlStateNormal];
    }

    feedbackLabel.text = @"";

    TicTacToePacket *resetPacket = [[TicTacToePacket alloc] initResetPacket];
    [self sendPacket:resetPacket];
    [resetPacket release];

    piece = kPlayerPieceUndecided;
}

- (void)resetDieState {
    dieRollReceived = NO;
    dieRollAcknowledged = NO;
    myDieRoll = kDiceNotRolled;
    opponentDieRoll = kDiceNotRolled;
}

- (void)startGame {
    if (myDieRoll == opponentDieRoll) {
        myDieRoll = kDiceNotRolled;
        opponentDieRoll = kDiceNotRolled;
        [self sendDieRoll];
        piece = kPlayerPieceUndecided;
    }
    else if (myDieRoll < opponentDieRoll) {
        state = kGameStateOpponentTurn;
        piece = kPlayerPieceX;
        feedbackLabel.text = NSLocalizedString(@"Opponent's Turn",
            @"Opponent's Turn");

    }
    else {
        state = kGameStateMyTurn;
        piece = kPlayerPieceO;
        feedbackLabel.text = NSLocalizedString(@"Your Turn", @"Your Turn");
    }
    [self resetDieState];
}

- (void)checkForGameEnd {
    NSInteger moves = 0;

    UIImage     *currentButtonImages[9];
    UIImage     *winningImage = nil;

    for (int i = kUpperLeft; i <= kLowerRight; i++) {
        UIButton *oneButton = (UIButton *)[self.view viewWithTag:i];
        if ([oneButton imageForState:UIControlStateNormal])
            moves++;
        currentButtonImages[i - kUpperLeft] = [oneButton
            imageForState:UIControlStateNormal];

}

    // Top Row
    if (currentButtonImages[0] == currentButtonImages[1] &&
        currentButtonImages[0] == currentButtonImages[2] &&
        currentButtonImages[0] != nil)
        winningImage = currentButtonImages[0];

 // Middle Row
    else if (currentButtonImages[3] == currentButtonImages[4] &&
             currentButtonImages[3] == currentButtonImages[5] &&
             currentButtonImages[3] != nil)
        winningImage = currentButtonImages[3];

    // Bottom Row
    else if (currentButtonImages[6] == currentButtonImages[7] &&
             currentButtonImages[6] == currentButtonImages[8] &&
             currentButtonImages[6] != nil)
        winningImage = currentButtonImages[6];

    // Left Column
    else if (currentButtonImages[0] == currentButtonImages[3] &&
             currentButtonImages[0] == currentButtonImages[6] &&
             currentButtonImages[0] != nil)
        winningImage = currentButtonImages[0];

    // Middle Column
    else if (currentButtonImages[1] == currentButtonImages[4] &&
             currentButtonImages[1] == currentButtonImages[7] &&
             currentButtonImages[1] != nil)
        winningImage = currentButtonImages[1];

    // Right Column
    else if (currentButtonImages[2] == currentButtonImages[5] &&
             currentButtonImages[2] == currentButtonImages[8] &&
             currentButtonImages[2] != nil)
        winningImage = currentButtonImages[2];
    // Diagonal starting top left
    else if (currentButtonImages[0] == currentButtonImages[4] &&
             currentButtonImages[0] == currentButtonImages[8] &&
             currentButtonImages[0] != nil)
        winningImage = currentButtonImages[0];

  // Diagonal starting top right
    else if (currentButtonImages[2] == currentButtonImages[4] &&
             currentButtonImages[2] == currentButtonImages[6] &&
             currentButtonImages[2] != nil)
        winningImage = currentButtonImages[2];


    if (winningImage == xPieceImage) {
        if (piece == kPlayerPieceX) {
            feedbackLabel.text = NSLocalizedString(@"You Won!", @"You Won!");
            state = kGameStateDone;
        }
        else {
            feedbackLabel.text = NSLocalizedString(@"Opponent Won!",

@"Opponent Won!");
            state = kGameStateDone;
        }
    }
    else if (winningImage == oPieceImage) {
        if (piece == kPlayerPieceO){
            feedbackLabel.text = NSLocalizedString(@"You Won!", @"You Won!");
            state = kGameStateDone;
        }
        else {
            feedbackLabel.text = NSLocalizedString(@"Opponent Won!",
                @"Opponent Won!");
            state = kGameStateDone;
        }

    }
    else {
        if (moves >= 9) {
            feedbackLabel.text = NSLocalizedString(@"Cat Wins!", @"Cat Wins!");
            state = kGameStateDone;
        }
    }

    if (state == kGameStateDone)
        [self performSelector:@selector(startNewGame) withObject:nil
            afterDelay:3.0];
}

#pragma mark -
#pragma mark Superclass Overrides
- (void)viewDidLoad {
    [super viewDidLoad];
    myDieRoll = kDiceNotRolled;
    self.oPieceImage = [UIImage imageNamed:@"O.png"];
    self.xPieceImage = [UIImage imageNamed:@"X.png"];
}

- (void)viewDidUnload {
    [super viewDidUnload];
    self.newGameButton = nil;
    self.xPieceImage = nil;
    self.oPieceImage = nil;
}

- (void)dealloc {
    [newGameButton release];
    [feedbackLabel release];
    [xPieceImage release];
    [oPieceImage release];

    session.available = NO;
    [session disconnectFromAllPeers];
    [session setDataReceiveHandler: nil withContext: nil];
    session.delegate = nil;
    [session release];
    [peerID release];
    [super dealloc];

}

#pragma mark -
#pragma mark GameKit Peer Picker Delegate Methods
- (GKSession *)peerPickerController:(GKPeerPickerController *)picker sessionForConnectionType:(GKPeerPickerConnectionType)type{
    GKSession *theSession = [[GKSession alloc]
        initWithSessionID:kTicTacToeSessionID displayName:nil
        sessionMode:GKSessionModePeer];
    return [theSession autorelease];
}

- (void)peerPickerController:(GKPeerPickerController *)picker
didConnectPeer:(NSString *)thePeerID toSession:(GKSession *)theSession {
    self.peerID = thePeerID;

    self.session = theSession;
    self.session.delegate = self;
    [self.session setDataReceiveHandler:self withContext:NULL];

    [picker dismiss];
    picker.delegate = nil;
    [picker release];

    [self startNewGame];
}

- (void)peerPickerControllerDidCancel:(GKPeerPickerController *)picker {
    newGameButton.hidden = NO;
}

#pragma mark -
#pragma mark GameKit Session Delegate Methods
- (void)session:(GKSession *)theSession didFailWithError:(NSError *)error {
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:
        NSLocalizedString(@"Error Connecting!", @"Error Connecting!")
        message:NSLocalizedString(@"Unable to establish the connection.",
            @"Unable to establish the connection.")
        delegate:self
        cancelButtonTitle:NSLocalizedString(@"Bummer", @"Bummer")
        otherButtonTitles:nil];
    [alert show];
    [alert release];
    theSession.available = NO;
    [theSession disconnectFromAllPeers];
    theSession.delegate = nil;
    [theSession setDataReceiveHandler:nil withContext:nil];
    self.session = nil;
}

- (void)session:(GKSession *)theSession peer:(NSString *)peerID
didChangeState:(GKPeerConnectionState)inState {
    if (inState == GKPeerStateDisconnected) {
        state = kGameStateInterrupted;
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:
            NSLocalizedString(@"Peer Disconnected!", @"Peer Disconnected!")
            message:NSLocalizedString(@"Your opponent has disconnected, or 

the connection has been lost",
                @"Your opponent has disconnected, or the connection has been lost")
            delegate:self
            cancelButtonTitle:NSLocalizedString(@"Bummer", @"Bummer")
            otherButtonTitles:nil];
        [alert show];
        [alert release];
        theSession.available = NO;
        [theSession disconnectFromAllPeers];
        theSession.delegate = nil;
        [theSession setDataReceiveHandler:nil withContext:nil];
        self.session = nil;
    }
}

#pragma mark -
#pragma mark GameKit Send & Receive Methods
- (void)sendDieRoll {
    state = kGameStateRollingDice;
    TicTacToePacket *rollPacket;
    if (myDieRoll == kDiceNotRolled) {
        rollPacket = [[TicTacToePacket alloc] initDieRollPacket];
        myDieRoll = rollPacket.dieRoll;
    }
    else
        rollPacket = [[TicTacToePacket alloc] initDieRollPacketWithRoll:myDieRoll];
    [self sendPacket:rollPacket];
    [rollPacket release];

}

- (void) receiveData:(NSData *)data fromPeer:(NSString *)peer
inSession:(GKSession *)theSession context:(void *)context
{
    NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc]
        initForReadingWithData:data];
    TicTacToePacket *packet = [unarchiver decodeObjectForKey:kTicTacToeArchiveKey];

    switch (packet.type) {
        case kPacketTypeDieRoll:
            opponentDieRoll = packet.dieRoll;
            TicTacToePacket *ack = [[TicTacToePacket alloc]
                initAckPacketWithDieRoll:opponentDieRoll];
            [self sendPacket:ack];
            [ack release];
            dieRollReceived = YES;
            break;
        case kPacketTypeAck:
            if (packet.dieRoll != myDieRoll) {
                NSLog(@"Ack packet doesn't match opponentDieRoll (mine: %d, 

send: %d", packet.dieRoll, myDieRoll);
            }
            dieRollAcknowledged = YES;
            break;
        case kPacketTypeMove:{
            UIButton *theButton = (UIButton *)[self.view viewWithTag:packet.space];
            [theButton setImage:(piece == kPlayerPieceO) ? xPieceImage : oPieceImage

forState:UIControlStateNormal];
            state = kGameStateMyTurn;
            feedbackLabel.text = NSLocalizedString(@"Your Turn", @"Your Turn");
            [self checkForGameEnd];
        }
            break;
        case kPacketTypeReset:
            if (state == kGameStateDone)
                [self resetDieState];
            break;
        default:
            break;
    }

    if (dieRollReceived == YES && dieRollAcknowledged == YES)
        [self startGame];

    [unarchiver release];
}

- (void) sendPacket:(TicTacToePacket *)packet {
    NSMutableData *data = [[NSMutableData alloc] init];
    NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc]
        initForWritingWithMutableData:data];
    [archiver encodeObject:packet forKey:kTicTacToeArchiveKey];
    [archiver finishEncoding];

    NSError *error = nil;

    if (![session sendDataToAllPeers:data withDataMode:GKSendDataReliable
        error:&error]) {
        // You will do real error handling
        NSLog(@"Error sending data: %@", [error localizedDescription]);
    }
    [archiver release];
    [data release];
}

#pragma mark -
#pragma mark Alert View Delegate Methods
- (void)alertView:(UIAlertView *)alertView willDismissWithButtonIndex:(NSInteger)buttonIndex {
    [self resetBoard];
    newGameButton.hidden = NO;
}

@end

Whoa. Deep breath now. That was a lot of code, huh? Let's break it down.

The first method we wrote is the action method that is called when the New Game button is pressed. When that happens, we set dieRollReceived and dieRollAcknowledged to NO, because we know neither of these things has happened yet for the new game.

- (IBAction)newGameButtonPressed {
    dieRollReceived = NO;

dieRollAcknowledged = NO;

Next, we hide the button, because we don't want our player to request a new game while we're looking for peers or playing the game. Then we create an instance of GKPeerPickerController, set self as the delegate, and show the peer picker controller.

newGameButton.hidden = YES;
    GKPeerPickerController *picker = [[GKPeerPickerController alloc] init];

    picker.delegate = self;

    [picker show];
}

That's all we need to do to kick off the process of letting the user select another device to play against. The peer picker will handle everything, and then call delegate methods when we need to take some action.

We also wrote an action method that is called when the user taps one of the nine game spaces. The first thing we do is cast sender to a UIButton. We know sender will always be an instance of UIButton, and doing this will prevent us from needing to cast sender every time we use it.

- (IBAction)gameSpacePressed:(id)sender {
    UIButton *buttonPressed = (UIButton *)sender;

Next, we check the game state. We don't want to let the user select a space if it's not that player's turn. We also check to make sure that the button pressed has no image already assigned. If it has an image assigned to it, then there's already either an X or an O in the space this button represents, and the user is not allowed to select it.

if (state == kGameStateMyTurn &&
        [buttonPressed imageForState:UIControlStateNormal] == nil) {

If the space has no image assigned and it is our turn, we set the image to whichever image is appropriate for our player, based on whether we went first or second. The piece variable will get set later when we compare die rolls. We also set the feedback label to inform the users that it's no longer their turn, and change the state to reflect that as well.

[buttonPressed setImage:(piece == kPlayerPieceO) ? oPieceImage : xPieceImage
            forState:UIControlStateNormal];
        feedbackLabel.text = NSLocalizedString(@"Opponent's Turn",
            @"Opponent's Turn");
        state = kGameStateOpponentTurn;

We must inform the other device that we've made our move, so we create an instance of TicTacToePacket, passing the tag value from the button that was pressed to identify which space our player selected. We use a method called sendPacket:, which we'll look at in a moment, to send the instance of TicTacToePacket to the other node, and then we release packet:

TicTacToePacket *packet = [[TicTacToePacket alloc]
            initMovePacketWithSpace:buttonPressed.tag];
        [self sendPacket:packet];
        [packet release];

Finally, we check to see if the game is over. The method checkForGameEnd determines if either player won or if there are no spaces on the board, which would mean it's a tie.

[self checkForGameEnd];
    }
}

The method startNewGame is very simple. It just calls a method to reset the board, and then calls another method to roll the die and send the result to the other node. Both of these actions can happen at times other than game start. For example, we reset the board if the connection is lost, and we send the die roll if both nodes roll the same number.

- (void)startNewGame {
    [self resetBoard];
    [self sendDieRoll];
}

Resetting the board involves removing the images from all of the buttons that represent spaces on the game board. Rather than declare nine outlets—one to point at each button—we just loop through the nine tag values and retrieve the buttons from our content view using viewWithTag:.

- (void)resetBoard {
    for (int i = kUpperLeft; i <= kLowerRight; i++) {
        UIButton *oneButton = (UIButton *)[self.view viewWithTag:i];
        [oneButton setImage:nil forState:UIControlStateNormal];
    }

We also blank out the feedback label.

feedbackLabel.text = @"";

And we send a packet to the other node telling it that we're resetting. This is done just to make sure that if we follow up with another die roll, the other machine knows not to overwrite it. The fact that network communication happens asynchronously means we can't rely on things always happening in a specific order, as we can with a program running on only one device. It's possible that we'll send the die roll before the other device has finished determining who won. By sending a reset packet, we tell the other node that there may be another die roll coming for a new game, so make sure it's in the right state to accept that new roll. If we didn't do something like this, it might store our die roll, and then overwrite the rolled value when it resets its own board, which would cause a hang because the other device would then be waiting for a die roll that would never arrive.

TicTacToePacket *resetPacket = [[TicTacToePacket alloc] initResetPacket];
    [self sendPacket:resetPacket];
    [resetPacket release];

We also need to reset the player's game piece. Because the game is over, we don't know if the player will be X or O for the next game.

piece = kPlayerPieceUndecided;
}

Resetting the die state is nothing more than setting dieRollReceived and dieRollAcknowledged to NO, and setting both our die roll and the opponent's die roll to kDiceNotRolled:

- (void)resetDieState {
    dieRollReceived = NO;
    dieRollAcknowledged = NO;
    myDieRoll = kDiceNotRolled;
    opponentDieRoll = kDiceNotRolled;
}

The next method is called once we have received our opponent's die roll and have also gotten an acknowledgment that it has received ours. First, we make sure that we don't have a tie. If we do have a tie, we kick off the die-rolling process again.

- (void)startGame {
    if (myDieRoll == opponentDieRoll) {
        myDieRoll = kDiceNotRolled;
        opponentDieRoll = kDiceNotRolled;
        [self sendDieRoll];
        piece = kPlayerPieceUndecided;
    }

Otherwise, we set state, piece, and the feedbackLabel's text based on whether it's our turn or the opponent's turn to go first.

else if (myDieRoll < opponentDieRoll) {
        state = kGameStateOpponentTurn;
        piece = kPlayerPieceX;
        feedbackLabel.text = NSLocalizedString(@"Opponent's Turn",
            @"Opponent's Turn");
    }
    else {
        state = kGameStateMyTurn;
        piece = kPlayerPieceO;
        feedbackLabel.text = NSLocalizedString(@"Your Turn", @"Your Turn");
    }

Then we reset the die state. It may seem odd to do it here, but at this point, we're finished with the die rolling for this game, and because we may receive our opponent's die roll before our code has realized the game is over, we reset now to ensure that the die rolls are not accidentally reused in the next game.

[self resetDieState];
}

The checkForGameEnd method just checks all nine spaces to see whether they have X or O in them, and then looks for three in a row. It does this by first declaring a variable called moves to keep track of how many moves have happened. This is how it will tell if there's a tie. If there have been nine moves, and no one has won, then there are no available spaces left on the board, so it's a tie.

- (void)checkForGameEnd {
    NSInteger moves = 0;

Next, we declare an array of nine UIImage pointers. We're going to pull the images out of the nine buttons representing spaces on the board and put them in this array to make it easier to check if a player won.

UIImage     *currentButtonImages[9];

If we find three in a row, we'll store one of the three images in this variable so we know which player won the game.

UIImage     *winningImage = nil;

Next, we loop through the buttons by tag, as we did in the resetBoard method earlier, storing the images from the buttons in the array we declared earlier.

for (int i = kUpperLeft; i <= kLowerRight; i++) {
        UIButton *oneButton = (UIButton *)[self.view viewWithTag:i];
        if ([oneButton imageForState:UIControlStateNormal])
            moves++;
        currentButtonImages[i - kUpperLeft] = [oneButton
            imageForState:UIControlStateNormal];
    }

The next big chunk of code just checks to see if there are three of the same images in a row anywhere. If it finds three in a row, it stores one of the three images in winningImage. When it completes the check, it will know which player, if any, has won.

// Top Row
    if (currentButtonImages[0] == currentButtonImages[1] &&
        currentButtonImages[0] == currentButtonImages[2] &&
        currentButtonImages[0] != nil)
        winningImage = currentButtonImages[0];

   // Middle Row
    else if (currentButtonImages[3] == currentButtonImages[4] &&
             currentButtonImages[3] == currentButtonImages[5] &&
             currentButtonImages[3] != nil)
        winningImage = currentButtonImages[3];

    // Bottom Row
    else if (currentButtonImages[6] == currentButtonImages[7] &&
             currentButtonImages[6] == currentButtonImages[8] &&
             currentButtonImages[6] != nil)
        winningImage = currentButtonImages[6];

   // Left Column
    else if (currentButtonImages[0] == currentButtonImages[3] &&
             currentButtonImages[0] == currentButtonImages[6] &&
             currentButtonImages[0] != nil)
        winningImage = currentButtonImages[0];

    // Middle Column
    else if (currentButtonImages[1] == currentButtonImages[4] &&
             currentButtonImages[1] == currentButtonImages[7] &&
             currentButtonImages[1] != nil)
        winningImage = currentButtonImages[1];

    // Right Column
    else if (currentButtonImages[2] == currentButtonImages[5] &&

currentButtonImages[2] == currentButtonImages[8] &&
             currentButtonImages[2] != nil)
        winningImage = currentButtonImages[2];
    // Diagonal starting top left
    else if (currentButtonImages[0] == currentButtonImages[4] &&
             currentButtonImages[0] == currentButtonImages[8] &&
             currentButtonImages[0] != nil)
        winningImage = currentButtonImages[0];

   // Diagonal starting top right
    else if (currentButtonImages[2] == currentButtonImages[4] &&
             currentButtonImages[2] == currentButtonImages[6] &&
             currentButtonImages[2] != nil)
        winningImage = currentButtonImages[2];

Finally, we check to see if there was a winner, and whether it was our opponent or our player. If there is a winner, we set the feedback label and state as appropriate.

if (winningImage == xPieceImage) {
        if (piece == kPlayerPieceX) {
            feedbackLabel.text = NSLocalizedString(@"You Won!", @"You Won!");
            state = kGameStateDone;
        }
        else {
            feedbackLabel.text = NSLocalizedString(@"Opponent Won!",
                @"Opponent Won!");
            state = kGameStateDone;
        }
    }
    else if (winningImage == oPieceImage) {
        if (piece == kPlayerPieceO){
            feedbackLabel.text = NSLocalizedString(@"You Won!", @"You Won!");
            state = kGameStateDone;
        }
        else {
            feedbackLabel.text = NSLocalizedString(@"Opponent Won!",
                @"Opponent Won!");
            state = kGameStateDone;
        }
    }

If there wasn't a winner, then we check to see if any spaces are left on the board by looking at moves. If no spaces remain, then we know the game is over, and the cat won.

else {
        if (moves >= 9) {
            feedbackLabel.text = NSLocalizedString(@"Cat Wins!", @"Cat Wins!");
            state = kGameStateDone;
        }
    }

If any of the preceding code set the state to kGameStateDone, then we use performSelector:withObject:afterDelay: to start a new game after the user has had time to read who won.

if (state == kGameStateDone)
        [self performSelector:@selector(startNewGame) withObject:nil
            afterDelay:3.0];
}

In viewDidLoad, we first set myDieRoll to show that we have not yet rolled the die to choose who goes first. Then we load the two images used for the playing pieces and store them in the two properties designed to hold them.

- (void)viewDidLoad {
    [super viewDidLoad];
    myDieRoll = kDiceNotRolled;
    self.oPieceImage = [UIImage imageNamed:@"O.png"];
    self.xPieceImage = [UIImage imageNamed:@"X.png"];
}

The viewDidUnload method is pretty typical, so it doesn't warrant any discussion.

- (void)viewDidUnload {
    [super viewDidUnload];
    self.newGameButton = nil;
    self.xPieceImage = nil;
    self.oPieceImage = nil;
}

Most of the dealloc method is pretty standard, too. Just notice that before we release session, we take care of disconnecting from our peers and setting both the delegate and data receive handler to nil, as we discussed earlier in the chapter.

- (void)dealloc {
    [newGameButton release];

    [xPieceImage release];
    [oPieceImage release];

    session.available = NO;
    [session disconnectFromAllPeers];
    [session setDataReceiveHandler: nil withContext: nil];
    session.delegate = nil;
    [session release];

    [super dealloc];
}

Now, we get into the peer picker delegate methods. This first one is where the picker asks us to provide a session. Because we want all devices to both advertise and look for other devices on the network, we specify GKSessionModePeer for the session mode. Notice that we also use our constant kTicTacToeSessionID, which we defined in the header file to make sure that we connect only to other instances of TicTacToe.

- (GKSession *)peerPickerController:(GKPeerPickerController *)picker sessionForConnectionType:(GKPeerPickerConnectionType)type{
    GKSession *theSession = [[GKSession alloc]

initWithSessionID:kTicTacToeSessionID displayName:nil
        sessionMode:GKSessionModePeer];
    return [theSession autorelease];
}

Because the peer picker is only for simple peer-to-peer games, once we're notified of a connection, we store the session and the peer identifier, and then dismiss the picker. After we've dismissed it, we call startNewGame to get things going.

- (void)peerPickerController:(GKPeerPickerController *)picker
didConnectPeer:(NSString *)thePeerID toSession:(GKSession *)theSession {
    self.peerID = thePeerID;

    self.session = theSession;
    self.session.delegate = self;
    [self.session setDataReceiveHandler:self withContext:NULL];

    [picker dismiss];
    picker.delegate = nil;
    [picker release];

    [self startNewGame];
}

This method is called if the users select Cancel from either the Bluetooth enable or peer picker dialog. It simply makes sure that our New Game button is visible if they cancel, so they can still start a new game.

- (void)peerPickerControllerDidCancel:(GKPeerPickerController *)picker {
    newGameButton.hidden = NO;
}

The next few methods are the session delegate methods. The first one we implement is called if a connection attempt fails. All we do is put up an alert view informing the user that it failed, and then clean up the session. In the alert view delegate method, we reset the board so the users can try again or select a new opponent if they want.

- (void)session:(GKSession *)theSession didFailWithError:(NSError *)error {
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:
        NSLocalizedString(@"Error Connecting!", @"Error Connecting!")
        message:NSLocalizedString(@"Unable to establish the connection.",
            @"Unable to establish the connection.")
        delegate:self
        cancelButtonTitle:NSLocalizedString(@"Bummer", @"Bummer")
        otherButtonTitles:nil];
    [alert show];
    [alert release];
    theSession.available = NO;
    [theSession disconnectFromAllPeers];
    theSession.delegate = nil;
    [theSession setDataReceiveHandler:nil withContext:nil];
    self.session = nil;
}

Because we're using the peer picker, we don't need to handle choosing another node or connecting to it. But we must make sure that if the opponent disconnects, we don't keep trying to play that game. The following method is called any time a peer's state changes. If we're notified that another node has disconnected, we again inform the users through an alert view, and when they dismiss it, our alert view delegate method will reset the board.

- (void)session:(GKSession *)theSession peer:(NSString *)peerID
        didChangeState:(GKPeerConnectionState)inState {
    if (inState == GKPeerStateDisconnected) {
        state = kGameStateInterrupted;
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:
            NSLocalizedString(@"Peer Disconnected!", @"Peer Disconnected!")
            message:NSLocalizedString(@"Your opponent has disconnected, or 

the connection has been lost",
                @"Your opponent has disconnected, or the connection has been lost")
            delegate:self
            cancelButtonTitle:NSLocalizedString(@"Bummer", @"Bummer")
            otherButtonTitles:nil];
        [alert show];
        [alert release];
        theSession.available = NO;
        [theSession disconnectFromAllPeers];
        theSession.delegate = nil;
        [theSession setDataReceiveHandler:nil withContext:nil];
        self.session = nil;
    }
}

This method sends a die roll packet to the other node. The initDieRollPacket method automatically generates a packet with a random number.

- (void)sendDieRoll {
    state = kGameStateRollingDice;
    TicTacToePacket *rollPacket;
    if (myDieRoll == kDiceNotRolled) {
        rollPacket = [[TicTacToePacket alloc] initDieRollPacket];
        myDieRoll = rollPacket.dieRoll;
    }
    else
        rollPacket = [[TicTacToePacket alloc] initDieRollPacketWithRoll:myDieRoll];
    [self sendPacket:rollPacket];
    [rollPacket release];
}

The following is our data receive handler. This method is called whenever we receive a packet from the other node. The first thing we do is unarchive the data into a copy of the original TicTacToePacket instance that was sent.

- (void) receiveData:(NSData *)data fromPeer:(NSString *)peer
        inSession:(GKSession *)theSession context:(void *)context {
    NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc]
        initForReadingWithData:data];
    TicTacToePacket *packet = [unarchiver decodeObjectForKey:kTicTacToeArchiveKey];

Then we use a switch statement to take different actions based on the type of packet we received.

switch (packet.type) {

If it's a die roll, we store our opponent's value, send back an acknowledgment of the value, and set dieRollReceived to YES.

case kPacketTypeDieRoll:
            opponentDieRoll = packet.dieRoll;
            TicTacToePacket *ack = [[TicTacToePacket alloc]
                initAckPacketWithDieRoll:opponentDieRoll];
            [self sendPacket:ack];
            [ack release];
            dieRollReceived = YES;
            break;

If we've received an acknowledgment, we make sure the number returned is the same as the one we sent. This is just a consistency check. It shouldn't ever happen that the number is not the same. If it did, it might be an indication of a problem with our code, or it could mean that someone is cheating. Although we doubt that anyone would bother cheating at tic-tac-toe, people have been know to cheat in some networked games, so you might want to consider validating any information exchanged with peers. Here, we're just logging the inconsistency and moving on. In your real-world applications, you might want to take more serious action if you detect a data inconsistency of this nature.

case kPacketTypeAck:
            if (packet.dieRoll != myDieRoll) {
                NSLog(@"Ack packet doesn't match opponentDieRoll (mine: %d, 

send: %d", packet.dieRoll, myDieRoll);
            }
            dieRollAcknowledged = YES;
            break;

If the packet is a move packet, which denotes that the other player chose a space, we update the appropriate space with an X or O image, and change the state and label to reflect the fact that it's now our player's turn. We also check to see if the other player's move resulted in the game being over.

case kPacketTypeMove:{
            UIButton *theButton = (UIButton *)[self.view viewWithTag:packet.space];
            [theButton setImage:(piece == kPlayerPieceO) ? xPieceImage : oPieceImage
                forState:UIControlStateNormal];
            state = kGameStateMyTurn;
            feedbackLabel.text = NSLocalizedString(@"Your Turn", @"Your Turn");
            [self checkForGameEnd];
        }
            break;

When we receive a reset packet, all we do is change the game state to kGameStateDone, so that if a die roll comes in before we've realized the game is over, we don't discard it.

case kPacketTypeReset:
            if (state == kGameStateDone)
                [self resetDieState];
        default:
            break;
    }

If we received a packet, and both dieRollReceived and dieRollAcknowledged are now YES, we know it's time to start the game.

if (dieRollReceived == YES && dieRollAcknowledged == YES)
        [self startGame];

Of course, before our method is complete, we need to release the unarchiver, since we used alloc to create it.

[unarchiver release];
}

The next method sends a packet to the other device. It takes an instance of TicTacToePacket and archives it into an instance of NSData. It then uses the session's sendDataToAllPeers:withDataMode:error: method to send it across the wire—well, across the wireless, in this case.

- (void) sendPacket:(TicTacToePacket *)packet {
    NSMutableData *data = [[NSMutableData alloc] init];
    NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc]
        initForWritingWithMutableData:data];
    [archiver encodeObject:packet forKey:kTicTacToeArchiveKey];
    [archiver finishEncoding];

    NSError *error = nil;

    if (![session sendDataToAllPeers:data withDataMode:GKSendDataReliable
        error:&error]) {
        // You will do real error handling
        NSLog(@"Error sending data: %@", [error localizedDescription]);
    }
    [archiver release];
    [data release];
}

The last method in our controller class is the alert view delegate. This is called any time we show an alert view. The only reason we ever show an alert view in this application is to inform the user that something bad happened. Therefore, if we get here, we know we must reset the board and show the New Game button.

- (void)alertView:(UIAlertView *)alertView willDismissWithButtonIndex:(NSInteger)buttonIndex {
    [self resetBoard];
    newGameButton.hidden = NO;
}
@end