vehicle_es_test.cpp

#include "cbase.h"
#include <string>
#include "in_buttons.h"
#include "physics.h"
#include "convar_serverbounded.h"

#ifdef CLIENT_DLL
   #include "c_prop_sfr_vehicle.h"
   #include "asw_input.h"
   #define  CPropSFRVehicle C_PropSFRVehicle
   #define CESTestVehicle C_ESTestVehicle
   #define CBasePlayer C_BasePlayer
#else
   #include "prop_sfr_vehicle.h"
#endif

static const Vector m_angTurnMax( 75.0f, 75.0f, 45.0f );
static const Vector m_angAccelMax( 110.0f, 300.0f, 140.0f );
static const Vector m_vecAccelMax( 60.0f, 30.0f, 40.0f );

class CESTestVehicle : public CPropSFRVehicle
{
public:
   DECLARE_CLASS( CESTestVehicle, CPropSFRVehicle );
   DECLARE_NETWORKCLASS();
#ifdef CLIENT_DLL
   DECLARE_PREDICTABLE();
   DECLARE_INTERPOLATION();
#else
   DECLARE_DATADESC();
#endif

   CESTestVehicle();

   virtual void Precache()
   {
      PrecacheModel( c_VEHICLE_MODEL.c_str() );
      BaseClass::Precache();
   }

   virtual bool ShouldRegenerateOriginFromCellBits()const
   {
      return false; //we don't use cells anymore
   }

   virtual void Spawn();
   void InitPhysics();
   virtual bool IsPredicted() const {return true;}
   virtual CBasePlayer  *GetPredictionOwner( void ){ return ToBasePlayer( GetPassenger( 0 ) ); }

   virtual void DriveVehicle( float flFrameTime, CUserCmd *ucmd, int iButtonsDown, int iButtonsReleased );
   //virtual void SetupMove( C_BasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move );
    void SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move );
    void ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMoveData );
    void FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move );
    void ItemPostFrame( CBasePlayer *pPlayer ); // AFAIK used for weapon stuff, though the inputs up there can be used too.

   void CommitInputs(float Interval);


#ifdef GAME_DLL
   virtual int ShouldTransmit( const CCheckTransmitInfo *pInfo );
    virtual int UpdateTransmitState();
    //void SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways );

    //  VPhysics stuff.
    virtual void VPhysicsShadowUpdate( IPhysicsObject *pPhysics );
    virtual void VPhysicsPreCollision( int index, gamevcollisionevent_t *pEvent );
    virtual void VPhysicsShadowCollision( int index, gamevcollisionevent_t *pEvent );
#endif

   virtual void VPhysicsUpdate( IPhysicsObject *pPhysics );

    //  Custom physics stuff.
    void PhysicsSimulate( void );

#ifdef CLIENT_DLL
   virtual void ClientThink();

   virtual bool ShouldPredict();
   virtual bool ShouldInterpolate();
    virtual void PostDataUpdate( DataUpdateType_t updateType );
    virtual void OnDataChanged(DataUpdateType_t type);
    virtual void UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd );

   virtual const Vector & GetRenderOrigin( void );


    // Called by prediction when it detects a prediction correction.
    // vDelta is the line from where the client had predicted the player to at the usercmd in question,
    // to where the server says the client should be at said usercmd.
    void NotePredictionError( const Vector &vDelta );

    // Called by the renderer to apply the prediction error smoothing.
    void GetPredictionErrorSmoothingVector( Vector &vOffset );

#else
   virtual void Think();
#endif
   virtual void GetVehicleViewPosition( int nRole, Vector *pOrigin, QAngle *pAngles, float *pFOV = NULL );

protected:
   static const std::string c_VEHICLE_MODEL;

   //CNetworkVar( QAngle, m_angCur );
   //CNetworkVar( QAngle, m_angTarget );
   CNetworkVector( m_vOffset );
   QAngle m_angLastViewAngles;
   AngularImpulse m_anginVehicleTurning;

   CNetworkVar( Vector, m_vVphysicsPos );
   CNetworkVar( QAngle, m_angVPhysAngles );

   CNetworkVar( Vector, m_vNetPos );
   CNetworkVar( QAngle, m_angNetAngles );

   //es
   CNetworkVector( m_vecEntityAngVelocity );
   Vector       m_vecMetersVelocity;
   Vector   input_torque;
    Vector  input_force;
   Vector m_vecCustomRenderOrigin;


#ifdef CLIENT_DLL
   Vector m_vecPredictionError;
    float m_flPredictionErrorTime;
#endif

   float m_fForce;

};

const std::string CESTestVehicle::c_VEHICLE_MODEL("models/arwing/arwing.mdl");

PRECACHE_REGISTER( CESTestVehicle );

IMPLEMENT_NETWORKCLASS_ALIASED( ESTestVehicle, DT_ESTestVehicle );

BEGIN_NETWORK_TABLE( CESTestVehicle, DT_ESTestVehicle )
#ifdef CLIENT_DLL
   //RecvPropQAngles( RECVINFO( m_angCur ) ),
   //RecvPropQAngles( RECVINFO( m_angTarget ) ),
   RecvPropVector( RECVINFO( m_vOffset ) ),
   RecvPropVector( RECVINFO( m_vVphysicsPos ) ),
   RecvPropQAngles( RECVINFO( m_angVPhysAngles ) ),
   RecvPropVector( RECVINFO( m_vNetPos ) ),
   RecvPropQAngles( RECVINFO( m_angNetAngles ) ),
   RecvPropVector( RECVINFO( m_vecEntityAngVelocity ) ),

   RecvPropVectorXY( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ), 0, C_BasePlayer::RecvProxy_LocalOriginXY ),
    RecvPropFloat( RECVINFO_NAME( m_vecNetworkOrigin[2], m_vecOrigin[2] ), 0, C_BasePlayer::RecvProxy_LocalOriginZ ),

   //RecvPropVector     ( RECVINFO_NAME( m_vecMetersVelocity, m_vecVelocity ) ),
#else
   //SendPropQAngles( SENDINFO( m_angCur ) ),
   //SendPropQAngles( SENDINFO( m_angTarget ) ),
   SendPropVector( SENDINFO( m_vOffset ) ),
   SendPropVector( SENDINFO( m_vVphysicsPos ) ),
   SendPropQAngles( SENDINFO( m_angVPhysAngles ) ),
   SendPropVector( SENDINFO( m_vNetPos ) ),
   SendPropQAngles( SENDINFO( m_angNetAngles ) ),
   SendPropVector       ( SENDINFO( m_vecEntityAngVelocity ), 16, SPROP_CHANGES_OFTEN, -256.0f, 256.0f ), // Artificially high for collisions

    // We need to send a hi-res origin to avoid prediction errors sliding along walls
    SendPropExclude( "DT_BaseEntity", "m_vecOrigin" ),
    //// send a hi-res origin to the local player for use in prediction
    ////SendPropVector  (SENDINFO(m_vecOrigin), -1,  SPROP_NOSCALE|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_Origin ),
    SendPropVectorXY(SENDINFO(m_vecOrigin),               -1, SPROP_NOSCALE | SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_OriginXY ),
    SendPropFloat   (SENDINFO_VECTORELEM(m_vecOrigin, 2), -1, SPROP_NOSCALE | SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_OriginZ ),


   //SendPropVector     ( SENDINFO( m_vecVelocity ), 32, SPROP_CHANGES_OFTEN ),
#endif
END_NETWORK_TABLE();

LINK_ENTITY_TO_CLASS( vehicle_es_test, CESTestVehicle );

#ifndef CLIENT_DLL
BEGIN_DATADESC(CESTestVehicle)

END_DATADESC();
#else
BEGIN_PREDICTION_DATA(CESTestVehicle)
   //DEFINE_PRED_FIELD( m_angCur, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
   //DEFINE_PRED_FIELD( m_angTarget, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
   DEFINE_PRED_FIELD( m_vOffset, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
   DEFINE_PRED_FIELD( m_vVphysicsPos, FIELD_VECTOR, FTYPEDESC_INSENDTABLE  ),
   DEFINE_PRED_FIELD( m_angVPhysAngles, FIELD_VECTOR, FTYPEDESC_INSENDTABLE   ),
   DEFINE_PRED_FIELD_TOL( m_vecEntityAngVelocity, FIELD_VECTOR, FTYPEDESC_INSENDTABLE, 0.5 ), // 15 bits over 1440 spread
   //DEFINE_PRED_FIELD_TOL( m_vecMetersVelocity, FIELD_VECTOR, FTYPEDESC_INSENDTABLE, 0.05 ), // 18 bits over 512 spread
END_PREDICTION_DATA();
#endif

CESTestVehicle::CESTestVehicle()
{
   m_vOffset.GetForModify().Init(0,0,0);
   //m_angCur.GetForModify().Init(0,0,0);
   m_angLastViewAngles.Init();
   m_angVPhysAngles.GetForModify().Init();
   m_vVphysicsPos.GetForModify().Init();
   m_anginVehicleTurning.Init();

   m_vecEntityAngVelocity.GetForModify().Init();
   SetPredictionEligible( true );

#ifdef CLIENT_DLL
   m_vecPredictionError.Init();
   m_flPredictionErrorTime = 0;
#endif
}

#ifdef CLIENT_DLL
   void CESTestVehicle::UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd )
   {
        // Blend the view angles.
        //int eyeAttachmentIndex = LookupAttachment( "vehicle_driver_eyes" );
        //Vector vehicleEyeOrigin;
        //QAngle vehicleEyeAngles;
        //GetAttachmentLocal( eyeAttachmentIndex, vehicleEyeOrigin, vehicleEyeAngles );

  //    QAngle outAngles;
        //InterpolateAngles( pCmd->viewangles, vehicleEyeAngles, outAngles, 1.0f );
        //pCmd->viewangles = outAngles;

      BaseClass::UpdateViewAngles(pLocalPlayer,pCmd);


   }
#endif

void CESTestVehicle::GetVehicleViewPosition( int nRole, Vector *pOrigin, QAngle *pAngles, float *pFOV )
{
   if( pOrigin )
   {
//      *pOrigin = GetAbsOrigin();
//
//#ifdef CLIENT_DLL
      Vector eyePos;
      QAngle eyeAngles;
      GetAttachment( "vehicle_driver_eyes3rd", eyePos, eyeAngles );

      *pOrigin = eyePos;
//#endif
   }

   if( pAngles )
   {
      *pAngles = GetAbsAngles();/* + m_angCur;*/
   }

   if( pFOV )
   {
      *pFOV = 110.0f;
   }
}

#ifdef CLIENT_DLL
   void CESTestVehicle::ClientThink()
#else
   void CESTestVehicle::Think()
#endif
{
   #ifdef CLIENT_DLL
   //if( !physenv )
   //   return;
   //else if( !VPhysicsGetObject() )
   //   InitPhysics();

   //Draw Client entity pos
   NDebugOverlay::Cross3DOriented( GetAbsOrigin(), GetAbsAngles(), 10.0f, 0, 255, 0, true, 0.0f);

   #else

   //Draw Server entity pos
   NDebugOverlay::Cross3DOriented( GetAbsOrigin(), GetAbsAngles(), 10.0f, 255, 0, 0, true, 0.0f);

   #endif

    //SetSimulationTime( gpGlobals->curtime );
    //SetNextThink( gpGlobals->curtime );
    //SetAnimatedEveryTick( true );

   //if( VPhysicsGetObject() )
   //{
      //Vector pos = GetAbsOrigin();
      //QAngle ang = GetAbsAngles();

   //   //Draw Vphysics entity pos
   //   NDebugOverlay::Cross3DOriented( pos, ang, 10.0f, 128, 128, 0, true, 0.0f );

   //#ifdef CLIENT_DLL
   //   Vector Smoothed;
   //   Smoothed = VectorLerp( m_vVphysicsPos.Get(), pos, 1.0f/gpGlobals->frametime );
   //   SetAbsOrigin(Smoothed);
   //   SetAbsAngles(m_angVPhysAngles.Get());
   //#else
   //   m_vVphysicsPos = pos;
   //   m_angVPhysAngles = ang;
   //#endif
   //}


   //if( VPhysicsGetObject() )
   //{
   //   m_anginVehicleTurning = m_anginVehicleTurning * 10.0f;

   //   Vector vel, forward;
   //   GetVectors( &forward, NULL, NULL );
   //   vel = m_fForce * forward;

   //   VPhysicsGetObject()->SetVelocity( &vel, &m_anginVehicleTurning );
   //}

#ifdef CLIENT_DLL
   BaseClass::ClientThink();
#else
   BaseClass::Think();
#endif
}

void CESTestVehicle::Spawn()
{
   PrecacheModel( c_VEHICLE_MODEL.c_str() );
   SetModel( c_VEHICLE_MODEL.c_str() );
   //PrecacheModel( c_VEHICLE_MODEL.c_str() );
   BaseClass::Spawn();
   m_fForce = 0;

#ifdef CLIENT_DLL
   SetNextClientThink( CLIENT_THINK_ALWAYS );
#else
   SetSolid( SOLID_VPHYSICS );
    SetSolidFlags( 0 );

   InitPhysics(); //init on server this early, wait for the client
#endif

}



void CESTestVehicle::InitPhysics()
{
   //SetSimulatedEveryTick(true);
#ifdef GAME_DLL
   VPhysicsDestroyObject();

   solid_t solid;
   PhysModelParseSolid( solid, this, GetModelIndex() );
   IPhysicsObject *pPhysicsObject =  PhysModelCreate( this, GetModelIndex(), GetAbsOrigin(), GetAbsAngles(), &solid );//VPhysicsInitNormal( SOLID_VPHYSICS, 0, false, &solid );

   //Set physics flags
   Assert( pPhysicsObject );
    PhysSetGameFlags( pPhysicsObject, FVPHYSICS_NO_SELF_COLLISIONS );

   pPhysicsObject->EnableGravity( false );
   pPhysicsObject->EnableDrag( false );
   pPhysicsObject->SetCallbackFlags( CALLBACK_GLOBAL_COLLISION | CALLBACK_SHADOW_COLLISION | CALLBACK_GLOBAL_FRICTION );

    //// Setup Defaults
    VPhysicsSetObject( pPhysicsObject );

    pPhysicsObject->SetShadow( 1024.0f, 1024.0f, true, true );
    pPhysicsObject->GetShadowController()->SetPhysicallyControlled( true );
    pPhysicsObject->GetShadowController()->SetTeleportDistance( 0.0f );

    pPhysicsObject->EnableCollisions( true );
    pPhysicsObject->Wake();

    PhysAddShadow( this );
#endif
}

void CESTestVehicle::DriveVehicle( float flFrameTime, CUserCmd *ucmd, int iButtonsDown, int iButtonsReleased )
{
}


//-----------------------------------------------------------------------------
// Do the move (apply usercmd to vehicle/physics here)
//-----------------------------------------------------------------------------

void CESTestVehicle::SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move )
{
    if( GetPassenger(0) == player )
    {

        #define SCALEINPUT( x ) x > 0 ? (float)( x * x ) * ( 1.0f / ( 128.0f * 128.0f ) ) : (float)( x * x ) * ( -1.0f / ( 128.0f * 128.0f ) )
      input_torque.Init( 0 , SCALEINPUT(ucmd->mouse_control_axis.y), -SCALEINPUT(ucmd->mouse_control_axis.x) /*-SCALEINPUT(ucmd->mouse_control_axis.z)*/ );
      input_force.Init( -SCALEINPUT( ( ucmd->buttons & IN_FORWARD )? 128.0f : 0.0f ), 0, 0 );
        #undef SCALEINPUT

        #ifdef CLIENT_DLL
           //SetAbsVelocity( m_vecMetersVelocity );
      #else
            engine->Con_NPrintf( 4, "input_torque x: %f y: %f z: %f", input_torque.x, input_torque.y, input_torque.z );
            engine->Con_NPrintf( 6, "mouse_control_axis x: %i y: %i z: %i", ucmd->mouse_control_axis.x, ucmd->mouse_control_axis.y, ucmd->mouse_control_axis.z );
            engine->Con_NPrintf( 8, "input_force x: %f y: %f z: %f", input_force.x, input_force.y, input_force.z );
        #endif
    }
}

//-----------------------------------------------------------------------------
// Process movement functions
//-----------------------------------------------------------------------------

void CESTestVehicle::ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMoveData )
{
    //  Not sure what this function does.  I think it's safe to stub for now.
    // Run the move and update the velocity of the craft
    if ( GetPassenger(0) == pPlayer )
    {
        CommitInputs( gpGlobals->frametime );
    }
}

void CESTestVehicle::PhysicsSimulate( void )
{
   BaseClass::PhysicsSimulate();
#ifdef GAME_DLL // This could be shared, but it could be causing hitching and desync
    //BaseClass::PhysicsSimulate();

    //Vector origin = GetAbsOrigin();

    //if( origin.x >= MAX_COORD_INTEGER ||
    //  origin.y >= MAX_COORD_INTEGER ||
    //  origin.z >= MAX_COORD_INTEGER ||
    //  origin.x <= MIN_COORD_INTEGER ||
    //  origin.y <= MIN_COORD_INTEGER ||
    //  origin.z <= MIN_COORD_INTEGER || enginetrace->GetPointContents( origin ) == CONTENTS_SOLID )
    //{
    //  Warning("Out of world ship was cleaned up\n");
    //  Event_Killed( CTakeDamageInfo( this, this, m_iMaxHealth, DMG_NEVERGIB ) );
    //  return;
    //}


    //if( !GetPassenger(0) ) // No players present
    //{
    //  input_force = vec3_origin;
    //  input_torque = vec3_origin;

    //  if( GetAbsVelocity() != vec3_origin || m_vecEntityAngVelocity != vec3_origin )
    //      CommitInputs( gpGlobals->frametime );
    //}
#endif
}

void CESTestVehicle::VPhysicsUpdate( IPhysicsObject *pPhysics )
{
   BaseClass::VPhysicsUpdate( pPhysics );
}

//-----------------------------------------------------------------------------
// Finish movement functions
//-----------------------------------------------------------------------------

void CESTestVehicle::FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move )
{
    if( GetPassenger(0) == player )
    {
#ifdef CLIENT_DLL
        SetNetworkOrigin( GetLocalOrigin() );
        SetNetworkAngles( GetLocalAngles() );

        // For prediction
        //m_vecMetersVelocity = GetAbsVelocity();
#else

        PhysicsTouchTriggers();
      PhysicsRelinkChildren( gpGlobals->frametime );
#endif
    }
}

//-----------------------------------------------------------------------------
// Post-frame player processing
//-----------------------------------------------------------------------------

void CESTestVehicle::ItemPostFrame( CBasePlayer *player )
{
   BaseClass::ItemPostFrame(player);
}

/*  This is what sdk_playermove.cpp has to say about these functions:

SetupMove:
This is called pre player movement and copies all the data necessary from the player for movement.
(Server-side, the client-side version of this code can be found in prediction.cpp.)

FinishMove:
This is called post player movement to copy back all data that movement could have modified and that
is necessary for future movement. (Server-side, the client-side version of this code can be found
in prediction.cpp.)

*/

/*  Guesstimates about what the functions do:

SetupMove:
Called before player movement code, to handle commands

ProcessMovement:
Called after player movement code; now has access to processed player movements.
Not relevant for us because we don't rely on player movement.

*/

void CESTestVehicle::CommitInputs(float Interval)
{
    // Ok, it's time to redo this flying code, and write long comments like this one
    // The main idea behind this is to go for full arcade flight
    // with a bit of a newtonian flare on the "cut engines" key
    // so what we will do is rotate the velocity vector, rather than do all the acceleration shit
    // that will allow us to use realistic accels for translational without compromising turn speed

    // Define a bunch of vectors over here
    Vector localvelocity, accel;
    AngularImpulse angaccel(0,0,0);

    {
        // Speed depends on wether or not turbo is on
        float flSpeedMax = 100.0f;

        VectorIRotate( GetAbsVelocity(), EntityToWorldTransform(), localvelocity );

        // Just regular turning for angles
        VectorMultiply( m_angTurnMax, input_torque, angaccel );
        angaccel -= m_vecEntityAngVelocity.Get();  //  "angaccel" and "angular" are angular velocities
        angaccel /= Interval;  //  "angaccel" now an angular acceleration
        angaccel.x = MIN( m_angAccelMax.x, angaccel.x );
      angaccel.y = MIN( m_angAccelMax.y, angaccel.y );
      angaccel.z = MIN( m_angAccelMax.z, angaccel.z );

        // Poor man's normalization. Basically projects the box to a circle
        // Its not perfect, but it works (problem is being at 0.7 x and 0.7 y is the same as 1 x and 1 y)
        float vel = input_force.LengthSqr();
        if( vel > 1.0f )
            input_force *= FastRSqrt( vel );

        accel = input_force * flSpeedMax - localvelocity; //  "accel" now a velocity delta in local space
        //  Note: here and in the VectorMultiply following are the only
        //  cases in which a specific input parameter is referenced.
        accel /= Interval;  //  "accel" now an acceleration
        accel.x = MIN( m_vecAccelMax.x, accel.x );  //  Clamp to max
      accel.y = MIN( m_vecAccelMax.y, accel.y );  //  Clamp to max
      accel.z = MIN( m_vecAccelMax.z, accel.z );  //  Clamp to max

        accel *= Interval;
        angaccel *= Interval;
        localvelocity += accel;
        m_vecEntityAngVelocity += angaccel;

        QAngle angvel;
        matrix3x4_t AngVel, output, localToWorld;

        AngularImpulseToQAngle( m_vecEntityAngVelocity, angvel );

#ifdef CLIENT_DLL
        AngleMatrix( GetNetworkAngles(), localToWorld ); // Nothing lost here, it gets done if you call EntityToWorld too
#else
        AngleMatrix( GetLocalAngles(), localToWorld ); // Nothing lost here, it gets done if you call EntityToWorld too
#endif
        AngleMatrix( angvel * Interval, AngVel );
        ConcatTransforms( localToWorld, AngVel, output );
        MatrixAngles( output, angvel );
#ifdef CLIENT_DLL
        // This should fix pred errors
        angvel[0] = anglemod(angvel[0]);
        angvel[1] = anglemod(angvel[1]);
        angvel[2] = anglemod(angvel[2]);
#endif

        SetAbsAngles( angvel );

        // NOTE: output is the new angle, this bypasses all the slippage inducing stuff by hard clamping the rotation
        VectorRotate( localvelocity, output, accel );
        SetAbsVelocity( accel );

   #ifdef GAME_DLL
      engine->Con_NPrintf( 10, "server velocity x: %f y: %f z: %f", GetLocalVelocity().x, GetLocalVelocity().y, GetLocalVelocity().z );
   #else
      engine->Con_NPrintf( 12, "client velocity x: %f y: %f z: %f", GetLocalVelocity().x, GetLocalVelocity().y, GetLocalVelocity().z );
   #endif
    }

    //m_iEngineBits = EngineBits( input_force );


#ifdef CLIENT_DLL
    Vector origin = GetNetworkOrigin() + GetAbsVelocity() *  TICK_INTERVAL;
   //DevMsg( "Client New Origin ( %f, %f, %f )\n", origin.x, origin.y, origin.z );
#else
    Vector origin = GetLocalOrigin() + GetAbsVelocity() *  TICK_INTERVAL;
   //DevMsg( "Server New Origin ( %f, %f, %f )\n", origin.x, origin.y, origin.z );
#endif

   SetLocalOrigin( origin );


#ifdef GAME_DLL
    if( VPhysicsGetObject() )
    {
        VPhysicsGetObject()->UpdateShadow( GetAbsOrigin(), GetAbsAngles(), false, TICK_INTERVAL );
    }
#endif
}

//-----------------------------------------------------------------------------
// VPhysics stuff
//-----------------------------------------------------------------------------
#ifdef GAME_DLL

   int  CESTestVehicle::UpdateTransmitState()
   {
       // always call ShouldTransmit() for maines
       //return SetTransmitState( FL_EDICT_FULLCHECK );
       return SetTransmitState( FL_EDICT_ALWAYS );
   }

   int CESTestVehicle::ShouldTransmit( const CCheckTransmitInfo *pInfo )
   {
       // asw temp
       return FL_EDICT_ALWAYS;

       // always transmit if we're inhabited by the target client
       if ( GetPassenger(0) && pInfo->m_pClientEnt == GetPassenger(0)->edict() )
       {
           return FL_EDICT_ALWAYS;
       }

       return BaseClass::ShouldTransmit( pInfo );
   }



   void CESTestVehicle::VPhysicsPreCollision( int index, gamevcollisionevent_t *pEvent )
   {
       pEvent->pObjects[index]->SetVelocity( &(GetAbsVelocity() ), &m_vecEntityAngVelocity.Get() );
   }

   void CESTestVehicle::VPhysicsShadowCollision( int index, gamevcollisionevent_t *pEvent )
   {
       Vector velocity; QAngle angles;
       pEvent->pObjects[index]->GetPosition( &velocity, &angles );
       SetAbsOrigin( velocity );
       SetAbsAngles( angles );
       AngularImpulse angvel;
       pEvent->pObjects[index]->GetVelocity( &velocity, &angvel );
       SetAbsVelocity( velocity );
       m_vecEntityAngVelocity = angvel;

       Vector damagePos;
       pEvent->pInternalData->GetContactPoint( damagePos );
       Vector damageForce = pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass();
       if ( damageForce == vec3_origin )
       {
           // This can happen if this entity is a func_breakable, and can't move.
           // Use the velocity of the entity that hit us instead.
           damageForce = pEvent->postVelocity[!index] * pEvent->pObjects[!index]->GetMass();
       }

       //int otherIndex = !index;
       //CBaseEntity *pOther = pEvent->pEntities[otherIndex];

       //// We're to take normal damage from this
       //int damageType;
       //float damage = CalculateDefaultPhysicsDamage( index, pEvent, (IsInSpace()?ES_SCALEFACTOR*4.0f:4.0f/ES_SCALEFACTOR), true, damageType );
       //if ( damage > 0 )
       //{
       //   CTakeDamageInfo dmgInfo( pOther, pOther, damageForce, damagePos, damage, damageType | DMG_TACTICAL_SHIP );
       //   PhysCallbackDamage( this, dmgInfo, *pEvent, index );

       //   CBasePlayer *player = dynamic_cast< CBasePlayer * >( GetPassenger() );
       //   if( player )
       //   {
       //       CSingleUserRecipientFilter filter( player );
       //       EmitSound( filter, entindex(),  "Cockpit.ImpactAlarm" );
       //   }
       //}
   }

   void CESTestVehicle::VPhysicsShadowUpdate( IPhysicsObject *pPhysics )
   {
       Vector origin = GetAbsOrigin();

       if ( pPhysics->GetGameFlags() & FVPHYSICS_PENETRATING || pPhysics->GetContactPoint( NULL, NULL ) )
       {
           Vector velocity, angvel; QAngle angles;
           pPhysics->GetPosition( &velocity, &angles );
           SetAbsOrigin( velocity );
           SetAbsAngles( angles );

           PhysicsTouchTriggers( &origin );
         PhysicsRelinkChildren(gpGlobals->frametime);
       }
   }
#endif


#ifdef CLIENT_DLL
   const Vector & CESTestVehicle::GetRenderOrigin( void )
   {
      //Vector vOrigin;

      m_vecCustomRenderOrigin = GetAbsOrigin();// - ( GetAbsOrigin() - GetNetworkOrigin() ) + (GetAbsVelocity() * TICK_INTERVAL);

       // Apply a smoothing offset to smooth out prediction errors.
       Vector vSmoothOffset;
       GetPredictionErrorSmoothingVector( vSmoothOffset );
       m_vecCustomRenderOrigin += vSmoothOffset;

      //NDebugOverlay::Cross3DOriented( m_vecCustomRenderOrigin, GetAbsAngles(), 10.0f, 0, 0, 255, true, 0.0f);

      return  m_vecCustomRenderOrigin;
   }

   bool CESTestVehicle::ShouldPredict()
   {
       C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();

       if( !player )
           return false;

      if( GetPassenger(0) == player && gpGlobals->maxClients > 1 ) //MP only
           return true;

       return false;
   }

   bool CESTestVehicle::ShouldInterpolate( void )
   {
      if( gpGlobals->maxClients == 1 ) //MP only
         return false;

       C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
       if ( player && player->GetVehicle() && static_cast<CESTestVehicle *>(player->GetVehicle()->GetVehicleEnt() ) == this )
           return true;
       return BaseClass::ShouldInterpolate();
   }

   void CESTestVehicle::PostDataUpdate( DataUpdateType_t updateType )
   {
       BaseClass::PostDataUpdate( updateType );
   }

   void CESTestVehicle::OnDataChanged( DataUpdateType_t type )
   {
       BaseClass::OnDataChanged( type );

       if( type == DATA_UPDATE_CREATED )
       {
           //m_nType = GetVehicleInfo()->nRole;
           //m_vecAccelMax = GetVehicleInfo()->vecAccel;
           //m_angAccelMax = GetVehicleInfo()->vecAngularAccel;
           //m_flSpeedMax = GetVehicleInfo()->flMaxSpeed; // Updated later
           //m_flBoostMax = GetVehicleInfo()->flMaxBoostSpeed;
           //m_angTurnMax = GetVehicleInfo()->angTurnMax;

           //CreateVPhysics();

           MDLCACHE_CRITICAL_SECTION();

           //m_VehicleFX.Init( this );

           SetNextClientThink( CLIENT_THINK_ALWAYS );
       }

       UpdateVisibility();

       //if( m_iOldTeamNum != GetTeamNumber() )
       //{
       //   m_VehicleFX.InitTeam();
       //   m_iOldTeamNum = GetTeamNumber();
       //}
   }


   void CESTestVehicle::NotePredictionError( const Vector &vDelta )
   {
       // don't worry about prediction errors when dead
       if ( !GetPassenger(0) )
           return;

   #if !defined( NO_ENTITY_PREDICTION )
       Vector vOldDelta;

      GetPredictionErrorSmoothingVector( vOldDelta );

       // sum all errors within smoothing time
       m_vecPredictionError = vDelta + vOldDelta;

       // remember when last error happened
       m_flPredictionErrorTime = gpGlobals->curtime;

       ResetLatched();
   #endif
   }


   //extern ConVar cl_smooth;
   extern ConVar_ServerBounded *cl_predict;
   //extern ConVar cl_smoothtime;
   extern ConVar_ServerBounded *cl_interp;

   void CESTestVehicle::GetPredictionErrorSmoothingVector( Vector &vOffset )
   {
      ConVarRef cl_smooth("cl_smooth");
      ConVarRef cl_smoothtime("cl_smoothtime");
   #if !defined( NO_ENTITY_PREDICTION )
       if ( engine->IsPlayingDemo() || !cl_smooth.GetInt() || !cl_predict->GetInt() || engine->IsPaused() )
       {
           vOffset.Init();
           return;
       }

       float errorAmount = ( gpGlobals->curtime - m_flPredictionErrorTime ) / cl_smoothtime.GetFloat();

       if ( errorAmount >= 1.0f )
       {
           vOffset.Init();
           return;
       }

       errorAmount = 1.0f - errorAmount;

       vOffset = m_vecPredictionError * errorAmount;
   #else
       vOffset.Init();
   #endif

   //   vOffset.Init();
   //#if !defined( NO_ENTITY_PREDICTION )
   //   // don't worry about prediction errors when dead
   //   if ( !GetPassenger(0) )
   //   {
   //       return;
   //   }
   //
   //   C_BasePlayer * player = dynamic_cast<C_BasePlayer *>(GetPassenger(0) );
   //   Assert(player);
   //   player->GetPredictionErrorSmoothingVector( vOffset );
   //#endif
   }

#endif