lightfx.cpp

Blood 2全套源码

// ----------------------------------------------------------------------- //
//
// MODULE  : LightFX.cpp
//
// PURPOSE : Glowing Light
//
// CREATED : 02/04/98
//
// ----------------------------------------------------------------------- //

#include <stdio.h>
#include "cpp_server_de.h"
#include "generic_msg_de.h"
#include "LightFX.h"
#include <mbstring.h>
#include "SoundTypes.h"

#ifdef RIOT_BUILD
#include "RiotObjectUtilities.h"
#else
#include "ObjectUtilities.h"
#endif

// Defines....

#define LFX_INTENSITY_INIT		0
#define LFX_INTENSITY_MIN		1
#define LFX_INTENSITY_RAMP_UP	2
#define LFX_INTENSITY_MAX		3
#define LFX_INTENSITY_RAMP_DOWN	4

#define LFX_RADIUS_INIT			0
#define LFX_RADIUS_MIN			1
#define LFX_RADIUS_RAMP_UP		2
#define LFX_RADIUS_MAX			3
#define LFX_RADIUS_RAMP_DOWN	4

#define DOWNSOUND               0
#define UPSOUND                 1

#define UPDATE_DELTA			0.1f

BEGIN_CLASS(LightFX)
 		ADD_DESTRUCTABLE_AGGREGATE()
		ADD_REALPROP(HitPoints, 1.0f)
//		ADD_LONGINTPROP(Flags, 1)           
        ADD_BOOLPROP(LightSwitch, DTRUE)                
        ADD_REALPROP(LifeTime, 0.0f)          
        ADD_LONGINTPROP(NumColorCycles, 0.0f)           
        ADD_COLORPROP(Color1, 255.0f, 255.0f, 255.0f)   
        ADD_REALPROP(Color1Time, 0.0f)                  
        ADD_COLORPROP(Color2, 255.0f, 255.0f, 255.0f)   
        ADD_REALPROP(Color2Time, 0.0f)                  
        ADD_COLORPROP(Color3, 255.0f, 255.0f, 255.0f)   
        ADD_REALPROP(Color3Time, 0.0f)                  
        ADD_LONGINTPROP(NumIntensityCycles, 0.0f)       
        ADD_REALPROP(IntensityMin		, 0.5f)         
        ADD_REALPROP(IntensityMax		, 1.0f)         
        ADD_REALPROP(IntensityMinTime	, 0.0f)         
        ADD_REALPROP(IntensityMaxTime	, 0.0f)         
        ADD_REALPROP(IntensityRampUpTime, 0.0f)         
        ADD_REALPROP(IntensityRampDownTime, 0.0f)       
        ADD_LONGINTPROP(NumRadiusCycles, 0.0f)          
        ADD_REALPROP_FLAG(RadiusMin		, 500.0f, PF_RADIUS)           
        ADD_REALPROP_FLAG(RadiusMax		, 0.0f, PF_RADIUS)             
        ADD_REALPROP(RadiusMinTime	, 0.0f)             
        ADD_REALPROP(RadiusMaxTime	, 0.0f)             
        ADD_REALPROP(RadiusRampUpTime, 0.0f)            
        ADD_REALPROP(RadiusRampDownTime, 0.0f)  
        ADD_STRINGPROP(RampUpSound,   "")    
        ADD_STRINGPROP(RampDownSound, "")  
#ifdef RIOT_BUILD
END_CLASS_DEFAULT_FLAGS(LightFX, BaseClass, NULL, NULL, CF_ALWAYSLOAD)
#else
END_CLASS_DEFAULT_FLAGS(LightFX, BaseClass, NULL, NULL, CF_ALWAYSLOAD | CF_HIDDEN)
#endif

void BPrint(char*);

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	
//
//	PURPOSE:	Constructor
//
// ----------------------------------------------------------------------- //

LightFX::LightFX() : BaseClass(OT_LIGHT)
{
	AddAggregate(&m_damage);

	m_bOn  				        = DTRUE;

	m_nNumColorCycles           = 0;		    // Number of times to cycle through
	
	VEC_INIT(m_vCurrentColor);
	VEC_INIT(m_vColor1);
	VEC_INIT(m_vColor2);
	VEC_INIT(m_vColor3);

    m_fRedValue = 1.0f;
    m_fGreenValue = 1.0f;
    m_fBlueValue = 1.0f;
    
	m_nNumIntensityCycles       = 0;	    // Number of times to cycle through
	m_fIntensityMin			    = 0.5f;
	m_fIntensityMax			    = 1.0f;
	m_fIntensityMinTime		    = 0.0f;
	m_fIntensityMaxTime		    = 0.0f;
	m_fIntensityRampUpTime		= 0.0f;
	m_fIntensityRampDownTime	= 0.0f;

	m_nNumRadiusCycles          = 0;		// Number of times to cycle through
    
	m_fRadiusMin			    = 500.0f;   // default Radius
    
	m_fRadiusMax			    = 0.0f;
	m_fRadiusMinTime		    = 0.0f;
	m_fRadiusMaxTime		    = 0.0f;
	m_fRadiusRampUpTime	        = 0.0f;
	m_fRadiusRampDownTime	    = 0.0f;

	m_fLifeTime			        = -1.0f;

	m_vColor1.x = m_vColor1.y = m_vColor1.z = 255.0f;
	m_vColor2.x = m_vColor2.y = m_vColor2.z = 255.0f;
	m_vColor3.x = m_vColor3.y = m_vColor3.z = 255.0f;

    m_fCurrentRadius         = 0.0f;
    
    m_fIntensityTime         = 0.0f;
    m_fRadiusTime            = 0.0f;
    m_fColorTime             = 0.0f;
    
    m_nCurIntensityState     = 0;
    m_nCurRadiusState        = 0;
    m_nCurColorUsed          = 0;
    
    m_fStartTime             = 0.0f;

	m_bDynamic				 = DTRUE;

	m_hstrRampUpSound		 = DNULL;
	m_hstrRampDownSound		 = DNULL;

	m_fHitPts				 = 1.0f;
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::~LightFX()	
//
//	PURPOSE:	Destructor
//
// ----------------------------------------------------------------------- //

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

	if (m_hstrRampUpSound)
	{
		pServerDE->FreeString(m_hstrRampUpSound);
	}

	if (m_hstrRampDownSound)
	{
		pServerDE->FreeString(m_hstrRampDownSound);
	}
}


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

DDWORD LightFX::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
	switch(messageID)
	{
		case MID_PRECREATE:
		{
			DDWORD dwRet = BaseClass::EngineMessageFn(messageID, pData, fData);

			if (fData == 1.0f || fData == 2.0f)
			{
				m_bDynamic = DFALSE;
				ReadProp((ObjectCreateStruct*)pData);
			}

			PostPropRead((ObjectCreateStruct*)pData);

			return dwRet;
		}
		break;
    
		case MID_INITIALUPDATE:
		{
			InitialUpdate((DVector *)pData);
			break;
		}

		case MID_UPDATE:
		{
    		if (!Update()) 
            {
		    	CServerDE* pServerDE = BaseClass::GetServerDE();
			    if (pServerDE) pServerDE->RemoveObject(m_hObject);
            }
		}
		break;

		default : break;
	}

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



// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::ObjectMessageFn
//
//	PURPOSE:	Handle object-to-object messages
//
// ----------------------------------------------------------------------- //
DDWORD LightFX::ObjectMessageFn(HOBJECT hSender, DDWORD messageID, HMESSAGEREAD hRead)
{
	switch(messageID)
	{
 		case MID_TRIGGER:
		{
			HandleTrigger(hSender, hRead);
			break;
		}
    
		case MID_DAMAGE:
		{
			DDWORD dwRet = BaseClass::ObjectMessageFn (hSender, messageID, hRead);
			if (m_damage.IsDead())
			{
				g_pServerDE->RemoveObject(m_hObject);
			}
			return dwRet;
			break;
		}
		default : break;
	}

	return BaseClass::ObjectMessageFn (hSender, messageID, hRead);
}





// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::HandleTrigger()
//
//	PURPOSE:	Called when triggered.
//
// ----------------------------------------------------------------------- //
void LightFX::HandleTrigger( HOBJECT hSender, HMESSAGEREAD hRead )
{
	HSTRING hMsg = g_pServerDE->ReadFromMessageHString(hRead);
	char *pszMessage = g_pServerDE->GetStringData( hMsg );

    if ( _mbsncmp((const unsigned char*)pszMessage, (const unsigned char*)"SWITCH", 6) == 0)
    {
        ToggleLight();
    } 
    else if ( _mbsncmp((const unsigned char*)pszMessage, (const unsigned char*)"ON", 2) == 0)
    {
        TurnOn();
    }            
    else if ( _mbsncmp((const unsigned char*)pszMessage, (const unsigned char*)"OFF", 3) == 0)
    {
	    TurnOff();
    }        
    
	g_pServerDE->FreeString( hMsg );
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::TurnOn
//
//	PURPOSE:	Turn light on
//
// ----------------------------------------------------------------------- //

void LightFX::TurnOn() 
{ 
	m_bOn = DTRUE;
	m_fRadius = m_fCurrentRadius; 

	g_pServerDE->SetNextUpdate(m_hObject, 0.001f);

	DDWORD dwFlag = g_pServerDE->GetObjectFlags(m_hObject); 
	g_pServerDE->SetObjectFlags(m_hObject, dwFlag | FLAG_VISIBLE);
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::TurnOff
//
//	PURPOSE:	Turn light off
//
// ----------------------------------------------------------------------- //

void LightFX::TurnOff()          
{ 
	m_bOn = DFALSE; 

	g_pServerDE->SetNextUpdate(m_hObject, 0.0f);

	DDWORD dwFlag = g_pServerDE->GetObjectFlags(m_hObject); 
	g_pServerDE->SetObjectFlags(m_hObject, dwFlag &= ~FLAG_VISIBLE);
 
	// Its NOT turned on, so reset the start time
    // So if there is a duration, then it will start timing when the 
	// switch is turned on
    
	m_fStartTime = g_pServerDE->GetTime();
        
	m_fRadius = 0.0f;  // Effectively turn light off
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::ReadProp
//
//	PURPOSE:	Set property value
//
// ----------------------------------------------------------------------- //
DBOOL LightFX::ReadProp(ObjectCreateStruct *)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return DFALSE;

	GenericProp genProp;

	if (pServerDE->GetPropGeneric("HitPoints", &genProp) == DE_OK)
		m_fHitPts = genProp.m_Float;

	if (pServerDE->GetPropGeneric("LightSwitch", &genProp) == DE_OK)
		m_bOn = genProp.m_Bool;

	if (pServerDE->GetPropGeneric("LifeTime", &genProp) == DE_OK)
		m_fLifeTime = genProp.m_Float;

    if (m_fLifeTime < 0.0f) m_fLifeTime = 0.0f;

	if (pServerDE->GetPropGeneric("NumColorCycles", &genProp) == DE_OK)
		m_nNumColorCycles = genProp.m_Long;

	if (pServerDE->GetPropGeneric("Color1", &genProp) == DE_OK)
		VEC_COPY(m_vColor1, genProp.m_Color);

	if (pServerDE->GetPropGeneric("Color2", &genProp) == DE_OK)
		VEC_COPY(m_vColor2, genProp.m_Color);

	if (pServerDE->GetPropGeneric("Color3", &genProp) == DE_OK)
		VEC_COPY(m_vColor3, genProp.m_Color);

	if (pServerDE->GetPropGeneric("Color1Time", &genProp) == DE_OK)
		m_fColor1Time = genProp.m_Float;

	if (pServerDE->GetPropGeneric("Color2Time", &genProp) == DE_OK)
		m_fColor2Time = genProp.m_Float;

	if (pServerDE->GetPropGeneric("Color3Time", &genProp) == DE_OK)
		m_fColor3Time = genProp.m_Float;

	if (pServerDE->GetPropGeneric("NumIntensityCycles", &genProp) == DE_OK)
		m_nNumIntensityCycles = genProp.m_Long;

	if (pServerDE->GetPropGeneric("IntensityMin", &genProp) == DE_OK)
		m_fIntensityMin = genProp.m_Float;

    if (m_fIntensityMin < 0.0f) m_fIntensityMin = 0.0f;

	if (pServerDE->GetPropGeneric("IntensityMax", &genProp) == DE_OK)
		m_fIntensityMax = genProp.m_Float;

    if (m_fIntensityMax > 255.0f)   m_fIntensityMax = 255.0f;


	if (pServerDE->GetPropGeneric("IntensityMinTime", &genProp) == DE_OK)
		m_fIntensityMinTime = genProp.m_Float;

	if (pServerDE->GetPropGeneric("IntensityMaxTime", &genProp) == DE_OK)
		m_fIntensityMaxTime = genProp.m_Float;

	if (pServerDE->GetPropGeneric("IntensityRampUpTime", &genProp) == DE_OK)
		m_fIntensityRampUpTime = genProp.m_Float;

	if (pServerDE->GetPropGeneric("IntensityRampDownTime", &genProp) == DE_OK)