I received my DICE+ developer kit a couple weeks ago and was excited to get to testing. What is DICE+? DICE+ is a bluetooth connected, smart, 6 sided die that is made out of materials safe to roll directly on your devices. It has a 20hr battery which powers a bunch of cool sensors like accelerometers, magnetic field sensor, touch sensitive faces, and a few more. The built in anti-cheat protection makes sure each roll is fair, and each face can display a wide range of colors due to the red, green and blue LEDs backlighting every side. Balanced to match any standard 6 sided die performance, the DICE+ brings back some of the tactile fun of playing games on digital devices. Although not quite out on the market as of this writing, developers can download the SDK, order kits and start developing. The developers over at DICE+ have also set aside a kit to give away to one of the readers of this post. The first 6 readers who reply to this post and correctly lists all sensors available, will be entered in the drawing. A DICE+ will then be rolled, a winner selected from those replies and sent one of the DICE+ developer kits. Now that I have had some fun, I thought I would share, and show how easy it was to use.

In the following tutorial, I have designed a simple 2 player game in which you are trying to be the first player to get your ship into space. Each player takes a turn rolling the die, the first player to reach 25 is the winner. With the addition of some simple UIView animations to animate our player ships and space background, the race to space can begin. Link to project file and assets are at the end of this post.

First lets create a new, single view, portrait oriented project for iPad called ‘RaceToSpace’ using ARC (Automatic Reference Counting).  After downloading the DICE+ SDK from the website, drag and drop the framework into your project, add the ‘CoreBluetooth’, and QuartzCore frameworks. For DICE+, You will also have to add ‘-all_load’ to your projects build settings, under other linker commands. In Interface Builder, add a UIImageView to your view, setting its size and origin to the following x=0, y=-1024, width=768 and height=2048. Press your editors double column view button, and while holding the control button, left mouse click the newly added UIImageView and link to your .h file creating an IBOutlet reference called ‘spaceBackground’. Add a Play button to start the game, a label at the bottom to show bluetooth connection info and turn status, and 2 labels at the top for displaying player scores. Link all of these to your .h file as you did with the space background UIImageView, using these corresponding names; playButton, status, player1Score, player2Score. You will also need to right click on the PLAYBUTTON, and link the ‘touch up inside’ action onto your ViewController.m file and name it ‘Play’. Now that the basic building blocks are setup, we can get to configuring the software for use with your die.

In your ViewController .h, add the following code to match.

 
#import <UIKit/UIKit.h>
#import <DicePlus/DicePlus.h>
#import "Player.h"

@interface ViewController : UIViewController <DPDiceManagerDelegate>
{
    DPDiceManager* diceManager;
    DPDie* availableDie;
    DPDie* connectedDie;
}
@property (weak, nonatomic) IBOutlet UILabel *player1Score;
@property (weak, nonatomic) IBOutlet UILabel *player2Score;
@property (weak, nonatomic) IBOutlet UIImageView *spaceBackground;
@property (weak, nonatomic) IBOutlet UILabel *status;
@property (nonatomic, retain) NSArray *players;
@property (nonatomic, retain) Player *currentPlayer;
@property (weak, nonatomic) IBOutlet UIButton *play;

@end

In your ViewController.m, add the following code to your viewDidLoad method. This initializes the dice manager, sets the DEV KEY with the [diceManager startScanning] command, and starts scanning for available devices. Also add the #define MaxPoints 25. This defines the winning score.

 
#define MaxPoints 25

@implementation ViewController

- (void)viewDidLoad
{
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.

    if (connectedDie != nil) {
        return;
    }
    availableDie = nil;
    diceManager = [DPDiceManager sharedDiceManager];
    diceManager.delegate = self;

    //DICE+ generic development key.
    uint8_t key[8] = {0x83, 0xed, 0x60, 0x0e, 0x5d, 0x31, 0x8f, 0xe7};
    [diceManager setKey:key];

    //Start scanning for an available DICE+.
    [diceManager startScan];
    self.status.text = @"Searching for DICE+...";
}

If you notice the error pertaining to the #import Player.h and the player object, we will be adding that in a moment so you can ignore that for now. We do need to add some delegate calls so we can be notified of a DICE+ connection, and some to receive results when the die is rolled. I will also explain in detail the contained code when we walk thru the functionality of the game.

 
- (void)die:(DPDie *)die didRoll:(DPRoll *)roll error:(NSError *)error
{
    //Roll was valid
    if (roll.flags == DPRollFlagOK) {
        //Stop roll updates just to make sure wrong player doesnt mistakenly roll DICE+.
        [connectedDie stopRollUpdates];
        //Convert roll result (1-6) to binary mask equivalent
        int mask = 1 << (roll.result-1);
        //Blink the top face green showing roll result. DICE+ uses a binary mask for determinning which face, or faces to light.
        [connectedDie startBlinkAnimationWithMask:mask priority:0 r:0 g:255 b:0 onPeriod:100 cyclePeriod:50 blinkCount:5];
        //Move player ship
        [self moveCurrentPlayer:roll.result];

    } else if (roll.flags == DPRollFlagTilt) {
        //DICE+ roll error
        self.status.text = @"Roll Tilted";
        //Blink DICE+ faces red to indicate a roll error occured.
        [connectedDie startBlinkAnimationWithMask:63
                                         priority:1
                                                r:255
                                                g:0
                                                b:0
                                         onPeriod:100
                                      cyclePeriod:200
                                       blinkCount:4];
    } else if (roll.flags == DPRollFlagTooShort) {
        //DICE+ roll error
        self.status.text = @"Roll too short";
        //Blink dice plus faces red to indicate a roll error occured.
        [connectedDie startBlinkAnimationWithMask:63
                                         priority:1
                                                r:255
                                                g:0
                                                b:0
                                         onPeriod:100
                                      cyclePeriod:200
                                       blinkCount:4];
    }
}

#pragma mark - DPDiceManagerDelegate methods
- (void)centralManagerDidUpdateState:(CBCentralManagerState)state
{
    // See CBCentralManagerDelegate documentation for info about CBCentralManager state changes
}

- (void)diceManagerStoppedScan:(DPDiceManager *)manager
{
    //Scanning has stopped, restart scan if no available die was found.
    if (availableDie == nil) {
        [diceManager startScan];
        self.status.text = @"Searching for DICE+...";
    }
}

- (void)diceManager:(DPDiceManager *)manager didDiscoverDie:(DPDie *)die
{
    //A DICE+ die was found, not connected yet.
    availableDie = die;
    availableDie.delegate = (id)self;

    [diceManager stopScan];
    //Attempt to connect to available DICE+ found.
    [diceManager connectDie:availableDie];

    self.status.text = @"Connecting DICE+...";
}

- (void)diceManager:(DPDiceManager *)manager didConnectDie:(DPDie *)die
{
    //Available DICE+ connected and is ready for play.
    availableDie = nil;
    connectedDie = die;
    connectedDie.delegate = (id)self;
    self.status.text = @"Press play to begin.";
}

- (void)diceManager:(DPDiceManager *)manager failedConnectingDie:(DPDie *)die error:(NSError *)error
{
    //DICE+ failed connection attempt.
    availableDie = nil;
    connectedDie = nil;
    self.status.text = @"Connection failed... Searching...";

    [diceManager startScan];
}

- (void)diceManager:(DPDiceManager *)manager didDisconnectDie:(DPDie *)die error:(NSError *)error
{
    //DICE+ disconnected
    availableDie = nil;
    connectedDie = nil;
    self.status.text = @"Die disconnected... Searching...";

    [diceManager startScan];
}

- (void)dieFailedAuthorization:(DPDie *)die error:(NSError *)error
{
    //DICE+ authorization failed.
    self.status.text = @"Failed authorization";
}

The DICE+ is well documented and there are quite a few delegate methods that can be used depending on which sensor you issue a startUpdate too.

We’ll go back to the functions of the game a little later on in the post, for now lets look at whats happening when connecting to the die.

After the app has started scanning for an active die and one has been found, the dice manager delegate , didDiscoverDie, will be called and the scanning is stopped using [diceManager stopScan]. Since we don’t know that we can successfully connect to the die, only that one is available, we store the returned found die as availableDie, then attempt a connection with it. If no available dice were found and the scanner times out (after 12 seconds), diceManagerStoppedScan: will get called. In our example we simply restart the scanning process and scan again.

Upon a successfull connection, dice manager didConnectDie delegate method is called. Since we want to differentiate between an available die and our successfully connected die, connectedDie is assigned and used for the rest of the games life cycle, and availableDie is nilled out. If for some reason there is an issue connecting to the available die, ‘failedConnectingDie:’ is called. If a die is connected and looses that connection for some reason, the diceManager ‘didDisconnectDie:’ is called. In this example a scan is started again to try and regain a connection.

Once we have a connected die, it is easy to start the various sensor updates and listen for their delegate calls. For this game, we will only worry about [connectedDie startRollUpdates], [connectedDie stopRollUpdates], and the corresponding delegate methods to receive the roll response once a valid roll is done.

- (void)die:(DPDie *)die didRoll:(DPRoll *)roll error:(NSError *)error

The value of the roll is returned in roll.result with roll state in roll.flag that gives information about the roll itself. DPRollFlagOK is returned with a valid roll, DPRollFlagTilt is returned if the die has landed on a tilt, and DPRollFlagTooShort if not enough time was taken to make the roll. These flags are part of the anti cheat error checking done within the die.

As we add the functionality of the game, you will also see how easy it is to change and animate the LEDs for each face once a roll is completed, or for any other reason you may need.

For the actual gameplay we will be adding 6 new methods but first we need to create a player object to represent each of our 2 players. Right click on the RaceToSpace folder in the left hand, project navigator pane and select new file. Create a new subclass of NSObject and name it Player.

Add the following to the Player.h,

@interface Player : NSObject

@property(nonatomic, retain) UIImage *shipImage;
@property(nonatomic) NSInteger score;
@property(nonatomic) NSInteger playerNumber;

- (id)initWithImage:(UIImage *)shipImage;

@end

and this to your Player.m,

- (id)initWithImage:(UIImage *)shipImage;
{
    self = [super init];
    if (self) {
        // Initialization code
        self.shipImage = shipImage;
        self.score = 0;
    }
    return self;
}

Now we need to create the 2 players, do this at the beginning of your viewDidLoad, just after the call to super. Each player is created and assigned a player number, a UIImageView is also created to display the players ship, placed at their start positions on the screen and added to the view. By setting the tag of each of these UIImageViews to the players number, we can be sure to move the correct ship for the player. Initialize our player reference NSArray with both of our players..

 
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
    //Setup Player 1
    Player *player1 = [[Player alloc] initWithImage:[UIImage imageNamed:@"rocketShip1"]];
    player1.playerNumber = 1;
    UIImageView *player1ship = [[UIImageView alloc] initWithFrame:CGRectMake(0, 0, 64, 113)];
    player1ship.contentMode = UIViewContentModeCenter;
    player1ship.image = player1.shipImage;
    player1ship.center = CGPointMake(192, 928);
    player1ship.tag = player1.playerNumber;
    [self.view addSubview:player1ship];

    //Setup Player 2
    Player *player2 = [[Player alloc] initWithImage:[UIImage imageNamed:@"rocketShip2"]];
    player2.playerNumber = 2;
    UIImageView *player2ship = [[UIImageView alloc] initWithFrame:CGRectMake(0, 0, 64, 113)];
    player2ship.contentMode = UIViewContentModeCenter;
    player2ship.image = player2.shipImage;
    player2ship.center = CGPointMake(576, 928);
    player2ship.tag = player2.playerNumber;
    [self.view addSubview:player2ship];

Add some code to our Play button action and add these remaining methods to you ViewController.m and we will take a quick walk thru of the game.

- (IBAction)play:(id)sender
{
    //Rest players score to 0 in case this is a replay.
    self.play.hidden = YES;
    [self setupPlayer];
}

- (void)setupPlayer
{
    if (!self.currentPlayer){
        //Its a new game, make current player, player 1.
        self.currentPlayer = [self.players objectAtIndex:0];
    } else {
            //Switch between players
            if (self.currentPlayer.playerNumber == 1){
                //Make current player, player 2.
                self.currentPlayer = [self.players objectAtIndex:1];
            } else {
                //Make current player, player 1.
                self.currentPlayer = [self.players objectAtIndex:0];
            }
        }
    self.status.text = [NSString stringWithFormat:@"Player %i's turn", self.currentPlayer.playerNumber];

    //Start DICE+ roll updates for current player.
    [connectedDie startRollUpdates];
}

- (void)prepareForNewGame
{
    //Set player scores to 0 and reset ships to start position.
    for (Player *p in self.players){
        p.score = 0;
        UIImageView *playerShip = (UIImageView *)[self.view viewWithTag:p.playerNumber];
        playerShip.center = CGPointMake(playerShip.center.x, 928);
    }

    //Reset some labels
    self.play.hidden = NO;
    self.player1Score.text = @"0 points";
    self.player2Score.text = @"0 points";
    self.status.text = @"Press play to begin.";

    //Animate background back to start position
    [UIView animateWithDuration:.25 animations:^{
        self.spaceBackground.center = CGPointMake(384, 0);
    }];

    //Set current player to nil so new game will start with player 1.
    self.currentPlayer = nil;
}

- (BOOL)currentPlayerIsWinner
{
    //check if current player has matched, or exceeded max points
    if (self.currentPlayer.score >= MaxPoints){
        return YES;
    }
    return NO;
}

- (void)moveCurrentPlayer:(NSInteger)rollValue
{
    //Get UIImageView for players ship and animate p the screen.
    UIImageView *playerShip = (UIImageView *)[self.view viewWithTag:self.currentPlayer.playerNumber];

    //Calculate appropriate distance to travel based on MaxPoints, so winner is always near top of screen.
    int offset = (1024 - rintf(1024/6))/MaxPoints;
    int distance = rollValue * offset;
    self.currentPlayer.score = self.currentPlayer.score + rollValue;

    if ([self currentPlayerIsWinner]) {
        //Current player has won. Do something.
        NSString *winnerText = [NSString stringWithFormat:@"Congratulations player %i, you are the Winner!", self.currentPlayer.playerNumber];
        UIAlertView *winnerNotify = [[UIAlertView alloc] initWithTitle:@"WINNER!!" message:winnerText delegate:self cancelButtonTitle:@"OK" otherButtonTitles: nil];
        [winnerNotify show];
        self.status.text = @"We have a WINNER!";

        //Fly the winning ship the rest of the way off the screen.
        [UIView animateWithDuration:1 animations:^{
            playerShip.center = CGPointMake(playerShip.center.x, -200);
        }];
        return;
    } else {
        [UIView animateWithDuration:1 animations:^{
            playerShip.center = CGPointMake(playerShip.center.x, playerShip.center.y - distance);
        }];
        if (self.currentPlayer.playerNumber == 2){
            self.player2Score.text = [NSString stringWithFormat:@"%i points", self.currentPlayer.score];
            [self slideBackground:distance];
        } else {
            self.player1Score.text = [NSString stringWithFormat:@"%i points", self.currentPlayer.score];
            [self setupPlayer];
        }
    }
}

- (void)slideBackground:(NSInteger)distance
{
    //Check if background is able to scroll any further, if so scroll up distace value.
    if (self.spaceBackground.center.y + distance < 1024){
        [UIView animateWithDuration:3 delay:0 options:UIViewAnimationOptionCurveEaseInOut animations:^{
            self.spaceBackground.center = CGPointMake(384, self.spaceBackground.center.y + distance);
        } completion:^(BOOL finished) {
            //Setup next player when animation is done.
            [self setupPlayer];
        }];
    }
}

When the play button is pressed and the - (IBAction)play:(id)sender callback is called, the play button is hidden and [self setupPlayer] is called. SetupPlayer, checks to see if self.currentPlayer uninitialized, if so then it represents a new game and currentPlayer is assigned as Player1 from index 0 of the Players reference array. We set the text of our connection status label to state that it is player 1’s turn and the DICE+ roll updates are started with [connectedDie startRollUpdates]; The game is now waiting for player 1 to roll. Once a valid roll is made, the die: didRoll: delegate method is called. With a successful roll.flag of DPRollFlagOK a few things happen. Dependent on the value of roll.result, an int called mask is set to a specific value. This mask value is how we tell the DICE+ which face or faces to light up.

A quick explanation of the  mask value. If you think of a 6 bit binary number, adding each decimal value of the bits (or faces) you want lit up, this total number is the mask. For example if I wanted the number 2 face to light,

1    2    3    4    5    6  (face)

1    2    4    8    16  32  (decimal value)

0    1    0    0    0    0  (binary mask)

Number for the mask would be 2.

If you wanted faces 1, 2 and 3 to light up, the mask would be,

1    2    3    4    5    6  (face)

1    2    4    8    16  32  (decimal value)

1    1    1     0    0    0  (binary mask)

Number for mask would be 6.

All faces would be represented by the number 63.

We can pass this mask, as well as color and various other info to the die in a couple of different methods used to blink and fade the lights on and off. In our game, when a roll is invalid (either tilted or too short), an animation is used to blink all the faces red for a short time. Upon a valid roll, the face of the rolled value is blinked green.

After a successful roll, the roll updates of the die are stopped, this may not be necessary but may stop any accidental rolls and turn changes. [self moveCurrentPlayer:roll.result] is then called, passing along the rolled die value. This value is used in moveCurrentPlayer to move the current players ship up the screen (players UIImageView is found in the view by its tag), added to their current score and checks to see if the current player is the winner [self currentPlayerIsWinner] and returns a TRUE/FALSE. If the current player is not the winner, the game continues to the next step. If this is player2, then the background image is slid down the screen an appropriate amount in [self slideBackground:roll.result] using a simple UIView animation. Whether the background needed sliding or not, the next step is [self setupPlayer].

[self setupPlayer] determines that the currentPlayer is valid, checks the player’s number of the current player, and switches current player to the other player, roll updates are started once again and the next player can take their turn. In [self moveCurrentPlayer] once a player reaches, or passes, 25 (as defined at the top of ViewController.m in MaxPoints) that triggers the winning phase. One slight addition to add to our game is to show a UIAlertView when a player wins and inform us when it is dismissed so we can reset the game.

Add to your ViewController.h so we can know when the user dismisses the winning text and delegate call for the alertView,

@interface ViewController : UIViewController <DPDiceManagerDelegate, UIAlertViewDelegate>

and the following in your ViewController.m so we know when it is dismissed.

- (void)alertView:(UIAlertView *)alertView didDismissWithButtonIndex:(NSInteger)buttonIndex
{
    //Once cancel is pressed on the alertview, prepare for new game.
    [self prepareForNewGame];
}

On a winning score the UIAlertView is displayed, status text is updated and the winning ship is flown the rest of the way of the screen. When the player dismisses the UIAlertView popup, [self prepareForNewGame] is called. Within that method, variables are reset, ships are set back to their starting positions and currentPlayer is set to nil. With a press of the Play button once again, the game play can start again.

I realize a lot more could be added, more in-depth animations could be done and special instances such as rolling the same number twice in a row to initiate special rules but since this was more about attaching and using the DICE+, I will leave those upgrades and additions to you. Hope you enjoyed this tutorial, I have enjoyed getting to test out this new product and look forward to what may come of it. Thanks.

Here is the link to the images used in the game, and here is a link to the GitHub repository. In order to ensure the latest SDK, you will need to download the DICE+ SDK (the version of the SDK depends on the firmware loaded on the Die) separately, and drag the DicePlus.framework file into the project.

Hey guys. So usually the posts we put up here involve screencasts and presentations, but we are going to start also posting small less time consuming pieces for the site. Today I bring to you a small project involving NSTimers. Today we are going to build an app that represents a horse race. We will create a view with 6 small UIView squares with a blue background at the bottom of the screen, we will use a timer to move a random one of them forward a random amount of distance. Let’s get started!

Source

You can get the source here: NSTimerDemo

Steps

Step 1

Create a view based application in xCode. Call it whatever.

Step 2

In your view controller class header file add:

NSTimer *myTimer;

Step 3

In your view controller class, uncomment out the viewDidLoad method and fill in the following code:

- (void)viewDidLoad
{
      [super viewDidLoad];
 
      CGRect workingFrame;
      workingFrame.origin.x = 15;
      workingFrame.origin.y = 400;
      workingFrame.size.width = 40;
      workingFrame.size.height = 40;
 
      for(int i = 0; i < 6; i++)
      {
           UIView *myView = [[UIView alloc] initWithFrame:workingFrame];
           [myView setTag:i];
           [myView setBackgroundColor:[UIColor blueColor]];
 
           workingFrame.origin.x = workingFrame.origin.x + workingFrame.size.width + 10;
           [self.view addSubview:myView];
      }
 
      myTimer = [NSTimer scheduledTimerWithTimeInterval:.1 target:self selector:@selector(moveACar) userInfo:nil repeats:YES];
  }

Step 4

In your view controller class, add the following method:

-(void)moveACar
{
      int r = rand() % 6;
      NSLog(@"My number is %d", r);
 
      for(UIView *aView in [self.view subviews])
      {
           if([aView tag] == r)
           {
                int movement = rand() % 100;
                CGRect workingFrame = aView.frame;
                workingFrame.origin.y = workingFrame.origin.y - movement;
 
                [UIView beginAnimations:nil context:NULL];
                [UIView setAnimationDuration:.2];
                [aView setFrame:workingFrame];
                [UIView commitAnimations];
 
                if(workingFrame.origin.y < 0)
                {
                    [myTimer invalidate];
                }
           }
      }
}

Conclusion

So that is it. Timers are really cool and come in handy for all sorts of small problems in a project. Happy coding.

EyeCue has received tremendous amount of success since its original launch. We have had thousands of downloads on the daily basis. Unfortunately, quite a few users experienced crashes due to the compatibility issues in iPhone SDK 2.1 and iPhone SDK 2.2.

In an effort the combat the incompatibility issue, we’ve recompiled the code and re-released the new and updated version in iTunes.

I have even made a video for it. Check it out here

Get your copy here

Giddy up!

User Interaction

The first thing we will implement is user interaction. All we really want to do is move the paddle’s X location to the X location of the touch from the user. This will be a very simple implementation and could be much better (I will add this as a challenge at the bottom of the tutorial). Open iTennisViewController.m and add the following code.

Just as we did in a previous tutorial, we are overriding the touchesMoved method. This will detect when the user “drags” their finger on the screen. First, I added the “else if” statement inside of touchesBegan that simply forwards all events to touchesMoved if the game is in a running state.

The first 2 lines inside of touchesMoved simply detect the location of the user’s touch. Next, we need to create a new CGPoint from the X location of the touch and the Y location of the yellow racquet (player racquet). Objective-C won’t simply let us say racquet_yellow.center.x = location.x. This is probably because CGPoint is immutable (not editable).

Finally, the center of the player’s racquet is set to our new location.

Collision Detection

*Update, the user Naren has pointed out a much simpler collision detection. The code has been updated to reflect it. Inside the gameLoop method of iTennisViewController.m add the following code

So, Apple has provided us with a very handy methods to check if to object frames collide. Its called CGRectIntersectsRect. We simply hand this method the frame of our ball and racquet. When the ball collides with the racquet, we want to reverse its Y velocity. The next if statement is required because sometimes we get in a state where the ball gets “trapped” on a paddle bouncing back and for and not going anywhere. So, we want to ensure the ball’s velocity only gets reversed if it is front of each racquet. (Note, the NSlog is not needed, it was just for debugging)

Simple Game AI

Next, we are going to discuss how simple AI can be added to allow a computer player to play iTennis with you. Many of you might not know just how much is involved in a decent Artificial intelligence. I could go on and on with nerdy math, philosophy, heuristics and the like, but I’m not. I will show you some super NOOB, very easy to understand game AI. Basically, the computer will “watch” the ball and move in the direction of it in hopes of hitting it. Let’s get started…

We first need to define a constant that will define how fast the computer player can move. Add the following define to the top of iTennisViewController.m

As you start testing, you can adjust this number. This is basically defining how fast the computer player can move in order to get to the ball. The higher you make this number, the “better” the computer player will be. You could actually make your computer unbeatable if this number were high enough. Now, add the following code right under your collision detection code:

The first “if” statement is to add some difficulty for the computer. It basically checks to see if the ball is on “his” side of the court. The computer will not move or respond to the ball unless it’s on his side. It could be omitted, but makes for a more interesting game. The next if statements check to see if the X coordinates of the center of the ball are different than the X coordinates of the center of the racquet. If the ball is to the right of the computer’s racquet, the X coordinate of the computer’s racquet is increased by kCompMoveSpeed. If the ball is to the left of the computer’s racquet, the X coordinate of the computer’s racquet is decreased by kCompMoveSpeed.

It should now be clear how adjusting the kCompMoveSpeed variable, will affect the computer’s performance…

Now, you can actually hit Build and Go to see the game in action. As you can see the computer responds to the ball and hits it most of the time. There is still one last piece to make the game fun. Scoring!

Game Mechanics: Scoring

Now, we need a way to keep score. This is actually some more simple collision detection. We are basically checking to see if the ball collides with the back walls. First, let’s define a few variables and a method. Open up iTennisViewController.h. Add the following highlighted code:

We need integer representations of the score so we can add points when the player and the computer score. Also, we will need a function called reset that will be called to reset the ball to the center of the screen. Now we need to define one more variable. Add the following line to your defines at the top of iTennisViewController.m

This variable is pretty self explanatory, but in case you didn’t catch on, it defines the amount of points needed to win. I just made it 5 for a quick game. Now, let’s check to see if a player or computer scored. Right after your AI code, add the following code:

Ok, first we see 2 if statements. The are basically checking to see if the ball has hit/passed the top or bottom of the screen. If it passes the top, the player score gets incremented. If it passes the bottom, the computer score gets incremented. The next line contains a little bit of fanciness if you are new to programming. We are calling the reset function, but what is that expression we are passing to it?

Well, if you look at the definition of reset, it takes a BOOL value that determines if the game is over. So this can either be true or false. We are simply passing true or false when the expression is evaluated. So, (player_score_value >= kScoreToWin) will evaluate to false when the player_score_value variable is less than 5. Once this variable reaches 5, it will return true and pass it into the reset function.

Why do this? Well it saves us lines of code and complexity. So now you don’t have to do if(player_score_value >= kScoreToWin) ) [self reset:YES]; }else{[self reset:NO];} . make sense?

Now, let’s define the reset function. Add the following method to iTennisViewController.m

The first thing we do is pause the game. Remember pausing the game causes the “Tap to Begin” Message to Display. Next, we center the ball on the screen. If YES/true was passed in for the newGame variable, we need to do a few things. First, we check who won by comparing the computer and player scores. Next, we update the “tapToBegin” message to notify the player who won. You could add another label for this, but I am just recycling this one… Finally, we reset the player and computer scores to 0 because a new game is starting.

If it is not a new game, we need to reset the tapToBegin message to display “tapToBegin”. This has to be done in case the message was altered to say “Player/Computer wins!”. Finally, we update the labels on the screen to reflect the new scores. Now you should be good to go…

Click Build and Go and battle the computer in an epic game of iTennis! If you have any comments or questions, leave them here or ask me on Twitter. You can also download the source for this tutorial here

As Promised, Here are some challenges

• Improve on user interaction – Make it so when the user taps, the racquet moves towards the tap rather than moves directly to the tap location
• Improve collision detection – When the ball hits the paddle, use some simple physics to make the speed of the paddle affect the speed (and direction) of the ball
• Improve on the AI – add some randomness to your AI, make it attempt to “predict” where the ball is going to be
• Improve Scoring – Make it used tennis scores 15, 30 , etc…
• Improve scoring – Make it so you must win by 2 points

Stay tuned for the next tutorial when I will be going over game audio, splash screen, about, and some other polishing… Happy iCoding!

An independent game developer known as GarageGames has recently released their tried and true game development engine for the iPhone. They already have an engine for large platforms such as Mac, Windows, Linux, Wii, Xbox, and now they are expanding to the most up-in-coming mobile platfor ever; the iPhone.

“Ready to make games for the iPhone?” is the tagline on their game engine site. They claim that “Making games for the iPhone is now a straightforward process using Torque’s proven 2D and 3D tools for game development”.

GarageGames also boasts that they have added iPhone specific funtionality to Torque such as

• Multi-touch Input Support
• Touchscreen Gesture Recognition
• iPhone Optimized Compressed Texture
• Advanced Character and Shape Animations

With this release, I hope to see some great (possibly free) games for the iPhone in the near future. They didn’t release specific pricing, but they boast that it will be affordable. So check it out, and make WOW for the iPhone!