item.h

泡泡堂单机版(含ASL游戏引擎源码 泡泡堂单机版(含ASL游戏引擎源码

#pragma once

#include "incs.h"
#include "ability.h"
#include <queue>

enum Direction
{
	drUp,
	drDown,
	drLeft,
	drRight,
	drMiddle,
	drUpLeft,
	drUpRight,
	drDownLeft,
	drDownRight
	
};

struct Cell;

class CItem
{
public:
	CItem(void) : m_pbmMain(NULL), m_pbmShadow(NULL) {}
	virtual ~CItem(void) {}
	
	virtual CItem* Clone(void) const = 0;
	virtual void Draw(void) const = 0;
	virtual void Update(float fDelta) {}

	inline void LoadMainBitmap(ASLBitmap *pbmMain) { m_pbmMain = pbmMain; }
	inline void LoadShadowBitmap(ASLBitmap *pbmShadow) { m_pbmShadow = pbmShadow; }	
	inline void SetPosition(int y, int x) { m_nCellX = x; m_nCellY = y; }
	inline ASLBitmap* GetShadow(void) const { return m_pbmShadow; }

protected:
	Cell* GetCell(Direction dr);

protected:
	ASLBitmap *m_pbmMain;
	ASLBitmap *m_pbmShadow;
	int m_nCellX;
	int m_nCellY;
};

class CAniItem : public CItem
{
public:
	static const int ANI_END = -1;
public:
	CAniItem(void)
	: m_bOnAni(false)
	, m_fDelta(0.0f)
	, m_fInterval(0.0f)
	, m_fTime(0.0f)
	, m_nCurrentFrame(0)
	{}

	inline void SetInterval(float fInterval) { m_fInterval = fInterval; }
	inline void SetDelta(float fDelta) { m_fDelta = fDelta; }
	inline void PushSequence(int nSeq) { m_qAniSeq.push(nSeq); }

	virtual void Update(float fDelta);

protected:
	int		m_nCurrentFrame;			// 当前帧号
private:
	bool	m_bOnAni;					// 是否正在动画
	float	m_fDelta;					// 每帧间隔
	float	m_fInterval;				// 动画间隔
	float	m_fTime;					// 计时器
	std::queue<int> m_qAniSeq;			// 动画序列队列
};

class CMedium : public CItem
{
public:
	virtual CItem* Clone(void) const { return new CMedium(*this); }
	virtual void Draw(void) const;
};

class CMediumAni : public CAniItem
{
public:
	virtual CItem* Clone(void) const { return new CMediumAni(*this); }
	virtual void Draw(void) const;
};

class CLarge : public CAniItem
{
public:
	CLarge(void) : m_pbmAni(NULL) {}
	virtual CItem* Clone(void) const { return new CLarge(*this); }
	virtual void Draw(void) const;
	void LoadAniBitmap(ASLBitmap *pbmAni) { m_pbmAni = pbmAni; }
protected:
	ASLBitmap*	m_pbmAni;
};

class CBox : public CItem
{
public:
	CBox(void) : m_nOffsetX(0), m_nOffsetY(0), m_bMoving(false) {}
	virtual CItem* Clone(void) const { return new CBox(*this); }
	virtual void Draw(void) const;
	virtual void Update(float fDelta);
	void Move(Direction dir);

private:
	int m_nOffsetX;
	int m_nOffsetY;
	bool m_bMoving;
	Direction m_Direction;
};

class CBlindage : public CItem
{
public:
	CBlindage(void) : m_nStatus(0), m_bWaggle(false), m_fTime(0.0f) {}
	virtual void Update(float fDelta);
	inline void Waggle(void) { m_bWaggle = true; }

protected:
	int m_nStatus;
private:
	bool m_bWaggle;
	float m_fTime;
};

class CBush : public CBlindage
{
public:
	virtual CItem* Clone(void) const { return new CBush(*this); }
	virtual void Draw(void) const;
};

class CTent: public CBlindage
{
public:
	virtual CItem* Clone(void) const { return new CTent(*this); }
	virtual void Draw(void) const;
};

class CGift : public CItem
{
public:
	CGift(void) : m_fTime(0.0f), m_nDir(1), m_nOffsetY(0), m_bStart(true), m_nScale(1) {}
	virtual CItem* Clone(void) const { return new CGift(*this); }
	virtual void Draw(void) const;
	virtual void Update(float fDelta);	
	inline void SetAbility(const Ability &ab) { m_Ability = ab; }
	inline const Ability& GetAbility(void) const { return m_Ability; }

private:
	float m_fTime;
	int m_nDir;
	int m_nOffsetY;
	bool m_bStart;
	int m_nScale;
	Ability m_Ability;
};

class CRole;

class CPopo : public CItem
{
private:
	enum ExpProperty { epNone, epFirm, epPopo, epSolid };
	ExpProperty GetExpProperty(int nCellY, int nCellX, Direction dr);

public:
	CPopo(void) : m_fTime(0.0f), m_nSeq(0), m_nPower(1), m_fRemainTime(3.3f),
		m_nOffsetX(0), m_nOffsetY(0), m_bMoving(false) {}
	virtual CItem* Clone(void) const { return new CPopo(*this); }
	virtual void Draw(void) const;
	virtual void Update(float fDelta);
	inline void SetPower(int nPower) { ASSERT(nPower > 0); m_nPower = nPower; }
	inline void SetOwner(CRole *pOwner) { ASSERT(pOwner != NULL); m_pOwner = pOwner; }
	inline void Move(Direction dr) { m_bMoving = true; m_Direction = dr; }
	void Explode(void);

private:
	float m_fTime;
	float m_fRemainTime;
	int m_nSeq;
	int m_nPower;
	CRole *m_pOwner;
	int m_nOffsetX;
	int m_nOffsetY;
	bool m_bMoving;
	Direction m_Direction;
};