用cocos2dx做一个简单的单机捕鱼达人游戏（3）

第三步就先写游戏中“新手村”主逻辑吧
玩家进入新手村，默认就有1000金币，出了新手村数据就清空，下次再进来还是1000金币
先写鱼吧
用工厂模式来写鱼的创建以及管理-----3个类 一个fish类一个fishManage类一个fishFactory类
fish.h

#pragma once
#ifndef _Fish_H_
#define _Fish_H_
#include"cocos2d.h"
class FishManage;
class FishFactory;
using namespace cocos2d;
enum FISHTYPE
{
	FishTypeOne,
	FishTypeTwo,
	FishTypeThree,
	FishTypeFour,
	FishTypeFive,
	FishTypeSix
};
class Fish:public Sprite
{
public:
	Fish(FISHTYPE t);
	~Fish();
	bool init() override;
	static Fish* create(FISHTYPE t);
	//获得种类
	FISHTYPE getFishType()
	{
		return this->type;
	}
	void setLive(bool isLive)
	{
		this->isLive = isLive;
	}
	bool getLive()
	{
		return isLive;
	}
	float getHp()
	{
		return m_cHp;
	}
	void reduceHp(double bulletAtt)
	{
		m_cHp -= bulletAtt;
	}
	int getCoin()
	{
		return this->coin;
	}
	//第一种鱼的游泳动画
	void SwimCartoonOne();
	//第一种鱼鲸鱼的死亡动画
	void DeadCartoonOne();
	//第二种鱼的游泳动画
	void SwimCartoonTwo();
	//第二种鱼鲸鱼的死亡动画
	void DeadCartoonTwo();
	//第三种鱼小金鱼的游泳动画
	void SwinCartoonThree();
	//第三种鱼鲸鱼的死亡动画
	void DeadCartoonThree();
	void onEnter() override;
	void onExit() override;
	//死亡动画执行完的回调函数
	void FishBack();
	//鱼的游泳位置动画
	void FishSwim();
	bool isPeng;//增加一个bool值用于阻挡死了的鱼应为要回调播放动画造成的阻碍别的子弹
	int birth;//出生的位置1屏幕上边2屏幕右边3屏幕下边4屏幕左边
private:
	float speed;//鱼的游泳速度
	FISHTYPE type;//鱼的种类
	//默认调度器的update函数重写
	void update(float dt);
	//鱼的游动
	void swim(float dt);
	float m_cHp;//血量
	bool isLive;//是否存活
	int coin;//金币
	
};
#endif // !_Fish_H_

fish.cpp

#include"Fish.h"
#include"FishManage.h"
Fish::Fish(FISHTYPE t):
type(t)
{
}


Fish::~Fish()
{
}

bool Fish::init()
{
	switch (this->type)
	{
	case FishTypeOne:
	{if (!initWithFile("bigfish.png"))
	{
		return false;
	}
	//鲸鱼的动画播放
	SwimCartoonOne();
	//鲸鱼的速度
	speed = 70;
	//随机血量
	int num = rand() % 10;
	m_cHp = 95+num;
	//杀死鱼所加的金币
	coin = 100;
	}
	break;
	case FishTypeTwo:
	{if (!initWithFile("/fish/xiaoliyu/fish001.png"))
	{
		return false;
	}
	//鲸鱼的动画播放

	//小鲤鱼鱼的速度
	speed = 100;
	//随机血量
	int num = rand() % 10;
	m_cHp = 20+num;
	//杀死鱼所加的金币
	coin = 20;
	}
		break;
	case FishTypeThree:
	{if (!initWithFile("/fish/xiaojinyu/fishthree1.png"))
	{
		return false;
	}
	//鲸鱼的动画播放

	//小金鱼的速度
	speed = 100;

	//随机血量
	int num = rand() % 5;
	m_cHp = 8+num;

	//杀死鱼所加的金币
	coin = 5;
	}
		break;
	default:
		break;
	}
	int num = rand()%4+1;
	birth = num;//随机的出生位置
	 isPeng=false;//增加一个bool值用于阻挡死了的鱼应为要回调播放动画造成的阻碍别的子弹
	//开启默认调度器
	scheduleUpdate();
	return true;
}

Fish * Fish::create(FISHTYPE t)
{
	Fish* ret = new(std::nothrow) Fish(t);
	if (ret&&ret->init())
	{
		ret->autorelease();
	}
	else
	{
		delete ret;
		ret = nullptr;
	}
	return ret;
}

void Fish::SwimCartoonOne()
{
	//鲸鱼的动画播放
	//1创建animation-ref
	Animation*act = Animation::create();
	//2添加精灵帧
	for (int i = 1; i < 6; i++)
	{
		char fileName[32];
		sprintf_s(fileName, "/bigFishCartoon/bigfish%d.png", i);
		act->addSpriteFrameWithFile(fileName);
	}
	//设置动画的状态
	act->setDelayPerUnit(0.1);//帧速率
	act->setLoops(-1);//循环次数
	act->setRestoreOriginalFrame(true);//动画结束回到第一帧
									   //4animation添加到animate中（创建animate）
	Animate*pAnimate = Animate::create(act);
	this->runAction(pAnimate);
}

void Fish::DeadCartoonOne()
{
	//1创建animation-ref
	Animation* act = Animation::create();
	//2添加精灵帧
	for (int i = 1; i < 11; i++)
	{

		char fileName[30];
		sprintf_s(fileName, "/bigFishCartoon/bigfish%d.png", i);
		act->addSpriteFrameWithFile(fileName);
	}
	//3设置动画的状态
	act->setDelayPerUnit(0.03);//设置帧速率
	act->setLoops(3);//设置循环的次数，-1表示一直循环
	act->setRestoreOriginalFrame(true);//设置是否在动画结束后回到原始帧
									   //4.Animation添加到Animate中(创建Animate)
	Animate* animate = Animate::create(act);

	CallFunc* callFunc = CallFunc::create(this,
		callfunc_selector(Fish::FishBack));//回调函数
	Sequence* seqAct = Sequence::create(animate, callFunc, nullptr);//序列动作:...传无限多个参数,以nullptr结尾
	this->runAction(seqAct);
}

void Fish::SwimCartoonTwo()
{
	//小鲤鱼的动画播放
	//1创建animation-ref
	Animation*actTwo = Animation::create();
	//2添加精灵帧
	for (int i = 2; i < 6; i++)
	{
		char fileName[32];
		sprintf_s(fileName, "/fish/xiaoliyu/fish0%d.png", i);
		actTwo->addSpriteFrameWithFile(fileName);
	}
	//设置动画的状态
	actTwo->setDelayPerUnit(0.1);//帧速率
	actTwo->setLoops(-1);//循环次数
	actTwo->setRestoreOriginalFrame(true);//动画结束回到第一帧
									   //4animation添加到animate中（创建animate）
	Animate*pAnimateTwo = Animate::create(actTwo);
	this->runAction(pAnimateTwo);
}

void Fish::DeadCartoonTwo()
{
	//1创建animation-ref
	Animation* actDeadTwo = Animation::create();
	//2添加精灵帧
	for (int i = 1; i < 13; i++)
	{
		char fileName[30];
		sprintf_s(fileName, "/fish/xiaoliyu/fish00%d.png", i);
		actDeadTwo->addSpriteFrameWithFile(fileName);
	}
	//3设置动画的状态
	actDeadTwo->setDelayPerUnit(0.03);//设置帧速率
	actDeadTwo->setLoops(3);//设置循环的次数，-1表示一直循环
	actDeadTwo->setRestoreOriginalFrame(true);//设置是否在动画结束后回到原始帧
									   //4.Animation添加到Animate中(创建Animate)
	Animate* animateDeadTwo = Animate::create(actDeadTwo);

	CallFunc* callFunc = CallFunc::create(this,
		callfunc_selector(Fish::FishBack));//回调函数
	Sequence* seqAct = Sequence::create(animateDeadTwo, callFunc, nullptr);//序列动作:...传无限多个参数,以nullptr结尾
	this->runAction(seqAct);
}

void Fish::SwinCartoonThree()
{
	//小鲤鱼的动画播放
	//1创建animation-ref
	Animation*actTwo = Animation::create();
	//2添加精灵帧
	for (int i = 1; i < 6; i++)
	{
		char fileName[32];
		sprintf_s(fileName, "/fish/xiaojinyu/fishthree%d.png", i);
		actTwo->addSpriteFrameWithFile(fileName);
	}
	//设置动画的状态
	actTwo->setDelayPerUnit(0.1);//帧速率
	actTwo->setLoops(-1);//循环次数
	actTwo->setRestoreOriginalFrame(true);//动画结束回到第一帧
										  //4animation添加到animate中（创建animate）
	Animate*pAnimateTwo = Animate::create(actTwo);
	this->runAction(pAnimateTwo);
}

void Fish::DeadCartoonThree()
{
	//1创建animation-ref
	Animation* actDeadThree = Animation::create();
	//2添加精灵帧
	for (int i = 1; i < 8; i++)
	{
		char fileName[30];
		sprintf_s(fileName, "/fish/xiaojinyu/fishthree%d.png", i);
		actDeadThree->addSpriteFrameWithFile(fileName);
	}
	//3设置动画的状态
	actDeadThree->setDelayPerUnit(0.03);//设置帧速率
	actDeadThree->setLoops(3);//设置循环的次数，-1表示一直循环
	actDeadThree->setRestoreOriginalFrame(true);//设置是否在动画结束后回到原始帧
											  //4.Animation添加到Animate中(创建Animate)
	Animate* animateDeadThree = Animate::create(actDeadThree);

	CallFunc* callFuncThree = CallFunc::create(this,
		callfunc_selector(Fish::FishBack));//回调函数
	Sequence* seqActThree = Sequence::create(animateDeadThree, callFuncThree, nullptr);//序列动作:...传无限多个参数,以nullptr结尾
	this->runAction(seqActThree);
}

void Fish::onEnter()
{
	
	//按鱼的种类开启各自的动画及图片加载
	switch (type)
	{
			case FishTypeOne:
				//随机血量重置
				m_cHp = 85 ;
				Sprite::initWithFile("bigfish.png");
				//鲸鱼游泳动画开启
				SwimCartoonOne();
			break;		
			case FishTypeTwo:
			//随机血量重置
			m_cHp = 15 ;//鱼的血量重置
			Sprite::initWithFile("/fish/xiaoliyu/fish001.png");
			//小鲤鱼游泳动画开启
			SwimCartoonTwo();
			break;
			case FishTypeThree:
			m_cHp = 5 ;//鱼的血量重置
			SwinCartoonThree();
			Sprite::initWithFile("/fish/xiaojinyu/fishthree1.png");
			//小金鱼游泳动画开启
			break;
	default:
		break;
	}
	 isPeng=false;//增加一个bool值用于阻挡死了的鱼应为要回调播放动画造成的阻碍别的子弹
	isLive = true;
	Node::onEnter();//
	//开启默认调度器
	scheduleUpdate();

}

void Fish::onExit()
{
	Node::onExit();
}

void Fish::FishBack()
{
	FishManage::getInstance()->collection(this);//收集到死亡池
}

void Fish::FishSwim()
{
	// 移动
	MoveTo* moveTo = MoveTo::create(3.0f, Vec2(0, 300));
	EaseElasticInOut* eei = EaseElasticInOut::create(moveTo);
	this->runAction(eei);

}

void Fish::update(float dt)
{
	swim(dt);//游泳
	Size winSize = Director::getInstance()->getWinSize();//屏幕的大小
	//获得鱼的大小
	Size fishSize = getContentSize();
	//如果鱼出了屏幕就开始回收机制

	if (birth==1&& getPositionX()>(winSize.width+ fishSize.width)
		|| getPositionX()<(0 - fishSize.width)
		|| getPositionY()<(0 - fishSize.width))
	{
		FishManage::getInstance()->collection(this);
	}
	else if (birth == 2 && getPositionY()>(winSize.height+fishSize.height)
		|| getPositionX()<(0 - fishSize.width)
		|| getPositionY()<(0 - fishSize.width))
	{
		FishManage::getInstance()->collection(this);
	}
	else if (birth == 3 && getPositionY()>(winSize.height+fishSize.height)
		|| getPositionX()<(0 - fishSize.width)
		|| getPositionX()>(winSize.width + fishSize.width))
	{
		FishManage::getInstance()->collection(this);
	}
	else if (birth == 4 && getPositionY()>(winSize.height+fishSize.height)
		|| getPositionX()>(winSize.width + fishSize.width)
		|| getPositionY()<(0 - fishSize.width))
	{
		FishManage::getInstance()->collection(this);
	}
}

void Fish::swim(float dt)
{	//位置变化
	switch (birth)
	{
	case 1:
		setRotation(-90);
		setPositionY(getPositionY() - dt * speed);
			break;
	case 2:
		setPositionX(getPositionX() - dt * speed);
		break; 
	case 3:
		setRotation(90);
		setPositionY(getPositionY() +dt * speed);
			break;
	case 4:
		setRotation(180);
		setPositionX(getPositionX() + dt * speed);
		break;
	default:
		setRotation(180);
		setPositionX(getPositionX() + dt * speed);
		break;
	}	
}

fishManage.h

#pragma once
#ifndef _FishManage_H_
#define _FishManage_H_
#include<list>
class Fish;
enum FISHTYPE;
class FishManage
{
public:
	~FishManage();
	static FishManage*getInstance()
	{
		if (nullptr == pInstance)
		{
			pInstance = new FishManage;
		}
		return pInstance;
	}
	void add(Fish*fish);//添加鱼
	void collection(Fish*fish);//消除鱼
	Fish*finddeath(FISHTYPE t);//
	std::list<Fish*>FishLive;//生存池
	std::list<Fish*>FishDead;//死亡池

private:
	static FishManage*pInstance;//单实例
	FishManage();
};
#endif // !_FishManage_H_

fishManage.cpp

#include "FishManage.h"
#include"Fish.h"
FishManage*FishManage::pInstance = nullptr;
FishManage::~FishManage()
{
	//将所有鱼引用计数-1
	for (Fish* Fish : FishLive)
	{
		Fish->release();
	}
	FishLive.clear();//清空链表
	for (Fish* Fish : FishDead)
	{
		Fish->release();
	}
	FishDead.clear();//清空链表
}

void FishManage::add(Fish * fish)
{
	FishLive.push_back(fish);
}

void FishManage::collection(Fish * fish)
{
	fish->removeFromParent();
	FishLive.remove(fish);
	FishDead.push_back(fish);
}

Fish * FishManage::finddeath(FISHTYPE t)
{
	for (Fish*fish:FishDead)
	{
		if (t==fish->getFishType())
		{
			FishDead.remove(fish);
			return fish;
		}
	}
	return nullptr;
}

FishManage::FishManage()
{
}

fishFactory.h

#pragma once
#ifndef _FishFactory_H_
#define _FishFactory_H_
class Fish;
enum FISHTYPE;
class FishFactory
{
public:
	FishFactory();
	~FishFactory();
	//鱼的创建
	static Fish*create(FISHTYPE t);
private:

};

#endif // !_FishFactory_H_

fishFactory.cpp

#include "FishFactory.h"
#include"FishManage.h"
#include"Fish.h"
FishFactory::FishFactory()
{
}

FishFactory::~FishFactory()
{
}

Fish * FishFactory::create(FISHTYPE t)
{
	Fish*fish = nullptr;

	fish = FishManage::getInstance()->finddeath(t);
	if (nullptr==fish)
	{
		fish = Fish::create(t);
	}
	fish->retain();
	FishManage::getInstance()->add(fish);
	return fish;
}