Implementing Space Demon iPhone Game Part 2 (Refactoring)

In the last article we wrote all the code in the same file. This is called Spagetti coding and it will become a further mess in the future when you want to make changes to the game. It is always a good idea to refactor the code as you develop. In this article you will also notice that a lot of code has been refactored and separated into smaller classes.

Environment Class:

In the previous implementation we had a method called "buildSeaOfFire" which was responsible for created the background of the game. The method was part of the main game layer. In the latest version of the codebase we have moved the code to a new class called Environment.m. The header and the implementation files are shown below:

view sourceprint?
01
#import
02
 
03
#import "cocos2d.h"
04
 
05
@interface Environment : NSObject {
06
 
07
CCLayer *layer;
08
 
09
}
10
 
11
-(void) setup;
12
 
13
@property (nonatomic,retain) CCLayer *layer;
14
 
15
@end
16
 
17
//
18
 
19
//  Environment.m
20
 
21
//  HelloCocos
22
 
23
//
24
 
25
//  Created by Mohammad Azam on 12/14/10.
26
 
27
//  Copyright 2010 HighOnCoding. All rights reserved.
28
 
29
//
30
 
31
#import "Environment.h"
32
 
33
#import "Scoreboard.h"
34
 
35
@implementation Environment
36
 
37
@synthesize layer;
38
 
39
-(Environment *) initWithLayer:(CCLayer *) l
40
 
41
{
42
 
43
self = [super init];
44
 
45
self.layer = l;
46
 
47
return self;
48
 
49
}
50
 
51
-(void) setup
52
 
53
{
54
 
55
int x=0;
56
 
57
int y = 0;
58
 
59
CCParticleFire *emitter = [[CCParticleFire alloc]init];
60
 
61
CGSize windowSize = [[CCDirector sharedDirector] winSize];
62
 
63
y = windowSize.height + 50;
64
 
65
int noOfFireBallsNeeded = windowSize.width / emitter.texture.contentSize.width;
66
 
67
for(int i=1; i<=noOfFireBallsNeeded;i++)
68
 
69
{
70
 
71
CCParticleFire *seaOfFire = [[CCParticleFire alloc] init];
72
 
73
[seaOfFire setStartSize:10];
74
 
75
[seaOfFire setEmissionRate:10];
76
 
77
[seaOfFire setLife:20];
78
 
79
[seaOfFire setGravity:ccp(0,-90)];
80
 
81
seaOfFire.position = ccp(x,y);
82
 
83
[self.layer addChild:seaOfFire z:-1];
84
 
85
x += emitter.texture.contentSize.width;
86
 
87
}
88
 
89
}
90
 
91
@end

The Enviroment.m class can be instantiated using the custom constructor called initWithLayer. The initWithLayer constructor takes in the layer and then assigns to a public property exposed by the Environment.m class.

The main game layer can now use the Environment class inside the constructor init:

view sourceprint?
1
// setup the environment = sea of fire
2
 
3
Environment *env = [[Environment alloc] initWithLayer:self];
4
 
5
[env setup];

As you can see the above approach is much cleaner than adding all the code in the game layer file. In the next section we will describe how we created separate classes for the Demon and the Spaceship.

Implementing Demon:

Once again you can always go ahead and create a CCSprite property in the game layer file and then use that as your Demon but it is always a good idea to keep responsibilities separate. The main layer should not be responsible for controlling the Demon. It is the responsibility of the Demon class to control the activities performed by the Demon. The Demon class header  file is shown below:

view sourceprint?
01
//  Demon.h
02
 
03
//  HelloCocos
04
 
05
//
06
 
07
//  Created by Mohammad Azam on 12/14/10.
08
 
09
//  Copyright 2010 HighOnCoding. All rights reserved.
10
 
11
//
12
 
13
#import <Foundation/Foundation.h>
14
 
15
#import "cocos2d.h"
16
 
17
#import "Spaceship.h"
18
 
19
#import "BaseEntity.h"
20
 
21
@interface Demon : BaseEntity {
22
 
23
CCSprite *sprite;
24
 
25
CCLayer *layer;
26
 
27
CCParticleSun *fireball;
28
 
29
Spaceship *spaceship;
30
 
31
}
32
 
33
-(void) start;
34
 
35
-(void) fire;
36
 
37
-(void) hit;
38
 
39
@property (nonatomic,retain) CCSprite *sprite;
40
 
41
@property (nonatomic,retain) CCLayer *layer;
42
 
43
@property (nonatomic,retain) CCParticleSun *fireball;
44
 
45
@property (nonatomic,retain) Spaceship *spaceship;
46
 
47
@end

The first thing to note about Demon class is that instead of inheriting from NSObject it inherits from the BaseEntity class. The BaseEntity class contains properties which will be used by most of your classes. One of those property is called windowSize which is used to retrieve the screen size of the iPhone or the iPad.

The Spaceship class looks similar to the Demon class. The header file implementation is shown below:

view sourceprint?
01
#import "cocos2d.h"
02
 
03
#import "BaseEntity.h"
04
 
05
@interface Spaceship : BaseEntity {
06
 
07
CCSprite *sprite;
08
 
09
CCParticleMeteor *laser;
10
 
11
CCLayer *layer;
12
 
13
CCParticleSmoke *smoke;
14
 
15
}
16
 
17
-(void) move:(CGPoint) location;
18
 
19
-(void) fire;
20
 
21
-(void) destroyLaser;
22
 
23
-(void) hit;
24
 
25
-(void) generateSmoke;
26
 
27
-(void) destroy;
28
 
29
@property (nonatomic,retain) CCSprite *sprite;
30
 
31
@property (nonatomic,retain) CCParticleMeteor *laser;
32
 
33
@property (nonatomic,retain) CCLayer *layer;
34
 
35
@property (nonatomic,retain) CCParticleSmoke *smoke;
36
 
37
@property (nonatomic,retain) CCParticleFire *explosion;
38
 
39
@end

By separating the responsibility into different classes your code looks more cleaner and can be changed easily for future updates.

Conclusion:

In this article we took the old codebase and refactored the code. The refactoring will allow us to make future changes easily with less headache. In the next article we will dive into the details of putting the Demon and the Spaceship on the screen and starting the war.