rotating.cpp

Blood 2全套源码

// ----------------------------------------------------------------------- //
//
// MODULE  : Rotating.cpp
//
// PURPOSE : Rotating implementation
//
// CREATED : 4/29/98
//
// ----------------------------------------------------------------------- //

#include "Rotating.h"
#include "cpp_server_de.h"
#include "ObjectUtilities.h"
#include "generic_msg_de.h"
#include <mbstring.h>


#define RWM_UPDATE_DELTA	0.001f
#define TRIGGER_MSG_ON		"ON"
#define TRIGGER_MSG_OFF		"OFF"
#define TRIGGER_MSG_TOGGLE	"TOGGLE"

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Rotating::Rotating()
//
//	PURPOSE:	Initialize object
//
// ----------------------------------------------------------------------- //

Rotating::Rotating() : Aggregate()
{
	m_hObject			= DNULL;
	m_hstrSpinUpSound	= DNULL;
	m_hstrBusySound		= DNULL;
	m_hstrSpinDownSound	= DNULL;
	m_fSoundRadius		= 1000.0f;
	m_sndLastSound		= DNULL;

	VEC_INIT(m_vVelocity);
	VEC_INIT(m_vSaveVelocity);
	VEC_INIT(m_vSpinUpTime);
	VEC_INIT(m_vSpinDownTime);
	VEC_INIT(m_vSpinTimeLeft);
	VEC_SET(m_vSign, 1.0f, 1.0f, 1.0f);
	
	m_fLastTime		= 0.0f;
	m_fStartTime	= 0.0f;

	m_eState		= RWM_OFF;

	m_fPitch		= 0.0f;
	m_fYaw			= 0.0f;
	m_fRoll			= 0.0f;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Rotating::~Rotating()
//
//	PURPOSE:	Destroy object
//
// ----------------------------------------------------------------------- //

Rotating::~Rotating()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	if (m_hstrSpinUpSound)
	{
		pServerDE->FreeString(m_hstrSpinUpSound);
	}
	if (m_hstrSpinDownSound)
	{
		pServerDE->FreeString(m_hstrSpinDownSound);
	}
	if (m_hstrBusySound)
	{
		pServerDE->FreeString(m_hstrBusySound);
	}
	if( m_sndLastSound )
		g_pServerDE->KillSound( m_sndLastSound );
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Rotating::EngineMessageFn
//
//	PURPOSE:	Handle engine messages
//
// ----------------------------------------------------------------------- //

DDWORD Rotating::EngineMessageFn(LPBASECLASS pObject, DDWORD messageID, void *pData, DFLOAT fData)
{
	switch(messageID)
	{
		case MID_UPDATE:
		{
			Update();
			break;
		}

		case MID_PRECREATE:
		{
			ObjectCreateStruct* pStruct = (ObjectCreateStruct*)pData;
			
			if (pStruct)
			{
				if (fData == PRECREATE_WORLDFILE)
				{
					ReadProp(pStruct);
				}
			}
			break;
		}

		case MID_INITIALUPDATE:
		{
			if (fData != INITIALUPDATE_SAVEGAME)
				InitialUpdate();
			break;
		}

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

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

		default : break;
	}


	return Aggregate::EngineMessageFn(pObject, messageID, pData, fData);
}


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

DDWORD Rotating::ObjectMessageFn(LPBASECLASS pObject, HOBJECT hSender, DDWORD messageID, HMESSAGEREAD hRead)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return 0;

	switch (messageID)
	{
		case MID_TRIGGER:
		{
			HSTRING hMsg = pServerDE->ReadFromMessageHString(hRead);
			HandleTrigger(hSender, hMsg);
			pServerDE->FreeString(hMsg);
		}
		break;
	}
	
	return Aggregate::ObjectMessageFn(pObject, hSender, messageID, hRead);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Rotating::ReadProp
//
//	PURPOSE:	Set property value
//
// ----------------------------------------------------------------------- //

DBOOL Rotating::ReadProp(ObjectCreateStruct *)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return DFALSE;

	DFLOAT fRealVal;
	pServerDE->GetPropReal("XAxisRevTime", &fRealVal);
	if (fRealVal > 0.0f) m_vVelocity.x = MATH_CIRCLE / fRealVal;

	pServerDE->GetPropReal("YAxisRevTime", &fRealVal);
	if (fRealVal > 0.0f) m_vVelocity.y = MATH_CIRCLE / fRealVal;

	pServerDE->GetPropReal("ZAxisRevTime", &fRealVal);
	if (fRealVal > 0.0f) m_vVelocity.z = MATH_CIRCLE / fRealVal;

	DBOOL bVal = DFALSE;
	pServerDE->GetPropBool("XRotateForward", &bVal);
	m_vSign.x = (bVal == DTRUE) ? 1.0f : -1.0f;

	bVal = DFALSE;
	pServerDE->GetPropBool("YRotateForward", &bVal);
	m_vSign.y = (bVal == DTRUE) ? 1.0f : -1.0f;

	bVal = DFALSE;
	pServerDE->GetPropBool("ZRotateForward", &bVal);
	m_vSign.z = (bVal == DTRUE) ? 1.0f : -1.0f;

	bVal = DFALSE;
	pServerDE->GetPropBool("StartOn", &bVal);
	if (bVal) m_eState = RWM_NORMAL;
	
	pServerDE->GetPropReal("SoundRadius", &m_fSoundRadius);

	pServerDE->GetPropReal("XAxisSpinUpTime", &fRealVal);
	m_vSpinUpTime.x = fRealVal;

	pServerDE->GetPropReal("XAxisSpinDownTime", &fRealVal);
	m_vSpinDownTime.x = fRealVal;

	pServerDE->GetPropReal("YAxisSpinUpTime", &fRealVal);
	m_vSpinUpTime.y = fRealVal;

	pServerDE->GetPropReal("YAxisSpinDownTime", &fRealVal);
	m_vSpinDownTime.y = fRealVal;

	pServerDE->GetPropReal("ZAxisSpinUpTime", &fRealVal);
	m_vSpinUpTime.z = fRealVal;

	pServerDE->GetPropReal("ZAxisSpinDownTime", &fRealVal);
	m_vSpinDownTime.z = fRealVal;

	char buf[MAX_CS_FILENAME_LEN];
	if (pServerDE->GetPropString("SpinUpSound", buf, MAX_CS_FILENAME_LEN) == DE_OK)
	{
		m_hstrSpinUpSound = pServerDE->CreateString(buf);
	}

	if (pServerDE->GetPropString("BusySound", buf, MAX_CS_FILENAME_LEN) == DE_OK)
	{
		m_hstrBusySound = pServerDE->CreateString(buf);
	}

	if (pServerDE->GetPropString("SpinDownSound", buf, MAX_CS_FILENAME_LEN) == DE_OK)
	{
		m_hstrSpinDownSound = pServerDE->CreateString(buf);
	}

	return DTRUE;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Rotating::InitialUpdate()
//
//	PURPOSE:	First update
//
// ----------------------------------------------------------------------- //

void Rotating::InitialUpdate()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	if (m_eState != RWM_OFF)
	{
//		pServerDE->SetNextUpdate(m_hObject, RWM_UPDATE_DELTA);
		SetNormalRotation();
	}

	VEC_COPY(m_vSaveVelocity, m_vVelocity);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Rotating::Init
//
//	PURPOSE:	Initialize object
//
// ----------------------------------------------------------------------- //

DBOOL Rotating::Init(HOBJECT hObject)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!hObject || !pServerDE) return DFALSE;

	m_hObject = hObject;

	return DTRUE;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Rotating::SetNormalRotation()
//
//	PURPOSE:	Set the model to normal rotation state
//
// ----------------------------------------------------------------------- //

void Rotating::SetNormalRotation()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	m_eState = RWM_NORMAL;

	m_fLastTime = pServerDE->GetTime();

	StartSound(m_hstrBusySound, DTRUE);

	pServerDE->SetNextUpdate(m_hObject, RWM_UPDATE_DELTA);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Rotating::SetOff()
//
//	PURPOSE:	Set the model to off state
//
// ----------------------------------------------------------------------- //

void Rotating::SetOff()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	m_eState = RWM_OFF;

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


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Rotating::SetSpinUp()
//
//	PURPOSE:	Set the model to the spin up state
//
// ----------------------------------------------------------------------- //

void Rotating::SetSpinUp()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	m_eState = RWM_SPINUP;

	m_fStartTime = pServerDE->GetTime();

	VEC_COPY(m_vSpinTimeLeft, m_vSpinUpTime);

	StartSound(m_hstrSpinUpSound, DFALSE);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Rotating::SetSpinDown()
//
//	PURPOSE:	Set the model to the spin up state
//
// ----------------------------------------------------------------------- //

void Rotating::SetSpinDown()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	m_eState = RWM_SPINDOWN;

	m_fStartTime = pServerDE->GetTime();