You start by contacting us at info (at) iphonegametutorials (dot) com… Then you can choose to build off an existing tutorial on the site or maybe come up with a new tutorial all your own! You get full credit for that tutorial and it will be displayed on iphonegametutorials.com for all to see – We’ll also include a bio / game mention at the bottom of each post. As if all that wasn’t enough, you’ll also be included on the side bar of “Contributors” as well! I don’t know what could be better for someone trying to show off their chops in the mobile game space or get a little more spotlight on the game they’ve made!

So what are we looking for: Game programming tutorials, graphic tutorials and mobile business tutorials. Any tutorials that fit in the game development, game graphics or indie business space are very much welcome! No experience writing tutorials? No problem, we can help you in the process since we’ve been doing it for years at this point. You can even just supply a working snippet of your game mechanic and we can help with the rest!

Thank you to all those people who have been answering questions in the posts in the meantime, we can’t express how much that means to us. We hope to have a new tower defense tutorial out this week!

Thanks for all your continued support!
iPhone Game Tutorial Team

Share this:

In the meantime, source code and download after the break!

Lets get to the goodies first, here is the source code: Tower Defense Part 9.

Firstly lets look at the opening menu, go into the source file and find the new images: menuscreen, pause, cancel and buy, and add them to your project resources file, copying them if needed. Now create a new class and call it MenuLayer and make it a subclass of CCLayer.

Open MenuLayer.h and add the following:

#import "CCLayer.h"
#import "cocos2d.h"
#import "GameHUD.h"
#import "TutorialScene.h"
next open MenuLayer.m and add the following
-(id)init{
     if ((self = [super init])) {
          CGSize winSize = [[CCDirector sharedDirector] winSize];
          CCSprite *background = [CCSprite spriteWithFile:@"MenuScreen.png"];
          background.position = ccp(winSize.width/2, winSize.height/2);
          [self addChild:background];

          CCMenuItemImage *rangeButton = [CCMenuItemImage itemFromNormalImage:@"Buy.png" selectedImage:@"Buy.png" target:self selector:@selector(startGame)];
          CCMenu *menu = [CCMenu menuWithItems:rangeButton, nil];
          menu.position = ccp(winSize.width/2-65, winSize.height/2-15);
          [menu alignItemsVerticallyWithPadding: 20.0f];
          [self addChild:menu];
     }

     return self;
}

-(void) startGame
{
     [GameHUD resetGameHUD];
     [Tutorial resetGame];
     [self.parent removeChild:self cleanup:TRUE];
     [[CCDirector sharedDirector] resume];
}

-(void) dealloc{
     [super dealloc];
}

We should all be fairly familiar with the above by now, however if you are not familiar with menu items it could be a smidge confusing. So we add our menu screen background and add our menu item (the buy
image). When the user clicks this image we run the function startGame. The function start game will remove the menu layer (the game layer & GUI is underneath and hidden), we then reset the game using two functions which we will implement next.

Add this to TutorialScene.h

#import "MenuLayer.h"

Open TutorialScene.m and add the following functions

+(void) resetGame{
     reset = YES;
}

-(void) resetLayer{
     reset = NO;

     DataModel *m = [DataModel getModel];
     NSMutableArray *towersToDelete = [[NSMutableArray alloc] init];

     for (Tower *tower in m._towers) {
          [towersToDelete addObject:tower];
          [self removeChild:tower cleanup:YES];
     }

     for (Tower *tower in towersToDelete) {
          [self removeChild:tower cleanup:YES];
     }

     [towersToDelete release];

     for (Creep *target in m._targets) {
          [m._targets removeObject:target];
          [self removeChild:target.healthBar cleanup:YES];
          [self removeChild:target cleanup:YES];
     }

     NSMutableArray *projectilesToDelete = [[NSMutableArray alloc] init];
     for (Projectile *projectile in m._projectiles) {
          [projectilesToDelete addObject:projectile];
     }

     for (Projectile *projectile in projectilesToDelete) {
          [self removeChild:projectile cleanup:YES];
     }

     [projectilesToDelete release];
     [m._towers removeAllObjects];
     [m._targets removeAllObjects];
     [m._projectiles removeAllObjects];
     [m._waves removeAllObjects];
     [self addWaves];

     // Call game logic about every second
     [self schedule:@selector(update:)];
     [self schedule:@selector(gameLogic:) interval:0.2];! !
     self.currentLevel = 0;
     self.position = ccp(-258, -122);
     self.isTouchEnabled = YES;
}

Then at the very top of our update cycle add the following:

if (reset == YES) {
     [self resetLayer];
}

What’s going on: These functions work together to reset the game layer, all towers, creeps and projectiles are removed. We reschedule our game loops and set the scene back into its initial position.
Similarly open GameHUD.m and add the following:

+(void) resetGameHUD
{
     resetGameHUD = YES;
}

-(void) resetGameHUDLayer
{
     resetGameHUD = NO;
     [healthBar setSprite:[CCSprite
     spriteWithFile:@"health_bar_green.png"]];
     [healthBar setScale:0.5];

     baseHpPercentage = 99;
     [healthBar setPercentage:baseHpPercentage];
     [self updateBaseHp:+1];
     waveCount = 0;
     [waveCountLabel setString:[NSString stringWithFormat: @"Wave 1"]];
     resources = baseAttributes.baseStartingMoney;
     [resourceLabel setString:[NSString stringWithFormat: @"Money $%i",resources]];
}

and at the top of update:

if (resetGameHUD == YES) {
     [self resetGameHUDLayer];
}

What’s going on: These functions also work together to reset the gameHUD. We reset our health bar, wave count and the money available. Simples. Now if you build and run this program, not a lot different will happen. First we need to add our menu screen so that it loads straight away.

Open TutorialScene.m and go to the top where the +(id)scene method is. Below where we add our GameHUD add the following:

CCLayer *menuLayer =[[[MenuLayer alloc]init ]autorelease];
[scene addChild:menuLayer z:10];
[[CCDirector sharedDirector] pause];

What this does is load our menu layer, put it above our game and HUD layers then we pause the CCDirector so that the game does not play in the background. Run this and we should see our menu working perfectly.

End Game
There are two ways to reach the end of the game at the moment, either the base health runs out and the player loses, or the player reaches the end of the waves which we have set out (in this case they complete wave 5). As such we shall create an endGame layer which can either be Win or Lose.
Create a new class called EndGame and make it a sub-class of CCLayerColor (this could be a CCLayer, but why not find out about this new class type).

Add the following to EndGame.h :

#import "CCLayer.h"
#import "cocos2d.h"
#import "GameHUD.h"
#import "TutorialScene.h"
#import "MenuLayer.h"
@interface EndGame : CCLayerColor{
}

-(id)init:(bool)win;

@end

Then in EndGame.m add the following

-(id) init:(bool) win
{
     if( (self=[super initWithColor:ccc4(150,50,50,255)])) {
          CGSize winSize = [[CCDirector sharedDirector] winSize];
          self.isTouchEnabled = YES;
          GameHUD *gameHUD;
          gameHUD = [GameHUD sharedHUD];

          CCLabelTTF *endGameLabel = [CCLabelTTF labelWithString:@"" dimensions:CGSizeMake(150, 40) alignment:UITextAlignmentRight fontName:@"Marker Felt" fontSize:30];
          endGameLabel.position = ccp((winSize.width/2-10), (winSize.height - 30));
          endGameLabel.color = ccc3(255,80,20);

          [self addChild:endGameLabel z:1];

          if (win == NO){
               [endGameLabel setString:[NSString stringWithFormat: @"Game Over!"]];
          }
          else {
               [endGameLabel setString:[NSString stringWithFormat: @"You Win!"]];
          }

          CCLabelTTF *welldoneLabel = [CCLabelTTF labelWithString:@"" dimensions:CGSizeMake(300, 40) alignment:UITextAlignmentRight fontName:@"Marker Felt" fontSize:30];
          welldoneLabel.position = ccp((winSize.width/2-30), (winSize.height/2 + 75));
          welldoneLabel.color = ccc3(255,80,20);

          [self addChild:welldoneLabel z:1];

          [welldoneLabel setString:[NSString stringWithFormat: @"You reached wave %i",gameHUD.waveCount]];
          CCLabelTTF *restartLabel = [CCLabelTTF labelWithString:@"Restart?" dimensions:CGSizeMake(300, 40) alignment:UITextAlignmentRight fontName:@"Marker Felt" fontSize:30];

          restartLabel.position = ccp((winSize.width/2 - 150), (winSize.height/2));
          restartLabel.color = ccc3(255,80,20);

          [self addChild:restartLabel z:1];

          CCLabelTTF *menuLabel = [CCLabelTTF labelWithString:@"Menu" dimensions:CGSizeMake(300, 40) alignment:UITextAlignmentRight fontName:@"Marker Felt" fontSize:30];
          menuLabel.position = ccp((winSize.width/2 - 150), (winSize.height/2-50));
          menuLabel.color = ccc3(255,80,20);

          [self addChild:menuLabel z:1];

          CCMenuItemImage *replayButton;
          CCMenuItemImage *menuButton;
          CCMenu *menu;

          replayButton = [CCMenuItemImage
          itemFromNormalImage:@"Buy.png" selectedImage:@"Buy.png" target:self selector:@selector(replayLevel)];
          menuButton = [CCMenuItemImage itemFromNormalImage:@"Buy.png" selectedImage:@"Buy.png" target:self selector:@selector(returnToMenu)];
          menu = [CCMenu menuWithItems: replayButton, menuButton, nil];

          menu.position = ccp((winSize.width/2 + 50), (winSize.height/2-22));
          [menu alignItemsVerticallyWithPadding: 5.0f];

          [self addChild:menu];
          [[CCTouchDispatcher sharedDispatcher] addTargetedDelegate:self priority:10 swallowsTouches:YES];
     }

     return self;
}

-(void) replayLevel
{
     //Reset the game and start from the beginning.
     [GameHUD resetGameHUD];
     [Tutorial resetGame];
     [self.parent removeChild:self cleanup:TRUE];
     [[CCDirector sharedDirector] resume];
}

-(void) returnToMenu
{
     CCLayer *menuLayer =[[[MenuLayer alloc]init ]autorelease];
     [self.parent addChild:menuLayer z:10];
     [self.parent removeChild:self cleanup:TRUE];
}

-(void) dealloc{
     [super dealloc];
}

Very similar to GameHUD: we add all our text via labels, rather than using a background image (like MenuLayer). The advantage is that we can tweak our layout in xcode, rather than opening Photoshop and re-importing, however this can become very fiddly…

The init function has a bool variable associated with it, this we use to adjust the text on screen to say either “You Win”, or “You Lose”. We added two clickable menu items on this scene, one to replay the level
and another to return to the menu screen. ReplayLevel function is almost exactly the same as the start game function from MenuLayer.

The returnToMenu function simply creates and adds the menu layer, then removes the endgame layer.

Calling the endGame: Win

Open TutorialScene.m and find our update function, and find the piece of
code that searches for the end of the current wave and adjust it to the following:

Wave *wave = [self getCurrentWave];
if ([m._targets count] ==0 && wave.redCreeps <= 0 && wave.greenCreeps <= 0 && wave.brownCreeps <= 0) {
     if (self.currentLevel == 5) {
          CCLayerColor *endGameLayer =[[[EndGame alloc]init:YES]autorelease];
          [self.parent addChild:endGameLayer z:10];
          [[CCDirector sharedDirector] pause];
     }
     else{
          [self schedule:@selector(waveWait) interval:3.0];
          [gameHUD newWaveApproaching];
     }
}

We have added a search for the last wave (wave 5) when this is selected we load the endGameLayer with a “WIN = YES” call and pause the game.

Calling the endGame: Loose

Open GameHUD.m and adjust the updateBaseHp method to the following:

-(void) updateBaseHp:(int)amount{
     baseHpPercentage += amount;
     if (baseHpPercentage <= 25) {
          [self->healthBar setSprite:[CCSprite spriteWithFile:@"health_bar_red.png"]];
          [self->healthBar setScale:0.5];
     }

     if (baseHpPercentage <= 0) {
          //Game Over Scenario
          //printf("Game Over\n");
          CCLayerColor *endGameLayer =[[[EndGame alloc]init:NO ]autorelease];
          [self.parent addChild:endGameLayer z:10];
          [[CCDirector sharedDirector] pause];
     }

     [self->healthBar setPercentage:baseHpPercentage];
}

When the baseHp goes <= 0 we load the endGameLayer with a call “WIN = NO” and pause the game.
Run the game at this point and all should be working fine.

Pause

While we are doing menus lets create a pause menu.
Create a new class called PauseLayer and make it a subclass of CCLayerColor.

Add the following to PauseLayer.h :

#import "CCLayer.h"
#import "cocos2d.h"
#import "GameHUD.h"
#import "EndGame.h"
#import "TutorialScene.h"
#import "MenuLayer.h"
@interface PauseLayer : CCLayerColor{
}

@end

Next add the following to PauseLayer.m :

-(id) init
{
     if( (self=[super initWithColor:ccc4(150,50,50,255)])) {
          CGSize winSize = [[CCDirector sharedDirector] winSize];
          self.isTouchEnabled = YES;

          GameHUD *gameHUD;
          gameHUD = [GameHUD sharedHUD];
          CCLabelTTF *endGameLabel = [CCLabelTTF labelWithString:@"" dimensions:CGSizeMake(150, 40) alignment:UITextAlignmentRight fontName:@"Marker Felt" fontSize:30];
          endGameLabel.position = ccp((winSize.width/2-10), (winSize.height - 30));
          endGameLabel.color = ccc3(255,80,20);

          [self addChild:endGameLabel z:1];

          if (gameHUD.waveCount != 5){
               [endGameLabel setString:[NSString stringWithFormat: @"Paused"]];
          }

          CCLabelTTF *welldoneLabel = [CCLabelTTF labelWithString:@"" dimensions:CGSizeMake(300, 40) alignment:UITextAlignmentRight fontName:@"Marker Felt" fontSize:30];
          welldoneLabel.position = ccp((winSize.width/2-30), (winSize.height/2 + 75));
          welldoneLabel.color = ccc3(255,80,20);

          [self addChild:welldoneLabel z:1];

          [welldoneLabel setString:[NSString stringWithFormat: @"You reached wave %i",gameHUD.waveCount]];
          CCLabelTTF *restartLabel = [CCLabelTTF labelWithString:@"Continue" dimensions:CGSizeMake(300, 40) alignment:UITextAlignmentRight fontName:@"Marker Felt" fontSize:30];
          restartLabel.position = ccp((winSize.width/2 - 150), (winSize.height/2));
          restartLabel.color = ccc3(255,80,20);

          [self addChild:restartLabel z:1];

          CCLabelTTF *menuLabel = [CCLabelTTF labelWithString:@"Quit" dimensions:CGSizeMake(300, 40) alignment:UITextAlignmentRight fontName:@"Marker Felt" fontSize:30];
          menuLabel.position = ccp((winSize.width/2 - 150), (winSize.height/2-50));
          menuLabel.color = ccc3(255,80,20);

          [self addChild:menuLabel z:1];

          CCMenuItemImage *replayButton;
          CCMenuItemImage *menuButton;
          CCMenu *menu;
          replayButton = [CCMenuItemImage itemFromNormalImage:@"Buy.png" selectedImage:@"Buy.png" target:self selector:@selector(continueLevel)];
          menuButton = [CCMenuItemImage itemFromNormalImage:@"Cancel.png" selectedImage:@"Cancel.png" target:self selector:@selector(returnToMenu)];
          menu = [CCMenu menuWithItems: replayButton, menuButton, nil];
          menu.position = ccp((winSize.width/2 + 50), (winSize.height/ 2-22));

          [menu alignItemsVerticallyWithPadding: 5.0f];
          [self addChild:menu];
          [[CCTouchDispatcher sharedDispatcher] addTargetedDelegate:self priority:10 swallowsTouches:YES];
     }

     return self;
}

-(void) continueLevel
{
     //Replay Game
     [self.parent removeChild:self cleanup:TRUE];
     [[CCDirector sharedDirector] resume];
}

-(void) returnToMenu
{
     //Return to menu
     CCLayer *menuLayer =[[[MenuLayer alloc]init ]autorelease];
     [self.parent addChild:menuLayer z:10];
     [self.parent removeChild:self cleanup:TRUE];
}

-(void)dealloc
{
     [super dealloc];
}

Similarly to EndGame we use a CCLayerColor and add our text using labels. We then create two selectable icons, one will return the player to the game, and the other to the start menu, these methods should be clear now as they are basically the same as we have used in other menus.

Now we'll access the pause menu - Open GameHUD.m and add the following to the bottom of the init method.

CCMenuItemImage *pauseButton = [CCMenuItemImage
itemFromNormalImage:@"Pause.png" selectedImage:@"Pause.png" target:self
selector:@selector(pauseGame)];
pauseButton.scale = 0.13;
CCMenu *menu = [CCMenu menuWithItems:pauseButton, nil];
menu.position = ccp(winSize.width -35, 35);
[menu alignItemsVerticallyWithPadding: 20.0f];
[self addChild:menu];

Then add the following method:

-(void) pauseGame
{
     CCLayerColor *pauseLayer =[[[PauseLayer alloc]init]autorelease];
     [self.parent addChild:pauseLayer z:10];
     [[CCDirector sharedDirector] pause];
}

We simply place our pause image at the bottom right of the screen, and when it is selected we run the pauseLayer and pause the game. There we go, these are three very simple menus for our game.

Homework: Why not try creating a “score”. Combine the number of enemies killed (give each creep class a different value) plus bonuses for completing a round (or anything else that you want to give points for). Then when the end game is shown, tell the player their score.

Good luck!

Share this:

Open the source code and find the files baseAttributes.h and .m. add these files to your project class folder, open them and take a look inside.

Ok, so there are a few variables in here which may be new or unexpected, however if they are not immediately obvious we will be using all these variables in the near future. The main categories of variables are, base health and money variables, Machine Gun variables, Freeze tower variables, Cannon tower variables and Creep variables.

As always – Source code AND download after the break

First things first, if you want to just see everything in action, here is the source code: Tower Defense Part 8.

GameHUD:

Open gameHUD.h and add the following:

#import “baseAttributes.h”
BaseAttributes *baseAttributes;

in gameHUD.M at the top of the init method add:

baseAttributes = [BaseAttributes sharedAttributes];

Ok, so we now have access to all the variables kept in baseAttributes.

Add the following lines to replace “baseHpPercentage = 100;”

baseHp = baseAttributes.baseHealth;
baseHpPercentage = (baseHp/baseAttributes.baseHealth) *100;

Remove resources = 100; and add the following AFTER “[self addChild:resourceLabel z:1];”

resources = baseAttributes.baseStartingMoney;
[self->resourceLabel setString:[NSString stringWithFormat: @"Money $%i",resources]];

Add the following call at the end of init

[self schedule:@selector(updateResourcesNom) interval: baseAttributes.baseMoneyRegenRate];

Change updateResourcesNom function too

-(void) updateResourcesNom{
     [self updateResources:baseAttributes.baseMoneyRegen];
}

Note: Remove the call to updateResourcesNom from TutorialScene.m -> init function, it just sits better within GameHUD.m Next, we shall take a look at Tower costs in GameHUD.m (init).  First, we are only going to use 3 towers in this game, so remove the 4th tower from the NSArray *images, and change the 3rd tower to “CannonTurret.png” and include the CannonTurret.png image (from the source file) into your Resources folder. We are going to implement the CannonTurret here later, however for now it is useful to have the image here.

Replace the setCost switch statement with the following:

//Set cost values
switch (i) {
     case 0:
          [towerCost setString:[NSString stringWithFormat:@"$ %i", (int) (baseAttributes.baseMGCost*baseAttributes.baseTowerCostPercentage)]];
     break;

     case 1:
          [towerCost setString:[NSString stringWithFormat:@"$ %i",(int) (baseAttributes.baseFCost*baseAttributes.baseTowerCostPercentage)]];
     break;

     case 2:
          [towerCost setString:[NSString stringWithFormat:@"$ %i",(int) (baseAttributes.baseCCost*baseAttributes.baseTowerCostPercentage)]];
     break;

     default:
     break;
}

and in TutorialScene.m in addTower method replace the switch statement with the following:

switch (towerTag) {
     case 1:
          if (gameHUD.resources >= (int) (baseAttributes.baseMGCost*baseAttributes.baseTowerCostPercentage)) {
               target = [MachineGunTower tower];
               [gameHUD updateResources:-(int) (baseAttributes.baseMGCost*baseAttributes.baseTowerCostPercentage)];
          }
          else
               return;
          break;

     case 2:
          if (gameHUD.resources >= (int) (baseAttributes.baseFCost*baseAttributes.baseTowerCostPercentage)) {
               target = [FreezeTower tower];
               [gameHUD updateResources:-(int) (baseAttributes.baseFCost*baseAttributes.baseTowerCostPercentage)];
          }
          else
               return;
          break;

     case 3:
          if (gameHUD.resources >= (int) (baseAttributes.baseCCost*baseAttributes.baseTowerCostPercentage)) {
               target = [MachineGunTower tower];//We will change this when we create the CannonTower class.
               [gameHUD updateResources:-(int) (baseAttributes.baseCCost*baseAttributes.baseTowerCostPercentage)];
          }
          else
               return;
          break;

     default:
     break;
}

Then we’re going to want to add this to init method:

baseAttributes = [BaseAttributes sharedAttributes];

Moving on to TutorialScene.h:

#import “baseAttributes.h”

BaseAttributes * baseAttributes;

Run this and every thing should still be in working order.

More gameHUD:
Add the following method to gameHud.m

-(void) update:(ccTime) dt {
     for (CCSprite *sprite in movableSprites){

          switch (sprite.tag) {
               case 1:
                    if (baseAttributes.baseMGCost*baseAttributes.baseTowerCostPercentage > resources)
                    {
                         sprite.opacity = 50;
                         break;
                    }
                    else
                         sprite.opacity = 255;
                    break;

               case 2:
                    if (baseAttributes.baseFCost*baseAttributes.baseTowerCostPercentage > resources)
                    {
                         sprite.opacity = 50;
                         break;
                    }
                    else
                         sprite.opacity = 255;
                    break;

               case 3:
                    if (baseAttributes.baseCCost*baseAttributes.baseTowerCostPercentage > resources)
                    {
                         sprite.opacity = 50;
                         break;
                    }
                    else
                         sprite.opacity = 255;
                    break;

                    default:
                    break;
         }
     }
}

and add a call to update in the init method:

[self schedule:@selector(update:)];

Next, replace ccTouchBegan with the following:

- (BOOL)ccTouchBegan:(UITouch *)touch withEvent:(UIEvent *)event {
     CGPoint touchLocation = [self convertTouchToNodeSpace:touch];

     CCSprite * newSprite = nil;

     for (CCSprite *sprite in movableSprites) {
          if (CGRectContainsPoint(sprite.boundingBox, touchLocation)) {
               if (sprite.opacity == 255) {
                    DataModel *m = [DataModel getModel];
                    m._gestureRecognizer.enabled = NO;
                    selSpriteRange = [CCSprite spriteWithFile:@"Range.png"];

                    switch (sprite.tag) {
                    case 1:
                         selSpriteRange.scale = (baseAttributes.baseMGRange/50);
                    break;

                    case 2:
                         selSpriteRange.scale = (baseAttributes.baseFRange/50);
                    break;

                    case 3:
                         selSpriteRange.scale = (baseAttributes.baseCRange/50);
                    break;

                    default:
                    break;
                    }

                    [self addChild:selSpriteRange z:-1];
                    selSpriteRange.position = sprite.position;

                    newSprite = [CCSprite spriteWithTexture:[sprite texture]]; //sprite;

                    newSprite.position = sprite.position;
                    selSprite = newSprite;
                    selSprite.tag = sprite.tag;

                    [self addChild:newSprite];
               }
               break;
          }
     }
     return YES;
}

What do these changes do? Well, we can set now our tower Cost from baseAttributes.m rather than having to change both tutorialscene.m and gamehud.m. We have also included a scaling factor (baseTowerCostPercentage), which is currently set to 1 (i.e. no change), which we can use later to make all the towers proportionally cheaper/more expensive.

Next we show the image with full opacity only if the player has enough money to buy it. Then in ccTouchesBegan we did two things, one only allow the player to select a tower if the opacity is full (ie we have enough money), then we scale the towerRange image for each tower class individually. (The original file has a diameter of 100, and a range of 50).

Now that we’ve gotten some nitty gritty class work out of the way we start to make the changes to the class that will really make this a fun time. So lets get started with Creeps first!

In Creep.m remove the following variables:

float setRedHp = 9;
float setRedSpeed = 6;
float setGreenHp = 18;
float setGreenSpeed = 12;

Then in fastRedCreep replace them with:

BaseAttributes* baseAttributes = [BaseAttributes sharedAttributes];
creep.hp = creep.totalHp = baseAttributes.baseRedCreepHealth;
creep.moveDuration = baseAttributes.baseRedCreepMoveDur;

In StrongGreenCreep replace them with:

BaseAttributes* baseAttributes = [BaseAttributes sharedAttributes];
creep.hp = creep.totalHp = baseAttributes.baseGreenCreepHealth;
creep.moveDuration = baseAttributes.baseGreenCreepMoveDur;

Now in BossBrownCreep replace the setp of these variables with
:

BaseAttributes* baseAttributes = [BaseAttributes sharedAttributes];
creep.hp = creep.totalHp = baseAttributes.baseBrownCreepHealth;
creep.moveDuration = baseAttributes.baseBrownCreepMoveDur;

Phew – now our creeps will use the variables set in the baseAttributes class. Once again, we do this so that, all game variables can be easily changed from one location, the BaseAttributes class. This also facilitates the possibility of upgrading the creeps during gameplay or between levels.

Next up towers!

Yep we are finally there, we are going to implement the Cannon Tower, with splash damage! First, open the source code and copy the entire contents of Tower.h and Tower.m into your project, in the respective files (replacing any content). Next add the images CannonTurretUpgrade.png, FreezeTurretUpgrade.png and MachineGunTurretUpgrade.png from the source file into your project resources folder.

Take a few moments to look through the code in Tower.m and .h and get your head around it. Key points:

• We now have a CannonTower class, it is very similar to the other classes. In the parent class “Tower” we created a number of new variables, then in each of the child classes (MachineGunTower, FreezeTower, CannonTower) we used the data in baseAttributes to set these variables.
• Towers need experience to level up. (Experience will increase through successful hits.)
• If a Tower has reached its lvlUp limit, a new image, used to indicate that a upgrade is ready is shown replacing the original tower image.
• Variables such as tower damage, range and fire rate are set in baseAttributes and are stored in the tower class.
• We now send to Projectile, the tower id of its shooting tower.

This is a somewhat major over haul, if some of this does not make immediate sense, hopefully it will become apparent shortly. Next we must make a few adjustments to the projectile class, we must add the cannonProjectile class, and we must also allow projectile to hold the tower ID that shot it.

//Projectile.h
     @interface Projectile : CCSprite {
          CCSprite *parentTower;
     }

     @property (nonatomic, assign) CCSprite *parentTower;
     + (id)projectile: (id) sender;
     @end

     @interface IceProjectile : Projectile {
     }
     + (id)projectile: (id) sender;
     @end

     @interface CannonProjectile : Projectile {
     }
     + (id)projectile: (id) sender;
     @end

In the actual projectile class:

//Projectile.m
#import "Projectile.h"
@implementation Projectile
@synthesize parentTower = parentTower;

+ (id)projectile: (id) sender {
     Projectile *projectile = nil;
     if ((projectile = [[[super alloc]
          initWithFile:@"Projectile.png"] autorelease])) {
               projectile.parentTower = sender;
          }
     return projectile;
}

- (void) dealloc
{
     [super dealloc];
}
@end

@implementation IceProjectile
+ (id)projectile : (id) sender{

     IceProjectile *projectile = nil;
     if ((projectile = [[[super alloc] initWithFile:@"IceProjectile.png"] autorelease])) {
          projectile.parentTower = sender;
     }
     return projectile;
}

- (void) dealloc
{
     [super dealloc];
}
@end

@implementation CannonProjectile
+ (id)projectile : (id) sender{

     CannonProjectile *projectile = nil;
     if ((projectile = [[[super alloc]
          initWithFile:@"CannonProjectile.png"] autorelease])) {
               projectile.parentTower = sender;
     }
     return projectile;
}

- (void) dealloc
{
     [super dealloc];
}
@end

Oh, and remember to add the “CannonProjectile.png” from the source file too! Holding the parentTower id in the projectileClass is very useful, especially for tower experience. One final thing, go to Tutorialscene.m and find the AddTower method.

for switch (towerTag) case 3: change the call to:

target = [CannonTower tower];

Run the program now, make sure that the Cannon is firing the correct projectile, and there are no errors. Making it go Boom, oh and gaining experience Both of these functions are implemented within the “upgrade” function in TutorialScene.m.

Find the statement

if (CGRectIntersectsRect(projectileRect, targetRect))
{
     //Code
}

and replace it with the following:

if (CGRectIntersectsRect(projectileRect, targetRect)) {
     [projectilesToDelete addObject:projectile];

     Creep *creep = (Creep *)target;
     Creep *thisCreep;

     Tower *parentTower = (Tower *) projectile.parentTower;
     int thisHitDamage;

     CGRect splashRect;
     switch (projectile.tag) {
     case 1:
          thisHitDamage = (rand()%baseAttributes.baseMGDamageRandom)+parentTower.damageMin;
          creep.hp -= thisHitDamage;
          parentTower.experience += thisHitDamage;
     break;

     case 2:
          thisHitDamage = (rand()%baseAttributes.baseFDamageRandom)+parentTower.damageMin;
          creep.hp -= thisHitDamage;
          parentTower.experience += thisHitDamage;

          id actionFreeze = [CCMoveTo actionWithDuration:parentTower.freezeDur position:creep.position];
          id actionMoveResume = [CCCallFuncN actionWithTarget:self selector:@selector(ResumePath:)];
          [creep stopAllActions];
          [creep runAction:[CCSequence actions:actionFreeze, actionMoveResume, nil]];
     break;

     case 3:
          thisHitDamage = (rand()%baseAttributes.baseFDamageRandom)+parentTower.damageMin;
          parentTower.experience += thisHitDamage;
          splashRect = CGRectMake(projectile.position.x - (parentTower.splashDist), projectile.position.y - (parentTower.splashDist), (parentTower.splashDist*2), (parentTower.splashDist*2));

          for (CCSprite *target in m._targets) {
               CGRect thistargetRect = CGRectMake(target.position.x - (target.contentSize.width/2), target.position.y - (target.contentSize.height/2), target.contentSize.width, target.contentSize.height);
               if (CGRectIntersectsRect(splashRect, thistargetRect)) {
                    thisCreep = (Creep *) target;
                    thisCreep.hp -= thisHitDamage;

                    if (thisCreep.hp <= 0) {
                         [targetsToDelete addObject:target];
                         [gameHUD updateResources: rand()% (baseAttributes.baseMoneyDropped)];

                         [self removeChild:thisCreep.healthBar cleanup:YES];
                    }
               }
          }
     break;

     default:
     break;
     }

     if (creep.hp <= 0) {
          [targetsToDelete addObject:target];
          [gameHUD updateResources: rand()%(baseAttributes.baseMoneyDropped)];
          [self removeChild:creep.healthBar cleanup:YES];
     }
     break;
}

Bam Done! Whats new? :

• We capture the parentTower of the projectile so that we can gain access to its variables.
• The projectile.tag if statements have been replaced with a more efficient switch statement.
• The hit damage is affected by a random amount (located in baseAttributes for each tower individually) to emulate critical/glancing hits.
• The parent towers experience is increased by the amount of damage done.

Its probably worth just talking about splash damage in a little bit more detail. When a Cannon projectile hits a creep projectile we first decided how much damage it will do. We then create a Rect around this projectile, with a side length of twice the splashDistance (so splashDistance is the “radius”). We then run through the all the creeps again, and see if any of them fall within the SplashRect. Any that do fall within this rect take damage and if their hp <= 0 then they are removed.

Run this and we have a working program with 3 tower types, 2 creep classes and our game variables are all stored within one place. Next up, we're going to give our game an ending and maybe a few other goodies as well!

Yours,
Aiden Fry
iPhone Game Tutorials Contributor

Aiden Fry is a recent graduate, working to get into the games industry. He is a games programmer with a special interest in audio programming. Please check out his website aidenfry.tk to see some of his work.

Share this:

Firstly, problem solving:
After downloading the source code, the first thing that anyone with a developers license should see is that when you run the game those pesky lines / tile artifact issues have been solved. This was done by a small edit to the file CCSprite.m, big thank you to DreemLife for your efforts with sorting out this issue. If you are experiencing those tile artifacts in this project, the previous tutorials, or for any other project, then replace your CCsprite.m file with the one from the source code in this project.

Tower shenanigans:
Sometimes after a Creep has been removed, a Tower will send a projectile towards (0,0). This is because we have removed the towers target, without telling it not to shoot. Simply add the following to tower.m -> FinishedFiring method. (This will need to be done for all Tower classes)

-(void)finishFiring {
if (self.target != NULL) {
// Keep all pre-existing code
} }

Next, I would like our towers to target one creep, until it is either dead or out of range, before targeting a new creep, However at the moment only the nearest creep is targeted. Add the following method to each tower class

-(void)checkTarget {
double curDistance = ccpDistance(self.position, self.target.position);
if (self.target.hp <= 0 || curDistance > self.range){
self.target = [self getClosestTarget]; } }

Adding this call to the

+(id) tower methods. [tower schedule:@selector(checkTarget) interval:0.5];
and change the call to getClosestTarget in TowerUpdate methods
-(void)towerLogic:(ccTime)dt {
if (self.target == nil) {
self.target = [self getClosestTarget];
}
//All other code stays the same
}

Increasing the Tower Rotate speed & bullet speed, It just seems nicer! Staying in the towerLogic method, change the rotateSpeed to:

float rotateSpeed = 0.25 / M_PI; // 1/4 second to rotate 180 degrees and in finished

and the firing delta to:

ccTime delta = 0.5;

Run this and we should see our game is behaving a little better. One more thing is that we are currently able to build two towers on the same location. This needs changing. In tutorialsScene.m replace canBuild… method with the following.

-(BOOL) canBuildOnTilePosition:(CGPoint) pos
{
     CGPoint towerLoc = [self tileCoordForPosition: pos];
     int tileGid = [self.background tileGIDAt:towerLoc];
     NSDictionary *props = [self.tileMap propertiesForGID:tileGid];
     NSString *type = [props valueForKey:@"buildable"];

     bool occupied = NO;
     DataModel *m = [DataModel getModel];

     for (Tower *tower in m._towers) {
          CGRect towerRect = CGRectMake(tower.position.x - (tower.contentSize.width/2), tower.position.y - (tower.contentSize.height/2), tower.contentSize.width, tower.contentSize.height);
          if (CGRectContainsPoint(towerRect, pos)) {
               occupied = YES;
          }
     } 

     if([type isEqualToString: @"1"] && occupied == NO) {
          return YES;
     }
     return NO;
}

Similarly in addTower add the following before the switch statement

-(void)addTower: (CGPoint)pos: (int)towerTag {
     DataModel *m = [DataModel getModel];
     Tower *target = nil;
     CGPoint towerLoc = [self tileCoordForPosition: pos];

     int tileGid = [self.background tileGIDAt:towerLoc];
     NSDictionary *props = [self.tileMap propertiesForGID:tileGid];
     NSString *type = [props valueForKey:@"buildable"];

     bool occupied = NO; 

     for (Tower *tower in m._towers) {
          CGRect towerRect = CGRectMake(tower.position.x - (tower.contentSize.width/2), tower.position.y - (tower.contentSize.height/2), tower.contentSize.width, tower.contentSize.height);
          if (CGRectContainsPoint(towerRect, pos)) {
               occupied = YES;
          }
     } 

     if([type isEqualToString: @"1"] && occupied == NO) {
          switch (towerTag) {
               //Leave all other code the same.

One improvement, for better player usability, when placing towers the player can not really see the tower as their finger is in the way. lets move the sprite up a little so we can see it while placing the tower. First, go into GameHUD and find the CCtouchBegan method where we set newsprite.position, replace it with the following.

newSprite.position = ccpAdd(sprite.position, ccp(0, 50));

Now open TutorialScene.m and find the canBuildonTilePosition method an the following at the very top of the method

pos = ccpAdd(pos, ccp(0, 50));

similarly add the same code to the top of the addTower method. Run and check that this works.

Creeps:
As you may have noticed, the creeps speed up and slow down depending on the distance between waypoints. Now, we will fix this so that Creeps move at the same speed all the way around the map. In the Creeps.m file we will need to following method to the Creep implementation:

(float) moveDurScale {
     DataModel *m = [DataModel getModel]; 

     WayPoint *waypoint0 = (WayPoint *) [m._waypoints objectAtIndex:0];
     WayPoint *waypoint1 = (WayPoint *) [m._waypoints objectAtIndex:1]; 

     firstDistance = ccpDistance(waypoint0.position, waypoint1.position);
     WayPoint *waypoint2 = (WayPoint *) [m._waypoints objectAtIndex:(self.curWaypoint-1)];
     WayPoint *waypoint3 = (WayPoint *) [m._waypoints objectAtIndex:(self.curWaypoint)]; 

     float thisDistance = ccpDistance(waypoint2.position, waypoint3.position);
     float moveScale = thisDistance/firstDistance; return (self.moveDuration * moveScale);
}

//Add to Creep.h interface float firstDistance;
(float) moveDurScale;

What this does is to represent the current distance as a fraction of the first distance (between waypoints). This fraction is then used to scale the moveDuration. EG if a distance is half as long as the first distance, the move duration is half that of the first duration. Now to implement this new method, go into TutorialScene.m and find the FollowPath method and

replace:

int moveDuration = creep.moveDuration;

with:

float moveDuration = [creep moveDurScale];

Finally, find ResumePath method and replace:

float moveDuration = creep.moveDuration * distFraction;

with:

float durScale = [creep moveDurScale];
float moveDuration = durScale * distFraction;

There, Build this and things should start looking even better and behaving as we would expect.

New Additions:
Boss Creep:

Add the following class to Creep.m

@implementation BossBrownCreep

+ (id)creep {
     BossBrownCreep *creep = nil;

     if ((creep = [[[super alloc] initWithFile:@"Enemy3.png"] autorelease])) {
          creep.hp = creep.initHp = 500;
          creep.moveDuration = 10;
          creep.curWaypoint = 0; [creep schedule:@selector(creepLogic:) interval:0.2];

          [creep schedule:@selector(healthBarLogic:)];
     } 

     return creep;
}
@end

and add the class definition to the Creep.h. Using the BossCreep. In wave.m add the BrownCreeps to this method in exactly the same way as the Green or Red creeps. Then remember to update the wave.h file for this function and add the variables for brownCreeps. Next we will open tutorial.m and change our addWaves method so that it looks something like this:

wave = [[Wave alloc] initWithCreep:[FastRedCreep creep] SpawnRate:1.0 RedCreeps:5
GreenCreeps:0 BrownCreeps:0];

Now we can set the brown creeps as we like, I have reserved them for wave 5 the boss wave. Replace the addTarget method with the following

-(void)addTarget {
     DataModel *m = [DataModel getModel];
     Wave * wave = [self getCurrentWave];

     if (wave.redCreeps <= 0 && wave.greenCreeps <= 0 && wave.brownCreeps <= 0) {
          return; //
     } 

     //wave.totalCreeps--;
     Creep *target = nil;
     int creepChoice = (arc4random() % 3);

     int layer;
     switch (creepChoice) {
          case 0:
               if (wave.redCreeps > 0) {
                    target = [FastRedCreep creep];
                    target.tag = 1;
                    wave.redCreeps--;
                    layer = 1;
               }
               else {
                    [self addTarget];
                    return;
               }
          break;

          case 1:
               if (wave.greenCreeps >0) {
                    target = [StrongGreenCreep creep];
                    target.tag = 2;
                    wave.greenCreeps--;
                    layer = 1;
               }
               else {
                    [self addTarget];
                    return;
               }
          break;

          case 2:
               if (wave.brownCreeps >0) {
                    target = [BossBrownCreep creep];
                    target.tag = 3;
                    wave.brownCreeps--;
                    layer = 2;
               }
               else{
                    [self addTarget];
                    return;
               }
          break;

          default:
          break;
     } 

     WayPoint *waypoint = [target getCurrentWaypoint];

     target.position = waypoint.position;
     waypoint = [target getNextWaypoint ];

     [self addChild:target z:layer];
     float moveDuration = target.moveDuration;
     id actionMove = [CCMoveTo actionWithDuration:moveDuration position:waypoint.position];
     id actionMoveDone = [CCCallFuncN actionWithTarget:self selector:@selector(FollowPath:)];

     [target runAction:[CCSequence actions:actionMove, actionMoveDone, nil]]; // Add to targets array
     [m._targets addObject:target];
     return;
}

The last thing to do is to find our update method, and look at the bottom where we search to see if the wave has ended. Replace the if statement with the following

if ([m._targets count] ==0 && wave.redCreeps <= 0 && wave.greenCreeps <= 0 && wave.brownCreeps <= 0) {

Run this and we now will have some harder boss creeps, use them wisely! Creep health Bars: I thought it would be good to include health bars above the creeps so that we are able to see how much damage each creep is has taken. Add a CCProgressTimer and a new int to creep.h

CCProgressTimer *healthBar;
int _totalHp;

Make sure to also add the needed @property and @synthesize these variables as well, then in Creep.M under creepLogic add the following method:

-(void)healthBarLogic:(ccTime)dt {

     //Update health bar pos and percentage.
     healthBar.position = ccp(self.position.x, (self.position.y+20));
     healthBar.percentage = ((float)self.hp/(float)self.totalHp) *100;

     if (healthBar.percentage <= 0) {
          [self removeChild:healthBar cleanup:YES];
     }
}

This simply keeps the health bar placed above the creep, and updates the bar.percentage by the creeps hp. Add these calls in both +(id)creep methods

creep.hp = creep.totalHp = setRedHp;
[creep schedule:@selector(healthBarLogic:)];

Finally to implement these health bars add the following to addTarget in TutorialScene.m

//Under [self addChild:target z:1];
target.healthBar = [CCProgressTimer progressWithFile:@"health_bar_red.png"];
target.healthBar.type = kCCProgressTimerTypeHorizontalBarLR;
target.healthBar.percentage = 100;
[target.healthBar setScale:0.1];
target.healthBar.position = ccp(target.position.x,(target.position.y+20));

[self addChild:target.healthBar z:3];

Finally go down to upgrade method and add the following when we check to see the is the creep is dead.

if (creep.hp <= 0) {
     [targetsToDelete addObject:target];
     [gameHUD updateResources:1];
     [self removeChild:creep.healthBar cleanup:YES];//Add this
}

There we have it, health bars Waves: They are a little fast no?!
Just add the following method to TutorialScene.m:

-(void)waveWait {
     [self unschedule:@selector(waveWait)];
     [self getNextWave]; [gameHUD updateWaveCount];
}

Then in update, where we call to [self getNextWave] and [gameHUD updateWaveCount] change this to:

[self schedule:@selector(waveWait) interval:3.0];

Now there is a small gap between the waves, lets tell the player this! Open gameHUD.h and add the following variable:

 CCLabelTTF *newWaveLabel;

Now open gameHUD.m and add the following

//Add to init
// Set up new Wave label
newWaveLabel = [CCLabelTTF labelWithString:@"" dimensions:CGSizeMake(300, 50)
alignment:UITextAlignmentRight fontName:@"TrebuchetMS-Bold" fontSize:30];
newWaveLabel.position = ccp((winSize.width/2)-20, (winSize.height/2)+30);
newWaveLabel.color = ccc3(255,50,50); [self addChild:newWaveLabel z:1];

//add new methods & define them in the header file
-(void) newWaveApproaching {
     [newWaveLabel setString:[NSString stringWithFormat: @"HERE THEY COME!"]];
}

-(void) newWaveApproachingEnd {
     [newWaveLabel setString:[NSString stringWithFormat: @" "]];
}

Now, call newWaveApproaching when we call waveWait, and call newWaveApproachingEnd from the actual waveWait method. (both in tutorial.m) Finally, finally! I don’t like the fact that when the game begins the first wave is instantly spawned, lets use the waveWait method here too. Open tutorial.m and find the addWaves and simply add a blank wave at the beginning.

Wave *wave = nil;
wave = [[Wave alloc] initWithCreep:[FastRedCreep creep] SpawnRate:1.0 RedCreeps:0 GreenCreeps:0];
[m._waves addObject:wave];

Now two quick adjustments need to be made, in getNextWave, change our maximum wave count to be 6 (or one more that it previously was), and go into gameHUD.m, in the init method change the starting waveCount to be

waveCount = 0;

That's enough for this particular spring clean, however check back soon for part 8B where we'll be discussing more tower types including a new baseAttributes class.

Yours,
Aiden Fry
iPhone Game Tutorials Contributor

Aiden Fry is a recent graduate, working to get into the games industry. He is a games programmer with a special interest in audio programming. Please check out his website aidenfry.tk to see some of his work.

Share this:

In this tutorial we will incorporate “money” into the game so that towers cost the player, and the amount of money available will slowly increase over time. We shall also be incorporating base health bar into the game so we can ultimately have a game over. This particular tutorial focuses primarily on implementing dynamic labels and images, and the game logic behind them, as part of the gameHUD.

When adding labels to gameHUD.m the first thing we need to do is to decide upon what we want to display, in this case; Money count, abase health label and a base health bar, a wave count, and the prices of each tower.

Source code after the break…

First things first, if you want to just see everything in action, here is the source code: Tower Defense Part 7.

In gameHUD.m find the init function. Right before the line:

[[CCTouchDispatcher sharedDispatcher] addTargetedDelegate:self priority:0 swallowsTouches:YES];

paste the following code:

// Set up Resources and Resource label
resources = 100;
self->resourceLabel = [CCLabelTTF labelWithString:@"Money $100" dimensions:CGSizeMake(150, 25) alignment:UITextAlignmentRight fontName:@"Marker Felt" fontSize:20]; 

resourceLabel.position = ccp(30, (winSize.height -15));
resourceLabel.color = ccc3(255,80,20);
[self addChild:resourceLabel z:1]; 

// Set up BaseHplabel
CCLabelTTF *baseHpLabel = [CCLabelTTF labelWithString:@"Base Health" dimensions:CGSizeMake(150, 25) alignment:UITextAlignmentRight fontName:@"Marker Felt" fontSize:20];

baseHpLabel.position = ccp((winSize.width -185), (winSize.height -15));
baseHpLabel.color = ccc3(255,80,20);
[self addChild:baseHpLabel z:1]; 

// Set up wavecount label
waveCount = 1;
self->waveCountLabel = [CCLabelTTF labelWithString:@"Wave 1" dimensions:CGSizeMake(150, 25) alignment:UITextAlignmentRight fontName:@"Marker Felt" fontSize:20]; 

waveCountLabel.position = ccp(((winSize.width/2) -80), (winSize.height -15));
waveCountLabel.color = ccc3(100,0,100);
[self addChild:waveCountLabel z:1];

The first three blocks of code, where we set up the wave count, resources (money) and base health labels should be fairly simple, however if you are unfamiliar with labels then feel free to take a few moments to understand the code above.
The interesting code comes next when implementing the health bar. First download the Red and Green health bar images here [insert link] and then import them to your resources folder in Xcode.

Next copy the following code and place it bellow the label setup shown above.

//Set up health Bar
baseHpPercentage = 100;
self->healthBar = [CCProgressTimer progressWithFile:@"health_bar_green.png"];
self->healthBar.type = kCCProgressTimerTypeHorizontalBarLR;
self->healthBar.percentage = baseHpPercentage;
[self->healthBar setScale:0.5];
self->healthBar.position = ccp(winSize.width -55, winSize.height -15);
[self addChild:healthBar z:1];

We are using a “CCProgresstimer” to show the health bar image, we chose this because a ProgressTimer is able to show percentages of an image. We chose the type horizontalBarLR because the health bar image is a horizontal bar, and we wish (when the base takes damage) to decrease the health bar starting from the right end (100% health), moving towards the left end (0% health). We then set the percentage to be 100, as we start with full health. We also scale the image by half for aesthetic reasons, and set the position of the bar.

The last thing that we need to do, is to set labels to show the “price” of each tower.

Find the for statement which places the tower images onto the gameHUD, then replace it with the following.

for(int i = 0; i < images.count; ++i) {
      NSString *image = [images objectAtIndex:i];
      CCSprite *sprite = [CCSprite spriteWithFile:image];
      float offsetFraction = ((float)(i+1))/(images.count+1);
      sprite.position = ccp(winSize.width*offsetFraction, 35);
      sprite.tag = i+1; printf("tag %i", sprite.tag);
      [self addChild:sprite];
      [movableSprites addObject:sprite]; 

      //Set up and place towerCost labels
      CCLabelTTF *towerCost = [CCLabelTTF labelWithString:@"$" fontName:@"Marker Felt" fontSize:10];
      towerCost.position = ccp(winSize.width*offsetFraction, 15);
      towerCost.color = ccc3(0, 0, 0);
      [self addChild:towerCost z:1]; 

      //Set cost values
      switch (i) {
            case 0:
                  [towerCost setString:[NSString stringWithFormat:@"$ 25]];
            break; 

            case 1:
                  [towerCost setString:[NSString stringWithFormat:@"$ 35”]];
            break; 

            case 2:
                  [towerCost setString:[NSString stringWithFormat:@"$ 25]];
            break; 

            case 3:
                  [towerCost setString:[NSString stringWithFormat:@"$ 25]];
            break; 

            default:
            break;
      }
}

This simply places a price label slightly bellow the tower image, with a separate price for each tower image.

One final thing to do is to set up the variables involved in the dynamic labels. Add the following variables into the declaration of gameHUD.h:

int resources;

      CCLabelTTF *resourceLabel;
      CCLabelTTF *waveCountLabel;
      float baseHpPercentage;
      CCProgressTimer *healthBar;
} 

@property (nonatomic, assign) int resources;
@property (nonatomic, assign) float baseHpPercentage;

and in gameHUD.m add the following:

@synthesize resources = resources;
@synthesize baseHpPercentage = baseHpPercentage; 

int waveCount;

Next we will add the logic behind these labels to make them informative to the player and meaningful within the game.

Adding Towers: Removing Resources.
Go into gameHUD.m and add the following functions (remember to add the headers too).

-(void) updateResources:(int)amount {
      resources += amount;
      [self->resourceLabel setString:[NSString stringWithFormat: @"Money $ %i",resources]];
} 

-(void) updateResourcesNom {
      resources += 1;
      [self->resourceLabel setString:[NSString stringWithFormat: @"Money $ %i",resources]];
}

We can now use this function to update the amount of resources, then place the new number on screen. Next go into TutorialScene.m and find the addTower function. Replace the switch statement (towerTag) with the following:

switch (towerTag) {
      case 1:
            if (gameHUD.resources >= 25) {
                  target = [MachineGunTower tower];
                  [gameHUD updateResources:-25];
            } else return;
      break; 

      case 2:
            if (gameHUD.resources >= 35) {
                  target = [FreezeTower tower];
                  [gameHUD updateResources:-35];
             } else return;
      break; 

      case 3:
            if (gameHUD.resources >= 25) {
                  target = [MachineGunTower tower];
                  [gameHUD updateResources:-25];
             } else return;
      break; 

      case 4:
            if (gameHUD.resources >= 25) {
                  target = [MachineGunTower tower];
                  [gameHUD updateResources:-25];
            } else return;
      break; 

      default:
      break; 

}

What this does, is to check to see if there is enough resources available, if there is then it creates the tower selected and removes the cost of the tower from resources.

Next, Increasing the Resources available. There are two ways which the player can increase their money.
1: Money increases over time.
2: Gain money from killing creeps. We will implement both methods, starting with gaining money from killing creeps, go to -update and find where our creep collisions are being detected. When a creep’s health drops below 0 (a creep dies) we add one to the resources total eg:

(creep.hp <= 0) {
      [targetsToDelete addObject:target];
      [gameHUD updateResources:1];
}

Next, to increase money over time find the init function of TutorialScene and add the following after the declaration of gameHUD

[gameHUD schedule:@selector(updateResourcesNom) interval: 2.0];

This will add 1 resource ever two seconds.

Run and test this, and we should have fully operational resources/money functionality.

Next, we need to change the base health when a creep reaches the end of its path. Add the following function to gameHUD.m (& the header).

-(void) updateBaseHp:(int)amount {
      baseHpPercentage += amount; 

      if (baseHpPercentage <= 25) {
            [self->healthBar setSprite:[CCSprite spriteWithFile:@"health_bar_red.png"]];
            [self->healthBar setScale:0.5];
      } 

      if (baseHpPercentage <= 0) {
            //Game Over Scenario
            printf("Game Over\n"); 

            //Implement Game Over Scenario
      }

      [self->healthBar setPercentage:baseHpPercentage]; }

So, what this does is to update the baseHpPercentage by a given amount. If the baseHp falls below 25% then we change the image to the red health bar, then in the baseHp falls below (or equal to) 0 we have reached game over (at the moment just a printf message but we shall work on this next tutorial). Then after these checks we update the image bar to reveal the baseHpPercentage. Now, open Creep.m and find the getNextWaypoint function. In this function we check to see if the creep is at the last waypoint, if it is we delete the creep. After we delete the creep add the following code.

gameHUD = [GameHUD sharedHUD]; 

if (gameHUD.baseHpPercentage > 0) {
      [gameHUD updateBaseHp:-10];
}

This means that the baseHp will decrease by 10 for each creep that “hits” it. Run and test this code, we should see the health bar be affected by the creeps and change color when low on health.

Finally we wish to update the WaveCount, so that players can get a feeling for how far through the game they are, and have something to aim for (ie. a previous highest level).

In gameHUd.com add the following function (and header):

-(void) updateWaveCount {
      waveCount++;
      [self->waveCountLabel setString:[NSString stringWithFormat: @"Wave %i",waveCount]];
}

next go into TutorialScene and the update function, find the if statement which detects the end of the current wave and add a call to the updateWaveCount function.

Wave *wave = [self getCurrentWave];
if ([m._targets count] ==0 && wave.redCreeps <= 0 && wave.greenCreeps <= 0) {
      [self getNextWave];
      [gameHUD updateWaveCount];
}

And there we have it! We now have 3 dynamic labels, with corresponding logic, and also have prices for each tower. The actual prices, resource spawn rates and starting resources are all nominal, feel free to change these settings to get the balance of challenge and enjoyment that you wish.

Yours,
Aiden Fry
iPhone Game Tutorials Contributor

Aiden Fry is a recent graduate, working to get into the games industry. He is a games programmer with a special interest in audio programming. Please check out his website aidenfry.tk to see some of his work.

Share this:

In this Tutorial, we will be incorporating a new tower type into our game, this will give you the knowledge to then continue on and make/implement your own towers types. The tower type which we will be incorporating is a freeze tower, this tower will shoot Ice projectiles at a creep which will freeze it in place for a period of time, before the creep then continues on its journey.

Source code after the break!

The first thing to do is to download the new Turret and Projectile images that I created in about 2 minutes. They can be found here: Freeze Turret and Ice Projectile. Alternatively you can use your own images (however i recommend re-naming them in the same way to avoid confusion later). Then add them to your resources folder in Xcode. Alternatively if you want to just see everything in action, here is the source code: Tower Defense Part 6.

Now we have our images in our project, we want to add our new turret image to our HUD so that the player can select and place it within the level. Open GameHUD.m and look at the init section.

NSArray *images = [NSArray arrayWithObjects:@"MachineGunTurret.png", @"FreezeTurret.png", @"MachineGunTurret.png", @"MachineGunTurret.png", nil];
for(int i = 0; i < images.count; ++i) {
     NSString *image = [images objectAtIndex:i];
     CCSprite *sprite = [CCSprite spriteWithFile:image];
     float offsetFraction = ((float)(i+1))/(images.count+1);
     sprite.position = ccp(winSize.width*offsetFraction, 35);
     sprite.tag = i+1;//individual tag for each Turret.
     [self addChild:sprite];
     [movableSprites addObject:sprite];

Within the "NSArray *images" we have changed the second "MachineGunTurret.png" to "FreezeTurret.png". This will load the freeze turret image as the second from the left image. Then in the "for loop" we added an individual tag to each tower type, "sprite.tag = i+1;" I chose to +1 so that the first Turret type(MachineGunTurret) starts at 1 rather than 0. And the New FreezeTurret will have a tag of 2. For now, turret types 3 + 4 are still machine gun turrets, but once you have completed this tutorial, feel free to add your own turrets types in here.

While we are in GameHUD.m go down to ccTouchesBegan and add the following piece of code directly above the line "[self addChild:newSprite];"

selSprite.tag = sprite.tag;

then go down to ccTouchedEnded and adjust the if statement:

if (!CGRectContainsPoint(backgroundRect, touchLocation))

to say:

if (!CGRectContainsPoint(backgroundRect, touchLocation)) {
     CGPoint touchLocationInGameLayer = [m._gameLayer convertTouchToNodeSpace:touch];
     [m._gameLayer addTower: touchLocationInGameLayer: selSprite.tag];
}

What do these changes do? In effect they take the tag of the currently selected turret type, and pass it to the addTower function in TutorialScene.m, when the player lets go of the tower placing it within the level. To get rid of the pesky error messages which are now occurring we need to adjust the addTower function.
Go into TutorialScene.h replace the addTower function definition with the following:

- (void)addTower: (CGPoint)pos: (int)towerTag;

then in TutorialScene.m replace the addTower function header (not the contents of the function) with the following:

-(void)addTower: (CGPoint)pos: (int)towerTag{
     //Keep the same function content!
}

At this moment in time, if we run the game, we will see the FreezeTurret in the HUD and be able to select and move it, however when we place it on the map, it will transform into a MachineGunTurret.This is partly because we have not created the FreezeTower class, we shall do this now. Open Tower.m and copy and paste the following class at the very end of the file (after @end).

@implementation FreezeTower
+ (id)tower {
     FreezeTower *tower = nil;
     if ((tower = [[[super alloc] initWithFile:@"FreezeTurret.png"] autorelease])) {
          tower.range = 200;
          tower.target = nil;
          [tower schedule:@selector(towerLogic:) interval:2];
     }

     return tower;
}

-(id) init
{
     if ((self=[super init]) ) {
          //[[CCTouchDispatcher sharedDispatcher] addTargetedDelegate:self priority:0 swallowsTouches:YES];
     }

     return self;
}

-(void)setClosestTarget:(Creep *)closestTarget {
     self.target = closestTarget;
}

-(void)towerLogic:(ccTime)dt {
     self.target = [self getClosestTarget];

     if (self.target != nil) {
          //rotate the tower to face the nearest creep

          CGPoint shootVector = ccpSub(self.target.position, self.position);
          CGFloat shootAngle = ccpToAngle(shootVector);
          CGFloat cocosAngle = CC_RADIANS_TO_DEGREES(-1 * shootAngle);

          float rotateSpeed = 0.5 / M_PI; // 1/2 second to roate 180 degrees
          float rotateDuration = fabs(shootAngle * rotateSpeed);

          [self runAction:[CCSequence actions: [CCRotateTo actionWithDuration:rotateDuration angle:cocosAngle], [CCCallFunc actionWithTarget:self selector:@selector(finishFiring)], nil]];
     }
}

-(void)creepMoveFinished:(id)sender {
     DataModel * m = [DataModel getModel];

     CCSprite *sprite = (CCSprite *)sender; [self.parent removeChild:sprite cleanup:YES];

     [m._projectiles removeObject:sprite];
}

- (void)finishFiring {
     DataModel *m = [DataModel getModel];
     self.nextProjectile = [Projectile projectile];
     self.nextProjectile.position = self.position;
     [self.parent addChild:self.nextProjectile z:1];
     [m._projectiles addObject:self.nextProjectile];

     ccTime delta = 0.5;
     CGPoint shootVector = ccpSub(self.target.position, self.position);
     CGPoint normalizedShootVector = ccpNormalize(shootVector);
     CGPoint overshotVector = ccpMult(normalizedShootVector, 320);
     CGPoint offscreenPoint = ccpAdd(self.position, overshotVector);

     [self.nextProjectile runAction:[CCSequence actions: [CCMoveTo actionWithDuration:delta position:offscreenPoint], [CCCallFuncN actionWithTarget:self selector:@selector(creepMoveFinished:)], nil]];
     self.nextProjectile.tag = 2;!!
     self.nextProjectile = nil;
}
@end

then in Tower.H: copy and paste the following class definitions at the very end of the file (after @end)

@interface FreezeTower : Tower {

}

+ (id)tower;
- (void)setClosestTarget:(Creep *)closestTarget;
- (void)towerLogic:(ccTime)dt;
- (void)creepMoveFinished:(id)sender;
- (void)finishFiring;
@end

So what have we done here? Well if you look through the code you will see that we have done very little apart from copy the MachineGunTurret class and change a few parameters. Such as: the image, the fire rate of the turret (towerLogic schedule), the speed of the projectile (just made it a bit faster). So now we have our FreezeTurret class, we should go back into addTower and allow it to create a FreezeTurret if a player selects a freeze turret. Now open TutorialScene.m, and go to the addTower function. Under the check to see if the tile is build able add in the following:

NSLog(@"Buildable: %@", type);
if([type isEqualToString: @"1"]) {
     printf("tower tag %i", towerTag);

     switch (towerTag) {
          case 1:
               target = [MachineGunTower tower];
          break;
          case 2:
               target = [FreezeTower tower];
          break;
          case 3:
               target = [MachineGunTower tower];
          break;
          case 4:
               target = [MachineGunTower tower];
          break;
          default:
          break;
     }

Now our towerTag, passed from GameHUD, comes in handy as we check to see which tower the player has selected. When the player lets go we add the same tower type to the level. So now we should be able to select and add two different classes of Tower to our game world.

Run, Check, Debug.

Ok, so you might have noticed, at the moment the FreezeTurret behaves more like a slow MachineGunTurret than a FreezeTurret. In this next section we shall improve on this by adding the freeze logic to the update function, and then allowing the creeps to resume its path. The first thing that we should do is to go into Tower.M and make sure that the projectiles coming from MachineGunTurret have a tag of 1. Whilst the projectiles coming from FreezeTurret have a tag of 2. Next, open TutorialScene.m and go down to our Update function, and find the section where we check for collisions between projectiles and creeps and replace the entire if statement with the following.

if (CGRectIntersectsRect(projectileRect, targetRect)) {
     [projectilesToDelete addObject:projectile];
     Creep *creep = (Creep *)target;

     if (projectile.tag ==1) { //MachineGun Projectile
          creep.hp--;
          if (creep.hp <= 0) {
               [targetsToDelete addObject:target];
          }
          break;
     }
     else if (projectile.tag ==2) { //Freeze projectile
     id actionFreeze = [CCMoveTo actionWithDuration:1 position:creep.position];
     id actionMoveResume = [CCCallFuncN actionWithTarget:self selector:@selector(ResumePath:)];
     [creep stopAllActions];
     [creep runAction:[CCSequence actions:actionFreeze, actionMoveResume, nil]];
     break;
     }
     break;
}

When a collision between a projectile and a creep is detected, we then check to see what the projectile tag is. If the projectile.tag == 1 then we know this projectile come from a MachineGunTurret and we perform the same actions as we have done in the previous tutorials. However if the projectile.tag == 2 then we know this is a freeze projectile, in which case we run a series of actions. First we Freeze the creep for 1 second at its current location. Then we call a new function ResumePath:, in which we will allow the creep to continue along its path.

in tutorialscene.m add in the following function

-(void)ResumePath:(id)sender {
     Creep *creep = (Creep *)sender;
     WayPoint * cWaypoint = [creep getCurrentWaypoint];//destination
     WayPoint * lWaypoint = [creep getLastWaypoint];//startpoint
     float waypointDist = fabsf(cWaypoint.position.x -lWaypoint.position.x);
     float playerDist = fabsf(creep.position.x - cWaypoint.position.x);
     float distFraction = playerDist / waypointDist;
     float moveDuration = creep.moveDuration * (distFraction); //Time it takes to go from one way point to another * the fraction of how far is left to go (meaning it will move at the correct speed)

     id actionMove = [CCMoveTo actionWithDuration:moveDuration position:cWaypoint.position];
     id actionMoveDone = [CCCallFuncN actionWithTarget:self selector:@selector(FollowPath:)];
     [creep stopAllActions];
     [creep runAction:[CCSequence actions:actionMove, actionMoveDone, nil]];
}

then in creep.m add in the following function

- (WayPoint *)getLastWaypoint{
     DataModel *m = [DataModel getModel];
     //int lastWaypoint = m._waypoints.count;
     self.lastWaypoint = self.curWaypoint -1;
     WayPoint *waypoint = (WayPoint *) [m._waypoints objectAtIndex:self.lastWaypoint];
     return waypoint;
}

[Side Note: REMEMBER TO ADD IN THE HEADERS FOR THESE FUNCTIONS.]

What do we do in these functions? Well in essence we find the distance between the previous waypoint and the current waypoint. Then we find the distance between the creep and the current waypoint. We then represent the distance between the creep and the current waypoint as a fraction of the distance between the last waypoint and the current waypoint. Then we use this fraction to affect the creep.moveDuration so that when the creep continues towards the current waypoint, it moves at a speed relative to its fellow creeps. After it hits the current waypoint it will then continue along its path normally. One thing that I would like to do here is to correct a slight error which occurs within the creep.m code. Replace the getNextWaypoint function with the following:

[Update: found a small issue in the getNextWaypoint function that would cause the health bar to act weird - It's been fixed now in the below code]

- (WayPoint *)getNextWaypoint{
DataModel *m = [DataModel getModel];
self.curWaypoint++;

if (self.curWaypoint >= m._waypoints.count){
        self.curWaypoint--;
        gameHUD = [GameHUD sharedHUD];
        if (gameHUD.baseHpPercentage > 0) {
            [gameHUD updateBaseHp:-10];
        }

        Creep *target = (Creep *) self;
        NSMutableArray *endtargetsToDelete = [[NSMutableArray alloc] init];
        [endtargetsToDelete addObject:target];

        for (CCSprite *target in endtargetsToDelete) {
            [m._targets removeObject:target];
            [self.parent removeChild:target cleanup:YES];
        }
        return NULL;

    }

WayPoint *waypoint = (WayPoint *) [m._waypoints objectAtIndex:self.curWaypoint];
return waypoint;

}

If you have noticed an intermittent crash, it is because when the creeps gets to the last waypoint this function was not working correctly. However this update will recognize when a creep is at the last waypoint and delete the creep. So, run this and we should see that the FreezeTowers, freeze the creeps, and then the creeps (after one second) will continue along their path at a normal speed.

One final thing we can implement is to add in an IceProjectile that the FreezeTower fires, rather than the usual machine gun projectile. Once again this is fairly simple, open Projectile.m and add the following class at the end of the file (after @end):

@implementation IceProjectile
+ (id)projectile {
     IceProjectile *projectile = nil;
     if ((projectile = [[[super alloc] initWithFile:@"IceProjectile.png"] autorelease])) {

     }
     return projectile;
}

- (void) dealloc
{
     [super dealloc];
}

@end

then in Projectile.h add the following at the end of the file:

@interface IceProjectile : CCSprite {
}

+ (id)projectile;
@end

Simply this creates another class of projectile, the IceProjectile. Now go into Tower.h and go down to the FreezeTower class, and find the function finishedFiring. Adjust the call to [Projectile projectile]; to say the following:

self.nextProjectile = [IceProjectile projectile];

And there we have it! FreezeTowers, IceProjectiles, and FreezeCreep functionality. As always, comments / suggestions / found errors? All very welcome! Thanks for Reading!

Yours,
Aiden Fry
iPhone Game Tutorials Contributor

Aiden Fry is a recent graduate, working to get into the games industry. He is a games programmer with a special interest in audio programming. Please check out his website aidenfry.tk to see some of his work.

Share this:

Before we get into it, you’ll find things much easier to follow if you’ve already looked at Part5a of this tutorial series – So go there and come back… don’t worry we’ll wait.

Source code after the break…

Here is the source code: Tower Defense Part 5b. Once again, we’re using the Cocos2d framework which you can download here!

The first thing I did is to change the make up of the wave class. open wave.m and adjust the initWithCreep function to the following.

- (id) initWithCreep:(Creep *)creep SpawnRate:(float)spawnrate RedCreeps:(int)redcreeps GreenCreeps: (int)greencreeps
{
     NSAssert(creep!=nil, @"Invalid creep for wave.");
     if( (self = [self init]) )
     {
          _creepType = creep;
          _spawnRate = spawnrate;
          _redCreeps = redcreeps;
          _greenCreeps = greencreeps;
     }
     return self;
}

Also add your new variables as such (and remove totalCreeps variables):

@synthesize redCreeps = _redCreeps;
@synthesize greenCreeps = _greenCreeps;

Whilst in wave.H replace the entire file with the following:

#import "cocos2d.h"
#import "Creep.h"

@interface Wave : CCNode {
    float _spawnRate;
    int _redCreeps;
    int _greenCreeps;
    Creep * _creepType;
}

@property (nonatomic) float spawnRate;
@property (nonatomic) int redCreeps;
@property (nonatomic) int greenCreeps;
@property (nonatomic, retain) Creep *creepType;
- (id)initWithCreep:(Creep *)creep SpawnRate:(float)spawnrate RedCreeps:
(int)redcreeps GreenCreeps:(int)greencreeps;
@end

Hold up: All that we have done here is to change the make-up of the initWithCreep function (used in addWaves) to allow us to set the amount of red and green creeps separately, instead of just a totalCreeps value. Now go back into the main file (yep we have some errors, don’t worry!) and go to the function addWaves. Here we need to change our definitions to now include our RedCreeps and GreenCreeps variables (removing the TotalCreeps variable) until we have something which looks like this.

      wave = [[Wave alloc] initWithCreep:[FastRedCreep creep] SpawnRate: 0.7 RedCreeps:5 GreenCreeps:15];

Still we have some errors, no problem, this is because we were checking the TotalCreeps in a few places, however with this variable now nonexistent we need to change these checks.
in addTarget change:

if (wave.totalCreeps < 0) {
     return;
}

to

if (wave.redCreeps <= 0 && wave.greenCreeps <= 0 ) {
     return;
}

Hold up: Simply this means that we won’t spawn any more creeps than are in the wave, and now we have split the creeps into green and red, we need to check that both are at 0. Next up you will see something like this

wave.totalCreeps--;

remove this piece of code. This was lowering the count of creeps left to spawn in this wave, however we will now do the same thing in a different way. Below this line you will see the next section of code:

Creep *target = nil;
if ((arc4random() % 2) == 0) {
     target = [FastRedCreep creep];
} else {
     target = [StrongGreenCreep creep];
}

In this section we set the creep type to spawn at random, evenly between Red and Green creeps. Replace this code with the following.

Creep *target = nil;
if ((arc4random() % 2) == 0) {
      if (wave.redCreeps > 0) {
            target = [FastRedCreep creep];
            wave.redCreeps--;
      }
      else if (wave.greenCreeps >0){
            target = [StrongGreenCreep creep];
            wave.greenCreeps--;
            // NSLog(@"no more red");
      }
}
else {
      if (wave.greenCreeps >0) {
            target = [StrongGreenCreep creep];
            wave.greenCreeps--;
      }
      else if (wave.redCreeps >0){
            target = [FastRedCreep creep];
            wave.redCreeps--;
            //NSLog(@"no more green");
      }
}

Hold up: In the new code above we are once again choosing a creep type (red/green) at random, however we then check to see if there are any creeps of that type left to spawn in this wave. This is a bit wordy so I’ll give a little example.

If the random generator chooses a Red Creep, and there is at least 1 Red Creep left to spawn in this wave, then a Red Creep is spawned and we decrease the number of Reds left to spawn in this wave. If there are not any Red Creeps left to spawn, then we Spawn a Green Creep and decrease the number of Green Creeps left to spawn in this wave. There I hope you understood that, should be fairly simple even if I can’t really vocalize it concisely.
Oh yes, and finally one last change. Go to the update section, where we earlier implemented a check for the end of the wave and replace the if statement with the following.

Wave *wave = [self getCurrentWave];
//int alivecount = [m._targets count];
if ([m._targets count] ==0 && wave.redCreeps <= 0 && wave.greenCreeps <= 0) {
      printf("Get next wave\n");
      // NSLog(@"Get next wave\n");//use for debugging
      [self getNextWave];
}

Hold up: Should understand this by now as it is the same general update we have been doing from wave.totalCreeps (expired) to wave.redCreeps and Wave.greenCreeps.

Run, Test, Enjoy!

Remember, here is the source code for everything we have covered within this tutorial!

Tower Defense Part 5b Download.

Thanks for Reading, Hope this helps you all. Comment for help/explanations/pointing out any “doh” moments from me! Also Comment for suggestions for where you want this series to go next.

Yours,
Aiden Fry
iPhone Game Tutorials Contributor

Aiden Fry is a recent graduate, working to get into the games industry. He is a games programmer with a special interest in audio programming. Please check out his website aidenfry.tk to see some of his work.

Share this:

Welcome to the latest edition of the Tower Defense Tutorial. This is just the start of the long awaited renewal of the Tower Defense Tutorials. I (like many of you I am sure), have been following this particular tutorial series with interest, and was slightly downcast when I realized that part 4 was the last to be released. So hear me now, I vow to take up the challenge and by the end of these tutorials we will have a fully working game!

Yours, Aiden.

[Editor's Note: We are also very happy that Aiden has taken up the challenge as well!]

The Tower Defense Tutorial Part 5a – Multiple Waves!

A Quick Look Back:
I will assume that all of you have been following the tutorial series found here – part 1, part 2, part 3, part 4 – and are mostly OK with what has gone before, however it is good just to mention a few key things about what has already taken place.

1. We have some creeps that go around a set path.
2. We can place towers around the path.
3. Towers fire at the nearest Creep.
4. Creeps have Hp, and when HP is 0 (due to tower projectiles) the creeps “die” and are removed from the game.
5. At the moment there is only one “Wave” of Creeps.

Aims of this Tutorial:

• Creating Multiple waves of Creeps.
• Defining how many Creeps of each type (red/green) per wave.

Source code after the break…

Here is the source code: Tower Defense Part 5a. Once again, we’re using the Cocos2d framework which you can download here!

To create multiple waves, first we must define multiple waves, this is done in addWaves in TutorialScene.m, originally it should look like this.

-(void)addWaves {
     DataModel *m = [DataModel getModel];

     Wave *wave = nil;
     wave = [[Wave alloc] initWithCreep:[FastRedCreep creep] SpawnRate: 0.3 TotalCreeps:50];
     [m._waves addObject:wave];
     wave = nil;
     wave = [[Wave alloc] initWithCreep:[StrongGreenCreep creep] SpawnRate:1.0 TotalCreeps:5];
     [m._waves addObject:wave];
     wave = nil;!
}

Hold up: The above means that there are two waves defined, the first wave has a total of 50 creeps, and spawns a knew one at 0.3 creeps per second. The initWithCreep[fastred] or [stronggreem] actually means nil to zilch at the moment (as we are defining which creep type to spawn at random in addTarget) therefore I will be “init-ing” with fast red creep from now on to avoid confusion.
After we define our wave, we add it to an array for storage/call back later and initialize our wave variable to nil. Adding our own waves: Yep you guessed it, to define our own waves all we need to do is to add more lines to the addWaves function, and just adjust the spawn rate and totalcreeps (if you so wish). I chose to create 5 waves, that will increase in difficulty as we progress.

-(void)addWaves {
     DataModel *m = [DataModel getModel];

     Wave *wave = nil;
     wave = [[Wave alloc] initWithCreep:[FastRedCreep creep] SpawnRate: 1.0 TotalCreeps:10];
     [m._waves addObject:wave];
     wave = nil;
     wave = [[Wave alloc] initWithCreep:[FastRedCreep creep] SpawnRate: 0.7 TotalCreeps:20];
     [m._waves addObject:wave];
     wave = nil;!
     wave = [[Wave alloc] initWithCreep:[FastRedCreep creep] SpawnRate: 0.5 TotalCreeps:50];
     [m._waves addObject:wave];
     wave = nil;
     wave = [[Wave alloc] initWithCreep:[FastRedCreep creep] SpawnRate: 0.3 TotalCreeps:70];
     [m._waves addObject:wave];
     wave = nil;
     wave = [[Wave alloc] initWithCreep:[FastRedCreep creep] SpawnRate: 0.2 TotalCreeps:100];
     [m._waves addObject:wave];
     wave = nil;
}

One thing to mention here is that if we wish to spawn our creeps as faster than one per second, we must change our scheduler call to gameLogic. Go to Tutorial.m and find the init function. Here you will see a call to game logic such as:

[self schedule:@selector(gameLogic:) interval:1.0];

The gameLogic function looks at the spawn rate and compares it with the time that has passed since the last spawn. Therefor if we wanted a spawn rate of 0.1 and the gameLogic is scheduled at 1.0 when running the game the actual spawn rate will be 1.0. Therefor we must make sure that the gameLogic interval is a division of all the spawn rates.

I have set the gamescheduler to:

[self schedule:@selector(gameLogic:) interval:0.1];

As 0.1 is a divisible factor of all my spawn rates, and therefor the creeps will spawn at the rate that i set them.

Note: be aware that making the gameLogic interval smaller we are increasing the processing overhead.

Spawning our waves: The next thing to do is to spawn the next wave once the current wave has been defeated., This is fairly simple. In the update function (right at the end of the update) add in the following code.

Wave *wave = [self getCurrentWave];
if ([m._targets count] ==0 && wave.totalCreeps <= 0) {
     // NSLog(@"Get next wave\n");//use for debugging
     [self getNextWave];
}

Hold up: Simply what this piece of code does is to: get the current wave from m._waves array where we saved our waves to in addWaves, then check to see if there are any creeps currently on screen, and check to see that all the creeps have been spawned from the current wave. If these checks are correct, its means that we are at the end of the current wave and its time to load the next wave. There is one last thing to do before we test out our new wave system. Within getNextWave we check to see if we are at the end of our waves. So you will need to adjust this check for the amount of waves that you have included. For me this is 5 waves, however remember that it will count from 0 (unless you specify other wise).

if (self.currentLevel >= 5){
     //self.currentLevel = 0;
     NSLog(@"you have reached the end of the game!");
}

There you have it, multiple programmable waves! Run, Test, Have Fun.

Part B will be released soon, I promise – The source code for up until this point can be downloaded here.

Yours,
Aiden Fry
iPhone Game Tutorials Contributor

Aiden Fry is a recent graduate, working to get into the games industry. He is a games programmer with a special interest in audio programming. Please check out his website aidenfry.tk to see some of his work.

Share this:

The goals were simple – create a casual game for Halloween that we can show off to prospective clients, but maybe even capitalize on the season and make a few bucks in the process.

So, without further ado, here is a list of 10 pitfalls we either narrowly missed or in some cases fell into head first when making our first iPhone game!

Rule #1 – Don’t sacrifice quality simple because it’s your first game.

Game art and music are often overlooked during a rushed development schedule, but 9 out of 9.0001 times it’s a critical mistake. Nothing can bring down a good game design faster than “programmer art” or no sound in a game. Think of it this way – Prior to the point of people *actually paying for your game* they are already judging your work through the screenshots you show in the app store and the description that you write about it. You know the statement, “a picture is worth a thousand words”, well I’ve seen a ton of games just like this….

Never played this....

One of hundreds of thousands of games found in the iPhone app store…

Or this...

Now, I don’t know about you, but that game and the thousands like it are just looking to be skipped. This developer might have the world’s best car handling physics (I doubt it though), but no one will even get to the point of playing it because even in the store it looks terrible. I almost feel bad about calling that game out, just because I’m sure the developer put hundreds of hours in.

Seriously, don’t fall into the trap of thinking that just because you’re independent that you can’t produce something of extremely good quality. Yes, it will take you more time to develop than someone with a powerhouse of developers, artists and muscians, but you’re just going to have to be more creative. If you don’t like your artistic style, fix it or find someone who works cheap. If your procedural algorithm routines suck, fix them or find someone who can do it better.

All we’re saying is that if you don’t want a review on iTunes that says, “Pass on this one. Looks terrible and plays even worse”, make sure to put a bit of polish into the game (and the app store page as well).

Rule #2 – Don’t do ad-based marketing.

This is something we’ve learned from experience. When you’ve made a masterpiece and no one can see it, it’s a heartbreaking thing. God knows in my life how many times I’ve said, “If I could get someone to just look at my product I know they would love it”. So in a fit of desperation you put 50 dollars into an AdMob or one of the 70+ other Ad Networks to sell your 99 cent game. I guarantee that in a few minutes or hours you’ll be through that money with only a few clicks as a result and officially $49.50 in the hole.

Don’t get me wrong! Once again, there are situations where this doesn’t need to turn out like this and paying for ads might be the way to go. Hell, even if you’re game is 4.99 (or has in-app purchases) it might make more practical sense… but not much else if your game is 99 cents… or god forbid it’s free and you’re hoping to get your money back through ad support.

Rule #3 – Do you have a ton of players? Maybe in-game ads aren’t for you.

Does your ad really need to cover everything?

Maybe your game isn’t selling well or maybe you feel like offering a free “ad supported” version of the game. Adding ads to support the project – especially – when it hasn’t been planned from the start – is just not worth it. Don’t get me wrong, there are games that make money with AdMob and the like, but the other 99.997 percent of indie developers will not even make the minimum to get paid out. When you have 100k active and dedicated players of your game, then you can make the deals through sponsorship and ad buys, but if you’re starting out, it’s just better to stay true to the game.
The worst, I mean the worst, is when you decide to add new ads into a game that wasn’t built to support ads. We’ve definitely been there before…

Even if the view isn’t obstructed by some terrible and unrelated ad, it still most likely won’t be clicked on and has the very real potential of sucking the player out of the game. Something you don’t want from a very real customer, who might have had a better experience with a non-ad supported version and actually bought the game.

Risk alienating a few players after you have more than enough to spare. What number is that? I don’t know yet. Maybe someone in the comments will have a good answer

Rule #4 – Release, update, update, update aaaaand update

Personally, I am a firm believer in having a roll out schedule after the first major release. You need to keep people playing your game while at the same time building the next one. Rovio (creators of Angry Birds) have built a $2 billion company out of some lovable characters and additional new content. Can you name another company that has done that? Does Disney sound familiar? Remember content is king and if you want to rule, give the people what they want. I know, I know, it’s hard to do this for free, but on a long enough timeline it could pay dividends.

Dedicated fans can be your best friends in the world, so don’t ignore their suggestions and comments (iPhoneGameTutorials.com could learn this lesson again). Here are a few things you can do in your game to empower your players and have them stay around longer:

1. Update your content regularly – Put in additional levels and/or new content on a weekly or bi-weekly basis! You game isn’t level based? Then fix the bugs!
2. Give users a place to communicate about your game and to offer their feedback – Don’t force them to have a conversation through their ratings
3. Add passive achievements and badging to your game – give people a reason to keep your game installed for months
4. Put in sharing features for Twitter and/or Facebook for easy sharing – people usually have similar friends, those similar friends might download your game.

If it wasn’t for some loyal readers comments these last few months, our site would be all but barren. So remember, keep the people who keep coming back happy – give them what they want: tons of porn [Editor's Note: I think he means CONTENT].

Rule #5 – Remember the importance of having a good time during development

If I could only post one rule more than once… this might be it!

You may not know it yet, but making an awesome product is seriously hard work. When you’re pushing to meet deadlines the business of games can be an uphill battle the whole way. No one has ever said love is easy and doing something by yourself that you love is no less difficult. Always keep in mind the reason you’re building the game you are and don’t sweat the small stuff as it were.

One way to do this is to work within the framework of small goals. They allow you create a feedback cycle with yourself. Code a little, debug a little, feel good to see your game doing a little bit more cool stuff. The worst parts of any development are the big things that take a long time to finish, because you risk losing that joy of accomplishment while you work on it.

Rule #6 - Don’t re-invent the wheel, or the game engine.

It’s very easy to focus too much on developing the framework or game engine, and too little about making the actual game. You risk getting all entangled up in the nitty gritty and never actually get around to actually building anything.

You’ll notice we use Cocos2d (download) on this site a ton of times, because it works for the games we want to create. Could we create our own OpenGL wrapper game engine? Sure we could, but what’s the point when there are already some fantastic packages with established communities! Currently there are several open source game engines to choose from, and many cropping up all the time. Our advice is take a look at some of the packages we go over on this site or type “iPhone Game Engines” and you’ll find a million and one comparisons.

Never forget you are first and foremost making a game – not a middle-ware component. You should not start by coding the math library but instead by figuring out how to make the game entertaining.

Rule #7 – The work you do after you finish development is just as important as building the game itself.

You should push your game whenever you can. Why? Because you’re indie. Nobody knows you. You absolutely need to get yourself out and start building your brand as early as you possibly can. You can’t expect to have the next big hit, so you need to start dipping your toes into the water early. Marketing is hard, but so is building a game and you’ve already started that – just go a little farther!

Building a brand can be a full-time position. Spend an hour or two everyday talking to your community or other people to help them discover you. Above all else, be proud of the work you’ve put into your game and continue to put into it. So, if you create something, show it off, tell people about it, talk about it whenever you can – you’ve put weeks or months into it… be proud.

Rule #8 – Analytics (know how your audience plays your game).

How many people have played your game today? How many people turned off the sound? How many people turned off the music? How many people played and lost level 17? You should know this. Don’t let analytics fall into a “nice to have” category. After you’ve released the the app and people are installing it around the globe, the usage metrics can be some of the most informative information about how people are using your game and where you can make improvements.

Rule #9 – The value in adorable/cute/sweet/awesome characters

The more I watch, read and learn the more I realize the power of cute.

Aww, how cute... and so very angry

Rovio is making a killing this way – did you know they opened their first store dedicated to their plush stuffed characters in Helsinki, Finland? This really does come back to the idea of polish – you need to make a game that really is not just fun to play, but is something that will make people feel comfortable sharing with their friends.  Or paying $15.99 for a stuffed green pig.

Rule #10 - Prefer game concepts / game updates which have a fast development time
Experience / Experience / Experience… As you roll out new versions or even new games entirely, keep in mind the development time. Your game is competing against big and small alike and it’s better to do the job right once with a good amount of planning than to bite off more than you can chew. So instead of improving the core mechanic and seeing how your fans react, you spend 6 months trying to get every last feature into release 2.0. This will alienate your users and most likely the game will float out of their consciousness and off of their phones!

So, what are your thoughts about the biggest mistakes an indie game developer can make? Have you ran into any of these or have ways to avoid them? Tell us in the comments below!

Share this:

We felt that it was important to mention Steve Jobs on our site today – a site based on the great devices and technology he pioneered. We are all very sad at the passing of a man who was a designer first and a CEO second.

Now, I’ve been using Apple products virtually my entire life (starting with my Apple II) and have been amazed that with each new product released the bar has been continually raised. At our offices today we have multiple Macbook Pros, iPods, iPhones and iPads on virtually every work surface. This is not just because we do development with these devices, but because we genuinely enjoy using these products and find them to be essential in our personal lives as well. So, we’ve put together a list of influential years in Steve Job’s life that we think exemplify how much he has changed the personal computer, mobile and tablet landscape over the years:

1977: First Successful Personal Computer
1984: The Macintosh
1985: NeXT Computer – Jobs starts again.
1996: Apple buys NeXT and makes Jobs CEO again.
2000: Jobs introduces a new way of thinking about design for personal computers
2001: The iPod.
2006: Jobs redefines the laptop with the MacBook
2007: iPhone makes its debut
2010: The iPad brings tablets to the foreground.

For a man who helped create so much, we would like to thank him for his contributions and look forward to Apple continuing his legacy of great products in the years to come.

Sincerely,
iPhoneGameTutorials

Share this: