#pragma once

#include "incs.h"
#include "item.h"
#include "ability.h"

class CRoleState;

class CRole
{
public:
	CRole(void);
	~CRole(void);

	static void LoadSharedBitmap(ASLFile *pFile);
	void Load(ASLFile *pFile);
	void Start(void);
	void New(void);
	void Draw(void) const;
	void Update(float fDelta);
	void Move(Direction dr);
	void LayPopo(void);
	void Win(void);
	void Normal(void);
	inline void SetPosition(int y, int x) { m_nCellY = y; m_nCellX = x; }
	inline int GetX(void) const { return m_nCellX; }
	inline int GetY(void) const { return m_nCellY; }
	inline int GetOffsetX(void) const { return m_nOffsetX; }
	inline int GetOffsetY(void) const { return m_nOffsetY; }
	inline bool IsFlying(void) const { return m_bFlying; }
	inline bool IsDead(void) const { return m_bDead; }
	inline Ability& GetAbility(void) { return m_Ability; }

private:
	enum WalkProperty { wpNone, wpTent, wpStop };	

	template <Direction dr>
	WalkProperty GetWalkProperty(void);

	template <Direction dr>
	void Push(void);

	void UpdateMoveUp(int nSpeed);
	void UpdateMoveDown(int nSpeed);
	void UpdateMoveLeft(int nSpeed);
	void UpdateMoveRight(int nSpeed);

	void EnterNewCell(void);
	void AdjustCell(void);
	void ChangeState(CRoleState *pState);

private:
	friend class CRoleState;
	friend class CRoleStateStart;
	friend class CRoleStateNormal;
	friend class CRoleStateIdle;
	friend class CRoleStateTraped;
	friend class CRoleStateOnTrap;
	friend class CRoleStateOnSave;
	friend class CRoleStateOnDie;
	friend class CRoleStateDead;
	friend class CRoleStateWin;
	friend class CRoleStateOnRide;
	friend class CRoleStateOnDismount;

private:
	static ASLBitmap m_bmBigPopo;
	static ASLBitmap m_bmSlowTurtle;
	static ASLBitmap m_bmFastTurtle;
	static ASLBitmap m_bmOwl;
	static ASLBitmap m_bmFastUFO;
	ASLBitmap m_bmMain;
	ASLBitmap m_bmShadow;
	ASLBitmap m_bmStart;
	ASLBitmap m_bmAni;
	ASLBitmap m_bmDie;
	ASLBitmap m_bmRide;
	CRoleState *m_pState;
	int m_nCellX;
	int m_nCellY;
	int m_nOffsetX;
	int m_nOffsetY;
	Direction m_Direction;
	int m_nPushTime;
	bool m_bMoving;	
	bool m_bFlying;
	bool m_bDead;
	Ability m_Ability;
};

//-----------------------------------------------------------------------------
// 狀態(tài)類定義, 應(yīng)用State模式
//-----------------------------------------------------------------------------
enum RoleState
{
	rsStart,
	rsNormal,
	rsIdle,
	rsTraped,
	rsOnTrap,
	rsOnSave, 
	rsOnDie,
	rsDead,
	rsWin,
	rsOnRide,
	rsOnDismount
};

class CRoleState
{
public:
	CRoleState(CRole *pRole) : m_pRole(pRole) {}
	virtual void Draw(int x, int y) const = 0;
	virtual void Update(float fDelta) = 0;
	virtual RoleState Type(void) const = 0;
	void ChangeState(CRoleState *pState) { m_pRole->ChangeState(pState); }

protected:
	void CheckChange(void);
	void DrawShadow(int x, int y) const;

protected:
	CRole *m_pRole;
};

class CRoleStateStart : public CRoleState
{
public:
	CRoleStateStart(CRole *pRole);
	virtual void Draw(int x, int y) const;
	virtual void Update(float fDelta);
	virtual RoleState Type(void) const { return rsStart; }

private:
	int m_nAniSeq;
	float m_fTime;
};

class CRoleStateNormal : public CRoleState
{
public:
	CRoleStateNormal(CRole *pRole);
	virtual void Draw(int x, int y) const;
	virtual void Update(float fDelta);
	virtual RoleState Type(void) const { return rsNormal; }

private:
	int m_nIdleCount;	
	int m_nFrameCount;
	int m_nCurrentFrame;
};

class CRoleStateIdle : public CRoleState
{
public:
	CRoleStateIdle(CRole *pRole);
	virtual void Draw(int x, int y) const;
	virtual void Update(float fDelta);
	virtual RoleState Type(void) const { return rsIdle; }

private:
	int m_nAniSeq;
	float m_fTime;
};

class CRoleStateOnTrap : public CRoleState
{
public:
	CRoleStateOnTrap(CRole *pRole);
	virtual void Draw(int x, int y) const;
	virtual void Update(float fDelta);
	virtual RoleState Type(void) const { return rsOnTrap; }

private:
	int m_nAniSeq;
	float m_fTime;
};

class CRoleStateTraped : public CRoleState
{
public:
	CRoleStateTraped(CRole *pRole);
	virtual void Draw(int x, int y) const;
	virtual void Update(float fDelta);
	virtual RoleState Type(void) const { return rsTraped; }

private:
	float m_fTime;
	float m_fDeadTime;
	int m_nShake;
	int m_nShakeDr;
	int m_nSpeedCount;
};

class CRoleStateOnSave : public CRoleState
{
public:
	CRoleStateOnSave(CRole *pRole);
	virtual void Draw(int x, int y) const;
	virtual void Update(float fDelta);
	virtual RoleState Type(void) const { return rsOnSave; }

private:
	int m_nAniSeq;
	float m_fTime;
};

class CRoleStateOnDie : public CRoleState
{
public:
	CRoleStateOnDie(CRole *pRole);
	virtual void Draw(int x, int y) const;
	virtual void Update(float fDelta);
	virtual RoleState Type(void) const { return rsOnDie; }

private:
	int m_nAniSeq;
	float m_fTime;
};

class CRoleStateDead : public CRoleState
{
public:
	CRoleStateDead(CRole *pRole) : CRoleState(pRole) {}
	virtual void Draw(int x, int y) const {}
	virtual void Update(float fDelta) {}
	virtual RoleState Type(void) const { return rsDead; }
};

class CRoleStateWin : public CRoleState
{
public:
	CRoleStateWin(CRole *pRole);
	virtual void Draw(int x, int y) const;
	virtual void Update(float fDelta);
	virtual RoleState Type(void) const { return rsWin; }
	
private:
	int m_nAniSeq;
	float m_fTime;
};

class CRoleStateOnRide : public CRoleState
{
public:
	CRoleStateOnRide(CRole *pRole);
	virtual void Draw(int x, int y) const;
	virtual void Update(float fDelta);
	virtual RoleState Type(void) const { return rsOnRide; }

private:
	int m_nAniSeq;
	float m_fTime;
};

class CRoleStateOnDismount : public CRoleState
{
public:
	CRoleStateOnDismount(CRole *pRole);
	virtual void Draw(int x, int y) const;
	virtual void Update(float fDelta);
	virtual RoleState Type(void) const { return rsOnDismount; }

private:
	int m_nAniSeq;
	float m_fTime;
};

//-----------------------------------------------------------------------------
const int ROLE_NUM = 2;
extern CRole ROLE[ROLE_NUM];