sequence.cpp

一个symbian上成熟的小游戏源码

#include "Sequence.h"
#include <libc/string.h>

namespace gamespace
{

	CSequence* CSequence::NewL(TInt* aPDatas,TInt aLen,TInt* aPDelays/*=NULL*/ )
	{
		CSequence* self=CSequence::NewLC(aPDatas,aLen,aPDelays);
		CleanupStack::Pop();
		return self;
	}

	CSequence* CSequence::NewLC(TInt* aPDatas,TInt aLen,TInt* aPDelays/*=NULL*/  )
	{
		CSequence* self=new(ELeave)CSequence;
		CleanupStack::PushL(self);
		self->ConstructL(aPDatas,aLen,aPDelays);
		return self;
	}

	void CSequence::ConstructL(TInt* aPDatas,TInt aLen,TInt* aPDelays)
	{
		Set(aPDatas,aLen,aPDelays);
	}

	CSequence::CSequence()
	{
		iLen=0;
		iCurrentIndex=0;
		iBLoop=ETrue;
		iElapse=0;
		iPDatas=NULL;
		iPDelays=NULL;
	}

	CSequence::CSequence(CSequence& aSequence )
	{
		iPDatas=NULL;
		iPDelays=NULL;

		*this=aSequence;
	}

	CSequence::~CSequence()
	{
		delete[] iPDatas;
		delete[] iPDelays;
	}

	void CSequence::Set(TInt* aPDatas,TInt aLen,TInt* aPDelays )
	{
		iLen=aLen;
		delete[] iPDatas;
		delete[] iPDelays;

		iPDatas=new TInt[iLen];
		iPDelays=new TInt[iLen];
		memcpy(iPDatas,aPDatas,sizeof(TInt)*iLen);

		if (aPDelays)//如果pDelaysSrc!=NULL
		{
			memcpy(iPDelays,aPDelays,sizeof(TInt)*iLen);
		}
		else//如果pDelaysSrc==NULL，置pDelays数组默认为1
		{
			for (TInt i=0;i<iLen;i++)
			{
				iPDelays[i]=1;
			}
		}
	}

	void CSequence::Set(TInt iLenSrc)
	{
		iLen=iLenSrc;
		delete[] iPDatas;
		delete[] iPDelays;

		iPDatas=new TInt[iLen];
		iPDelays=new TInt[iLen];
		for (TInt i=0;i<iLen;i++)
		{
			iPDatas[i]=i;
			iPDelays[i]=1;
		}
	}

	bool CSequence::NextFrame()
	{
		if (iElapse<iPDelays[iCurrentIndex])
		{
			iElapse++;
			return false;
		}

		iElapse=1;
		iCurrentIndex++;

		if (iCurrentIndex>iLen-1)
		{
			if (iBLoop)//序列循环
				iCurrentIndex=0;
			else//序列不循环
				iCurrentIndex=iLen-1;

			iElapse=0;
			return true;
		}

		return false;
	}

	void CSequence::PrevFrame()
	{
		iCurrentIndex--;

		if (iCurrentIndex<0)
		{
			if (iBLoop)//序列循环
				iCurrentIndex=iLen-1;
			else//序列不循环
				iCurrentIndex=0;
		}
	}

	TInt CSequence::CurrentIndex()
	{
		return iCurrentIndex;
	}

	TInt CSequence::CurrentFrame()
	{
		if (!iPDatas)
		{
			return -1;
		}

		return iPDatas[iCurrentIndex];
	}

	CSequence::operator TInt()
	{
		return CurrentFrame();
	}

	void CSequence::operator=(CSequence* aSequence )
	{
		if (this==aSequence || iPDatas==aSequence->iPDatas)
		{
			return;
		}

		iCurrentIndex=aSequence->iCurrentIndex;
		iBLoop=aSequence->iBLoop;
		iElapse=aSequence->iElapse;

		Set( aSequence->iPDatas,aSequence->iLen,aSequence->iPDelays );
	}

	void CSequence::SetCurrentIndex( TInt sequenceIndex )
	{
		if (sequenceIndex<0 || sequenceIndex>iLen-1)
		{
			return;
		}

		iCurrentIndex=sequenceIndex;
	}

	TInt CSequence::Length()
	{
		return iLen;
	}

}