C++ CServerDE::StartMessageToObject方法代码示例

void UltraRestore::ObjectTouch (HOBJECT hObject)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;
	
	// send it very large values for heal and repair - the normal heal and repair functions
	// will cap the values at the maximums...

	HMESSAGEWRITE hMessage = pServerDE->StartMessageToObject(this, hObject, MID_HEAL);
	pServerDE->WriteToMessageFloat(hMessage, 20000.0f);
	pServerDE->EndMessage(hMessage);
	
	hMessage = pServerDE->StartMessageToObject(this, hObject, MID_REPAIR);
	pServerDE->WriteToMessageFloat(hMessage, 20000.0f);
	pServerDE->EndMessage(hMessage);

	UltraPowerupItem::ObjectTouch (hObject);
}

void SpellPickup::ObjectTouch(HOBJECT hObject)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	HMESSAGEWRITE hMessage = pServerDE->StartMessageToObject(this, hObject, MID_ADDAMMO);
	pServerDE->WriteToMessageByte(hMessage, (DBYTE)m_nSpellType);
	pServerDE->EndMessage(hMessage);
}

void PowerupPickup::ObjectTouch(HOBJECT hObject)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	HMESSAGEWRITE hMessage = pServerDE->StartMessageToObject(this, hObject, MID_ADDPOWERUP);
	pServerDE->WriteToMessageByte(hMessage, (DBYTE)m_nType);
	pServerDE->WriteToMessageFloat(hMessage, m_fValue * m_fValueMult);
	pServerDE->EndMessage(hMessage);
}

void WeaponPickup::ObjectTouch(HOBJECT hObject)
{
	HMESSAGEWRITE hMessage;
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	hMessage = pServerDE->StartMessageToObject(this, hObject, MID_ADDWEAPON);
	pServerDE->WriteToMessageByte(hMessage, m_nType);
	pServerDE->WriteToMessageFloat(hMessage, m_fValue * m_fValueMult );
	pServerDE->EndMessage(hMessage);

}

void KeyPickup::ObjectTouch(HOBJECT hObject)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	HMESSAGEWRITE hMessage = pServerDE->StartMessageToObject(this, hObject, MID_KEYPICKUP);
	pServerDE->WriteToMessageHString(hMessage, m_hstrObjectName);
	pServerDE->WriteToMessageHString(hMessage, m_hstrDisplayName);
	pServerDE->WriteToMessageHString(hMessage, m_hstrIconFile);
	pServerDE->WriteToMessageHString(hMessage, m_hstrIconFileH);
	pServerDE->WriteToMessageByte(hMessage, m_byUseCount);
	pServerDE->EndMessage(hMessage);
}

void Trigger::DoTrigger(HOBJECT hObj, DBOOL bTouchNotify)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	m_bTouchNotifyActivation = bTouchNotify;
	m_hTouchObject = hObj;

	// Make sure we don't create links with ourself...

	if (m_hObject != m_hTouchObject)
	{
		pServerDE->CreateInterObjectLink(m_hObject, m_hTouchObject);
	}

	if (m_bActive)
	{
		// if we're locked, send a message to the object that triggered us, giving
		// that object a chance to unlock us (only if there is a way to unlock us)

		if (m_bLocked)
		{
			if (m_hstrUnlockKey)
			{
				HMESSAGEWRITE hWrite = pServerDE->StartMessageToObject (this, hObj, MID_INVENTORYITEMQUERY);
				pServerDE->WriteToMessageByte (hWrite, IT_KEY);
				pServerDE->WriteToMessageByte (hWrite, 0);
				pServerDE->WriteToMessageHString (hWrite, m_hstrUnlockKey);
				pServerDE->EndMessage (hWrite);
			}
			return;
		}
		
		// activate the trigger

		RequestActivate();
	}
}

void WeaponPowerup::ObjectTouch(HOBJECT hObject)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE || !hObject) return;

	// If we hit non-character objects, just ignore them...

	HCLASS hCharClass = pServerDE->GetClass("CBaseCharacter");
	HCLASS hObjClass  = pServerDE->GetObjectClass(hObject);

	if (pServerDE->IsKindOf(hObjClass, hCharClass))
	{
		CBaseCharacter* pCharObj = (CBaseCharacter*)pServerDE->HandleToObject(hObject);

		if (pCharObj && !pCharObj->IsDead() && pCharObj->CanCarryWeapon(m_iWeaponType))
		{
			HMESSAGEWRITE hMessage = pServerDE->StartMessageToObject(this, hObject, MID_ADDWEAPON);
			pServerDE->WriteToMessageByte( hMessage, m_iWeaponType );
			pServerDE->WriteToMessageFloat( hMessage, ( float )m_dwAmmo );
			pServerDE->EndMessage(hMessage);
		}
	}
}

void VolumeBrush::UpdatePhysics(ContainerPhysics* pCPStruct)
{
    CServerDE* pServerDE = GetServerDE();
    if (m_bHidden || !pServerDE || !pCPStruct || !pCPStruct->m_hObject) return;

    DFLOAT fUpdateDelta = pServerDE->GetFrameTime();

    // Check to see if this object is the player object...

    if (!pServerDE->IsKindOf(pServerDE->GetObjectClass(pCPStruct->m_hObject), m_hPlayerClass))
    {
        // Check to see if this object is a character object...

        DBOOL bCharacter = DFALSE;
        HCLASS hBaseCharClass = pServerDE->GetClass("CBaseCharacter");

        if (pServerDE->IsKindOf(pServerDE->GetObjectClass(pCPStruct->m_hObject), hBaseCharClass))
        {
            bCharacter = DTRUE;

            if (m_bLocked)
            {
                // See if they have the key we need to unlock
                HMESSAGEWRITE hMessage = pServerDE->StartMessageToObject((LPBASECLASS)this, pCPStruct->m_hObject, MID_KEYQUERY);
                pServerDE->WriteToMessageHString(hMessage, m_hstrKeyName);
                pServerDE->EndMessage(hMessage);
            }
        }


        // Update velocity...

        // Dampen velocity and acceleration based on the viscosity of the container...

        if (m_fViscosity > 0.0f)
        {
            VEC_MULSCALAR(pCPStruct->m_Velocity, pCPStruct->m_Velocity, m_fViscosity);
            VEC_MULSCALAR(pCPStruct->m_Acceleration, pCPStruct->m_Acceleration, m_fViscosity);
        }


        // Do special liquid / zero gravity handling...

        if (IsLiquid(m_eContainerCode))
        {
            UpdateLiquidPhysics(pCPStruct, bCharacter);
        }


        // Add any current...

        // Make current relative to update delta (actually change the REAL velocity)...

        DVector vCurrent;
        VEC_MULSCALAR(vCurrent, m_vCurrent, fUpdateDelta);

        VEC_ADD(pCPStruct->m_Velocity, pCPStruct->m_Velocity, vCurrent);
    }

    // Update damage...

    // Make damage relative to update delta...

    if (m_fDamage)
    {
        DFLOAT fTime = pServerDE->GetTime();
        DFLOAT fDamageDeltaTime = fTime - m_fLastDamageTime;

        if (fDamageDeltaTime >= DAMAGE_UPDATE_DELTA || fTime == m_fLastDamageTime)
        {
            m_fLastDamageTime = fTime;

            DVector vDir;
            VEC_INIT(vDir);

            DamageObject(m_hObject, this, pCPStruct->m_hObject, m_fDamage * DAMAGE_UPDATE_DELTA, vDir, vDir, m_nDamageType);
        }
    }

}