cocos2dx如何制作一个塔防游戏 Cocos2d-x 2.0.4

概述转载自：http://blog.csdn.net/akof1314/article/details/8674186 本文实践自 Pablo Ruiz 的文章《How To Make a Tower Defense Game》，文中使用Cocos2D，我在这里使用Cocos2D-x 2.0.4进行学习和移植。在这篇文章，将会学习到如何制作一个塔防游戏。在这当中，学习如何在设定的时间内出现一波波的敌人

转载自：http://blog.csdn.net/akof1314/article/details/8674186

本文实践自 Pablo Ruiz 的文章《How To Make a Tower Defense Game》，文中使用Cocos2D，我在这里使用Cocos2D-x 2.0.4进行学习和移植。在这篇文章，将会学习到如何制作一个塔防游戏。在这当中，学习如何在设定的时间内出现一波波的敌人，使这些敌人沿着指定的路点前进，如何在地图上指定的位置创建炮塔，如何使炮塔射击敌人，如何可视化调试路点和炮塔的攻击范围。

步骤如下：
1.新建Cocos2d-win32工程，工程名为"TowerDefense"，去除"Box2D"选项，勾选"Simple Audio Engine in Cocos Denshion"选项；
2.下载本游戏所需的资源，将资源放置"Resources"目录下；

3.为场景添加背景图片。打开HelloWorldScene.cpp文件，修改init函数，如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

boolHelloWorld::init() { boolbRet= false; do { CC_BREAK_IF(!cclayer::init()); this->settouchEnabled( true); CCSizewins=CCDirector::sharedDirector()->getWinSize(); CCSprite*background=CCSprite::create( "Bg.png"); this->addChild(background); background->setposition(ccp(wins.wIDth/ 2,wins.height/ 2)); bRet= true; } while( 0); returnbRet; }

通过放置的背景图片，可以直观的看出哪些地方允许玩家放置炮塔。编译运行，如下图所示：

4.接着，需要沿路设置一些点，在这些点上能够让玩家触摸和建立炮塔。为了方便管理，使用.pList文件来存储炮塔的放置点，这样就可以很容易的改变它们。Towersposition.pList已经在资源文件夹中，其中已经有了一些炮塔的位置。查看这个文件，可以看到一个字典数组，字典只包含两个键"x"和"y"。每个字典条目代表一个炮塔位置的x和y坐标。现在需要读取这个文件，并且放置塔基到地图上。打开HelloWorldScene.h文件，添加以下变量：

1
cocos2d::CCArray*towerBases; 打开 HelloWorldScene.cpp 文件，添加如下方法：

voIDHelloWorld::loadTowerpositions()
{
CCArray*towerpositions=CCArray::createWithContentsOffile( "Towersposition.pList");
towerBases=CCArray::createWithCapacity( 10);
towerBases->retain();

CCObject*pObject= NulL;
CCARRAY_FOREACH(towerpositions,pObject)
{
CCDictionary*towerPos=(CCDictionary*)pObject;
CCSprite*towerBase=CCSprite::create( "open_spot.png");
this->addChild(towerBase);
towerBase->setposition(ccp(((CCString*)towerPos->objectForKey( "x"))->intValue(),
((CCString*)towerPos->objectForKey( "y"))->intValue()));
towerBases->addobject(towerBase);
}
}

在init函数里面，添加背景图片代码之后，添加如下代码：

this->loadTowerpositions(); 在析构函数里面，添加如下代码：
towerBases->release(); 编译运行，就可以看到道路两侧的方块，这些是做为玩家炮塔的基座。如下图所示：

5.开始建立炮塔。打开 HelloWorldScene.h 文件，添加如下代码：
CC_SYNTHESIZE_RETAIN(cocos2d::CCArray*,_towers,Towers); 添加 Tower 类，派生自 CCNode 类， Tower.h 文件代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#ifndef__TOWER_H__
#define__TOWER_H__

#include "cocos2d.h"
#include "HelloWorldScene.h"

#definekTOWER_COST 300

classTower: publiccocos2d::CCNode
{
public:
Tower( voID);
~Tower( voID);

staticTower*nodeWithTheGame(HelloWorld*game,cocos2d::CCPointlocation);
boolinitWithTheGame(HelloWorld*game,cocos2d::CCPointlocation);

voIDupdate( floatdt);
voIDdraw( voID);

CC_SYNTHESIZE(HelloWorld*,_theGame,TheGame);
CC_SYNTHESIZE(cocos2d::CCSprite*,_mySprite,MySprite);

private:
intattackRange;
intdamage;
floatfireRate;
};

#endif //__TOWER_H__

打开Tower.cpp文件，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include "Tower.h"
using namespacecocos2d;

Tower::Tower( voID)
{
}

Tower::~Tower( voID)
{
}

Tower*Tower::nodeWithTheGame(HelloWorld*game,CCPointlocation)
{
Tower*pRet= newTower();
if(pRet&&pRet->initWithTheGame(game,location))
{
returnpRet;
}
else
{
deletepRet;
pRet= NulL;
return NulL;
}
}

boolTower::initWithTheGame(HelloWorld*game,CCPointlocation)
{
boolbRet= false;
do
{
attackRange= 70;
damage= 10;
fireRate= 1;

_mySprite=CCSprite::create( "tower.png");
this->addChild(_mySprite);
_mySprite->setposition(location);
_theGame=game;
_theGame->addChild( this);

this->scheduleUpdate();

bRet= true;
} while( 0);

returnbRet;
}

voIDTower::update( floatdt)
{

}

voIDTower::draw( voID)
{
#ifdefCOCOS2D_DEBUG
ccDrawcolor4F( 255,255,255);
ccDrawCircle(_mySprite->getposition(),attackRange,360,30,false);
#endif
CCNode::draw();
}

这个Tower类包含几个属性：一个精灵对象，这是炮塔的可视化表现；一个父层的引用，方便访问父层；还有三个变量：

attackRange: 炮塔可以攻击敌人的距离。 damage: 炮塔对敌人造成的伤害值。 fireRate: 炮塔再次攻击敌人的时间间隔。 有了这三个变量，就可以创建各种不同攻击属性的炮塔，比如需要很长时间来重新加载的远程重击，或者范围有限的快速攻击。最后，代码中的 draw 方法，用于在炮塔周围绘制一个圆，以显示出它的攻击范围，这将方便调试。
6.让玩家添加炮塔。打开 HelloWorldScene.cpp 文件，加入以下头文件声明：
#include "Tower.h" 在析构函数中添加如下代码：
_towers->release(); 在 init 函数，添加如下代码：
1
2
_towers=CCArray::create();
_towers->retain(); 添加如下两个方法，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
boolHelloWorld::canBuyTower()
{
return true;
}

voIDHelloWorld::cctouchesBegan(CCSet*ptouches,CCEvent*pEvent)
{
CCSetIteratoriter=ptouches->begin();
for(;iter!=ptouches->end();iter++)
{
CCtouch*ptouch=(CCtouch*)(*iter);
CCPointlocation=ptouch->getLocation();

CCObject*pObject= NulL;
CCARRAY_FOREACH(towerBases,pObject)
{
CCSprite*tb=(CCSprite*)pObject;
if( this->canBuyTower()&&tb->boundingBox().containsPoint(location)&&!tb->getUserData())
{
//Wewillspendourgoldlater.

Tower*tower=Tower::nodeWithTheGame( this,tb->getposition());
_towers->addobject(tower);
tb->setUserData(tower);
}
}
}
}

方法cctouchesBegan检测当用户触摸屏幕上任何点时，遍历towerBases数组，检查触摸点是否包含在任何一个塔基上。不过在创建炮塔前，还有两件事需要检查：
①玩家是否买得起炮塔？canBuyTower方法用来检查玩家是否有足够的金币来购买炮塔。在这里先假设玩家有很多金币，方法返回true。
②玩家是否违法了建筑规则？如果tb的UserData已经设置了，那么这个塔基已经有了炮塔，不能再添加一个新的了。
如果一切检查都通过，那么就创建一个新的炮塔，放置在塔基上，并将它添加到炮塔数组中。编译运行，触摸塔基，就可以看到炮塔放置上去了，并且它的周围还有白色的圆圈显示攻击范围，如下图所示：

7.添加路点。敌人将会沿着一系列的路点前进，这些简单相互连接的点构成了一条路径，敌人在这条路径上进行行走。敌人会出现在第一个路点，搜寻列表中的下一个路点，移动到那个位置，重复这个过程，直到他们到达列表中的最后一个路点——玩家基地。如果被敌人到达基地，那么玩家就会受到损害。添加Waypoint类，派生自CCNode类，Waypoint.h文件代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#ifndef__WAYPOINT_H__
#define__WAYPOINT_H__

#include "cocos2d.h"
#include "HelloWorldScene.h"

classWaypoint: publiccocos2d::CCNode
{
public:
Waypoint( voID);
~Waypoint( voID);

staticWaypoint*nodeWithTheGame(HelloWorld*game,cocos2d::CCPointlocation);

voIDdraw( voID);

CC_SYNTHESIZE(cocos2d::CCPoint,_myposition,Myposition);
CC_SYNTHESIZE(Waypoint*,_nextWaypoint,NextWaypoint);

private:
HelloWorld*theGame;
};

#endif //__WAYPOINT_H__ 打开 Waypoint.cpp 文件，代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include "Waypoint.h"
using namespacecocos2d;

Waypoint::Waypoint( voID)
{
_nextWaypoint= NulL;
}

Waypoint::~Waypoint( voID)
{
}

Waypoint*Waypoint::nodeWithTheGame(HelloWorld*game,CCPointlocation)
{
Waypoint*pRet= newWaypoint();
if(pRet&&pRet->initWithTheGame(game,location))
{
returnpRet;
}
else
{
deletepRet;
pRet= NulL;
return NulL;
}
}

boolWaypoint::initWithTheGame(HelloWorld*game,CCPointlocation)
{
boolbRet= false;
do
{
theGame=game;
_myposition=location;

this->setposition(CCPointZero);
theGame->addChild( this);

bRet= true;
} while( 0);

returnbRet;
}

voIDWaypoint::draw( voID)
{
#ifdefCOCOS2D_DEBUG
ccDrawcolor4F( 0,0,255);
ccDrawCircle(_myposition,6,false);
ccDrawCircle(_myposition,2,false);

if(_nextWaypoint)
{
ccDrawline(_myposition,_nextWaypoint->_myposition);
}
#endif

CCNode::draw();
} 首先，通过传入的 HelloWorld 对象引用和路点位置坐标，进行初始化一个 waypoint 对象。每个路点都包含下一个路点的引用，这将会创建一个路点链接列表。每个路点知道列表中的下一个路点。通过这种方式，可以引导敌人沿着链表上的路点到达他们的最终目的地。最后， draw 方法绘制显示路点的位置，并且绘制一条直线将其与下一个路点进行连接，这仅仅用于调试目的。

8.创建路点列表。打开HelloWorldScene.h文件，添加以下代码：

打开 HelloWorldScene.cpp 文件，加入以下头文件声明：
#include "Waypoint.h" 在析构函数中添加如下代码：
_waypoints->release(); 添加以下方法：

voIDHelloWorld::adDWaypoints()
{
_waypoints=CCArray::create();
_waypoints->retain();

Waypoint*waypoint1=Waypoint::nodeWithTheGame( this,ccp( 420,35));
_waypoints->addobject(waypoint1);

Waypoint*waypoint2=Waypoint::nodeWithTheGame( this,ccp( 35,35));
_waypoints->addobject(waypoint2);
waypoint2->setNextWaypoint(waypoint1);

Waypoint*waypoint3=Waypoint::nodeWithTheGame( this,130));
_waypoints->addobject(waypoint3);
waypoint3->setNextWaypoint(waypoint2);

Waypoint*waypoint4=Waypoint::nodeWithTheGame( this,ccp( 445,130));
_waypoints->addobject(waypoint4);
waypoint4->setNextWaypoint(waypoint3);

Waypoint*waypoint5=Waypoint::nodeWithTheGame( this,220));
_waypoints->addobject(waypoint5);
waypoint5->setNextWaypoint(waypoint4);

Waypoint*waypoint6=Waypoint::nodeWithTheGame( this,ccp(- 40,220));
_waypoints->addobject(waypoint6);
waypoint6->setNextWaypoint(waypoint5);
}

在init函数，添加如下代码：

this->adDWaypoints(); 编译运行，效果如下图所示：

在地图上有6个路点，这是敌人的行走路线。在让敌人出现在游戏中前，还需要添加一个辅助方法。打开 HelloWorldScene.cpp 文件，添加方法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
boolHelloWorld::collisionWithCircle(CCPointcirclePoint,floatradius,CCPointcirclePointTwo,floatradiusTwo)
{
floatxdif=circlePoint.x-circlePointTwo.x;
floatydif=circlePoint.y-circlePointTwo.y;

floatdistance=sqrt(xdif*xdif+ydif*ydif);

if(distance<=radius+radiusTwo)
{
return true;
}
return false;
}

方法collisionWithCircle用于判断两个圆是否碰撞或者相交。这将用于判断敌人是否到达一个路点，同时也可以检测敌人是否在炮塔的攻击范围之内。
9.添加敌人。打开HelloWorldScene.h文件，添加以下代码：

1
2
3
4
intwave;
cocos2d::cclabelBMFont*ui_wave_lbl;

打开HelloWorldScene.cpp文件，在析构函数里，添加如下代码：

_enemIEs->release(); 添加 Enemy 类，派生自 CCNode 类， Enemy.h 文件代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#ifndef__ENEMY_H__
#define__ENEMY_H__

#include "cocos2d.h"
#include "HelloWorldScene.h"
#include "Waypoint.h"

classEnemy: publiccocos2d::CCNode
{
public:
Enemy( voID);
~Enemy( voID);

staticEnemy*nodeWithTheGame(HelloWorld*game);
boolinitWithTheGame(HelloWorld*game);
voIDdoActivate( floatdt);
voIDgetRemoved();

voIDupdate( floatdt);
voIDdraw( voID);

CC_SYNTHESIZE(HelloWorld*,MySprite);

private:
cocos2d::CCPointmyposition;
intmaxHp;
intcurrentHp;
floatwalkingSpeed;
Waypoint*destinationWaypoint;
boolactive;
};

#endif //__ENEMY_H__ 打开 Enemy.cpp 文件，代码如下： 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include "Enemy.h"
using namespacecocos2d;

#defineHEALTH_bar_WIDTH 20
#defineHEALTH_bar_ORIGIN- 10

Enemy::Enemy( voID)
{
}

Enemy::~Enemy( voID)
{
}

Enemy*Enemy::nodeWithTheGame(HelloWorld*game)
{
Enemy*pRet= newEnemy();
if(pRet&&pRet->initWithTheGame(game))
{
returnpRet;
}
else
{
deletepRet;
pRet= NulL;
return NulL;
}
}

boolEnemy::initWithTheGame(HelloWorld*game)
{
boolbRet= false;
do
{
maxHp= 40;
currentHp=maxHp;
active= false;
walkingSpeed= 0. 5;

_theGame=game;
_mySprite=CCSprite::create( "enemy.png");
this->addChild(_mySprite);

Waypoint*waypoint=(Waypoint*)_theGame->getWaypoints()->objectAtIndex(_theGame->getWaypoints()->count()- 1);
destinationWaypoint=waypoint->getNextWaypoint();
CCPointpos=waypoint->getMyposition();
myposition=pos;
_mySprite->setposition(pos);
_theGame->addChild( this);

this->scheduleUpdate();

bRet= true;
} while( 0);

returnbRet;
}

voIDEnemy::doActivate( floatdt)
{
active= true;
}

voIDEnemy::getRemoved()
{
this->getParent()->removeChild( this,true);
_theGame->getEnemIEs()->removeObject( this);

//Notifythegamethatwekilledanenemysowecancheckifwecansendanotherwave
_theGame->enemyGotKilled();
}

voIDEnemy::update( floatdt)
{
if(!active)
{
return;
}

if(_theGame->collisionWithCircle(myposition,1,destinationWaypoint->getMyposition(),1))
{
if(destinationWaypoint->getNextWaypoint())
{
destinationWaypoint=destinationWaypoint->getNextWaypoint();
}
else
{
//Reachedtheendoftheroad.damagetheplayer
_theGame->getHpdamage();
this->getRemoved();
}
}

CCPointtargetPoint=destinationWaypoint->getMyposition();
floatmovementSpeed=walkingSpeed;

CCPointnormalized=ccpnormalize(ccp(targetPoint.x-myposition.x,targetPoint.y-myposition.y));
_mySprite->setRotation(CC_radians_TO_degrees(atan2(normalized.y,-normalized.x)));

myposition=ccp(myposition.x+normalized.x*movementSpeed,myposition.y+normalized.y*movementSpeed);
_mySprite->setposition(myposition);
}

voIDEnemy::draw( voID)
{
CCPointhealthbarBack[]={
ccp(_mySprite->getposition().x- 10,_mySprite->getposition().y+ 16),
ccp(_mySprite->getposition().x+ 10,_mySprite->getposition().y+ 14),
ccp(_mySprite->getposition().x- 10,_mySprite->getposition().y+ 14)
};
ccDrawSolIDpoly(healthbarBack,4,ccc4f( 255,255));

CCPointhealthbar[]={
ccp(_mySprite->getposition().x+HEALTH_bar_ORIGIN,
ccp(_mySprite->getposition().x+HEALTH_bar_ORIGIN+( float)(currentHP*HEALTH_bar_WIDTH)/maxHp,
ccp(_mySprite->getposition().x+HEALTH_bar_ORIGIN,_mySprite->getposition().y+ 14)
};
ccDrawSolIDpoly(healthbar,ccc4f( 0,255));

CCNode::draw();
}

首先，通过传递一个HelloWorld对象引用进行初始化。在初始化函数里面，对一些重要的变量进行设置：

maxHP: 敌人的生命值。 walkingSpeed: 敌人的移动速度。 mySprite: 存储敌人的可视化表现。 destinationWaypoint: 存储下一个路点的引用。 update 方法每帧都会被调用，它首先通过 collisionWithCircle 方法检查是否到达了目的路点。如果到达了，则前进到下一个路点，直到敌人到达终点，玩家也就受到伤害。接着，它根据敌人的行走速度，沿着一条直线移动精灵到达下一个路点。它通过以下算法：
①计算出从当前位置到目标位置的向量，然后将其长度设置为1（向量标准化）
②将移动速度乘以标准化向量，得到移动的距离，将它与当前坐标进行相加，得到新的坐标位置。
最后， draw 方法在精灵上面简单的实现了一条血量条。它首先绘制一个红色背景，然后根据敌人的当前生命值用绿色进行覆盖血量条。
10.显示敌人。打开 HelloWorldScene.cpp 文件，添加头文件声明：
#include "Enemy.h" 添加如下方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
boolHelloWorld::loaDWave()
{
CCArray*waveData=CCArray::createWithContentsOffile( "Waves.pList");
if(wave>=waveData->count())
{
return false;
}

CCArray*currentWaveData=(CCArray*)waveData->objectAtIndex(wave);
CCObject*pObject= NulL;
CCARRAY_FOREACH(currentWaveData,pObject)
{
CCDictionary*enemyData=(CCDictionary*)pObject;
Enemy*enemy=Enemy::nodeWithTheGame( this);
_enemIEs->addobject(enemy);
enemy->schedule(schedule_selector(Enemy::doActivate),((CCString*)enemyData->objectForKey( "spawnTime"))->floatValue());
}

wave++;
ui_wave_lbl->setString(CCString::createWithFormat( "WAVE:%d",wave)->getCString());
return true;
}

voIDHelloWorld::enemyGotKilled()
{
//IftherearenomoreenemIEs.
if(_enemIEs->count()<= 0)
{
if(! this->loaDWave())
{
cclog( "Youwin!");
CCDirector::sharedDirector()->replaceScene(CCTransitionSplitCols::create( 1,HelloWorld::scene()));
}
}
}

voIDHelloWorld::getHpdamage()
{

}

在init函数里面，添加如下代码：

1
2
3
4
5
6
7
8
9
wave= 0;
ui_wave_lbl=cclabelBMFont::create(CCString::createWithFormat( "WAVE:%d",wave)->getCString(),"Font_red_14.fnt");
this->addChild(ui_wave_lbl,10);
ui_wave_lbl->setposition(ccp( 400,wins.height- 12));
ui_wave_lbl->setAnchorPoint(ccp( 0,0. 5));

_enemIEs=CCArray::create();
_enemIEs->retain();
this->loaDWave();

现在对上面的代码进行一些解释。最重要的部分是loaDWave方法，它从Waves.pList文件读取数据。查看这个文件，可以看到它包含了3个数组，每个数组代表着一波敌人。第一个数组包含6个字典，每个字典定义了一个敌人。在本篇文章中，这个字典仅存储敌人的出现时间，但是也可用于定义敌人类型或者其他特殊属性，以区分不同的敌人。loaDWave方法检查下一波应出现的敌人，根据波信息创建相应的敌人，并安排它们在规定的时间出现在屏幕上。enemyGotKilled方法检查当前屏幕上的敌人数量，如果已经没有敌人的话，那么就让下一波敌人出现。之后，还使用这个方法来判断玩家是否赢得了游戏。编译运行，敌人正向玩家基地前进，如下图所示：

10.炮塔攻击。每座塔进行检查是否有敌人出现在攻击范围之内，如果有的话，对敌人进行开火，直到以下两种情况之一发生：敌人移动出范围；敌人被消灭。那么炮塔就会寻找下一个敌人。打开Tower.h文件，添加以下代码：

classEnemy; 添加以下变量：
boolattacking;
Enemy*chosenEnemy; 打开 Tower.cpp 文件，添加头文件声明：
#include "Enemy.h" 在 initWithTheGame 函数开头if条件之后，添加如下代码：
chosenEnemy= NulL; 添加以下方法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
voIDTower::attackEnemy()
{
this->schedule(schedule_selector(Tower::shootWeapon),fireRate);
}

voIDTower::chosenEnemyForAttack(Enemy*enemy)
{
chosenEnemy= NulL;
chosenEnemy=enemy;
this->attackEnemy();
enemy->getAttacked( this);
}

voIDTower::shootWeapon( floatdt)
{
CCSprite*bullet=CCSprite::create( "bullet.png");
_theGame->addChild(bullet);
bullet->setposition(_mySprite->getposition());
bullet->runAction(CCSequence::create(
CCMoveto::create( 0. 1,chosenEnemy->getMySprite()->getposition()),
CCCallFunc::create( this,callfunc_selector(Tower::damageEnemy)),
CCCallFuncN::create( this,callfuncN_selector(Tower::removeBullet)),
NulL));
}

voIDTower::removeBullet(CCSprite*bullet)
{
bullet->getParent()->removeChild(bullet,true);
}

voIDTower::damageEnemy()
{
if(chosenEnemy)
{
chosenEnemy->getdamaged(damage);
}
}

voIDTower::targetKilled()
{
if(chosenEnemy)
{
chosenEnemy= NulL;
}

this->unschedule(schedule_selector(Tower::shootWeapon));
}

voIDTower::lostSightOfEnemy()
{
chosenEnemy->gotLostSight( this);
if(chosenEnemy)
{
chosenEnemy= NulL;
}

this->unschedule(schedule_selector(Tower::shootWeapon));
} 最后，更新 update 方法为如下： voIDTower::update( floatdt)
{
if(chosenEnemy)
{
//Wemakeitturntotargettheenemychosen
CCPointnormalized=ccpnormalize(ccp(chosenEnemy->getMySprite()->getposition().x-_mySprite->getposition().x,
chosenEnemy->getMySprite()->getposition().y-_mySprite->getposition().y));
_mySprite->setRotation(CC_radians_TO_degrees(atan2(normalized.y,-normalized.x))+ 90);

if(!_theGame->collisionWithCircle(_mySprite->getposition(),chosenEnemy->getMySprite()->getposition(),1))
{
this->lostSightOfEnemy();
}
}
else
{
CCObject*pObject= NulL;
CCARRAY_FOREACH(_theGame->getEnemIEs(),pObject)
{
Enemy*enemy=(Enemy*)pObject;
if(_theGame->collisionWithCircle(_mySprite->getposition(),enemy->getMySprite()->getposition(),1))
{
this->chosenEnemyForAttack(enemy);
break;
}
}
}
}

打开Enemy.h文件，添加以下代码：

cocos2d::CCArray*attackedBy; 打开 Enemy.cpp 文件，在 initWithTheGame 函数开头if条件之后，添加如下代码：
attackedBy=CCArray::createWithCapacity( 5);
attackedBy->retain(); 在 getRemoved 函数开头，添加如下代码：
1
2
3
4
5
6
CCObject*pObject= NulL;
CCARRAY_FOREACH(attackedBy,pObject)
{
Tower*attacker=(Tower*)pObject;
attacker->targetKilled();
} 添加如下方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
voIDEnemy::getAttacked(Tower*attacker)
{
attackedBy->addobject(attacker);
}

voIDEnemy::gotLostSight(Tower*attacker)
{
attackedBy->removeObject(attacker);
}

voIDEnemy::getdamaged( intdamage)
{
currentHp-=damage;
if(currentHp<= 0)
{
this->getRemoved();
}
}

代码中最重要的部分是在Tower类的update方法。炮塔不断检查敌人是否在攻击范围内，如果是的话，炮塔将旋转朝向敌人，开火攻击。一个敌人一旦被标记为被攻击，将会调用方法让炮塔以攻击间隔发射子d。反过来，每个敌人都存储有向其攻击的炮塔列表，所以如果敌人被杀死了，那么炮塔就会被通知停止攻击。编译运行，放置几个炮塔在地图上，将会看到一旦敌人进入炮塔的攻击范围，炮塔就会向它们开火攻击，敌人的血量条就会减少，直到被消灭。如下图所示：

11.显示玩家血量。打开HelloWorldScene.h文件，添加以下代码：

1
2
3
intplayerHp;
cocos2d::cclabelBMFont*ui_hp_lbl;
boolgameEnded; 变量playerHp表示玩家的生命值，cclabelBMFont对象是一个标签，用来显示生命数值。gameEnded用来表示游戏是否结束。打开 HelloWorldScene.cpp 文件，在 init 函数里面，添加如下代码：
1
2
3
4
5
gameEnded= false;
playerHp= 5;
ui_hp_lbl=cclabelBMFont::create(CCString::createWithFormat( "HP:%d",playerHp)->getCString(),"Font_red_14.fnt");
this->addChild(ui_hp_lbl,10);
ui_hp_lbl->setposition(ccp( 35,wins.height- 12)); 添加如下方法：

voIDHelloWorld::getHpdamage()
{
playerHp--;
ui_hp_lbl->setString(CCString::createWithFormat( "HP:%d",playerHp)->getCString());
if(playerHp<= 0)
{
this->doGameOver();
}
}

voIDHelloWorld::doGameOver()
{
if(!gameEnded)
{
gameEnded= true;
CCDirector::sharedDirector()->replaceScene(CCTransitionRotoZoom::create( 1,HelloWorld::scene()));
}
}

添加的方法为减少玩家生命值，更新标签，并检查玩家生命是否耗尽，如果是的话，游戏就结束了。当敌人到达基地的时候，getHpdamage方法被调用。编译运行，让敌人到达基地，你将会看到玩家的生命在减少，直到游戏失败。如下图所示：

12.限制金币供应量。大多数游戏都实现了“零和”功能，建造每座炮塔需要一定的资源，并给玩家有限的资源进行分配。打开HelloWorldScene.h文件，添加如下代码：

intplayerGold;
cocos2d::cclabelBMFont*ui_gold_lbl; 就像显示生命数值一样，一个变量表示玩家的金币数，一个标签对象显示金币数值。打开 HelloWorldScene.cpp 文件，在 init 函数里面，添加如下代码：
playerGold= 1000;
ui_gold_lbl=cclabelBMFont::create(CCString::createWithFormat( "GolD:%d",playerGold)->getCString(),"Font_red_14.fnt");
this->addChild(ui_gold_lbl,10);
ui_gold_lbl->setposition(ccp( 135,wins.height- 12));
ui_gold_lbl->setAnchorPoint(ccp( 0,0. 5)); 添加如下方法：
voIDHelloWorld::awardGold( intgold)
{
playerGold+=gold;
ui_gold_lbl->setString(CCString::createWithFormat( "GolD:%d",playerGold)->getCString());
} 替换 canBuyTower 方法，代码如下：
1
2
3
4
5
6
7
8
boolHelloWorld::canBuyTower()
{
if(playerGold-kTOWER_COST>= 0)
{
return true;
}
return false;
} 在 cctouchesBegan 函数里面，语句 //We will spend our gold later. 的后面，添加如下代码：
playerGold-=kTOWER_COST;
ui_gold_lbl->setString(CCString::createWithFormat( "GolD:%d",playerGold)->getCString()); 上述的代码在玩家尝试放置炮塔时，检查是否有足够的金币。如果足够的话，炮塔就会放置上去，并从玩家的金币数中减去炮塔的费用。每次杀死敌人的时候也应该奖励玩家一些金币。打开 Enemy.cpp 文件，在 getdamaged 函数里面，if条件后面，添加如下语句：
_theGame->awardGold( 200); 编译运行，会看到不能随意的放置炮塔了，因为每个炮塔都要花费金币。当然，杀死敌人就可以获得金币奖励，这样就可以继续购买炮塔。这是一个很好的系统。如下图所示：

13.加入背景音乐和音效。打开 HelloWorldScene.cpp 文件，添加头文件声明：
#include "SimpleAudioEngine.h" 在 init 函数，if条件之后，添加如下代码：
CocosDenshion::SimpleAudioEngine::sharedEngine()->playBackgroundMusic( "8bitDungeonLevel.mp3",true); 在 cctouchesBegan 函数，添加一个新的Tower对象前，添加如下代码：
CocosDenshion::SimpleAudioEngine::sharedEngine()->playEffect( "tower_place.wav"); 在 getHpdamage 函数里，添加如下代码：
CocosDenshion::SimpleAudioEngine::sharedEngine()->playEffect( "life_lose.wav"); 打开 Enemy.cpp 文件，添加头文件声明：
#include "SimpleAudioEngine.h" 在 getdamaged 函数里，添加如下代码：
CocosDenshion::SimpleAudioEngine::sharedEngine()->playEffect( "laser_shoot.wav"); 编译运行，现在游戏将有配乐，关闭掉调试绘制后，效果图：

参考资料：
1.How To Make a Tower Defense Gamehttp://www.raywenderlich.com/15730/how-to-make-a-tower-defense-game
2.钓龟岛保卫战-如何从零开始制作一款iOS塔防游戏（新）http://article.ityran.com/archives/1941
非常感谢以上资料，本例子源代码附加资源下载地址：http://download.csdn.net/detail/akof1314/5143209 如文章存在错误之处，欢迎指出，以便改正。

总结

以上是内存溢出为你收集整理的cocos2dx如何制作一个塔防游戏 Cocos2d-x 2.0.4全部内容，希望文章能够帮你解决cocos2dx如何制作一个塔防游戏 Cocos2d-x 2.0.4所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。