nullprop/halflife-photomode
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions
halflife-photomode/dlls/vehicle.cpp

1114 lines
28 KiB
C++
Raw Normal View History

[HL25] Backport func_vehicle entity
2024-08-28 15:17:52 +02:00
#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "trains.h"
#include "saverestore.h"
#include "weapons.h"
static float Fix2(float angle)
{
while (angle < 0)
angle += 360;
while (angle > 360)
angle -= 360;
return angle;
}
static void FixupAngles2(Vector& v)
{
v.x = Fix2(v.x);
v.y = Fix2(v.y);
v.z = Fix2(v.z);
}
// ---------------------------------------------------------------------
//
// Counter-Strike drivable vehicles.
//
// ---------------------------------------------------------------------
#define VEHICLE_STARTPITCH 60
#define VEHICLE_MAXPITCH 200
#define VEHICLE_MAXSPEED 1500 // approx max speed for sound pitch calculation
TYPEDESCRIPTION CFuncVehicle::m_SaveData[] =
{
DEFINE_FIELD(CFuncVehicle, m_ppath, FIELD_CLASSPTR),
DEFINE_FIELD(CFuncVehicle, m_length, FIELD_FLOAT),
DEFINE_FIELD(CFuncVehicle, m_height, FIELD_FLOAT),
DEFINE_FIELD(CFuncVehicle, m_speed, FIELD_FLOAT),
DEFINE_FIELD(CFuncVehicle, m_dir, FIELD_FLOAT),
DEFINE_FIELD(CFuncVehicle, m_startSpeed, FIELD_FLOAT),
DEFINE_FIELD(CFuncVehicle, m_controlMins, FIELD_VECTOR),
DEFINE_FIELD(CFuncVehicle, m_controlMaxs, FIELD_VECTOR),
DEFINE_FIELD(CFuncVehicle, m_sounds, FIELD_INTEGER),
DEFINE_FIELD(CFuncVehicle, m_flVolume, FIELD_FLOAT),
DEFINE_FIELD(CFuncVehicle, m_flBank, FIELD_FLOAT),
DEFINE_FIELD(CFuncVehicle, m_oldSpeed, FIELD_FLOAT),
};
IMPLEMENT_SAVERESTORE(CFuncVehicle, CBaseEntity);
LINK_ENTITY_TO_CLASS(func_vehicle, CFuncVehicle);
bool CFuncVehicle::KeyValue(KeyValueData* pkvd)
{
if (FStrEq(pkvd->szKeyName, "length"))
{
m_length = atof(pkvd->szValue);
return true;
}
if (FStrEq(pkvd->szKeyName, "width"))
{
m_width = atof(pkvd->szValue);
return true;
}
else if (FStrEq(pkvd->szKeyName, "height"))
{
m_height = atof(pkvd->szValue);
return true;
}
else if (FStrEq(pkvd->szKeyName, "startspeed"))
{
m_startSpeed = atof(pkvd->szValue);
return true;
}
else if (FStrEq(pkvd->szKeyName, "sounds"))
{
m_sounds = atoi(pkvd->szValue);
return true;
}
else if (FStrEq(pkvd->szKeyName, "volume"))
{
m_flVolume = (float)(atoi(pkvd->szValue));
m_flVolume *= 0.1;
return true;
}
else if (FStrEq(pkvd->szKeyName, "bank"))
{
m_flBank = atof(pkvd->szValue);
return true;
}
else if (FStrEq(pkvd->szKeyName, "acceleration"))
{
m_acceleration = atoi(pkvd->szValue);
if (m_acceleration < 1)
m_acceleration = 1;
else if (m_acceleration > 10)
m_acceleration = 10;
return true;
}
else
return CBaseEntity::KeyValue(pkvd);
}
void CFuncVehicle ::NextThink(float thinkTime, bool alwaysThink)
{
if (alwaysThink)
pev->flags |= FL_ALWAYSTHINK;
else
pev->flags &= ~FL_ALWAYSTHINK;
pev->nextthink = thinkTime;
}
void CFuncVehicle ::Blocked(CBaseEntity* pOther)
{
entvars_t* pevOther = pOther->pev;
// Blocker is on-ground on the train
if (FBitSet(pevOther->flags, FL_ONGROUND) && VARS(pevOther->groundentity) == pev)
{
pevOther->velocity = pev->velocity;
return;
float deltaSpeed = fabs(pev->speed);
if (deltaSpeed > 50)
deltaSpeed = 50;
if (!pevOther->velocity.z)
pevOther->velocity.z += deltaSpeed;
return;
}
else
{
pevOther->velocity = (pevOther->origin - pev->origin).Normalize() * pev->dmg;
pevOther->velocity.z += 300;
// slow down vehicle
pev->velocity = pev->velocity * 0.85;
}
ALERT(at_console, "TRAIN(%s): Blocked by %s (dmg:%.2f)\n", STRING(pev->targetname), STRING(pOther->pev->classname), pev->dmg);
// we can't hurt this thing, so we're not concerned with it
UTIL_MakeVectors(pev->angles);
Vector vFrontLeft, vFrontRight, vBackLeft, vBackRight;
Vector forward = (gpGlobals->v_forward * -1) * (m_length / 2); // for some stupid reason I have to invert this...
Vector right = (gpGlobals->v_right * -1) * (m_width / 2);
vFrontLeft = pev->origin + forward - right;
vFrontRight = pev->origin + forward + right;
vBackLeft = pev->origin - forward - right;
vBackRight = pev->origin - forward + right;
Vector vOrigin = pOther->pev->origin;
float minx, miny, minz;
float maxx, maxy, maxz;
minx = V_min(vFrontLeft.x, vBackRight.x);
maxx = V_max(vFrontLeft.x, vBackRight.x);
miny = V_min(vFrontLeft.y, vBackRight.y);
maxy = V_max(vFrontLeft.y, vBackRight.y);
minz = pev->origin.z;
maxz = pev->origin.z + abs(pev->mins.z - pev->maxs.z) * 2;
// Check if the target is out of the bounds of the vehicle...
if (((vOrigin.x < minx) || (vOrigin.x > maxx)) || ((vOrigin.y < miny) || (vOrigin.y > maxy)) || ((vOrigin.z < minz) || (vOrigin.z > maxz)))
pOther->TakeDamage(pev, pev, 150, DMG_CRUSH);
}
void CFuncVehicle ::Use(CBaseEntity* pActivator, CBaseEntity* pCaller, USE_TYPE useType, float value)
{
if (useType != USE_SET)
{
if (!ShouldToggle(useType, (pev->speed != 0)))
return;
if (pev->speed == 0)
{
pev->speed = m_speed * m_dir;
Next();
}
else
{
pev->speed = 0;
pev->velocity = g_vecZero;
pev->avelocity = g_vecZero;
StopSound();
SetThink(NULL);
}
}
else
{
if (value < 10) // It's either forward or backward
{
if ((value < 0) && (pev->speed > 145))
{
StopSound();
}
float delta = value;
float flSpeedRatio;
if (delta > 0) // accelerating
{
flSpeedRatio = (pev->speed / m_speed);
if (pev->speed < 0)
delta = flSpeedRatio + (0.015 / 3) + (m_acceleration * 0.0005);
else if (pev->speed < 10)
delta = flSpeedRatio + (0.015 / 7) + (m_acceleration * 0.0006);
else if (pev->speed < 20)
delta = flSpeedRatio + (0.02 / 6) + (m_acceleration * 0.0007);
else if (pev->speed < 30)
delta = flSpeedRatio + (0.025 / 6) + (m_acceleration * 0.0007);
else if (pev->speed < 45)
delta = flSpeedRatio + (0.02 / 5) + (m_acceleration * 0.0007);
else if (pev->speed < 60)
delta = flSpeedRatio + (0.019 / 5) + (m_acceleration * 0.0008);
else if (pev->speed < 80)
delta = flSpeedRatio + (0.018 / 4) + (m_acceleration * 0.0008);
else if (pev->speed < 100)
delta = flSpeedRatio + (0.017 / 4) + (m_acceleration * 0.0009);
else if (pev->speed < 150)
delta = flSpeedRatio + (0.016 / 6) + (m_acceleration * 0.0008);
else if (pev->speed < 225)
delta = flSpeedRatio + (0.016 / 7) + (m_acceleration * 0.0007);
else if (pev->speed < 300)
delta = flSpeedRatio + (0.015 / 8) + (m_acceleration * 0.0006);
else if (pev->speed < 400)
delta = flSpeedRatio + (0.013 / 9) + (m_acceleration * 0.0005);
else if (pev->speed < 550)
delta = flSpeedRatio + (0.012 / 10) + (m_acceleration * 0.0005);
else if (pev->speed < 800)
delta = flSpeedRatio + (0.011 / 12) + (m_acceleration * 0.0005);
}
else if (delta < 0) // braking
{
flSpeedRatio = pev->speed / m_speed;
if (flSpeedRatio > 0)
delta = flSpeedRatio - 0.05 / 4;
else if ((flSpeedRatio <= 0) && (flSpeedRatio > -0.05)) // Just started accelerating
delta = flSpeedRatio - 0.03 / 4;
else if ((flSpeedRatio <= 0.05) && (flSpeedRatio > -0.1))
delta = flSpeedRatio - 0.04 / 4;
else if ((flSpeedRatio <= 0.15) && (flSpeedRatio > -0.15))
delta = flSpeedRatio - 0.05 / 4;
else if ((flSpeedRatio <= 0.15) && (flSpeedRatio > -0.22))
delta = flSpeedRatio - 0.055 / 4;
else if ((flSpeedRatio <= 0.22) && (flSpeedRatio > -0.3))
delta = flSpeedRatio - 0.07 / 4;
else if (flSpeedRatio <= 0.3)
delta = flSpeedRatio - 0.05 / 4;
}
if (delta > 1)
delta = 1;
else if (delta < -0.35)
delta = -0.35;
pev->speed = m_speed * delta;
Next();
m_flAcceleratorDecay = gpGlobals->time + 0.25;
}
else
{
if (m_flCanTurnNow < gpGlobals->time)
{
if (value == 20) // turn left!
{
m_iTurnAngle += 1;
m_flSteeringWheelDecay = gpGlobals->time + 0.075;
if (m_iTurnAngle > 8)
m_iTurnAngle = 8;
}
else if (value == 30) // turn right
{
m_iTurnAngle -= 1;
m_flSteeringWheelDecay = gpGlobals->time + 0.075;
if (m_iTurnAngle < -8)
m_iTurnAngle = -8;
}
m_flCanTurnNow = gpGlobals->time + 0.05;
}
}
}
}
void CFuncVehicle ::StopSound(void)
{
// if sound playing, stop it
if (m_soundPlaying && pev->noise)
{
unsigned short us_encode;
unsigned short us_sound = ((unsigned short)(m_sounds) & 0x0007) << 12;
us_encode = us_sound;
PLAYBACK_EVENT_FULL(FEV_RELIABLE | FEV_UPDATE, edict(), m_usAdjustPitch, 0.0,
(float*)&g_vecZero, (float*)&g_vecZero, 0.0, 0.0, us_encode, 0, 1, 0);
}
m_soundPlaying = 0;
}
// update pitch based on speed, start sound if not playing
// NOTE: when train goes through transition, m_soundPlaying should go to 0,
// which will cause the looped sound to restart.
void CFuncVehicle ::UpdateSound(void)
{
float flpitch;
if (!pev->noise)
return;
flpitch = VEHICLE_STARTPITCH + (abs(pev->speed) * (VEHICLE_MAXPITCH - VEHICLE_STARTPITCH) / VEHICLE_MAXSPEED);
if (flpitch > VEHICLE_MAXPITCH)
flpitch = VEHICLE_MAXPITCH;
if (!m_soundPlaying)
{
// play startup sound for train
if (m_sounds < 5)
EMIT_SOUND_DYN(ENT(pev), CHAN_ITEM, "plats/vehicle_brake1.wav", m_flVolume, ATTN_NORM, 0, 100);
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise), m_flVolume, ATTN_NORM, 0, (int)flpitch);
m_soundPlaying = 1;
}
else
{
/*
// update pitch
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise), m_flVolume, ATTN_NORM, SND_CHANGE_PITCH, (int) flpitch);
*/
// volume 0.0 - 1.0 - 6 bits
// m_sounds 3 bits
// flpitch = 6 bits
// 15 bits total
unsigned short us_encode;
unsigned short us_sound = ((unsigned short)(m_sounds) & 0x0007) << 12;
unsigned short us_pitch = ((unsigned short)(flpitch / 10.0) & 0x003f) << 6;
unsigned short us_volume = ((unsigned short)(m_flVolume * 40.0) & 0x003f);
us_encode = us_sound | us_pitch | us_volume;
PLAYBACK_EVENT_FULL(FEV_UPDATE, edict(), m_usAdjustPitch, 0.0,
(float*)&g_vecZero, (float*)&g_vecZero, 0.0, 0.0, us_encode, 0, 0, 0);
}
}
void CFuncVehicle ::CheckTurning(void)
{
float maxspeed;
TraceResult tr;
bool bTurnIntoWall = false;
// Check to see if he's trying to turn into a wall
if (m_iTurnAngle < 0) // He's trying to turn right
{
if (pev->speed > 0)
{
UTIL_TraceLine(m_vFrontRight, m_vFrontRight - (gpGlobals->v_right * 16), ignore_monsters, dont_ignore_glass, ENT(pev), &tr);
if (tr.flFraction != 1.0)
{
m_iTurnAngle = 1;
}
}
else if (pev->speed < 0)
{
UTIL_TraceLine(m_vBackLeft, m_vBackLeft + (gpGlobals->v_right * 16), ignore_monsters, dont_ignore_glass, ENT(pev), &tr);
if (tr.flFraction != 1.0)
{
m_iTurnAngle = 1;
}
}
}
else if (m_iTurnAngle > 0)
{
if (pev->speed > 0)
{
UTIL_TraceLine(m_vFrontLeft, m_vFrontLeft + (gpGlobals->v_right * 16), ignore_monsters, dont_ignore_glass, ENT(pev), &tr);
if (tr.flFraction != 1.0)
{
m_iTurnAngle = -1;
}
}
else if (pev->speed < 0)
{
UTIL_TraceLine(m_vBackRight, m_vBackRight - (gpGlobals->v_right * 16), ignore_monsters, dont_ignore_glass, ENT(pev), &tr);
if (tr.flFraction != 1.0)
{
m_iTurnAngle = -1;
}
}
}
if (pev->speed > 0)
{
if (abs(m_iTurnAngle) > 4) // Doing a hard turn
{
if (m_flTurnStartTime == -1) // just started turning
{
m_flTurnStartTime = gpGlobals->time;
maxspeed = (float)m_speed;
}
else if ((gpGlobals->time - m_flTurnStartTime) >= 0.0)
{
maxspeed = (float)m_speed * 0.98;
}
else if ((gpGlobals->time - m_flTurnStartTime) > 0.3)
{
maxspeed = (float)m_speed * 0.95;
}
else if ((gpGlobals->time - m_flTurnStartTime) > 0.6)
{
maxspeed = (float)m_speed * 0.9;
}
else if ((gpGlobals->time - m_flTurnStartTime) > 0.8)
{
maxspeed = (float)m_speed * 0.8;
}
else if ((gpGlobals->time - m_flTurnStartTime) > 1)
{
maxspeed = (float)m_speed * 0.7;
}
else if ((gpGlobals->time - m_flTurnStartTime) > 1.2)
{
maxspeed = (float)m_speed * 0.5;
}
}
else if (abs(m_iTurnAngle) > 2)
{
m_flTurnStartTime = -1;
maxspeed = (float)m_speed * 0.9;
}
else
{
maxspeed = (float)m_speed;
m_flTurnStartTime = -1;
}
if (pev->speed > maxspeed)
{
pev->speed -= m_speed / 10;
}
}
}
void CFuncVehicle ::CollisionDetection(void)
{
TraceResult tr;
bool bHitSomething = false;
// Check to see if there's anything in front of us
if (pev->speed < 0) // We're going backwards
{
// Check back left portion of vehicle if we hit a wall
UTIL_TraceLine(m_vBackLeft, m_vBackLeft + (gpGlobals->v_forward * 16), ignore_monsters, dont_ignore_glass, ENT(pev), &tr);
if (tr.flFraction != 1.0)
{
bHitSomething = true;
if ((DotProduct(tr.vecPlaneNormal, gpGlobals->v_forward * -1) < 0.7) && (tr.vecPlaneNormal.z < 0.1)) // slightly vertical wall... skid along it
{
m_vSurfaceNormal = tr.vecPlaneNormal;
m_vSurfaceNormal.z = 0;
pev->speed = pev->speed * 0.99;
}
else if ((tr.vecPlaneNormal.z < 0.65) || (tr.fStartSolid))
pev->speed = pev->speed * -1;
else
m_vSurfaceNormal = tr.vecPlaneNormal;
CBaseEntity* pHit = CBaseEntity::Instance(tr.pHit);
if (pHit && (pHit->Classify() == CLASS_VEHICLE))
ALERT(at_console, "I hit another vehicle\n");
}
if (bHitSomething == false)
{
UTIL_TraceLine(m_vBackRight, m_vBackRight + (gpGlobals->v_forward * 16), ignore_monsters, dont_ignore_glass, ENT(pev), &tr);
if (tr.flFraction != 1.0)
{
bHitSomething = true;
if ((DotProduct(tr.vecPlaneNormal, gpGlobals->v_forward * -1) < 0.7) && (tr.vecPlaneNormal.z < 0.1)) // slightly vertical wall... skid along it
{
m_vSurfaceNormal = tr.vecPlaneNormal;
m_vSurfaceNormal.z = 0;
pev->speed = pev->speed * 0.99;
}
else if ((tr.vecPlaneNormal.z < 0.65) || (tr.fStartSolid))
pev->speed = pev->speed * -1;
else
m_vSurfaceNormal = tr.vecPlaneNormal;
}
}
if (bHitSomething == false)
{
UTIL_TraceLine(m_vBack, m_vBack + (gpGlobals->v_forward * 16), ignore_monsters, dont_ignore_glass, ENT(pev), &tr);
if (tr.flFraction != 1.0)
{
if ((DotProduct(tr.vecPlaneNormal, gpGlobals->v_forward * -1) < 0.7) && (tr.vecPlaneNormal.z < 0.1)) // slightly vertical wall... skid along it
{
m_vSurfaceNormal = tr.vecPlaneNormal;
m_vSurfaceNormal.z = 0;
pev->speed = pev->speed * 0.99;
}
else if ((tr.vecPlaneNormal.z < 0.65) || (tr.fStartSolid))
pev->speed = pev->speed * -1;
else
m_vSurfaceNormal = tr.vecPlaneNormal;
}
}
}
else if (pev->speed > 0)
{
// Check front left portion of vehicle
UTIL_TraceLine(m_vFrontLeft, m_vFrontLeft - (gpGlobals->v_forward * 16), dont_ignore_monsters, dont_ignore_glass, ENT(pev), &tr);
if (tr.flFraction != 1.0)
{
bHitSomething = true;
if ((DotProduct(tr.vecPlaneNormal, gpGlobals->v_forward * -1) > -0.7) && (tr.vecPlaneNormal.z < 0.1)) // slightly vertical wall... skid along it
{
m_vSurfaceNormal = tr.vecPlaneNormal;
m_vSurfaceNormal.z = 0;
pev->speed = pev->speed * 0.99;
}
else if ((tr.vecPlaneNormal.z < 0.65) || (tr.fStartSolid))
pev->speed = pev->speed * -1;
else
m_vSurfaceNormal = tr.vecPlaneNormal;
}
if (bHitSomething == false)
{
UTIL_TraceLine(m_vFrontRight, m_vFrontRight - (gpGlobals->v_forward * 16), ignore_monsters, dont_ignore_glass, ENT(pev), &tr);
if (tr.flFraction != 1.0)
{
bHitSomething = true;
if ((DotProduct(tr.vecPlaneNormal, gpGlobals->v_forward * -1) > -0.7) && (tr.vecPlaneNormal.z < 0.1)) // slightly vertical wall... skid along it
{
m_vSurfaceNormal = tr.vecPlaneNormal;
m_vSurfaceNormal.z = 0;
pev->speed = pev->speed * 0.99;
}
else if ((tr.vecPlaneNormal.z < 0.65) || (tr.fStartSolid))
pev->speed = pev->speed * -1;
else
m_vSurfaceNormal = tr.vecPlaneNormal;
}
}
if (bHitSomething == false)
{
UTIL_TraceLine(m_vFront, m_vFront - (gpGlobals->v_forward * 16), ignore_monsters, dont_ignore_glass, ENT(pev), &tr);
if (tr.flFraction != 1.0)
{
bHitSomething = true;
if ((DotProduct(tr.vecPlaneNormal, gpGlobals->v_forward * -1) > -0.7) && (tr.vecPlaneNormal.z < 0.1)) // slightly vertical wall... skid along it
{
m_vSurfaceNormal = tr.vecPlaneNormal;
m_vSurfaceNormal.z = 0;
pev->speed = pev->speed * 0.99;
}
else if ((tr.vecPlaneNormal.z < 0.65) || (tr.fStartSolid))
pev->speed = pev->speed * -1;
else
m_vSurfaceNormal = tr.vecPlaneNormal;
}
}
}
}
void CFuncVehicle ::TerrainFollowing(void)
{
TraceResult tr;
// Get the normal of the surface we're right on top of
UTIL_TraceLine(pev->origin, pev->origin + Vector(0, 0, -1 * (m_height + 48)), ignore_monsters, dont_ignore_glass, ENT(pev), &tr);
if (tr.flFraction != 1.0) // we hit something
{
m_vSurfaceNormal = tr.vecPlaneNormal;
}
else if (tr.fInWater)
{
m_vSurfaceNormal = Vector(0, 0, 1);
}
else if (tr.fStartSolid)
{
// ALERT(at_console,"I'm underground\n!");
}
}
void CFuncVehicle ::Next(void)
{
Vector vGravityVector = g_vecZero;
UTIL_MakeVectors(pev->angles);
Vector forward = (gpGlobals->v_forward * -1) * (m_length / 2); // for some stupid reason I have to invert this...
Vector right = (gpGlobals->v_right * -1) * (m_width / 2);
Vector up = (gpGlobals->v_up) * 16;
m_vFrontLeft = pev->origin + forward - right + up;
m_vFrontRight = pev->origin + forward + right + up;
m_vFront = pev->origin + forward + up;
m_vBackLeft = pev->origin - forward - right + up;
m_vBackRight = pev->origin - forward + right + up;
m_vBack = pev->origin - forward + up;
m_vSurfaceNormal = g_vecZero;
// Check to see if we're hitting something...and alter the vehicles velocity.
CheckTurning();
float time = 0.1;
if (m_flSteeringWheelDecay < gpGlobals->time)
{
m_flSteeringWheelDecay = gpGlobals->time + 0.1;
if (m_iTurnAngle < 0)
m_iTurnAngle++;
else if (m_iTurnAngle > 0)
m_iTurnAngle--;
}
if (m_flAcceleratorDecay < gpGlobals->time)
{
m_flAcceleratorDecay = gpGlobals->time + 0.1;
if (pev->speed < 0)
{
pev->speed += 20;
if (pev->speed > 0)
pev->speed = 0;
}
else if (pev->speed > 0)
{
pev->speed -= 20;
if (pev->speed < 0)
pev->speed = 0;
}
}
if (!pev->speed)
{
m_iTurnAngle = 0;
pev->avelocity = g_vecZero;
pev->velocity = g_vecZero;
// StopSound();
SetThink(&CFuncVehicle::Next);
NextThink(pev->ltime + time, true);
return;
}
else
{
TerrainFollowing();
CollisionDetection();
if (m_vSurfaceNormal != g_vecZero)
{
m_vVehicleDirection = CrossProduct(m_vSurfaceNormal, (gpGlobals->v_forward));
m_vVehicleDirection = CrossProduct(m_vSurfaceNormal, m_vVehicleDirection);
Vector vTargetAngle, vAngle;
float vx, vy;
vTargetAngle = UTIL_VecToAngles(m_vVehicleDirection);
vTargetAngle.y += 180;
vAngle = pev->angles;
if (m_iTurnAngle != 0)
vTargetAngle.y += m_iTurnAngle;
FixupAngles2(vTargetAngle);
FixupAngles2(vAngle);
vx = UTIL_AngleDistance(vTargetAngle.x, vAngle.x);
vy = UTIL_AngleDistance(vTargetAngle.y, vAngle.y);
if (vx > 10)
vx = 10;
else if (vx < -10)
vx = -10;
if (vy > 10)
vy = 10;
else if (vy < -10)
vy = -10;
pev->avelocity.y = (int)(vy * 10);
pev->avelocity.x = (int)(vx * 10);
// reset launch time to -1
m_flLaunchTime = -1;
m_flLastNormalZ = m_vSurfaceNormal.z;
}
else
{
time = 0.1;
if (m_flLaunchTime == -1)
{
m_flLaunchTime = gpGlobals->time;
vGravityVector = Vector(0, 0, 0);
pev->velocity = pev->velocity * 1.5;
}
else
{
float flAirTime;
flAirTime = gpGlobals->time - m_flLaunchTime;
vGravityVector = Vector(0, 0, flAirTime * -35);
if (vGravityVector.z < -400)
vGravityVector.z = -400;
}
m_vVehicleDirection = gpGlobals->v_forward * -1;
}
Vector temp;
temp = UTIL_VecToAngles(m_vVehicleDirection);
if (m_flUpdateSound < gpGlobals->time)
{
UpdateSound();
m_flUpdateSound = gpGlobals->time + 1;
}
if (m_vSurfaceNormal != g_vecZero)
{
pev->velocity = pev->speed * m_vVehicleDirection.Normalize();
}
else
{
pev->velocity = pev->velocity + vGravityVector;
}
SetThink(&CFuncVehicle::Next);
NextThink(pev->ltime + time, true);
return;
}
/************************************************/
}
void CFuncVehicle::DeadEnd(void)
{
// Fire the dead-end target if there is one
CPathTrack *pTrack, *pNext;
pTrack = m_ppath;
ALERT(at_aiconsole, "TRAIN(%s): Dead end ", STRING(pev->targetname));
// Find the dead end path node
// HACKHACK -- This is bugly, but the train can actually stop moving at a different node depending on it's speed
// so we have to traverse the list to it's end.
if (pTrack)
{
if (m_oldSpeed < 0)
{
do
{
pNext = pTrack->ValidPath(pTrack->GetPrevious(), true);
if (pNext)
pTrack = pNext;
} while (pNext);
}
else
{
do
{
pNext = pTrack->ValidPath(pTrack->GetNext(), true);
if (pNext)
pTrack = pNext;
} while (pNext);
}
}
pev->velocity = g_vecZero;
pev->avelocity = g_vecZero;
if (pTrack)
{
ALERT(at_aiconsole, "at %s\n", STRING(pTrack->pev->targetname));
if (pTrack->pev->netname)
FireTargets(STRING(pTrack->pev->netname), this, this, USE_TOGGLE, 0);
}
else
ALERT(at_aiconsole, "\n");
}
void CFuncVehicle ::SetControls(entvars_t* pevControls)
{
Vector offset = pevControls->origin - pev->oldorigin;
m_controlMins = pevControls->mins + offset;
m_controlMaxs = pevControls->maxs + offset;
}
bool CFuncVehicle ::OnControls(entvars_t* pevTest)
{
Vector offset = pevTest->origin - pev->origin;
if (pev->spawnflags & SF_TRACKTRAIN_NOCONTROL)
return false;
// Transform offset into local coordinates
UTIL_MakeVectors(pev->angles);
Vector local;
local.x = DotProduct(offset, gpGlobals->v_forward);
local.y = -DotProduct(offset, gpGlobals->v_right);
local.z = DotProduct(offset, gpGlobals->v_up);
if (local.x >= m_controlMins.x && local.y >= m_controlMins.y && local.z >= m_controlMins.z &&
local.x <= m_controlMaxs.x && local.y <= m_controlMaxs.y && local.z <= m_controlMaxs.z)
return true;
return false;
}
void CFuncVehicle ::Find(void)
{
m_ppath = CPathTrack::Instance(FIND_ENTITY_BY_TARGETNAME(NULL, STRING(pev->target)));
if (!m_ppath)
return;
entvars_t* pevTarget = m_ppath->pev;
if (!FClassnameIs(pevTarget, "path_track"))
{
ALERT(at_console, "func_track_train must be on a path of path_track\n");
m_ppath = NULL;
return;
}
Vector nextPos = pevTarget->origin;
nextPos.z += m_height;
Vector look = nextPos;
look.z -= m_height;
m_ppath->LookAhead(&look, m_length, 0);
look.z += m_height;
pev->angles = UTIL_VecToAngles(look - nextPos);
// The train actually points west
pev->angles.y += 180;
if (pev->spawnflags & SF_TRACKTRAIN_NOPITCH)
pev->angles.x = 0;
UTIL_SetOrigin(pev, nextPos);
NextThink(pev->ltime + 0.1, false);
SetThink(&CFuncVehicle::Next);
pev->speed = m_startSpeed;
UpdateSound();
}
void CFuncVehicle ::NearestPath(void)
{
CBaseEntity* pTrack = NULL;
CBaseEntity* pNearest = NULL;
float dist, closest;
closest = 1024;
while ((pTrack = UTIL_FindEntityInSphere(pTrack, pev->origin, 1024)) != NULL)
{
// filter out non-tracks
if (!(pTrack->pev->flags & (FL_CLIENT | FL_MONSTER)) && FClassnameIs(pTrack->pev, "path_track"))
{
dist = (pev->origin - pTrack->pev->origin).Length();
if (dist < closest)
{
closest = dist;
pNearest = pTrack;
}
}
}
if (!pNearest)
{
ALERT(at_console, "Can't find a nearby track !!!\n");
SetThink(NULL);
return;
}
ALERT(at_aiconsole, "TRAIN: %s, Nearest track is %s\n", STRING(pev->targetname), STRING(pNearest->pev->targetname));
// If I'm closer to the next path_track on this path, then it's my real path
pTrack = ((CPathTrack*)pNearest)->GetNext();
if (pTrack)
{
if ((pev->origin - pTrack->pev->origin).Length() < (pev->origin - pNearest->pev->origin).Length())
pNearest = pTrack;
}
m_ppath = (CPathTrack*)pNearest;
if (pev->speed != 0)
{
NextThink(pev->ltime + 0.1, false);
SetThink(&CFuncVehicle::Next);
}
}
void CFuncVehicle::OverrideReset()
{
NextThink(pev->ltime + 0.1, false);
SetThink(&CFuncVehicle::NearestPath);
}
CFuncVehicle* CFuncVehicle::Instance(edict_t* pent)
{
if (FClassnameIs(pent, "func_vehicle"))
return (CFuncVehicle*)GET_PRIVATE(pent);
return NULL;
}
/*QUAKED func_train (0 .5 .8) ?
Trains are moving platforms that players can ride.
The targets origin specifies the min point of the train at each corner.
The train spawns at the first target it is pointing at.
If the train is the target of a button or trigger, it will not begin moving until activated.
speed default 100
dmg default 2
sounds
1) ratchet metal
*/
int CFuncVehicle::Classify()
{
return CLASS_VEHICLE;
}
void CFuncVehicle ::Spawn()
{
if (pev->speed == 0)
m_speed = 165;
else
m_speed = pev->speed;
if (m_sounds == 0)
m_sounds = 3;
ALERT(at_console, "M_speed = %f\n", m_speed);
pev->speed = 0;
pev->velocity = g_vecZero;
pev->avelocity = g_vecZero;
pev->impulse = m_speed;
m_acceleration = 5;
m_dir = 1;
m_flTurnStartTime = -1;
if (FStringNull(pev->target))
ALERT(at_console, "Vehicle with no target");
if (pev->spawnflags & SF_TRACKTRAIN_PASSABLE)
pev->solid = SOLID_NOT;
else
pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
SET_MODEL(ENT(pev), STRING(pev->model));
UTIL_SetSize(pev, pev->mins, pev->maxs);
UTIL_SetOrigin(pev, pev->origin);
// Cache off placed origin for train controls
pev->oldorigin = pev->origin;
m_controlMins = pev->mins;
m_controlMaxs = pev->maxs;
m_controlMaxs.z += 72;
// start trains on the next frame, to make sure their targets have had
// a chance to spawn/activate
NextThink(pev->ltime + 0.1, false);
SetThink(&CFuncVehicle::Find);
Precache();
}
// GOOSEMAN
void CFuncVehicle ::Restart()
{
ALERT(at_console, "M_speed = %f\n", m_speed);
pev->speed = 0;
pev->velocity = g_vecZero;
pev->avelocity = g_vecZero;
pev->impulse = m_speed;
m_dir = 1;
m_flTurnStartTime = -1;
m_flUpdateSound = -1;
m_pDriver = NULL;
if (FStringNull(pev->target))
ALERT(at_console, "Vehicle with no target");
UTIL_SetOrigin(pev, pev->oldorigin);
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise));
// start trains on the next frame, to make sure their targets have had
// a chance to spawn/activate
NextThink(pev->ltime + 0.1, false);
SetThink(&CFuncVehicle::Find);
}
void CFuncVehicle ::Precache()
{
if (m_flVolume == 0.0)
m_flVolume = 1.0;
switch (m_sounds)
{
case 1:
PRECACHE_SOUND("plats/vehicle1.wav");
pev->noise = MAKE_STRING("plats/vehicle1.wav");
break;
case 2:
PRECACHE_SOUND("plats/vehicle2.wav");
pev->noise = MAKE_STRING("plats/vehicle2.wav");
break;
case 3:
PRECACHE_SOUND("plats/vehicle3.wav");
pev->noise = MAKE_STRING("plats/vehicle3.wav");
break;
case 4:
PRECACHE_SOUND("plats/vehicle4.wav");
pev->noise = MAKE_STRING("plats/vehicle4.wav");
break;
case 5:
PRECACHE_SOUND("plats/vehicle6.wav");
pev->noise = MAKE_STRING("plats/vehicle6.wav");
break;
case 6:
PRECACHE_SOUND("plats/vehicle7.wav");
pev->noise = MAKE_STRING("plats/vehicle7.wav");
break;
default:
PRECACHE_SOUND("plats/vehicle7.wav");
pev->noise = MAKE_STRING("plats/vehicle7.wav");
break;
}
PRECACHE_SOUND("plats/vehicle_brake1.wav");
PRECACHE_SOUND("plats/vehicle_start1.wav");
m_usAdjustPitch = PRECACHE_EVENT(1, "events/vehicle.sc");
}
// This class defines the volume of space that the player must stand in to control the vehicle
class CFuncVehicleControls : public CBaseEntity
{
public:
int ObjectCaps() { return CBaseEntity ::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
void Spawn();
void EXPORT Find();
};
LINK_ENTITY_TO_CLASS(func_vehiclecontrols, CFuncVehicleControls);
void CFuncVehicleControls ::Find()
{
edict_t* pTarget = NULL;
do
{
pTarget = FIND_ENTITY_BY_TARGETNAME(pTarget, STRING(pev->target));
} while (!FNullEnt(pTarget) && !FClassnameIs(pTarget, "func_vehicle"));
if (FNullEnt(pTarget))
{
ALERT(at_console, "No vehicle %s\n", STRING(pev->target));
return;
}
CFuncVehicle* pvehicle = CFuncVehicle::Instance(pTarget);
pvehicle->SetControls(pev);
UTIL_Remove(this);
}
void CFuncVehicleControls ::Spawn()
{
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE;
SET_MODEL(ENT(pev), STRING(pev->model));
UTIL_SetSize(pev, pev->mins, pev->maxs);
UTIL_SetOrigin(pev, pev->origin);
SetThink(&CFuncVehicleControls::Find);
pev->nextthink = gpGlobals->time;
}
Reference in a new issue Copy permalink