Cocos2d开发系列（七）

Learn IPhoneand iPad Cocos2d Game Delevopment》第8章 。

这种类型的游戏（shoot’emup游戏）最重要的是什么？射击的目标和需要躲避的子弹。本章，将为游戏添加一些敌人以及一个大 boss。

敌人和玩家将使用新的BulletCache 类射击不同的子弹，这些子弹来自同一个 pool。这个缓冲类会重用无效的子弹，以避免重复的内存分配和释放动作。同样，敌人会使用EnemyCache 类，因为待会屏幕上会出现成堆的敌人。

显然玩家可以向敌人射击。我会介绍基于组件编程的概念，用一种模板化的方式扩展游戏角色。除了 shooting 组件和 moving 组件，我们还会为 boss 老怪创建 healthbar 组件（生命值，俗称“血槽”）。毕竟，老怪不应该是一下就能pk 掉的，其生命值总是被一点点减少直至彻底干掉它。

一、添加 BulletCache 类

该类在是 “一站式” 的，可以一次性生成许多子弹。原来这些代码是放在 GameScene 类中，但这（指生成子弹）显然不该由 GameScene 来管。下面显示 BulletCache 的头文件，它包括了CCSpriteBatchNode 对象和无效子弹计数器nextInactiveBullet：

#import "cocos2d.h"

@interface BulletCache : CCNode {

CCSpriteBatchNode* batch;

int nextInactiveBullet;

}

-(void) shootBulletAt:

(CGPoint)startPositionvelocity:(CGPoint)velocity

frameName:(NSString*)frameName;

@end

为了把 代码重构到 GameScene类之外，我需要把 initialization 方法和射击子弹的方法移到 BulletCache 类（代码见后）。接着，我决定使用一个CCSpriteBatchNode 变量，以免在每次需要这个对象时就得调用一次[CCNode CCSpriteBatchNode]方法。这会带来细微的性能优化。由于我会在类 GameScene 中加入 BulletCache 对象，因此很容易就能把 sprite batch node 传给 BulletCache。

注意，新的 BulletCache有一个问题，增加了scene的层次——一个额外的 CCNode。如果你担心这点，你也可以把 sprite batch node放在GameScene类中，用一个方法从BulletCahce 获取这个 sprite batch node。

但是，额外的函数调用开销有可能会使性能得以下降。如果你怀疑是不是真的对性能由影响，那就让你的代码可读性更好些。当有必要进行性能优化的时候再重构你的代码。

#import "BulletCache.h"

#import "Bullet.h"

@implementation BulletCache

-(id) init {

if ((self = [super init])) {

// 从当前贴图集中获得角色帧

CCSpriteFrame* bulletFrame =[[CCSpriteFrameCache sharedSpriteFrameCache]

spriteFrameByName:@"bullet.png"];

// 使用角色帧的贴图构建CCSpriteBatchNode

batch = [CCSpriteBatchNodebatchNodeWithTexture:bulletFrame.texture];

[self addChild:batch];

// 创建子弹并加到 batch

for (int i = 0; i < 200; i++) {

Bullet* bullet =[Bullet bullet];

bullet.visible =NO;

[batchaddChild:bullet];

}

return self;

}}

-(void) shootBulletAt:(CGPoint)startPositionvelocity:(CGPoint)velocity frameName:(NSString*)frameName{

CCArray* bullets = [batch children];

CCNode* node = [bullets objectAtIndex:nextInactiveBullet];

NSAssert([node isKindOfClass:[Bulletclass]], @"not a Bullet!");

Bullet* bullet = (Bullet*)node;

[bullet shootBulletAt:startPositionvelocity:velocity frameName:frameName];

nextInactiveBullet++;

if (nextInactiveBullet >= [bulletscount]) {

nextInactiveBullet= 0;

}

}

@end

shootBulletAt方法已经完全变了。它有3个参数：startPosition，velocity和frameName——取代 Ship类指针。然后这些参数被传递给 Bullet 类的 shootBulletAt 方法，这个方法现在已经变为：

-(void) shootBulletAt:(CGPoint)startPositionvelocity:(CGPoint)vel frameName:(NSString*)frameName {

self.velocity = vel;

self.position = startPosition;

self.visible = YES;

// 改变子弹的贴图，设置一个不同的角色帧去显示

CCSpriteFrame *frame = [[CCSpriteFrameCachesharedSpriteFrameCache] spriteFrameByName:frameName];

[self setDisplayFrame:frame];

[self scheduleUpdate];

}

velocity 和position 被直接赋值给 bullet。这意味着调用 shootBulletAt 方法的代码必需自己决定子弹的位置、方向和速度。这出于这样的考虑：子弹射击的动作会适应更多的变化，包括可以改变子弹的角色帧（用setDisplayFrame 方法）。因为子弹使用的是相同的贴图集、相同的贴图，所以需要通过设置相应的贴图帧来改变子弹的显示。实际上，渲染贴图的不同部分很轻松，并不会带来额外的开销。

在编辑 Bullet 类时，我还修正了一个边界问题——只有子弹移出屏幕右边时，才会设为不可见并被放会重用列表（其实这是一个bug）。通过在update方法中使用 CGRectIntersectsRect 检查子弹的边框和屏幕矩形，任何完全移出屏幕的子弹都会被标记为重用：

// 子弹离开屏幕后，设为不可见

if (CGRectIntersectsRect([self boundingBox], screenRect) ==NO) {

……

}

screenRect变量出于方便和性能的原因，被存储为static 变量，因此它能被其他类访问，并不需要每次使用的时候创建。static 变量在类实现文件中声明并有效，比如 screenRect。它们就像类的全局变量，任何类实例都可以读取和修改。成员变量则不同，它们只存在于每个实例对象中。因为屏幕尺寸在游戏期间永远不会变，所有的子弹都需要用到它，把它存储为所有实例的static变量显然是行得通的。第一个实例负责给 screeenRect 赋值。 CGRectIsEmpty 方法负责检查 screenRect 变量是否未初始化——因为是static变量，只需要初始化一次就行了。

static CGRect screenRect;

......

// 确保只初始化一次

if (CGRectIsEmpty(screenRect)) {

CGSize screenSize = [[CCDirectorsharedDirector] winSize];

screenRect = CGRectMake(0, 0,screenSize.width, screenSize.height);

}

接下来，移除GameScene 类中原有的用于射击子弹的代码。此外，需要用初始化 BulletCache 来替换初始化 CCSpriteBatchNode （在GameScene 的 init 方法中）：

BulletCache* bulletCache = [BulletCache node];

[self addChild:bulletCache z:1tag:GameSceneNodeTagBulletCache];

还需要为 bulletCache 添加一个访问方法以便其他类通过GameScene访问BulletCache实例：

-(BulletCache*) bulletCache {

CCNode* node = [self getChildByTag:GameSceneNodeTagBulletCache];NSAssert([node isKindOfClass:[BulletCache class]], @"not aBulletCache"); return (BulletCache*)node;

}

InputLayer 现在可以用BulletCache 发射子弹了。 子弹的位置、速度和所用的角色帧这些属性， 应当在 InputLayer 的update方法里传递给射击方法：

if (fireButton.active && totalTime> nextShotTime) {

nextShotTime = totalTime + 0.5f;

GameScene* game = [GameScenesharedGameScene];

Ship* ship = [game defaultShip];

BulletCache* bulletCache = [gamebulletCache];

// 射击前设置 position, velocity h和 spriteframe

CGPoint shotPos = CGPointMake(ship.position.x+ [ship contentSize].width * 0.5f, ship.position.y);

float spread = (CCRANDOM_0_1() - 0.5f) *0.5f;

CGPoint velocity = CGPointMake(1, spread);

[bulletCache shootBulletAt:shotPos velocity:velocityframeName:@"bullet.png"];

}

重构后的射击过程添加了一些非常必要的灵活性。你可以设想一下，敌人现在可以使用同样的代码发射它们自己的子弹了。

二、敌人

此刻，对于敌人我们仅有一个模糊的概念，它们是干什么的？它们的行为是什么？对于敌人，最重要的是——你永远不知道他们该干什么。

就游戏而言，这意味着一切都要从头开始，要策划出你想让敌人做的事情，从而分析需要编写的代码。与真实世界不同，你完全控制着你的敌人们。是不是觉得自己很伟大？但在你或者其他人感到好笑之前，你需要为统治世界想出一个计划。

我创建了3种不同类型的敌人的图片。这里，我只知道其中一个应该是Boss。看一眼下面的图片，然后想象一下这些敌人分别能干些什么：

在写代码之前，先了解一下这些敌人有哪些行为是共性的，这样有些代码只用编写一次。代码复用是最重要的编码规范。我们先来看看敌人们都有哪些共性：

¥ 发射子弹

¥ 何时何地发射子弹的判断逻辑

¥ 能被玩家的子弹击中

¥ 不能被其他敌人的子弹击中

¥ 能被多次击中（有生命值）

¥ 有固定的行为和移动方式

¥ 死亡时显示特定的行为或动画

¥ 从屏幕以外进入屏幕后将会显示

¥ 当移出屏幕后将不再显示

你可能注意到，上面有些特性也符合玩家飞船。飞船也可以射击子弹，它也可能经受多次射击；当它被摧毁时也应该呈现某个行为或动画，它给人的感觉类似一个特殊的敌人。

扫描上述列表，会有3种实现方式。可以创建一个类，把飞船、敌人、Boss都包含在其中。代码将是有选择地执行部分代码，这取决于敌人的类型。例如，射击代码可能为不同的类型提供不同的分支。对于对象有限的游戏，这是不错的办法——但它无法面对大规模的对象。随着游戏中加入越来越多地对象，你的游戏代码必将变得肥大臃肿。对这个类的任何部分进行修改，都会潜在地对敌人或者飞船的行为带来不希望的影响。用一个变量——敌人类型来决定代码执行路径是一种古老的C 编程方式，不符合 O-C 的面向对象特性。

这种方式至今仍然非常有用，但一定要慎用。

第二种方式，是创建一个类层次。用一个Entity类作为基类，从它派生出一个飞船类、2个怪物类、1个Boss类。很多程序员常这样干，对于游戏对象不多的情况这种方式也非常好用。但本质上，这和第一种方式没什么不同。基类封装了子类要用到的一些通用代码，但不是全部代码。当Entity类中的代码开始基于某个子类的类型执行某个分支时，情况变得糟糕——跟第一种方法一样了。如果小心一点，你应该确保把针对某种敌人的代码放在某个子类里，但在修改的时候很容易会把很多改动放到Entity类里。

第3种方式，是使用组件编程。这意味着不同的代码路径从Entity类层次结构中分离出来，这部分代码仅仅加到所需的子类中。比如一个“血槽”组件。基于组件的编程可以单独写成一本书，对于射击游戏这类项目而言，这显得有些杀鸡用牛刀了，因此我会混合后面两种方式一起使用，这里只是给出一个概念：

如何组合游戏对象而不是各自为政，以及这样做的好处。

我想说明的是，不存在最好的编码方式。选择某种方式完全是主观的，取决于个人经验和偏好。如果你愿意随着对手上开发的游戏的逐渐理解，不断重构你的代码库，能运行的代码比干净的代码更可取。经验让你不经过计划就能做出这些决定，让你能更快地创建更多复杂游戏。要想达到这个目的，从完成一个小游戏开始，然后慢慢地挑战自己的极限。这是个需要学习的过程，很不幸的，在这个过程中你的学习兴趣也很容易被好高骛远消灭掉。为什么每个老练的游戏编程人员会告诉新人，从简单入手，去重写经典的电玩游戏比如俄罗斯方块、帕克人、小行星。

三、Entity类

Entity 类是继承自 CCSprite，只包含了Ship类中的setPosition方法定义，以使所有的Entity 实例始终在屏幕内移动。我只对代码做了一小点改动（其实就是如下面代码所示的if语句，原来的代码是没有if语句的），屏幕外的对象可以移动到屏幕内，但一旦进入屏幕后，它们不能再离开屏幕区域。在这个射击类游戏中，敌人不会从你身边走开，而是站在屏幕中间为了演示一下EnemyCache，进行简单的介绍。屏幕区域检查只是简单检查一下sprite的边框是否完全被屏幕边框所包含，如果是的话，代码将让sprite始终保持在屏幕边框内：

-(void) {

}

setPosition:(CGPoint)pos

// 如果当前位置在屏幕外，则不需要让位置调整到屏幕内

// 这会允许对象从屏幕外部移动到屏幕内部

if (CGRectContainsRect([GameScene screenRect], [selfboundingBox])) {

...

[supersetPosition:pos];

}

ShipEntity类取代了Ship类。由于Entity类已经包含了setPosition方法，ShipEntity类只剩下了initWithShipImage方法。该方法的代码没有改变。

四、EnemyEntity类

我们需要继续深入到EnemyEntity类，首先是头文件：

#import <Foundation/Foundation.h>

#import"Entity.h"

typedef enum{

EnemyTypeBreadman = 0,

EnemyTypeSnake,

EnemyTypeBoss,

EnemyType_MAX,

} EnemyTypes;

@interface EnemyEntity : Entity {

EnemyTypes type;

}

+(id) enemyWithType:(EnemyTypes)enemyType;

+(int) getSpawnFrequencyForEnemyType:(EnemyTypes)enemyType;

-(void) spawn;

@end

没有什么特别的。EnemyTypes 枚举用于3种不同的敌人类型，EnemyType_MAX用于在遍历时标志结束。EnemyEntity类使用了一个EnemyTypes变量存储类型，因此我可以用switch命令基于敌人的类型构建分支语句。EnemyEntity的实现包含许多代码，我会把它分成几个主题，并只显示相关的代码。首先是initWithType方法：

-(id) initWithType:(EnemyTypes)enemyType

{

type = enemyType;

NSString* frameName;

NSString* bulletFrameName;

int shootFrequency = 300;

switch (type)

{

case EnemyTypeBreadman:

frameName= @"monster-a.png";

bulletFrameName= @"candystick.png";

break;

case EnemyTypeSnake:

frameName= @"monster-b.png";

bulletFrameName= @"redcross.png";

shootFrequency= 200;

break;

case EnemyTypeBoss:

frameName= @"monster-c.png";

bulletFrameName= @"blackhole.png";

shootFrequency= 100;

break;

default:

[NSException exceptionWithName:@"EnemyEntityException" reason:@"unhandled enemytype" userInfo:nil];

}

if((self = [super initWithSpriteFrameName:frameName]))

{

//Create the game logic components

[self addChild:[StandardMoveComponent node]];

StandardShootComponent* shootComponent = [StandardShootComponent node];

shootComponent.shootFrequency= shootFrequency;

shootComponent.bulletFrameName= bulletFrameName;

[self addChild:shootComponent];

//enemies start invisible

self.visible = NO;

[self initSpawnFrequency];

}

return self;

}

方法一开始是变量赋值，根据敌人的类型，使用switch语句为每种类型提供默认值：敌人的角色帧名以及子弹的角色帧名。switch的default分支抛出异常，因为其他类型在Enemytypes枚举中未定义。这样，如果你定义了一种新的敌人类型，但是如果它不会动，或者发射出了错误的子弹，那么你会得到一个错误警告：哈，你忘记修改某些东西了！

最后别忘了调用[super init…]方法，否则super无法正确初始化并导致一个奇怪的错误然后崩溃。

接下来创建了一个组件，并把它加到EnemyEntity中。后面我会访问这个组件，在此你只需要知道StandardMoveComponent 能让敌人移动并射击。

把注意力放到initSpawnFrequency方法。

-(void) initSpawnFrequency

{

// initialize how frequent the enemies willspawn

if(spawnFrequency == nil)

{

spawnFrequency = [[CCArray alloc] initWithCapacity:EnemyType_MAX];

[spawnFrequency insertObject:[NSNumber numberWithInt:80] atIndex:EnemyTypeBreadman];

[spawnFrequency insertObject:[NSNumber numberWithInt:260] atIndex:EnemyTypeSnake];

[spawnFrequency insertObject:[NSNumber numberWithInt:1500] atIndex:EnemyTypeBoss];

//spawn one enemy immediately

[self spawn];

}

}

+(int) getSpawnFrequencyForEnemyType:(EnemyTypes)enemyType

{

NSAssert(enemyType < EnemyType_MAX, @"invalidenemy type");

NSNumber* number = [spawnFrequency objectAtIndex:enemyType];

return [number intValue];

}

-(void) dealloc

{

[spawnFrequency release];

spawnFrequency = nil;

[super dealloc];

}

我们把每种类型的敌人的出场频率记录在静态数组spawnFrequency里。第一个EnemyEntity实例负责初始化CCArray数组。CCArray不能存储原始数据类型比如整型，因此使用了NSNumber类。使用insertObject方法而不用addObject方法是为了保证对象加入时的顺序，同时别人看到这个枚举值也映射了对应的敌人类型。

dealloc方法释放了CCArray对象，并将其设为nil，这点非常重要。作为静态变量，第一个EnemyEntity对象在运行其dealloc方法时会释放spawnFrequency的内存，如果spawnFrequency不被设为nil，下一个EnemyEntity对象的dealloc方法将视图再次释放，这会“过度释放”spawnFrequency对象，导致程序崩溃。如果spawnFrequency为nil，任何发给它的消息都会被忽略，包括release消息。

spawn方法用于“生成”一个游戏对象：

-(void) spawn

{

CCLOG(@"spawn enemy");

// Select a spawn location just outside theright side of the screen, with random y position

CGRect screenRect = [GameScene screenRect];

CGSize spriteSize = [self contentSize];

float xPos = screenRect.size.width + spriteSize.width * 0.5f;

float yPos = CCRANDOM_0_1() * (screenRect.size.height - spriteSize.height)+ spriteSize.height * 0.5f;

self.position = CGPointMake(xPos, yPos);

// Finally set yourself to be visible, this alsoflag the enemy as "in use"

self.visible = YES;

}

因为EnemyCache用于统一创建所有的敌人，这里整个spawn 方法只是设定一个随机数的y坐标，x坐标是在右侧屏幕以外。visible属性在其他地方会用到，尤其是在组件类中，用于判断EnemyEntity当前是否已使用。如果visible为NO，它可以被“生出”并显示，如果为YES，它就会按照固定的逻辑运行。

五、EnemyCache类

从名字上看，这会让你想到BulletCache类，它也持有了大量已初始化对象，以便快速和简单地重用，减少了游戏时对象的创建、释放动作，而这恰恰是导致游戏流畅性下降的原因之一。尤其是动作游戏，这种不流畅给玩家体验带来了灾难性后果。以下是EnemyCache的头文件。

#import <Foundation/Foundation.h>

#import "cocos2d.h"

@interface EnemyCache : CCNode

{

CCSpriteBatchNode* batch;

CCArray* enemies;

int updateCount;

}

@end

CCSpriteBatchNode对象包含全部敌人角色（sprite），CCArray则储存了每种敌人的列表。updateCount变量在每帧生成一个敌人时自动增加。init方法与BulletCache的init方法十分类似：

-(id) init

{

if((self = [super init]))

{

//从贴图集缓存中得到图片

CCSpriteFrame* frame = [[CCSpriteFrameCache sharedSpriteFrameCache] spriteFrameByName:@"monster-a.png"];

batch = [CCSpriteBatchNode batchNodeWithTexture:frame.texture];

[self addChild:batch];

[self initEnemies];

[self scheduleUpdate];

}

return self;

}

但initEnemies方法就复杂多了：

-(void) initEnemies

{

// 创建enemies 数组，用于存放每种类型的敌人

enemies = [[CCArray alloc] initWithCapacity:EnemyType_MAX];

// 有多少种敌人，就创建多少个数组

for (int i = 0; i < EnemyType_MAX; i++)

{

//根据敌人种类的不同，设置不同的数组容量。

int capacity;

switch (i)

{

case EnemyTypeBreadman:

capacity = 6;

break;

case EnemyTypeSnake:

capacity = 3;

break;

case EnemyTypeBoss:

capacity = 1;

break;

default:

[NSException exceptionWithName:@"EnemyCacheException" reason:@"unhandled enemytype" userInfo:nil];

break;

}

//不需要alloc数组，当数组被加到enemies数组时会自动retain

CCArray* enemiesOfType = [CCArray arrayWithCapacity:capacity];

[enemies addObject:enemiesOfType];

}

for (int i = 0; i < EnemyType_MAX; i++)

{

CCArray* enemiesOfType = [enemies objectAtIndex:i];

int numEnemiesOfType = [enemiesOfType capacity];

for (int j = 0; j < numEnemiesOfType;j++)

{

EnemyEntity* enemy = [EnemyEntity enemyWithType:i];

[batch addChild:enemy z:0 tag:i];

[enemiesOfTypeaddObject:enemy];

}

}

}

有意思的是，CCArray* enemies 对象自身包含了多个CCArray*对象，每种类型的敌人使用一个CCArray*。这是一个典型的 2 维数组。enemies 变量需要用alloc 分配内存，否则initEnemies 方法一结束它的内存会被释放。相反，enimies数组中的CCAray 元素对象不需要alloc，因为当它被add 到enemies数组中时会被自动retain。每种敌人所用的CCArray数组，其初始容量为该类型一次允许加到屏幕中的个数。每种敌人的CCArray数组使用addObject方法加到enemies数组。用这种方式可以创建层次深度。事实上，cocos2d结点层次结构也是通过在CCNode 类中定义一个CCArray* children成员变量来构建的。

我将enimies数组的创建和初始化分别放在在两个单独的循环体中，尽管它们其实也可以在一个循环中进行，但它们明显是属于不同的任务，应该保持分离——至于因此导致的性能上的额外开销，是微乎其微的。

根据在CCArray初始化时的初始容量，相同数目的敌人被构建出来并加入到CCSpriteBatchNode中，然后又加到对应的某种敌人使用的CCArray中。通过CCSpriteBatchNode也能访问到敌人，但单独把这些敌人放在分开的数组中更方便处理，代码列表如下所示：

-(void) spawnEnemyOfType:(EnemyTypes)enemyType

{

CCArray* enemiesOfType = [enemies objectAtIndex:enemyType];

EnemyEntity* enemy;

CCARRAY_FOREACH(enemiesOfType, enemy)

{

//查找可重建的敌人，重用

if (enemy.visible== NO)

{

//CCLOG(@"spawn enemy type %i",enemyType);

[enemy spawn];

break;

}

}

}

-(void) update:(ccTime)delta

{

updateCount++;

for (int i = EnemyType_MAX- 1; i >= 0; i--)

{

int spawnFrequency = [EnemyEntity getSpawnFrequencyForEnemyType:i];

if (updateCount % spawnFrequency == 0)

{

[self spawnEnemyOfType:i];

break;

}

}

}

update方法使计数器updateCount加1。这并不会多花费多少时间，但却是值得的，因为他会使我们接下来更轻松一些。

For循环比较奇怪，循环变量i从EnemyType_MAX开始递减，一直到i为负值。这个目的是为了让EnemyTypes 更大的怪物更早出生。例如，当boss怪和蛇同时出现时，首先让boss怪出生。否则会导致这样的事情发生，蛇会和boss争抢出生机会，甚至阻塞了Boss的出生。这个出生逻辑有一个副作用，我把它保留给你自己去解决，如果你要写一个自己的射击游戏，你可能不得不自己实现一些东西。

spawnFrequency被EnemyEntity 的getSpawnFrequncyForEnemyType方法所赋值。

+(int) getSpawnFrequencyForEnemyType:(EnemyTypes)enemyType

{

NSAssert(enemyType < EnemyType_MAX, @"invalidenemy type");

NSNumber* number = [spawnFrequency objectAtIndex:enemyType];

return [number intValue];

}

这个方法首先断言enemyType是否是有效值。然后从spawnFrequency数组中取出指定类型的敌人的NSNumber对象并返回其intValue值。

回到update方法，接下来使用取模运算%，计算updateCount能否被spawnFrequency所整除，意思是只有updateCount数到指定的数时（updateCount是个计数器），某个怪才会降生。

spanEnemyOfType方法从enemies数组中取出对应的CCArray，然后只需要遍历指定的类型的CCArray数组，而不用去遍历整个CCSrpiteBatchNode：

-(void) spawnEnemyOfType:(EnemyTypes)enemyType

{

CCArray* enemiesOfType = [enemies objectAtIndex:enemyType];

EnemyEntity* enemy;

CCARRAY_FOREACH(enemiesOfType, enemy)

{

//find the first free enemy and respawn it

if (enemy.visible== NO)

{

//CCLOG(@"spawn enemy type %i",enemyType);

[enemy spawn];

break;

}

}

}

如果找到一个visible为NO的怪，调用其spawn方法。如果所有的该类怪的visible都是YES，当前屏幕上该类怪的数目已经达到最大，不再产生这种类别的怪，这样就限制了屏幕上同一种怪的数量。

六、Component类

Component类在游戏逻辑中被视作插件。如果把一个component（组件）加在一个entity类，则该entity可以执行组件的行为：移动，射击，动画，显示生命值等等。编写组件的好处是它能自动工作，因为它们与父容器（CCNode)交互，并尽可能地不对父容器做出要求。有时候组件要求父容器必须是一个EnemyEntity类，但实际上你可以在任何类型的EnemyEntity（子类）上使用它。组件类可根据使用组件的类来配置。例如，这是一个在EnemyEntity中使用StandarShoortComponent组件的例子：

StandardShootComponent* shootComponent = [StandardShootComponent node];

shootComponent.shootFrequency= shootFrequency;

shootComponent.bulletFrameName= bulletFrameName;

[self addChild:shootComponent];

shootFrequency和bulletFrameName变量是根据EnemyType来初始化的。把StandartShootComponent添加到EnemyEntity类，该类将会拥有射击的能力。因为组件类未对父容器做任何限制，你甚至可以把组件加到ShipEntity，使玩家飞船以指定射速进行自动射击。通过简单地激活或失活射击组件，你可以用很少的代码实现给玩家更换武器的效果。你仅仅是把射击代码隔离出来，然后把组建植入游戏对象并设置一些参数而已。

让武器失效并切换武器的逻辑很简单。甚至，你可以把组件使用到其他游戏。组件在封装可重用代码时非常有用，在许多游戏引擎中组件是一种标准机制。如果你想进一步了解游戏组件，请到我的blog（www.learn-cocos2d.com/2010/06/prefer-composition-inheritance/）。

StandardShootComponent的头文件如下：

@interface StandardShootComponent : CCSprite

{

int updateCount;

int shootFrequency;

NSString* bulletFrameName;

}

@property (nonatomic) int shootFrequency;

@property (nonatomic, copy) NSString* bulletFrameName;

@end

有两件事情值得注意。首先StandardShootComponent派生自CCSprite，尽管它没有使用任何贴图纹理。因为CCSpriteBatchNode只能包含CCSprite对象，而所有的EnemyEntity对象都被加到了CCSpriteBatchNode，而且EnemyEntity的子节点，这些都是StandardShotComponent的作用对象。因此StandardShootComponent需要从CCSprite继承以满足CCSpriteBatchNode的要求。

第2是一个NSString 指针，bulletFrameName，用@property关键字封装成了属性。如果你足够细心，应该发现在@property定义中的copy关键字。这说明只要给这个属性赋值，将产生一个复制操作。这样做对于确保这个字符串始终可用很重要， 因为字符串通常都是autorelease对象。我们也可以用retain对象，问题在于，如果源字符串被改变，这将影响到bulletFrameName，这可能不是我们希望的。

当然，copy关键字还意味着我们要负责在dealloc中释放它，如下所示。

@implementation StandardShootComponent

@synthesize shootFrequency;

@synthesize bulletFrameName;

-(id) init

{

if((self = [super init]))

{

[self scheduleUpdate];

}

return self;

}

-(void) dealloc

{

[bulletFrameName release];

[super dealloc];

}

-(void) update:(ccTime)delta

{

if(self.parent.visible)

{

updateCount++;

if (updateCount >= shootFrequency)

{

//CCLOG(@"enemy %@ shoots!",self.parent);

updateCount = 0;

GameScene* game = [GameScene sharedGameScene];

CGPoint startPos = ccpSub(self.parent.position, CGPointMake(self.parent.contentSize.width * 0.5f, 0));

[game.bulletCache shootBulletFrom:startPos velocity:CGPointMake(-2, 0) frameName:bulletFrameName];

}

}

}

@end

真正的射击代码首先要检查父对象是否visible为YES，否则射击代码显然不应该被调用。BulletCache发射子弹时使用组件bulletFrameName 属性和固定的速度进行发射。 开始位置startPos并不是指组件自己的位置，而是使用父容器的位置和contentSize计算出来的：子弹位于角色的左边。

对于常规的怪，一个startPos就足够了，但对于Boss来说，用它的嘴或者鼻子来发射子弹，这才酷呢！我把这个工作也留给了你：为组件增加一个属性，以便子弹的初始位置可以被设置。当然，你也可以创建一种单独的BossShootComponent类，专门给Boss设计一种更复杂的射击模式。StandardMoveComponents 也是一样的， boss怪也可能需要在屏幕右边的某个位置不停盘旋。

七、击中物体

几乎忘记了——你其实是想向怪物们开火并击中它们，不是吗？

BulletCache类是检查子弹击中物体的理想地点。我把方法加在了BulletCache中。实际上是3个方法，2个是public的，1个是private方法，如下所示。使用这两个方法：isPlayerBulletCollidingWithRect和isEnemyBulletCollidingWithRect方法的目的是为了隐藏根据子弹的主类进行碰撞检测的内部细节。

-(bool) isPlayerBulletCollidingWithRect:(CGRect)rect

{

return [self isBulletCollidingWithRect:rect usePlayerBullets:YES];

}

-(bool) isEnemyBulletCollidingWithRect:(CGRect)rect

{

return [self isBulletCollidingWithRect:rect usePlayerBullets:YES];

}

-(bool) isBulletCollidingWithRect:(CGRect)rect usePlayerBullets:(bool)usePlayerBullets

{

bool isColliding = NO;

Bullet* bullet;

CCARRAY_FOREACH([batch children], bullet)

{

if (bullet.visible&& usePlayerBullets == bullet.isPlayerBullet)

{

if(CGRectIntersectsRect([bullet boundingBox],rect))

{

isColliding = YES;

//remove the bullet

bullet.visible= NO;

break;

}

}

}

return isColliding;

}

你也可以把usePlayerBullets 参数暴露给其他类，但这样把这个参数由bool类型改变为enum类型时只会更难，一旦你想使用第3种子弹怎么办？

只对看得见的子弹进行检测，同时要检查isPlayerBullet 属性，确保怪物们不会被自己的子弹击中。其实碰撞检测是件简单的事情，你可以使用CGRectIntersectsRect，如果子弹真的击中了什么，子弹自身也应该“消失”。

EnemyCache类持有所有的EenemyEntity对象，这里也是调用方法去检测是否有怪物被玩家击中的好地方。现在EnemyCache类增加了checkForBulletCollisions方法（会由update方法来调用）：

-(void) checkForBulletCollisions

{

EnemyEntity* enemy;

CCARRAY_FOREACH([batch children], enemy)

{

if (enemy.visible)

{

BulletCache* bulletCache = [[GameScene sharedGameScene] bulletCache];

CGRect bbox = [enemy boundingBox];

if([bulletCache isPlayerBulletCollidingWithRect:bbox])

{

//This enemy got hit ...

[enemy gotHit];

}

}

}

}

在这里，很方便遍历所有的怪物，并忽略那些当前不可见的。使用BulletCache的isPlayerBulletCollidingWithRect方法以及怪物的boundingBox属性进行检测，我们能快速地发现一个怪是否被玩家子弹击中；如果击中，就调用EnemyEntity的gotHist方法，该方法只是简单地把怪变为不可见。

我把飞船被怪物子弹击中的练习留给了你。你必须在ShipEntity方法中调用update方法，然后实现checkForBulletCollisions方法并在update方法中调用它。你还要改变isPlayerBulletCollidingWithRect方法和isEnemyBulletColligingWithRect方法，当子弹击中时播放声效。

八、Boss的血槽

作为Boss，不应该一枪毙命。应该向玩家显示boss 的生命值，当boss被击中时血槽中的数值就减少一点。首先，需要在EnemyEntity类中增加一个hitPoints成员变量（即血点），用于表明怪物需要多少次击中才会KO。initialHitPoints变量储存怪物满血状态下的血点值，因为怪物被杀死后我们需要恢复它原来的血点（别忘记，我们的怪都是可以被“重用”的）。对头文件所做的修改如下：

@interface EnemyEntity : Entity {

EnemyTypes type;

int initialHitPoints;

int hitPoints;

}

@property (readonly, nonatomic) int hitPoints;

为了表现血槽，我们需要一个组件类。很显然这就是HealthbarComponent类：

@interface HealthbarComponent : CCSprite

{

}

-(void) reset;

@end

HealthComponent类的实现则比较有趣。HealthBarComponent 根据怪物的剩余血点更新它的scaleX属性（这个scaleX来自于CCNode）。

-(id) init

{

if((self = [super init]))

{

self.visible = NO;

[self scheduleUpdate];

}

return self;

}

-(void) reset

{

float parentHeight = self.parent.contentSize.height;

float selfHeight = self.contentSize.height;

self.position = CGPointMake(self.parent.anchorPointInPixels.x, parentHeight + selfHeight);

self.scaleX = 1;

self.visible = YES;

}

-(void) update:(ccTime)delta

{

if(self.parent.visible)

{

NSAssert([self.parent isKindOfClass:[EnemyEntity class]], @"nota EnemyEntity");

EnemyEntity* parentEntity = (EnemyEntity*)self.parent;

self.scaleX = parentEntity.hitPoints/ (float)parentEntity.initialHitPoints;

}

else if (self.visible)

{

self.visible = NO;

}

}

@end

血槽可以根据父对象的visible属性在可视／不可视之间切换。reset方法把血槽放到怪物角色的顶上。因为血点减少是通过修改scaleX属性来显示的，scaleX也应当被重置。

update方法中，当血槽的父对象是可视时，首先判断父对象是不是EnemyEntity类，因为血槽组件要使用到在EnemyEntity中才有效的某些属性，我们必须确保它的父类必须是EnemyEntity类。我把scaleX属性修改为百分数值：用当前血点除以满血点。因为不知道什么时候血点会变，我们只有在每一帧都进行这个计算，不管血点到底有没有发生变化。这样做有点性能上的浪费，对于复杂计算而言，最好是从EnemyEntity的onHit方法去调用血槽组件的方法。

在EnemyEntity的init方法中，如果怪物类型为EnemyTypeBoss，则把组件HealthbarComponent加到EnemyEntity对象。

注意：parentEntity.initialHitPoints被强制转换为float，否则”/”是进行整数除法，这样的结果永远是0。将除数使用float类型就可以保证除法是小数点除法，以得到非0的小数。

if (type == EnemyTypeBoss) {

HealthbarComponent*healthbar = [HealthbarComponent spriteWithSpriteFrameName:

@"healthbar.png"];

[self addChild:healthbar];

}

spawn方法进行了扩展，包括把血点重置为满血，调用子组件中的所有血槽组件的reset方法（如果由多个的话）。我省略了对怪物类型的判断，因为血槽是很通用的，可以被任何怪物用到。

-(void) spawn

{

//CCLOG(@"spawn enemy");

// 出生地点选择在屏幕右边，y坐标值为随机数

CGRect screenRect = [GameScene screenRect];

CGSize spriteSize = [self contentSize];

float xPos = screenRect.size.width + spriteSize.width * 0.5f;

float yPos = CCRANDOM_0_1() * (screenRect.size.height - spriteSize.height)+ spriteSize.height * 0.5f;

self.position = CGPointMake(xPos, yPos);

// 出生后就表示看得见了

self.visible = YES;

// 重置血点，因为我们重用的对象很可能才被打死

hitPoints = initialHitPoints;

// 重置一些组件，如血槽

CCNode* node;

CCARRAY_FOREACH([self children], node)

{

if ([node isKindOfClass:[HealthbarComponent class]])

{

HealthbarComponent* healthbar = (HealthbarComponent*)node;

[healthbarreset];

}

}

}

九、结论

做出一个完整并优雅的游戏是一个很大的成果，包括大量的重构，修改代码改进射击以及允许更多的特性并让它们和谐相处。本章，学习了BulletCache和EnemyCache类的作用，使用它们对某个类的所有实例进行管理，便于在一个地方集中访问这些实例。同时起到一种“实例池”的作用，有助于改善性能。

Entity类层次示范了如何把你的类分离出来，而不需要每个游戏对象都设计一个类。使用组件类和cocos2d结点这样的层次结构的好处在于，你可以把一些很特别的功能创建为即插即用的类。这有助于用复合的方式而非继承的方式构造你的游戏对象。以这种方式编写游戏逻辑能更“柔性”，同时代码的复用性更好。最后，还学习了如何向怪物射击，以及BulletCache和EnemyCache类如何以一种直接的方式完成这个目的。HealthbarComponent提供了一个组件编程的极好例子。

这个游戏到这里还有几件事情等你完成。首先最主要的是，玩家从来不会被子弹击中。可能你想为蛇加上一个血槽，或者为boss的行为写一些特殊的移动和射击组件。总之，这是一个开始编写滚屏游戏的绝佳起点，需要的只是不断去改进它。下一章，我将讲如果使用粒子特效为这个射击游戏增加炫目的视觉效果。