source-engine/game/client/episodic/c_vort_charge_token.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=====================================================================================//

#include "cbase.h"
#include "particles_simple.h"
#include "citadel_effects_shared.h"
#include "particles_attractor.h"
#include "iefx.h"
#include "dlight.h"
#include "clienteffectprecachesystem.h"
#include "c_te_effect_dispatch.h"
#include "fx_quad.h"

#include "c_ai_basenpc.h"

// For material proxy
#include "proxyentity.h"
#include "materialsystem/imaterial.h"
#include "materialsystem/imaterialvar.h"

#define NUM_INTERIOR_PARTICLES	8

#define DLIGHT_RADIUS (150.0f)
#define DLIGHT_MINLIGHT (40.0f/255.0f)

class C_NPC_Vortigaunt : public C_AI_BaseNPC
{
	DECLARE_CLASS( C_NPC_Vortigaunt, C_AI_BaseNPC );
	DECLARE_CLIENTCLASS();

public:
	virtual void	OnDataChanged( DataUpdateType_t updateType );
	virtual void	ClientThink( void );
	virtual void	ReceiveMessage( int classID, bf_read &msg );

public:
	bool  m_bIsBlue;           ///< wants to fade to blue
	float m_flBlueEndFadeTime; ///< when to end fading from one skin to another

	bool  m_bIsBlack;    ///< wants to fade to black (networked)
	float m_flBlackFade; ///< [0.00 .. 1.00] where 1.00 is all black. Locally interpolated.
};

IMPLEMENT_CLIENTCLASS_DT( C_NPC_Vortigaunt, DT_NPC_Vortigaunt, CNPC_Vortigaunt )
	RecvPropTime( RECVINFO(m_flBlueEndFadeTime ) ),
	RecvPropBool( RECVINFO(m_bIsBlue) ),
	RecvPropBool( RECVINFO(m_bIsBlack) ),
END_RECV_TABLE()


#define	VORTIGAUNT_BLUE_FADE_TIME			2.25f		// takes this long to fade from green to blue or back
#define VORT_BLACK_FADE_TIME 2.2f	// time to interpolate up or down in fading to black


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : updateType - 
//-----------------------------------------------------------------------------
void C_NPC_Vortigaunt::OnDataChanged( DataUpdateType_t updateType )
{
	BaseClass::OnDataChanged( updateType );

	// start thinking if we need to fade.
	if ( m_flBlackFade != (m_bIsBlack ? 1.0f : 0.0f) )
	{
		SetNextClientThink( CLIENT_THINK_ALWAYS );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void C_NPC_Vortigaunt::ClientThink( void )
{
	// Don't update if our frame hasn't moved forward (paused)
	if ( gpGlobals->frametime <= 0.0f )
		return;

	if ( m_bIsBlack )
	{
		// are we done?
		if ( m_flBlackFade >= 1.0f )
		{
			m_flBlackFade = 1.0f;
			SetNextClientThink( CLIENT_THINK_NEVER );
		}
		else // interpolate there
		{
			float lerpQuant = gpGlobals->frametime / VORT_BLACK_FADE_TIME;
			m_flBlackFade += lerpQuant;
			if ( m_flBlackFade > 1.0f )
			{
				m_flBlackFade = 1.0f;
			}
		}
	}
	else 
	{
		// are we done?
		if ( m_flBlackFade <= 0.0f )
		{
			m_flBlackFade = 0.0f;
			SetNextClientThink( CLIENT_THINK_NEVER );
		}
		else // interpolate there
		{
			float lerpQuant = gpGlobals->frametime / VORT_BLACK_FADE_TIME;
			m_flBlackFade -= lerpQuant;
			if ( m_flBlackFade < 0.0f )
			{
				m_flBlackFade = 0.0f;
			}
		}
	}
}

// FIXME: Move to shared code!
#define VORTFX_ZAPBEAM	0
#define VORTFX_ARMBEAM	1

//-----------------------------------------------------------------------------
// Purpose: Receive messages from the server
//-----------------------------------------------------------------------------
void C_NPC_Vortigaunt::ReceiveMessage( int classID, bf_read &msg )
{
	// Is the message for a sub-class?
	if ( classID != GetClientClass()->m_ClassID )
	{
		BaseClass::ReceiveMessage( classID, msg );
		return;
	}
	
	int messageType = msg.ReadByte();
	switch( messageType )
	{
	case VORTFX_ZAPBEAM:
		{
			// Find our attachment point
			unsigned char nAttachment = msg.ReadByte();
			
			// Get our attachment position
			Vector vecStart;
			QAngle vecAngles;
			GetAttachment( nAttachment, vecStart, vecAngles );

			// Get the final position we'll strike
			Vector vecEndPos;
			msg.ReadBitVec3Coord( vecEndPos );

			// Place a beam between the two points
			CNewParticleEffect *pEffect = ParticleProp()->Create( "vortigaunt_beam", PATTACH_POINT_FOLLOW, nAttachment );
			if ( pEffect )
			{
				pEffect->SetControlPoint( 0, vecStart );
				pEffect->SetControlPoint( 1, vecEndPos );
			}
		}
		break;

	case VORTFX_ARMBEAM:
		{
			int nIndex = msg.ReadLong();
			C_BaseEntity *pEnt = ClientEntityList().GetBaseEntityFromHandle( ClientEntityList().EntIndexToHandle( nIndex ) );

			if ( pEnt )
			{
				unsigned char nAttachment = msg.ReadByte();
				Vector vecEndPos;
				msg.ReadBitVec3Coord( vecEndPos );
				
				Vector vecNormal;
				msg.ReadBitVec3Normal( vecNormal );
				
				CNewParticleEffect *pEffect = pEnt->ParticleProp()->Create( "vortigaunt_beam_charge", PATTACH_POINT_FOLLOW, nAttachment );
				if ( pEffect )
				{
					// Set the control point's angles to be the surface normal we struct
					Vector vecRight, vecUp;
					VectorVectors( vecNormal, vecRight, vecUp );
					pEffect->SetControlPointOrientation( 1, vecNormal, vecRight, vecUp );
					pEffect->SetControlPoint( 1, vecEndPos );
				}
			}
		}
		break;
	default:
		AssertMsg1( false, "Received unknown message %d", messageType);
	}
}

class C_VortigauntChargeToken : public C_BaseEntity
{
	DECLARE_CLASS( C_VortigauntChargeToken, C_BaseEntity );
	DECLARE_CLIENTCLASS();

public:
	virtual void	UpdateOnRemove( void );
	virtual void	ClientThink( void );
	virtual void	NotifyShouldTransmit( ShouldTransmitState_t state );
	virtual void	OnDataChanged( DataUpdateType_t type );

	// For RecvProxy handlers
	float							m_flFadeOutTime;
	float							m_flFadeOutStart;

private:
	bool		SetupEmitters( void );

	bool							m_bFadeOut;
	CNewParticleEffect				*m_hEffect;
	dlight_t						*m_pDLight;
};

void RecvProxy_FadeOutDuration( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
	C_VortigauntChargeToken *pVortToken = (C_VortigauntChargeToken *) pStruct;
	Assert( pOut == &pVortToken->m_flFadeOutTime );

	pVortToken->m_flFadeOutStart = gpGlobals->curtime;
	pVortToken->m_flFadeOutTime = ( pData->m_Value.m_Float - gpGlobals->curtime );
}

IMPLEMENT_CLIENTCLASS_DT( C_VortigauntChargeToken, DT_VortigauntChargeToken, CVortigauntChargeToken )
	RecvPropBool( RECVINFO( m_bFadeOut ) ),
END_RECV_TABLE()

void C_VortigauntChargeToken::UpdateOnRemove( void )
{
	if ( m_hEffect )
	{
		m_hEffect->StopEmission();
		m_hEffect = NULL;
	}

	if ( m_pDLight != NULL )
	{
		m_pDLight->die = gpGlobals->curtime;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Change our transmission state 
//-----------------------------------------------------------------------------
void C_VortigauntChargeToken::NotifyShouldTransmit( ShouldTransmitState_t state )
{
	BaseClass::NotifyShouldTransmit( state );

	// Turn off
	if ( state == SHOULDTRANSMIT_END )
	{
		if ( m_hEffect )
		{
			m_hEffect->StopEmission();
			m_hEffect = NULL;
		}
	}

	// Turn on
	if ( state == SHOULDTRANSMIT_START )
	{
		m_hEffect = ParticleProp()->Create( "vortigaunt_charge_token", PATTACH_ABSORIGIN_FOLLOW );
		m_hEffect->SetControlPointEntity( 0, this );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void C_VortigauntChargeToken::OnDataChanged( DataUpdateType_t type )
{
	if ( m_bFadeOut )
	{
		if ( m_hEffect )
		{
			m_hEffect->StopEmission();
			m_hEffect = NULL;
		}
	}

	BaseClass::OnDataChanged( type );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void C_VortigauntChargeToken::ClientThink( void )
{
	//
	// -- DLight 
	//

	if ( m_pDLight != NULL )
	{
		m_pDLight->origin = GetAbsOrigin();
		m_pDLight->radius = DLIGHT_RADIUS;
	}
}

//=============================================================================
// 
//  Dispel Effect
//	
//=============================================================================

class C_VortigauntEffectDispel : public C_BaseEntity
{
	DECLARE_CLASS( C_VortigauntEffectDispel, C_BaseEntity );
	DECLARE_CLIENTCLASS();

public:
	virtual void	UpdateOnRemove( void );
	virtual void	ClientThink( void );
	virtual void	NotifyShouldTransmit( ShouldTransmitState_t state );
	virtual void	OnDataChanged( DataUpdateType_t type );

	// For RecvProxy handlers
	float							m_flFadeOutTime;
	float							m_flFadeOutStart;

private:
	bool	SetupEmitters( void );

	CNewParticleEffect				*m_hEffect;
	bool							m_bFadeOut;
	dlight_t						*m_pDLight;
};

void RecvProxy_DispelFadeOutDuration( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
	C_VortigauntEffectDispel *pVortToken = (C_VortigauntEffectDispel *) pStruct;
	Assert( pOut == &pVortToken->m_flFadeOutTime );

	pVortToken->m_flFadeOutStart = gpGlobals->curtime;
	pVortToken->m_flFadeOutTime = ( pData->m_Value.m_Float - gpGlobals->curtime );
}

IMPLEMENT_CLIENTCLASS_DT( C_VortigauntEffectDispel, DT_VortigauntEffectDispel, CVortigauntEffectDispel )
	RecvPropBool( RECVINFO( m_bFadeOut ) ),
END_RECV_TABLE()

void C_VortigauntEffectDispel::UpdateOnRemove( void )
{
	if ( m_hEffect )
	{
		m_hEffect->StopEmission();
		m_hEffect = NULL;
	}

	if ( m_pDLight != NULL )
	{
		m_pDLight->die = gpGlobals->curtime;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void C_VortigauntEffectDispel::OnDataChanged( DataUpdateType_t type )
{
	if ( m_bFadeOut )
	{
		if ( m_hEffect )
		{
			m_hEffect->StopEmission();
			m_hEffect = NULL;
		}
	}

	BaseClass::OnDataChanged( type );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void C_VortigauntEffectDispel::NotifyShouldTransmit( ShouldTransmitState_t state )
{
	BaseClass::NotifyShouldTransmit( state );

	// Turn off
	if ( state == SHOULDTRANSMIT_END )
	{
		if ( m_hEffect )
		{
			m_hEffect->StopEmission();
			m_hEffect = NULL;
		}
	}

	// Turn on
	if ( state == SHOULDTRANSMIT_START )
	{
		m_hEffect = ParticleProp()->Create( "vortigaunt_hand_glow", PATTACH_ABSORIGIN_FOLLOW );
		m_hEffect->SetControlPointEntity( 0, this );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Create our emitter
//-----------------------------------------------------------------------------
bool C_VortigauntEffectDispel::SetupEmitters( void )
{
	m_pDLight = NULL;

#ifndef _X360
	m_pDLight = effects->CL_AllocDlight ( index );
	m_pDLight->origin = GetAbsOrigin();
	m_pDLight->color.r = 64;
	m_pDLight->color.g = 255;
	m_pDLight->color.b = 64;
	m_pDLight->radius = 0;
	m_pDLight->minlight = DLIGHT_MINLIGHT;
	m_pDLight->die = FLT_MAX;
#endif // _X360

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void C_VortigauntEffectDispel::ClientThink( void )
{
	if ( m_pDLight != NULL )
	{
		m_pDLight->origin = GetAbsOrigin();
		m_pDLight->radius = DLIGHT_RADIUS;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void DispelCallback( const CEffectData &data )
{
	// Kaboom!
	Vector startPos = data.m_vOrigin + Vector(0,0,16);
	Vector endPos = data.m_vOrigin + Vector(0,0,-64);

	trace_t tr;
	UTIL_TraceLine( startPos, endPos, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr );

	if ( tr.fraction < 1.0f )
	{
		//Add a ripple quad to the surface
		FX_AddQuad( tr.endpos + ( tr.plane.normal * 8.0f ), 
			Vector( 0, 0, 1 ), 
			64.0f, 
			600.0f, 
			0.8f,
			1.0f,	// start alpha
			0.0f,	// end alpha
			0.3f,
			random->RandomFloat( 0, 360 ),
			0.0f,
			Vector( 0.5f, 1.0f, 0.5f ), 
			0.75f, 
			"effects/ar2_altfire1b", 
			(FXQUAD_BIAS_SCALE|FXQUAD_BIAS_ALPHA|FXQUAD_COLOR_FADE) );
		
		//Add a ripple quad to the surface
		FX_AddQuad( tr.endpos + ( tr.plane.normal * 8.0f ), 
			Vector( 0, 0, 1 ), 
			16.0f, 
			300.0f,
			0.9f,
			1.0f,	// start alpha
			0.0f,	// end alpha
			0.9f,
			random->RandomFloat( 0, 360 ),
			0.0f,
			Vector( 0.5f, 1.0f, 0.5f ), 
			1.25f, 
			"effects/rollerglow", 
			(FXQUAD_BIAS_SCALE|FXQUAD_BIAS_ALPHA) );
	}
}

DECLARE_CLIENT_EFFECT( "VortDispel", DispelCallback );

//-----------------------------------------------------------------------------
// Purpose: Used for emissive lightning layer on vort
//-----------------------------------------------------------------------------
class CVortEmissiveProxy : public CEntityMaterialProxy
{
public:
	CVortEmissiveProxy( void );
	virtual				~CVortEmissiveProxy( void );
	virtual bool		Init( IMaterial *pMaterial, KeyValues* pKeyValues );
	virtual void		OnBind( C_BaseEntity *pC_BaseEntity );
	virtual IMaterial *	GetMaterial();

private:

	IMaterialVar *m_pMatEmissiveStrength;
	IMaterialVar *m_pMatDetailBlendStrength;
};

//-----------------------------------------------------------------------------
CVortEmissiveProxy::CVortEmissiveProxy( void )
{
	m_pMatEmissiveStrength = NULL;
	m_pMatDetailBlendStrength = NULL;
}

CVortEmissiveProxy::~CVortEmissiveProxy( void )
{
	// Do nothing
}

//-----------------------------------------------------------------------------
bool CVortEmissiveProxy::Init( IMaterial *pMaterial, KeyValues* pKeyValues )
{
	Assert( pMaterial );

	// Need to get the material var
	bool bFound;
	m_pMatEmissiveStrength = pMaterial->FindVar( "$emissiveblendstrength", &bFound );

	if ( bFound )
	{
		// Optional
		bool bFound2;
		m_pMatDetailBlendStrength = pMaterial->FindVar( "$detailblendfactor", &bFound2 );
	}

	return bFound;
}

//-----------------------------------------------------------------------------
void CVortEmissiveProxy::OnBind( C_BaseEntity *pEnt )
{
	C_NPC_Vortigaunt *pVort = dynamic_cast<C_NPC_Vortigaunt *>(pEnt);

	float flBlendValue;

	if (pVort)
	{
		// do we need to crossfade?
		if (gpGlobals->curtime < pVort->m_flBlueEndFadeTime)
		{
			// will be 0 when fully faded and 1 when not faded at all:
			float fadeRatio = (pVort->m_flBlueEndFadeTime - gpGlobals->curtime) / VORTIGAUNT_BLUE_FADE_TIME;
			if (pVort->m_bIsBlue)
			{
				fadeRatio = 1.0f - fadeRatio;
			}
			flBlendValue = clamp( fadeRatio, 0.0f, 1.0f );
		}
		else // no crossfade
		{
			flBlendValue = pVort->m_bIsBlue ? 1.0f : 0.0f;
		}

		// ALEX VLACHOS: 
		// The following variable varies on [0 .. 1]. 0.0 means the vort wants to be his normal
		// color. 1.0 means he wants to be all black. It is interpolated in the
		// C_NPC_Vortigaunt::ClientThink() function. 
		// 
		// pVort->m_flBlackFade
	}
	else
	{	// if you bind this proxy to anything non-vort (eg a ragdoll) it's always green
		flBlendValue = 0.0f;
	}


	/*
	// !!! Change me !!! I'm using a clamped sin wave for debugging
	float flBlendValue = sinf( gpGlobals->curtime * 4.0f ) * 0.75f + 0.25f;

	// Clamp 0-1
	flBlendValue = ( flBlendValue < 0.0f ) ? 0.0f : ( flBlendValue > 1.0f ) ? 1.0f : flBlendValue;
	*/

	if( m_pMatEmissiveStrength != NULL )
	{
		m_pMatEmissiveStrength->SetFloatValue( flBlendValue );
	}

	if( m_pMatDetailBlendStrength != NULL )
	{
		m_pMatDetailBlendStrength->SetFloatValue( flBlendValue );
	}
}

//-----------------------------------------------------------------------------
IMaterial *CVortEmissiveProxy::GetMaterial()
{
	if ( m_pMatEmissiveStrength != NULL )
		return m_pMatEmissiveStrength->GetOwningMaterial();
	else if ( m_pMatDetailBlendStrength != NULL )
		return m_pMatDetailBlendStrength->GetOwningMaterial();
	else
		return NULL;
}

EXPOSE_INTERFACE( CVortEmissiveProxy, IMaterialProxy, "VortEmissive" IMATERIAL_PROXY_INTERFACE_VERSION );