forked from FWGS/Paranoia2
576 lines
14 KiB
C++
576 lines
14 KiB
C++
|
|
/*********************************************************
|
|
* Closed mod Physical entity: Original code of Nucleo *
|
|
**********************************************************/
|
|
|
|
|
|
#include "extdll.h"
|
|
#include "util.h"
|
|
#include "cbase.h"
|
|
#include "saverestore.h"
|
|
#include "func_break.h"
|
|
#include "decals.h"
|
|
#include "explode.h"
|
|
|
|
extern DLL_GLOBAL Vector g_vecAttackDir;
|
|
|
|
#define M_PI 3.141592653589793238462643 //NCL: Correct It!
|
|
|
|
// NCL: Based On "func_breakable"
|
|
class CPhy : public CBreakable
|
|
{
|
|
public:
|
|
void Spawn ( void );
|
|
void Precache( void );
|
|
void EXPORT PushableThink( void );
|
|
void Touch ( CBaseEntity *pOther );
|
|
void Move( CBaseEntity *pMover, int push );
|
|
void KeyValue( KeyValueData *pkvd );
|
|
void Solid( void );
|
|
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
|
|
void EXPORT StopSound( void );
|
|
|
|
virtual int ObjectCaps( void ) { return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_CONTINUOUS_USE; }
|
|
virtual int Save( CSave &save );
|
|
virtual int Restore( CRestore &restore );
|
|
void SetModelCollisionBox( void );
|
|
|
|
void TestBeam( Vector org, Vector end, Vector color, int life, int width );
|
|
|
|
inline float MaxSpeed( void ) { return m_maxSpeed; }
|
|
|
|
// NCL: Если стоит флаг Breakable
|
|
virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
|
|
|
|
static TYPEDESCRIPTION m_SaveData[];
|
|
|
|
int m_lastSound;
|
|
float m_maxSpeed;
|
|
float m_soundTime;
|
|
};
|
|
|
|
TYPEDESCRIPTION CPhy::m_SaveData[] =
|
|
{
|
|
DEFINE_FIELD( CPhy, m_maxSpeed, FIELD_FLOAT ),
|
|
DEFINE_FIELD( CPhy, m_soundTime, FIELD_TIME ),
|
|
};
|
|
|
|
IMPLEMENT_SAVERESTORE( CPhy, CBreakable );
|
|
|
|
// NCL: Temporary name
|
|
LINK_ENTITY_TO_CLASS( func_physbox, CPhy );
|
|
|
|
void CPhy :: Spawn( void )
|
|
{
|
|
// NCL: Brushes only
|
|
Vector vecMins = pev->mins;
|
|
Vector vecMaxs = pev->maxs;
|
|
|
|
CBreakable::Spawn();
|
|
|
|
pev->movetype = MOVETYPE_BOUNCE;//MOVETYPE_PUSHSTEP;
|
|
pev->solid = SOLID_SLIDEBOX;
|
|
|
|
// NCL: UNDONE! If developer sets path to the model file
|
|
SET_MODEL( ENT(pev), STRING(pev->model) );
|
|
// NCL: Model needs collision! I Can do it, but i'm lazy... =)
|
|
|
|
if ( pev->friction > 399 )
|
|
pev->friction = 399;
|
|
|
|
m_maxSpeed = 400 - pev->friction;
|
|
SetBits( pev->flags, FL_FLOAT );
|
|
|
|
pev->friction = 0.5;
|
|
pev->gravity = 1;
|
|
|
|
pev->origin.z += 1; // NCL: Pick up it to fix collision bug
|
|
|
|
UTIL_SetOrigin( this, pev->origin );
|
|
|
|
SetThink(&CPhy:: PushableThink );
|
|
pev->nextthink = 0.1;
|
|
|
|
// Multiply by area of the box's cross-section (assume 1000 units^3 standard volume)
|
|
pev->skin = ( pev->skin * (pev->maxs.x - pev->mins.x) * (pev->maxs.y - pev->mins.y) ) * 0.0005;
|
|
m_soundTime = 0;
|
|
}
|
|
|
|
void CPhy::SetModelCollisionBox(void)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
void CPhy :: Precache( void )
|
|
{
|
|
|
|
//PRECACHE_MODEL(pev->model); // Temporary unused.
|
|
CBreakable::Precache( );
|
|
|
|
}
|
|
|
|
|
|
void CPhy :: KeyValue( KeyValueData *pkvd )
|
|
{
|
|
|
|
// NCL: UnDone! Physics needs more parameters!
|
|
if ( FStrEq(pkvd->szKeyName, "size") ) // NCL: Id developer sets size manually
|
|
{
|
|
int bbox = atoi(pkvd->szValue);
|
|
pkvd->fHandled = TRUE;
|
|
|
|
SetModelCollisionBox();
|
|
|
|
}
|
|
else if ( FStrEq(pkvd->szKeyName, "skin") ) // NCL: Brushes needs a skinning?
|
|
{
|
|
pev->skin = atof(pkvd->szValue);
|
|
pkvd->fHandled = TRUE;
|
|
}
|
|
else
|
|
CBreakable::KeyValue( pkvd );
|
|
}
|
|
|
|
|
|
void CPhy :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
|
|
{
|
|
if ( !pActivator || !pActivator->IsPlayer() )
|
|
{
|
|
this->CBreakable::Use( pActivator, pCaller, useType, value );
|
|
return;
|
|
}
|
|
|
|
if ( pActivator->pev->velocity != g_vecZero )
|
|
Move( pActivator, 0 );
|
|
}
|
|
|
|
/*
|
|
===================
|
|
AngleBetweenVectors
|
|
===================
|
|
*/
|
|
|
|
float AngleBetweenVectors( const vec3_t v1, const vec3_t v2 )
|
|
{
|
|
float angle;
|
|
float l1 = v1.Length();
|
|
float l2 = v2.Length();
|
|
|
|
if ( !l1 || !l2 )
|
|
return 0.0f;
|
|
|
|
angle = acos( DotProduct( v1, v2 ) / (l1*l2) );
|
|
angle = ( angle * 180.0f ) / M_PI;
|
|
|
|
return angle;
|
|
}
|
|
|
|
void NormalizeAngles( float *angles )
|
|
{
|
|
int i;
|
|
// NCL: Normalize angles. It needs to update.
|
|
for ( i = 0; i < 3; i++ )
|
|
{
|
|
if ( angles[i] > 180.0 )
|
|
{
|
|
angles[i] -= 360.0;
|
|
}
|
|
else if ( angles[i] < -180.0 )
|
|
{
|
|
angles[i] += 360.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CPhy :: PushableThink( void )
|
|
{
|
|
// pev->velocity = pev->velocity * 0.8;
|
|
// pev->avelocity = pev->avelocity * 0.8;
|
|
// ALERT( at_debug, "Angles yaw: %3.2f\n", pev->angles.y );
|
|
|
|
/* if( pev->angles.x >= 360 )
|
|
pev->angles.x -= 360;
|
|
if( pev->angles.x >= -360 )
|
|
pev->angles.x += 360;*/
|
|
|
|
//if( pev->flags & FL_ONGROUND )
|
|
//{
|
|
|
|
// pev->avelocity = pev->avelocity;// * 5.5;
|
|
|
|
//}
|
|
|
|
// SetNextThink( 0.1 );
|
|
pev->nextthink = 0.1;
|
|
}
|
|
|
|
void CPhy :: Touch( CBaseEntity *pOther )
|
|
{
|
|
Vector savedangles = Vector( 0, 0, 0 );
|
|
int negate = 0;
|
|
TraceResult tr;
|
|
// look down directly to know the surface we're lying.
|
|
UTIL_TraceLine( pev->origin, pev->origin - Vector(0,0,64), ignore_monsters, edict(), &tr );
|
|
|
|
pev->velocity = pev->velocity * 0.8;
|
|
// pev->avelocity = pev->avelocity * 0.5;
|
|
|
|
if( !(pev->flags & FL_ONGROUND) )
|
|
{
|
|
//pev->avelocity.x = RANDOM_FLOAT( -400, 400 );// NCL: Enable it to fun =)
|
|
|
|
//NCL: no sound, temporary.
|
|
if (pev->frags == 0)
|
|
{
|
|
// You can place sounds here...
|
|
}
|
|
}
|
|
else
|
|
/******
|
|
This code is nice, but has a bug:
|
|
The angles of the entity it's normalized, but if you touch or move the entity, and if it have another initial
|
|
angle, the entity will move too quickly in the reverse angle.
|
|
|
|
Look that:
|
|
1- We have a stand barrel.
|
|
|
|
------
|
|
||||||
|
|
| |
|
|
| |
|
|
| |
|
|
------
|
|
|
|
2- and you hit the barrel and the barrel fall of and it's lie on the ground
|
|
|
|
-----------
|
|
| ||
|
|
| ||
|
|
-----------
|
|
|
|
3- Well, do a simple touch to the barrel...
|
|
|
|
-----------
|
|
|| |
|
|
|| |
|
|
-----------
|
|
|
|
If you have a barrel, don't make any diference, but if you have a more complex object (a monitor i suposed),
|
|
you will see the bug.
|
|
|
|
It's too hard to explain, you need see it...
|
|
******/
|
|
{
|
|
for( int i = 0; i<3; i++ )
|
|
{
|
|
if( pev->angles.x < 0 )
|
|
negate = 1;
|
|
|
|
if( fabs(pev->angles.x) < 45 )
|
|
savedangles.x = 0;
|
|
else if( fabs(pev->angles.x) >= 45 && fabs(pev->angles.x) <= 135 )
|
|
savedangles.x = 90;
|
|
else if( fabs(pev->angles.x) > 135 && fabs(pev->angles.x) <= 180 )
|
|
savedangles.x = 180;
|
|
}
|
|
|
|
#ifndef M_PI
|
|
#define M_PI 3.1415926535897932384626433832795 //NCL: Correct It!
|
|
#endif
|
|
#define ang2rad (2 * M_PI / 360)
|
|
|
|
if ( tr.flFraction < 1.0 )
|
|
{
|
|
Vector forward, right, angdir, angdiry;
|
|
Vector Angles = pev->angles;
|
|
|
|
NormalizeAngles( Angles );
|
|
|
|
UTIL_MakeVectorsPrivate( Angles, forward, right, NULL );
|
|
angdir = forward;
|
|
Vector left = -right;
|
|
angdiry = left;
|
|
|
|
pev->angles.x = -UTIL_VecToAngles( angdir - DotProduct(angdir, tr.vecPlaneNormal) * tr.vecPlaneNormal).x;
|
|
pev->angles.y = UTIL_VecToAngles( angdir - DotProduct(angdir, tr.vecPlaneNormal) * tr.vecPlaneNormal).y;
|
|
|
|
pev->angles.z = UTIL_VecToAngles( angdiry - DotProduct(angdiry, tr.vecPlaneNormal) * tr.vecPlaneNormal).x;
|
|
|
|
pev->angles.z = UTIL_VecToAngles( angdiry - DotProduct(angdiry, tr.vecPlaneNormal) * right ).x;
|
|
}
|
|
|
|
#undef ang2rad
|
|
|
|
if( negate )
|
|
pev->angles.x -= savedangles.x;
|
|
else
|
|
pev->angles.x += savedangles.x;
|
|
}
|
|
|
|
|
|
if ( FClassnameIs( pOther->pev, "worldspawn" ) )
|
|
return;
|
|
|
|
Move( pOther, 1 );
|
|
}
|
|
|
|
|
|
void CPhy :: Move( CBaseEntity *pOther, int push )
|
|
{
|
|
entvars_t* pevToucher = pOther->pev;
|
|
int playerTouch = 0;
|
|
|
|
// Is entity standing on this pushable ?
|
|
if ( FBitSet(pevToucher->flags,FL_ONGROUND) && pevToucher->groundentity && VARS(pevToucher->groundentity) == pev )
|
|
{
|
|
// Only push if floating
|
|
if ( pev->waterlevel > 0 && pev->watertype > CONTENT_FLYFIELD)
|
|
pev->velocity.z += pevToucher->velocity.z * 0.1;
|
|
|
|
return;
|
|
}
|
|
|
|
if ( pOther->IsPlayer() )
|
|
{
|
|
if ( push && !(pevToucher->button & (IN_FORWARD|IN_USE)) ) // Don't push unless the player is pushing forward and NOT use (pull)
|
|
return;
|
|
playerTouch = 1;
|
|
}
|
|
|
|
float factor;
|
|
|
|
if ( playerTouch )
|
|
{
|
|
if ( !(pevToucher->flags & FL_ONGROUND) ) // Don't push away from jumping/falling players unless in water
|
|
{
|
|
if ( pev->waterlevel < 1 || pev->watertype <= CONTENT_FLYFIELD)
|
|
// {
|
|
// pOther->TakeDamage(pev, pev, 30, DMG_PARALYZE | DMG_NEVERGIB);
|
|
return;
|
|
// }
|
|
else
|
|
// {
|
|
factor = 0.1;
|
|
// }
|
|
}
|
|
else
|
|
factor = 1;
|
|
}
|
|
else
|
|
factor = 0.25;
|
|
|
|
if (!push)
|
|
factor = factor*0.1;
|
|
|
|
pev->velocity.x += pevToucher->velocity.x * factor;
|
|
pev->velocity.y += pevToucher->velocity.y * factor;
|
|
|
|
float length = sqrt( pev->velocity.x * pev->velocity.x + pev->velocity.y * pev->velocity.y );
|
|
if ( push && (length > MaxSpeed()) )
|
|
{
|
|
pev->velocity.x = (pev->velocity.x * MaxSpeed() / length );
|
|
pev->velocity.y = (pev->velocity.y * MaxSpeed() / length );
|
|
}
|
|
if ( playerTouch )
|
|
{
|
|
pevToucher->velocity.x = pev->velocity.x;
|
|
pevToucher->velocity.y = pev->velocity.y;
|
|
if ( (gpGlobals->time - m_soundTime) > 0.7 )
|
|
{
|
|
m_soundTime = gpGlobals->time;
|
|
if ( length > 0 && FBitSet(pev->flags,FL_ONGROUND) )
|
|
{
|
|
/******
|
|
Sys:
|
|
A big hack...
|
|
When you move the entity, it will make a sound.
|
|
|
|
There are 6 materials type:
|
|
-No defined (no material) The entity doesn't make any sound.
|
|
-Metal (metal rough sound)
|
|
-Plaster (a plastic tube sound)
|
|
-Glass (UNDONE: glass move sound??)
|
|
-Cement (concrete sound)
|
|
-Wood (wood sound)
|
|
*******/
|
|
if (pev->frags == 0)
|
|
{
|
|
//no sound
|
|
}
|
|
|
|
if (pev->frags == 1) //metal
|
|
{
|
|
|
|
}
|
|
|
|
if (pev->frags == 2) //plaster
|
|
{
|
|
|
|
}
|
|
|
|
if (pev->frags == 3) { }//glass
|
|
|
|
if (pev->frags == 4) //cemento
|
|
{
|
|
|
|
}
|
|
|
|
if (pev->frags == 5) //wood
|
|
{
|
|
|
|
}
|
|
// SetThink( StopSound );
|
|
// pev->nextthink = 0.1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
void CPhy::StopSound( void )
|
|
{
|
|
Vector dist = pev->oldorigin - pev->origin;
|
|
if ( dist.Length() <= 0 )
|
|
STOP_SOUND( ENT(pev), CHAN_WEAPON, m_soundNames[m_lastSound] );
|
|
}
|
|
#endif
|
|
|
|
void CPhy :: TestBeam( Vector org, Vector end, Vector color, int life, int width )
|
|
{
|
|
extern short g_sModelIndexLaser;
|
|
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
|
|
WRITE_BYTE( TE_BEAMPOINTS );
|
|
WRITE_COORD( org.x );
|
|
WRITE_COORD( org.y );
|
|
WRITE_COORD( org.z );
|
|
|
|
WRITE_COORD( end.x );
|
|
WRITE_COORD( end.y );
|
|
WRITE_COORD( end.z );
|
|
WRITE_SHORT( g_sModelIndexLaser );
|
|
WRITE_BYTE( 0 ); // framerate
|
|
WRITE_BYTE( 0 ); // framerate
|
|
|
|
WRITE_BYTE( life ); // life
|
|
WRITE_BYTE( width ); // width
|
|
|
|
WRITE_BYTE( 0 ); // noise
|
|
WRITE_BYTE( color.x ); // r, g, b
|
|
WRITE_BYTE( color.y ); // r, g, b
|
|
WRITE_BYTE( color.z ); // r, g, b
|
|
WRITE_BYTE( 160 ); // brightness
|
|
WRITE_BYTE( 0 ); // speed
|
|
MESSAGE_END();
|
|
}
|
|
|
|
int CPhy :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
|
|
{
|
|
Vector vecDir, r, anorm, rforward, rup, rright;
|
|
float a;
|
|
float force = flDamage * 10;
|
|
TraceResult trace = UTIL_GetGlobalTrace( );
|
|
UTIL_MakeVectors( pev->angles );
|
|
|
|
// grab the vector of the incoming attack. ( pretend that the inflictor is a little lower than it really is, so the body will tend to fly upward a bit).
|
|
vecDir = r = Vector( 0, 0, 0 );
|
|
if (!FNullEnt( pevInflictor ))
|
|
{
|
|
if ( FClassnameIs( pevInflictor, "projectile" ) )
|
|
pevInflictor = VARS( pevInflictor->owner );
|
|
|
|
CBaseEntity *pInflictor = CBaseEntity :: Instance( pevInflictor );
|
|
if (pInflictor)
|
|
{
|
|
vecDir = g_vecAttackDir = ( trace.vecEndPos - pInflictor->Center() ).Normalize();
|
|
r = ( trace.vecEndPos - Center() ).Normalize();
|
|
}
|
|
}
|
|
|
|
anorm = UTIL_VecToAngles( r );
|
|
NormalizeAngles( r );
|
|
anorm.x = -anorm.x;
|
|
UTIL_MakeVectorsPrivate( anorm, rforward, rright, rup );
|
|
|
|
|
|
if (pev->frags == 1) //metal
|
|
{
|
|
//if ( bitsDamageType & (DMG_BULLET | DMG_CLUB) )
|
|
if ( ( bitsDamageType & DMG_BULLET)|| ( bitsDamageType & DMG_CLUB) )
|
|
{
|
|
UTIL_Ricochet( trace.vecEndPos, 0.5 );
|
|
|
|
switch (RANDOM_LONG(0,2))
|
|
{
|
|
case 0: EMIT_SOUND(ENT(pev), CHAN_BODY, "fisica/metal/b_impact1.wav", 0.9, ATTN_NORM); break;
|
|
case 1: EMIT_SOUND(ENT(pev), CHAN_BODY, "fisica/metal/b_impact2.wav", 0.9, ATTN_NORM); break;
|
|
case 2: EMIT_SOUND(ENT(pev), CHAN_BODY, "fisica/metal/b_impact3.wav", 0.9, ATTN_NORM); break;
|
|
}
|
|
|
|
//int color, int count, int speed, int velocityRange//PARAMs
|
|
|
|
// StreakSplash( trace.vecEndPos, trace.vecPlaneNormal, 6, 20, 50, 400 );//REFERENCE
|
|
// if (RANDOM_LONG( 0, 99 ) < 40)
|
|
// UTIL_Sparks( trace.vecEndPos, trace.vecPlaneNormal, 0, 5, 500, 500 );//chispas
|
|
// UTIL_Sparks( trace.vecEndPos, trace.vecPlaneNormal, 9, 5, 5, 100 );//puntos
|
|
// UTIL_Sparks( trace.vecEndPos, trace.vecPlaneNormal, 0, 5, 500, 20 );//chispas
|
|
|
|
}
|
|
}
|
|
|
|
if (pev->frags == 3) //glass
|
|
UTIL_Ricochet( trace.vecEndPos, 0.5 );
|
|
|
|
if (pev->frags == 4) //cement
|
|
UTIL_Sparks( trace.vecEndPos );
|
|
|
|
if (pev->frags == 5) //wood
|
|
{
|
|
switch (RANDOM_LONG(0,2))
|
|
{
|
|
case 0: EMIT_SOUND(ENT(pev), CHAN_VOICE, "debris/wood1.wav", 0.9, ATTN_NORM); break;
|
|
case 1: EMIT_SOUND(ENT(pev), CHAN_VOICE, "debris/wood2.wav", 0.9, ATTN_NORM); break;
|
|
case 2: EMIT_SOUND(ENT(pev), CHAN_VOICE, "debris/wood3.wav", 0.9, ATTN_NORM); break;
|
|
}
|
|
}
|
|
|
|
// if ( bitsDamageType & DMG_BULLET )
|
|
/*******
|
|
Sys: What the ....
|
|
|
|
If the material is "plaster" let's do more movement.
|
|
*******/
|
|
//if (pev->frags == 2) //plastico
|
|
//{
|
|
force *= 0.8;
|
|
pev->avelocity.z = cos( AngleBetweenVectors( vecDir, rup ) ) * force * 1;
|
|
//}
|
|
//else// Isn't plaster
|
|
//{
|
|
// if ( ( bitsDamageType & DMG_BULLET)|| ( bitsDamageType & DMG_CLUB) )
|
|
// force *= 0.5;
|
|
//}
|
|
|
|
pev->flags &= ~FL_ONGROUND;
|
|
//pev->origin.z += 1;
|
|
|
|
pev->avelocity.x = cos( AngleBetweenVectors( vecDir, rup ) ) * 100;
|
|
pev->avelocity.y = cos( AngleBetweenVectors( vecDir, -rright ) ) * 200;
|
|
// pev->avelocity.z = cos( AngleBetweenVectors( vecDir, -rup ) ) * 200;
|
|
|
|
// pev->avelocity.z = cos( AngleBetweenVectors( vecDir, rup ) ) * force * 2;//fooz
|
|
// pev->avelocity.z = sin( AngleBetweenVectors( vecDir, rup ) ) * force * 2;//fooz
|
|
|
|
ALERT( at_console, "X : %3.1f %3.1f° Y: %3.1f %3.1f°\n", pev->avelocity.x, AngleBetweenVectors( vecDir, rup ), pev->avelocity.y, AngleBetweenVectors( vecDir, -rright ) );
|
|
|
|
pev->velocity = pev->velocity /*+ gpGlobals->v_up * force * RANDOM_FLOAT( 0, 0.5 )*/ + vecDir * force * RANDOM_FLOAT( 0.5, 1.0 );
|
|
|
|
pev->velocity = pev->velocity + gpGlobals->v_up * force * RANDOM_FLOAT( 0, 0.5 ) + vecDir * force * RANDOM_FLOAT( 0.5, 1.0 );
|
|
|
|
//if ( pev->spawnflags & SF_PUSH_BREAKABLE )
|
|
// return CBreakable::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
|
|
|
|
return 1;
|
|
}
|
|
|