Shooting some lasers

Did you think that the backpack-reactor was Dr. Fringe's only invention? You were wrong; he needs some kind of weapon to face the aliens and fortunately, he has developed some high tech lasers. So let's allow him to shoot them when we touch the screen.

First add the required image:

We're going to declare an array of lasers so we can keep control of them, so add these two private instance variables after int _numUFOs;:

    // Declare array of green lasers
    NSMutableArray *_arrayLaserGreen;
    
    // Max number of lasers in scene
    int _numLaserGreen;

Initialize the variables in the init method by adding the following code before return self;:

    // Initialize the array of green lasers
    _numLaserGreen = 5;
    _arrayLaserGreen = [NSMutableArray arrayWithCapacity:_numLaserGreen];

Dr. Nicholas Fringe's invention is still in the beta phase, that's why he can't shoot more than five laser beams at the same time. We need to enable touch interaction, something that we already know how to do. In the init method, add the following line at the end before return self;:

self.userInteractionEnabled = YES;

Implement touchBegan by adding these lines to GameScene.m:

-(void) touchBegan:(UITouch *)touch withEvent:(UIEvent *)event {
    
    if ([_arrayLaserGreen count] < _numLaserGreen){
        // Create green laser and setting its position
        CCSprite *laserGreen = [CCSprite spriteWithImageNamed:@"laser_green.png"];
        laserGreen.position = CGPointMake(_scientist.position.x + _scientist.contentSize.width / 4, _scientist.position.y + _scientist.contentSize.height / 2);        
        // Add laser to array of lasers
        [_arrayLaserGreen addObject:laserGreen];
        
        // Add the laser to the scene
        [self addChild:laserGreen];
        
        // Declare laser speed
        float laserSpeed = 400.0;
        
        // Calculate laser's final position
        CGPoint nextPosition = CGPointMake(laserGreen.position.x, _screenSize.height + laserGreen.contentSize.height / 2);
        
        // Calculate duration
        float laserDuration = ccpDistance(nextPosition, laserGreen.position) / laserSpeed;
        
        // Move laser sprite out of the screen
        CCActionMoveTo *actionLaserGreen = [CCActionMoveTo actionWithDuration:laserDuration position:nextPosition];
        
        // Action to be executed when the laser reaches its final position
        CCActionCallBlock *callDidMove = [CCActionCallBlock actionWithBlock:^{
            
            // Remove laser from array and scene
            [_arrayLaserGreen removeObject:laserGreen];
            [self removeChild:laserGreen];
            
        }];
        
        CCActionSequence *sequenceLaserGreen = [CCActionSequence actionWithArray:@[actionLaserGreen, callDidMove]];
        
        [laserGreen runAction:sequenceLaserGreen];
    }
}

The very first thing we're doing is checking whether we have shot the maximum number of laser beams. If not, we create a new one, setting its position by the laser gun and adding it to the scene and the array of green lasers.

Each laser will trace a vertical path from its initial shooting position to the top, off the screen. That's why we're calculating the final position as the same x axis value and _screenSize.height + laserGreen.contentSize.height / 2 on the y axis. This is the same approach we take every time we want to place some sprite off the screen, so it's nothing new to us.

As we want the laser to always move at the same speed, we specify its velocity to calculate the duration of the movement and we make this calculation in the same way we did in the previous chapter: divide the distance to be covered by the laser's speed.

Then we create a CCActionMoveTo instance with the calculated direction and the final position. Once the move action ends, we want the laser to disappear from both the scene and the array, so we implement a CCActionCallBlock action where we place this logic.

As the last instruction, we build a sequence with the movement action and the action block and run it. Build and run your game and look what we've just done.

When UFOs collide

Despite being in the beta phase, Dr. Fringe's laser beams can destroy the alien's spaceships, so let's implement collision detection for this purpose.

When a laser beam hits a UFO, on one hand the spaceship's number of hits will decrease for one unit, and on the other hand, the laser will disappear from the scene. The same will happen to the UFO when its number of hits is 0.

First let's declare and implement an instance of the UFO method to check whether its number of hits has reached 0 or not. In UFO.h, add the following line just after the initWithHits method:

// Declare check method
-(BOOL) checkNumHits;

Then in UFO.m, implement checkNumHits by adding these lines at the bottom of the file, before the @end clause:

// Implement checkNumHits
-(BOOL) checkNumHits{
   
    if(_numHits == 0) {
        // Remove UFO from scene and return TRUE
        [self removeFromParent];
        return TRUE;
    }
    
    return FALSE;
}

This method will look at _numHits. If the _numHits instance variable equals 0, and in that case, it will remove the object from its parent (the scene) and return TRUE. For any other _numHits instance variable, it will return FALSE.

Back to GameScene.m. We are going to develop a method to wrap collision detection tasks. In the update method, add the following lines at the end:

    // Collision detection
    [self detectCollisions];

Implement the method by pasting the following lines:

-(void)detectCollisions {
    
     CCSprite *laserGreen;
    
     // For each UFO on the scene
     for(UFO *ufo in _arrayUFOs) {
        
        // For each laser beam shot
        for (laserGreen in _arrayLaserGreen){

            // Detect laserGreen-ufo collision
            if (CGRectIntersectsRect(ufo.boundingBox, laserGreen.boundingBox)) {
                
                CCLOG(@"COLLISION DETECTED");

                // Decrease UFO's number of hits
                ufo.numHits--;
                
                // Check if numHits is 0
                if ([ufo checkNumHits]) {                    
                CCLOG(@"UFO DESTROYED");
 }
            }
        }
}
}

We're iterating the green lasers and the spaceships array and trying to detect a collision between their rectangles. When a collision happens, we decrease the UFO number of hits and we check whether it should be destroyed. In that case, we remove the object from the scene. However, at the moment it won't work properly. If you run the object, you will realize that's because once we destroy the first _numUFOs spaceships, no more are spawned.

This is due to the fact that we aren't removing the destroyed spaceships from the array. You may be thinking that making an object disappear from the scene has a straightforward solution: remove the object from the array and the child from the scene, but it's not that simple.

If you want to try it, add this line after CCLOG(@"UFO DESTROYED");:

[_arrayUFOs removeObject:ufo];

Run the project again and shoot until you destroy one UFO.

There you have it, the app crashed due to an uncaught exception:

Terminating app due to uncaught exception 'NSGenericException', reason: '*** Collection <__NSArrayM: 0x17805b900> was mutated while being enumerated.'
***

If you pay attention to the log message, it makes sense. It's warning us that we're modifying the array while it's being enumerated (iterated) and this is a forbidden action.

So, how can we deal with it? The approach followed by game developers is to create a separate array to store the objects we want to delete and then proceed to remove them as soon as the loop ends.

As we will have the same problem with laser beams if we try to remove them when a collision happens, we will apply a similar approach.

First of all, delete the line to remove the spaceship from arrayUFOs and declare two new arrays after int _numLaserGreen;:

    // Array of removable laser beams
    NSMutableArray *_lasersGreenToRemove;
    
    // Array of removable UFOs
    NSMutableArray *_ufosToRemove;

Initialize them at the end of the init method, just after self.userInteractionEnabled = YES;:

    // Initialize removable objects arrays
    _lasersGreenToRemove = [NSMutableArray array];
    _ufosToRemove = [NSMutableArray array];

Then, in detectCollisions, find the following line:

    CCLOG(@"COLLISION DETECTED");

Replace it with:

    // Stopping laser beam actions
    [laserGreen stopAllActions];
                
    // Adding the object to the removable objects array
    [_lasersGreenToRemove addObject:laserGreen];
                
    // Remove the laser from the scene
    [self removeChild:laserGreen];

Then find the line:

 CCLOG(@"UFO DESTROYED");

Replace it with the following ones:

    // Stopping ufo actions
    [ufo stopAllActions];
                    
    // Adding the object to the removable objects array
    [_ufosToRemove addObject:ufo];

Finally, add these lines after the _arrayLaserGreen loop:

  for (CCSprite *laserGreen in _arrayLaserGreen){
 .
 .
 .
  }
  // Remove objects from array
  [_arrayLaserGreen removeObjectsInArray:_lasersGreenToRemove];

Add this one after the _arrayUFOs loop:

 for(UFO *ufo in _arrayUFOs) {
  .
  .
  .
  }
  // Remove objects from array 
  [_arrayUFOs removeObjectsInArray:_ufosToRemove];

Remember that we aren't removing UFOs from the scene in this method because we're already performing this task inside checkNumHits.

If you run the game now, you will find that each spaceship's spawn/destruction and the laser beam's shooting and disappearing functions are working correctly.