Before working with a session, we need to connect to another device. Thankfully, Apple has provided the GKPeerPickerController that does just that. The peer picker comes complete with its own user interface for locating and accepting connections.

Here are the steps needed to add peer picker to the P2P Chat example:

These additions will get the peer picker to show on the screen, but you still need to implement the delegate in order to do anything with the session the peer picker configures for you. In order to do this, your class must implement GKPeerPickerControllerDelegate:

@protocol GKPeerPickerControllerDelegate <NSObject>
   @optional
   - (void)peerPickerController:(GKPeerPickerController *)picker
      didSelectConnectionType:(GKPeerPickerConnectionType)type;

   - (GKSession *)peerPickerController:(GKPeerPickerController *)picker
      sessionForConnectionType:(GKPeerPickerConnectionType)type;
   - (void)peerPickerController:(GKPeerPickerController *)picker
      didConnectPeer:(NSString *)peerID toSession:(GKSession *)session;
   - (void)peerPickerControllerDidCancel:(GKPeerPickerController *)picker;
@end

Here are the details of how the GKPeerPickerControllerDelegate is implemented in P2PChat:

Now that you have a peer picker set up, you can implement the GKSession object that you will use to send and receive messages between devices. In P2P Chat, the GKSession object is initialized in the peerPickerController:sessionForConnectionType: method implementation for the protocol GKPeerPickerControllerDelegate:

-(GKSession*)peerPickerController:(GKPeerPickerController*)picker
   sessionForConnectionType:(GKPeerPickerConnectionType)type {
   if(!gameSession) {
      gameSession = [[GKSession alloc]
         initWithSessionID:@"com.appsamuck.p2pchat"
         displayName:nil sessionMode:GKSessionModePeer];
      gameSession.delegate = self;
   }
   return gameSession;
}

This line creates and initializes the session:

gameSession = [[GKSession alloc] initWithSessionID:@"com.appsamuck.p2pchat"
   displayName:nil sessionMode:GKSessionModePeer];

The parameters needed for initializing a session are:

In P2P Chat, the displayName parameter is set to nil. Setting displayName to nil instructs the picker to use the device name as the displayName. We set the mode to GKSessionModePeer, which tells the session to act as both server and client. This results in the best user experience.

Once you have created the GKSession you begin to send messages. To send a message, you will need to call the method sendDataToAllPeers:withDataMode:error:. This method is used in P2P Chat whenever the Speak button is clicked:

- (IBAction)speakButtonClicked:(id)sender {
    if (!isConnected) return;
   NSString *message = textField.text;
   NSData *data = [message dataUsingEncoding:NSASCIIStringEncoding];
   [gameSession sendDataToAllPeers:data withDataMode:GKSendDataReliable error:nil];
}

Take care to notice the parameter data mode. There are two ways to send messages:

The last thing left to do is to implement pertinent methods defined by the protocol GKSessionDelegate:

@protocol GKSessionDelegate <NSObject>
@optional
   - (void)session:(GKSession *)session peer:(NSString *)peerID
      didChangeState:(GKPeerConnectionState)state;
   - (void)session:(GKSession *)session
      connectionWithPeerFailed:(NSString *)peerID withError:(NSError *)error;
   - (void)session:(GKSession *)session didFailWithError:(NSError *)error;
@end

Only one method in this protocol is necessary for P2P Chat. The app needs to know whenever the state of a peer changes relative to the session. For this, the app needs to implement the method session:peer:didChangeState. In this method the app needs to react whenever a peer connects or disconnects. The peer picker will handle all other state changes of concern for us:

- (void)session:(GKSession *)session peer:(NSString *)peerID
   didChangeState:(GKPeerConnectionState)state {
   NSString* stateName = nil;
   switch (state) {
      case GKPeerStateConnected:
         [session setDataReceiveHandler: self withContext: nil];
         self.isConnected = true;
         self.gameSession = session;
         [peerPicker dismiss];
         break;
      case GKPeerStateDisconnected:
         self.isConnected = false;
         break;
   }
}

Note these two lines of code from above:

[session setDataReceiveHandler: self withContext: nil];

and

[peerPicker dismiss];

Calling dismiss on the peer picker simply closes the peer picker. However, remember to make the call to get the peer picker off the screen. The call to setDataReceiveHandler: withContext warrants a little more discussion. Setting the DataReceiveHandler tells the GKSession which object to send data to as it arrives from the remote peer. The class receiving the data must implement the following method as P2P Chat has done:

- (void) receiveData:(NSData *)data fromPeer:(NSString *)peer
   inSession:(GKSession *)session context:(void *)context {
   NSString *message = [[NSString alloc] initWithData:data
      encoding:NSASCIIStringEncoding];
   textView.text = [textView.text stringByAppendingString:
      [NSString stringWithFormat:@"%@
", message]];
}

As illustrated above, whenever data is received from a peer, you can intercept the data in this method and use it in your app as prescribed by your requirements.

Earlier in the chapter we discussed that network games at times have to deal with lost packets and latency. These are the types of issues that can trip us up in the later stages of the development process and lead to an expensive overhaul. As long as we are sending packets quickly and repeatedly, a lost packet here or there will not cause huge hiccups. However, latency could be an issue here. We need a good idea of how much latency to expect in a normal peer-to-peer connection. The best thing to do is to try and measure it so we know what we are dealing with. In order to see what we were up against, we wrote a small app that sends a packet of data back and forth between two peers to constantly record the current time on the device. This allows us to measure how long it takes a packet to round-trip, or get back to the device that it originated from.

We created a small app based on P2P Chat to perform the test. Here is a short breakdown of the key pieces of the application and how it works so you will understand how we arrived at our results. First, we need a packet to round-trip for the test:

typedef struct {
   int player;
   int count;
   double time;
} Packet;

Once the GKSession is established, a message can be sent to the peer. The following code is used to send the message:

localPacket.player = playerNumber;
localPacket.count = ++currentCount;
localPacket.time = CFAbsoluteTimeGetCurrent();
localData = [localData initWithBytes:&localPacket length:sizeof(Packet)];
[self.gameSession sendDataToAllPeers:localData
   withDataMode:GKSendDataUnreliable error:&sendError];

When the peer receives a packet from a peer, it returns the package back to the sender. When the peer receives a packet that it created, measurements can be recorded. Listing 7.1 shows how this was accomplished.

#pragma mark GKSessionDelegate
- (void) receiveData:(NSData *)data fromPeer:(NSString *)peer
   inSession:(GKSession *)session context:(void *)context {
   Packet packetData;
   [data getBytes:& packetData length:sizeof(Packet)];

   if (packetData.player == playerNumber) {
      // This packet originated here
      if (lastCount+1 != packetData.count) {
         // This throws out missed or late packets
         packetData++;
         double elapsedTime = CFAbsoluteTimeGetCurrent() - packetData.time;
         totalElapsedTime += elapsedTime;
         NSString *remoteStatus remoteStatus = [NSString stringWithFormat:
            @"Average time: %f", totalElapsedTime / packetCount];
         textView.text = remoteStatus;
         lastCount = packetData.count;
      }
   }
   else {
      // This packet originated on the peer we need to return it
      remotePacket = received;
      remoteData = [remoteData initWithBytes:&remotePacket
         length:sizeof(Packet)];
      [self.gameSession sendDataToAllPeers:remoteData
         withDataMode:GKSendDataUnreliable error:nil];
   }
}

- (void)session:(GKSession *)session
   didReceiveConnectionRequestFromPeer:(NSString *)peerID {
   // This method will only be called on one device
   playerNumber = 2;
}

After running the test, we discovered that in peer-to-peer the time it takes to round-trip is as follows:

Also realize this is a round trip, so we can assume that a single packet will be roughly half of this time. Also, if your packet is larger, it will take longer to send. So what does this tell us? If we keep small packets, we can expect to be able to receive about 50 per second; worst case, we will receive 10 per second. That's not too shabby. What happens if we switch the same example to reliable messaging? You can do this by changing GKSendDataUnreliable to GKSendDataReliable throughout the code.

For example, change this:

[self.gameSession sendDataToAllPeers:remoteData
   withDataMode:GKSendDataUnreliable error:nil];

to this:

[self.gameSession sendDataToAllPeers:remoteData
   withDataMode:GKSendDataReliable error:nil];

When this was done in our test, we yielded the following results with reliable messaging:

As expected, reliable is a bit slower, but still fairly good. Choose whether to use reliable messaging or unreliable messaging according to the needs of your game. For the AmuckPuck game, we will need to use a little of both. For puck and paddle movements, we will use unreliable for speed. For major game events like scoring, we will use reliable messaging. Also, based on the numbers above, we will be able to move forward without prediction or interpolation.

Next is the first piece of the HockeyTableView header—this is the big one. The following definitions supply several knobs to turn so you can fine-tune the behavior and physics of the hockey table:

#define ANIMATION_INTERVAL 1.0 / 60.0
#define MAX_TOP_PLAYER_Y 200
#define MIN_BOTTOM_PLAYER_Y 280
#define MAX_PADDLE_STRIKE 15.0
#define MIN_PADDLE_STRIKE 2.5
#define PADDLE_STRIKE 1.5
#define PUCK_DECAY_RATE 0.10
#define PUCK_SPIN_DECAY_RATE 0.05
#define PUCK_DIAMETER 40
#define PUCK_RADIUS 20
#define PADDLE_DIAMETER 80
#define PADDLE_RADIUS 40
#define GOAL_START 80
#define GOAL_END 240

The following enumerations are used to define and communicate the different states that the table can assume:

typedef enum {
   NO_CONNECTION = 0,
   HEADTOHEAD_CONNECTION,
   HOST_CONNECTION,
   CLIENT_CONNECTION
} ConnectionType;
typedef enum {
   BOTTOM_PLAYER = 0,
   TOP_PLAYER
} PlayerCode;
typedef enum {
   SCORE_MESSAGE = 0,
   WIN_MESSAGE
} MessageCode;

HockeyTableViewDelegate is a protocol that is used to send an alert when a goal has been scored. This protocol is needed by the HockeyViewController so it can send out a message when a goal is scored:

@protocol HockeyTableViewDelegate <NSObject>
@optional
- (void)hockeyTableDidScore:(PlayerCode)playerCode;
@end

Next is the remaining "public" definition for the HockeyTableView interface:

@interface HockeyTableView : UIView {

   id<HockeyTableViewDelegate> delegate;

   ConnectionType connectionType;
   CALayer *bottomPaddleLayer;
   CALayer *topPaddleLayer;
   CALayer *puckLayer;
   StateData bottomPaddleData;
   StateData topPaddleData;

   UIImage *goalImage;
   UIImage *blueWinsImage;
   UIImage *redWinsImage;

   int topScore;
   int bottomScore;

   double messageRotation;

   NSTimer *animationTimer;

   UILabel *scoreLabel;
   UIImageView *messageView;
}
@property (nonatomic,assign) id /*<HockeyTableViewDelegate>*/ delegate;
@property (nonatomic) StateData bottomPaddleData;
@property (nonatomic) StateData topPaddleData;
@property (nonatomic) ConnectionType connectionType;
- (void)startAnimation;
- (void)stopAnimation;
- (void)updatePuckData:(StateData)puckData;
- (void)displayMessage:(MessageCode)messageCode
   forPlayer:(PlayerCode)playerCode;
@end

At the beginning of the implementation of HockeyTableView you will see a short list of private methods. It is helpful to separate fields and attributes of the interface this way, especially when a class becomes as large as this one:

//  HockeyTableView.m
#import "HockeyTableView.h"
// private methods
@interface HockeyTableView ()
@property (nonatomic, assign) NSTimer *animationTimer;
- (void)initializeContents;
- (void)drawView;
- (void)updateView;
- (void)updatePuck;
- (void)didScore:(PlayerCode)playerCode;
@end

In addition to the private section, we have included a handful of helper methods. These methods do not need to access any class members and could be moved out to another global library. The helper methods have been implemented in C instead of Objective-C to illustrate how you can seamlessly blend the two syntaxes in a single project in Xcode:

// helper methods
CGPoint normalVector(double x1, double x2, double y1, double y2);
double distance(double x1, double x2, double y1, double y2);
double paddleSpeed(StateData stateData);
void correctTouchPoint(CGPoint *touchPoint);

HockeyViewController manages and hosts the HockeyTableView. All peer-to-peer communication that occurs between the two devices is managed right here in this class. This has been extremely beneficial in this project because we can come to one place for all of our communication maintenance:

// HockeyViewController.h
#import <GameKit/GameKit.h>
#import "FlipsideViewController.h"
#import "MainView.h"
#import "HockeyData.h"
#import "MenuViewController.h"
#import "RootViewController.h"
@interface HockeyViewController : UIViewController <GKPeerPickerControllerDelegate, GKSessionDelegate, HockeyTableViewDelegate> {
   RootViewController *rootViewController;
   MainView *mainView;
   GKPeerPickerController *picker;
   GKSession *session;
   ConnectionType connectionType;
}
@property (nonatomic, retain) GKSession *session;
@property (nonatomic, retain) GKPeerPickerController *picker;
@property (nonatomic, assign) RootViewController *rootViewController;
- (IBAction)showInfo;
- (IBAction)showMenu;
- (void)sendData;
- (void)showPeerPicker;
- (void)startNearby;
- (void)startHeadToHead;
@end

The method initializeComponents of HockeyTableView is called during the construction of the class. This method is responsible for the following:

- (void)initializeContents {

   self.multipleTouchEnabled = true;

   CGImageRef puckImg = [[UIImage imageWithContentsOfFile:[[NSBundle mainBundle]
      pathForResource:@"AmuckPuck" ofType:@"png"]] CGImage];
   puckLayer = [CALayer layer];
   puckLayer.frame = CGRectMake(0.0, 0.0, CGImageGetWidth(puckImg),
      CGImageGetHeight(puckImg));
   puckLayer.contents = (id)puckImg;
   puckLayer.anchorPoint = CGPointMake(0.5, 0.5);

   CGImageRef paddle1Img = [[UIImage imageWithContentsOfFile:[[NSBundle
      mainBundle] pathForResource:@"RedPaddle" ofType:@"png"]] CGImage];
   bottomPaddleLayer = [CALayer layer];
   bottomPaddleLayer.frame = CGRectMake(0.0, 0.0, CGImageGetWidth(paddle1Img),
      CGImageGetHeight(paddle1Img));
   bottomPaddleLayer.contents = (id)paddle1Img;
   bottomPaddleLayer.anchorPoint = CGPointMake(0.5, 0.57);

   CGImageRef paddle2Img = [[UIImage imageWithContentsOfFile:[[NSBundle
      mainBundle] pathForResource:@"BluePaddle" ofType:@"png"]] CGImage];
   topPaddleLayer = [CALayer layer];
   topPaddleLayer.frame = CGRectMake(0.0, 0.0, CGImageGetWidth(paddle2Img),
      CGImageGetHeight(paddle2Img));
   topPaddleLayer.contents = (id)paddle2Img;
   topPaddleLayer.anchorPoint = CGPointMake(0.5, 0.57);

   bottomPaddleData.paddleLocation = CGPointMake(160, 380);
   topPaddleData.paddleLocation = CGPointMake(160, 100);
   bottomPaddleData.puckLocation = CGPointMake(160, 250);
   bottomPaddleData.puckVelocity = CGPointMake(0, 0);

   // Set the background image

   CGImageRef bgImg = [[UIImage imageWithContentsOfFile:[[NSBundle mainBundle]
      pathForResource:@"stagebg" ofType:@"png"]] CGImage];
   self.layer.contents = (id)bgImg;

   // Add our sublayers
   [self.layer insertSublayer:puckLayer above:self.layer];
   [self.layer insertSublayer:bottomPaddleLayer above:self.layer];
   [self.layer insertSublayer:topPaddleLayer above:self.layer];

   // Prevent things from drawing outside our layer bounds
   self.layer.masksToBounds = YES;

   // add a label to display the score
   scoreLabel = [[UILabel alloc] initWithFrame:CGRectMake(10.0, 10.0, 150.0,
      25.0)];
   scoreLabel.textColor = [UIColor whiteColor];
   scoreLabel.backgroundColor = [UIColor clearColor];
   scoreLabel.font = [UIFont fontWithName:@"Arial" size:18];
   scoreLabel.alpha = 0.5;
   [self addSubview:scoreLabel];
   [self bringSubviewToFront:scoreLabel];

   // load images for messages
   goalImage = [UIImage imageNamed:@"Goal.png"];
   blueWinsImage = [UIImage imageNamed:@"BlueWins.png"];
   redWinsImage = [UIImage imageNamed:@"RedWins.png"];

}

Today it is fairly common for 2-D games to be powered by 3-D graphics. Graphics accelerators are equipped with powerful capabilities. They can blend, rotate, translate, and more without taxing the processor. Therefore, it makes more sense to use the 3-D accelerator to draw in 2-D than it does to try and manage the pixels by hand. In fact, all the views and animations we have used so far are built on top of an underlying 3-D engine.

Until now we have been using UIViews for all of our graphics needs. We could do the same for this game, but this is a great opportunity to pull back the layers a little and work directly with Core Animation. Core Animation is built directly on top of OpenGL ES, so we get the benefits of 3-D acceleration but without the full complexity of a 3-D environment.

If you have done game programming in the past, you may have used a game loop. It really makes sense for AmuckPuck to update the position of items in a game loop, especially the puck. In order to make this happen, we dropped down a level so we could work directly with CALayer objects. The methods startAnimation and stopAnimation manage an NSTimer object, which is the basis for our game loop. On each pulse of the timer, animateView is called, which in turn calls updateView and drawView:

- (void)startAnimation {
   animationTimer = [NSTimer scheduledTimerWithTimeInterval:ANIMATION_INTERVAL
      target:self selector:@selector(animateView) userInfo:nil repeats:YES];
}
- (void)stopAnimation {
    animationTimer = nil;
}
#pragma mark Animate Layers
- (void) animateView {
   [self updateView];
   [self drawView];
}

Separation of game logic into updateView and drawView was the goal of using CALayer objects and the NSTimer. This allows the application to manage positional data and game physics in the method updateView. Then we can code rendering and drawing separately in the method drawView.

Now inside the method drawView we can manually change the position of each CALayer. Remember that position, velocity, and rotation puck and paddles are managed in structures that are not part of the CALayer. In the updateView method, we update the position inside of the structures independent of the layers. When this is complete and drawView is called, we render the view by updating the CALayer objects with data from these structures inside of a CATransaction:

- (void)drawView {
   // Wrap these layer changes in a transaction and set the animation
   // duration to 0 so we don't get implicit animation
   [CATransaction begin];
   [CATransaction setValue:[NSNumber numberWithDouble:0.]
      forKey:kCATransactionAnimationDuration];

   // Position the paddle
   bottomPaddleLayer.position = bottomPaddleData.paddleLocation;
   topPaddleLayer.position = topPaddleData.paddleLocation;
   puckLayer.position = bottomPaddleData.puckLocation;
   puckLayer.transform = CATransform3DMakeRotation(bottomPaddleData.puckAngle,
      0., 0., 1.);

   if (messageView) {
      messageView.layer.transform = CATransform3DMakeRotation(messageRotation,
         0., 0., 1.);
   }

   [CATransaction commit];
}

Notice that in drawView we are updating the internal CALayer of the UIView messageView. This is an example of how the UIView and CALayer can work together. This is being implemented in this manner because it gives us a smooth rotation of the messageView that will continue over the course of two separate animations. We will show the rest of the message animation a little later in the chapter.

For a game like this, physics are necessary to emulate a realistic experience. Calculating believable physics can be a real challenge. The following methods are full of calculations, algorithms, and math, working hard to produce believable physics of the puck bouncing around on the hockey table:

- (void) updateView {

   if (connectionType != CLIENT_CONNECTION) {
      [self updatePuck];
   }

   // update the message rotation; this is only used if messageView
   // is visible;
   if (messageView) {
      messageRotation += 0.05;
      if (messageRotation > 100*3.24)
         messageRotation = messageRotation - (100*3.24);
   }
}

In the updateView method above, you see a call out to updatePuck. This method is really the meat of the physics engine. The function of each line in this method is not as easily discoverable as most of the others. To compensate, updatePuck is decorated with comments much more heavily than the norm (Listing 7.3).

- (void)updatePuck {

   // handle the puck hitting the paddle
   // Calculate the distance between the centers of the puck and the paddle
   double dist = distance(bottomPaddleData.puckLocation.x,
      bottomPaddleData.paddleLocation.x, bottomPaddleData.puckLocation.y,
      bottomPaddleData.paddleLocation.y);
   if (!bottomPaddleData.intersect & dist < (PADDLE_RADIUS + PUCK_RADIUS)) {
      // calculate a normal vector from the paddle to the puck
      CGPoint vector = normalVector(bottomPaddleData.puckLocation.x,
         bottomPaddleData.paddleLocation.x, bottomPaddleData.puckLocation.y,

         bottomPaddleData.paddleLocation.y);
      double speed = paddleSpeed(bottomPaddleData);
      vector.x = vector.x * speed;
      vector.y = vector.y * speed;
      // update the velocity of the puck
      bottomPaddleData.puckVelocity.x = vector.x;
      bottomPaddleData.puckVelocity.y = vector.y;
      bottomPaddleData.intersect = true;
   }
   else
      bottomPaddleData.intersect = false;

   dist = distance(bottomPaddleData.puckLocation.x,
      topPaddleData.paddleLocation.x, bottomPaddleData.puckLocation.y,
      topPaddleData.paddleLocation.y);
   if (!topPaddleData.intersect & dist < (PADDLE_RADIUS + PUCK_RADIUS)) {
      // calculate a normal vector from the paddle to the puck
      CGPoint vector = normalVector(bottomPaddleData.puckLocation.x,
         topPaddleData.paddleLocation.x, bottomPaddleData.puckLocation.y,
         topPaddleData.paddleLocation.y);
      double speed = paddleSpeed(topPaddleData);
      vector.x = vector.x * speed;
      vector.y = vector.y * speed;
      // update the velodity of the puck
      bottomPaddleData.puckVelocity.x = vector.x;
      bottomPaddleData.puckVelocity.y = vector.y;
      bottomPaddleData.intersect = true;
   }
   else
      bottomPaddleData.intersect = false;


   // decay the velocity of the puck
   if (bottomPaddleData.puckVelocity.x > 0.3)
      bottomPaddleData.puckVelocity.x += -PUCK_DECAY_RATE;
   else if (bottomPaddleData.puckVelocity.x < −0.3)
      bottomPaddleData.puckVelocity.x += PUCK_DECAY_RATE;

   if (bottomPaddleData.puckVelocity.y > 0.3)
      bottomPaddleData.puckVelocity.y += -PUCK_DECAY_RATE;
   else if (bottomPaddleData.puckVelocity.y < −0.3)
      bottomPaddleData.puckVelocity.y += PUCK_DECAY_RATE;

   // apply terminal velocity.
   // the puck should not be traveling so fast that it can pass
   // through the paddle without intersecting with it
   if (bottomPaddleData.puckVelocity.x > PADDLE_RADIUS)
      bottomPaddleData.puckVelocity.x = PADDLE_RADIUS;
   else if (bottomPaddleData.puckVelocity.x < -PADDLE_RADIUS)
      bottomPaddleData.puckVelocity.x = PADDLE_RADIUS;

   if (bottomPaddleData.puckVelocity.y > PADDLE_RADIUS)
      bottomPaddleData.puckVelocity.y = PADDLE_RADIUS;
   else if (bottomPaddleData.puckVelocity.y < -PADDLE_RADIUS)
      bottomPaddleData.puckVelocity.y = PADDLE_RADIUS;


   // decay the rotation of the puck
   if (bottomPaddleData.puckRotation > 0.001)
      bottomPaddleData.puckRotation += -PUCK_SPIN_DECAY_RATE;
   else if (bottomPaddleData.puckRotation < −0.001)
      bottomPaddleData.puckRotation += PUCK_SPIN_DECAY_RATE;

   // move the puck as prescribed by the rotation
   bottomPaddleData.puckAngle += bottomPaddleData.puckRotation;
   if (bottomPaddleData.puckAngle > 360.0)
      bottomPaddleData.puckAngle = bottomPaddleData.puckAngle - 360.0;

   // move the puck as prescribed by the velocity
   bottomPaddleData.puckLocation.x += bottomPaddleData.puckVelocity.x;
   bottomPaddleData.puckLocation.y += bottomPaddleData.puckVelocity.y;

   // bounce the puck off left and right walls
   if ((bottomPaddleData.puckLocation.x + PUCK_RADIUS) > 320) {
      // invert the velocity
      bottomPaddleData.puckVelocity.x = -bottomPaddleData.puckVelocity.x;
      // move the puck back inbounds before it is drawn
      bottomPaddleData.puckLocation.x = 320 - PUCK_RADIUS;
      // change the rotation of the puck according to the angle and speed
      // that it strikes the wall
      bottomPaddleData.puckRotation +=
         -(bottomPaddleData.puckVelocity.y * 0.005);
   }
   if ((bottomPaddleData.puckLocation.x - PUCK_RADIUS) < 0) {
      bottomPaddleData.puckVelocity.x = -bottomPaddleData.puckVelocity.x;
      bottomPaddleData.puckLocation.x = PUCK_RADIUS;
      bottomPaddleData.puckRotation +=
         (bottomPaddleData.puckVelocity.y * 0.005);
   }

   // bounce the puck off the top and bottom walls
   if (!messageView) {
      if ((bottomPaddleData.puckLocation.y + PUCK_RADIUS) > 480) {
         // let the puck go if it is headed through the goal
         if ((bottomPaddleData.puckLocation.x < GOAL_START)
            | (bottomPaddleData.puckLocation.x > GOAL_END)) {
            bottomPaddleData.puckVelocity.y = -bottomPaddleData.puckVelocity.y;
            bottomPaddleData.puckLocation.y = 480 -PUCK_RADIUS;
            bottomPaddleData.puckRotation +=
               (bottomPaddleData.puckVelocity.x * 0.005);
         }
         else {

            [self didScore:BOTTOM_PLAYER];
         }
      }
      if ((bottomPaddleData.puckLocation.y - PUCK_RADIUS) < 0) {
         if ((bottomPaddleData.puckLocation.x < GOAL_START)
            | (bottomPaddleData.puckLocation.x > GOAL_END)) {
            bottomPaddleData.puckVelocity.y = -bottomPaddleData.puckVelocity.y;
            bottomPaddleData.puckLocation.y = PUCK_RADIUS;
            bottomPaddleData.puckRotation +=
               -(bottomPaddleData.puckVelocity.x * 0.005);
         }
         else {
            [self didScore:TOP_PLAYER];
         }
      }
   }
}

You may have noticed the connectionType flag in some of the previous code listings. This is used to indicate the connection type of the application. In its current version, the application can be connected as follows:

In a head-to-head connection, updates to the puck and paddles are all handled and maintained on a single device. Also, Multi-Touch has to be enabled since two touches (one for each paddle) are observed at the same time. The top player is only updated locally in head-to-head connections (Listing 7.4).

- (void)updatePaddlesWithTouches:(NSSet *)touches {
   NSArray *allTouches = [touches allObjects];
   int count = [allTouches count];
   if (count > 0) {
      for (int i=0; i<count;i++) {
         UITouch *touch = [allTouches objectAtIndex:i];

         CGPoint touchPoint =  [touch locationInView:self];

         // if the touchPoint is out of bounds we need to correct it
         correctTouchPoint(&touchPoint);

         if (connectionType == HEADTOHEAD_CONNECTION &
            touchPoint.y < MAX_TOP_PLAYER_Y) {
            topPaddleData.paddleVelocity.x =
               touchPoint.x - topPaddleData.paddleLocation.x ;
            topPaddleData.paddleVelocity.y =
               touchPoint.y - topPaddleData.paddleLocation.y;
            topPaddleData.paddleLocation.x = touchPoint.x;
            topPaddleData.paddleLocation.y = touchPoint.y;
         }
         else if (touchPoint.y > MIN_BOTTOM_PLAYER_Y) {
            bottomPaddleData.paddleVelocity.x =
               touchPoint.x - bottomPaddleData.paddleLocation.x;
            bottomPaddleData.paddleVelocity.y =
               touchPoint.y - bottomPaddleData.paddleLocation.y;
            bottomPaddleData.paddleLocation.x = touchPoint.x;
            bottomPaddleData.paddleLocation.y = touchPoint.y;
         }
      }
   }
}
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
   [self updatePaddlesWithTouches:touches];
}

- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event {
   [self updatePaddlesWithTouches:touches];
}

- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event {
   [self updatePaddlesWithTouches:touches];
}

Another important thing to notice in the method updateView (repeated below) is that updatePuck is not called for client connections:

- (void) updateView {

   if (connectionType != CLIENT_CONNECTION) {
      [self updatePuck];
   }
   ...
}

In a peer-to-peer client connection, the top player is updated whenever data is received remotely from the method updatePuckData:

- (void)updatePuckData:(StateData)puckData {
   bottomPaddleData.puckLocation.x = 320 - puckData.puckLocation.x;
   bottomPaddleData.puckLocation.y = 480 - puckData.puckLocation.y;
   bottomPaddleData.puckRotation = puckData.puckRotation;
   bottomPaddleData.puckVelocity.x = 320 - puckData.puckVelocity.x;
   bottomPaddleData.puckVelocity.y = 480 - puckData.puckVelocity.y;
}

The previous method ultimately receives its data from a message sent from a peer-to-peer host. This way puck physics are calculated only on one of the two devices. The sendData and receiveData methods from HockeyViewController implement this functionality (Listing 7.5).

- (void)sendData {
   if (mainView.connectionType == HEADTOHEAD_CONNECTION) return;

   StateData paddleData = mainView.bottomPaddleData;
   NSData *data = [[NSData alloc] initWithBytes:&paddleData
      length:sizeof(StateData)];
   [session sendDataToAllPeers :data withDataMode:GKSendDataUnreliable
      error:nil];
}
- (void) receiveData:(NSData *)remoteData fromPeer:(NSString *)peer
   inSession: (GKSession *)session context:(void *)context {


   int messageType;
   [remoteData getBytes:&messageType length:sizeof(int)];
   if (messageType == 0) {
      StateData paddleData;
      [remoteData getBytes:&paddleData length:sizeof(StateData)];

      // Remote player should display on top so we need
      // to invert the values
      paddleData.paddleLocation.x = 320 - paddleData.paddleLocation.x;
      paddleData.paddleLocation.y = 480 - paddleData.paddleLocation.y;

      mainView.topPaddleData = paddleData;

      // if we are a client we need to copy puck data sent from the host
      if (mainView.connectionType == CLIENT_CONNECTION ) {
         [mainView updatePuckData:paddleData];

      }

      [self sendData];
   }
   else {
      EventData eventData;
      [remoteData getBytes:&eventData length:sizeof(EventData)];
      [mainView displayMessage:SCORE_MESSAGE forPlayer:TOP_PLAYER];
   }
}

Note that receiveData inverts the paddle and puck positions that are received from the peer. This way, in peer-to-peer connections, each player controls the paddle on the bottom of the screen.

Back in the HockeyTableView class, the method didScore is called whenever a player scores a goal. We list this method here to highlight the fact that it calls out to the delegate method hockeyTableDidScore conditionally, depending on connection type:

- (void)didScore:(PlayerCode)playerCode {

   if (messageView) return;

   if ((bottomPaddleData.puckLocation.y > 480 + PUCK_DIAMETER)
      | (bottomPaddleData.puckLocation.y < -PUCK_DIAMETER)) {
      bottomPaddleData.puckVelocity.x = 0;
      bottomPaddleData.puckVelocity.y = 0;
      [self displayMessage:SCORE_MESSAGE forPlayer:playerCode];
      if (connectionType == HOST_CONNECTION) {
         [delegate hockeyTableDidScore:playerCode];
      }
   }
}

This method is needed because all puck movements are calculated on the host in peer-to-peer and the client never knows when the player scores. Calling out to this delegate sends the appropriate message to the client, as seen in the following method hockeyTableDidScore from HockeyViewController:

- (void)hockeyTableDidScore:(PlayerCode)playerCode {
   EventData eventData;
   eventData.packetType = 1;
   NSData *dataPacket = [[NSData alloc] initWithBytes:&eventData
      length:sizeof(EventData)];
   [session sendDataToAllPeers:dataPacket withDataMode:GKSendDataReliable
      error:nil];
}

Earlier in the chapter we discussed how each client is notified when a goal is made. When a player does score, we added a circular "Goal" message that zooms in and out of view while rotating (Figure 7.19).

Figure 7.19. An animated message is displayed after a goal is scored.

A call to displayMessage starts this animation and plays it all the way through. If you run the app you will see that the message zooms out from the center and then pauses for a second. After the pause, the message expands and fades until it is no longer visible:

- (void)displayMessage:(MessageCode)messageCode forPlayer:(PlayerCode)playerCode {

   UIImage *messageImage = goalImage;
   if (messageCode == WIN_MESSAGE) {
      if (messageCode == BOTTOM_PLAYER)
         messageImage = connectionType =
            CLIENT_CONNECTION ? redWinsImage : blueWinsImage;
      else if (messageCode == TOP_PLAYER)
         messageImage = connectionType =
            CLIENT_CONNECTION ? blueWinsImage : redWinsImage;
   }

   messageView = [[UIImageView alloc] initWithImage:messageImage];
   [goalImage release];
   messageView.alpha = 0.0;
   messageView.frame = CGRectMake(self.center.x, self.center.y, 0.0, 0.0);

   [self addSubview:messageView];
   [self bringSubviewToFront:messageView];

   [UIView beginAnimations:nil context:messageView];
   [UIView setAnimationDuration:0.75];
   [UIView setAnimationCurve:UIViewAnimationCurveLinear];
   [messageView setAlpha:0.5];
   messageView.frame = CGRectMake(self.center.x-150.0, self.center.y-150.0,
      300.0, 300.0);
   messageView.tag = 0;
   [UIView setAnimationDelegate:self];
   [UIView setAnimationDidStopSelector:
      @selector(animateMessageDidStop:finished:context:) ];
   [UIView commitAnimations];
}

By having one animation begin after another ends, we create a nice effect for the game. This is accomplished by assigning animateMessageDidStop as the selector in the call to the setAnimationDidStopSelector method above. Notice that animateMessageDidStop also points its selector back to itself, which provides a nice place to do some cleanup:

- (void)animateMessageDidStop:(NSString *)animationID finished:
   (NSNumber *)finished context:(void *)context {
   if (messageView.tag == 1) {
      bottomPaddleData.puckLocation = CGPointMake(160, 250);
      bottomPaddleData.puckVelocity = CGPointMake(0, 0);
      [messageView release];
      messageView = nil;
      return;
   }
   [UIView beginAnimations:nil context:messageView];
   [UIView setAnimationDelay:2.0];

   [UIView setAnimationDuration:0.75];
   [UIView setAnimationCurve:UIViewAnimationCurveLinear];
   [messageView setAlpha:0.0];
   messageView.frame = CGRectMake(self.center.x-750.0, self.center.y-750.0,
      1500.0, 1500.0);
   messageView.tag = 1;
   [UIView setAnimationDelegate:self];
   [UIView setAnimationDidStopSelector:
      @selector(animateMessageDidStop:finished:context:) ];
   [UIView commitAnimations];
}

During the entire animation, the message is rotated. The rotation is applied to the CALayer of the UIImageView in the drawMethod you saw earlier:

if (messageView) {
   messageView.layer.transform = CATransform3DMakeRotation(messageRotation,
      0., 0., 1.);
}

A handful of helper methods are used to abstract out some of the common logic needed throughout the previous code listings. They are listed here to help connect the last dots of the code in HockeyTableView. Listing 7.6 returns a normal vector between x1, y1, and x2; y2 is used to represent direction. It then returns the distance between two points, calculates the speed of the paddle, and prevents the paddle from sliding past its boundary.

CGPoint normalVector(double x1, double x2, double y1, double y2) {
   double run = x1 - x2;
   double rise = y1 - y2;
   double total = abs(rise) + abs(run);
   CGPoint vector;
   vector.x = run / total;
   vector.y = rise / total;
   return vector;
}
double distance(double x1, double x2, double y1, double y2) {
   return sqrt(pow(x1 -x2, 2) + pow(y1 - y2, 2));
}
double paddleSpeed(StateData stateData) {
   double speed = sqrt(pow(stateData.paddleVelocity.x, 2)
      + pow(stateData.paddleVelocity.y, 2));
   speed = abs(speed * PADDLE_STRIKE);
   if (speed > MAX_PADDLE_STRIKE)
      return MAX_PADDLE_STRIKE;

   if (speed < MIN_PADDLE_STRIKE)
      return MIN_PADDLE_STRIKE;
   return speed;
}
void correctTouchPoint(CGPoint *touchPoint) {
   if ((*touchPoint).x - PADDLE_RADIUS < 0)
      (*touchPoint).x = PADDLE_RADIUS;
   if ((*touchPoint).x + PADDLE_RADIUS > 320)
      (*touchPoint).x = 320 - PADDLE_RADIUS;
   if ((*touchPoint).y - PADDLE_RADIUS < 0)
      (*touchPoint).y = PADDLE_RADIUS;
   if ((*touchPoint).y + PADDLE_RADIUS > 480)
      (*touchPoint).y = 480 - PADDLE_RADIUS;
}
@end

The methods connectionType and startNearby are straightforward but noteworthy. When a player selects a game type from the menu, these methods are called to record connectionType internally. Peer-to-peer connections start as a host connection and then one peer switches to the client during the connection process:

- (void)startNearby {
   connectionType = HOST_CONNECTION;
}
- (void)startHeadToHead {
   connectionType = HEADTOHEAD_CONNECTION;
}

The receiveData method is called by your GKSession whenever data is received from a peer. This method was listed in the preceding code to demonstrate how paddle data is sent to the client in a peer-to-peer connection. When looking at it this time, notice how you can discover the message type by partially reading into the data stream. This is very useful since the message containing StateData is sent unreliably and the message containg MessageData is sent reliably:

- (void) receiveData:(NSData *)remoteData fromPeer:(NSString *)peer
   inSession: (GKSession *)session context:(void *)context {

   int messageType;
   [remoteData getBytes:&messageType length:sizeof(int)];
   if (messageType == 0) {
      StateData paddleData;

      [remoteData getBytes:&paddleData length:sizeof(StateData)];

      // Remote player should display on top so we need
      // to invert the values
      paddleData.paddleLocation.x = 320 - paddleData.paddleLocation.x;
      paddleData.paddleLocation.y = 480 - paddleData.paddleLocation.y;

      mainView.topPaddleData = paddleData;

      // if we are a client we need to copy puck data sent from the host
      if (mainView.connectionType == CLIENT_CONNECTION ) {
         [mainView updatePuckData:paddleData];
      }

      [self sendData];
   }
   else {
      EventData eventData;
      [remoteData getBytes:&eventData length:sizeof(EventData)];
      [mainView displayMessage:SCORE_MESSAGE forPlayer:TOP_PLAYER];
   }
}

Calling hockeyTableDidScore and showPeerPicker sends out the data we just saw being received in the method receiveData from the preceeding code:

- (void)hockeyTableDidScore:(PlayerCode)playerCode {
   EventData eventData;
   eventData.packetType = 1;
   NSData *dataPacket = [[NSData alloc] initWithBytes:&eventData
      length:sizeof(EventData)];
   [session sendDataToAllPeers:dataPacket withDataMode:GKSendDataReliable
      error:nil];
}
- (void)sendData {
   if (mainView.connectionType == HEADTOHEAD_CONNECTION) return;

   StateData paddleData = mainView.bottomPaddleData;
   NSData *data = [[NSData alloc] initWithBytes:&paddleData
      length:sizeof(StateData)];
   [session sendDataToAllPeers :data withDataMode:GKSendDataUnreliable
      error:nil];
}

The following code to connect peers is almost identical to that in P2P Chat. However, one very important step stands out. The method session: didReceiveConnectionRequestFromPeer is used to make the distinction that we are the client if it is called (Listing 7.7).

- (void)showPeerPicker {
   // allocate and setup the peer picker controller
   picker  = [[GKPeerPickerController alloc] init];
   picker.delegate = self;
   picker.connectionTypesMask = GKPeerPickerConnectionTypeNearby;
   [picker show];
}
- (void)peerPickerController:(GKPeerPickerController *)picker
      didSelectConnectionType:(GKPeerPickerConnectionType)type {
    if(type == GKPeerPickerConnectionTypeOnline) {
   }
}
- (GKSession *) peerPickerController:(GKPeerPickerController *)picker
   sessionForConnectionType:(GKPeerPickerConnectionType)type {
   session = [[GKSession alloc] initWithSessionID:
      @"com.yourwebsite.yourapplicationname" displayName:nil
      sessionMode:GKSessionModePeer];
   session.delegate = self;
   return session;
}
- (void)peerPickerController:(GKPeerPickerController *)picker
   didConnectToPeer:(NSString *)peerID {
   [self.picker dismiss];
}
- (void)peerPickerControllerDidCancel:(GKPeerPickerController *)picker {
   [self.picker dismiss];
   [self.rootViewController showMenu];
}
- (void)session:(GKSession *)session
   didReceiveConnectionRequestFromPeer:(NSString *)peerID {
   connectionType = CLIENT_CONNECTION;
   mainView.connectionType = CLIENT_CONNECTION;
}
- (void)session:(GKSession *)session peer:(NSString *)peerID
   didChangeState:(GKPeerConnectionState)state {
   switch (state) {
      case GKPeerStateConnected:
         [self.session setDataReceiveHandler :self withContext:nil];
         [self.picker dismiss];
         [self sendData];
         break;
      case GKPeerStateDisconnected:
         break;
   }
}
@end