door.cpp

Blood 2全套源码

		VEC_ADD(pos, pos, vDir)
		pServerDE->MoveObject(m_hObject, &pos);
	}
}


// --------------------------------------------------------------------------- //
//
//	ROUTINE:	Door::EngineMessageFn()
//
//	PURPOSE:	Handler for engine messages
//
// --------------------------------------------------------------------------- //

DDWORD Door::EngineMessageFn(DDWORD messageID, void *pData, float fData)
{
	switch (messageID)
	{
		case MID_UPDATE:
			Update((DVector*)pData);
			break;

		case MID_PRECREATE:
		{
			// Need to call base class to have the object name read in before
			// we call PostPropRead()

			DDWORD dwRet = B2BaseClass::EngineMessageFn(messageID, pData, fData);

			if (fData == PRECREATE_WORLDFILE)
			{
				ReadProp((ObjectCreateStruct*)pData);
			}

			PostPropRead((ObjectCreateStruct*)pData);

			return dwRet;
		}
		break;

		case MID_INITIALUPDATE:
		{
			InitialUpdate((int)fData);
			CacheFiles();
		}
		break;

		case MID_SAVEOBJECT:
		{
			Save((HMESSAGEWRITE)pData, (DDWORD)fData);
		}
		break;

		case MID_LOADOBJECT:
		{
			Load((HMESSAGEREAD)pData, (DDWORD)fData);
		}
		break;
	}

	return B2BaseClass::EngineMessageFn(messageID, pData, fData);
}


// --------------------------------------------------------------------------- //
//
//	ROUTINE:	Door::TriggerMsg()
//
//	PURPOSE:	Handler for door trigger messages.
//
// --------------------------------------------------------------------------- //

void Door::TriggerMsg(HOBJECT hSender, HSTRING hMsg)
{
	CServerDE* pServerDE = GetServerDE();
	char* pMsg = pServerDE->GetStringData(hMsg);
	if (!pMsg) return;

	// Make sure the door is active...

	pServerDE->SetDeactivationTime(m_hObject, DOOR_DEFAULT_DEACTIVATION_TIME);

	if (_mbsicmp((const unsigned char*)pMsg, (const unsigned char*)g_szTrigger) == 0)
	{
		TriggerHandler();
	}
	else if (_mbsicmp((const unsigned char*)pMsg, (const unsigned char*)g_szTriggerClose) == 0)
	{
		TriggerClose();
	}
	// If it's a lock or unlock, relay it to our trigger object
	else if (m_hTriggerObj && ((_mbsicmp((const unsigned char*)pMsg, (const unsigned char*)g_szLock) == 0) || (_mbsicmp((const unsigned char*)pMsg, (const unsigned char*)g_szUnLock) == 0)))
	{
		HMESSAGEWRITE hMessage = pServerDE->StartMessageToObject(g_pServerDE->HandleToObject(hSender), m_hTriggerObj, MID_TRIGGER);
		pServerDE->WriteToMessageHString(hMessage, hMsg);
		pServerDE->EndMessage(hMessage);
	}
}

	
// --------------------------------------------------------------------------- //
//
//	ROUTINE:	Door::ObjectMessageFn()
//
//	PURPOSE:	Handler for server object messages.
//
// --------------------------------------------------------------------------- //

DDWORD Door::ObjectMessageFn(HOBJECT hSender, DDWORD messageID, HMESSAGEREAD hRead)
{
	CServerDE* pServerDE = GetServerDE();
	switch (messageID)
	{
		case MID_TRIGGER:
		{
			HSTRING hMsg = pServerDE->ReadFromMessageHString(hRead);
			TriggerMsg(hSender, hMsg);
			pServerDE->FreeString(hMsg);
		}
		break;

		case MID_DOORBLOCK:
		{
			m_bDoorBlocked = DTRUE;
		}
		break;
	}
	
	return B2BaseClass::ObjectMessageFn(hSender, messageID, hRead);
}


// --------------------------------------------------------------------------- //
//
//	ROUTINE:	Door::StartSound()
//
//	PURPOSE:	Start the specified sound
//
// --------------------------------------------------------------------------- //

void Door::StartSound(HSTRING hstrSoundName, DBOOL bLoop)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	// Stop the last sound if there is one...

	if (m_sndLastSound)
	{
		pServerDE->KillSound(m_sndLastSound);
		m_sndLastSound = DNULL;
	}

	if (!hstrSoundName) return;

	char *pSoundName = pServerDE->GetStringData(hstrSoundName);
	if (!pSoundName) return;

	PlaySoundInfo playSoundInfo;
	PLAYSOUNDINFO_INIT(playSoundInfo);

	playSoundInfo.m_dwFlags = PLAYSOUND_3D | PLAYSOUND_ATTACHED | PLAYSOUND_REVERB;
	if (bLoop)
	{
		playSoundInfo.m_dwFlags |= PLAYSOUND_LOOP | PLAYSOUND_GETHANDLE;
	}

	_mbsncpy((unsigned char*)playSoundInfo.m_szSoundName, (const unsigned char*)pSoundName, _MAX_PATH );
	playSoundInfo.m_hObject = m_hObject;
	playSoundInfo.m_fOuterRadius = 1500;
	playSoundInfo.m_fInnerRadius = 500;
	playSoundInfo.m_nVolume = 100;
	playSoundInfo.m_nPriority = SOUNDPRIORITY_MISC_MEDIUM;

	pServerDE->PlaySound(&playSoundInfo);

	// Save the handle of the sound...

	if (bLoop)
		m_sndLastSound = playSoundInfo.m_hSound;
}



// --------------------------------------------------------------------------- //
//
//	ROUTINE:	Door::SetPortalState()
//
//	PURPOSE:	Sets the state of the portal, if any
//
// --------------------------------------------------------------------------- //

void Door::SetPortalState(DBOOL bOpen)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	if (m_hstrPortal)
	{
		DDWORD dwPortalFlags = 0;
		DRESULT res;
		if ((res = pServerDE->GetPortalFlags(pServerDE->GetStringData(m_hstrPortal), &dwPortalFlags)) == LT_OK)
		{
			if (bOpen)
				dwPortalFlags |= PORTAL_OPEN;
			else
				dwPortalFlags &= ~PORTAL_OPEN;

			pServerDE->SetPortalFlags(pServerDE->GetStringData(m_hstrPortal), dwPortalFlags);
		}
	}
}



// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Door::GetWaveValue()
//
//	PURPOSE:	Given a speed value and a percentag
//
// ----------------------------------------------------------------------- //

DFLOAT Door::GetWaveValue( DFLOAT fSpeed, DFLOAT fPercentOpen, DDWORD dwWaveType )
{
	if (dwWaveType == DOORWAVE_LINEAR)
		return fSpeed;

	DFLOAT fNewSpeed;
	DFLOAT f10Percent = fSpeed * 0.1f;

	switch ( dwWaveType )
	{
		case DOORWAVE_SINE:
			fNewSpeed = fSpeed * ((DFLOAT)sin(fPercentOpen * PI)) + f10Percent;
			break;

		case DOORWAVE_SLOWOFF:
			fNewSpeed = fSpeed * ((DFLOAT)cos(fPercentOpen * PI/2)) + f10Percent;
			break;

		case DOORWAVE_SLOWON:
			fNewSpeed = fSpeed * ((DFLOAT)sin(fPercentOpen * PI/2)) + f10Percent;
			break;
	}

	return fNewSpeed;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Door::CacheFiles
//
//	PURPOSE:	Cache resources used by the object
//
// ----------------------------------------------------------------------- //

void Door::CacheFiles()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	// {MD 9/23/98}
	if(!(pServerDE->GetServerFlags() & SS_CACHING))
		return;

	char* pFile = DNULL;

	if (m_hstrOpenBusySound)
	{
		pFile = g_pServerDE->GetStringData(m_hstrOpenBusySound);
		if (pFile)
		{
			 g_pServerDE->CacheFile(FT_SOUND ,pFile);
		}
	}

	if (m_hstrOpenStopSound)
	{
		pFile = g_pServerDE->GetStringData(m_hstrOpenStopSound);
		if (pFile)
		{
			 g_pServerDE->CacheFile(FT_SOUND ,pFile);
		}
	}

	if (m_hstrCloseBusySound)
	{
		pFile = g_pServerDE->GetStringData(m_hstrCloseBusySound);
		if (pFile)
		{
			 g_pServerDE->CacheFile(FT_SOUND ,pFile);
		}
	}

	if (m_hstrCloseStopSound)
	{
		pFile = g_pServerDE->GetStringData(m_hstrCloseStopSound);
		if (pFile)
		{
			 g_pServerDE->CacheFile(FT_SOUND ,pFile);
		}
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Door::Save
//
//	PURPOSE:	Save the object
//
// ----------------------------------------------------------------------- //

void Door::Save(HMESSAGEWRITE hWrite, DDWORD dwSaveFlags)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE || !hWrite) return;

	pServerDE->WriteToLoadSaveMessageObject(hWrite, m_hTriggerObj);
	pServerDE->WriteToMessageDWord(hWrite, m_dwTriggerFlags);
	pServerDE->WriteToMessageFloat(hWrite, m_fSpeed);
	pServerDE->WriteToMessageFloat(hWrite, m_fMoveDist);
	pServerDE->WriteToMessageVector(hWrite, &m_vMoveDir);
	pServerDE->WriteToMessageHString(hWrite, m_hstrOpenBusySound);
	pServerDE->WriteToMessageHString(hWrite, m_hstrOpenStopSound);
	pServerDE->WriteToMessageHString(hWrite, m_hstrCloseBusySound);
	pServerDE->WriteToMessageHString(hWrite, m_hstrCloseStopSound);
	pServerDE->WriteToMessageFloat(hWrite, m_fWaitTime);
	pServerDE->WriteToMessageVector(hWrite, &m_vTriggerDims);
	pServerDE->WriteToMessageFloat(hWrite, m_fClosingSpeed);

	pServerDE->WriteToMessageByte(hWrite, (DBYTE)m_bLocked);
	pServerDE->WriteToMessageByte(hWrite, (DBYTE)m_bBoxPhysics);
	pServerDE->WriteToMessageVector(hWrite, &m_vOpenPos);
	pServerDE->WriteToMessageVector(hWrite, &m_vClosedPos);
	pServerDE->WriteToMessageDWord(hWrite, m_dwDoorState);
	pServerDE->WriteToMessageFloat(hWrite, m_fDoorOpenTime);

	pServerDE->WriteToMessageFloat(hWrite, m_fSoundRadius);

	pServerDE->WriteToMessageHString(hWrite, m_hstrPortal);
	pServerDE->WriteToMessageDWord(hWrite, m_dwFlags);
	pServerDE->WriteToMessageDWord(hWrite, m_dwWaveform);

	pServerDE->WriteToMessageByte(hWrite, (DBYTE)m_bStartedMoving);
	pServerDE->WriteToMessageFloat(hWrite, m_fOpenDelay);
	pServerDE->WriteToMessageByte(hWrite, (DBYTE)m_bFireThrough);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Door::Load
//
//	PURPOSE:	Load the object
//
// ----------------------------------------------------------------------- //

void Door::Load(HMESSAGEREAD hRead, DDWORD dwLoadFlags)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE || !hRead) return;

	pServerDE->ReadFromLoadSaveMessageObject(hRead, &m_hTriggerObj);
	m_dwTriggerFlags		= pServerDE->ReadFromMessageDWord(hRead); 
	m_fSpeed				= pServerDE->ReadFromMessageFloat(hRead); 
	m_fMoveDist				= pServerDE->ReadFromMessageFloat(hRead); 
	pServerDE->ReadFromMessageVector(hRead, &m_vMoveDir);
	m_hstrOpenBusySound		= pServerDE->ReadFromMessageHString(hRead); 
	m_hstrOpenStopSound		= pServerDE->ReadFromMessageHString(hRead); 
	m_hstrCloseBusySound	= pServerDE->ReadFromMessageHString(hRead); 
	m_hstrCloseStopSound	= pServerDE->ReadFromMessageHString(hRead); 
	m_fWaitTime				= pServerDE->ReadFromMessageFloat(hRead); 
	pServerDE->ReadFromMessageVector(hRead, &m_vTriggerDims);
	m_fClosingSpeed			= pServerDE->ReadFromMessageFloat(hRead); 

	m_bLocked				= (DBOOL)pServerDE->ReadFromMessageByte(hRead); 
	m_bBoxPhysics			= (DBOOL)pServerDE->ReadFromMessageByte(hRead); 
	pServerDE->ReadFromMessageVector(hRead, &m_vOpenPos);
	pServerDE->ReadFromMessageVector(hRead, &m_vClosedPos);
	m_dwDoorState			= pServerDE->ReadFromMessageDWord(hRead); 
	m_fDoorOpenTime			= pServerDE->ReadFromMessageFloat(hRead); 

	m_fSoundRadius			= pServerDE->ReadFromMessageFloat(hRead); 

	m_hstrPortal			= pServerDE->ReadFromMessageHString(hRead);
	m_dwFlags				= pServerDE->ReadFromMessageDWord(hRead); 
	m_dwWaveform			= pServerDE->ReadFromMessageDWord(hRead); 

	m_bStartedMoving		= (DBOOL)pServerDE->ReadFromMessageByte(hRead);
	m_fOpenDelay			= pServerDE->ReadFromMessageFloat(hRead);
	m_bFireThrough			= (DBOOL)pServerDE->ReadFromMessageByte(hRead); 
}