You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
667 lines
16 KiB
667 lines
16 KiB
/*** |
|
* |
|
* Copyright (c) 1996-2002, Valve LLC. All rights reserved. |
|
* |
|
* This product contains software technology licensed from Id |
|
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc. |
|
* All Rights Reserved. |
|
* |
|
* Use, distribution, and modification of this source code and/or resulting |
|
* object code is restricted to non-commercial enhancements to products from |
|
* Valve LLC. All other use, distribution, or modification is prohibited |
|
* without written permission from Valve LLC. |
|
* |
|
****/ |
|
/* |
|
|
|
===== lights.cpp ======================================================== |
|
|
|
spawn and think functions for editor-placed lights |
|
|
|
*/ |
|
|
|
#include "extdll.h" |
|
#include "util.h" |
|
#include "cbase.h" |
|
|
|
//LRC |
|
int GetStdLightStyle (int iStyle) |
|
{ |
|
switch (iStyle) |
|
{ |
|
// 0 normal |
|
case 0: return MAKE_STRING("m"); |
|
|
|
// 1 FLICKER (first variety) |
|
case 1: return MAKE_STRING("mmnmmommommnonmmonqnmmo"); |
|
|
|
// 2 SLOW STRONG PULSE |
|
case 2: return MAKE_STRING("abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba"); |
|
|
|
// 3 CANDLE (first variety) |
|
case 3: return MAKE_STRING("mmmmmaaaaammmmmaaaaaabcdefgabcdefg"); |
|
|
|
// 4 FAST STROBE |
|
case 4: return MAKE_STRING("mamamamamama"); |
|
|
|
// 5 GENTLE PULSE 1 |
|
case 5: return MAKE_STRING("jklmnopqrstuvwxyzyxwvutsrqponmlkj"); |
|
|
|
// 6 FLICKER (second variety) |
|
case 6: return MAKE_STRING("nmonqnmomnmomomno"); |
|
|
|
// 7 CANDLE (second variety) |
|
case 7: return MAKE_STRING("mmmaaaabcdefgmmmmaaaammmaamm"); |
|
|
|
// 8 CANDLE (third variety) |
|
case 8: return MAKE_STRING("mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa"); |
|
|
|
// 9 SLOW STROBE (fourth variety) |
|
case 9: return MAKE_STRING("aaaaaaaazzzzzzzz"); |
|
|
|
// 10 FLUORESCENT FLICKER |
|
case 10: return MAKE_STRING("mmamammmmammamamaaamammma"); |
|
|
|
// 11 SLOW PULSE NOT FADE TO BLACK |
|
case 11: return MAKE_STRING("abcdefghijklmnopqrrqponmlkjihgfedcba"); |
|
|
|
// 12 UNDERWATER LIGHT MUTATION |
|
// this light only distorts the lightmap - no contribution |
|
// is made to the brightness of affected surfaces |
|
case 12: return MAKE_STRING("mmnnmmnnnmmnn"); |
|
|
|
// 13 OFF (LRC) |
|
case 13: return MAKE_STRING("a"); |
|
|
|
// 14 SLOW FADE IN (LRC) |
|
case 14: return MAKE_STRING("aabbccddeeffgghhiijjkkllmmmmmmmmmmmmmm"); |
|
|
|
// 15 MED FADE IN (LRC) |
|
case 15: return MAKE_STRING("abcdefghijklmmmmmmmmmmmmmmmmmmmmmmmmmm"); |
|
|
|
// 16 FAST FADE IN (LRC) |
|
case 16: return MAKE_STRING("acegikmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm"); |
|
|
|
// 17 SLOW FADE OUT (LRC) |
|
case 17: return MAKE_STRING("llkkjjiihhggffeeddccbbaaaaaaaaaaaaaaaa"); |
|
|
|
// 18 MED FADE OUT (LRC) |
|
case 18: return MAKE_STRING("lkjihgfedcbaaaaaaaaaaaaaaaaaaaaaaaaaaa"); |
|
|
|
// 19 FAST FADE OUT (LRC) |
|
case 19: return MAKE_STRING("kigecaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); |
|
|
|
default: return MAKE_STRING("m"); |
|
} |
|
} |
|
|
|
|
|
class CLight : public CPointEntity |
|
{ |
|
public: |
|
virtual void KeyValue( KeyValueData* pkvd ); |
|
virtual void Spawn( void ); |
|
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); |
|
void Think( void ); |
|
|
|
virtual int Save( CSave &save ); |
|
virtual int Restore( CRestore &restore ); |
|
virtual STATE GetState(void) { return m_iState; }; //LRC |
|
|
|
static TYPEDESCRIPTION m_SaveData[]; |
|
|
|
int GetStyle( void ) { return m_iszCurrentStyle; }; //LRC |
|
void SetStyle( int iszPattern ); //LRC |
|
|
|
void SetCorrectStyle( void ); //LRC |
|
|
|
private: |
|
STATE m_iState; // current state |
|
int m_iOnStyle; // style to use while on |
|
int m_iOffStyle; // style to use while off |
|
int m_iTurnOnStyle; // style to use while turning on |
|
int m_iTurnOffStyle; // style to use while turning off |
|
int m_iTurnOnTime; // time taken to turn on |
|
int m_iTurnOffTime; // time taken to turn off |
|
int m_iszPattern; // custom style to use while on |
|
int m_iszCurrentStyle; // current style string |
|
}; |
|
|
|
LINK_ENTITY_TO_CLASS( light, CLight ) |
|
|
|
TYPEDESCRIPTION CLight::m_SaveData[] = |
|
{ |
|
DEFINE_FIELD( CLight, m_iState, FIELD_INTEGER ), |
|
DEFINE_FIELD( CLight, m_iszPattern, FIELD_STRING ), |
|
DEFINE_FIELD( CLight, m_iszCurrentStyle, FIELD_STRING ), |
|
DEFINE_FIELD( CLight, m_iOnStyle, FIELD_INTEGER ), |
|
DEFINE_FIELD( CLight, m_iOffStyle, FIELD_INTEGER ), |
|
DEFINE_FIELD( CLight, m_iTurnOnStyle, FIELD_INTEGER ), |
|
DEFINE_FIELD( CLight, m_iTurnOffStyle, FIELD_INTEGER ), |
|
DEFINE_FIELD( CLight, m_iTurnOnTime, FIELD_INTEGER ), |
|
DEFINE_FIELD( CLight, m_iTurnOffTime, FIELD_INTEGER ), |
|
}; |
|
|
|
IMPLEMENT_SAVERESTORE( CLight, CPointEntity ) |
|
|
|
// |
|
// Cache user-entity-field values until spawn is called. |
|
// |
|
void CLight::KeyValue( KeyValueData* pkvd ) |
|
{ |
|
if (FStrEq(pkvd->szKeyName, "m_iOnStyle")) |
|
{ |
|
m_iOnStyle = atoi(pkvd->szValue); |
|
pkvd->fHandled = TRUE; |
|
} |
|
else if (FStrEq(pkvd->szKeyName, "m_iOffStyle")) |
|
{ |
|
m_iOffStyle = atoi(pkvd->szValue); |
|
pkvd->fHandled = TRUE; |
|
} |
|
else if (FStrEq(pkvd->szKeyName, "m_iTurnOnStyle")) |
|
{ |
|
m_iTurnOnStyle = atoi(pkvd->szValue); |
|
pkvd->fHandled = TRUE; |
|
} |
|
else if (FStrEq(pkvd->szKeyName, "m_iTurnOffStyle")) |
|
{ |
|
m_iTurnOffStyle = atoi(pkvd->szValue); |
|
pkvd->fHandled = TRUE; |
|
} |
|
else if (FStrEq(pkvd->szKeyName, "m_iTurnOnTime")) |
|
{ |
|
m_iTurnOnTime = atoi(pkvd->szValue); |
|
pkvd->fHandled = TRUE; |
|
} |
|
else if (FStrEq(pkvd->szKeyName, "m_iTurnOffTime")) |
|
{ |
|
m_iTurnOffTime = atoi(pkvd->szValue); |
|
pkvd->fHandled = TRUE; |
|
} |
|
else if( FStrEq(pkvd->szKeyName, "pitch" ) ) |
|
{ |
|
pev->angles.x = atof( pkvd->szValue ); |
|
pkvd->fHandled = TRUE; |
|
} |
|
else if( FStrEq(pkvd->szKeyName, "pattern" ) ) |
|
{ |
|
m_iszPattern = ALLOC_STRING( pkvd->szValue ); |
|
pkvd->fHandled = TRUE; |
|
} |
|
else if (FStrEq(pkvd->szKeyName, "firetarget")) |
|
{ |
|
pev->target = ALLOC_STRING( pkvd->szValue ); |
|
pkvd->fHandled = TRUE; |
|
} |
|
else |
|
{ |
|
CPointEntity::KeyValue( pkvd ); |
|
} |
|
} |
|
|
|
void CLight :: SetStyle ( int iszPattern ) |
|
{ |
|
if (m_iStyle < 32) // if it's using a global style, don't change it |
|
return; |
|
m_iszCurrentStyle = iszPattern; |
|
// ALERT(at_console, "SetStyle %d \"%s\"\n", m_iStyle, (char *)STRING( iszPattern )); |
|
LIGHT_STYLE(m_iStyle, (char *)STRING( iszPattern )); |
|
} |
|
|
|
// regardless of what's been set by trigger_lightstyle ents, set the style I think I need |
|
void CLight :: SetCorrectStyle ( void ) |
|
{ |
|
if (m_iStyle >= 32) |
|
{ |
|
switch (m_iState) |
|
{ |
|
case STATE_ON: |
|
if (m_iszPattern) // custom styles have priority over standard ones |
|
SetStyle( m_iszPattern ); |
|
else if (m_iOnStyle) |
|
SetStyle(GetStdLightStyle(m_iOnStyle)); |
|
else |
|
SetStyle(MAKE_STRING("m")); |
|
break; |
|
case STATE_OFF: |
|
if (m_iOffStyle) |
|
SetStyle(GetStdLightStyle(m_iOffStyle)); |
|
else |
|
SetStyle(MAKE_STRING("a")); |
|
break; |
|
case STATE_TURN_ON: |
|
if (m_iTurnOnStyle) |
|
SetStyle(GetStdLightStyle(m_iTurnOnStyle)); |
|
else |
|
SetStyle(MAKE_STRING("a")); |
|
break; |
|
case STATE_TURN_OFF: |
|
if (m_iTurnOffStyle) |
|
SetStyle(GetStdLightStyle(m_iTurnOffStyle)); |
|
else |
|
SetStyle(MAKE_STRING("m")); |
|
break; |
|
case STATE_IN_USE: |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
else |
|
{ |
|
m_iszCurrentStyle = GetStdLightStyle( m_iStyle ); |
|
} |
|
} |
|
|
|
void CLight :: Think( void ) |
|
{ |
|
switch (GetState()) |
|
{ |
|
case STATE_TURN_ON: |
|
m_iState = STATE_ON; |
|
FireTargets(STRING(pev->target),this,this,USE_ON,0); |
|
break; |
|
case STATE_TURN_OFF: |
|
m_iState = STATE_OFF; |
|
FireTargets(STRING(pev->target),this,this,USE_OFF,0); |
|
break; |
|
case STATE_OFF: |
|
case STATE_ON: |
|
case STATE_IN_USE: |
|
break; |
|
default: |
|
break; |
|
} |
|
SetCorrectStyle(); |
|
} |
|
|
|
/*QUAKED light (0 1 0) (-8 -8 -8) (8 8 8) LIGHT_START_OFF |
|
Non-displayed light. |
|
Default light value is 300 |
|
Default style is 0 |
|
If targeted, it will toggle between on or off. |
|
*/ |
|
|
|
void CLight::Spawn( void ) |
|
{ |
|
if( FStringNull( pev->targetname ) ) |
|
{ |
|
// inert light |
|
REMOVE_ENTITY(ENT( pev ) ); |
|
return; |
|
} |
|
|
|
if( FBitSet( pev->spawnflags, SF_LIGHT_START_OFF ) ) |
|
m_iState = STATE_OFF; |
|
else |
|
m_iState = STATE_ON; |
|
SetCorrectStyle(); |
|
} |
|
|
|
void CLight::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) |
|
{ |
|
if( m_iStyle >= 32 ) |
|
{ |
|
if ( !ShouldToggle( useType ) ) |
|
return; |
|
|
|
switch (GetState()) |
|
{ |
|
case STATE_ON: |
|
case STATE_TURN_ON: |
|
if (m_iTurnOffTime) |
|
{ |
|
m_iState = STATE_TURN_OFF; |
|
SetNextThink( m_iTurnOffTime ); |
|
} |
|
else |
|
m_iState = STATE_OFF; |
|
break; |
|
case STATE_OFF: |
|
case STATE_TURN_OFF: |
|
if (m_iTurnOnTime) |
|
{ |
|
m_iState = STATE_TURN_ON; |
|
SetNextThink( m_iTurnOnTime ); |
|
} |
|
else |
|
m_iState = STATE_ON; |
|
break; |
|
STATE_IN_USE: |
|
break; |
|
default: |
|
break; |
|
} |
|
SetCorrectStyle(); |
|
} |
|
} |
|
|
|
// |
|
// shut up spawn functions for new spotlights |
|
// |
|
LINK_ENTITY_TO_CLASS( light_spot, CLight ) |
|
|
|
class CEnvLight : public CLight |
|
{ |
|
public: |
|
void KeyValue( KeyValueData* pkvd ); |
|
void Spawn( void ); |
|
}; |
|
|
|
LINK_ENTITY_TO_CLASS( light_environment, CEnvLight ) |
|
|
|
void CEnvLight::KeyValue( KeyValueData* pkvd ) |
|
{ |
|
if( FStrEq(pkvd->szKeyName, "_light" ) ) |
|
{ |
|
int r, g, b, v, j; |
|
char szColor[64]; |
|
j = sscanf( pkvd->szValue, "%d %d %d %d\n", &r, &g, &b, &v ); |
|
if( j == 1 ) |
|
{ |
|
g = b = r; |
|
} |
|
else if( j == 4 ) |
|
{ |
|
float vf = v / 255.0f; |
|
r *= vf; |
|
g *= vf; |
|
b *= vf; |
|
} |
|
|
|
// simulate qrad direct, ambient,and gamma adjustments, as well as engine scaling |
|
r = (int)( pow( r / 114.0f, 0.6f ) * 264.0f ); |
|
g = (int)( pow( g / 114.0f, 0.6f ) * 264.0f ); |
|
b = (int)( pow( b / 114.0f, 0.6f ) * 264.0f ); |
|
|
|
pkvd->fHandled = TRUE; |
|
sprintf( szColor, "%d", r ); |
|
CVAR_SET_STRING( "sv_skycolor_r", szColor ); |
|
sprintf( szColor, "%d", g ); |
|
CVAR_SET_STRING( "sv_skycolor_g", szColor ); |
|
sprintf( szColor, "%d", b ); |
|
CVAR_SET_STRING( "sv_skycolor_b", szColor ); |
|
} |
|
else |
|
{ |
|
CLight::KeyValue( pkvd ); |
|
} |
|
} |
|
|
|
void CEnvLight::Spawn( void ) |
|
{ |
|
char szVector[64]; |
|
UTIL_MakeAimVectors( pev->angles ); |
|
|
|
sprintf( szVector, "%f", (double)gpGlobals->v_forward.x ); |
|
CVAR_SET_STRING( "sv_skyvec_x", szVector ); |
|
sprintf( szVector, "%f", (double)gpGlobals->v_forward.y ); |
|
CVAR_SET_STRING( "sv_skyvec_y", szVector ); |
|
sprintf( szVector, "%f", (double)gpGlobals->v_forward.z ); |
|
CVAR_SET_STRING( "sv_skyvec_z", szVector ); |
|
|
|
CLight::Spawn(); |
|
} |
|
|
|
//********************************************************** |
|
//LRC- the CLightDynamic entity - works like the flashlight. |
|
//********************************************************** |
|
|
|
#define SF_LIGHTDYNAMIC_START_OFF 1 |
|
#define SF_LIGHTDYNAMIC_FLARE 2 |
|
|
|
class CLightDynamic : public CBaseEntity |
|
{ |
|
public: |
|
void Spawn( void ); |
|
void Precache( void ); |
|
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); |
|
int ObjectCaps( void ) { return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; } |
|
void SetEffects( void ); |
|
STATE GetState( void ); |
|
}; |
|
|
|
LINK_ENTITY_TO_CLASS( light_glow, CLightDynamic ); |
|
|
|
void CLightDynamic::Spawn( void ) |
|
{ |
|
Precache( ); |
|
|
|
SET_MODEL(ENT(pev), "sprites/null.spr"); |
|
pev->solid = SOLID_NOT; |
|
pev->movetype = MOVETYPE_NONE; |
|
|
|
if (!(pev->spawnflags & SF_LIGHTDYNAMIC_START_OFF)) |
|
{ |
|
pev->health = 1; |
|
SetEffects(); |
|
} |
|
} |
|
|
|
void CLightDynamic :: Precache( void ) |
|
{ |
|
PRECACHE_MODEL("sprites/null.spr"); |
|
} |
|
|
|
void CLightDynamic::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) |
|
{ |
|
if (ShouldToggle(useType, pev->health)) |
|
{ |
|
if (pev->health) |
|
pev->health = 0; |
|
else |
|
pev->health = 1; |
|
SetEffects(); |
|
} |
|
} |
|
|
|
void CLightDynamic::SetEffects( void ) |
|
{ |
|
if (pev->health) |
|
{ |
|
if (pev->frags == 2) |
|
pev->effects |= EF_BRIGHTLIGHT; |
|
else if (pev->frags) |
|
pev->effects |= EF_DIMLIGHT; |
|
|
|
if (pev->spawnflags & SF_LIGHTDYNAMIC_FLARE) |
|
pev->effects |= EF_LIGHT; |
|
} |
|
else |
|
{ |
|
pev->effects &= ~(EF_DIMLIGHT | EF_BRIGHTLIGHT | EF_LIGHT); |
|
} |
|
} |
|
|
|
STATE CLightDynamic::GetState( void ) |
|
{ |
|
if (pev->health) |
|
return STATE_ON; |
|
else |
|
return STATE_OFF; |
|
} |
|
|
|
//********************************************************** |
|
//LRC- the CTriggerLightstyle entity - changes the style of a light temporarily. |
|
//********************************************************** |
|
class CLightFader : public CPointEntity |
|
{ |
|
public: |
|
void EXPORT FadeThink( void ); |
|
void EXPORT WaitThink( void ); |
|
virtual int Save( CSave &save ); |
|
virtual int Restore( CRestore &restore ); |
|
|
|
static TYPEDESCRIPTION m_SaveData[]; |
|
|
|
CLight *m_pLight; |
|
char m_cFrom; |
|
char m_cTo; |
|
char m_szCurStyle[2]; |
|
float m_fEndTime; |
|
int m_iszPattern; |
|
float m_fStep; |
|
int m_iWait; |
|
}; |
|
|
|
LINK_ENTITY_TO_CLASS( lightfader, CLightFader ); |
|
|
|
TYPEDESCRIPTION CLightFader::m_SaveData[] = |
|
{ |
|
DEFINE_FIELD( CLightFader, m_pLight, FIELD_CLASSPTR ), |
|
DEFINE_FIELD( CLightFader, m_cFrom, FIELD_CHARACTER ), |
|
DEFINE_FIELD( CLightFader, m_cTo, FIELD_CHARACTER ), |
|
DEFINE_ARRAY( CLightFader, m_szCurStyle, FIELD_CHARACTER, 2 ), |
|
DEFINE_FIELD( CLightFader, m_fEndTime, FIELD_FLOAT ), |
|
DEFINE_FIELD( CLightFader, m_iszPattern, FIELD_STRING ), |
|
DEFINE_FIELD( CLightFader, m_fStep, FIELD_FLOAT ), |
|
DEFINE_FIELD( CLightFader, m_iWait, FIELD_INTEGER ), |
|
}; |
|
|
|
IMPLEMENT_SAVERESTORE(CLightFader,CPointEntity); |
|
|
|
void CLightFader::FadeThink( void ) |
|
{ |
|
if (m_fEndTime > gpGlobals->time) |
|
{ |
|
m_szCurStyle[0] = m_cTo + (char)((m_cFrom - m_cTo) * (m_fEndTime - gpGlobals->time) * m_fStep); |
|
m_szCurStyle[1] = 0; // null terminator |
|
// ALERT(at_console, "FadeThink: %s %s\n", STRING(m_pLight->pev->classname), m_szCurStyle); |
|
m_pLight->SetStyle(MAKE_STRING(m_szCurStyle)); |
|
SetNextThink( 0.1 ); |
|
} |
|
else |
|
{ |
|
// fade is finished |
|
m_pLight->SetStyle(m_iszPattern); |
|
if (m_iWait > -1) |
|
{ |
|
// wait until it's time to switch off |
|
SetThink(&CLightFader:: WaitThink ); |
|
SetNextThink( m_iWait ); |
|
} |
|
else |
|
{ |
|
// we've finished, kill the fader |
|
SetThink(&CLightFader:: SUB_Remove ); |
|
SetNextThink( 0.1 ); |
|
} |
|
} |
|
} |
|
|
|
// we've finished. revert the light and kill the fader. |
|
void CLightFader::WaitThink( void ) |
|
{ |
|
m_pLight->SetCorrectStyle(); |
|
SetThink(&CLightFader:: SUB_Remove ); |
|
SetNextThink( 0.1 ); |
|
} |
|
|
|
|
|
|
|
class CTriggerLightstyle : public CPointEntity |
|
{ |
|
public: |
|
void KeyValue( KeyValueData *pkvd ); |
|
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); |
|
virtual int Save( CSave &save ); |
|
virtual int Restore( CRestore &restore ); |
|
static TYPEDESCRIPTION m_SaveData[]; |
|
|
|
private: |
|
int m_iszPattern; |
|
int m_iFade; |
|
int m_iWait; |
|
}; |
|
|
|
LINK_ENTITY_TO_CLASS( trigger_lightstyle, CTriggerLightstyle ); |
|
|
|
TYPEDESCRIPTION CTriggerLightstyle::m_SaveData[] = |
|
{ |
|
DEFINE_FIELD( CTriggerLightstyle, m_iszPattern, FIELD_STRING ), |
|
DEFINE_FIELD( CTriggerLightstyle, m_iFade, FIELD_INTEGER ), |
|
DEFINE_FIELD( CTriggerLightstyle, m_iWait, FIELD_INTEGER ), |
|
}; |
|
|
|
IMPLEMENT_SAVERESTORE(CTriggerLightstyle,CBaseEntity); |
|
|
|
void CTriggerLightstyle::KeyValue( KeyValueData *pkvd ) |
|
{ |
|
if (FStrEq(pkvd->szKeyName, "pattern")) |
|
{ |
|
m_iszPattern = ALLOC_STRING( pkvd->szValue ); |
|
pkvd->fHandled = TRUE; |
|
} |
|
else if (FStrEq(pkvd->szKeyName, "m_iFade")) |
|
{ |
|
m_iFade = atoi( pkvd->szValue ); |
|
pkvd->fHandled = TRUE; |
|
} |
|
else if (FStrEq(pkvd->szKeyName, "m_iWait")) |
|
{ |
|
m_iWait = atoi( pkvd->szValue ); |
|
pkvd->fHandled = TRUE; |
|
} |
|
else |
|
CBaseEntity::KeyValue( pkvd ); |
|
} |
|
|
|
void CTriggerLightstyle::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) |
|
{ |
|
CBaseEntity *pTarget = NULL; |
|
if ( !pev->target ) |
|
return; |
|
|
|
//ALERT( at_console, "Lightstyle change for: (%s)\n", STRING(pev->target) ); |
|
|
|
for (;;) |
|
{ |
|
pTarget = UTIL_FindEntityByTargetname(pTarget,STRING(pev->target), pActivator); |
|
if (FNullEnt(pTarget)) |
|
break; |
|
|
|
int iszPattern; |
|
if (m_iszPattern) |
|
iszPattern = m_iszPattern; |
|
else |
|
iszPattern = GetStdLightStyle(m_iStyle); |
|
|
|
// not a light entity? |
|
if (!FClassnameIs(pTarget->pev, "light") && !FClassnameIs(pTarget->pev, "light_spot") && !FClassnameIs(pTarget->pev, "light_environment")) |
|
{ |
|
if (pTarget->m_iStyle >= 32) |
|
LIGHT_STYLE(pTarget->m_iStyle, (char*)STRING(iszPattern)); |
|
} |
|
else |
|
{ |
|
CLight *pLight = (CLight*)pTarget; |
|
|
|
if (m_iFade) |
|
{ |
|
// ALERT(at_console, "Making fader ent, step 1/%d = %f\n", m_iFade, 1/m_iFade); |
|
CLightFader *pFader = GetClassPtr( (CLightFader*)NULL ); |
|
pFader->m_pLight = pLight; |
|
pFader->m_cFrom = ((char*)STRING(pLight->GetStyle()))[0]; |
|
pFader->m_cTo = ((char*)STRING(iszPattern))[0]; |
|
pFader->m_iszPattern = iszPattern; |
|
pFader->m_fEndTime = gpGlobals->time + m_iFade; |
|
pFader->m_fStep = ((float)1)/m_iFade; |
|
pFader->m_iWait = m_iWait; |
|
pFader->SetThink(&CLightFader::FadeThink ); |
|
pFader->SetNextThink( 0.1 ); |
|
} |
|
else |
|
{ |
|
pLight->SetStyle( iszPattern ); |
|
if (m_iWait != -1) |
|
{ |
|
CLightFader *pFader = GetClassPtr( (CLightFader*)NULL ); |
|
pFader->m_pLight = pLight; |
|
pFader->SetThink(&CLightFader::WaitThink ); |
|
pFader->SetNextThink( m_iWait ); |
|
} |
|
} |
|
} |
|
} |
|
}
|
|
|