//-----------------------------------------------------------------------------
//
//  $Logfile:: /Quake 2 Engine/Sin/code/game/sentient.cpp                     $
// $Revision:: 189                                                            $
//   $Author:: Jimdose                                                        $
//     $Date:: 11/17/98 6:56p                                                 $
//
// 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/sentient.cpp                          $
// 
// 189   11/17/98 6:56p Jimdose
// made EventGiveHealth clear the damage skin on the player
// 
// 188   11/16/98 9:05p Markd
// added meansofdeath to pain
// 
// 187   11/16/98 7:46p Markd
// Hooked up takeItem to an event, for some reason this was never done?
// 
// 186   11/14/98 8:07p Jimdose
// added DF_NO_DROP_WEAPONS
// 
// 185   11/13/98 10:20p Aldie
// Added event take item
// 
// 184   11/13/98 2:36a Aldie
// Fixed typo for MOD_SPEARGUN and gibbing.  Also removed pain for MUTANT_DRAIN
// 
// 183   11/12/98 11:29p Aldie
// No blood for mutant drain
// 
// 182   11/09/98 6:22p Markd
// Added dropweaponnow event
// 
// 181   11/08/98 10:49p Jimdose
// sentientFrozen wasn't being archived
// 
// 180   11/08/98 8:30p Aldie
// Added a couple of strings to archive for sentients
// 
// 179   10/27/98 6:20a Aldie
// Fixed drop inventory items bug
// 
// 178   10/27/98 3:50a Jimdose
// made armordamage not do Ion tesselation when FL_NOION is set
// 
// 177   10/26/98 9:53p Markd
// Moved GotKill around, added gibfest sound
// 
// 176   10/26/98 8:12p Aldie
// Fixed some weapon bugs with detaching from owner when removing
// 
// 175   10/26/98 2:21a Aldie
// Added MOD_HELIGUN to DoGib
// 
// 174   10/25/98 10:15p Aldie
// Fix dropweapon code (again)
// 
// 173   10/25/98 4:37a Aldie
// Put an assertion to help us find a bug with giving items
// 
// 172   10/25/98 1:51a Aldie
// Fixed an inventory bug ( free inventory ) and lowered percentage of gun
// getting shot out of your hands
// 
// 171   10/24/98 11:47p Jimdose
// fixed RestorePersistantData so that setowner works after G_CallSpawn
// 
// 170   10/24/98 6:38p Markd
// Added gibbed to GotKill, also added GotKill to gibbed section of ArmorDamage
// 
// 169   10/24/98 4:34p Aldie
// Added a warning message if we could not find the item in
// "EventGiveTargetname" - hopefully this will help find the problem.
// 
// 168   10/24/98 2:08p Aldie
// Fixed crash bug with floating inventories
// 
// 167   10/24/98 12:42a Markd
// changed origins to worldorigins where appropriate
// 
// 166   10/23/98 9:58p Aldie
// Fixed dropweapon bug
// 
// 165   10/23/98 7:11p Aldie
// Damage tweak for singleplayer
// 
// 164   10/23/98 2:37a Aldie
// Added MOD_VEHICLE
// 
// 163   10/22/98 11:11p Markd
// Put item variables into Add and Remove to keep track of inventory
// 
// 162   10/22/98 10:22p Markd
// Put in support for game and level item script variables
// 
// 161   10/22/98 9:29p Aldie
// Added support for death gib animations
// 
// 160   10/22/98 4:58p Aldie
// Only do rocket jump in deathmatch
// 
// 159   10/22/98 2:38a Aldie
// Added setdropweapon command for sentients
// 
// 158   10/22/98 1:40a Aldie
// Don't put blood on ents
// 
// 157   10/21/98 8:41p Markd
// Fixed currentWeapon bug with WeaponUse
// 
// 156   10/21/98 7:50p Aldie
// Fixed a function declaration
// 
// 155   10/20/98 11:23p Jimdose
// made weapons switch properly if you pickup a weapon while reloading
// made drop weapon and take weapon use the best weapon when switching
// 
// 154   10/20/98 8:05p Aldie
// Added a DoGib function to ease readability
// 
// 153   10/20/98 1:18a Markd
// Made fists and adrenaline a gibbable act
// 
// 152   10/19/98 12:07a Jimdose
// made all code use fast checks for inheritance (no text lookups when
// possible)
// isSubclassOf no longer requires ::_classinfo()
// 
// 151   10/18/98 6:43p Markd
// Allowed other actors to have their weapons knocked from their hands
// 
// 150   10/17/98 8:14p Jimdose
// Changed G_CallSpawn2 to G_CallSpawn
// 
// 149   10/17/98 5:15p Markd
// rotate centroid by orientation when making force field
// 
// 148   10/16/98 3:10a Aldie
// Removed global dmg multipliers
// 
// 147   10/15/98 3:37p Markd
// Added forcefield support
// 
// 146   10/15/98 3:11p Aldie
// Damage skill multiplier ( for testing purposes )
// 
// 145   10/14/98 1:19a Jimdose
// Got cross-level persistant info working
// 
// 144   10/12/98 3:49p Aldie
// Init a couple vars
// 
// 143   10/11/98 5:34p Aldie
// Gib from MUTANTHANDS
// 
// 142   10/11/98 12:03a Aldie
// Mutant mode takes less dmg
// 
// 141   10/10/98 5:58p Aldie
// More quantumdestab fixes
// 
// 140   10/09/98 5:23p Aldie
// Teamplay
// 
// 139   10/08/98 12:02a Jimdose
// Bloodsplats are now a separate class
// 
// 138   10/05/98 10:18p Aldie
// Covnverted over to new silencer methods
// 
// 137   10/04/98 10:28p Aldie
// Added multiple weapon changes.  Damage, flashes, quantum stuff
// 
// 136   10/03/98 7:27p Markd
// Added pos tio get gun orientation
// 
// 135   10/03/98 5:13p Jimdose
// changed the way Unarchive reads the event pointer
// 
// 134   10/01/98 8:00p Aldie
// Consolidated cprintf
// 
// 133   9/27/98 4:36p Aldie
// Modified armor damage and clipped velocity.z for bulletweapons in
// armordamage
// 
// 132   9/26/98 4:45p Aldie
// Added mutant mode
// 
// 131   9/25/98 4:37p Markd
// Made two sentient functions not inline, so that it would work with vc 6.0
// 
// 130   9/23/98 12:37p Markd
// added tesselate sound when ionized
// 
// 129   9/22/98 3:21p Markd
// put in parentmode lockout for blood and gibs
// 
// 128   9/22/98 12:14p Aldie
// Added sentientFrozen
// 
// 127   9/21/98 6:05p Markd
// added archive and unarchive functions
// 
// 126   9/20/98 9:08p Aldie
// Fixed a particle bug with RandomParticles
// 
// 125   9/20/98 7:11p Aldie
// Added flags to particles
// 
// 124   9/18/98 9:55p Markd
// Added noshadow event
// 
// 123   9/18/98 8:40p Aldie
// Ion tesselate effect
// 
// 122   9/16/98 8:58p Aldie
// Added ability to do a hold down weapon charge
// 
// 121   9/12/98 11:08p Aldie
// Fixed armor damage bug
// 
// 120   9/11/98 2:50p Aldie
// Added releasefiring functionality
// 
// 119   9/09/98 6:49p Markd
// Check to see if weapon is droppable before dropping it
// 
// 118   9/05/98 12:12p Aldie
// Tweaked armor damage that does 50% damage to player and 50% damage to armor
// in deathmatch.  Also inited poweruptype and poweruptimer
// 
// 117   9/02/98 11:08a Markd
// Put in setModel into Sentient so that weapon could be properly detached and
// re-attached again.
// 
// 116   9/01/98 7:46p Aldie
// Changed blood around so dead bodies bleed
// 
// 115   8/31/98 7:16p Markd
// Fixed player animation naming convention
// 
// 114   8/31/98 5:45p Aldie
// Powerup stuff
// 
// 113   8/31/98 1:55p Markd
// weapons no longer double trigger animations
// 
// 112   8/29/98 9:46p Jimdose
// Added call info to G_Trace
// 
// 111   8/29/98 7:23p Aldie
// Made a givetargetname function for giving monsters targeted items.
// 
// 110   8/29/98 2:53p Aldie
// Updated printing of location based damage
// 
// 109   8/27/98 9:03p Jimdose
// made grav a reference
// 
// 108   8/27/98 6:43p Markd
// re-added StartAnimating calls in TempAnim and SetANim
// 
// 107   8/27/98 6:00p Aldie
// Drop inventory items if the actors are gibbed.
// 
// 106   8/27/98 5:29p Markd
// Took out start animating calls
// 
// 105   8/27/98 2:30p Aldie
// Added DAMAGE_NO_SKILL flag
// 
// 104   8/24/98 6:52p Jimdose
// Fixed inverted gravity axis
// 
// 103   8/22/98 9:35p Jimdose
// Added support for alternate gravity axis
// 
// 102   8/21/98 7:38p Markd
// Fixed climbing code
// 
// 101   8/19/98 8:50p Aldie
// Show damage locations and use random particles for blood.
// 
// 100   8/17/98 2:58p Aldie
// Rearranged blood and spark particles
// 
// 99    8/15/98 4:07p Aldie
// Made NextWeapon and PreviousWeapon obey the AutoChange function.  So the
// sniperrifle will not be auto used.
// 
// 98    8/14/98 5:48p Aldie
// Moved more of blood splat stuff here.
// 
// 97    8/14/98 5:39p Aldie
// Moved spray blood to entity
// 
// 96    8/13/98 8:10p Aldie
// Added sparks and blood to armordamage
// 
// 95    8/12/98 4:20p Aldie
// Fixed icons not showing up correctly
// 
// 94    8/06/98 10:53p Aldie
// Added weapon tweaks and kickback.  Also modified blast radius damage and
// rocket jumping.
// 
// 93    8/04/98 6:14p Aldie
// Updated armor damage stuff
// 
// 92    8/04/98 5:10p Markd
// Took out "Monster" clause in ArmorDamage
// 
// 91    7/31/98 8:09p Jimdose
// Script commands now include flags to indicate cheats and console commands
// 
// 90    7/29/98 2:32p Aldie
// Changed health to a float
// 
// 89    7/26/98 4:15a Aldie
// Check for in vehicle so the player can kill himself
// 
// 88    7/26/98 2:59a Markd
// guys don't get their guns knocked out of their hands for now
// 
// 87    7/26/98 2:54a Markd
// changed player damage multipliers
// 
// 86    7/26/98 12:46a Aldie
// Trying to fix stuck dead anims
// 
// 85    7/25/98 3:57p Markd
// Added EV_GotKill
// 
// 84    7/25/98 2:11a Jimdose
// Added SentientList
// 
// 83    7/24/98 9:58p Aldie
// Gib stuff
// 
// 82    7/24/98 6:19p Aldie
// Check for inventory of type
// 
// 81    7/24/98 3:49p Aldie
// Made sentients check for uselessness in the future
// 
// 80    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
// 
// 79    7/23/98 1:51p Aldie
// Print damage to attacker and client
// 
// 78    7/23/98 12:17p Aldie
// Print damage reports to victims.
// 
// 77    7/21/98 9:09p Aldie
// Process commands on given weapons too.  Seems to work ok.
// 
// 76    7/21/98 1:10p Aldie
// Added meansofdeath to obituaries
// 
// 75    7/20/98 7:42p Aldie
// Set owner of given items before processing their commands.
// 
// 74    7/20/98 6:54p Markd
// Added damage support based on skill level
// 
// 73    7/20/98 5:40p Aldie
// When giving items to sentients process the commands immediately.
// 
// 72    7/19/98 10:34p Aldie
// Added DAMAGE_NO_ARMOR functionality
// 
// 71    7/19/98 7:38p Markd
// Added Shield support for 1/4 damage
// 
// 70    7/19/98 7:35p Markd
// Fixed ForceWeaponChange so that it doesn't squash newWeapon
// 
// 69    7/19/98 5:41p Markd
// Added ForceWeaponChange, added takeItem 
// 
// 68    7/18/98 7:37p Aldie
// Updated showdamage printing.
// 
// 67    7/18/98 5:08p Aldie
// Added showdamage
// 
// 66    7/17/98 4:01p Markd
// Added CanChangeWeapons
// 
// 65    7/14/98 6:57p Aldie
// Updated health commands
// 
// 64    7/13/98 5:00p Aldie
// Added dead player bodies with gibbing
// 
// 63    7/11/98 8:22p Jimdose
// When dropping a weapon, if the weapon can't be dropped, it's deleted if the
// player is dying.  This fixes the crash when the player dies while using the
// fists.
// 
// 62    7/11/98 5:55p Aldie
// Undid when we send icons to the player for picking stuff up.
// 
// 61    7/10/98 11:11p Jimdose
// characters no longer switch weapons after dropping them when killed
// 
// 60    7/10/98 12:05a Aldie
// Fixed icon sending if you don't pickup a weapon
// 
// 59    7/01/98 7:03p Aldie
// Floating inventory mods for empty inventories
// 
// 58    6/30/98 6:48p Aldie
// Gib a dead body, and don't display items that have 0 amount.
// 
// 57    6/25/98 8:47p Markd
// Added keyed items for Triggers, Rewrote Item class, rewrote every pickup
// method
// 
// 56    6/25/98 12:42p Aldie
// Updated some inventory and weapon swtiching stuff
// 
// 55    6/24/98 4:44p Aldie
// Made it so you can only view one inventory at a time
// 
// 54    6/24/98 1:37p Aldie
// Implementation of inventory system and picking stuff up
// 
// 53    6/21/98 5:54p Jimdose
// Moved call to GetBoneGroupName from the constructor to SetCurrentWeapon
// since the model isn't set yet when the constructor is called.
// 
// 52    6/20/98 7:49p Markd
// Added location to pain and killed events, also added gun_bone_group_name
// variable
// 
// 51    6/20/98 2:20p Aldie
// Removed sone printfs
// 
// 50    6/19/98 9:28p Jimdose
// Added GetGunOrientation
// 
// 49    6/19/98 6:36p Aldie
// Put some more inventory managment in
// 
// 48    6/18/98 9:25p Aldie
// Started inventory system
// 
// 47    6/18/98 2:00p Markd
// rewrote tesselation code
// 
// 46    6/17/98 1:20a Jimdose
// Changed Attack to FireWeapon
// 
// 45    6/15/98 9:09p Aldie
// Added a generic give and an updater for silenced weapons, when you pick it
// up
// 
// 44    6/15/98 3:36p Aldie
// Updated armor damage calculations
// 
// 43    6/10/98 2:10p Aldie
// Updated damage function.
// 
// 42    6/09/98 4:22p Jimdose
// AnimLoop went into an infinite loop when the anim didn't exist
// 
// 41    6/08/98 9:04p Aldie
// Updated checks for weapon changing when no ammo available
// 
// 40    6/08/98 8:35p Markd
// put in code to put away weapon when readytouse becomes false
// 
// 39    6/08/98 8:19p Markd
// Put in ReadyToUse call when switching weapons
// 
// 38    6/08/98 11:34a Aldie
// Updated damage based location checks
// 
// 37    6/05/98 6:25p Aldie
// Added give and take armor as well as ArmorDamage calculations based on
// location hit
// 
// 36    5/27/98 12:59a Markd
// Put in shadows flag
// 
// 35    5/26/98 4:46p Aldie
// added take functions
// 
// 34    5/24/98 8:46p Jimdose
// Made a lot of functions more str-friendly.
// Got rid of a lot of char * based strings
// Cleaned up get spawn arg functions and sound functions
// sound functions now use consistant syntax
// 
// 33    5/24/98 4:48p Jimdose
// Made char *'s const
// 
// 32    5/20/98 6:38p Jimdose
// Made anim functions use const char *
// 
// 31    5/08/98 2:57p Markd
// Added weapon pickup sound
// 
// 30    5/03/98 4:37p Jimdose
// Changed Vector class
// 
// 29    4/25/98 5:09p Markd
// Added up and down support for angles
// 
// 28    4/07/98 6:47p Jimdose
// Fixed weapon switching bugs
// 
// 27    4/06/98 5:46p Jimdose
// Added "angles" spawn values
// 
// 26    4/05/98 2:57a Jimdose
// Made checks for anim and classname case insensitive
// 
// 25    3/30/98 2:37p Jimdose
// Added Ammo
// Added weapon dropping
// 
// 24    3/29/98 10:01p Jimdose
// Added animation control functions
// 
// 23    3/27/98 5:37p Jimdose
// Added FreeInventory for when players respawn
// 
// 22    3/24/98 4:57p Jimdose
// Changed usage of GetToken to GetString so that script variables can be used
// 
// 21    3/23/98 1:31p Jimdose
// Revamped event and command system
// 
// 20    3/18/98 7:23p Jimdose
// Added code for handling readying and putting away weapons
// 
// 19    3/02/98 8:49p Jimdose
// Changed the classid parameter of CLASS_DECLARATION to a quoted string so
// that you could have a NULL classid.
// 
// 18    3/02/98 5:38p Jimdose
// Added destructor so that all held weapons are released from being owned.
// Temporariliy disabled type checking on Weapons.
// 
// 17    2/19/98 2:36p Jimdose
// Added weapons back in
// 
// 16    2/17/98 6:59p Jimdose
// no longer pass script into interpretCommand
// 
// 15    2/03/98 10:51a Jimdose
// Updated to work with Quake 2 engine
// Moved initialization to constructor and removed Init function
// 
// 13    12/15/97 4:39p Aldie
// Added support for gunoffset in def files.
// 
// 12    12/15/97 1:37a Jimdose
// Added assertions in nextWeapon and previousWeapon to help track down a bug.
// While changing weapons, I got a NULL pointer when I retrieved a entity
// number from the inventory.  Weapons in the inventory should never be freed
// during the game without being removed from the inventory first.
// 
// 11    12/11/97 3:36p Markd
// Moved ClearInventory List to before Init call to super class
// 
// 10    12/09/97 7:41p Markd
// Added NumWeapons and WeaponNumber functions
// 
// 9     11/20/97 9:02p Jimdose
// Changed Container class to use entity # instead of void *
// 
// 8     11/18/97 5:27p Markd
// Changed "ammo" command and also fixed some weapon checking
// 
// 7     11/15/97 6:54p Markd
// Added InterpretCommand, Added "fire", "ammo" and "weapon" command
// 
// 6     10/28/97 6:05p Jimdose
// Sentients now pick up nails from nail weapons.
// 
// 5     10/27/97 3:29p Jimdose
// Removed dependency on quakedef.h
// 
// 4     10/24/97 2:58p Jimdose
// Fixed bug where sentient was bound to weapon instead of weapon bound to
// sentient.
// 
// 3     10/01/97 2:04p Jimdose
// Weapons are now bound to their owners when they are picked up.
// 
// 2     9/26/97 6:47p Jimdose
// Added standard Ritual headers
//
// DESCRIPTION:
// Base class of entity that can carry other entities, and use weapons.
//

#include "g_local.h"
#include "entity.h"
#include "sentient.h"
#include "weapon.h"
#include "scriptmaster.h"
#include "ammo.h"
#include "armor.h"
#include "misc.h"
#include "inventoryitem.h"
#include "player.h"
#include "actor.h"

CLASS_DECLARATION( Entity, Sentient, NULL );

Event EV_Sentient_Attack( "fire" );
Event EV_Sentient_ReleaseAttack( "releasefire" );
Event EV_Sentient_GiveWeapon( "weapon" );
Event EV_Sentient_GiveAmmo( "ammo" );
Event EV_Sentient_GiveArmor( "armor" );
Event EV_Sentient_GiveItem( "item" );
Event EV_Sentient_GiveTargetname( "give" );
Event EV_Sentient_GiveInventoryItem( "invitem" );
Event EV_Sentient_GiveHealth( "health", EV_CHEAT );
Event EV_Sentient_TakeWeapon( "take_weapon" );
Event EV_Sentient_TakeAmmo( "take_ammo" );
Event EV_Sentient_TakeArmor( "take_armor" );
Event EV_Sentient_TakeItem( "take_item" );
Event EV_Sentient_WeaponPutAway( "weapon_putaway" );
Event EV_Sentient_WeaponReady( "weapon_ready" );
Event EV_Sentient_WeaponDoneFiring( "weapon_donefiring" );
Event EV_Sentient_AnimLoop( "animloop" );
Event EV_Sentient_UselessCheck( "useless_check" );
Event EV_Sentient_TurnOffShadow( "noshadow" );
Event EV_Sentient_Freeze( "freeze" );
Event EV_Sentient_UnFreeze( "unfreeze" );
Event EV_Sentient_ImpactDamage( "impact_damage" );
Event EV_Sentient_WeaponUse( "weaponuse", EV_CONSOLE );
Event EV_Sentient_SetDropWeapon( "dropweapon" );
Event EV_Sentient_DropWeaponNow( "dropweaponnow" );

ResponseDef Sentient::Responses[] =
   {
	   { &EV_Sentient_Attack,				( Response )Sentient::FireWeapon },
      { &EV_Sentient_ReleaseAttack,		( Response )Sentient::ReleaseFireWeapon },
	   { &EV_Sentient_GiveWeapon,			( Response )Sentient::EventGiveWeapon },
      { &EV_Sentient_TakeWeapon,			( Response )Sentient::EventTakeWeapon },
	   { &EV_Sentient_GiveAmmo,			( Response )Sentient::EventGiveAmmo },
      { &EV_Sentient_TakeAmmo,			( Response )Sentient::EventTakeAmmo },
      { &EV_Sentient_GiveArmor,			( Response )Sentient::EventGiveArmor },
      { &EV_Sentient_TakeArmor,			( Response )Sentient::EventTakeArmor },
      { &EV_Sentient_GiveItem,         ( Response )Sentient::EventGiveItem },
      { &EV_Sentient_GiveInventoryItem,( Response )Sentient::EventGiveInventoryItem },
      { &EV_Sentient_GiveHealth,       ( Response )Sentient::EventGiveHealth },
      { &EV_Sentient_GiveTargetname,   ( Response )Sentient::EventGiveTargetname },
      { &EV_Sentient_WeaponPutAway,		( Response )Sentient::WeaponPutAway },
	   { &EV_Sentient_WeaponReady,		( Response )Sentient::WeaponReady },
		{ &EV_Sentient_WeaponDoneFiring,	( Response )Sentient::WeaponDoneFiring },
		{ &EV_Sentient_AnimLoop,			( Response )Sentient::AnimLoop },
      { &EV_Damage,                    ( Response )Sentient::ArmorDamage },
      { &EV_Touch,                     ( Response )Sentient::SearchBody },
  		{ &EV_Sentient_UselessCheck,		( Response )Sentient::UselessCheck },
  		{ &EV_Sentient_TurnOffShadow,		( Response )Sentient::TurnOffShadow },
      { &EV_Sentient_Freeze,		      ( Response )Sentient::Freeze },
      { &EV_Sentient_UnFreeze,	      ( Response )Sentient::UnFreeze },
      { &EV_Sentient_ImpactDamage,     ( Response )Sentient::ImpactDamage },
      { &EV_Sentient_WeaponUse,		   ( Response )Sentient::WeaponUse },
      { &EV_Sentient_SetDropWeapon,	   ( Response )Sentient::SetDropWeapon },
      { &EV_Sentient_DropWeaponNow,	   ( Response )Sentient::DropWeaponNowEvent },
      { &EV_Sentient_TakeItem,	      ( Response )Sentient::EventTakeItem },
		{ NULL, NULL }
	};

Container<Sentient *> SentientList;

Sentient::Sentient()
	{
   Vector defangles;

	SentientList.AddObject( ( Sentient * )this );

	inventory.ClearObjectList();
	currentWeapon = NULL;
   currentItem = NULL;
	newWeapon = NULL;
	animOverride = false;
	dropweapon = true;
   tempAnimEvent = NULL;
   
	eyeposition = "0 0 64";
	gunoffset = "0 0 56";
   
   firedown = false;
   firedowntime = 0;

   // angles
   defangles = Vector( 0, G_GetFloatArg( "angle", 0 ), 0 );
   if (defangles.y == -1)
      {
      defangles = Vector( -90, 0, 0 );
      }
   else if (defangles.y == -2)
      {
      defangles = Vector( 90, 0, 0 );
      }
   angles = G_GetVectorArg( "angles", defangles );
	setAngles( angles );
   stopanimating_tillchange = false;

   poweruptype    = 0;
   poweruptimer   = 0;
   sentientFrozen = false;

   // HACK FIXME
   //
   // temporary shadow flag
   //
   edict->s.renderfx |= RF_XFLIP;
	}

Sentient::~Sentient()
	{
	SentientList.RemoveObject( ( Sentient * )this );
	FreeInventory();
	}

Vector Sentient::EyePosition
	(
	void
	)

	{
	Vector pos;

	pos = worldorigin;
	pos[ gravity_axis[ gravaxis ].x ] += eyeposition[ 0 ];
	pos[ gravity_axis[ gravaxis ].y ] += eyeposition[ 1 ] * gravity_axis[ gravaxis ].sign;
	pos[ gravity_axis[ gravaxis ].z ] += eyeposition[ 2 ] * gravity_axis[ gravaxis ].sign;

	return pos;
	}

Vector Sentient::GunPosition
	(
	void
	)

	{
	Vector pos;

	pos = worldorigin;
	pos[ gravity_axis[ gravaxis ].x ] += gunoffset[ 0 ];
	pos[ gravity_axis[ gravaxis ].y ] += gunoffset[ 1 ] * gravity_axis[ gravaxis ].sign;
	pos[ gravity_axis[ gravaxis ].z ] += gunoffset[ 2 ] * gravity_axis[ gravaxis ].sign;

	return pos;
	}

inline void Sentient::GetGunOrientation
	(
   Vector pos, 
	Vector *forward,
	Vector *right,
	Vector *up
	)
	
	{
	const gravityaxis_t &grav = gravity_axis[ gravaxis ];

	if ( forward )
		{
		( *forward )[ grav.x ] = orientation[ 0 ][ 0 ];
		( *forward )[ grav.y ] = orientation[ 0 ][ 1 ] * grav.sign;
		( *forward )[ grav.z ] = orientation[ 0 ][ 2 ] * grav.sign;
		}

	if ( right )
		{
		( *right )[ grav.x ] = -orientation[ 1 ][ 0 ];
		( *right )[ grav.y ] = - orientation[ 1 ][ 1 ] * grav.sign;
		( *right )[ grav.z ] = - orientation[ 1 ][ 2 ] * grav.sign;
		}

	if ( up )
		{
		( *up )[ grav.x ] = orientation[ 2 ][ 0 ];
		( *up )[ grav.y ] = orientation[ 2 ][ 1 ] * grav.sign;
		( *up )[ grav.z ] = orientation[ 2 ][ 2 ] * grav.sign;
		}
	}

void Sentient::GetMuzzlePositionAndDirection
   (
   Vector *pos,
   Vector *dir
   )

   {
   *pos = Vector( "0 0 0" );
   *dir = Vector( "0 0 0" );

   if ( currentWeapon )
      currentWeapon->GetMuzzlePosition( pos, dir );
   }

void Sentient::EventGiveHealth
   (
   Event *ev
   )

   {
   int group_num;

   health = ev->GetFloat( 1 );

   if ( isClient() )
      {
      for( group_num = 0; group_num < edict->s.numgroups ; group_num++ )
         {
         edict->s.groups[ group_num ] &= ~MDL_GROUP_SKINOFFSET_BIT0;
         }
      }
   }

void Sentient::FireWeapon
	(
	Event *ev
	)

	{
	if ( ( currentWeapon ) && currentWeapon->ReadyToFire() && currentWeapon->HasAmmo() )
		{
		currentWeapon->Fire();
		}
	}

void Sentient::ReleaseFireWeapon
	(
	Event *ev
	)

	{
   // Only need to check if currentWeapon because FireWeapon checks for
   // the weapon ready and if it has ammo.
	if ( currentWeapon )
		{
      float fireholdtime = ev->GetFloat( 1 );
      currentWeapon->ReleaseFire( fireholdtime );
		}
	}

void Sentient::AddItem
	(
	Item *object
	)

	{
	inventory.AddObject( object->entnum );

   if ( object->isSubclassOf( InventoryItem ) ) 
      {
      currentItem = (InventoryItem *)object;
      }
   //
   // set our global game variables if client
   //
   if ( isClient() )
      {
      str fullname;
      ScriptVariable * var;

      fullname = str( "playeritem_" ) + object->getClassname();
      var = gameVars.GetVariable( fullname.c_str() );
      if ( !var )
         {
         gameVars.SetVariable( fullname.c_str(), 1 );
         }
      else
         {
         int amount;

         amount = var->intValue() + 1;
         var->setIntValue( amount );
         }

      var = levelVars.GetVariable( fullname.c_str() );
      if ( !var )
         {
         levelVars.SetVariable( fullname.c_str(), 1 );
         }
      else
         {
         int amount;

         amount = var->intValue() + 1;
         var->setIntValue( amount );
         }
      }
	}

void Sentient::RemoveItem
	(
	Item *object
	)

	{
	Weapon *weapon;

	inventory.RemoveObject( object->entnum );
	if ( currentWeapon == object )
		{
		currentWeapon = NULL;
		if ( newWeapon == object )
			{
			newWeapon = NULL;
			weapon = BestWeapon();
			}
		else
			{
			weapon = newWeapon;
			}

		SetCurrentWeapon( weapon );
		}

   //
   // set our global game variables if client
   //
   if ( isClient() )
      {
      str fullname;
      ScriptVariable * var;

      fullname = str( "playeritem_" ) + object->getClassname();

      var = levelVars.GetVariable( fullname.c_str() );
      if ( var )
         {
         int amount;

         amount = var->intValue() - 1;
         if ( amount < 0 )
            amount = 0;
         var->setIntValue( amount );
         }
      }

   if ( currentItem == (InventoryItem *) object )
      {
      currentItem = NULL;
      // Try to set the the current item

      currentItem = (InventoryItem *)NextItem( NULL );
      if (!currentItem)
         {
         currentItem = (InventoryItem *)PrevItem( NULL );
         }
      }
	}

Item *Sentient::FindItem
	(
	const char *itemname
	)

	{
	int	num;
	int	i;
	Item	*item;

	num = inventory.NumObjects();
	for( i = 1; i <= num; i++ )
		{
		item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );
		if ( !Q_stricmp( item->getClassname(), itemname ) )
			{
			return item;
			}
		}

	return NULL;
	}

void Sentient::FreeInventory
	(
	void
	)

	{
	int	num;
	int	i;
	Item	*item;

	if ( currentWeapon )
      currentWeapon->DetachFromOwner();

   SetCurrentWeapon( NULL );
	newWeapon = NULL;

	num = inventory.NumObjects();
	for( i = num; i > 0; i-- )
		{
		item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );
		delete item;
		}

	inventory.ClearObjectList();
   currentItem = NULL;
	}

void Sentient::FreeInventoryOfType
	(
	const char *type
	)

	{
	int	num;
	int	i;
	Item	*item;

	num = inventory.NumObjects();
	for( i = num; i > 0; i-- )
		{
		item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );
		if ( checkInheritance( type, item->getClassname() ) )
         {
         inventory.RemoveObject( item->entnum );

         // If the current item is about to be deleted, then look for
         // another item to be current
         if ( currentItem == item )
            {
            currentItem = NULL;
            // Try to set the the current item

           currentItem = (InventoryItem *)NextItem( NULL );
            if (!currentItem)
               {
               currentItem = (InventoryItem *)PrevItem( NULL );
               }
            }
         delete item;
         }    
		}
	}

qboolean Sentient::HasItem
	(
	const char *itemname
	)

	{
	return ( FindItem( itemname ) != NULL );
	}

int Sentient::NumWeapons
	(
   void
	)

	{
	int	num;
	int	i;
	Item	*item;
   int   numweaps;

   numweaps = 0;

	num = inventory.NumObjects();
	for( i = 1; i <= num; i++ )
		{
		item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );
      if ( checkInheritance( &Weapon::ClassInfo, item->getClassname() ) )
			{
         numweaps++;
			}
		}

   return numweaps;
	}

Weapon * Sentient::WeaponNumber
	(
   int weaponnum
	)

	{
	int	num;
	int	i;
	Item	*item;

	// make it so that 0 is our first weapon rather than 1
   weaponnum++;
	num = inventory.NumObjects();
	for( i = 1; i <= num; i++ )
		{
		item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );
      if ( item->isSubclassOf( Weapon ) )
         {
         weaponnum--;
         if ( !weaponnum )
				{
            return ( Weapon * )item;
				}
         }
		}

   return NULL;
	}

void Sentient::ChangeWeapon
	(
	Weapon *weapon
	)

	{
	if ( weapon == currentWeapon )
		{
		return;
		}

	if ( currentWeapon )
		{
		if ( !weapon->ReadyToUse() )
			{
			return;
			}
		newWeapon = weapon;
		if ( !currentWeapon->ReadyToChange() )
			{
			return;
			}
		currentWeapon->PutAway();
		}
	else
		{
		SetCurrentWeapon( weapon );
		}
	}

void Sentient::ForceChangeWeapon
	(
	Weapon *weapon
	)

	{
   if ( newWeapon == weapon )
      {
      return;
      }

	if ( weapon == currentWeapon )
		{
		return;
		}

   newWeapon = NULL;

	if ( currentWeapon )
		{
      currentWeapon->DetachFromOwner();
      }
	SetCurrentWeapon( weapon );
	}

qboolean Sentient::CanChangeWeapons
	(
   void
	)

	{
   return  !( 
               ( newWeapon != NULL ) ||
               ( currentWeapon && !currentWeapon->ReadyToChange() ) ||
               ( flags & FL_MUTANT )
            );
	}

void Sentient::SetCurrentWeapon
	(
	Weapon *weapon
	)

	{
	const char *name;

	newWeapon = NULL;
	currentWeapon = weapon;
	if ( currentWeapon )
		{
		currentWeapon->ReadyWeapon();

		// get the name of the group that the gun bone belongs to
		name = gi.GetBoneGroupName( edict->s.modelindex, "gun" );
		if ( name )
			{
		   gun_bone_group_name = name;
			}
		else
			{
		   gun_bone_group_name = "";
			}
		}
	}

Weapon *Sentient::CurrentWeapon
	(
	void 
	)

	{
	return currentWeapon;
	}

Weapon *Sentient::BestWeapon
	(
	Weapon *ignore
	)

	{
	Item		*next;
	int		n;
	int		j;
	int		bestrank;
	Weapon	*bestweapon;
	
	n = inventory.NumObjects();

	// Search forewards until we find a weapon
	bestweapon = NULL;
	bestrank = -999999;
	for( j = 1; j <= n; j++ )
		{
		next = ( Item * )G_GetEntity( inventory.ObjectAt( j ) );

		assert( next );

		if ( ( next != ignore ) && next->isSubclassOf( Weapon ) && ( ( ( Weapon * )next )->Rank() > bestrank ) &&
			( ( ( Weapon * )next )->HasAmmo() )	)
			{
			bestweapon = ( Weapon * )next;
			bestrank = bestweapon->Rank();
			}
		}	

	return bestweapon;
	}

Weapon *Sentient::NextWeapon
	(
	Weapon *weapon
	)

	{
	Item		*item;
	int		i;
	int		n;
	int		weaponorder;
	Weapon	*choice;
	int		choiceorder;
	Weapon	*bestchoice;
	int		bestorder;
	Weapon	*worstchoice;
	int		worstorder;

	if ( !inventory.ObjectInList( weapon->entnum ) )
		{
		error( "NextWeapon", "Weapon not in list" );
		}

	weaponorder = weapon->Order();
	bestchoice = weapon;
	bestorder = 65535;
	worstchoice = weapon;
	worstorder = weaponorder;

	n = inventory.NumObjects();
	for( i = 1; i <= n; i++ )
		{
		item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );

		assert( item );

		if ( item->isSubclassOf( Weapon ) )
			{
			choice = ( Weapon * )item;
			if ( !choice->HasAmmo() || !choice->AutoChange() )
				{
				continue;
				}

			choiceorder = choice->Order();
			if ( ( choiceorder > weaponorder ) && ( choiceorder < bestorder ) )
				{
				bestorder = choiceorder;
				bestchoice = choice;
				}
			
			if ( choiceorder < worstorder )
				{
				worstorder = choiceorder;
				worstchoice = choice;
				}
			}
		}

	if ( bestchoice == weapon )
		{
		return worstchoice;
		}

	return bestchoice;
	}

Weapon *Sentient::PreviousWeapon
	(
	Weapon *weapon
	)

	{
	Item		*item;
	int		i;
	int		n;
	int		weaponorder;
	Weapon	*choice;
	int		choiceorder;
	Weapon	*bestchoice;
	int		bestorder;
	Weapon	*worstchoice;
	int		worstorder;

	if ( !inventory.ObjectInList( weapon->entnum ) )
		{
		error( "PreviousWeapon", "Weapon not in list" );
		}

	weaponorder = weapon->Order();
	bestchoice = weapon;
	bestorder = -65535;
	worstchoice = weapon;
	worstorder = weaponorder;

	n = inventory.NumObjects();
	for( i = 1; i <= n; i++ )
		{
		item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );

		assert( item );

		if ( item->isSubclassOf( Weapon ) )
			{
			choice = ( Weapon * )item;
			if ( !choice->HasAmmo() || !choice->AutoChange() )
				{
				continue;
				}

			choiceorder = choice->Order();
			if ( ( choiceorder < weaponorder ) && ( choiceorder > bestorder ) )
				{
				bestorder = choiceorder;
				bestchoice = choice;
				}
			
			if ( choiceorder > worstorder )
				{
				worstorder = choiceorder;
				worstchoice = choice;
				}
			}
		}

	if ( bestchoice == weapon )
		{
		return worstchoice;
		}

	return bestchoice;
	}

qboolean Sentient::WeaponReady
	(
	void
	)

	{
	Weapon *best;

	if ( !currentWeapon )
		{
		return false;
		}
	
	if (!currentWeapon->ReadyToUse() )
		{
		best = BestWeapon();
		if ( best )
			{
			ChangeWeapon( best );
			}
		return false;
		}

   if ( !currentWeapon->ReadyToFire() )
		{
		return false;
		}

	if ( !currentWeapon->HasAmmo() )
		{
		best = BestWeapon();
		if ( best )
			{
			ChangeWeapon( best );
			}
		return false;
		}

	return true;
	}

void Sentient::DropWeapon
	(
	Weapon *weapon
	)

	{
	if ( weapon == currentWeapon )
		{
		if ( deadflag )
			{
			SetCurrentWeapon( NULL );
			}
		else
			{
			// Choose the best weapon that's not the current
			SetCurrentWeapon( BestWeapon( currentWeapon ) );
			}
		}
	
	// check if the sentient can drop the weapon
   if ( dropweapon )
      {
      // This one checks if the weapon is droppable
	   if ( !weapon->Drop() && deadflag )
		   {
		   // can't drop it, probably because there's no worldmodel
		   // since we're dead, just delete the weapon.
		   delete weapon;
         }
		}
   else
      {
      delete weapon;
      }
	}

void Sentient::DropCurrentWeapon
	(
	void
	)

	{
   if ( currentWeapon )
   	DropWeapon( currentWeapon );
	}

void Sentient::takeWeapon
   (
   const char *weaponname
   )
   {
	Weapon *weapon;

   assert( weaponname );

   weapon = ( Weapon * )FindItem( weaponname );
	if ( !weapon )
		{
		return;
		}
   
   if ( weapon == currentWeapon )
   	{
      SetCurrentWeapon( BestWeapon( weapon ) );
      }

   weapon->DetachFromOwner();
   weapon->PostEvent( EV_Remove, 0 );
   }

void Sentient::EventGiveTargetname
   (
   Event *ev
   )
   
   {
   str      name;
   Item     *item=NULL;
  	edict_t  *from;

   name = ev->GetString( 1 );

	for ( from = &g_edicts[ 1 ]; from < &g_edicts[ globals.num_edicts ] ; from++ )
		{
      if ( !from->inuse )
         continue;

		if ( from->entity->isSubclassOf( Item ) ) 
			{
         item = ( Item * ) from->entity;
         if ( item->itemname == name )
            break;
         }
		}
   
   // Item should be found
   assert( item );

   if ( item )
      {
      item->SetOwner( this );
      item->ProcessPendingEvents();
      AddItem( item );
      }
   else
      {
      ev->Error( "Could not give item %s to %s.\n", name, targetname );
      }
   }

Item *Sentient::giveItem
   (
   const char * itemname,
   int amount,
   int icon_index
   )

   {
	ClassDef		*cls;
	Item        *item;
   int         index;

   item = ( Item * )FindItem( itemname );

	if ( item )
		{
 		item->Add( amount );
		}
	else
		{
		cls = getClass( itemname );
		if ( !cls )
			{
			gi.dprintf( "No item named '%s'\n", itemname );
			return NULL;
			}

		item = ( Item * )cls->newInstance();
      
      item->SetOwner( this );

      item->ProcessPendingEvents();
      
      item->Set( amount );
      AddItem( item );
      }

   // Send icon to the player
	if ( this->isSubclassOf( Player ) )
		{
      if ( icon_index >= 0 )
         index = icon_index;
      else      
         index = item->Icon();

      if ( index >= 0 )
         {
         gi.WriteByte( svc_console_command );
         gi.WriteString( va( "pl %d %d", index, amount ) ); 
         gi.unicast( edict, NULL );
         }
      }
   return item;
   }

void Sentient::takeItem
   (
   const char *itemname,
   int amount
   )
   {
	Item        *item;

   item = ( Item * )FindItem( itemname );

	if ( item )
		{
 		item->Remove( amount );
      if ( !item->Amount() )
         item->ProcessEvent( EV_Remove );
		}
   }

void Sentient::EventTakeItem
	(
	Event *ev
	)

	{
   int amount;

   if ( ev->NumArgs() > 1 )
      amount = ev->GetInteger( 2 );
   else
      amount = 1;
	takeItem( ev->GetString( 1 ), amount );
	}


Weapon *Sentient::giveWeapon
	(
	const char *weaponname
	)

	{
	Weapon	*weapon;

	assert( weaponname );

   if ( !checkInheritance( &Weapon::ClassInfo, weaponname ) )
		{
		gi.dprintf( "A %s is not usable as a weapon\n", weaponname );
		return NULL;
      }

   weapon = ( Weapon * )giveItem( weaponname, 1 );

	if ( !currentWeapon || ( weapon->Rank() > currentWeapon->Rank() ) )
		{
		ChangeWeapon( weapon );
		}

	return weapon;
	}

Weapon *Sentient::useWeapon
	(
	const char *weaponname
	)

	{
	Weapon *weapon;

	assert( weaponname );

	weapon = ( Weapon * )FindItem( weaponname );
	if ( weapon )
		{
		ChangeWeapon( weapon );
		}

	return currentWeapon;
	}

void Sentient::EventGiveWeapon
	(
	Event *ev
	)

	{
	ChangeWeapon( giveWeapon( ev->GetString( 1 ) ) );
	}


void Sentient::EventTakeWeapon
	(
	Event *ev
	)

	{
	takeWeapon( ev->GetString( 1 ) );
	}

void Sentient::EventTakeAmmo
	(
	Event *ev
	)

	{
   int			amount;
	const char	*type;
	Ammo			*ammo;
	Weapon		*best;

	type = ev->GetString( 1 );
   amount = ev->GetInteger( 2 );

	ammo = ( Ammo * )FindItem( type );
	if ( ammo )
		{
		ammo->Remove( amount );
		}

   if ( currentWeapon && !currentWeapon->HasAmmo() )
		{
		best = BestWeapon();
		if ( best )
			{
			ChangeWeapon( best );
			}
		}
   }

void Sentient::EventGiveAmmo
	(
	Event *ev
	)

	{
   int			amount;
	const char	*type;

	type = ev->GetString( 1 );
   amount = ev->GetInteger( 2 );

	if ( !checkInheritance( &Ammo::ClassInfo, type ) )
		{
		gi.dprintf( "%s is not usable as ammo\n", type );
		return;
		}

   giveItem( type, amount );

	if ( currentWeapon && !currentWeapon->HasAmmo() )
		{
   	Weapon		*best;
		best = BestWeapon();
		if ( best )
			{
			ChangeWeapon( best );
			}
		}
   }

void Sentient::EventTakeArmor
	(
	Event *ev
	)

	{
   int			amount;
	const char	*type;
	Armor			*armor;

	type = ev->GetString( 1 );
   amount = ev->GetInteger( 2 );

	armor = ( Armor * )FindItem( type );
	if ( armor )
		{
		armor->Remove( amount );
		}
   }

void Sentient::EventGiveArmor
	(
	Event *ev
	)

	{
   int			amount;
	const char	*type;
	Armor			*armor;

	type     = ev->GetString( 1 );
   amount   = ev->GetInteger( 2 );

	if ( !checkInheritance( &Armor::ClassInfo, type ) )
		{
		gi.dprintf( "%s is not usable as armor\n", type );
		return;
		}

	armor    = ( Armor * )FindItem( type );

	if ( armor )
		{
		armor->Set( amount );
		}
	else
		{
      giveItem( type, amount );
      }
   }

void Sentient::EventGiveItem
   (
   Event *ev
   )

   {
	const char	*type;
   float       amount;

	type     = ev->GetString( 1 );
   amount   = ev->GetInteger( 2 );

   giveItem( type, amount );
   }

void Sentient::EventGiveInventoryItem
   (
   Event *ev
   )

   {
	const char	         *type;
   int                  amount;

	type     = ev->GetString( 1 );
   amount   = ev->GetInteger( 2 );

	if ( !checkInheritance( &InventoryItem::ClassInfo, type ) )
      {
      gi.dprintf( "item '%s' is not a InventoryItem\n", type );
      return;
      }

   giveItem( type, amount );
   }

void Sentient::WeaponPutAway
	(
	Event *ev
	)

	{
	SetCurrentWeapon( newWeapon );
	}

void Sentient::WeaponReady
	(
	Event *ev
	)

	{
   if ( newWeapon )
      {
      ChangeWeapon( newWeapon );
      }
	}

void Sentient::WeaponDoneFiring
	(
	Event *ev
	)

	{
	Weapon *best;

   if ( newWeapon )
      {
      ChangeWeapon( newWeapon );
      }
   else if ( !currentWeapon || !currentWeapon->HasAmmo() || !currentWeapon->ReadyToUse() )
		{
		best = BestWeapon();
		if ( best )
			{
			ChangeWeapon( best );
			}
		}
	}

EXPORT_FROM_DLL void Sentient::AnimLoop
	(
	Event *ev
	)

	{
	Event *t;

	animOverride = false;

	if ( deadflag )
		{
		StopAnimating();
		}
	else if ( animating )
		{
		RandomAnimate( currentAnim.c_str(), NULL );
		}
   else
      {
      stopanimating_tillchange = true;
      }

	if ( tempAnimEvent )
		{
		t = tempAnimEvent;
		tempAnimEvent = NULL;
      ProcessEvent( t );
		}
	}

EXPORT_FROM_DLL void Sentient::SetAnim
	(
	const char *anim
	)

	{
	assert( anim );

   assert ( !deadflag );

	if ( str( anim ) == currentAnim )
		{
      if (!animating && !stopanimating_tillchange)
         StartAnimating();
		return;
		}

   stopanimating_tillchange = false;
   currentAnim = str( anim );

	if ( animOverride )
		{
		return;
		}

	RandomAnimate( currentAnim.c_str(), EV_Sentient_AnimLoop );

   if (!animating)
      StartAnimating();
	}

EXPORT_FROM_DLL void Sentient::TempAnim
	(
	const char *anim,
	Event *event
	)

	{
   assert ( !deadflag );

	assert( anim );

	animOverride = true;

	tempAnimEvent = event;

	RandomAnimate( anim, EV_Sentient_AnimLoop );
	}

void Sentient::TempAnim
	(
	const char *anim,
	Event &event
   )

   {
	Event *ev;

	ev = new Event( event );
	TempAnim( anim, ev );
   }

void Sentient::PrintDamageLocationToAttacker
   (
   edict_s     *attacker,
   const char  *victim_name,
   const char  *location
   )

   {
   const char *expanded_location;

   expanded_location = ExpandLocation( location );

   if ( expanded_location )
      gi.cprintf ( attacker, PRINT_MEDIUM, "You hit %s in the %s.\n", victim_name, expanded_location );
   }

void Sentient::PrintDamageLocationToVictim
   (
   edict_s     *victim,
   const char  *location
   )

   {
   const char *expanded_location;

   expanded_location = ExpandLocation( location );

   if ( expanded_location )
      gi.cprintf ( victim, PRINT_MEDIUM, "%s damage\n", expanded_location );
   }

qboolean Sentient::DoGib
   (
   int meansofdeath,
   Entity *inflictor
   )

   {
   if ( !( flags & FL_DIE_GIBS ) || parentmode->value )
      {
      return false;
      }

   if ( 
       ( meansofdeath == MOD_TELEFRAG ) || 
       ( meansofdeath == MOD_MUTANTHANDS ) || 
       ( meansofdeath == MOD_HELIGUN ) || 
       ( meansofdeath == MOD_LAVA ) ||
       ( ( meansofdeath == MOD_FISTS ) && ( inflictor->flags & FL_ADRENALINE ) ) ||
       ( ( meansofdeath == MOD_SHOTGUN ) && ( G_Random() < 0.3 ) )
      )
      {
      return true;
      }

   if ( health > -75 )
      {
      return false;
      }

   // Impact and Crush < -75 health
   if ( ( meansofdeath == MOD_IMPACT ) || 
        ( meansofdeath == MOD_CRUSH ) ||
        ( meansofdeath == MOD_VEHICLE )
      )
      {
      return true;
      }

   // Any projectiles except spear
   if ( inflictor->isSubclassOf( Projectile ) )
      {
      if ( meansofdeath != MOD_SPEARGUN )
         {
         return true;
         }
      }
   
   // Shotgun only 10% of the time
   if ( meansofdeath == MOD_SHOTGUN )
      {
      if ( G_Random() > 0.5 )
         {
         return true;
         }
      }

   return false;
   }
   
void Sentient::ArmorDamage
	(
   Event *ev
   )

	{
   Armor    *armor=0;
 	Entity	*inflictor;
	Entity	*attacker;
	float		damage;
   float    armor_damage=0;
	Vector	momentum;
   Vector   position;
   Vector   normal;
   Vector   direction;
   Event		*event;
   int      dflags;
   int      meansofdeath;
   int      knockback;
   float    damage_mult;
   int      groupnum;
   int      trinum;
   const char *location="";
   float    unmodified_damage=0;

   if ( ( takedamage == DAMAGE_NO ) || ( movetype == MOVETYPE_NOCLIP ) )
	   {      
      if ( isClient () )
         {
         Player *player;
         
         player = ( Player * )this;
         if ( !player->GetVehicle() )
            return;
         }
      else
         {
         return;
         }
      }

   damage		   = ev->GetFloat  ( 1 );
	inflictor	   = ev->GetEntity ( 2 );
	attacker		   = ev->GetEntity ( 3 );
   position       = ev->GetVector ( 4 );
   direction      = ev->GetVector ( 5 );
   normal         = ev->GetVector ( 6 );
   knockback      = ev->GetInteger( 7 );
   dflags         = ev->GetInteger( 8 );
   meansofdeath   = ev->GetInteger( 9 );
   groupnum       = ev->GetInteger( 10 );
   trinum         = ev->GetInteger( 11 );
   damage_mult    = ev->GetFloat  ( 12 );

   // Forcefields make objects invulnerable
   if ( flags & FL_FORCEFIELD )
      {
      float    alpha;
      float    radius;
      Vector   delta;
      Vector   org;
      Entity   *forcefield;
      //
      // spawn forcefield
      //
      forcefield = new Entity;

      delta = centroid - worldorigin;
      radius = delta.length();

      //
      // transform the centroid around by the current orientation
      //
		MatrixTransformVector( delta.vec3(), orientation, org.vec3() );
      org += worldorigin;

      forcefield->setModel( "sphere2.def" );
      forcefield->setOrigin( org );
      forcefield->worldorigin.copyTo(forcefield->edict->s.old_origin);
      forcefield->setMoveType( MOVETYPE_NONE );
      forcefield->setSolidType( SOLID_NOT );
      forcefield->edict->s.scale = radius / 16;
      alpha = ( damage * damage_mult ) / 100;
      if ( alpha > 1 )
         alpha = 1;
      if ( alpha < 0.15f )
         alpha = 0.15f;
      forcefield->edict->s.alpha = alpha;
		forcefield->edict->s.renderfx |= RF_TRANSLUCENT;
      forcefield->PostEvent( EV_Remove, 0.1f );
      return;
      }

	// if enabled you can't hurt teammates (but you can hurt yourself)
	// knockback still occurs
	if ( ( attacker != this ) && ( DM_FLAG( DF_MODELTEAMS | DF_SKINTEAMS ) ) )
	   {
		if ( OnSameTeam ( this, attacker ) )
		   {
	      // check for friendly fire
         if ( DM_FLAG( DF_FRIENDLY_FIRE ) )
				meansofdeath = MOD_FRIENDLY_FIRE;
			else
				damage = 0;
		   }
	   }

   if (groupnum == -1)
      location = "all";
   else
      location = gi.Group_NumToName( edict->s.modelindex, groupnum );
   
   // Adjust damage for skill level
   if ( isClient() && !deathmatch->value && !(dflags & DAMAGE_NO_SKILL))
      {
      // Clamp the damage multiplier
      if ( damage_mult > 2 )
         damage_mult = 2;
      
      switch( ( int )skill->value )
         {
         case 0:
            damage *= 0.2f;
            break;
         case 1:
            damage *= 0.4f;
            break;
         case 2:
            damage *= 0.6f;
            break;
         default:
            damage *= 0.8f; 
            break;
         }
      }

   // Shields reduce damage by 75%
   if ( flags & FL_SHIELDS )
      {
      damage *= 0.25f;
      }
   else if ( flags & FL_MUTANT )
      {
      damage *= 0.33f;
      }

   // If in deathmatch, client takes a minimum of 33% damage from source
   if ( deathmatch->value )
      {
      damage *= 0.66f;
      unmodified_damage = damage * 0.33f;
      }

   // check to see if we have armor in this location to reduce the damage
   if (location[0]  && !(dflags & DAMAGE_NO_ARMOR) )
      {
      if ( !strncmp( location,"all",3 ) )
         {
         char *armortypes[] = {"RiotHelmet", "FlakJacket", "FlakPants", NULL};
         int i = 0;
         float reduced_damage = 0;
   
         // Go through all the armor types
         while (armortypes[i])
            {
            float partial_damage = damage / 3;
            float odam = partial_damage;

            armor = ( Armor * )FindItem( armortypes[i] );
            
            // Check for armor in this spot
            if ( armor && ( armor->Amount() > 0 ) )
               {
               // Reduce the parital damage by the amount of armor
               partial_damage -= armor->Amount();
         
               if ( partial_damage < 0 )
                  partial_damage = 0;

               // Remove the amount absorbed by the armor from the armor.
               armor->Remove( odam - partial_damage );

               // Keep track of the damage done to the armor for testing purposes
               armor_damage += (odam - partial_damage );
               }   
            // Keep track of damage done after armor has been applied
            reduced_damage += partial_damage;
            i++;
            }
         // This is the damage after all armor is done
         damage = reduced_damage;
         }
      // else check for specific location based
      else if ( !strncmp( location,"head",4 ) )
         armor = ( Armor * )FindItem( "RiotHelmet" );
      else if ( !strncmp(location,"torso",4 ) )
         armor = ( Armor * )FindItem( "FlakJacket" );
//      else if ( !strncmp( location,"arm",3 ) )
//         armor = ( Armor * )FindItem( "FlakJacket" );
      else if ( !strncmp(location,"leg",3 ) )
         armor = ( Armor * )FindItem( "FlakPants" );
      
      // If armor is there, remove the appropriate amount
      if ( armor && ( armor->Amount() > 0 ) && !(dflags & DAMAGE_NO_ARMOR) )
         {
         float odam = damage;
         damage -= armor->Amount();
         
         if ( damage < 0 )
            damage = 0;

         armor->Remove( odam-damage );
         armor_damage += (odam - damage );
         }
      }

   damage += unmodified_damage;

   // Damage multiplier
   damage *= damage_mult;

   // Damage skins if armor didn't absorb all damage
   if ( ( damage > 0 ) && ( groupnum != -1 ) && ( flags & FL_BLOOD ) )
      if ( !edict->s.groups[ groupnum ] )
         edict->s.groups[ groupnum ]++;

   // Show location based damage.
   if ( sv_showdamagelocation->value && deathmatch->value )
      {
      // Send message to attacker
      if ( attacker->isClient() )
         {
         if ( this->client )
            {
            PrintDamageLocationToAttacker( attacker->edict, this->client->pers.netname, location );
            }
         }

      // Send message to victim
      if ( this->isClient() && attacker != this ) 
         {
         PrintDamageLocationToVictim(this->edict, location);
         }
      }

   // Shows detailed damage messages 
   if ( sv_showdamage->value )
      {
      // Send message to attacker
      if ( attacker->isClient() )
         {
         if ( this->client )
            {
            gi.cprintf ( attacker->edict, PRINT_HIGH, "TARG:%s ARMOR_DAM:%0.2f TOT_DAM:%0.2f LOC:%s\n", 
               this->client->pers.netname, armor_damage, damage, location ); 
            }
         else
            {
            gi.cprintf ( attacker->edict, PRINT_HIGH, "TARG:%s ARMOR_DAM:%0.2f TOT_DAM:%0.2f LOC:%s\n", 
               getClassname(), armor_damage, damage, location );
            }
         }

      // Send message to victim
      if ( this->isClient() && attacker != this ) 
         {
         gi.cprintf ( this->edict, PRINT_HIGH, "TARG:%s ARMOR_DAM:%0.2f TOT_DAM:%0.2f LOC:%s\n", 
            this->client->pers.netname, armor_damage, damage, location );
         }
      }

   
   // Blood and sparks effects
   if ( 
        ( damage > 0 ) && 
        ( meansofdeath != MOD_DROWN ) && 
        ( meansofdeath != MOD_MUTANT_DRAIN )
      )
      {
      // Blood particles
      if ( flags & FL_BLOOD )
         {
         Particles( position, normal, __min( 150,damage ), 127, PARTICLE_RANDOM );
      
         // Blood splat
         if ( dflags & DAMAGE_BULLET )
            SprayBlood( position, direction, damage );
         }
      // Sparks from metal
      else if ( flags & FL_SPARKS )
         { 
         SpawnSparks (position, normal, __min(damage, 75) );
         }
      }
   else if (  armor_damage > 0 )
      {
      // Sparks off armor
      Particles( position, normal, __min(armor_damage, 75), 122, 0 );
      }

   // Gib if we are dead and get hit by a rocket or shotgun
   if ( deadflag == DEAD_DEAD )
      {
      health -= damage;
      if ( DoGib( meansofdeath, inflictor ) )
         {
         Event *gibEv;

         gibEv = new Event( EV_Gib );
         gibEv->AddInteger( 0 );
         ProcessEvent( gibEv );
         }
      return;
      }
   else if ( deadflag )
      {
      health -= damage; 
      return;
      }

   // Do the kick
	if (!(dflags & DAMAGE_NO_KNOCKBACK))
      {
		if ((knockback) && 
         (movetype != MOVETYPE_NONE) && 
         (movetype != MOVETYPE_BOUNCE) && 
         (movetype != MOVETYPE_PUSH) && 
         (movetype != MOVETYPE_STOP))
         {
	         float	m;

	         if (mass < 50)
		         m = 50;
	         else
		         m = mass;

            direction.normalize();
   		   if ( isClient() && ( attacker == this ) && deathmatch->value )
		         momentum = direction * ( 1700.0f * ( float )knockback / m ); // the rocket jump hack...
	         else
		         momentum = direction * ( 500.0f * ( float )knockback / m );

            if ( dflags & DAMAGE_BULLET )
               {
               // Clip the z velocity for bullet weapons
               if ( momentum.z > 75)
                  momentum.z = 75;
               }
            velocity += momentum;
         }
      }

	// check for godmode or invincibility
	if ( flags & FL_GODMODE )
		{
		return;
		}

   // do the damage
	health -= damage;

   // He's dead jim, send out a bunch of events
   if ( health <= 0 )
		{
      if ( ( meansofdeath == MOD_ION ) && !( flags & FL_NOION ) )
         {
         flags |= FL_DIE_TESSELATE;
         RandomGlobalSound( "snd_tesselate" );
         }

		event = new Event( EV_Killed );
		event->AddEntity( attacker );
		event->AddInteger( damage );
		event->AddEntity( inflictor );
      event->AddString( location );
      event->AddInteger( meansofdeath );
		ProcessEvent( event );
		return;
		}

   if ( ( damage > 0 ) && ( meansofdeath == MOD_ION ) && !( flags & FL_NOION ) )
      {
      // Do the ion particlizer effect
      TesselateModel
         (
         this,
         1,
         1000,
         direction,
         damage,
         1.0f,
         0,
         vec3_origin,
         TESSELATE_EXPANDANDSHRINK,
         126
         );
      }
   
   // Tesselate from damage
   if (flags & FL_TESSELATE)
      {
      TesselateModel
         (
         this,
         tess_min_size,
         tess_max_size,
         direction,
         damage,
         1.0f,
         tess_thickness,
         vec3_origin
         );
      }

   // Darken if we are hurt
   if (flags & FL_DARKEN)
      {
      edict->s.renderfx |= RF_LIGHTOFFSET;
      if ( max_health )
         {
         edict->s.lightofs = - ( 40.0f * ( (float)(max_health - health) / (float)max_health ) );
         }
      else
         {
         edict->s.lightofs -= damage;
         }
      if ( edict->s.lightofs < -127 )
         edict->s.lightofs = -127;
      if ( edict->s.lightofs > 127 )
         edict->s.lightofs = 127;
      }

   // Drop your weapon if you get hit in the hands
   if ( location == gun_bone_group_name && ( ( damage > 50 ) || ( G_Random( 1 ) > 0.97f ) ) )
      {
      // don't drop weapons when in deathmatch and DF_NO_DROP_WEAPONS is set
      if ( currentWeapon && currentWeapon->IsDroppable() && ( !deathmatch->value || !DM_FLAG( DF_NO_DROP_WEAPONS ) ) )
         {
         DropCurrentWeapon();
         WeaponKnockedFromHands();
         }
      }

   if ( meansofdeath == MOD_MUTANT_DRAIN )
      return;

	// Send pain event
   event = new Event( EV_Pain );
	event->AddFloat( damage );
	event->AddEntity( attacker );
   event->AddString( location );
   event->AddInteger( meansofdeath );
	ProcessEvent( event );
   }

void Sentient::UpdateSilencedWeapons
   (
   void
   )
   
   {  
   // If the current weapon is silencable, then change it.
   if ( currentWeapon && currentWeapon->IsSilenced() )
      {
      currentWeapon->ProcessEvent(EV_Weapon_PutAwayAndRaise);
      }
   }

int Sentient::NumInventoryItems
   (
   void
   )

   {
   
   return inventory.NumObjects();

   }

Item *Sentient::NextItem
	(
	Item *item
	)

	{
	Item		*next_item;
	int		i;
	int		n;
   qboolean item_found = false;

   if ( !item )
      {
      item_found = true;
      }
   else if ( !inventory.ObjectInList( item->entnum ) )
		{
		error( "NextItem", "Item not in list" );
		}

	n = inventory.NumObjects();

	for( i = 1; i <= n; i++ )
		{
		next_item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );
      assert( next_item );
      
 		if ( next_item->isSubclassOf( InventoryItem ) && item_found )
         return next_item;

      if ( next_item == item )
         item_found = true;
      }

   return NULL;
   }


Item *Sentient::PrevItem
	(
	Item *item
	)

	{
	Item		*prev_item;
	int		i;
	int		n;
   qboolean item_found = false;

   if ( !item )
      {
      item_found = true;
      }
   else if ( !inventory.ObjectInList( item->entnum ) )
		{
		error( "NextItem", "Item not in list" );
		}

	n = inventory.NumObjects();

	for( i = n; i >= 1; i-- )
		{
		prev_item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );
      assert( prev_item );
      
 		if ( prev_item->isSubclassOf( InventoryItem ) && item_found)
         return prev_item;

      if ( prev_item == item )
         item_found = true;
      }

   return NULL;
   }


// This will search a dead body and create a floating inventory for that player
// which will be displayed on the client as a list of icons.  If the user presses
// use, then he will pick up the items in that floating inventory, and the body
// will be faded out.
void Sentient::SearchBody
   (
   Event *ev
   )

   {
   int i,n;
   Item *item;
   Entity *other;
   Player *player;
   Event *event;
   qboolean inventory_created = false;

	other = ev->GetEntity( 1 );
   assert( other );
   
   // Only players can touch this
   if ( !other->isSubclassOf( Player ) ) 
      return;

   // Can't touch yourself
   if ( other == this )
      return;

   // Make sure the body is dead
   if ( !deadflag )
      return;

   n = inventory.NumObjects();

   // No items, get out of here
   if ( n == 0 )
      {
      return;
      }

	player = ( Player * )other;

   // Check to see if this inventory is already being displayed for
   // this body.
   if ( player->GetFloatingOwner() == this )
      {
      // Still touching the body, so extend the clear time
      player->CancelEventsOfType( EV_Player_ClearFloatingInventory );
      event = new Event( EV_Player_ClearFloatingInventory );
      player->PostEvent( event, 0.4f );
      return;
      }
   else if ( player->GetFloatingOwner() )
      {
      // Currently looking at an inventory, so don't bother with this one.
      return;
      }
   else
      {
      // Make sure the inventory is cleared out before making a new one.
      // Could have some left over items in there from other bodies
      player->ProcessEvent( EV_Player_ClearFloatingInventory );
      }
      
   // Create the inventory
	for( i = 1; i <= n; i++ )
		{
		item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );
      assert( item );
      if ( item->Amount() )
         {
         player->AddItemToFloatingInventory( item );
         inventory_created = true;   
         }
      }
   
   if (!inventory_created)
      return;

   // Set the current owner of the inventory
   player->SetFloatingOwner( this );
   
   // Send the inventory to the client
   player->SendFloatingInventory();

   // Clear the inventory in the future
   event = new Event( EV_Player_ClearFloatingInventory );
   player->PostEvent( event, 0.3f );
   }
   
void Sentient::UselessCheck( Event *ev )
   {
   Item     *item;
   int      n;
   int      i;
   Event    *event;

   // Check to see if we have any inventory and
   // remove if we don't

   n = inventory.NumObjects();
   for ( i = 1; i <= n; i++ ) 
      {
      item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );
      assert( item );
      if ( item->Amount() )
         {
         PostEvent ( EV_Sentient_UselessCheck, 1.0f + G_Random() );
         return;
         }
      }

   event = new Event( "remove_useless" );
   ProcessEvent( event );
   }

qboolean Sentient::HasInventoryOfType
	(
	const char *type
	)

	{
	int	num;
	int	i;
	Item	*item;

	num = inventory.NumObjects();
	for( i = num; i > 0; i-- )
		{
		item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );
		if ( checkInheritance( type, item->getClassname() ) )
         {
         return true;
         }    
		}
   return false;
	}

void Sentient::DropInventoryItems
   (
   void
   )

   {
   int   num;
   int   i;
   Item  *item;

   // Drop any inventory items
 	num = inventory.NumObjects();
	for( i = num; i >= 1; i-- )
		{
		item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );
      if ( item->isSubclassOf( InventoryItem ) )
         {
         item->Drop();
         }
      }
   }

qboolean Sentient::PowerupActive
   (
   void
   )

   {
   if ( poweruptype && this->client )
      {
      gi.cprintf( edict, PRINT_HIGH, "You are already using a powerup\n" );
      }

   return poweruptype;
   }

void Sentient::SprayBlood
   (
   Vector src,
   Vector dir,
   float damage
   )

   {
	trace_t	trace;
   Vector	norm;
	Vector	end;
   Vector   ang;
   float		dist;
   float		scale;
   BloodSplat *splat;

	dir.normalize();
	end = src + dir * 2048;

	trace = G_Trace( src, vec_zero, vec_zero, end, this, MASK_SOLIDNONFENCE, "Sentient::SprayBlood" );

	if ( HitSky( &trace ) || ( trace.ent->solid != SOLID_BSP ) || ( trace.ent->s.number != 0 ) ) 
		{
		return;
		}
   
   dist = ( Vector( trace.endpos ) - src ).length();
   scale = damage / ( dist * 0.3 );
   if ( scale > 0.6 )
		{
      scale = 0.6;
		}

   if ( scale < 0.02 )
		{
      return;
		}

   norm = trace.plane.normal;
   norm.x = -norm.x;
   norm.y = -norm.y;
   ang = norm.toAngles();
	ang.z = G_Random( 360 );
   end = trace.endpos + Vector( trace.plane.normal ) * 0.2;

   splat = new BloodSplat( end, ang, scale );
   }

EXPORT_FROM_DLL void Sentient::setModel
	(
	const char *mdl
	)

	{
   if ( currentWeapon )
      {
      // rebind the current gun
      currentWeapon->DetachFromOwner();
      Entity::setModel( mdl );
      currentWeapon->AttachToOwner();
      }
   else
      {
      Entity::setModel( mdl );
      }
	}

void Sentient::TurnOffShadow
   (
   Event *ev
   )

   {
   // HACK FIXME
   //
   // temporary shadow flag
   //
   edict->s.renderfx &= ~RF_XFLIP;
   }

EXPORT_FROM_DLL void Sentient::Archive
	(
	Archiver &arc
	)
   {
   int i;
   int num;

   Entity::Archive( arc );

   num = inventory.NumObjects();
	arc.WriteInteger( num  );
	for( i = 1; i <= num; i++ )
		{
		arc.WriteInteger( inventory.ObjectAt( i ) );
		}
   arc.WriteObjectPointer( currentWeapon );
   arc.WriteObjectPointer( currentItem );
   arc.WriteObjectPointer( newWeapon );
   arc.WriteString( currentAnim );
   arc.WriteBoolean( animOverride );
   arc.WriteEvent( *tempAnimEvent );
   arc.WriteString( gun_bone_group_name );
   arc.WriteBoolean( stopanimating_tillchange );
   arc.WriteInteger( poweruptype );
   arc.WriteInteger( poweruptimer );
   arc.WriteBoolean( sentientFrozen );
   arc.WriteBoolean( dropweapon );
   arc.WriteVector( gunoffset );
   arc.WriteVector( eyeposition );
   arc.WriteFloat( firedowntime );
   arc.WriteBoolean( firedown );
   arc.WriteString( saveskin );
   arc.WriteString( savemodel );
   }

EXPORT_FROM_DLL void Sentient::Unarchive
	(
	Archiver &arc
	)
   {
   int i;
   int num;
   int temp;

   Entity::Unarchive( arc );

   inventory.FreeObjectList();
	num = arc.ReadInteger();
	for( i = 1; i <= num; i++ )
		{
		temp = arc.ReadInteger();
		inventory.AddObject( temp );
		}

   arc.ReadObjectPointer( ( Class ** )&currentWeapon );
   arc.ReadObjectPointer( ( Class ** )&currentItem );
   arc.ReadObjectPointer( ( Class ** )&newWeapon );
   arc.ReadString( &currentAnim );
   arc.ReadBoolean( &animOverride );
   //FIXME
   // make a ReadEventPointer function
   tempAnimEvent = new Event( arc.ReadEvent() );
   arc.ReadString( &gun_bone_group_name );
   arc.ReadBoolean( &stopanimating_tillchange );
   arc.ReadInteger( &poweruptype );
   arc.ReadInteger( &poweruptimer );
   arc.ReadBoolean( &sentientFrozen );
   arc.ReadBoolean( &dropweapon );
   arc.ReadVector( &gunoffset );
   arc.ReadVector( &eyeposition );
   arc.ReadFloat( &firedowntime );
   arc.ReadBoolean( &firedown );
   arc.ReadString( &saveskin );
   arc.ReadString( &savemodel );
   }

void Sentient::WritePersistantData
   (
   SpawnArgGroup &group
   )

   {
   int i;
   int num;
   Entity *ent;

   G_SetSpawnArg( "classname", getClassname() );
   if ( currentWeapon )
      {
      G_SetSpawnArg( "current_weapon", currentWeapon->getClassname() );
      }
   if ( currentItem )
      {
      G_SetSpawnArg( "current_item", currentItem->getClassname() );
      }

   G_SetIntArg( "health", health );
   G_SetIntArg( "max_health", max_health );
   G_SetIntArg( "savegame", 1 );

   group.AddArgs();

   num = inventory.NumObjects();
	for( i = 1; i <= num; i++ )
		{
      ent = G_GetEntity( inventory.ObjectAt( i ) );
      if ( ent && ent->isSubclassOf( Item ) )
         {
         G_InitSpawnArguments();
         ( ( Item * )ent )->CreateSpawnArgs();
         G_SetSpawnArg( "classname", ent->getClassname() );
         G_SetIntArg( "savegame", 1 );
         group.AddArgs();
         }
		}

   G_InitSpawnArguments();
   }

void Sentient::RestorePersistantData
   (
   SpawnArgGroup &group
   )

   {
   str weap;
   str item;
   Entity *ent;
   int i;
   int num;
   Item *it;

   num = group.NumInGroup();
   for( i = 2; i <= num; i++ )
      {
      group.RestoreArgs( i );

	   game.force_entnum = false;
		ent = G_CallSpawn();
      if ( !ent->isSubclassOf( Item ) )
         {
         error( "RestorePersistantData", "Loaded non-Item object of class %s\n", ent->getClassname() );
         }

      // G_CallSpawn clears all the spawnargs
      group.RestoreArgs( i );

      it = ( Item * )ent;
      it->SetOwner( this );
      it->ProcessPendingEvents();
      AddItem( it );
      }

   group.RestoreArgs( 1 );

   weap = G_GetStringArg( "current_weapon" );
   item = G_GetStringArg( "current_item" );

   health = G_GetIntArg( "health", 100 );
   max_health = G_GetIntArg( "max_health", 100 );

   if ( weap.length() )
      {
      it = FindItem( weap.c_str() );
      assert( it );
      if ( it )
         {
         if ( !it->isSubclassOf( Weapon ) )
            {
            error( "RestorePersistantData", "Tried to set non-weapon of type %s as current weapon\n", it->getClassname() );
            }
         SetCurrentWeapon( ( Weapon * )it );
         }
      }

   if ( item.length() )
      {
      it = FindItem( item.c_str() );
      assert( it );
      if ( it )
         {
         if ( !it->isSubclassOf( InventoryItem ) )
            {
            error( "RestorePersistantData", "Tried to set non-inventory item of type %s as current item\n", it->getClassname() );
            }
         currentItem = ( InventoryItem * )it;
         }
      }

   }

EXPORT_FROM_DLL void Sentient::Freeze
   (
   Event *ev
   )

   {
   sentientFrozen = true;
   }

EXPORT_FROM_DLL void Sentient::UnFreeze
   (
   Event *ev
   )

   {
   sentientFrozen = false;
   }

void Sentient::ImpactDamage
   (
   Event *ev
   )

   {
   float damg;
   
   if ( deathmatch->value )
      {
      damg  = velocity.length();
      damg /= 20.0f;
      }
   else
      {
      damg = 100;
      }
    
   setMoveType( MOVETYPE_STEP );
   Damage(world, enemy, damg,
          worldorigin, vec_zero, vec_zero, 0, 
          0, MOD_IMPACT,
          -1, -1, 1.0f );
   }

void Sentient::WeaponUse
   (
   Event *ev
   )

   {
   Event *event;

   if ( !currentWeapon )
      return;

   currentWeapon->ForceState( WEAPON_READY );

   event = new Event( EV_Weapon_SecondaryUse );
   event->AddEntity( this );
   currentWeapon->ProcessEvent( event );
   }

void Sentient::DoubleArmor
   (
   void
   )

   {
   int i,n;
   
   n = inventory.NumObjects();

	for( i = 1; i <= n; i++ )
		{
		Item  *item;
      item = ( Item * )G_GetEntity( inventory.ObjectAt( i ) );

 		if ( item->isSubclassOf( Armor ) )
         item->Set( item->Amount() * 2 );
      }  
   }

void Sentient::WeaponKnockedFromHands
   (
   void
   )

   {
   str realname;

   realname = GetRandomAlias( "snd_lostweapon" );
	if ( realname.length() > 1 )
      {
      sound( realname, 1, CHAN_VOICE );
      }
   else
      {
      RandomSound( "snd_pain", 1, CHAN_VOICE );
      }
   }

void Sentient::SetDropWeapon
   (
   Event *ev
   )

   {
   dropweapon = ev->GetInteger( 1 );
   }

void Sentient::DropWeaponNowEvent
   (
   Event *ev
   )

   {
   DropCurrentWeapon();
   }