trigger.cpp

Blood 2全套源码

	if (!hObj) return bRetVal;

	// first check for a trigger relay
	if (m_bTriggerRelayActivate && g_pServerDE->IsKindOf(hObjClass, hTriggerObj))
	{
		bRetVal = DTRUE;
	}
	else if (g_pServerDE->IsKindOf(hObjClass, hPlayerObj))
	{
		if (m_bPlayerActivate)
		{
			if (m_bLocked && m_hstrKeyName)
			{
				// See if he has the key we need to unlock.. Trigger should become unlocked.
				HMESSAGEWRITE hMessage = g_pServerDE->StartMessageToObject((LPBASECLASS)this, hObj, MID_KEYQUERY);
				g_pServerDE->WriteToMessageHString(hMessage, m_hstrKeyName);
				g_pServerDE->EndMessage(hMessage);
			}
			if (!m_bLocked)
				bRetVal = DTRUE;
			else
			{
				if (m_hstrLockedSound && IsPlayer(hObj))
				{
					if (GetGameType() == GAMETYPE_ACTION && g_pPlayerObj)
					{
						HSTRING hstr = g_pServerDE->FormatString(IDS_GENERAL_LOCKED);
						g_pPlayerObj->SendConsoleMessage(g_pServerDE->GetStringData(hstr));
						g_pServerDE->FreeString(hstr);
//						g_pPlayerObj->SendConsoleMessage("Locked!");
					}
					else
					{
						char *pSound = g_pServerDE->GetStringData(m_hstrLockedSound);
						PlaySoundFromObject(hObj, pSound, 200.0f, SOUNDPRIORITY_MISC_HIGH);
					}
				}
			}
		}
	}
	else if (g_pServerDE->IsKindOf(hObjClass, hAIObj))
	{
		if (m_bAIActivate)
			bRetVal = DTRUE;
	}
	else if (m_bObjectActivate)
	{
		bRetVal = DTRUE;
	}

	// If object is triggerable, see if only ActivationObjectName can trigger it.
	if (bRetVal && m_bNamedObjectActivate && m_hstrActivationObjectName)
	{
		char *pName = g_pServerDE->GetObjectName(hObj);

		if (!pName || _mbsicmp((const unsigned char*)pName, (const unsigned char*)g_pServerDE->GetStringData(m_hstrActivationObjectName)) != 0)
			bRetVal = DFALSE;
	}

	return bRetVal;
}


void Trigger::Setup(DBOOL bActive, char *pszTarget, char *pszMessage, DBOOL bTouchActivate,
					DBOOL bPlayerActivate, DBOOL bAIActivate, DBOOL bObjectActivate, 
					DBOOL bTriggerRelayActivate, DBOOL bNamedObjectActivate, 
					HSTRING hstrActivationObjectName, DBOOL bLocked,
					HSTRING hstrLockedMsg, HSTRING hstrLockedSound, HSTRING hstrUnlockedMsg, 
					HSTRING hstrUnlockedSound, HSTRING hstrKeyName)
{
	if (!g_pServerDE) return;

	SetActive(bActive);
	SetTargetName(0, pszTarget);
	SetMessageName(0, pszMessage);

	m_bTouchActivate		= bTouchActivate;
	m_bPlayerActivate		= bPlayerActivate;
	m_bAIActivate			= bAIActivate;
	m_bObjectActivate		= bObjectActivate;
	m_bTriggerRelayActivate = bTriggerRelayActivate;
	m_bNamedObjectActivate	= bNamedObjectActivate;
	m_bLocked				= bLocked;

	if (hstrActivationObjectName)
	{
		if (m_hstrActivationObjectName)
		{
			g_pServerDE->FreeString(m_hstrActivationObjectName);
		}
		m_hstrActivationObjectName = g_pServerDE->CopyString(hstrActivationObjectName);
	}

	if (hstrLockedMsg)
	{
		if (m_hstrLockedMsg)
		{
			g_pServerDE->FreeString(m_hstrLockedMsg);
		}
		m_hstrLockedMsg = g_pServerDE->CopyString(hstrLockedMsg);
	}

	if (hstrLockedSound)
	{
		if (m_hstrLockedSound)
		{
			g_pServerDE->FreeString(m_hstrLockedSound);
		}
		m_hstrLockedSound = g_pServerDE->CopyString(hstrLockedSound);
	}

	if (hstrUnlockedMsg)
	{
		if (m_hstrUnlockedMsg)
		{
			g_pServerDE->FreeString(m_hstrUnlockedMsg);
		}
		m_hstrUnlockedMsg = g_pServerDE->CopyString(hstrUnlockedMsg);
	}

	if (hstrUnlockedSound)
	{
		if (m_hstrUnlockedSound)
		{
			g_pServerDE->FreeString(m_hstrUnlockedSound);
		}
		m_hstrUnlockedSound = g_pServerDE->CopyString(hstrUnlockedSound);
	}

	if (hstrKeyName)
	{
		if (m_hstrKeyName)
		{
			g_pServerDE->FreeString(m_hstrKeyName);
		}
		m_hstrKeyName = g_pServerDE->CopyString(hstrKeyName);
	}

}


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

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

	DFLOAT fTime = pServerDE->GetTime();

	pServerDE->WriteToMessageByte(hWrite, m_bActive);
	pServerDE->WriteToMessageVector(hWrite, &m_vDims);
	pServerDE->WriteToMessageFloat(hWrite, m_fTriggerResetTime);

	pServerDE->WriteToMessageHString(hWrite, m_hstrActivationSound);
	pServerDE->WriteToMessageFloat(hWrite, m_fSoundRadius);

	for (int i=0; i < MAX_TRIGGER_MESSAGES; i++)
	{
		pServerDE->WriteToMessageHString(hWrite, m_hstrTargetName[i]);
		pServerDE->WriteToMessageHString(hWrite, m_hstrMessageName[i]);
		pServerDE->WriteToMessageFloat(hWrite, m_fTriggerMessageDelay[i]);
		pServerDE->WriteToMessageByte(hWrite, m_bDelay[i]);
	}
	pServerDE->WriteToMessageFloat(hWrite, m_fMaxTriggerMessageDelay);
	pServerDE->WriteToMessageFloat(hWrite, m_fDelayStartTime - fTime);

	pServerDE->WriteToMessageByte(hWrite, m_bTouchActivate);
	pServerDE->WriteToMessageByte(hWrite, m_bPlayerActivate);
	pServerDE->WriteToMessageByte(hWrite, m_bAIActivate);
	pServerDE->WriteToMessageByte(hWrite, m_bObjectActivate);
	pServerDE->WriteToMessageByte(hWrite, m_bTriggerRelayActivate);
	pServerDE->WriteToMessageByte(hWrite, m_bNamedObjectActivate);
	pServerDE->WriteToMessageByte(hWrite, m_bLocked);

	pServerDE->WriteToMessageDWord(hWrite, m_nActivationCount);
	pServerDE->WriteToMessageDWord(hWrite, m_nCurrentActivation);

	pServerDE->WriteToMessageHString(hWrite, m_hstrLockedMsg);
	pServerDE->WriteToMessageHString(hWrite, m_hstrLockedSound);
	pServerDE->WriteToMessageHString(hWrite, m_hstrUnlockedMsg);
	pServerDE->WriteToMessageHString(hWrite, m_hstrUnlockedSound);
	pServerDE->WriteToMessageHString(hWrite, m_hstrKeyName);

	pServerDE->WriteToMessageHString(hWrite, m_hstrActivationObjectName);
}


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

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

	DFLOAT fTime = pServerDE->GetTime();

	m_bActive				= pServerDE->ReadFromMessageByte(hRead);
	pServerDE->ReadFromMessageVector(hRead, &m_vDims);
	m_fTriggerResetTime		= pServerDE->ReadFromMessageFloat(hRead);

	m_hstrActivationSound	= pServerDE->ReadFromMessageHString(hRead);
	m_fSoundRadius			= pServerDE->ReadFromMessageFloat(hRead);

	for (int i=0; i < MAX_TRIGGER_MESSAGES; i++)
	{
		m_hstrTargetName[i]		= pServerDE->ReadFromMessageHString(hRead);
		m_hstrMessageName[i]	= pServerDE->ReadFromMessageHString(hRead);
		m_fTriggerMessageDelay[i]	= pServerDE->ReadFromMessageFloat(hRead);
		m_bDelay[i]			= pServerDE->ReadFromMessageByte(hRead);
	}
	m_fMaxTriggerMessageDelay	= pServerDE->ReadFromMessageFloat(hRead);
	m_fDelayStartTime		= pServerDE->ReadFromMessageFloat(hRead) + fTime;

	m_bTouchActivate		= pServerDE->ReadFromMessageByte(hRead);
	m_bPlayerActivate		= pServerDE->ReadFromMessageByte(hRead);
	m_bAIActivate			= pServerDE->ReadFromMessageByte(hRead);
	m_bObjectActivate		= pServerDE->ReadFromMessageByte(hRead);
	m_bTriggerRelayActivate = pServerDE->ReadFromMessageByte(hRead);
	m_bNamedObjectActivate	= pServerDE->ReadFromMessageByte(hRead);
	m_bLocked				= pServerDE->ReadFromMessageByte(hRead);

	m_nActivationCount		= pServerDE->ReadFromMessageDWord(hRead);
	m_nCurrentActivation	= pServerDE->ReadFromMessageDWord(hRead);

	m_hstrLockedMsg			= pServerDE->ReadFromMessageHString(hRead);
	m_hstrLockedSound		= pServerDE->ReadFromMessageHString(hRead);
	m_hstrUnlockedMsg		= pServerDE->ReadFromMessageHString(hRead);
	m_hstrUnlockedSound		= pServerDE->ReadFromMessageHString(hRead);
	m_hstrKeyName			= pServerDE->ReadFromMessageHString(hRead);

	m_hstrActivationObjectName	= pServerDE->ReadFromMessageHString(hRead);
}



BEGIN_CLASS(BigTrigger)
END_CLASS_DEFAULT(BigTrigger, Trigger, NULL, NULL)



BEGIN_CLASS(ToggleTrigger)
	ADD_STRINGPROP(OffMessageName1, "")
	ADD_STRINGPROP(OffMessageName2, "")
	ADD_STRINGPROP(OffMessageName3, "")
	ADD_STRINGPROP(OffMessageName4, "")
	ADD_STRINGPROP(OffMessageName5, "")
	ADD_STRINGPROP(OffMessageName6, "")
	ADD_STRINGPROP(OffMessageName7, "")
	ADD_STRINGPROP(OffMessageName8, "")
	ADD_STRINGPROP(OffMessageName9, "")
	ADD_STRINGPROP(OffMessageName10, "")
	ADD_BOOLPROP(StartOn, DFALSE)
END_CLASS_DEFAULT(ToggleTrigger, Trigger, NULL, NULL)


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

ToggleTrigger::ToggleTrigger()
{
	for (int i=0;i < MAX_TRIGGER_MESSAGES; i++)
	{
		m_hstrOffMessageName[i]	= DNULL;
	}

	m_bOn = DFALSE;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	ToggleTrigger::~ToggleTrigger()
//
//	PURPOSE:	Deallocate object
//
// ----------------------------------------------------------------------- //

ToggleTrigger::~ToggleTrigger()
{
	if (!g_pServerDE) return;

	for (int i=0;i < MAX_TRIGGER_MESSAGES; i++)
	{
		if (m_hstrOffMessageName[i])
		{
			g_pServerDE->FreeString(m_hstrOffMessageName[i]);
		}
	}
}



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

DBOOL ToggleTrigger::ReadProp(ObjectCreateStruct *pStruct)
{
	if (!g_pServerDE) return DFALSE;

	char buf[MAX_CS_FILENAME_LEN];

	for (int i=0; i < MAX_TRIGGER_MESSAGES; i++)
	{
		char key[40];

		sprintf(key, "OffMessageName%d", i+1);
		buf[0] = '\0';
		g_pServerDE->GetPropString(key, buf, MAX_CS_FILENAME_LEN);
		if (buf[0]) m_hstrOffMessageName[i] = g_pServerDE->CreateString(buf);
	}

	g_pServerDE->GetPropBool("StartOn", &m_bOn);

	return DTRUE;
}


// ------------------------------------------------------------ //
//
//	ROUTINE:	ToggleTrigger::EngineMessageFn
//
//	PURPOSE:	Handle engine messages
//
// ----------------------------------------------------------------------- //
DDWORD ToggleTrigger::EngineMessageFn(DDWORD messageID, void *pData, float fData)
{
	switch(messageID)
	{
		case MID_PRECREATE:
		{
			if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
			{
				ReadProp((ObjectCreateStruct*)pData);
			}
			break;
		}

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

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

		default : break;
	}

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


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	ToggleTrigger::SendMessages
//
//	PURPOSE:	Sends the trigger messages
//
// ----------------------------------------------------------------------- //
void ToggleTrigger::SendMessages()
{
	g_pServerDE->SetNextUpdate(m_hObject, m_fTriggerResetTime);

	for (int i=0; i < MAX_TRIGGER_MESSAGES; i++)
	{
		HSTRING hstrMessage = m_bOn ? m_hstrOffMessageName[i] : m_hstrMessageName[i];

		if (m_hstrTargetName[i] && hstrMessage)
		{
			SendTriggerMsgToObjects(this, m_hstrTargetName[i], hstrMessage);
		}

	}
	m_bOn = !m_bOn;
}


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

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

	for (int i=0; i < MAX_TRIGGER_MESSAGES; i++)
	{
		pServerDE->WriteToMessageHString(hWrite, m_hstrOffMessageName[i]);
	}

	pServerDE->WriteToMessageByte(hWrite, m_bOn);
}


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

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

	for (int i=0; i < MAX_TRIGGER_MESSAGES; i++)
	{
		m_hstrOffMessageName[i]	= pServerDE->ReadFromMessageHString(hRead);
	}

	m_bOn = pServerDE->ReadFromMessageByte(hRead);
}