actionengine.cpp

游戏框架

// ***************************************************************
//  ActionEngine   version:  1.0
//  -------------------------------------------------------------
//	File Name:	ActionEngine.cpp
//	Created:	2007/07/18
//	Modified:	2007/07/18   16:52
//	Author:		William.Liang
//  Msn:		[e-mail]
//  Email:		[e-mail], [e-mail]
//	Description:
//
//	Purpose:	
//  -------------------------------------------------------------
//  license:
//
//  The contents of this file are subject to the Mozilla Public
//  License Version 1.1 (the "License"); you may not use this file
//  except in compliance with the License. You may obtain a copy
//  of the License at http://www.mozilla.org/MPL/ Software dis-
//  tributed under the License is distributed on an "AS IS" 
//  basis, WITHOUT WARRANTY OF ANY KIND, either express or im-
//  plied. See the License for the specific language governing
//  rights and limitations under the License.
//
//  The Initial Developer of the Original Code is William.Liang .
//  Copyright (C) 2007 - All Rights Reserved.
// ***************************************************************
#include "StdAfx.h"
#include "ActionEngine.h"
//#include "EventService.h"

//宏定义
#define NO_TIME_LEFT						DWORD(-1)				//不响应时间

//////////////////////////////////////////////////////////////////////////

//************************************
// <p>Description: 构造函数</p>
//************************************
CActionThread::CActionThread(void)
{
	m_dwTimerSpace=0L;
	m_pActionEngine=NULL;
}

//************************************
// <p>Description: 析构函数</p>
//************************************
CActionThread::~CActionThread(void)
{
}

//************************************
// <p>Description: 配置函数</p>
// <p>Parameters:  </p>
// <p>    CActionEngine * pActionEngine</p>
// <p>    DWORD dwTimerSpace</p>
//
// <p>Returns:   bool</p>
//************************************
bool CActionThread::InitThread(CActionEngine * pActionEngine, DWORD dwTimerSpace)
{
	//效益参数
	//_ASSERT(dwTimerSpace>=5L);
	_ASSERT(pActionEngine!=NULL);
	if (pActionEngine==NULL) return false;

	//设置变量
	m_dwTimerSpace=dwTimerSpace;
	m_pActionEngine=pActionEngine;

	return true;
}

//************************************
// <p>Description: 运行函数</p>
//
// <p>Returns:   bool</p>
//************************************
bool CActionThread::RepetitionRun()
{
	_ASSERT(m_pActionEngine!=NULL);
	Sleep(m_dwTimerSpace);
	m_pActionEngine->OnActionThreadSink();
	return true;
}

//////////////////////////////////////////////////////////////////////////

//************************************
// <p>Description: 构造函数</p>
//************************************
CActionEngine::CActionEngine()
{
	m_bService=false;
	m_dwTimerSpace=25;
}

//************************************
// <p>Description: 析构函数</p>
//************************************
CActionEngine::~CActionEngine(void)
{
	//停止服务
	StopService();

	//清理内存
	RemoveAll();

	return;
}

//************************************
// <p>Description: 接口查询</p>
// <p>Parameters:  </p>
// <p>    const IID & Guid</p>
// <p>    DWORD dwQueryVer</p>
//
// <p>Returns:   void * __cdecl</p>
//************************************
void * __cdecl CActionEngine::QueryInterface(const IID & Guid, DWORD dwQueryVer)
{
	QUERYINTERFACE(IActionEngine,Guid,dwQueryVer);
	QUERYINTERFACE(IActionEngineManager,Guid,dwQueryVer);
	QUERYINTERFACE_IUNKNOWNEX(IActionEngine,Guid,dwQueryVer);
	return NULL;
}

//************************************
// <p>Description: 设置定时器</p>
// <p>Parameters:  </p>
// <p>    IGameObject * pIGameObject</p>
// <p>    enuActionType ActionType</p>
// <p>    WORD wActionID</p>
// <p>    DWORD dwElapse</p>
// <p>    DWORD dwRepeat</p>
// <p>    WPARAM wParam</p>
//
// <p>Returns:   bool __cdecl</p>
//************************************
bool __cdecl CActionEngine::CreateAction(IGameObject* pIGameObject, enuActionType ActionType, WORD wActionID, DWORD dwElapse, DWORD dwRepeat, WPARAM wParam, BOOL bCheckExist)
{
	//锁定资源
	CThreadLockHandle LockHandle(&m_ThreadLock);

	//效验参数
	_ASSERT(dwRepeat>0L);
	if (dwRepeat==0) return false;

	//查找对象相同动作
	//bool bActionExist = false;// = (m_ActionItems.GetBy(pIGameObject)!=NULL);
	bool bActionExist = bCheckExist && (m_ActionItems.GetBy(wActionID)!=NULL);

	//创建定时器
	if (bActionExist==false)
	{
		tagActionItem*	pActionItem = new tagActionItem;
		IActionProcess*	pIActionProcess	= NULL;
		DWORD	dwFrames = (dwElapse+m_dwTimerSpace-1)/m_dwTimerSpace;

		switch(ActionType){
			case Action_Move:
				{
					_POINT	Point = *(_POINT*)wParam;
					pIActionProcess = new CActionProcessMove(pIGameObject, dwFrames, Point);
					break;
				}
			case Action_Resize:
				{
					_SIZE	Size = *(_SIZE*)wParam;
					pIActionProcess = new CActionProcessScaling(pIGameObject, dwFrames, Size);
					break;
				}
			case Action_Angle:
				{
					tagProcessAngleParam*	lpAngleParam = (tagProcessAngleParam*)wParam;
					pIActionProcess = new CActionProcessAngle(pIGameObject, dwFrames, lpAngleParam);
					break;
				}
			case Action_Vibrating:
				{
					tagProcessVibratingParam*	lpVibratingParam = (tagProcessVibratingParam*)wParam;
					pIActionProcess = new CActionProcessVibrating(pIGameObject, dwFrames, lpVibratingParam);
					break;
				}
			case Action_MoveTrack:
				{
					tagProcessTrackParam*	lpTrackParam = (tagProcessTrackParam*)wParam;
					pIActionProcess = new CActionProcessMoveTrack(pIGameObject, dwFrames, lpTrackParam);
					break;
				}
		}

		if(pIActionProcess){
			pActionItem->wActionID			= wActionID;
			pActionItem->pIGameObject		= pIGameObject;
			pActionItem->pIActionProcess	= pIActionProcess;
			pActionItem->bIsCallBack		= false;
			pActionItem->dwFrames			= dwFrames;
			pActionItem->dwPassFrames		= dwFrames;
			pActionItem->dwRepeatTimes		= dwRepeat;
			pActionItem->wBindParam			= wParam;

			m_ActionItems.Push(pActionItem, wActionID);
			int i=m_ActionItems.GetCount();

			return true;
		}
	}
	return false;
}

//************************************
// <p>Description: 设置定时器</p>
// <p>Parameters:  </p>
// <p>    IGameObject * pIGameObject</p>
// <p>    IActionProcess * pIActionProcess</p>
// <p>    WORD wActionID</p>
// <p>    DWORD dwElapse</p>
// <p>    DWORD dwRepeat</p>
// <p>    WPARAM wParam</p>
//
// <p>Returns:   bool __cdecl</p>
//************************************
bool __cdecl CActionEngine::CreateAction(IGameObject* pIGameObject, IActionProcess* pIActionProcess, WORD wActionID, DWORD dwElapse, DWORD dwRepeat, WPARAM wParam, BOOL bCheckExist)
{
	//锁定资源
	CThreadLockHandle LockHandle(&m_ThreadLock);

	//效验参数
	_ASSERT(dwRepeat>0L);
	if (dwRepeat==0) return false;

	//查找对象相同动作
	bool bActionExist = bCheckExist && (m_ActionItems.GetBy(wActionID)!=NULL);

	//创建定时器
	if (bActionExist==false)
	{
		if(pIActionProcess){
			tagActionItem*	pActionItem = new tagActionItem;
			DWORD	dwFrames = (dwElapse+m_dwTimerSpace-1)/m_dwTimerSpace;

			pActionItem->wActionID			= wActionID;
			pActionItem->pIGameObject		= pIGameObject;
			pActionItem->pIActionProcess	= pIActionProcess;
			pActionItem->bIsCallBack		= false;
			pActionItem->dwFrames			= dwFrames;
			pActionItem->dwPassFrames		= dwFrames;
			pActionItem->dwRepeatTimes		= dwRepeat;
			pActionItem->wBindParam			= wParam;

			m_ActionItems.Push(pActionItem, wActionID);

			return true;
		}
	}
	return false;
}

//************************************
// <p>Description: 删除定时器</p>
// <p>Parameters:  </p>
// <p>    WORD wActionID</p>
//
// <p>Returns:   bool __cdecl</p>
//************************************
bool __cdecl CActionEngine::Remove(WORD wActionID)
{
	//锁定资源
	CThreadLockHandle LockHandle(&m_ThreadLock);

	tagActionItem*		pActionItem = m_ActionItems.GetBy(wActionID);
	if(pActionItem){
		SafeDelete(pActionItem->pIActionProcess);
		SafeDelete(pActionItem);

		m_ActionItems.RemoveBy(wActionID);

		return true;
	}

	return false;
}

//************************************
// <p>Description: 删除定时器</p>
//
// <p>Returns:   bool __cdecl</p>
//************************************
bool __cdecl CActionEngine::RemoveAll()
{
	//锁定资源
	CThreadLockHandle LockHandle(&m_ThreadLock);

	//删除定时器
	tagActionItem*		pActionItem = m_ActionItems.Iterators(true);
	while(pActionItem){
		//删除执行处理接口指针
		SafeDelete(pActionItem->pIActionProcess);
		//删除执行项
		SafeDelete(pActionItem);

		pActionItem = m_ActionItems.Iterators();
	}
	m_ActionItems.RemoveAll();

	return true;
}

//************************************
// <p>Description: 开始服务</p>
//
// <p>Returns:   bool __cdecl</p>
//************************************
bool __cdecl CActionEngine::StartService()
{
	//效验状态
	//定时器引擎重复启动，启动操作忽略
	if (m_bService==true) return true;

	//判断绑定
	if (m_AttemperEvent.IsValid()==false)
	{
		//CEventTrace::ShowEventNotify(TEXT("定时器引擎未与触发服务绑定"),Level_Exception);
		return false;
	}

	//设置变量
	if (m_ActionThread.InitThread(this,m_dwTimerSpace)==false)
	{
		//CEventTrace::ShowEventNotify(TEXT("定时器引擎线程服务初始化失败"),Level_Exception);
		return false;
	}

	//启动服务
	if (m_ActionThread.StartThead()==false)
	{
		//CEventTrace::ShowEventNotify(TEXT("定时器引擎线程服务启动失败"),Level_Exception);
		return false;
	}

	//设置变量
	m_bService=true;

	return true;
}

//************************************
// <p>Description: 停止服务</p>
//
// <p>Returns:   bool __cdecl</p>
//************************************
bool __cdecl CActionEngine::StopService()
{
	//设置变量
	m_bService=false;

	//停止线程
	m_ActionThread.StopThread();

	//删除计时器
	RemoveAll();

	return true;
}

//************************************
// <p>Description: 设置接口</p>
// <p>Parameters:  </p>
// <p>    IUnknownEx * pIUnknownEx</p>
//
// <p>Returns:   bool __cdecl</p>
//************************************
bool __cdecl CActionEngine::SetActionEngineSink(IUnknownEx * pIUnknownEx)
{
	//效验参数
	_ASSERT(pIUnknownEx!=NULL);
	_ASSERT(m_bService==false);
	if (m_bService==true) return false;
	if (pIUnknownEx==NULL) return false;

	//设置接口
	if (m_AttemperEvent.SetQueueService(pIUnknownEx)==false)
	{
		//CEventTrace::ShowEventNotify(TEXT("定时器引擎与触发服务绑定失败"),Level_Exception);
		return false;
	}
	
	return true;
}

//************************************
// <p>Description: 动作通知</p>
//
// <p>Returns:   void</p>
//************************************
void CActionEngine::OnActionThreadSink()
{
	//锁定资源
	CThreadLockHandle LockHandle(&m_ThreadLock);

	//查询定时器
	if (m_ActionItems.GetCount()>0)
	{
		bool bKillAction=false;
		tagActionItem*		pActionItem = m_ActionItems.Iterators(true);
		while(pActionItem){
			//动作处理
			//bKillAction=false;
			//每个动作检查
			pActionItem->dwPassFrames--;
			//动作结束处理
			if (pActionItem->dwPassFrames==0L){
				//动作的最后一帧对齐处理
				pActionItem->pIActionProcess->Process(true);
				//发送通知
				m_AttemperEvent.PostActionEvent(pActionItem->pIGameObject, pActionItem->wActionID, pActionItem->dwRepeatTimes-1, pActionItem->wBindParam);

				//设置次数
				if (pActionItem->dwRepeatTimes!=TIMER_REPEAT_TIMER)
				{
					_ASSERT(pActionItem->dwRepeatTimes>0);
					if (pActionItem->dwRepeatTimes==1L)
					{
						pActionItem->dwRepeatTimes--;
						bKillAction=true;
					}
					else{
						pActionItem->dwRepeatTimes--;
						pActionItem->dwPassFrames = pActionItem->dwFrames;
						pActionItem->pIActionProcess->Reset();
					}
				}
			}
			else{
				//动作的每帧处理
				pActionItem->pIActionProcess->Process();
			}
			pActionItem = m_ActionItems.Iterators();
		}

		//处理已失效的动作
		if(bKillAction){
			for(INT_PTR i=m_ActionItems.GetCount();i>=1;i--){
				pActionItem = m_ActionItems.Get(i);
				if(pActionItem->dwPassFrames==0 && pActionItem->dwRepeatTimes==0){
					pActionItem->pIActionProcess->Release();
					SafeDelete(pActionItem);
					m_ActionItems.Remove(i);
				}
			}
		}
	}

	return;
}

//////////////////////////////////////////////////////////////////////////