gamelayer.cpp

游戏框架

// ***************************************************************
//  GameLayer   version:  1.0
//  -------------------------------------------------------------
//	File Name:	GameLayer.cpp
//	Created:	2007/07/18
//	Modified:	2007/07/18   16:27
//	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 ".\gamelayer.h"
#include ".\gamescene.h"

//************************************
// <p>Description: 构造函数</p>
//************************************
CGameLayer::CGameLayer()
{
	m_pBufferPage = NULL;

	SetDisabled(true);
}

//************************************
// <p>Description: 析构函数</p>
//************************************
CGameLayer::~CGameLayer(void)
{
	if(m_pBufferPage)
		SafeDelete(m_pBufferPage);

	Release();
}

//************************************
// <p>Description: 计算容器坐标</p>
// <p>Parameters:  </p>
//
// <p>Returns:   void</p>
//************************************
void CGameLayer::CalcContainerPosition(){

	//设置上一级的容器坐标
	__super::CalcContainerPosition();

	IGameObject*		pGameObject = m_lstGameObjects.Iterators(true);
	while(pGameObject){
		//重置该场下的所有层的容器坐标
		pGameObject->CalcContainerPosition();
		pGameObject = m_lstGameObjects.Iterators();
	}

	return;
}

//************************************
// <p>Description: 对象个数</p>
// <p>Parameters:  </p>
//
// <p>Returns:   INT_PTR</p>
//************************************
INT_PTR CGameLayer::GetLength(){
	return m_lstGameObjects.GetCount();
}

//************************************
// <p>Description: 返回对象</p>
// <p>Parameters:  </p>
// <p>    INT_PTR nIndex</p>
//
// <p>Returns:   IGameObject*</p>
//************************************
IGameObject* CGameLayer::Get(INT_PTR nIndex){
	return m_lstGameObjects.Get(nIndex);
}

//************************************
// <p>Description: 返回对象</p>
// <p>Parameters:  </p>
// <p>    LPCTSTR szKey</p>
//
// <p>Returns:   IGameObject*</p>
//************************************
IGameObject* CGameLayer::GetBy(LPCTSTR szKey){
	return m_lstGameObjects.GetBy(szKey);
}

//************************************
// <p>Description: 返回对象</p>
// <p>Parameters:  </p>
// <p>    INT_PTR nIndex</p>
//
// <p>Returns:   IGameObject*</p>
//************************************
IGameObject* CGameLayer::operator[](INT_PTR nIndex){
	return Get(nIndex);
}

//************************************
// <p>Description: 返回对象</p>
// <p>Parameters:  </p>
// <p>    LPCTSTR szKey</p>
//
// <p>Returns:   IGameObject*</p>
//************************************
IGameObject* CGameLayer::operator[](LPCTSTR szKey){
	return GetBy(szKey);
}

//************************************
// <p>Description: 添加对象</p>
// <p>Parameters:  </p>
// <p>    IGameObject * pIGameObject</p>
// <p>    _CString szName</p>
// <p>    INT_PTR nPosition</p>
//
// <p>Returns:   bool</p>
//************************************
bool CGameLayer::Add(IGameObject* pIGameObject, _CString szName, INT_PTR nPosition){
	if(nPosition==LISTTEMPLATE_LAST_ITEM)
		m_lstGameObjects.Push(pIGameObject, szName);
	else
		m_lstGameObjects.Insert(pIGameObject, nPosition, szName);

	//关联对象
	pIGameObject->SetParent(GET_OBJECTPTR_INTERFACE(this, IBaseObject));
	pIGameObject->CalcContainerPosition();

	//带缓冲
	if(m_wCacheType>0 && m_pBufferPage){
		m_pBufferPage->Add(pIGameObject, szName);
	}
	NotifiyChange();

	return true;
}

//************************************
// <p>Description: 移除对象</p>
// <p>Parameters:  </p>
// <p>    INT_PTR nIndex</p>
//
// <p>Returns:   bool</p>
//************************************
bool CGameLayer::Remove(INT_PTR nIndex){
	m_lstGameObjects.Remove(nIndex);

	//带缓冲
	if(m_wCacheType>0 && m_pBufferPage){
		m_pBufferPage->Remove(nIndex);
	}

	return true;
}

//************************************
// <p>Description: 移除对象</p>
// <p>Parameters:  </p>
// <p>    _CString szKey</p>
//
// <p>Returns:   bool</p>
//************************************
bool CGameLayer::Remove(_CString szKey){
	m_lstGameObjects.RemoveBy(szKey);

	//带缓冲
	if(m_wCacheType>0 && m_pBufferPage){
		m_pBufferPage->RemoveBy(szKey);
	}
	return true;
}

//************************************
// <p>Description: 移除所有对象</p>
// <p>Parameters:  </p>
//
// <p>Returns:   bool</p>
//************************************
bool CGameLayer::ClearAll(){
	m_lstGameObjects.RemoveAll();
	return true;
}

//************************************
// <p>Description: 渲染层</p>
// <p>Parameters:  </p>
// <p>    WPARAM wParam</p>
//
// <p>Returns:   void</p>
//************************************
void CGameLayer::Render(WPARAM wParam){
	if(m_wCacheType>0){
		m_pBufferPage->Render(wParam);
	}
	else{
		IGameObject*		pIGameObject = m_lstGameObjects.Iterators(true);
		while(pIGameObject){
			//渲染所有可视场景
			if(pIGameObject->IsVisabled()){
				pIGameObject->Render(wParam);
			}
			pIGameObject = m_lstGameObjects.Iterators();
		}
	}
}

//************************************
// <p>Description: 预渲染</p>
// <p>Parameters:  </p>
// <p>    WPARAM wParam</p>
//
// <p>Returns:   void</p>
//************************************
void CGameLayer::PreRender(WPARAM wParam){
	//自动模式
	if(m_wCacheType==1 && m_bChanged){
		m_pBufferPage->GenerateBuffer();
		m_bChanged = false;
	}
}

//设置缓冲类型
void CGameLayer::SetCacheType(WORD wType){
	WORD	wOldCacheType = __super::GetCacheType();
	//新旧设置相等，返回
	if(wOldCacheType==wType) return;

	if(wOldCacheType==0){
		//未开启缓冲，要转为带缓冲
		m_pBufferPage = new CGameBufferPage();
		m_pBufferPage->Create("_FrameBuffer_", m_BasalInfo.Size, wType==1);

		//将层内的所有对象关联至缓冲对象
		IGameObject*		pIGameObject = m_lstGameObjects.Iterators(true);
		while(pIGameObject){
			m_pBufferPage->Add(pIGameObject, "");
			pIGameObject = m_lstGameObjects.Iterators();
		}
	}
	else{
		//已开启缓冲，要转回不带缓冲
		if(wType==0){
			//清空缓冲对象
			SafeDelete(m_pBufferPage);
			m_pBufferPage = NULL;
		}
	}

	__super::SetCacheType(wType);
}

//************************************
// <p>Description: 查找指定坐标下的对象</p>
// <p>Parameters:  </p>
// <p>    float x</p>
// <p>    float y</p>
// <p>    CGameScene * * pGameScene</p>
// <p>    CGameLayer * * pGameLayer</p>
// <p>    IGameObject * * pIGameObject</p>
//
// <p>Returns:   bool</p>
//************************************
bool CGameLayer::FindObject(float x, float y, CGameScene** pGameScene, CGameLayer** pGameLayer, IGameObject** pIGameObject)
{
	bool		bFound = false;
	for(INT_PTR i=m_lstGameObjects.GetCount();i>0;i--){
		*pIGameObject = m_lstGameObjects.Get(i);
		if((*pIGameObject)->IsVisabled() && (!(*pIGameObject)->IsDisabled()) && (*pIGameObject)->Hitting(x, y)){
			return true;
		}
	}
	//*pIGameObject = m_lstGameObjects.Iterators(true);
	//while(*pIGameObject){
	//	//所有可视对象及在X，Y点之下
	//	if((*pIGameObject)->IsVisabled() && (*pIGameObject)->Hitting(x, y)){
	//		return true;
	//	}
	//	(*pIGameObject) = m_lstGameObjects.Iterators();
	//}
	return false;
}

//************************************
// <p>Description: 交换深度</p>
// <p>Parameters:  </p>
// <p>    IUnknownEx * pIObject1</p>
// <p>    IUnknownEx * pIObject2</p>
//
// <p>Returns:   void</p>
//************************************
void CGameLayer::SwitchDepth(IUnknownEx* pIObject1, IUnknownEx* pIObject2){
	m_lstGameObjects.Switch((IGameObject*)pIObject1, (IGameObject*)pIObject2);
}

//************************************
// <p>Description: 交换深度</p>
// <p>Parameters:  </p>
// <p>    IUnknownEx * pIObject</p>
// <p>    DWORD dwNewDepth</p>
//
// <p>Returns:   void</p>
//************************************
void CGameLayer::SwitchDepth(IUnknownEx* pIObject, DWORD dwNewDepth){
	IGameObject*		pIGameObject = (IGameObject*)pIObject;

	//位置没有变化，不处理
	if(dwNewDepth == pIGameObject->GetDepth()) return;

	bool			bDirection = dwNewDepth > pIGameObject->GetDepth();
	INT_PTR			nOrignalPos = m_lstGameObjects.GetPosition(pIGameObject);
	IGameObject*	pNextIGameObject = NULL;
	if(bDirection){
		//向后搜索
		for(INT_PTR nPos=nOrignalPos+1;nPos<=GetLength();nPos++){
			pNextIGameObject = m_lstGameObjects.Get(nPos);
			//后一个对象的深度比新的深度要大，则退出
			if(pNextIGameObject->GetDepth()> dwNewDepth) return;

			SwitchDepth(pIObject, (IUnknownEx*)pNextIGameObject->QueryInterface(IID_IUnknownEx, VER_IUnknownEx));

		}
	}
	else{
		//向前搜索
		for(INT_PTR nPos=nOrignalPos-1;nPos>=1;nPos--){
			pNextIGameObject = m_lstGameObjects.Get(nPos);
			//后一个对象的深度比新的深度要小，则退出
			if(pNextIGameObject->GetDepth()< dwNewDepth) return;

			SwitchDepth(pIObject, (IUnknownEx*)pNextIGameObject->QueryInterface(IID_IUnknownEx, VER_IUnknownEx));

		}
	}
}

//************************************
// <p>Description: 释放对象</p>
// <p>Parameters:  </p>
//
// <p>Returns:   bool</p>
//************************************
bool CGameLayer::Release(){
	if (IsValid()){
		IGameObject*		pIGameObject = m_lstGameObjects.Iterators(true);
		while(pIGameObject){
			pIGameObject->Release();
			pIGameObject = m_lstGameObjects.Iterators();
		}
		return true;
	}

	return false;
}

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