1273 lines
28 KiB
C++
1273 lines
28 KiB
C++
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Logfile:: /Quake 2 Engine/Sin/code/game/vehicle.cpp $
|
|
// $Revision:: 51 $
|
|
// $Author:: Markd $
|
|
// $Date:: 2/19/99 7:49p $
|
|
//
|
|
// Copyright (C) 1997 by Ritual Entertainment, Inc.
|
|
// All rights reserved.
|
|
//
|
|
// This source is may not be distributed and/or modified without
|
|
// expressly written permission by Ritual Entertainment, Inc.
|
|
//
|
|
// $Log:: /Quake 2 Engine/Sin/code/game/vehicle.cpp $
|
|
//
|
|
// 51 2/19/99 7:49p Markd
|
|
// implemented turret for CTF
|
|
//
|
|
// 50 11/16/98 8:26p Jimdose
|
|
// made vehicles check for water and lava
|
|
//
|
|
// 49 10/23/98 12:26a Markd
|
|
// Took out some vehicle coasting
|
|
//
|
|
// 48 10/22/98 4:45p Markd
|
|
// made vehicles more responsive
|
|
//
|
|
// 47 10/20/98 7:52p Markd
|
|
// Fixed drivable vehicles
|
|
//
|
|
// 46 10/19/98 12:07a Jimdose
|
|
// made all code use fast checks for inheritance (no text lookups when
|
|
// possible)
|
|
// isSubclassOf no longer requires ::_classinfo()
|
|
//
|
|
// 45 10/18/98 9:01p Markd
|
|
// Added ShowWeapon method and showweapon variable
|
|
//
|
|
// 44 10/17/98 8:14p Jimdose
|
|
// Changed Damage to DamgeEvent
|
|
//
|
|
// 43 10/15/98 11:53p Markd
|
|
// added jumping ability to vehicles
|
|
//
|
|
// 42 10/08/98 7:17p Markd
|
|
// added steerinplace and stuff
|
|
//
|
|
// 41 10/06/98 10:17p Markd
|
|
// changed some vehicle physics stuff
|
|
//
|
|
// 40 10/05/98 12:28a Jimdose
|
|
// Moved angledist to q_shared
|
|
//
|
|
// 39 9/22/98 5:20p Markd
|
|
// Put in new consolidated gib function
|
|
//
|
|
// 38 9/20/98 7:01p Markd
|
|
// made vehicle auto rotate its bounding box
|
|
//
|
|
// 37 9/16/98 10:07p Markd
|
|
// working on vehicles
|
|
//
|
|
// 36 9/16/98 4:29p Markd
|
|
// Put in scaled bounding boxes for vehicles
|
|
//
|
|
// 35 9/16/98 11:01a Markd
|
|
// Fixed some vehicle stuff that broke the intro and non-drivable vehicles
|
|
//
|
|
// 34 9/15/98 4:38p Markd
|
|
// Removed auto-jumping and other stuff
|
|
//
|
|
// 33 9/15/98 4:30p Markd
|
|
// Updated vehicle code
|
|
//
|
|
// 32 9/14/98 9:56p Markd
|
|
// put in sounds
|
|
//
|
|
// 31 9/14/98 6:13p Markd
|
|
// working on vehicles
|
|
//
|
|
// 30 9/14/98 3:30p Markd
|
|
// intermediate checkin
|
|
//
|
|
// 29 9/09/98 3:04p Markd
|
|
// Added IsDrivable also setup some default pm_types etc.
|
|
//
|
|
// 28 8/29/98 9:47p Jimdose
|
|
// Changed calls to gi.trace to G_Trace
|
|
//
|
|
// 27 7/25/98 4:39p Jimdose
|
|
// Added Driver
|
|
//
|
|
// 26 7/23/98 6:17p Aldie
|
|
// Updated damage system and fixed some damage related bugs. Also put tracers
|
|
// back to the way they were, and added gib event to funcscriptmodels
|
|
//
|
|
// 25 7/21/98 1:10p Aldie
|
|
// Added meansofdeath to obituaries
|
|
//
|
|
// 24 7/20/98 12:09p Markd
|
|
// Added vehicleanim support and driveroffset stuff
|
|
//
|
|
// 23 7/19/98 7:34p Markd
|
|
// Added proper vehicle exit
|
|
//
|
|
// 22 7/19/98 5:41p Markd
|
|
// Forced changing of weapons
|
|
//
|
|
// 21 7/19/98 3:43p Markd
|
|
// Took out special damage handling
|
|
//
|
|
// 20 7/18/98 11:26p Markd
|
|
// Fixed damage, forgot to register Damage Event
|
|
//
|
|
// 19 7/18/98 11:15p Markd
|
|
// Added damage ability
|
|
//
|
|
// 18 7/18/98 3:57p Markd
|
|
// Put in InVehicle support
|
|
//
|
|
// 17 7/17/98 4:03p Markd
|
|
// Added a bunch of functionality to the vehicle class
|
|
//
|
|
// 16 6/23/98 11:45p Jimdose
|
|
// Got rid of some warnings
|
|
//
|
|
// 15 6/23/98 2:58p Jimdose
|
|
// Better (but still bad) driving code
|
|
//
|
|
// 14 6/22/98 2:04p Jimdose
|
|
// Reintegrated into sin
|
|
//
|
|
// 12 11/19/97 8:07p Jimdose
|
|
// Fixed bug where vehicle would "heal" monsters if the player backed into them
|
|
// with a vehicle.
|
|
//
|
|
// 11 11/12/97 5:11p Jimdose
|
|
// Enter and Exit events are now defined in player
|
|
//
|
|
// 10 11/01/97 2:09p Jimdose
|
|
// Fixed rover1
|
|
//
|
|
// 9 11/01/97 2:02p Jimdose
|
|
// Worked on vehicles
|
|
//
|
|
// 8 10/31/97 9:03p Jimdose
|
|
// Worked on vehicles
|
|
//
|
|
// 7 10/30/97 11:48p Jimdose
|
|
// Worked on vehicle code
|
|
//
|
|
// 6 10/29/97 8:49p Jimdose
|
|
// Began work on steering
|
|
//
|
|
// 5 10/27/97 3:29p Jimdose
|
|
// Removed dependency on quakedef.h
|
|
//
|
|
// 4 10/09/97 4:26p Jimdose
|
|
// Worked on vehicle code
|
|
//
|
|
// 3 10/08/97 9:30p Jimdose
|
|
// Refined Vehicle movement.
|
|
//
|
|
// 2 10/08/97 6:03p Jimdose
|
|
// Began vehicle support.
|
|
//
|
|
// DESCRIPTION:
|
|
// Script controlled Vehicles.
|
|
//
|
|
|
|
#include "g_local.h"
|
|
#include "scriptslave.h"
|
|
#include "vehicle.h"
|
|
#include "player.h"
|
|
#include "specialfx.h"
|
|
#include "explosion.h"
|
|
#include "earthquake.h"
|
|
#include "gibs.h"
|
|
|
|
Event EV_Vehicle_Start( "start" );
|
|
Event EV_Vehicle_Enter( "enter" );
|
|
Event EV_Vehicle_Exit( "exit" );
|
|
Event EV_Vehicle_Drivable( "drivable" );
|
|
Event EV_Vehicle_UnDrivable( "undrivable" );
|
|
Event EV_Vehicle_Jumpable( "canjump" );
|
|
Event EV_Vehicle_Lock( "lock" );
|
|
Event EV_Vehicle_UnLock( "unlock" );
|
|
Event EV_Vehicle_SeatAnglesOffset( "seatanglesoffset" );
|
|
Event EV_Vehicle_SeatOffset( "seatoffset" );
|
|
Event EV_Vehicle_DriverAnimation( "driveranim" );
|
|
Event EV_Vehicle_SetWeapon( "setweapon" );
|
|
Event EV_Vehicle_SetSpeed( "vehiclespeed" );
|
|
Event EV_Vehicle_SetTurnRate( "turnrate" );
|
|
Event EV_Vehicle_SteerInPlace( "steerinplace" );
|
|
Event EV_Vehicle_ShowWeapon( "showweapon" );
|
|
|
|
|
|
CLASS_DECLARATION( ScriptModel, VehicleBase, NULL );
|
|
|
|
ResponseDef VehicleBase::Responses[] =
|
|
{
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
VehicleBase::VehicleBase()
|
|
{
|
|
takedamage = DAMAGE_NO;
|
|
showModel();
|
|
setSolidType( SOLID_NOT );
|
|
setMoveType( MOVETYPE_NONE );
|
|
setOrigin( origin + Vector( "0 0 30") );
|
|
|
|
//
|
|
// we want the bounds of this model auto-rotated
|
|
//
|
|
flags |= FL_ROTATEDBOUNDS;
|
|
|
|
//
|
|
// rotate the mins and maxs for the model
|
|
//
|
|
setSize( mins, maxs );
|
|
|
|
vlink = NULL;
|
|
offset = "0 0 0";
|
|
}
|
|
|
|
CLASS_DECLARATION( VehicleBase, BackWheels, "script_wheelsback" );
|
|
|
|
ResponseDef BackWheels::Responses[] =
|
|
{
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
CLASS_DECLARATION( VehicleBase, FrontWheels, "script_wheelsfront" );
|
|
|
|
ResponseDef FrontWheels::Responses[] =
|
|
{
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
CLASS_DECLARATION( VehicleBase, Vehicle, "script_vehicle" );
|
|
|
|
ResponseDef Vehicle::Responses[] =
|
|
{
|
|
{ &EV_Blocked, ( Response )Vehicle::VehicleBlocked },
|
|
{ &EV_Touch, ( Response )Vehicle::VehicleTouched },
|
|
{ &EV_Use, ( Response )Vehicle::DriverUse },
|
|
{ &EV_Vehicle_Start, ( Response )Vehicle::VehicleStart },
|
|
{ &EV_Vehicle_Drivable, ( Response )Vehicle::Drivable },
|
|
{ &EV_Vehicle_UnDrivable, ( Response )Vehicle::UnDrivable },
|
|
{ &EV_Vehicle_Jumpable, ( Response )Vehicle::Jumpable },
|
|
{ &EV_Vehicle_SeatAnglesOffset, ( Response )Vehicle::SeatAnglesOffset },
|
|
{ &EV_Vehicle_SeatOffset, ( Response )Vehicle::SeatOffset },
|
|
{ &EV_Vehicle_Lock, ( Response )Vehicle::Lock },
|
|
{ &EV_Vehicle_UnLock, ( Response )Vehicle::UnLock },
|
|
{ &EV_Vehicle_SetWeapon, ( Response )Vehicle::SetWeapon },
|
|
{ &EV_Vehicle_DriverAnimation, ( Response )Vehicle::DriverAnimation },
|
|
{ &EV_Vehicle_SetSpeed, ( Response )Vehicle::SetSpeed },
|
|
{ &EV_Vehicle_SetTurnRate, ( Response )Vehicle::SetTurnRate },
|
|
{ &EV_Vehicle_SteerInPlace, ( Response )Vehicle::SteerInPlace },
|
|
{ &EV_Vehicle_ShowWeapon, ( Response )Vehicle::ShowWeaponEvent },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
Vehicle::Vehicle()
|
|
{
|
|
takedamage = DAMAGE_YES;
|
|
seatangles = vec_zero;
|
|
driveroffset = vec_zero;
|
|
seatoffset = vec_zero;
|
|
driver = 0;
|
|
lastdriver = 0;
|
|
currentspeed = 0;
|
|
turnangle = 0;
|
|
turnimpulse = 0;
|
|
moveimpulse = 0;
|
|
jumpimpulse = 0;
|
|
conesize = 75;
|
|
hasweapon = false;
|
|
locked = false;
|
|
steerinplace = false;
|
|
drivable = false;
|
|
jumpable = false;
|
|
showweapon = false;
|
|
setSolidType( SOLID_BBOX );
|
|
flags |= FL_SPARKS|FL_DIE_TESSELATE|FL_DIE_EXPLODE|FL_DARKEN;
|
|
gravity = 1;
|
|
mass = size.length() * 10;
|
|
|
|
//
|
|
// we use this to signify the init state of the angles
|
|
//
|
|
health = G_GetFloatArg( "health", 1000 );
|
|
speed = G_GetFloatArg( "speed", 600 );
|
|
maxturnrate = G_GetFloatArg( "maxturnrate", 40.0f );
|
|
PostEvent( EV_Vehicle_Start, 0 );
|
|
}
|
|
|
|
void Vehicle::VehicleStart
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
Entity *ent;
|
|
VehicleBase *last;
|
|
vec3_t trans[ 3 ];
|
|
vec3_t orient;
|
|
Vector drivemins, drivemaxs;
|
|
int groupindex;
|
|
int tri_num;
|
|
float max;
|
|
float width,height;
|
|
|
|
|
|
last = this;
|
|
|
|
for( ent = G_NextEntity( world ); ent != NULL; ent = G_NextEntity( ent ) )
|
|
{
|
|
if ( ( ent != this ) && ( ent->isSubclassOf( VehicleBase ) ) )
|
|
{
|
|
if ( ( ent->absmax.x >= absmin.x ) && ( ent->absmax.y >= absmin.y ) && ( ent->absmax.z >= absmin.z ) &&
|
|
( ent->absmin.x <= absmax.x ) && ( ent->absmin.y <= absmax.y ) && ( ent->absmin.z <= absmax.z ) )
|
|
{
|
|
last->vlink = ( VehicleBase * )ent;
|
|
last = ( VehicleBase * )ent;
|
|
last->offset = last->worldorigin - worldorigin;
|
|
last->offset = getLocalVector( last->offset );
|
|
last->edict->s.scale *= edict->s.scale;
|
|
}
|
|
}
|
|
}
|
|
|
|
last->vlink = NULL;
|
|
|
|
//
|
|
// get the seat offset
|
|
//
|
|
if ( gi.GetBoneInfo( edict->s.modelindex, "seat", &groupindex, &tri_num, orient ) )
|
|
{
|
|
gi.GetBoneTransform( edict->s.modelindex, groupindex, tri_num, orient, edict->s.anim, edict->s.frame,
|
|
edict->s.scale, trans, driveroffset.vec3() );
|
|
}
|
|
driveroffset += seatoffset * edict->s.scale;
|
|
SetDriverAngles( worldangles + seatangles );
|
|
|
|
max_health = health;
|
|
|
|
//
|
|
// calculate drive mins and maxs
|
|
//
|
|
max = 0;
|
|
if ( fabs( mins[ 0 ] ) > max )
|
|
max = fabs( mins[ 0 ] );
|
|
if ( fabs( maxs[ 0 ] ) > max )
|
|
max = fabs( maxs[ 0 ] );
|
|
if ( fabs( mins[ 1 ] ) > max )
|
|
max = fabs( mins[ 1 ] );
|
|
if ( fabs( maxs[ 1 ] ) > max )
|
|
max = fabs( maxs[ 1 ] );
|
|
drivemins = Vector( -max, -max, mins[ 2 ] ) * edict->s.scale;
|
|
drivemaxs = Vector( max, max, maxs[ 2 ] ) * edict->s.scale;
|
|
|
|
width = maxs[ 1 ] - mins[ 1 ];
|
|
height = maxs[ 0 ] - mins[ 0 ];
|
|
|
|
maxtracedist = height;
|
|
|
|
Corners[ 0 ][ 0 ] = -(width/4);
|
|
Corners[ 0 ][ 1 ] = (height/4);
|
|
Corners[ 0 ][ 2 ] = 0;
|
|
|
|
Corners[ 1 ][ 0 ] = (width/4);
|
|
Corners[ 1 ][ 1 ] = (height/4);
|
|
Corners[ 1 ][ 2 ] = 0;
|
|
|
|
Corners[ 2 ][ 0 ] = -(width/4);
|
|
Corners[ 2 ][ 1 ] = -(height/4);
|
|
Corners[ 2 ][ 2 ] = 0;
|
|
|
|
Corners[ 3 ][ 0 ] = (width/4);
|
|
Corners[ 3 ][ 1 ] = -(height/4);
|
|
Corners[ 3 ][ 2 ] = 0;
|
|
if ( drivable )
|
|
{
|
|
// drop everything back to the floor
|
|
droptofloor( 64 );
|
|
Postthink();
|
|
}
|
|
last_origin = worldorigin;
|
|
setSize( drivemins, drivemaxs );
|
|
}
|
|
|
|
void Vehicle::Drivable
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
setMoveType( MOVETYPE_NONE );
|
|
drivable = true;
|
|
}
|
|
|
|
void Vehicle::UnDrivable
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
setMoveType( MOVETYPE_PUSH );
|
|
drivable = false;
|
|
}
|
|
|
|
void Vehicle::Jumpable
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
jumpable = true;
|
|
}
|
|
|
|
void Vehicle::Lock
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
locked = true;
|
|
}
|
|
|
|
void Vehicle::UnLock
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
locked = false;
|
|
}
|
|
|
|
void Vehicle::SteerInPlace
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
steerinplace = true;
|
|
}
|
|
|
|
void Vehicle::SeatAnglesOffset
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
seatangles = ev->GetVector( 1 );
|
|
}
|
|
|
|
void Vehicle::SeatOffset
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
seatoffset = ev->GetVector( 1 );
|
|
}
|
|
|
|
void Vehicle::SetWeapon
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
showweapon = true;
|
|
hasweapon = true;
|
|
weaponName = ev->GetString( 1 );
|
|
}
|
|
|
|
void Vehicle::ShowWeaponEvent
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
showweapon = true;
|
|
}
|
|
|
|
void Vehicle::DriverAnimation
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
driveranim = ev->GetString( 1 );
|
|
}
|
|
|
|
qboolean Vehicle::HasWeapon
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return hasweapon;
|
|
}
|
|
|
|
qboolean Vehicle::ShowWeapon
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return showweapon;
|
|
}
|
|
|
|
void Vehicle::SetDriverAngles
|
|
(
|
|
Vector angles
|
|
)
|
|
{
|
|
int i;
|
|
|
|
if ( !driver )
|
|
return;
|
|
|
|
for( i = 0; i < 3; i++ )
|
|
{
|
|
driver->client->ps.pmove.delta_angles[ i ] = ANGLE2SHORT( angles[ i ] - driver->client->resp.cmd_angles[ i ] );
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CheckWater
|
|
=============
|
|
*/
|
|
void Vehicle::CheckWater
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
Vector point;
|
|
int cont;
|
|
int sample1;
|
|
int sample2;
|
|
VehicleBase *v;
|
|
const gravityaxis_t &grav = gravity_axis[ gravaxis ];
|
|
|
|
unlink();
|
|
v = this;
|
|
while( v->vlink )
|
|
{
|
|
v = v->vlink;
|
|
v->unlink();
|
|
}
|
|
|
|
if ( driver )
|
|
{
|
|
driver->unlink();
|
|
}
|
|
|
|
//
|
|
// get waterlevel
|
|
//
|
|
waterlevel = 0;
|
|
watertype = 0;
|
|
|
|
sample2 = maxs[ grav.z ] - mins[ grav.z ];
|
|
sample1 = sample2 / 2;
|
|
|
|
point[ grav.x ] = worldorigin[ grav.x ];
|
|
point[ grav.y ] = worldorigin[ grav.y ];
|
|
point[ grav.z ] = worldorigin[ grav.z ] + mins[ grav.z ] + grav.sign;
|
|
cont = gi.pointcontents( point.vec3() );
|
|
|
|
if ( cont & MASK_WATER )
|
|
{
|
|
watertype = cont;
|
|
waterlevel = 1;
|
|
point[ grav.z ] = worldorigin[ grav.z ] + mins[ grav.z ] + sample1;
|
|
cont = gi.pointcontents( point.vec3() );
|
|
if ( cont & MASK_WATER )
|
|
{
|
|
waterlevel = 2;
|
|
point[ grav.z ] = worldorigin[ grav.z ] + mins[ grav.z ] + sample2;
|
|
cont = gi.pointcontents( point.vec3() );
|
|
if ( cont & MASK_WATER )
|
|
{
|
|
waterlevel = 3;
|
|
}
|
|
}
|
|
}
|
|
|
|
link();
|
|
v = this;
|
|
while( v->vlink )
|
|
{
|
|
v = v->vlink;
|
|
v->link();
|
|
}
|
|
|
|
if ( driver )
|
|
{
|
|
driver->link();
|
|
driver->waterlevel = waterlevel;
|
|
driver->watertype = watertype;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============
|
|
WorldEffects
|
|
=============
|
|
*/
|
|
void Vehicle::WorldEffects
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
//
|
|
// Check for earthquakes
|
|
//
|
|
if ( groundentity && ( level.earthquake > level.time ) )
|
|
{
|
|
velocity += Vector(EARTHQUAKE_STRENGTH*G_CRandom(),EARTHQUAKE_STRENGTH*G_CRandom(),fabs(50*G_CRandom()));
|
|
}
|
|
|
|
//
|
|
// check for lava
|
|
//
|
|
if ( watertype & CONTENTS_LAVA )
|
|
{
|
|
Damage( world, world, 20 * waterlevel, worldorigin, vec_zero, vec_zero, 0, DAMAGE_NO_ARMOR, MOD_LAVA, -1, -1, 1.0f );
|
|
}
|
|
}
|
|
|
|
void Vehicle::DriverUse
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
Event *event;
|
|
Entity *other;
|
|
Sentient *sent;
|
|
|
|
other = ev->GetEntity( 1 );
|
|
if ( !other || !other->isSubclassOf( Sentient ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
sent = ( Sentient * )other;
|
|
if ( driver )
|
|
{
|
|
int height;
|
|
int ang;
|
|
Vector angles;
|
|
Vector forward;
|
|
Vector pos;
|
|
float ofs;
|
|
trace_t trace;
|
|
|
|
if ( other != driver )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( locked )
|
|
return;
|
|
|
|
//
|
|
// place the driver on the ground
|
|
//
|
|
ofs = size.length() * 0.5f;
|
|
for ( height = 0; height < 100; height += 16 )
|
|
{
|
|
for ( ang = 0; ang < 360; ang += 30 )
|
|
{
|
|
angles[ 1 ] = driver->worldangles[ 1 ] + ang + 90;
|
|
angles.AngleVectors( &forward, NULL, NULL );
|
|
pos = worldorigin + (forward * ofs);
|
|
pos[2] += height;
|
|
trace = G_Trace( pos, driver->mins, driver->maxs, pos, NULL, MASK_PLAYERSOLID, "Vehicle::DriverUse 1" );
|
|
if ( !trace.allsolid )
|
|
{
|
|
Vector end;
|
|
|
|
end = pos;
|
|
end[ 2 ] -= 128;
|
|
trace = G_Trace( pos, driver->mins, driver->maxs, end, NULL, MASK_PLAYERSOLID, "Vehicle::DriverUse 2" );
|
|
if ( trace.fraction < 1.0f )
|
|
{
|
|
driver->setOrigin( pos );
|
|
goto foundpos;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
|
|
foundpos:
|
|
|
|
turnimpulse = 0;
|
|
moveimpulse = 0;
|
|
jumpimpulse = 0;
|
|
|
|
//driver->unbind();
|
|
event = new Event( EV_Vehicle_Exit );
|
|
event->AddEntity( this );
|
|
driver->ProcessEvent( event );
|
|
if ( hasweapon )
|
|
{
|
|
driver->takeWeapon( weaponName.c_str() );
|
|
}
|
|
if ( drivable )
|
|
{
|
|
edict->s.sound = 0;
|
|
RandomSound( "snd_dooropen", 1, CHAN_BODY );
|
|
RandomSound( "snd_stop", 1, CHAN_VOICE );
|
|
driver->setSolidType( SOLID_BBOX );
|
|
}
|
|
|
|
driver = NULL;
|
|
//if ( drivable )
|
|
// setMoveType( MOVETYPE_NONE );
|
|
}
|
|
else
|
|
{
|
|
driver = ( Sentient * )other;
|
|
lastdriver = driver;
|
|
|
|
if ( drivable )
|
|
setMoveType( MOVETYPE_VEHICLE );
|
|
if ( hasweapon )
|
|
{
|
|
Weapon *weapon;
|
|
|
|
weapon = driver->giveWeapon( weaponName.c_str() );
|
|
if ( weapon )
|
|
{
|
|
driver->ForceChangeWeapon( weapon );
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
if ( drivable )
|
|
{
|
|
RandomSound( "snd_doorclose", 1, CHAN_BODY );
|
|
RandomSound( "snd_start", 1, CHAN_VOICE );
|
|
driver->setSolidType( SOLID_NOT );
|
|
}
|
|
|
|
event = new Event( EV_Vehicle_Enter );
|
|
event->AddEntity( this );
|
|
if ( driveranim.length() )
|
|
event->AddString( driveranim );
|
|
driver->ProcessEvent( event );
|
|
|
|
//driver->bind( this );
|
|
//offset = other->origin;
|
|
offset = other->worldorigin - worldorigin;
|
|
|
|
flags |= FL_POSTTHINK;
|
|
SetDriverAngles( worldangles + seatangles );
|
|
}
|
|
}
|
|
|
|
qboolean Vehicle::Drive
|
|
(
|
|
usercmd_t *ucmd
|
|
)
|
|
|
|
{
|
|
Vector i, j, k;
|
|
|
|
if ( !driver || !driver->isClient() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( !drivable )
|
|
{
|
|
driver->client->ps.pmove.pm_type = PM_INVEHICLE;
|
|
ucmd->forwardmove = 0;
|
|
ucmd->sidemove = 0;
|
|
return false;
|
|
}
|
|
|
|
driver->client->ps.pmove.pm_type = PM_LOCKVIEW;
|
|
driver->client->ps.pmove.pm_flags |= PMF_NO_PREDICTION;
|
|
|
|
moveimpulse = ( ( float )ucmd->forwardmove ) * 3;
|
|
turnimpulse = ( ( float )-ucmd->sidemove ) * 0.5;
|
|
jumpimpulse = ( ( float )ucmd->upmove * gravity ) / 350;
|
|
if ( ( jumpimpulse < 0 ) || ( !jumpable ) )
|
|
jumpimpulse = 0;
|
|
|
|
turnimpulse += 2*angledist( SHORT2ANGLE( ucmd->angles[ 1 ] ) - driver->client->resp.cmd_angles[ 1 ] );
|
|
|
|
return true;
|
|
}
|
|
|
|
void Vehicle::Postthink
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
float turn;
|
|
Vector i, j, k;
|
|
int index;
|
|
trace_t trace;
|
|
Vector normalsum;
|
|
int numnormals;
|
|
Vector temp;
|
|
Vector pitch;
|
|
Vector roll;
|
|
VehicleBase *v;
|
|
VehicleBase *last;
|
|
float drivespeed;
|
|
|
|
|
|
if ( drivable )
|
|
{
|
|
currentspeed = moveimpulse / 10;
|
|
|
|
turnangle = turnangle * 0.25f + turnimpulse;
|
|
if ( turnangle > maxturnrate )
|
|
{
|
|
turnangle = maxturnrate;
|
|
}
|
|
else if ( turnangle < -maxturnrate )
|
|
{
|
|
turnangle = -maxturnrate;
|
|
}
|
|
else if ( fabs( turnangle ) < 2 )
|
|
{
|
|
turnangle = 0;
|
|
}
|
|
temp[ PITCH ] = 0;
|
|
temp[ YAW ] = angles[ YAW ];
|
|
temp[ ROLL ] = 0;
|
|
temp.AngleVectors( &i, &j, &k );
|
|
j = vec_zero - j;
|
|
|
|
//
|
|
// figure out what our orientation is
|
|
//
|
|
numnormals = 0;
|
|
for ( index = 0; index < 4; index++ )
|
|
{
|
|
Vector start, end;
|
|
Vector boxoffset;
|
|
|
|
boxoffset = Corners[ index ];
|
|
start = worldorigin + i * boxoffset[0] + j * boxoffset[1] + k * boxoffset[2];
|
|
end = start;
|
|
end[ 2 ] -= maxtracedist;
|
|
trace = G_Trace( start, vec_zero, vec_zero, end, NULL, MASK_SOLID, "Vehicle::PostThink Corners" );
|
|
if ( trace.fraction != 1.0f && !trace.startsolid )
|
|
{
|
|
normalsum += Vector( trace.plane.normal );
|
|
numnormals++;
|
|
}
|
|
}
|
|
if ( numnormals > 1 )
|
|
{
|
|
temp = normalsum * ( 1.0f/ numnormals );
|
|
temp.normalize();
|
|
i = temp.CrossProduct( temp, j );
|
|
pitch = i;
|
|
// determine pitch
|
|
angles[ 0 ] = (pitch.toPitch());
|
|
}
|
|
|
|
turn = turnangle * ( 1.0f / 200.0f );
|
|
|
|
if ( groundentity )
|
|
{
|
|
float dot;
|
|
Vector newvel;
|
|
Vector flatvel;
|
|
|
|
velocity[ 0 ] *= 0.925f;
|
|
velocity[ 1 ] *= 0.925f;
|
|
flatvel = Vector( orientation[ 0 ] );
|
|
velocity += flatvel * currentspeed;
|
|
flatvel[ 2 ] = 0;
|
|
dot = velocity * flatvel;
|
|
if ( dot > speed )
|
|
{
|
|
dot = speed;
|
|
}
|
|
else if ( dot < -speed )
|
|
{
|
|
dot = -speed;
|
|
}
|
|
else if ( fabs( dot ) < 20.0f )
|
|
{
|
|
dot = 0;
|
|
}
|
|
newvel = flatvel * dot;
|
|
velocity[ 0 ] = newvel[ 0 ];
|
|
velocity[ 1 ] = newvel[ 1 ];
|
|
velocity[ 2 ] += dot * jumpimpulse;
|
|
|
|
avelocity *= 0.05;
|
|
if ( steerinplace )
|
|
{
|
|
if ( dot < 350 )
|
|
dot = 350;
|
|
avelocity.y += turn * dot;
|
|
}
|
|
else
|
|
{
|
|
avelocity.y += turn * dot;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
avelocity *= 0.1;
|
|
}
|
|
angles += avelocity * FRAMETIME;
|
|
setAngles( angles );
|
|
}
|
|
drivespeed = velocity * Vector( orientation[ 0 ] );
|
|
|
|
if ( drivable && driver )
|
|
{
|
|
Event * event;
|
|
|
|
event = new Event( EV_RandomEntitySound );
|
|
if ( currentspeed > 0 )
|
|
event->AddString( "snd_forward" );
|
|
else if ( currentspeed < 0 )
|
|
event->AddString( "snd_backward" );
|
|
else
|
|
event->AddString( "snd_idle" );
|
|
ProcessEvent( event );
|
|
}
|
|
i = Vector( orientation[ 0 ] );
|
|
j = Vector( orientation[ 1 ] );
|
|
k = Vector( orientation[ 2 ] );
|
|
|
|
if ( driver )
|
|
{
|
|
Player * player;
|
|
|
|
player = ( Player * )( Sentient * )driver;
|
|
player->setOrigin( worldorigin + i * driveroffset[0] + j * driveroffset[1] + k * driveroffset[2] );
|
|
if ( drivable )
|
|
{
|
|
player->velocity = vec_zero;
|
|
player->setAngles( angles );
|
|
player->v_angle = angles;
|
|
player->v_angle[ PITCH ] = player->v_angle[ PITCH ];
|
|
}
|
|
}
|
|
|
|
last = this;
|
|
while( last->vlink )
|
|
{
|
|
v = last->vlink;
|
|
v->setOrigin( worldorigin + i * v->offset.x + j * v->offset.y + k * v->offset.z );
|
|
v->avelocity = avelocity;
|
|
v->velocity = velocity;
|
|
v->angles[ ROLL ] = angles[ ROLL ];
|
|
v->angles[ YAW ] = angles[ YAW ];
|
|
v->angles[ PITCH ] = (int)( v->angles[ PITCH ] + (drivespeed/4) ) % 360;
|
|
|
|
if ( v->isSubclassOf( FrontWheels ) )
|
|
{
|
|
v->angles += Vector( 0, turnangle, 0 );
|
|
}
|
|
v->setAngles( v->angles );
|
|
|
|
last = v;
|
|
}
|
|
|
|
CheckWater();
|
|
WorldEffects();
|
|
|
|
// save off last origin
|
|
last_origin = worldorigin;
|
|
|
|
if ( !driver && !velocity.length() && groundentity && !( watertype & CONTENTS_LAVA ) )
|
|
{
|
|
flags &= ~FL_POSTTHINK;
|
|
if ( drivable )
|
|
setMoveType( MOVETYPE_NONE );
|
|
}
|
|
}
|
|
|
|
void Vehicle::VehicleTouched
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
Entity *other;
|
|
float speed;
|
|
Vector delta;
|
|
Vector dir;
|
|
|
|
other = ev->GetEntity( 1 );
|
|
if ( other == driver )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( other == world )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( drivable && !driver )
|
|
{
|
|
return;
|
|
}
|
|
|
|
delta = worldorigin - last_origin;
|
|
speed = delta.length();
|
|
if ( speed > 2 )
|
|
{
|
|
RandomGlobalSound( "vehicle_crash" );
|
|
dir = delta * ( 1 / speed );
|
|
other->Damage( this, lastdriver, speed * 8, worldorigin, dir, vec_zero, speed*15, 0, MOD_VEHICLE, -1, -1, 1.0f );
|
|
}
|
|
|
|
}
|
|
|
|
void Vehicle::VehicleBlocked
|
|
(
|
|
Event *ev
|
|
)
|
|
|
|
{
|
|
Entity *other;
|
|
float speed;
|
|
float damage;
|
|
Vector delta;
|
|
Vector newvel;
|
|
Vector dir;
|
|
|
|
return;
|
|
if ( !velocity[0] && !velocity[1] )
|
|
return;
|
|
|
|
other = ev->GetEntity( 1 );
|
|
if ( other == driver )
|
|
{
|
|
return;
|
|
}
|
|
if ( other->isSubclassOf( VehicleBase ) )
|
|
{
|
|
delta = other->worldorigin - worldorigin;
|
|
delta.normalize();
|
|
|
|
newvel = vec_zero - ( velocity) + ( other->velocity * 0.25 );
|
|
if ( newvel * delta < 0 )
|
|
{
|
|
velocity = newvel;
|
|
delta = velocity - other->velocity;
|
|
damage = delta.length()/4;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else if ( ( velocity.length() < 350 ) )
|
|
{
|
|
other->velocity += velocity*1.25f;
|
|
other->velocity[ 2 ] += 100;
|
|
damage = velocity.length()/4;
|
|
}
|
|
else
|
|
{
|
|
damage = other->health + 1000;
|
|
}
|
|
|
|
// Gib 'em outright
|
|
speed = fabs( velocity.length() );
|
|
dir = velocity * ( 1 / speed );
|
|
other->Damage( this, lastdriver, damage, worldorigin, dir, vec_zero, speed, 0, MOD_VEHICLE, -1, -1, 1.0f );
|
|
}
|
|
|
|
Sentient *Vehicle::Driver
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return driver;
|
|
}
|
|
|
|
qboolean Vehicle::IsDrivable
|
|
(
|
|
void
|
|
)
|
|
|
|
{
|
|
return drivable;
|
|
}
|
|
|
|
void Vehicle::SetSpeed
|
|
(
|
|
Event *ev
|
|
)
|
|
{
|
|
speed = ev->GetFloat( 1 );
|
|
}
|
|
|
|
void Vehicle::SetTurnRate
|
|
(
|
|
Event *ev
|
|
)
|
|
{
|
|
maxturnrate = ev->GetFloat( 1 );
|
|
}
|
|
|
|
float Vehicle::SetDriverPitch
|
|
(
|
|
float pitch
|
|
)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
CLASS_DECLARATION( Vehicle, DrivableVehicle, "script_drivablevehicle" );
|
|
|
|
ResponseDef DrivableVehicle::Responses[] =
|
|
{
|
|
{ &EV_Damage, ( Response )Entity::DamageEvent },
|
|
{ &EV_Killed, ( Response )DrivableVehicle::Killed },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
DrivableVehicle::DrivableVehicle()
|
|
{
|
|
drivable = true;
|
|
flags |= FL_SPARKS|FL_DIE_TESSELATE|FL_DIE_EXPLODE|FL_DARKEN;
|
|
}
|
|
|
|
void DrivableVehicle::Killed(Event *ev)
|
|
{
|
|
Entity * ent;
|
|
Entity * attacker;
|
|
Vector dir;
|
|
Event * event;
|
|
const char * name;
|
|
int num;
|
|
VehicleBase *last;
|
|
|
|
takedamage = DAMAGE_NO;
|
|
setSolidType( SOLID_NOT );
|
|
hideModel();
|
|
|
|
attacker = ev->GetEntity( 1 );
|
|
|
|
//
|
|
// kill the driver
|
|
//
|
|
if ( driver )
|
|
{
|
|
Vector dir;
|
|
SentientPtr sent;
|
|
Event * event;
|
|
|
|
velocity = vec_zero;
|
|
sent = driver;
|
|
event = new Event( EV_Use );
|
|
event->AddEntity( sent );
|
|
ProcessEvent( event );
|
|
dir = sent->worldorigin - worldorigin;
|
|
dir[ 2 ] += 64;
|
|
dir.normalize();
|
|
sent->Damage( this, this, sent->health*2, worldorigin, dir, vec_zero, 50, 0, MOD_VEHICLE, -1, -1, 1.0f );
|
|
}
|
|
|
|
if (flags & FL_DIE_TESSELATE)
|
|
{
|
|
dir = worldorigin - attacker->worldorigin;
|
|
TesselateModel
|
|
(
|
|
this,
|
|
tess_min_size,
|
|
tess_max_size,
|
|
dir,
|
|
ev->GetInteger( 2 ),
|
|
tess_percentage,
|
|
tess_thickness,
|
|
vec3_origin
|
|
);
|
|
ProcessEvent( EV_BreakingSound );
|
|
}
|
|
|
|
if (flags & FL_DIE_EXPLODE)
|
|
{
|
|
CreateExplosion( worldorigin, 150*edict->s.scale, edict->s.scale * 2, true, this, this, this );
|
|
}
|
|
|
|
if (flags & FL_DIE_GIBS)
|
|
{
|
|
setSolidType( SOLID_NOT );
|
|
hideModel();
|
|
|
|
CreateGibs( this, -150, edict->s.scale, 3 );
|
|
}
|
|
//
|
|
// kill all my wheels
|
|
//
|
|
last = this;
|
|
while( last->vlink )
|
|
{
|
|
last->vlink->PostEvent( EV_Remove, 0 );
|
|
last = last->vlink;
|
|
}
|
|
|
|
|
|
//
|
|
// kill the killtargets
|
|
//
|
|
name = KillTarget();
|
|
if ( name && strcmp( name, "" ) )
|
|
{
|
|
num = 0;
|
|
do
|
|
{
|
|
num = G_FindTarget( num, name );
|
|
if ( !num )
|
|
{
|
|
break;
|
|
}
|
|
|
|
ent = G_GetEntity( num );
|
|
ent->PostEvent( EV_Remove, 0 );
|
|
}
|
|
while ( 1 );
|
|
}
|
|
|
|
//
|
|
// fire targets
|
|
//
|
|
name = Target();
|
|
if ( name && strcmp( name, "" ) )
|
|
{
|
|
num = 0;
|
|
do
|
|
{
|
|
num = G_FindTarget( num, name );
|
|
if ( !num )
|
|
{
|
|
break;
|
|
}
|
|
|
|
ent = G_GetEntity( num );
|
|
|
|
event = new Event( EV_Activate );
|
|
event->AddEntity( attacker );
|
|
ent->ProcessEvent( event );
|
|
}
|
|
while ( 1 );
|
|
}
|
|
|
|
PostEvent( EV_Remove, 0 );
|
|
}
|