sqwarmed/sdk_src/game/server/func_movelinear.cpp

414 lines
12 KiB
C++

//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: Implements a brush model entity that moves along a linear path.
// Water whose level can be changed is implemented using the same entity.
//
//=============================================================================//
#include "cbase.h"
#include "func_movelinear.h"
#include "entitylist.h"
#include "locksounds.h"
#include "ndebugoverlay.h"
#include "engine/IEngineSound.h"
#include "physics_saverestore.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// -------------------------------
// SPAWN_FLAGS
// -------------------------------
#define SF_MOVELINEAR_NOTSOLID 8
LINK_ENTITY_TO_CLASS( func_movelinear, CFuncMoveLinear );
LINK_ENTITY_TO_CLASS( momentary_door, CFuncMoveLinear ); // For backward compatibility
//
// func_water_analog is implemented as a linear mover so we can raise/lower the water level.
//
LINK_ENTITY_TO_CLASS( func_water_analog, CFuncMoveLinear );
BEGIN_DATADESC( CFuncMoveLinear )
DEFINE_KEYFIELD( m_vecMoveDir, FIELD_VECTOR, "movedir" ),
DEFINE_KEYFIELD( m_soundStart, FIELD_SOUNDNAME, "StartSound" ),
DEFINE_KEYFIELD( m_soundStop, FIELD_SOUNDNAME, "StopSound" ),
DEFINE_FIELD( m_currentSound, FIELD_SOUNDNAME ),
DEFINE_KEYFIELD( m_flBlockDamage, FIELD_FLOAT, "BlockDamage"),
DEFINE_KEYFIELD( m_flStartPosition, FIELD_FLOAT, "StartPosition"),
DEFINE_KEYFIELD( m_flMoveDistance, FIELD_FLOAT, "MoveDistance"),
// DEFINE_PHYSPTR( m_pFluidController ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Open", InputOpen ),
DEFINE_INPUTFUNC( FIELD_VOID, "Close", InputClose ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetPosition", InputSetPosition ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetSpeed", InputSetSpeed ),
// Outputs
DEFINE_OUTPUT( m_OnFullyOpen, "OnFullyOpen" ),
DEFINE_OUTPUT( m_OnFullyClosed, "OnFullyClosed" ),
// Functions
DEFINE_FUNCTION( StopMoveSound ),
END_DATADESC()
void SendProxy_CropFlagsToConveyorFlagBitsLength( const SendProp *pProp, const void *pStruct, const void *pVarData, DVariant *pOut, int iElement, int objectID)
{
int mask = (1<<13) - 1;
int data = *(int *)pVarData;
pOut->m_Int = ( data & mask );
}
IMPLEMENT_SERVERCLASS_ST(CFuncMoveLinear, DT_FuncMoveLinear)
SendPropVector( SENDINFO( m_vecVelocity ), 0, SPROP_NOSCALE ),
SendPropInt ( SENDINFO(m_fFlags), 0, SPROP_UNSIGNED ),
END_SEND_TABLE()
//------------------------------------------------------------------------------
// Purpose: Called before spawning, after keyvalues have been parsed.
//------------------------------------------------------------------------------
void CFuncMoveLinear::Spawn( void )
{
// Convert movedir from angles to a vector
QAngle angMoveDir = QAngle( m_vecMoveDir.x, m_vecMoveDir.y, m_vecMoveDir.z );
AngleVectors( angMoveDir, &m_vecMoveDir );
SetMoveType( MOVETYPE_PUSH );
SetModel( STRING( GetModelName() ) );
// Don't allow zero or negative speeds
if (m_flSpeed <= 0)
{
m_flSpeed = 100;
}
// If move distance is set to zero, use with width of the
// brush to determine the size of the move distance
if (m_flMoveDistance <= 0)
{
Vector vecOBB = CollisionProp()->OBBSize();
vecOBB -= Vector( 2, 2, 2 );
m_flMoveDistance = DotProductAbs( m_vecMoveDir, vecOBB ) - m_flLip;
}
m_vecPosition1 = GetLocalOrigin() - (m_vecMoveDir * m_flMoveDistance * m_flStartPosition);
m_vecPosition2 = m_vecPosition1 + (m_vecMoveDir * m_flMoveDistance);
m_vecFinalDest = GetLocalOrigin();
SetTouch( NULL );
Precache();
AddFlag( FL_CONVEYOR );
// It is solid?
SetSolid( SOLID_VPHYSICS );
if ( FClassnameIs( this, "func_water_analog" ) )
{
AddSolidFlags( FSOLID_VOLUME_CONTENTS );
}
if ( !FClassnameIs( this, "func_water_analog" ) && FBitSet (m_spawnflags, SF_MOVELINEAR_NOTSOLID) )
{
AddSolidFlags( FSOLID_NOT_SOLID );
}
CreateVPhysics();
}
bool CFuncMoveLinear::ShouldSavePhysics( void )
{
// don't save physics for func_water_analog, regen
return !FClassnameIs( this, "func_water_analog" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CFuncMoveLinear::CreateVPhysics( void )
{
if ( !FClassnameIs( this, "func_water_analog" ) )
{
//normal door
if ( !IsSolidFlagSet( FSOLID_NOT_SOLID ) )
{
VPhysicsInitShadow( false, false );
}
}
else
{
// special contents
AddSolidFlags( FSOLID_VOLUME_CONTENTS );
//SETBITS( m_spawnflags, SF_DOOR_SILENT ); // water is silent for now
IPhysicsObject *pPhysics = VPhysicsInitShadow( false, false );
fluidparams_t fluid;
Assert( CollisionProp()->GetCollisionAngles() == vec3_angle );
fluid.damping = 0.01f;
fluid.surfacePlane[0] = 0;
fluid.surfacePlane[1] = 0;
fluid.surfacePlane[2] = 1;
fluid.surfacePlane[3] = CollisionProp()->GetCollisionOrigin().z + CollisionProp()->OBBMaxs().z - 1;
fluid.currentVelocity.Init(0,0,0);
fluid.torqueFactor = 0.1f;
fluid.viscosityFactor = 0.01f;
fluid.pGameData = static_cast<void *>(this);
//FIXME: Currently there's no way to specify that you want slime
fluid.contents = CONTENTS_WATER;
m_pFluidController = physenv->CreateFluidController( pPhysics, &fluid );
}
return true;
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CFuncMoveLinear::Precache( void )
{
if (m_soundStart != NULL_STRING)
{
PrecacheScriptSound( (char *) STRING(m_soundStart) );
}
if (m_soundStop != NULL_STRING)
{
PrecacheScriptSound( (char *) STRING(m_soundStop) );
}
m_currentSound = NULL_STRING;
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CFuncMoveLinear::MoveTo(Vector vPosition, float flSpeed)
{
if ( flSpeed != 0 )
{
if ( m_soundStart != NULL_STRING )
{
if (m_currentSound == m_soundStart)
{
StopSound(entindex(), CHAN_BODY, (char*)STRING(m_soundStop));
}
else
{
m_currentSound = m_soundStart;
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_BODY;
ep.m_pSoundName = (char*)STRING(m_soundStart);
ep.m_flVolume = 1;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
}
LinearMove( vPosition, flSpeed );
if ( m_pFluidController )
{
m_pFluidController->WakeAllSleepingObjects();
}
// Clear think (that stops sounds)
SetThink(NULL);
}
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CFuncMoveLinear::StopMoveSound( void )
{
if ( m_soundStart != NULL_STRING && ( m_currentSound == m_soundStart ) )
{
StopSound(entindex(), CHAN_BODY, (char*)STRING(m_soundStart) );
}
if ( m_soundStop != NULL_STRING && ( m_currentSound != m_soundStop ) )
{
m_currentSound = m_soundStop;
CPASAttenuationFilter filter( this );
EmitSound_t ep;
ep.m_nChannel = CHAN_BODY;
ep.m_pSoundName = (char*)STRING(m_soundStop);
ep.m_flVolume = 1;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
}
SetThink(NULL);
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CFuncMoveLinear::MoveDone( void )
{
// Stop sounds at the next think, rather than here as another
// SetPosition call might immediately follow the end of this move
SetThink(&CFuncMoveLinear::StopMoveSound);
SetNextThink( gpGlobals->curtime + 0.1f );
BaseClass::MoveDone();
if ( GetLocalOrigin() == m_vecPosition2 )
{
m_OnFullyOpen.FireOutput( this, this );
}
else if ( GetLocalOrigin() == m_vecPosition1 )
{
m_OnFullyClosed.FireOutput( this, this );
}
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CFuncMoveLinear::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( useType != USE_SET ) // Momentary buttons will pass down a float in here
return;
if ( value > 1.0 )
value = 1.0;
Vector move = m_vecPosition1 + (value * (m_vecPosition2 - m_vecPosition1));
Vector delta = move - GetLocalOrigin();
float speed = delta.Length() * 10;
MoveTo(move, speed);
}
//-----------------------------------------------------------------------------
// Purpose: Sets the position as a value from [0..1].
//-----------------------------------------------------------------------------
void CFuncMoveLinear::SetPosition( float flPosition )
{
Vector vTargetPos = m_vecPosition1 + ( flPosition * (m_vecPosition2 - m_vecPosition1));
if ((vTargetPos - GetLocalOrigin()).Length() > 0.001)
{
MoveTo(vTargetPos, m_flSpeed);
}
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CFuncMoveLinear::InputOpen( inputdata_t &inputdata )
{
if (GetLocalOrigin() != m_vecPosition2)
{
MoveTo(m_vecPosition2, m_flSpeed);
}
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
void CFuncMoveLinear::InputClose( inputdata_t &inputdata )
{
if (GetLocalOrigin() != m_vecPosition1)
{
MoveTo(m_vecPosition1, m_flSpeed);
}
}
//------------------------------------------------------------------------------
// Purpose: Input handler for setting the position from [0..1].
// Input : Float position.
//-----------------------------------------------------------------------------
void CFuncMoveLinear::InputSetPosition( inputdata_t &inputdata )
{
SetPosition( inputdata.value.Float() );
}
//-----------------------------------------------------------------------------
// Purpose: Called every frame when the bruch is blocked while moving
// Input : pOther - The blocking entity.
//-----------------------------------------------------------------------------
void CFuncMoveLinear::Blocked( CBaseEntity *pOther )
{
// Hurt the blocker
if ( m_flBlockDamage )
{
pOther->TakeDamage( CTakeDamageInfo( this, this, m_flBlockDamage, DMG_CRUSH ) );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CFuncMoveLinear::InputSetSpeed( inputdata_t &inputdata )
{
// Set the new speed
m_flSpeed = inputdata.value.Float();
// FIXME: This is a little questionable. Do we want to fix the speed, or let it continue on at the old speed?
float flDistToGoalSqr = ( m_vecFinalDest - GetLocalOrigin() ).LengthSqr();
if ( flDistToGoalSqr > Square( FLT_EPSILON ) )
{
if ( fabs( m_flSpeed ) > FLT_EPSILON )
{
// NOTE: We do NOT want to call sound functions here, just vanilla position changes
LinearMove( m_vecFinalDest, m_flSpeed );
}
else
{
// If we set our speed to 0, just move to the current position to stop.
m_flSpeed = 1.0f;
LinearMove( GetLocalOrigin(), m_flSpeed );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Draw any debug text overlays
// Output : Current text offset from the top
//-----------------------------------------------------------------------------
int CFuncMoveLinear::DrawDebugTextOverlays(void)
{
int text_offset = BaseClass::DrawDebugTextOverlays();
if (m_debugOverlays & OVERLAY_TEXT_BIT)
{
char tempstr[512];
float flTravelDist = (m_vecPosition1 - m_vecPosition2).Length();
float flCurDist = (m_vecPosition1 - GetLocalOrigin()).Length();
Q_snprintf(tempstr,sizeof(tempstr),"Current Pos: %3.3f",flCurDist/flTravelDist);
EntityText(text_offset,tempstr,0);
text_offset++;
float flTargetDist = (m_vecPosition1 - m_vecFinalDest).Length();
Q_snprintf(tempstr,sizeof(tempstr),"Target Pos: %3.3f",flTargetDist/flTravelDist);
EntityText(text_offset,tempstr,0);
text_offset++;
}
return text_offset;
}