task.cpp

一个自己写的游戏引擎,用DirectX 写成

//--------------------------------------------------
//  Desc: Task
//  Author: artsylee/2006.11.21
//--------------------------------------------------
#include "../stdafx.h"
#include "Task.h"
#include "Message.h"

//---------------------------------------------------
// 任务基类(抽象基类)
//---------------------------------------------------
CTask::CTask()						
{
	m_bAutoDelete = false;
	m_cLayer = 0;
}
CTask::~CTask()			
{	
	Destroy();	
}
void CTask::Destroy()	
{
	m_bAutoDelete = false;
	m_cLayer = 0;
}

bool CTask::IsAutoDelete()	
{
	return m_bAutoDelete;
}
void CTask::SetAutoDelete(bool c)
{
	m_bAutoDelete = c;
}

unsigned char CTask::GetLayer(void)
{
	return m_cLayer;
}

void CTask::SetLayer(unsigned char layer)
{
	m_cLayer = layer;
}

//---------------------------------------------------
// CMessageTask (abstract class)
//---------------------------------------------------
CMessageTask::CMessageTask()
{
	m_pMsgmanager = NULL;
	m_Param1 = 0;
	m_Param2 = 0;
	m_pParam3 = NULL;
}

CMessageTask::~CMessageTask()
{
	m_pMsgmanager = NULL;
}

void CMessageTask::EndMessage()
{
	if(m_pMsgmanager != NULL)
	{
		CMessage msg(m_MsgType, 0, 0);
		msg.m_dwParam1 = m_Param1;
		msg.m_dwParam2 = m_Param2;
		msg.m_pParam3 = m_pParam3;
		m_pMsgmanager->PostMessage(msg);
	}
}

void CMessageTask::SetMessage(CMessageManager *pmm, DWORD type)
{
	m_pMsgmanager = pmm;
	m_MsgType = type;
}

void CMessageTask::SetParam(DWORD p1, DWORD p2, void* p3 /* = NULL */)
{
	m_Param1 = p1;
	m_Param2 = p2;
	m_pParam3 = p3;
}

//---------------------------------------------------
// 帧延时任务(抽象基类)
//---------------------------------------------------
CDelayTask::CDelayTask()
{
	m_dwLastTime = 0;
	m_dwDelay = 100;
}

CDelayTask::~CDelayTask()
{
	m_dwLastTime = 0;
	m_dwDelay = 100;
}

//---------------------------------------------------
// 任务管理器
//---------------------------------------------------
CTaskManager::CTaskManager()
{
}

CTaskManager::~CTaskManager()
{
	RemoveAll();
}

void CTaskManager::RemoveAll()
{
	std::list<CTask*>::iterator itor = m_TaskList.begin();
	while(itor!=m_TaskList.end())
	{
		delete (*itor);
		(*itor) = NULL;
		itor++;
	}
	m_TaskList.clear();
}

void CTaskManager::AddTask(CTask *pTask)
{
	if(m_TaskList.size()==0)
	{
		m_TaskList.push_back(pTask);
	}
	else if(pTask->GetLayer()>=(*(--m_TaskList.end()))->GetLayer())
	{
		m_TaskList.push_back(pTask);
	}
	else if(pTask->GetLayer()<=(*(m_TaskList.begin()))->GetLayer())
	{
		m_TaskList.push_front(pTask);
	}
	else
	{
		std::list<CTask*>::iterator itor = m_TaskList.begin();
		while(itor != m_TaskList.end())
		{
			if(pTask->GetLayer()<=(*itor)->GetLayer())
			{
				m_TaskList.insert(itor, pTask);
				return;
			}
			itor++;
		}
	}
}

int CTaskManager::GetTaskCount(void) const
{
	return m_TaskList.size();
}

bool CTaskManager::RemoveTask(CTask *pTask)
{
	std::list<CTask*>::iterator itor = m_TaskList.begin();
	while(itor!=m_TaskList.end())
	{
		if((*itor)==pTask)
		{
			delete (*itor);
			(*itor) = NULL;
			m_TaskList.erase(itor);
			return true;
		}	
		itor++;
	}
	return false;
}

void CTaskManager::Update()
{
	std::list<CTask*>::iterator itor = m_TaskList.begin();
	while(itor!=m_TaskList.end())
	{
		if((*itor)->IsAutoDelete())
		{
			delete (*itor);
			(*itor) = NULL;
			itor = m_TaskList.erase(itor);
			continue;
		}	
		(*itor)->Update();
		itor++;
	}
}

void CTaskManager::Render(TaskLayer layer /* = TL_SEA */)
{
	if(layer == TL_LOGIC)
		return;
	unsigned char minLayer = layer * SUBLAYER;
	unsigned char maxLayer = (layer + 1) * SUBLAYER;
	std::list<CTask*>::iterator itor = m_TaskList.begin();
	while(itor!=m_TaskList.end())
	{
		unsigned char tasklayer = (*itor)->GetLayer();
		if(tasklayer>=minLayer && tasklayer<maxLayer)
		{
			(*itor)->Render();
		}
		itor++;
	}
}