objectengine.cpp

此为传奇游戏源代码

	AddProcess(pCharObject, wIdent, wParam, lParam1, lParam2, lParam3, pszData);
}

void CCharObject::AddProcess(CCharObject* pCharObject, WORD wIdent, WORD wParam, DWORD lParam1, DWORD lParam2, DWORD lParam3, char *pszData)
{
//	EnterCriticalSection(&m_cs);

	_LPTPROCESSMSG lpProcessMsg = new _TPROCESSMSG;

	if (!m_fIsGhost)
	{
		if (lpProcessMsg)
		{
			lpProcessMsg->wIdent			= wIdent;
			lpProcessMsg->wParam			= wParam;
			lpProcessMsg->lParam1			= lParam1;
			lpProcessMsg->lParam2			= lParam2;
			lpProcessMsg->lParam3			= lParam3;

			lpProcessMsg->dwDeliveryTime	= 0;

			lpProcessMsg->pCharObject		= pCharObject;

			if (pszData)
			{
				int nLen = memlen(pszData);

				lpProcessMsg->pszData = new char[nLen];
				memmove(lpProcessMsg->pszData, pszData, nLen);
			}
			else
				lpProcessMsg->pszData		= NULL;

			m_ProcessQ.PushQ((BYTE *)lpProcessMsg);
		}
	}

//	LeaveCriticalSection(&m_cs);
}

void CCharObject::AddDelayProcess(CCharObject* pCharObject, WORD wIdent, WORD wParam, DWORD lParam1, DWORD lParam2, DWORD lParam3, char *pszData, int nDelay)
{
//	EnterCriticalSection(&m_cs);

	_LPTPROCESSMSG lpProcessMsg = new _TPROCESSMSG;

	if (lpProcessMsg)
	{
		lpProcessMsg->wIdent			= wIdent;
		lpProcessMsg->wParam			= wParam;
		lpProcessMsg->lParam1			= lParam1;
		lpProcessMsg->lParam2			= lParam2;
		lpProcessMsg->lParam3			= lParam3;

		lpProcessMsg->dwDeliveryTime	= GetTickCount() + nDelay;

		lpProcessMsg->pCharObject		= pCharObject;

		if (pszData)
		{
			int nLen = memlen(pszData);

			lpProcessMsg->pszData = new char[nLen];
			memmove(lpProcessMsg->pszData, pszData, nLen);
		}
		else
			lpProcessMsg->pszData		= NULL;

		m_DelayProcessQ.PushQ((BYTE *)lpProcessMsg);
	}

//	LeaveCriticalSection(&m_cs);
}

void CCharObject::AddRefMsg(WORD wIdent, WORD wParam, DWORD lParam1, DWORD lParam2, DWORD lParam3, char *pszData)
{
	CMapCellInfo*	pMapCellInfo	= NULL;
	CCharObject*	pCharObject		= NULL;

	int nStartX = m_nCurrX - _RANGE_X;
	int nEndX	= m_nCurrX + _RANGE_X;
	int nStartY = m_nCurrY - _RANGE_Y;
	int nEndY	= m_nCurrY + _RANGE_Y;

	if (m_fInspector) return;

	if (GetTickCount() - m_dwCacheTick > _CACHE_TICK || m_xCacheObjectList.GetCount() == 0)
	{
		m_xCacheObjectList.Clear();

		for (int x = nStartX; x <= nEndX; x++)
		{
			for (int y = nStartY; y <= nEndY; y++)
			{
				if (pMapCellInfo = m_pMap->GetMapCellInfo(x, y))
				{
					if (pMapCellInfo->m_xpObjectList)
					{
						if (pMapCellInfo->m_xpObjectList->GetCount())
						{
							PLISTNODE pListNode = pMapCellInfo->m_xpObjectList->GetHead();

							while (pListNode)
							{
								_LPTOSOBJECT pOSObject = pMapCellInfo->m_xpObjectList->GetData(pListNode);

								if (pOSObject->btType == OS_MOVINGOBJECT)
								{
									pCharObject = (CCharObject*)pOSObject->pObject;

									if (!pCharObject->m_fIsGhost)
									{
										if (pCharObject->m_wObjectType & _OBJECT_HUMAN)
										{	
											pCharObject->AddProcess(this, wIdent, wParam, lParam1, lParam2, lParam3, pszData);					
											m_xCacheObjectList.AddNewNode(pCharObject);
										}
									}
								}
								
								pListNode = pMapCellInfo->m_xpObjectList->GetNext(pListNode);
							} // while (pListNode)
						} // if (pMapCellInfo->m_pObjectList.GetCount())
					}
				} // if (pMapCellInfo)
			}// for (y)
		} // for (x)

		m_dwCacheTick = GetTickCount();
	}
	else
	{
		PLISTNODE pListNode = m_xCacheObjectList.GetHead();

		while (pListNode)
		{
			CCharObject* pCharObject = m_xCacheObjectList.GetData(pListNode);

			if (!pCharObject->m_fIsGhost)
			{
				if ((pCharObject->m_pMap = m_pMap) && (abs(pCharObject->m_nCurrX - m_nCurrX) <= 11) && 
					(abs(pCharObject->m_nCurrY - m_nCurrY) <= 11))
				{
					if (pCharObject->m_wObjectType & _OBJECT_HUMAN)
						pCharObject->AddProcess(this, wIdent, wParam, lParam1, lParam2, lParam3, pszData);
//                     end else begin
//                      if cret.WantRefMsg and ((msg = RM_STRUCK) or (msg = RM_HEAR) or (msg = RM_DEATH)) then
//                       cret.SendMsg (self, msg, wparam, lparam1, lparam2, lparam3, str);
				}
			}
			
			pListNode = m_xCacheObjectList.GetNext(pListNode);
		} // while (pListNode)
	}
}

void CCharObject::SpaceMove(int nX, int nY, CMirMap* pMirMap)
{
	CVisibleObject* pVisibleObject;

	if (m_pMap->RemoveObject(m_nCurrX, m_nCurrY, OS_MOVINGOBJECT, this))
	{
		PLISTNODE pListNode = m_xVisibleObjectList.GetHead();

		while (pListNode)
		{
			pVisibleObject = m_xVisibleObjectList.GetData(pListNode);

			if (pVisibleObject)
			{
				delete pVisibleObject;
				pVisibleObject = NULL;
			}
			
			pListNode = m_xVisibleObjectList.RemoveNode(pListNode);
		} // while (pListNode)

		m_pMap = pMirMap;

		m_nCurrX = nX;
		m_nCurrY = nY;

		if (m_pMap->AddNewObject(m_nCurrX, m_nCurrY, OS_MOVINGOBJECT, this))
		{
			AddProcess(this, RM_CLEAROBJECTS, 0, 0, 0, 0, NULL);
			AddProcess(this, RM_CHANGEMAP, 0, 0, 0, 0, NULL);

			AddRefMsg(RM_SPACEMOVE_SHOW, m_nDirection, m_nCurrX, m_nCurrY, 0, NULL);
		}
	}
}

void CCharObject::UpdateVisibleObject(CCharObject* pCharObject)
{
	CVisibleObject* pVisibleObject;

	PLISTNODE		pListNode = m_xVisibleObjectList.GetHead();

	while (pListNode)
	{
		pVisibleObject = m_xVisibleObjectList.GetData(pListNode);

		if (pVisibleObject->pObject == pCharObject)
		{
			pVisibleObject->nVisibleFlag = 1;
			return;
		}
		
		pListNode = m_xVisibleObjectList.GetNext(pListNode);
	} // while (pListNode)

	CVisibleObject* pNewVisibleObject = new CVisibleObject;

	pNewVisibleObject->nVisibleFlag	= 2;
	pNewVisibleObject->pObject		= pCharObject;

	m_xVisibleObjectList.AddNewNode(pNewVisibleObject);
}

void CCharObject::UpdateVisibleItem(int nX, int nY, CMapItem* pMapItem)
{
	CVisibleMapItem* pVisibleItem;

	PLISTNODE		pListNode = m_xVisibleItemList.GetHead();

	while (pListNode)
	{
		pVisibleItem = m_xVisibleItemList.GetData(pListNode);

		if (pVisibleItem->pMapItem == pMapItem)
		{
			pVisibleItem->nVisibleFlag = 1;
			return;
		}
		
		pListNode = m_xVisibleItemList.GetNext(pListNode);
	} // while (pListNode)

	CVisibleMapItem* pVisibleNewItem = new CVisibleMapItem;

	pVisibleNewItem->nVisibleFlag	= 2;
	pVisibleNewItem->wX				= (WORD)nX;
	pVisibleNewItem->wY				= (WORD)nY;
	pVisibleNewItem->pMapItem		= pMapItem;

	m_xVisibleItemList.AddNewNode(pVisibleNewItem);
}

void CCharObject::UpdateVisibleEvent(CEvent* pEvent)
{
	CVisibleEvent* pVisibleEvent;

	PLISTNODE		pListNode = m_xVisibleEventList.GetHead();

	while (pListNode)
	{
		pVisibleEvent = m_xVisibleEventList.GetData(pListNode);

		if (pVisibleEvent->pEvent == pEvent)
		{
			pVisibleEvent->nVisibleFlag = 1;
			return;
		}
		
		pListNode = m_xVisibleEventList.GetNext(pListNode);
	} // while (pListNode)

	CVisibleEvent* pVisibleNewEvent = new CVisibleEvent;

	pVisibleNewEvent->nVisibleFlag	= 2;
	pVisibleNewEvent->pEvent		= pEvent;

	m_xVisibleEventList.AddNewNode(pVisibleNewEvent);
}

void CCharObject::SearchViewRange()
{
	int nStartX = m_nCurrX - m_nViewRange;
	int nEndX	= m_nCurrX + m_nViewRange;
	int nStartY = m_nCurrY - m_nViewRange;
	int nEndY	= m_nCurrY + m_nViewRange;

	CMapCellInfo*		pMapCellInfo;
	_LPTOSOBJECT		pOSObject;	
	CCharObject*		pCharObject;
	CEvent*				pEvent;
	PLISTNODE			pListNode;
	CVisibleObject*		pVisibleObject;
	CVisibleMapItem*	pVisibleItem;
	CVisibleEvent*		pVisibleEvent;

	// Clear VisibleObjectList
	if (m_xVisibleObjectList.GetCount())
	{
		pListNode = m_xVisibleObjectList.GetHead();

		while (pListNode)
		{
			if (pVisibleObject = m_xVisibleObjectList.GetData(pListNode))
				pVisibleObject->nVisibleFlag = 0;

			pListNode = m_xVisibleObjectList.GetNext(pListNode);
		}
	}

	// Clear VisibleMapItem
	if (m_xVisibleItemList.GetCount())
	{
		pListNode = m_xVisibleItemList.GetHead();

		while (pListNode)
		{
			if (pVisibleItem = m_xVisibleItemList.GetData(pListNode))
				pVisibleItem->nVisibleFlag = 0;

			pListNode = m_xVisibleItemList.GetNext(pListNode);
		}
	}

	// Clear VisibleEvent
	if (m_xVisibleEventList.GetCount())
	{
		pListNode = m_xVisibleEventList.GetHead();

		while (pListNode)
		{
			if (pVisibleEvent = m_xVisibleEventList.GetData(pListNode))
				pVisibleEvent->nVisibleFlag = 0;

			pListNode = m_xVisibleEventList.GetNext(pListNode);
		}
	}

	// Search VisibleAllObjectList
	for (int x = nStartX; x <= nEndX; x++)
	{
		for (int y = nStartY; y <= nEndY; y++)
		{
			pMapCellInfo = m_pMap->GetMapCellInfo(x, y);

			if (pMapCellInfo)
			{
				if (pMapCellInfo->m_xpObjectList)
				{
					if (pMapCellInfo->m_xpObjectList->GetCount())
					{
						pListNode = pMapCellInfo->m_xpObjectList->GetHead();

						while (pListNode)
						{
							pOSObject = pMapCellInfo->m_xpObjectList->GetData(pListNode);

							if (pOSObject)
							{
								if (pOSObject->btType == OS_MOVINGOBJECT)
								{
									pCharObject = (CCharObject*)pOSObject->pObject;
									
									if (!pCharObject->m_fInspector && !pCharObject->m_fIsGhost && !pCharObject->m_fHideMode)
										UpdateVisibleObject(pCharObject);
								}
								else if (pOSObject->btType == OS_ITEMOBJECT)
								{
									if (GetTickCount() - pOSObject->dwAddTime > 60 * 60 * 1000)
									{
										delete pOSObject;
										pOSObject = NULL;

										pListNode = pMapCellInfo->m_xpObjectList->RemoveNode(pListNode);
										continue;
									}
									else
										UpdateVisibleItem(x, y, (CMapItem*)pOSObject->pObject);
								}
								else if (pOSObject->btType == OS_EVENTOBJECT)
								{
									pEvent = (CEvent*)pOSObject->pObject;

									if (pEvent->m_fVisible)
										UpdateVisibleEvent(pEvent);
								}
							}
							
							pListNode = pMapCellInfo->m_xpObjectList->GetNext(pListNode);
						} // while (pListNode)
					} // if (pMapCellInfo->m_pObjectList.GetCount())
				}
			} // if (pMapCellInfo)
		}// for (y)
	} // for (x)

	if (m_xVisibleObjectList.GetCount())
	{
		pListNode = m_xVisibleObjectList.GetHead();

		while (pListNode)
		{
			if (pVisibleObject = m_xVisibleObjectList.GetData(pListNode))
			{
				if (pVisibleObject->nVisibleFlag == 0)
				{
					if (!pVisibleObject->pObject->m_fHideMode)
						AddProcess(pVisibleObject->pObject, RM_DISAPPEAR, 0, 0, 0, 0, NULL);

					delete pVisibleObject;
					pVisibleObject = NULL;
					
					pListNode = m_xVisibleObjectList.RemoveNode(pListNode);

					continue;
				}
				else
				{
					if (m_wObjectType & _OBJECT_HUMAN)
					{
						if (pVisibleObject->nVisibleFlag == 2)	// 2:New Object
						{
							if (pVisibleObject->pObject != this)
							{
								if (pVisibleObject->pObject->m_fIsDead)
								{
									AddProcess(pVisibleObject->pObject, RM_DEATH, pVisibleObject->pObject->m_nDirection, 
																		pVisibleObject->pObject->m_nCurrX, pVisibleObject->pObject->m_nCurrY, 0, NULL);
								}
								else
									AddProcess(pVisibleObject->pObject, RM_TURN, pVisibleObject->pObject->m_nDirection, 
																		pVisibleObject->pObject->m_nCurrX, pVisibleObject->pObject->m_nCurrY, 
																		0, pVisibleObject->pObject->m_szName);
							}
						}
					}
				} // if (pVisibleObject->nVisibleFlag == 0)
			} // if (pVisibleObject = m_xVisibleObjectList.GetData(pListNode))
			
			pListNode = m_xVisibleObjectList.GetNext(pListNode);
		} // while (pListNode)
	}

	// Update Map Item
	if (m_xVisibleItemList.GetCount())
	{
		pListNode = m_xVisibleItemList.GetHead();

		while (pListNode)
		{
			if (pVisibleItem = m_xVisibleItemList.GetData(pListNode))
			{
				if (pVisibleItem->nVisibleFlag == 0)
				{
					AddProcess(this, RM_ITEMHIDE, 0, (LPARAM)pVisibleItem->pMapItem, pVisibleItem->wX, pVisibleItem->wY, NULL);
					
					delete pVisibleItem;
					pVisibleItem = NULL;
					
					pListNode = m_xVisibleItemList.RemoveNode(pListNode);

					continue;
				}
				else
				{
					if (pVisibleItem->nVisibleFlag == 2)	// 2:New Item
						AddProcess(this, RM_ITEMSHOW, pVisibleItem->pMapItem->wLooks, (LPARAM)pVisibleItem->pMapItem, 
										pVisibleItem->wX, pVisibleItem->wY, pVisibleItem->pMapItem->szName);	
				} // if (pVisibleObject->nVisibleFlag == 0)
			} // if (pVisibleObject = m_xVisibleItemList.GetData(pListNode))
			
			pListNode = m_xVisibleItemList.GetNext(pListNode);
		} // while (pListNode)
	}

	// Update Event Item
	if (m_xVisibleEventList.GetCount())
	{
		pListNode = m_xVisibleEventList.GetHead();

		while (pListNode)
		{
			if (pVisibleEvent = m_xVisibleEventList.GetData(pListNode))
			{
				if (pVisibleEvent->nVisibleFlag == 0)
				{
					AddProcess(this, RM_HIDEEVENT, 0, (LPARAM)pVisibleEvent->pEvent, pVisibleEvent->pEvent->m_nX, pVisibleEvent->pEvent->m_nY);
					
					pListNode = m_xVisibleEventList.RemoveNode(pListNode);

					delete pVisibleEvent;
					pVisibleEvent = NULL;

					continue;
				}
				else if (pVisibleEvent->nVisibleFlag == 2) 
				{
					AddProcess(this, RM_SHOWEVENT, pVisibleEvent->pEvent->m_nEventType, (LPARAM)pVisibleEvent->pEvent, 
									MAKELONG(pVisibleEvent->pEvent->m_nX, pVisibleEvent->pEvent->m_nEventParam), pVisibleEvent->pEvent->m_nY);	
				}
			}
			
			pListNode = m_xVisibleEventList.GetNext(pListNode);
		} // while (pListNode)
	}
}

void CCharObject::Disappear()
{
	if (m_pMap)
	{
		m_pMap->RemoveObject(m_nCurrX, m_nCurrY, OS_MOVINGOBJECT, this);
		AddRefMsg(RM_DISAPPEAR, 0, 0, 0, 0, NULL);
	}
}

void CCharObject::MakeGhost()
{
	m_fIsGhost		= TRUE;
	m_dwGhostTime	= GetTickCount();
   
	Disappear();
}

void CCharObject::TurnTo(int nDir)
{
	AddRefMsg(RM_TURN, nDir, m_nCurrX, m_nCurrY, 0, m_szName);

	m_nDirection = nDir;
}

BOOL CCharObject::TurnXY(int nX, int nY, int nDir)
{
	if (m_nCurrX == nX && m_nCurrY == nY)
	{