vehicle.cpp

this keik game source

//-----------------------------------------------------------------------------
//
//  $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 );
      }
	}