cocos2dx 游戏 飞机大战

本来学Android学的好好的，由于某些原因，现在暂时要做cocos游戏开发，学了五天，把做的一个demo分享一下：

能超过20000分的告诉我吧，我反正是到不了。。。运行有bug或者太卡就跟我说下吧，说了也不一定改。。（懒得折腾它了，继续做其它的。简单的规则：每存活一帧得一分，三种飞机不同血量分值，击杀敌机得分，漏杀扣分，敌人根据你的位置移动攻击，三种道具，加血量，加武器等级，导弹必杀技。血量100，挨子弹和撞敌机均扣15血。

上截图：

下载链接：http://beta.qq.com/m/q1q8

源码链接：github仓库

当然，这里源码也只是把代码放下，毕竟一个工程文件500多m。。

主要的一些文件介绍：

#pragma once
#ifndef __PLAYER_H_
#define __PLAYER_H_

#include "cocos2d.h"
#include "Entrity.h"
class BulletLayer;

#define JUMP_ACTION_TAG 1
USING_NS_CC;

/*

	主角类
	自控制生命值，子弹等级，必杀技等
*/
class Player :public Entrity
{
public:
	Player();
	~Player();
	CREATE_FUNC(Player);
	virtual bool init();
	int getHp();
	void hit();
	int getAttack();
	int getBullNum();
	void upBullet();
	void shootBoom(int x);
	void getHp(int x);
	void setBullet(BulletLayer *bullet);
private:
	int mHp;
	int mAtt;
	int mBulnum;
	BulletLayer *mBullet;
};	
#endif

#pragma once
#ifndef __OTHER_SCENE_H_
#define __OTHER_SCENE_H_
#include <cocos2d.h>
#include "Player.h"
#include "cocostudio/CocoStudio.h"
#include "ui/CocosGUI.h"
#include "Bullet.h"
#include "RollerLayer.h"
#include "ControllMoveLayer.h"
#include "ColliderLayer.h"
#include "GameLogic.h"
#include "UiLayer.h"
using namespace cocos2d::ui;
/*
	游戏运行场景
*/
USING_NS_CC;
class GameScene:public cocos2d::Layer
{
public:
	static cocos2d::Scene* createScene();
	virtual bool init();
	CREATE_FUNC(GameScene);
	virtual void update(float dt);
private :
	void initBackground();
	void initPlayer();
	void initUi();
	void initGameLogic();
	void initController();
	void initCollider();
private:
	Player*mPlayer;
	RollerLayer *mBackGround;
	UiLayer *mUiLayer;
	GameLogic *mGameLogic;
	ControllMoveLayer *mControllerLayer;
	ColliderLayer *mColliderLayer;

};


#endif

#pragma once

#ifndef __GAMEOVER_H_
#define __GAMEOVER_H_
#include"cocos2d.h"
#include "cocostudio/CocoStudio.h"
#include "ui/CocosGUI.h"
USING_NS_CC;
using namespace cocos2d;
/*

	游戏失败场景
*/
class GameOver :public cocos2d:: Layer
{
public:

	static cocos2d::Scene* createScene(int sc);
	virtual bool init();

	CREATE_FUNC(GameOver);
	void setscore(int score);
	void onMenu(Ref *ref);
	void update(float dt);
	cocos2d::ui::Text *mscore;
private :
	int sscore;
};
#endif

#pragma once
#ifndef __UI_LAYER__H__
#define __UI_LAYER__H__
#include "cocostudio/CocoStudio.h"
#include "ui/CocosGUI.h"
#include "cocos2d.h"
USING_NS_CC;
using namespace cocos2d::ui;
/*
ui层，用于显示ui部分
*/
class UiLayer :public Layer
{
public :
	CREATE_FUNC(UiLayer);
	void setHpPercent(float per);
	void setscore(int score);
private:
	bool init();
	
	LoadingBar *mHpBar;
	Text *mscoreText;
};

#endif 

#pragma once
#ifndef _ROLLER_LAYER_H_
#define _ROLLER_LAYER_H_
#include "cocos2d.h"
USING_NS_CC;

/*

	背景滚动层，通过两张背景图片的滚动，实现无线循环的背景
*/
class RollerLayer :public Layer
{

public:
	//滚动模式，水平，垂直
	static const int VERTICAL = 1;
	static const int HORIZONTAL = 2;
	CREATE_FUNC(RollerLayer);
	virtual bool init();
	void update(float dt);
	//设置好用于滚动的两张背景图片
	void setBackgrounds(Sprite *map1,Sprite*map2);
	//滚动方向
	void setRollOrientaion(int orientation);
	//滚动速度
	void setSpeed(int iSpeed);
	//返回背景大小
	Size getMapSize();
private:
	//水平滚动
	void rollHorizontal();
	//垂直滚动
	void rollVertical();
protected :
	Sprite *mMap1;
	Sprite *mMap2;
	int mOrientation;
	int mSpeed;
};

#endif

#pragma once
#ifndef __CONTROLL_MOVE_H_
#define __CONTROLL_MOVE_H_

#include "cocos2d.h"
USING_NS_CC;

/*

	游戏角色的移动控制层
*/
class ControllMoveLayer :public Layer
{
public :
	CREATE_FUNC(ControllMoveLayer);
	bool init();
	void setPlayer(Node *player);
private:
	void update(float dt);
	bool onTouchBegan(Touch *touch,Event *unused_event);
	void onTouchCancelled(Touch *touch,Event *unused_event);
	void onTouchMoved(Touch *touch,Event *unused_event);
	void onTouchEnded(Touch *touch,Event *unused_event);
	float mDeltaX;
	float mDeltaY;
	Node *mPlayer;
	bool isControlled;
};
#endif

#pragma once
#ifndef ___GAME_LAYER_H__
#define ___GAME_LAYER_H__

#include "cocos2d.h"
#include "Player.h"
#include "Exp.h"
USING_NS_CC;
/*

	游戏逻辑层
*/
class GameLogic :public Layer 
{

public:
	CREATE_FUNC(GameLogic);
	bool init();
	//游戏分值的修改
	void modifyscore(int x);
	//当前得分
	int getscore();
	//当前等级
	int getLevel();
	//根据道具，进行相关计算
	void getExp(ToolExp exp);

	void getMonster(int x);
	//设置好游戏逻辑中需要用到了角色
	void setPlayer(Player *player);
	void update(float dt);
private :
	Player *mPlayer;
	int mscore=0;
	int mLevel=1;
};
#endif

#pragma once
#ifndef __EXP_H_H_
#define __EXP_H_H_
//枚举道具类型
enum ToolExp
{
	BULLET,//必杀技
	HP,//恢复血量
	STAR,//增强角色的子弹
};
#endif

#pragma once
#ifndef __ITEM_H____
#define __ITEM_H____

#include "Entrity.h"
class ItemFactor;
class Item :public Entrity
{

public:
	~Item();
	CREATE_FUNC(Item);
	virtual bool  init();
	//针对角色，进行动作
	virtual void  action(Node *player);
	//自己判断与角色是否产生了碰撞
	virtual bool  colliderWithPlayer(Node *player);
	//死亡
	virtual void  death(ItemFactor *factor);
	//产生爆炸效果，并返回这个效果需要的时间
	virtual float boom();
	//是否存活
	bool isAlive();
private :
	bool mAlive;
	//死亡
	void onDeath(float dt);
};
#endif

#pragma once
#ifndef __ITEM_FACTOR__H__
#define __ITEM_FACTOR__H__

/*

产生物品的工厂
*/
#include "Item.h"
class ItemFactor :public Node
{
public:
	~ItemFactor();
	CREATE_FUNC(ItemFactor);
	bool init();
	//移除所有工厂产生的物品
	void removeAllItem();
	//移除指定物品
	void removeItem(Item *item);
	//产生一个新的物品
	virtual void createItem(float dt);
	//设置角色
	void setPlayer(Node *player);
	//设置产生物品的速度
	void setCreateSpeed(float iSpeed);
	//返回当前工厂已将创建的所有物品
	const  Vector<Item*>& getItems();
	//删除所有死亡缓冲队列中已经死亡的物品
	void deleteCache();
	//把一个物品加入到死亡缓冲队列中
	void addToDeleteQueue(Item *item);
protected:
	Node *mPlayer;
	Vector<Item*>mItemsvec;
	Vector<Item*>mDeleItemCache;
	float mCreateSpeed;
};
#endif

#pragma once
#include "Item.h"


/*

普通怪物，有怪物的普遍特性，血量，分值等
*/
class MonsterItem :public Item
{
public:
	
	CREATE_FUNC(MonsterItem);
	bool init();
	void action(Node *player);
	int getscore();
	void hit(int att);
	int getHp();
	void set(int hp,int mscore);
protected:
	int mHp;
	int mscore;
	
};

#pragma once
#pragma once
#ifndef __ATTACK_MONSTER__H_

#define __ATTACK_MONSTER__H_

#include "MonsterItem.h"
/*
	具有攻击能力的怪物类
*/
class AttackMonster :public MonsterItem
{
public:
	~AttackMonster();
	CREATE_FUNC(AttackMonster);
	bool init();
	//移除自身的所有子弹
	void removeAllObject();
	//移除某一个子弹
	void removeBullet(Node *node);
	//针对角色进行动作，主要是移动，攻击
	void action(Node *player);
	void setLevel(int lev);
	//根据主角移动
	virtual void move(Node *player);
	//根据主角攻击
	virtual void attack(Node *player);
	protected:
	int mLevlel;
	Vector<Sprite*>mBullets;
};
#endif 

#pragma once
#ifndef __MONSTER__BOSS_H_
#define __MONSTER__BOSS_H_

#include "AttackMonster.h"


/*

	游戏boss类型
*/
class MonsterBoss :public AttackMonster
{
public:
	CREATE_FUNC(MonsterBoss);
	bool init();
	virtual void move(Node *player);
	virtual void attack(Node *player);
};


#endif

#pragma once
#ifndef __MONSTER__FACTOR__H_
#define __MONSTER__FACTOR__H_
#include "ItemFactor.h"

/*
	怪物产生工厂。根据当前等级，产生相应数量的怪物，根据随机数，产生相应类型的怪物
*/
class MonsterFactor :public ItemFactor
{
public :
	CREATE_FUNC(MonsterFactor);
	bool init();
	virtual void createItem(float dt);
	void upLevel();
	//根据当前分数，更改当前怪物生产上限
	void chooseLevel(int score);
private :
	int level;
	//一个标记位，防止第一个出现的怪物就是boss
	bool mHasBoss;
};
#endif

#pragma once
#ifndef  __TOOL__TEM_H_
#define  __TOOL__TEM_H_
#include "Item.h"
#include "Exp.h"

/*

道具类，有道具的类型等参数。
*/
class ToolItem :public Item
{
public:
	CREATE_FUNC(ToolItem);
	ToolExp  getExp();
	void action(Node *player);
	void setExp(ToolExp exp);
	float boom();
private:
	ToolExp mExp;
};



#endif 

#pragma once
#ifndef __TOOL_FACTOR__H__
#define __TOOL_FACTOR__H__
#include "ItemFactor.h"


/*

道具产生工厂
*/
class ToolFactor :public ItemFactor
{
public:
	CREATE_FUNC(ToolFactor);

	bool init();
	virtual void createItem(float dt);
};

#endif

#pragma once
#ifndef __BULLET_LAYER_H_
#define __BULLET_LAYER_H_
#include "cocos2d.h"
#include "BulletBase.h"
USING_NS_CC;
/*

	子弹控制层，主要用于控制子弹等级
*/
class BulletLayer :public Layer
{
public:
	BulletLayer();
	~BulletLayer();
	CREATE_FUNC(BulletLayer);
	bool init();
	void bindplayer(Player*player);
	Vector<Sprite*>&getBullets();
	//更改子弹等级
	void changeBullet(int bulletNumber);
	//移除子弹
	void removeBullet(Node *bullet);
	//发射必杀技
	void shootBoom(int x);
	//子弹升级
	void upBullet();
	//重置子弹
	void resetBullet();
	void update(float delta);
private :
	Player *mPlayer;
	BulletBase *mBullet;
	int bulletNumber;
};


#endif

#ifndef __BULLET_BASE_H_
#define __BULLET_BASE_H_
#include "cocos2d.h"
#include "Player.h"
USING_NS_CC;
/*

	子弹发射基类
*/
class BulletBase :public cocos2d::Node
{
public:
	~BulletBase();
	CREATE_FUNC(BulletBase);
	//移除产生的所有子弹
	void removeAllObject();
	//移除指定子弹
	void removeBullet(Node *node);
	//根绝角色位置产生子弹
	virtual void createBullet(Node *plane);
	//子弹发射
	virtual void shootBullet(float dt);
	//返回产生的所有子弹
	virtual Vector<Sprite*> &getBullets();
	//更改子弹等级
	void changeBullet(int num);
	//发射必杀技
	virtual void shootBoom(int x);
protected:
	Vector<Sprite*>mBullets;
	SpriteBatchNode *mBatchNode;
	Node *mPlayer;
	int mBulletNum = 1;
};

#endif

#pragma once
#ifndef __BULLET_ONE_H_
#define __BULLET_ONE_H_
#include "cocos2d.h"
#include "Player.h"
#include "BulletBase.h"
USING_NS_CC;
class Bulletone :public BulletBase
{
public:

	CREATE_FUNC(Bulletone);
	virtual void shootBullet(float dt);
	
	virtual void shootBoom(int x);
	
};



#endif

#pragma once
#ifndef __FACTOR_LAYER_H__
#define __FACTOR_LAYER_H__
#include "cocos2d.h"
#include "Player.h"
#include "ItemFactor.h"
#include "MonsterFactor.h"
#include "ToolFactor.h"
#include "Bullet.h"
#include "GameLogic.h"
USING_NS_CC;
/*

	游戏碰撞层，主要是控制角色与道具的碰撞检测，角色与怪物，与敌方子弹的碰撞检测，己方子弹与敌方的碰撞
*/
class ColliderLayer :public Layer
{
public:
	CREATE_FUNC(ColliderLayer);
	bool init();
	void setPlayer(Player *player);
	const Vector<Sprite*>&getBullets();
	//游戏逻辑层，因为这里检测碰撞后，需要逻辑层计算得分，物品等
	void setGameLogic(GameLogic *gameLogic);
private:
	//每一帧都要进行碰撞检测
	virtual void update(float dt);
	//检测怪物的碰撞
	void colliderMonster();
	//检测游戏道具的碰撞
	void colliderTool();
	//怪物生产工厂，负责怪物的产生位置，类型，时间
	MonsterFactor *mMonseterFactor;
	//道具生产工厂，负责道具的产生位置，类型，时间
	ToolFactor *toolFactor;
	//持有一个角色，进行相关计算
	Player *mPlayer;
	//持有角色的子弹层，因为需要统一在碰撞层进行碰撞检测
	BulletLayer *mBullerLayer;
	//游戏逻辑层，进行相关游戏逻辑计算。
	GameLogic *mGameLogic;
};
#endif