/*
 * Copyright (c) 2016-2022 Vera Visions LLC.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

/*QUAKED prop_vehicle_driveable (0 0 1) (-50 -50 0) (50 50 70)
Point entity defining a 4-wheel vehicle that you can drive.

-------- KEYS --------
"targetname" : Name

-------- SPAWNFLAGS --------


-------- NOTES --------


-------- TRIVIA --------
This entity was introduced in Half-Life 2 (2004).
*/

#define VEH_SKIDDING FL_USE_RELEASED

#define VEHSF_NOFLIP 2048

enumflags
{
	VEHFL_DRIVER,
	VEHFL_MODELINDEX,
	VEHFL_ORIGIN,
	VEHFL_ANGLES,
	VEHFL_VELOCITY,
	VEHFL_TURNING,
	VEHFL_FLAGS
};

class prop_vehicle_driveable_wheel
{
	void() prop_vehicle_driveable_wheel;

	float m_flSuspension;
	float m_flSuspensionForce;

#ifdef CLIENT

	vector origin_net;
	vector velocity_net;
	vector angles_net;
	virtual void(void) PredictPreFrame;
	virtual void(void) PredictPostFrame;
#endif

	virtual void(float) UpdateSuspension;
	virtual void(float) Move;
	virtual void(vector) Bounce;
	virtual void(float, float m_flTurn) Accel;
	virtual void(float, float) Physics;
};

class prop_vehicle_driveable:NSVehicle
{
	/* map-entity fields */
	float m_flBounceFactor;
	float m_flAcceleration;
	float m_flSkidSpeed;
	float m_flTraction;
	float m_flBreakFactor;
	float m_flSteerFactor;
	float m_flStraightenFactor;
	vector m_vecGravityDir;
	float m_flTimeLength;
	vector m_vecSeatOffest;

	/* collision boxes */
	NSEntity m_eCollBox1;
	NSEntity m_eCollBox2;

	prop_vehicle_driveable_wheel m_wlFL;
	prop_vehicle_driveable_wheel m_wlFR;
	prop_vehicle_driveable_wheel m_wlBL;
	prop_vehicle_driveable_wheel m_wlBR;
	vector m_vecControlMins;
	vector m_vecControlMaxs;
	PREDICTED_FLOAT(m_flTurn);

	float m_flBRWheelAxel;
	float m_flBLWheelAxel;
	float m_flFLWheelAxel;
	float m_flFRWheelAxel;

	float m_flUseTime;

	void(void) prop_vehicle_driveable;

	virtual void(void) Spawned;
	virtual void(void) Physics;
	virtual void(void) RunVehiclePhysics;
	virtual void(void) WeaponInput;
	virtual void(void) PlayerInput;
	virtual void(void) OnRemoveEntity;

#ifdef CLIENT
	virtual bool(void) HideViewWeapon;
	virtual void(void) PredictPreFrame;
	virtual void(void) PredictPostFrame;
	virtual void(float, float) ReceiveEntity;
	virtual void(void) UpdateView;
#else
	virtual void(void) Respawn;
	virtual void(void) OnPlayerUse;
	virtual void(void) EvaluateEntity;
	virtual float(entity, float) SendEntity;
#endif
};

void
prop_vehicle_driveable::prop_vehicle_driveable(void)
{
	m_eDriver = __NULL__;
	m_flBounceFactor = 1.25f;
	m_flAcceleration = 600.0f;
	m_flSkidSpeed = 256.0f;
	m_flTraction = 5.0f;
	m_flBreakFactor = 2.0f;
	m_flSteerFactor = 1.0f;
	m_flStraightenFactor = 1.0f;
	m_vecGravityDir = [0,0,-1];
	m_iVehicleFlags |= VHF_FROZEN;
	hitcontentsmaski = CONTENTBIT_BODY | CONTENTBITS_POINTSOLID | CONTENTBIT_VEHICLECLIP;

	if (!m_eCollBox1)
		m_eCollBox1 = spawn(NSEntity);
	if (!m_eCollBox2)
		m_eCollBox2 = spawn(NSEntity);

	{
		m_eCollBox1.SetSize([-32,-32,0], [32,32,32]);
		m_eCollBox2.SetSize([-32,-32,0], [32,32,32]);
	}

	m_eCollBox1.hitcontentsmaski = hitcontentsmaski;	
	m_eCollBox2.hitcontentsmaski = hitcontentsmaski;	

	if (!m_wlFL)
		m_wlFL = spawn(prop_vehicle_driveable_wheel);
	if (!m_wlFR)
		m_wlFR = spawn(prop_vehicle_driveable_wheel);
	if (!m_wlBL)
		m_wlBL = spawn(prop_vehicle_driveable_wheel);
	if (!m_wlBR)
		m_wlBR = spawn(prop_vehicle_driveable_wheel);

	m_eCollBox1.owner = m_eCollBox2.owner = \
		m_wlFL.owner = m_wlFR.owner = \
		m_wlBL.owner = m_wlBR.owner = this;

	customphysics = Physics;
}

#ifdef CLIENT
bool
prop_vehicle_driveable::HideViewWeapon(void)
{
	return true;
}
#endif

void
prop_vehicle_driveable::Physics(void)
{
#ifdef CLIENT
	DriverRelink();
#endif

	/* if nobody is in the car, we need to run physics here
	 * with fake input frames */
	if (GetDriver() == __NULL__) {
#ifdef SERVER
		m_flTimeLength = frametime;
		m_vecMoveValues = [0,0,0];
		m_iMoveButtons = 0;
		RunVehiclePhysics();
#else
		setorigin(this, origin);
#endif
	} else {
		//crossprint(sprintf("Driver: %s\n", GetDriver().classname));
	}

	HandleThink();
}

void
prop_vehicle_driveable::OnRemoveEntity(void)
{
	remove(m_wlFL);
	remove(m_wlFR);
	remove(m_wlBL);
	remove(m_wlBR);
	remove(m_eCollBox1);
	remove(m_eCollBox2);
}

#ifdef CLIENT
void
prop_vehicle_driveable::UpdateView(void)
{
	vector vecStart, vecEnd;

	pSeat->m_vecPredictedOrigin = origin;
	makevectors(view_angles);
	vecStart = [pSeat->m_vecPredictedOrigin[0], pSeat->m_vecPredictedOrigin[1], pSeat->m_vecPredictedOrigin[2] + 16] + (v_right * 4);
	vecEnd = vecStart + (v_forward * -256) + [0,0,16] + (v_right * 4);
	other = world;
	traceline(vecStart, vecEnd, MOVE_OTHERONLY, this);
	g_view.SetCameraOrigin(trace_endpos + (v_forward * 16));
	g_view.SetClientAngle(view_angles);
}

void
prop_vehicle_driveable_wheel::PredictPreFrame(void)
{
	SAVE_STATE(angles);
	SAVE_STATE(origin);
	SAVE_STATE(velocity);
}

void
prop_vehicle_driveable_wheel::PredictPostFrame(void)
{
	ROLL_BACK(angles);
	ROLL_BACK(origin);
	ROLL_BACK(velocity);
}
#endif

void
prop_vehicle_driveable_wheel::Bounce(vector normal)
{
	prop_vehicle_driveable vehParent;
	vehParent = (prop_vehicle_driveable)owner;

	vector vecBounce = (velocity * normal) * normal * vehParent.m_flBounceFactor;
	velocity -= vecBounce;
	vehParent.velocity = velocity;

#ifdef SERVER
	float flStregth = vlen((velocity * normal) * normal);

	if (flStregth > 96) {
		Sound_Play(vehParent, CHAN_VOICE, "prop_vehicle_driveable.bounce");
	}
#endif
}

void
prop_vehicle_driveable_wheel::Move(float flTimeLength)
{
	vector vecDest;
	vector vecSavedNormal;
	float flStepped;
	float flMovetime;
	int i;

	/* have a few attempts */
	for (i = 3, flMovetime = flTimeLength; flMovetime > 0 && i; i--) {
		vecDest = origin + (velocity * flMovetime);
		tracebox(origin, mins, maxs, vecDest, MOVE_NOMONSTERS, this);

		if (trace_startsolid) {
			continue;
		}

		origin = trace_endpos;

		if (trace_fraction < 1) {
			vecSavedNormal = trace_plane_normal;
			flMovetime -= flMovetime * trace_fraction;

			if (flMovetime) {
				float roof_fraction;
				vector roof_plane_normal;

				/* step up if we can */
				trace_endpos = origin;
				trace_endpos[2] += 8;

				tracebox(origin, mins, maxs, trace_endpos, MOVE_NOMONSTERS, this);
				flStepped = trace_endpos[2] - origin[2];

				roof_fraction = trace_fraction;
				roof_plane_normal = trace_plane_normal;

				vecDest = trace_endpos + velocity * flMovetime;

				 /* only horizontally */
				vecDest[2] = trace_endpos[2];

				/* move forwards */
				tracebox(trace_endpos, mins, maxs, vecDest, MOVE_NOMONSTERS, this);

				/* if we got anywhere, make this raised-step move count */
				if (trace_fraction != 0) {
					float fwfrac;
					vector fwplane;

					fwfrac = trace_fraction;
					fwplane = trace_plane_normal;

					/* move down */
					vecDest = trace_endpos;
					vecDest[2] -= flStepped + 1;
					tracebox(trace_endpos, mins, maxs, vecDest, MOVE_NOMONSTERS, this);

					if (trace_fraction < 1 && trace_plane_normal[2] > 0.7f) {
						flMovetime -= flMovetime * fwfrac;

						if (roof_fraction < 1) {
							Bounce(roof_plane_normal);
						}

						/* FIXME: do we need velocity < 0? */
						if (trace_fraction < 1) {
							Bounce(trace_plane_normal);
						} else if (fwfrac < 1) {
							Bounce(fwplane);
						}

						origin = trace_endpos;
						continue;
					}
				}
			}

			/* stepping failed, assume crash? */
			if (trace_ent == world) {
				if (vlen(velocity) > 300) {
					float impact;
					impact = -dotproduct(trace_plane_normal, velocity);
					int iImpactDamage = impact / 100;
				}
			}

			Bounce(vecSavedNormal);
			/* Physics_DoTouch(this, trace_ent); */
		} else {
			break;
		}
	}
}

void
prop_vehicle_driveable_wheel::Accel(float flMoveTime, float m_flTurn)
{
	prop_vehicle_driveable vehParent;
	entity eDriver;
	float flTraction;
	vector vecAngle;

	vehParent = (prop_vehicle_driveable)owner;
	eDriver = vehParent.m_eDriver;
	vecAngle = vehParent.angles;

	makevectors(vecAngle);

	if (m_flTurn) {
		/* cripple turnrate by our current velocity */
		float turnbreak = bound(0, vlen(velocity), 100) * 0.5;

		/* rotates v_forward */
		rotatevectorsbyangle([ 0, m_flTurn * turnbreak, 0]);
	}

	tracebox(origin, mins, maxs, origin - v_up, MOVE_NOMONSTERS, owner);

	/* allow a range, for 1qu's worth of spare tyre pressure. or something */
	flTraction = 1 - trace_fraction;

	/* air friction, doubles up for general rolling friction, ish */
	velocity *= 1 - flMoveTime * 0.1;
	
	if (flTraction) {
		if (eDriver) {
			velocity += v_forward * bound(-1, vehParent.m_vecMoveValues[0] / 400, 1) * vehParent.m_flAcceleration * flMoveTime * flTraction;
		}

		/* test if this car is skidding */
		float skid = (velocity * v_right);
		if ( fabs(skid) > vehParent.m_flSkidSpeed ) {
			vehParent.flags |= VEH_SKIDDING;
		}

		/* nuke sideways velocity. if a wheel is off the ground this probably
		   means that it'll be pushed further. players should try not to roll
		   too much. */
		/* FIXME: push opposite wheel up slightly to model chassis momentum
		   not slowing as much as the wheel itself (zomg: race conditions!) */
		velocity -= (velocity * v_right) * v_right * vehParent.m_flTraction * flMoveTime * flTraction;

		if (!eDriver || (vehParent.m_iMoveButtons & INPUT_BUTTON2 || vehParent.m_vecMoveValues[2] > 0)) {
			vector t;

			/* empty cars are assumed to have their brakes on.
			   nuke forward velocity. if a wheel is off the ground this probably
			   means that it'll be pushed further. players should try not to
			   roll too much.

			   Note: really we ought to be applying some axel friction even
			   when not breaking, but we'll just depend on air friction for
			   that. */
			velocity -= (velocity * v_forward) * v_forward * vehParent.m_flBreakFactor * flMoveTime * flTraction;

			/* if break is on, nuke the final part of the velocity, so we can
			   become truely motionless.*/
			t = velocity - velocity * dotproduct(velocity, vehParent.m_vecGravityDir);
			if (vlen(t) < 15) {
				velocity -= t;
			}
			
			/* don't bother with gravity if we're already on the ground and
			   breaking. this avoids weird slides. */
			if (!trace_fraction && trace_plane_normal * vehParent.m_vecGravityDir < -0.7f) {
				return;
			}
		}
	}

	/* apply gravity */
	velocity += vehParent.m_vecGravityDir * flMoveTime * serverkeyfloat("phy_gravity") * trace_fraction;

	tracebox(origin, mins * 4.0, maxs * 4.0, origin, MOVE_NORMAL, owner);
	if (trace_ent && trace_ent != vehParent.m_eDriver) {
		int iImpactDamage = vlen(velocity) / 10;

		if (iImpactDamage > 10) {
			trace_ent.velocity = velocity * 2.0 + [0,0,500];
			velocity *= 0.25f;
#ifdef SERVER
			if (trace_ent.takedamage) {
				NSSurfacePropEntity foo = (NSSurfacePropEntity)trace_ent;
				Damage_Apply(foo, vehParent.m_eDriver, iImpactDamage, 0, DMG_VEHICLE);
				//print(sprintf("Delivering %i impact damage\n", iImpactDamage));
			}
#endif
		}
	}
}

void
prop_vehicle_driveable_wheel::UpdateSuspension(float flTimeLength)
{
	float flDamp;
	float flForce;

	if (fabs(m_flSuspension) > 0.001 || fabs(m_flSuspensionForce) > 0.001) {
		m_flSuspension += m_flSuspensionForce * flTimeLength;
		
		flForce = bound(0, flTimeLength * 65, 2);
		flDamp = 1 - (flTimeLength * 4);
		if (flDamp < 0) {
			flDamp = 0;
		}
		m_flSuspensionForce *= flDamp;
		m_flSuspensionForce -= m_flSuspension * flForce;
		m_flSuspension = bound(-15, m_flSuspension, 15);
	}
}

void
prop_vehicle_driveable_wheel::Physics(float turnrate, float flTimeLength)
{
	vector owner_pos;

	/* try to correct the wheel's position, in case it got stuck */
	owner_pos = owner.origin + (owner.mins + owner.maxs) * 0.5f;
	tracebox(owner_pos, mins, maxs, origin, MOVE_NORMAL, owner);
	setorigin(this, trace_endpos);

	/* see if we're in-air */
	other = world;
	tracebox(origin, mins, maxs, origin - [0,0,1], MOVE_OTHERONLY, this);
	if (!trace_startsolid) {
		if ((trace_fraction < 1) && (trace_plane_normal[2] > 0.7)) {
			flags |= FL_ONGROUND;
		} else {
			flags &= ~FL_ONGROUND;
			m_flSuspensionForce += flTimeLength * 200.0;
		}
	}

	Accel(flTimeLength / 2, turnrate);
	Move(flTimeLength);
	Accel(flTimeLength / 2, turnrate);
	UpdateSuspension(flTimeLength);
	//print(sprintf("suspension: %d, force: %d\n", m_flSuspension, m_flSuspensionForce));
}

void
prop_vehicle_driveable_wheel::prop_vehicle_driveable_wheel(void)
{
	mins = [-8,-8,-35];
	maxs = [8,8,8];
	hitcontentsmaski = CONTENTBIT_BODY | CONTENTBITS_POINTSOLID | CONTENTBIT_VEHICLECLIP;
}

#ifdef CLIENT
void
prop_vehicle_driveable::PredictPreFrame(void)
{
	SAVE_STATE(modelindex);
	SAVE_STATE(origin);
	SAVE_STATE(angles);
	SAVE_STATE(velocity);
	SAVE_STATE(m_flTurn);
	SAVE_STATE(flags);
	SAVE_STATE(driver_entnum);

	m_wlFL.PredictPreFrame();
	m_wlFR.PredictPreFrame();
	m_wlBL.PredictPreFrame();
	m_wlBR.PredictPreFrame();
}

void
prop_vehicle_driveable::PredictPostFrame(void)
{
	ROLL_BACK(modelindex);
	ROLL_BACK(angles);
	ROLL_BACK(origin);
	ROLL_BACK(velocity);
	ROLL_BACK(m_flTurn);
	ROLL_BACK(flags);
	ROLL_BACK(driver_entnum);

	m_wlFL.PredictPostFrame();
	m_wlFR.PredictPostFrame();
	m_wlBL.PredictPostFrame();
	m_wlBR.PredictPostFrame();
}
#endif

void
prop_vehicle_driveable::WeaponInput(void)
{

}

void
prop_vehicle_driveable::PlayerInput(void)
{
	m_vecMoveValues = input_movevalues;
	m_iMoveButtons = input_buttons;
	m_flTimeLength = input_timelength;

	/* prediction frame... */
	RunVehiclePhysics();

#ifdef SERVER
	/* allow us to exit */
	if (m_flUseTime < time) {
		if (input_buttons & INPUT_BUTTON5) {
			eActivator = m_eDriver;
			OnPlayerUse();
			input_buttons &= ~INPUT_BUTTON5;
		}
	}
#endif

	WeaponInput();

	/* only allow use key */
	input_buttons = (input_buttons & INPUT_BUTTON5);
}

void
prop_vehicle_driveable::RunVehiclePhysics(void)
{
#if SERVER
	/* eject the dead */
	if (m_eDriver && m_eDriver.health <= 0) {
		PlayerLeave((NSClientPlayer)m_eDriver);
	}
#endif

	if (m_eDriver) {
		float y;

		y = m_vecMoveValues[1];
		y = bound(-200, y, 200) / 200;
		y *= m_flSteerFactor;

		if (y) {
			if (y < 0 && m_flTurn < 0) {
				m_flTurn = 0.0f;
			} else if (y > 0 && m_flTurn > 0) {
				m_flTurn = 0.0f;
			} else {
				m_flTurn = bound(-1, m_flTurn - y * m_flTimeLength, 1);
			}
		} else {
			/* straighten wheels forward over time */
			if (m_flTurn < 0) {
				m_flTurn = min(0, m_flTurn + m_flTimeLength * m_flStraightenFactor);
			} else if (m_flTurn > 0) {
				m_flTurn = max(0, m_flTurn - m_flTimeLength * m_flStraightenFactor);
			}
		}

		PlayerUpdateFlags();
	}

	if (spawnflags & VEHSF_NOFLIP) {
		angles[0] = bound (-45, angles[0], 45);
		angles[2] = bound (-45, angles[2], 45);
	}

	flags &= ~VEH_SKIDDING;

	angles[0] = Math_FixDelta(angles[0]);
	angles[1] = Math_FixDelta(angles[1]);
	angles[2] = Math_FixDelta(angles[2]);

	velocity[0] = bound(-1000, velocity[0], 1000);
	velocity[1] = bound(-1000, velocity[1], 1000);
	velocity[2] = bound(-1000, velocity[2], 1000);

	makevectors(angles);

	setorigin( m_wlFL, origin );
	setorigin( m_wlBL, m_wlFL.origin - v_forward * 85 );
	setorigin( m_wlFL, m_wlFL.origin + v_forward * 85 );
	setorigin( m_wlFR, m_wlFL.origin + v_right * 40 );
	setorigin( m_wlFL, m_wlFL.origin - v_right * 40 );
	setorigin( m_wlBR, m_wlBL.origin + v_right * 40 );
	setorigin( m_wlBL, m_wlBL.origin - v_right * 40 );

	m_wlFL.Physics( this.m_flTurn, m_flTimeLength);
	m_wlFR.Physics( this.m_flTurn, m_flTimeLength);
	m_wlBL.Physics( 0, m_flTimeLength);
	m_wlBR.Physics( 0, m_flTimeLength);

	velocity = m_wlFL.velocity;
	velocity += m_wlFR.velocity;
	velocity += m_wlBL.velocity;
	velocity += m_wlBR.velocity;
	velocity *= 0.25f;

	v_right = (m_wlFR.origin - m_wlFL.origin);
	v_right += (m_wlBR.origin - m_wlBL.origin);
	v_forward = (m_wlFL.origin + m_wlFR.origin);
	v_forward -= (m_wlBL.origin + m_wlBR.origin);
	v_up = -crossproduct(v_forward, v_right);
	angles = vectoangles( v_forward, v_up );

	/* figure out the new chassis position */
	vector new_origin;
	new_origin = m_wlFL.origin;
	new_origin += m_wlFR.origin;
	new_origin += m_wlBL.origin;
	new_origin += m_wlBR.origin;
	new_origin *= 0.25f;
	setorigin(this, new_origin);

	makevectors(angles);
	m_eCollBox1.SetOrigin(origin + (v_forward * 64));
	m_eCollBox2.SetOrigin(origin + (v_forward * -72));
	m_eCollBox1.SetSolid(SOLID_BBOX);
	m_eCollBox2.SetSolid(SOLID_BBOX);

	PlayerAlign();

	/* actiony stuff */
}

#ifdef SERVER
void
prop_vehicle_driveable::OnPlayerUse(void)
{
	if (m_flUseTime > time)
		return;

	if (m_eDriver == eActivator) {
		PlayerLeave((NSClientPlayer)eActivator);
		setorigin(eActivator, GetExitPos());
	} else if (!m_eDriver) {
		PlayerEnter((NSClientPlayer)eActivator);
		m_vecPlayerPos = [0,0,0];
	}
	m_flUseTime = time + 2.0f;
}

void
prop_vehicle_driveable::Respawn(void)
{
	SetMovetype(MOVETYPE_NONE);
	SetSolid(SOLID_BBOX);
	SetOrigin(GetSpawnOrigin() + [0,0,32]);
	SetAngles(GetSpawnAngles());
	SetModel(GetSpawnModel());

	m_flBRWheelAxel = gettagindex( this, "RRWheelAxel" );
	m_flBLWheelAxel = gettagindex( this, "RLWheelAxel" );
	m_flFLWheelAxel = gettagindex( this, "FLWheelAxel" );
	m_flFRWheelAxel = gettagindex( this, "FRWheelAxel" );

	m_wlFL.velocity =
	m_wlFR.velocity =
	m_wlBL.velocity =
	m_wlBR.velocity =
	velocity = [0,0,0];
	PlayerUse = OnPlayerUse;
	setsize( this, [-50,-50,0], [50,50,64]);

	if (m_eDriver)
		PlayerLeave((NSClientPlayer)m_eDriver);

	SendFlags = -1;
}
#endif

#ifdef CLIENT
void
prop_vehicle_driveable::ReceiveEntity(float flSendFlags, float flNew)
{
	if (flSendFlags & VEHFL_DRIVER) {
		driver_entnum = readentitynum();
		DriverRelink();
	}

	if (flSendFlags & VEHFL_MODELINDEX) {
		modelindex = readshort();
		m_vecSeatOffest[0] = readfloat();
		m_vecSeatOffest[1] = readfloat();
		m_vecSeatOffest[2] = readfloat();
		setsize( this, [-50,-50,0], [50,50,64]);
	}

	if (flSendFlags & VEHFL_ORIGIN) {
		origin[0] = readcoord();
		origin[1] = readcoord();
		origin[2] = readcoord();
		setorigin(this, origin);

		makevectors(angles);

		setorigin( m_wlFL, origin );
		setorigin( m_wlBL, m_wlFL.origin - v_forward * 85 );
		setorigin( m_wlFL, m_wlFL.origin + v_forward * 85 );
		setorigin( m_wlFR, m_wlFL.origin + v_right * 40 );
		setorigin( m_wlFL, m_wlFL.origin - v_right * 40 );
		setorigin( m_wlBR, m_wlBL.origin + v_right * 40 );
		setorigin( m_wlBL, m_wlBL.origin - v_right * 40 );
		m_eCollBox1.SetOrigin(origin + (v_forward * 64));
		m_eCollBox2.SetOrigin(origin + (v_forward * -72));
	}

	if (flSendFlags & VEHFL_ANGLES) {
		angles[0] = readfloat();
		angles[1] = readfloat();
		angles[2] = readfloat();
	}

	if (flSendFlags & VEHFL_VELOCITY) {
		velocity[0] = readfloat();
		velocity[1] = readfloat();
		velocity[2] = readfloat();
	}

	if (flSendFlags & VEHFL_TURNING)
		m_flTurn = readfloat();

	if (flSendFlags & VEHFL_FLAGS)
		flags = readfloat();

	if (flNew) {
		drawmask = MASK_ENGINE;
		SetMovetype(MOVETYPE_NONE);
		SetSolid(SOLID_BBOX);

		m_flBRWheelAxel = gettagindex( this, "RRWheelAxel" );
		m_flBLWheelAxel = gettagindex( this, "RLWheelAxel" );
		m_flFLWheelAxel = gettagindex( this, "FLWheelAxel" );
		m_flFRWheelAxel = gettagindex( this, "FRWheelAxel" );

		m_wlFL.velocity =
		m_wlFR.velocity =
		m_wlBL.velocity =
		m_wlBR.velocity =
		velocity = [0,0,0];
		RunVehiclePhysics();
		customphysics = Physics;
	}

	PredictPreFrame();
}
#else
void
prop_vehicle_driveable::EvaluateEntity(void)
{
	/* while the engine is still handling physics for these, we can't
	 * predict when origin/angle might change */
	if (ATTR_CHANGED(origin))
		SetSendFlags(VEHFL_ORIGIN);

	if (ATTR_CHANGED(angles)) {
		angles[0] = Math_FixDelta(angles[0]);
		angles[1] = Math_FixDelta(angles[1]);
		angles[2] = Math_FixDelta(angles[2]);

		SetSendFlags(VEHFL_ANGLES);
	}
	if (ATTR_CHANGED(modelindex))
		SetSendFlags(VEHFL_MODELINDEX);
	if (ATTR_CHANGED(velocity))
		SetSendFlags(VEHFL_VELOCITY);
	if (ATTR_CHANGED(m_flTurn))
		SetSendFlags(VEHFL_TURNING);
	if (ATTR_CHANGED(m_eDriver))
		SetSendFlags(VEHFL_DRIVER);
	if (ATTR_CHANGED(flags))
		SetSendFlags(VEHFL_FLAGS);

	SAVE_STATE(origin);
	SAVE_STATE(angles);
	SAVE_STATE(modelindex);
	SAVE_STATE(velocity);
	SAVE_STATE(m_flTurn);
	SAVE_STATE(m_eDriver);
	SAVE_STATE(flags);
}

float
prop_vehicle_driveable::SendEntity(entity ePVSent, float flSendFlags)
{
	WriteByte(MSG_ENTITY, ENT_VEH_4WHEEL);
	WriteFloat(MSG_ENTITY, flSendFlags);

	if (!modelindex)
		return (false);

	if (flSendFlags & VEHFL_DRIVER) {
		WriteEntity(MSG_ENTITY, m_eDriver);
	}

	if (flSendFlags & VEHFL_MODELINDEX) {
		WriteShort(MSG_ENTITY, modelindex);
		WriteFloat(MSG_ENTITY, m_vecSeatOffest[0]);
		WriteFloat(MSG_ENTITY, m_vecSeatOffest[1]);
		WriteFloat(MSG_ENTITY, m_vecSeatOffest[2]);
	}

	if (flSendFlags & VEHFL_ORIGIN) {
		WriteCoord(MSG_ENTITY, origin[0]);
		WriteCoord(MSG_ENTITY, origin[1]);
		WriteCoord(MSG_ENTITY, origin[2]);
	}

	if (flSendFlags & VEHFL_ANGLES) {
		WriteFloat(MSG_ENTITY, angles[0]);
		WriteFloat(MSG_ENTITY, angles[1]);
		WriteFloat(MSG_ENTITY, angles[2]);
	}

	if (flSendFlags & VEHFL_VELOCITY) {
		WriteFloat(MSG_ENTITY, velocity[0]);
		WriteFloat(MSG_ENTITY, velocity[1]);
		WriteFloat(MSG_ENTITY, velocity[2]);
	}

	if (flSendFlags & VEHFL_TURNING)
		WriteFloat(MSG_ENTITY, m_flTurn);

	if (flSendFlags & VEHFL_FLAGS)
		WriteFloat(MSG_ENTITY, flags);

	return true;
}
#endif

void
prop_vehicle_driveable::Spawned(void)
{
	super::Spawned();

#ifdef SERVER
	Sound_Precache("prop_vehicle_driveable.bounce");
#endif
}

#ifdef CLIENT
void
prop_vehicle_driveable_readentity(float isnew)
{
	prop_vehicle_driveable veh = (prop_vehicle_driveable)self;
	float flags = readfloat();

	if (isnew)
		spawnfunc_prop_vehicle_driveable();

	veh.ReceiveEntity(flags, isnew);
}
#endif