//-----------------------------------------------------------------------------
//
//  $Logfile:: /Code/DLLs/game/entity.cpp           $
// $Revision:: 271                                                           $
//   $Author:: Steven                                                   $
//     $Date:: 10/13/03 9:43a                                  $
//
// Copyright (C) 2002 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.
//
//
// DESCRIPTION:
// Base class for all enities that are controlled by the game.  If you have any
// object that should be called on a periodic basis and it is not an entity,
// then you have to have an dummy entity that calls it.
//
// An entity in the game is any object that is not part of the world.  Any non-world
// object that is visible in the game is an entity, although it is not required that
// all entities be visible to the player.  Some objects are basically just virtual
// constructs that act as an instigator of certain actions, for example, some
// triggers are invisible and cannot be touched, but when activated by other
// objects can cause things to happen.
//
// All entities are capable of receiving messages from the game or from other entities.
// Messages received by an entity may be ignored, passed on to their superclass,
// or acted upon by the entity itself.  The programmer must decide on the proper
// action for the entity to take to any message.  There will be many messages
// that are completely irrelevant to an entity and should be ignored.  Some messages
// may require certain states to exist and if they are received by an entity when
// it these states don't exist may indicate a logic error on the part of the
// programmer or map designer and should be reported as warnings (if the problem is
// not severe enough for the game to be halted) or as errors (if the problem should
// not be ignored at any cost).
//

#include "_pch_cpp.h"
//#include "g_local.h"
#include "entity.h"
#include "worldspawn.h"
#include "scriptmaster.h"
#include "sentient.h"
#include "specialfx.h"
#include "misc.h"
#include "object.h"
#include "player.h"
#include "weaputils.h"
#include "soundman.h"
#include "earthquake.h"
#include <qcommon/qfiles.h>
#include "mp_manager.hpp"
#include <qcommon/gameplaymanager.h>


// Player events
Event EV_ClientMove
	(
	"client_move",
   EV_DEFAULT,
	NULL,
	NULL,
	"The movement packet from the client is processed by this event."
	);
Event EV_ClientEndFrame
	(
	"client_endframe",
	EV_DEFAULT,
	NULL,
	NULL,
	"Called at the end of each frame for each client."
	);

// Generic entity events
Event EV_Classname
	(
	"classname" ,
	EV_TIKIONLY,
	"s",
	"nameOfClass",
	"Determines what class to use for this entity,\n"
	"this is pre-processed from the BSP at the start\n"
	"of the level."
	);
Event EV_SpawnFlags
	(
	"spawnflags",
	EV_CODEONLY,
	"i",
	"flags",
	"spawnflags from the BSP, these are set inside the editor"
	);
Event EV_SetTeam
	(
	"team",
	EV_DEFAULT,
	"s",
	"moveTeam",
	"used to make multiple entities move together."
	);
Event EV_Trigger
	(
	"trigger",
	EV_SCRIPTONLY,
	"s",
	"name",
	"Trigger the specified target or entity."
	);
Event EV_Activate
	(
	"doActivate",
	EV_DEFAULT,
	"e",
	"activatingEntity",
	"General trigger event for all entities"
	);
Event EV_Use
	(
	"doUse",
	EV_DEFAULT,
	"e",
	"activatingEntity",
	"sent to entity when it is used by another entity"
	);

Event EV_FadeNoRemove
	(
	"fade",
	EV_DEFAULT,
	"F[0,]F[0,1]",
	"fadetime target_alpha",
	"Fade the entity's alpha, reducing it by 0.03\n"
	"every FRAMETIME, until it has faded out, does not remove the entity"
	);

Event EV_FadeOut
	(
	"_fadeout",
	EV_CODEONLY,
	NULL,
	NULL,
	"Fade the entity's alpha and scale out, reducing it by 0.03\n"
	"every FRAMETIME, until it has faded out, removes the entity\n"
   "Once the entity has been completely faded, the entity is removed."
	);

Event EV_Fade
	(
	"fadeout",
	EV_DEFAULT,
	"F[0,]F[0,1]",
	"fadetime target_alpha",
	"Fade the entity's alpha and scale out, reducing it by 0.03\n"
	"every FRAMETIME, until it has faded out. If fadetime or\n"
   "target_alpha are defined, they will override the defaults.\n"
   "Once the entity has been completely faded, the entity is removed."
	);
Event EV_FadeIn
	(
	"fadein",
	EV_DEFAULT,
   "F[0,]F[0,1]",
   "fadetime target_alpha",
	"Fade the entity's alpha and scale in, increasing it by 0.03\n"
	"every FRAMETIME, until it has faded completely in to 1.0.\n"
   "If fadetime or target_alpha are defined, they will override\n"
   "the default values."
	);
 Event EV_Killed
	(
	"killed",
	EV_DEFAULT,
	"efei",
	"attacker damage inflictor meansofdeath",
	"event which is sent to an entity once it as been killed"
	);
Event EV_GotKill
	(
	"gotkill" ,
	EV_DEFAULT,
	"eieib",
	"victim damage inflictor meansofdeath gib",
	"event sent to attacker when an entity dies"
	);
Event EV_Pain
	(
	"pain",
	EV_DEFAULT,
	"iei",
	"damage attacker meansofdeath",
	"used to inflict pain to an entity"
	);
Event EV_Damage
	(
	"_damage",
	EV_CODEONLY,
	"feevvviii",
	"damage inflictor attacker position direction normal knockback damageflags meansofdeath",
	"general damage event used by all entities"
	);
Event EV_Stun
	(
	"_stun",
	EV_CODEONLY,
	"f",
	"time",
	"Stun this entity for the specified time"
	);
Event EV_Kill
	(
	"kill",
	EV_CONSOLE,
	NULL,
	NULL,
	"console based command to kill yourself if stuck."
	);
Event EV_Gib
	(
	"gib",
	EV_DEFAULT,
	"iIFS",
	"number power scale gibmodel",
	"causes entity to spawn a number of gibs"
	);
Event EV_Hurt
	(
	"hurt",
	EV_DEFAULT,
	"fSV",
	"damage means_of_death direction",
	"Inflicts damage if the entity is damageable.  If the number of damage\n"
	"points specified in the command argument is greater or equal than the\n"
	"entity's current health, it will be killed or destroyed."
	);

Event EV_TakeDamage
	(
	"takedamage",
	EV_DEFAULT,
	NULL,
	NULL,
	"makes entity take damage."
	);
Event EV_NoDamage
	(
	"nodamage",
	EV_DEFAULT,
	NULL,
	NULL,
	"entity does not take damage."
	);

Event EV_Stationary
	(
	"stationary",
	EV_DEFAULT,
	NULL,
	NULL,
	"entity does not move, causes no physics to be run on it."
	);

// Physics events
Event EV_MoveDone
	(
	"movedone",
	EV_DEFAULT,
	"e",
	"finishedEntity",
	"Sent to commanding thread when done with move ."
	);
Event EV_Touch
	(
	"doTouch",
	EV_DEFAULT,
	"e",
	"touchingEntity",
	"sent to entity when touched for the first time."
	);
Event EV_Contact
	(
	"inContactWithEntity",
	EV_DEFAULT,
	"e",
	"entityWrapper",
	"sent to an entity that is in contact with specified entity."
	);
Event EV_LostContact
	(
	"lostContactWithEntity",
	EV_DEFAULT,
	"e",
	"entityNoLongerInContact",
	"sent to an entity no longer in contact with specified entity."
	);
Event EV_Blocked
	(
	"doBlocked",
	EV_DEFAULT,
	"e",
	"obstacle",
	"sent to entity when blocked."
	);
Event EV_UseBoundingBox
	(
	"usebbox",
	EV_DEFAULT,
	NULL,
	NULL,
	"do not perform perfect collision, use bounding box instead."
	);
Event EV_Gravity
	(
	"gravity",
	EV_DEFAULT,
	"f",
	"gravityValue",
	"Change the gravity on this entity"
	);
Event EV_Stop
	(
	"stopped",
	EV_DEFAULT,
	NULL,
	NULL,
	"sent when entity has stopped bouncing for MOVETYPE_TOSS."
	);
Event EV_SetFullTrace
	(
	"fulltrace",
	EV_DEFAULT,
	"b",
	"on_or_off",
	"Turns fulltrace physics movement on or off for this entity."
	);

Event EV_ProcessInitCommands
	(
	"processinit",
	EV_CODEONLY,
	"i",
	"modelIndex",
	"process the init section of this entity, this is an internal command,\n"
	"it is not meant to be called from script."
	);
Event EV_Attach
	(
	"attach",
	EV_DEFAULT,
	"esIVV",
	"parent tagname use_angles offset angles_offset",
	"attach this entity to the parent's legs tag called tagname"
	);
Event EV_AttachModel
	(
	"attachmodel",
	EV_DEFAULT,
	"ssFSBFFFFVV",
	"modelname tagname scale targetname detach_at_death removetime fadeintime fadeoutdelay fadetime offset angles_offset",
	"attach a entity with modelname to this entity to tag called tagname.\n"
	"scale           - scale of attached entities\n"
	"targetname      - targetname for attached entities\n"
	"detach_at_death - when entity dies, should this model be detached.\n"
	"removetime      - when the entity should be removed, if not specified, never.\n"
   "fadeintime      - time to fade the model in over.\n"
   "fadeoutdelay    - time to wait until we fade the attached model out\n"
   "fadeoutspeed    - time the model fades out over\n"
	"offset		     - vector offset for the model from the specified tag\n"
	"angles_offset   - angles offset for the model from the specified tag"
	);
Event EV_RemoveAttachedModel
	(
	"removeattachedmodel",
	EV_DEFAULT,
	"sFS",
	"tagname fadetime modelname",
	"Removes the model attached to this entity at the specified tag."
	);
Event EV_RemoveAttachedModelByTargetname
(
	"removeAttachedModelByTargetname",
	EV_DEFAULT,
	"s",
	"targetname",
	"Removes all models that are attached to this entity with the specified targetname."
);
Event EV_Detach
	(
	"detach",
	EV_SCRIPTONLY,
	NULL,
	NULL,
	"detach this entity from its parent."
	);

Event EV_IncreaseShotCount
   (
	"increaseshotcount",
	EV_DEFAULT,
	NULL,
	NULL,
	"boosts the shotsFired on this entity's parent if it is an actor"
	);

// script stuff
Event EV_Model
	(
	"model",
	EV_DEFAULT,
	"s", 
	"modelName",
	"set the model to modelName."
	);
Event EV_Hide
	(
	"hide",
	EV_DEFAULT,
	NULL,
	NULL,
	"hide the entity, opposite of show."
	);
Event EV_Show
	(
	"show",
	EV_DEFAULT,
	NULL,
	NULL,
	"show the entity, opposite of hide."
	);
Event EV_BecomeSolid
	(
	"solid",
	EV_DEFAULT,
	NULL,
	NULL,
	"make solid."
	);
Event EV_BecomeNonSolid
	(
	"notsolid",
	EV_DEFAULT,
	NULL,
	NULL,
	"make non-solid."
	);
Event EV_Ghost
	(
	"ghost",
	EV_DEFAULT,
	NULL,
	NULL,
	"make non-solid but still send to client regardless of hide status."
	);
Event EV_TouchTriggers
	(
	"touchtriggers",
	EV_DEFAULT,
   "B",
   "touch_triggers_bool",
   "Sets whether the entity should touch triggers or not"
	);
Event EV_Sound
	(
	"playsound",
	EV_DEFAULT,
	"sIFS",
	"soundName channel volume min_distance",
	"play a sound coming from this entity.\n"
	"default channel, CHAN_BODY."
	);
Event EV_StopSound
	(
	"stopsound",
	EV_DEFAULT,
	"I",
	"channel",
	"stop the current sound on the specified channel.\n"
	"default channel, CHAN_BODY."
	);
Event EV_Bind
	(
	"bind",
	EV_DEFAULT,
	"e",
	"parent",
	"bind this entity to the specified entity."
	);
Event EV_Unbind
	(
	"unbind",
	EV_DEFAULT,
	NULL,
	NULL,
	"unbind this entity."
	);
Event EV_JoinTeam
	(
	"joinTeam",
	EV_DEFAULT,
	"e",
	"teamMember",
	"join a bind team."
	);
Event EV_QuitTeam
	(
	"quitTeam",
	EV_DEFAULT,
	NULL,
	NULL,
	"quit the current bind team"
	);
Event EV_SetHealth
   (
   "health",
   EV_CHEAT | EV_TIKIONLY,
   "i",
   "newHealth",
   "set the health of the entity to newHealth"
   );
Event EV_GetHealth
   (
   "gethealth",
   EV_CHEAT | EV_SCRIPTONLY,
   "@f",
   "currentHealth",
   "Gets the health of the entity"
   );
Event EV_SetMaxHealth
	(
	"maxhealth",
	EV_CHEAT,
	"i",
	"newMaxHealth",
	"set the max_health of the entity to newMaxHealth"
	);
Event EV_SetScale
   (
   "scale",
   EV_DEFAULT,
   "f",
   "newScale",
   "set the scale of the entity"
   );
Event EV_SetRandomScale
   (
   "randomScale",
   EV_DEFAULT,
   "fd",
   "minScale maxScale",
   "Set the scale of the entity randomly between minScale and maxScale"
   );
Event EV_SetSize
   (
   "setsize",
   EV_DEFAULT,
   "vv",
   "mins maxs",
   "Set the bounding box of the entity to mins and maxs."
   );
Event EV_GetMins
	(
	"getmins",
	EV_SCRIPTONLY,
	"@v",
	"returnval",
	"Returns the minimum extent of the bounding box"
	);
Event EV_GetMaxs
	(
	"getmaxs",
	EV_SCRIPTONLY,
	"@v",
	"returnval",
	"Returns the maximum extent of the bounding box"
	);
Event EV_SetMins
   (
   "_setmins",
   EV_CODEONLY,
   "v",
   "mins",
   "Set the mins of the bounding box of the entity to mins."
   );
Event EV_SetMaxs
   (
   "_setmaxs",
   EV_CODEONLY,
   "v",
   "maxs",
   "Set the maxs of the bounding box of the entity to maxs."
   );
Event EV_SetAlpha
   (
   "alpha",
   EV_DEFAULT,
   "f",
   "newAlpha",
   "Set the alpha of the entity to alpha."
   );
Event EV_SetOrigin
   (
   "origin",
   EV_SCRIPTONLY,
   "v",
   "newOrigin",
   "Set the origin of the entity to newOrigin."
   );
Event EV_SetOriginEveryFrame
	(
	"setorigineveryframe",
	EV_DEFAULT,
	NULL,
	NULL,
	"Sets the origin every frame ( for bound objects )"
	);

Event EV_GetOrigin
   (
   "getorigin",
   EV_CHEAT | EV_SCRIPTONLY,
   "@v",
   "returnval",
   "Gets the origin of the entity."
   );
Event EV_SetTargetName
   (
   "targetname",
   EV_SCRIPTONLY,
   "s",
   "targetName",
   "set the targetname of the entity to targetName."
   );
Event EV_GetTargetName
   (
   "getTargetName",
   EV_SCRIPTONLY,
   "@s",
   "targetName",
   "Gets the targetname of the entity with the leading $."
   );
Event EV_GetRawTargetName
   (
   "getRawTargetName",
   EV_SCRIPTONLY,
   "@s",
   "rawTargetName",
   "Gets the targetname of the entity without the leading $."
   );
Event EV_SetTarget
   (
   "target",
   EV_DEFAULT,
   "s",
   "targetname_to_target",
   "target another entity with targetname_to_target."
   );
Event EV_GetTarget
   (
   "getTarget",
   EV_SCRIPTONLY,
   "@sB",
   "name_of_current_target wantsPrefix",
   "Returns the name of the current target."
   );

Event EV_GetTargetEntity
	(
	"gettargetentity",
	EV_SCRIPTONLY,
	"@e",
	"NULL",
	"Returns the current target entity"
	);

Event EV_SetKillTarget
   (
   "killtarget",
   EV_DEFAULT,
   "s",
   "targetName",
   "when dying kill entities with this targetName."
   );
Event EV_GetModelName
	(
	"getmodelname",
	EV_SCRIPTONLY,
	"@s",
	"modelname",
	"Retrieves the model name of the entity"
	);
Event EV_SetAngles
   (
   "angles",
   EV_SCRIPTONLY,
   "v[0,360][0,360][0,360]",
   "newAngles",
   "set the angles of the entity to newAngles."
   );
Event EV_GetAngles
	(
	"getangles",
	EV_SCRIPTONLY,
	"@v",
	"angle_vector",
	"Retrieves the entity's angles"
	);
Event EV_SetAngle
   (
   "angle",
   EV_DEFAULT,
   "f",
   "newAngle",
   "set the angles of the entity using just one value.\n"
   "Sets the yaw of the entity or an up and down\n"
   "direction if newAngle is [0-359] or -1 or -2"
   );
Event EV_RegisterAlias
   (
   "alias",
   EV_CACHE,
   "ssSSSSSS",
   "alias realname parameter1 parameter2 parameter3 parameter4 parameter5 paramater6",
   "create an alias for the given realname\n"
   "Valid parameters are as follows:\n"
   "global - all instances act as one\n"
   "stop - once used, don't use again\n"
   "timeout [seconds] - once used wait [seconds] until using again\n"
   "maxuse [times] - can only be used [times] times.\n"
   "weight [weight] - random weighting"
   );
Event EV_RegisterAliasAndCache
   (
   "aliascache",
   EV_CACHE,
   "ssSSSSSS",
   "alias realname parameter1 parameter2 parameter3 parameter4 parameter5 paramater6",
   "create an alias for the given realname and cache the resource\n"
   "Valid parameters are as follows:\n"
   "global - all instances act as one\n"
   "stop - once used, don't use again\n"
   "timeout [seconds] - once used wait [seconds] until using again\n"
   "maxuse [times] - can only be used [times] times.\n"
   "weight [weight] - random weighting"
   );
Event EV_Cache
   (
   "cache",
   EV_CACHE,
   "s",
   "resourceName",
   "pre-cache the given resource."
   );
Event EV_AutoCache
   (
   "autocache",
   EV_CACHE | EV_TIKIONLY,
   "s",
   "resourceName",
   "pre-cache the given resource."
   );
Event EV_SetMass
   (
   "mass",
   EV_TIKIONLY,
   "i",
   "massAmount",
   "set the mass of this entity."
   );

Event EV_LoopSound
   (
   "loopsound",
   EV_DEFAULT,
   "sFS",
   "soundName volume minimum_distance",
   "play a looped-sound with a certain volume and minimum_distance\n"
   "which is attached to the current entity."
   );
Event EV_StopLoopSound
   (
   "stoploopsound",
   EV_DEFAULT,
   NULL,
   NULL,
   "Stop the looped-sound on this entity."
   );

Event EV_SurfaceModelEvent
   (
   "surface",
   EV_DEFAULT,
   "sSSSSSS",
   "surfaceName parameter1 parameter2 parameter3 parameter4 parameter5 parameter6",
   "change a legs surface parameter for the given surface.\n"
   "+ sets the flag, - clears the flag\n"
   "Valid surface commands are:\n"
   "skin1 - set the skin1 offset bit\n"
   "skin2 - set the skin2 offset bit\n"
   "nodraw - don't draw this surface"
   );


Event EV_SetAnimOnAttachedModel
   (
	"attachanim",
	EV_DEFAULT,
	"ss",
	"anim_name tag_name",
	"sets the anim on an attached entity at the specified tag"
	);

Event EV_SetCinematicAnim
	(
	"setcinematicanim",
	EV_DEFAULT,
	"s",
	"anim_name",
	"sets a cinematic anim on an entity"
	);

Event EV_CinematicAnimDone
	(
	"cinematicanimdone",
	EV_CODEONLY,
	NULL,
	NULL,
	"Called when an entity's cinematic animation is done, "
	"it is not meant to be called from script."
	);

Event EV_SetEntityExplosionModel
   (
   "setentityexplosionmodel",
	EV_DEFAULT,
	"s",
	"model_name",
	"sets this entitys explosion model which is used in selfDetonate"
	);

// AI sound events
Event EV_BroadcastSound
   (
   "soundevent",
   EV_DEFAULT,
   "FS",
   "soundRadius soundtype",
   "Let the AI know that this entity made a sound,\n"
   "radius determines how far the sound reaches."
   );
Event EV_HeardSound
   (
   "heardsound",
   EV_DEFAULT,
   "evi",
   "noisyEntity noisyLocation soundtype",
   "sent to entities when another makes a sound, not for script use\n"
   );

// Conditionals
Event EV_IfSkill
   (
   "ifskill",
   EV_DEFAULT,
   "isSSSSS",
   "skillLevel command argument1 argument2 argument3 argument4 argument5",
   "if the current skill level is skillLevel than execute command"
   );

// Lighting
Event EV_SetLight
   (
   "light",
   EV_DEFAULT,
   "ffff",
   "color_red color_green color_blue radius",
   "Create a dynmaic light on this entity."
   );

Event EV_LightOn
   (
   "lightOn",
   EV_DEFAULT,
   NULL,
   NULL,
   "Turn the configured dynmaic light on this entity on."
   );
Event EV_LightOff
   (
   "lightOff",
   EV_DEFAULT,
   NULL,
   NULL,
   "Turn the configured dynamic light on this entity off."
   );
Event EV_LightStyle
   (
   "lightStyle",
   EV_DEFAULT,
   "i",
   "lightStyleIndex",
   "What light style to use for this dynamic light on this entity."
   );
Event EV_LightRed
   (
   "lightRed",
   EV_DEFAULT,
   "f",
   "red",
   "Set the red component of the dynmaic light on this entity."
   );
Event EV_LightGreen
   (
   "lightGreen",
   EV_DEFAULT,
   "f",
   "green",
   "Set the green component of the dynmaic light on this entity."
   );
Event EV_LightBlue
   (
   "lightBlue",
   EV_DEFAULT,
   "f",
   "blue",
   "Set the blue component of the dynmaic light on this entity."
   );
Event EV_LightRadius
   (
   "lightRadius",
   EV_DEFAULT,
   "f",
   "radius",
   "Set the radius of the dynmaic light on this entity."
   );

// Entity flag specific
Event EV_EntityFlags
   (
   "flags",
   EV_DEFAULT,
   "SSSSSS",
   "parameter1 parameter2 parameter3 parameter4 parameter5 parameter6",
   "Change the current entity flags.\n"
   "Valid flags are as follows:\n"
   "+ sets a flag, - clears a flag\n"
   "blood - should it bleed\n"
   "explode - should it explode when dead\n"
   "die_gibs - should it spawn gibs when dead\n"
   "god - makes the entity invincible\n"
	"notarget - makes the entity notarget\n"
   );
Event EV_EntityRenderEffects
   (
   "rendereffects",
   EV_DEFAULT,
   "SSSSSS",
   "parameter1 parameter2 parameter3 parameter4 parameter5 parameter6",
   "Change the current render effects flags.\n"
   "Valid flags are as follows:\n"
   "+ sets a flag, - clears a flag\n"
   "dontdraw - send the entity to the client, but don't draw\n"
   "betterlighting - do sphere based vertex lighting on the entity\n"
   "lensflare - add a lens glow to the entity at its origin\n"
   "viewlensflare - add a view dependent lens glow to the entity at its origin\n"
   "lightoffset - use the dynamic color values as a light offset to the model\n"
   "skyorigin - this entity is the portal sky origin\n"
   "minlight - this entity always has some lighting on it\n"
   "fullbright - this entity is always fully lit\n"
   "additivedynamiclight - the dynamic light should have an additive effect\n"
   "lightstyledynamiclight - the dynamic light uses a light style, use the\n"
   "depthhack - this entity is drawn with depth hack on\n"
   "'lightstyle' command to set the index of the light style to be used"

   );
Event EV_EntityEffects
   (
   "effects",
   EV_DEFAULT,
   "SSSSSS",
   "parameter1 parameter2 parameter3 parameter4 parameter5 parameter6",
   "Change the current entity effects flags.\n"
   "Valid flags are as follows:\n"
   "+ sets a flag, - clears a flag\n"
   "everyframe - process commands every time entity is rendered"
   );
Event EV_EntitySVFlags
   (
   "svflags",
   EV_DEFAULT,
   "SSSSSS",
   "parameter1 parameter2 parameter3 parameter4 parameter5 parameter6",
   "Change the current server flags.\n"
   "Valid flags are as follows:\n"
   "+ sets a flag, - clears a flag\n"
   "broadcast - always send this entity to the client"
   );

// Special Effects
Event EV_Censor
   (
   "censor",
   EV_TIKIONLY,
   NULL,
   NULL,
   "used to ban certain contact when in parentmode\n"
   );
Event EV_Explosion
   (
   "explosionattack",
   EV_DEFAULT,
   "sS",
   "explosionModel tagName",
   "Spawn an explosion optionally from a specific tag"
   );
Event EV_DoRadiusDamage
	(
	"doradiusdamage",
	EV_DEFAULT,
	"fsffBF",
	"damage meansofdeath radius knockback constant_damage repeat_time",
	"calls RadiusDamage() using the entity information and owner"
	);
Event EV_SelfDetonate
   (
	"selfdetonate",
	EV_DEFAULT,
	NULL,
	NULL,
	"spawns and explosion and removes this entity"
	);

Event EV_ShaderEvent
   (
   "shader",
   EV_DEFAULT,
   "sfF",
   "shaderCommand argument1 argument2",
   "change a specific shader parameter for the entity.\n"
   "Valid shader commands are:\n"
   "translation [trans_x] [trans_y] - change the texture translation\n"
   "offset [offset_x] [offset_y] - change the texture offset\n"
   "rotation [rot_speed] - change the texture rotation speed\n"
   "frame [frame_num] - change the animated texture frame\n"
   "wavebase [base] - change the base parameter of the wave function\n"
   "waveamp [amp] - change the amp parameter of the wave function\n"
   "wavebase [phase] - change the phase parameter of the wave function\n"
   "wavefreq [freq] - change the frequency parameter of the wave function\n"
   );

Event EV_ScriptShaderEvent
   (
   "scriptshader",
   EV_DEFAULT,
   "sfF",
   "shaderCommand argument1 argument2",
   "alias for shader command, change a specific shader parameter for the entity.\n"
   "Valid shader commands are:\n"
   "translation [trans_x] [trans_y] - change the texture translation\n"
   "offset [offset_x] [offset_y] - change the texture offset\n"
   "rotation [rot_speed] - change the texture rotation speed\n"
   "frame [frame_num] - change the animated texture frame\n"
   "wavebase [base] - change the base parameter of the wave function\n"
   "waveamp [amp] - change the amp parameter of the wave function\n"
   "wavebase [phase] - change the phase parameter of the wave function\n"
   "wavefreq [freq] - change the frequency parameter of the wave function\n"
   );

Event EV_KillAttach
   (
   "killattach",
   EV_DEFAULT,
   NULL,
   NULL,
   "kill all the attached entities."
   );
Event EV_DropToFloor
	(
	"droptofloor",
	EV_CODEONLY,
	"F",
	"maxRange",
	"drops the entity to the ground, if maxRange is not specified 8192 is used."
	);
Event EV_AddToSoundManager
	(
	"_addtosoundmanager",
	EV_CODEONLY,
	NULL,
	NULL,
	"adds the current entity to the sound manager."
	);
Event EV_SetControllerAngles
	(
	"setcontrollerangles",
	EV_CODEONLY,
	"iv",
	"num angles",
	"Sets the control angles for the specified bone."
	);
Event EV_DeathSinkStart
	(
	"deathsinkstart",
	EV_CODEONLY,
	NULL,
	NULL,
	"Makes the entity sink into the ground and then get removed (this starts it)."
	);
Event EV_DeathSink
	(
	"deathsinkeachframe",
	EV_CODEONLY,
	NULL,
	NULL,
	"Makes the entity sink into the ground and then get removed (this gets called each frame)."
	);
Event EV_DamageType
	(
	"damage_type",
	EV_DEFAULT,
	"s",
   "meansofdeathstring",
	"Set the type of damage that this entity can take"
	);
Event EV_LookAtMe
	(
	"lookatme",
	EV_DEFAULT,
	NULL,
   NULL,
	"Makes the player look at this object if close."
	);
Event EV_ProjectilesCanStickToMe
	(
	"projectilecansticktome",
	EV_DEFAULT,
	"b",
	"can_stick",
	"Bool that determines whether projectiles stick in this entity."
	);
Event EV_DetachAllChildren
	(
	"detachallchildren",
	EV_SCRIPTONLY,
	NULL,
   NULL,
	"Detach all the children from the entity."
	);
Event EV_Morph
	(
	"morph",
	EV_DEFAULT,
	"sFFB",
   "morph_target_name final_percent morph_time return_to_zero",
	"Morphs to the specified morph target"
	);
Event EV_Unmorph
	(
	"unmorph",
	EV_DEFAULT,
	"s",
   "morph_target_name",
	"Unmorphs the specified morph target"
	);
Event EV_MorphControl
	(
	"morphcontrol",
	EV_CODEONLY,
	NULL,
   NULL,
	"Does all of the morph work each frame"
	);

Event EV_SetObjectProgram
   (
   "setobjectprogram",
	EV_DEFAULT,
	"s",
	"program",
	"sets this objects program"
	);

Event EV_ExecuteObjectProgram
   (
   "executeobjectprogram",
	EV_DEFAULT,
	"f",
	"time",
	"executes this objects program at the specified time"
	);

Event EV_ProjectileAtk
	(
	"projectileattack",
	EV_DEFAULT,
	"sS",
	"projectile_name tag_name",
	"Launches a projectile"
	);
Event EV_ProjectileAttackPoint
	(
	"projectileattackpoint",
	EV_DEFAULT,
	"svFF",
	"projectileName targetPosition trajectoryAngle lifespan",
	"Launches a projectile at the named entity"
	);
Event EV_ProjectileAttackEntity
	(
	"projectileattackentity",
	EV_DEFAULT,
	"ssFF",
	"projectileName entityName trajectoryAngle lifespan",
	"Launches a projectile at the named entity"
	);
Event EV_ProjectileAttackFromTag
	(
	"projectileattackfromtag",
	EV_DEFAULT,
	"ssFF",
	"projectileName tagName speed lifespan",
	"Launches a projectile from the named tag"
	);
Event EV_ProjectileAttackFromPoint
	(
	"projectileattackfrompoint",
	EV_DEFAULT,
	"svvFF",
	"projectileName position direction speed lifespan",
	"Launches a projectile from the desired location"
	);
Event EV_TraceAtk
   (
   "traceattack",
	EV_DEFAULT,
	"ffSFS",
	"damage range means_of_death knockback tag_name",
	"Does a trace attack"
	);

Event EV_Contents
(
	"contents",
	EV_DEFAULT,
	"sSSSSS",
	"ct1 ct2 ct3 ct4 ct5 ct6",
	"The content type of the entity"
);
Event EV_Mask
(
	"mask",
	EV_DEFAULT,
	"sSSSSS",
	"mask1 mask2 mask3 mask4 mask5 mask6",
	"Sets the mask of the entity.  Masks can either be real masks or contents.  A +before the"
	"mask adds it, a - removes it, and nothing sets it"
);

Event EV_DisplayEffect
	(
	"displayeffect",
	EV_DEFAULT,
	"sS",
	"effect_type effect_name",
	"Displays the named effect."
	);

Event EV_ForceAlpha
	(
	"forcealpha",
	EV_DEFAULT,
	"B",
	"bool",
	"Sets whether or not alpha is forced"
	);

Event EV_SpawnEffect
	(
	"spawneffect",
	EV_DEFAULT,
	"ssF",
	"modelName tagName removeTime",
	"Spawns the effect at the specified tag"
	);

Event EV_CreateEarthquake
   (
   "earthquake",
   EV_DEFAULT,
   "ffF",
   "magnitude duration distance",
   "Creates an earthquake"
   );

Event EV_SetFloatVar
	( 
	"setfloatvar",
	EV_DEFAULT,
	"sf",
	"variable_name float_value",
	"Sets a level, game, or entity variable."
	);
Event EV_SetVectorVar
	( 
	"setvectorvar",
	EV_DEFAULT,
	"sv",
	"variable_name vector_value",
	"Sets a level, game, or entity variable."
	);
Event EV_SetStringVar
	( 
	"setstringvar",
	EV_DEFAULT,
	"ss",
	"variable_name string_value",
	"Sets a level, game, or entity variable."
	);
Event EV_DoesVarExist
	( 
	"doesVarExist",
	EV_SCRIPTONLY,
	"@fs",
	"float_value variable_name",
	"Returns whether or not a variable exists."
	);
Event EV_GetFloatVar
	( 
	"getfloatvar",
	EV_SCRIPTONLY,
	"@fs",
	"float_value variable_name",
	"Gets a level, game, or entity variable."
	);
Event EV_RemoveVariable
	(
	"removevar",
	EV_SCRIPTONLY,
	"s",
	"variable_name",
	"Removes a level, game, or entity variable and frees any memory used by it"
	);
Event EV_GetVectorVar
	( 
	"getvectorvar",
	EV_SCRIPTONLY,
	"@vs",
	"vector_value variable_name",
	"Gets a level, game, or entity variable."
	);
Event EV_GetStringVar
	( 
	"getstringvar",
	EV_SCRIPTONLY,
	"@ss",
	"string_value variable_name",
	"Gets a level, game, or entity variable."
	);

Event EV_SetUserVar1
	( 
	"uservar1",
	EV_DEFAULT,
	"s",
	"string_value",
	"Sets an entity variable."
	);
Event EV_SetUserVar2
	( 
	"uservar2",
	EV_DEFAULT,
	"s",
	"string_value",
	"Sets an entity variable."
	);
Event EV_SetUserVar3
	( 
	"uservar3",
	EV_DEFAULT,
	"s",
	"string_value",
	"Sets an entity variable."
	);
Event EV_SetUserVar4
	( 
	"uservar4",
	EV_DEFAULT,
	"s",
	"string_value",
	"Sets an entity variable."
	);

Event EV_AffectingViewMode
	( 
	"viewmode",
	EV_DEFAULT,
	"s",
	"viewModeName",
	"Specifies that this entity uses the specified view mode."
	);

// These are events that may come from tiki files
Event EV_TikiNote
	( 
	"note",
	EV_DEFAULT,
	"s",
	"note",
	"This is a comment"
	);
Event EV_TikiTodo
	( 
	"todo",
	EV_DEFAULT,
	"s",
	"todo",
	"This is an item that needs to be done"
	);

Event EV_SetGroupID
	(
	"setgroupid",
	EV_DEFAULT,
	"i",
	"groupID",
	"Sets the groupID of this entity"
	);

Event EV_Multiplayer
	(
	"multiplayer",
	EV_DEFAULT,
	"sSSSSS",
	"realEventName parm1 parm2 parm3 parm4 parm5",
	"Sends off a real event only if this is a multiplayer game"
	);

Event EV_DamageModifier
	(
	"damagemodifier",
	EV_DEFAULT,
	"ssfFFF",
	"modifiertype value multiplier chance minpain maxpain",
	"Add a damage modifier to this entities list\n"
	"  modifiertypes are:\n"
	"  tikiname, name, group, actortype, targetname, damagetype"
	);

Event EV_SetMoveType
	(
	"setmovetype",
	EV_DEFAULT,
	"s",
	"movetype",
	"Sets the move type of this entity\n"
	" Valid types are: \n"
	" none , stationary , noclip , push , stop\n"
	" walk , step , fly , toss , flymissile\n"
	" bounce, slider, rope , gib , vehicle"
	);

Event EV_HelperNodeCommand
	(
	"helpernodecommand",
	EV_CODEONLY,
	"s",
	"commandtype",
	"Command from a helper node"
	);

Event EV_UseDataAnim
	(
	"useanim",
	EV_DEFAULT,
	"s",
	"animname",
	"Animation for the player to play when this entity is used."
	);

Event EV_UseDataType
	(
	"usetype",
	EV_DEFAULT,
	"s",
	"usetype",
	"Use type (widget name) for the use icon"
	);

Event EV_UseDataThread
	(
	"usethread",
	EV_DEFAULT,
	"s",
	"threadname",
	"Thread to call when this entity is used."
	);

Event EV_UseData
	(
	"usedata",
	EV_DEFAULT,
	"sss",
	"animname usetype threadname",
	"Sets data for this usuable entity."
	);

Event EV_UseMaxDist
	(
	"usemaxdist",
	EV_DEFAULT,
	"f",
	"maxdist",
	"Sets maximum distance this entity can be used."
	);

Event EV_UseCount
	(
	"usecount",
	EV_DEFAULT,
	"i",
	"count",
	"Sets the number of times this entity can be used."
	);

Event EV_SetArchetype
	(
	"archetype",
	EV_DEFAULT,
	"s",
	"archetype",
	"Sets the archetype name for this entity"
	);

Event EV_SetMissionObjective
	(
	"missionobjective",
	EV_DEFAULT,
	"b",
	"missionobjective",
	"Sets the mission objective flag"
	);

Event EV_SetGameplayHealth
	(
	"gdb_sethealth",
	EV_DEFAULT,
	"s",
	"healthstr",
	"Sets the gameplay version of health with keywords."
	);

Event EV_SetGameplayDamage
	(
	"gdb_setdamage",
	EV_DEFAULT,
	"s",
	"damagestr",
	"Sets the gameplay version of damage with keywords."
	);

Event EV_ProcessGameplayData
	(
	"processgameplaydata",
	EV_TIKIONLY,
	NULL,
	NULL,
	"Causes any subclass of entity to process any specific gameplay related data."
	);

Event EV_GetVelocity
	(
	"getvelocity",
	EV_SCRIPTONLY,
	"@v",
	"NULL",
	"Returns the Velocity"
	);

Event EV_SetVelocity
	(
	"setvelocity",
	EV_SCRIPTONLY,
	"v",
	"velocity",
	"Sets the Velocity"
	);
Event EV_WatchOffset
	(
	"watchoffset",
	EV_DEFAULT,
	"v",
	"offset",
	"Sets the entity's watch offset."
	);

Event EV_StartStasis
(
	"startStasis",
	EV_DEFAULT,
	NULL,
	NULL,
	"Makes the entity go into stasis mode"
);
Event EV_StopStasis
(
	"stopStasis",
	EV_DEFAULT,
	NULL,
	NULL,
	"Makes the entity stop its stasis mode"
);

Event EV_SetTargetPos
(
	"settargetposition",
	EV_DEFAULT,
	"s",
	"targetbone",
	"Sets the Target Position Bone"
);

Event EV_AddHealthOverTime
	(
	"addHealthOverTime",
	EV_DEFAULT,
	"ff",
	"healthToAdd timeToAdd",
	"Specifies how much and howlong to add health."
	);
Event EV_SimplePlayDialog
	(
	"simplePlayDialog",
	EV_DEFAULT,
	"sFF",
	"sound_file volume min_dist",
	"Plays a dialog without all the special features the actors' have."
	);
Event EV_Warp
(
	"warp",
	EV_CHEAT,
	"v",
	"position",
	"Warps the entity to the specified position."
);
Event EV_TraceHitsEntity
(
	"traceHitsEntity",
	EV_SCRIPTONLY,
	"sfe",
	"tagName length entityToCheck",
	"Does a trace to check to see if it hits this entity\n."
	"Use this very rarely or a programmer will kill you!"
);

Event EV_SetCustomShader
(
	"setcustomshader",
	EV_DEFAULT,
	"s",
	"shader_name",
	"Sets Custom Shader FX on Entity"
);
Event EV_ClearCustomShader
(
	"clearcustomshader",
	EV_DEFAULT,
	"s",
	"shader_name",
	"Clears Custom Shader FX on Entity"
);
Event EV_SetCustomEmitter
(
	"setCustomEmitter",
	EV_DEFAULT,
	"s",
	"emitterName",
	"Sets up a custom emitter for this entity."
);
Event EV_ClearCustomEmitter
(
	"clearCustomEmitter",
	EV_DEFAULT,
	"s",
	"emitterName",
	"Clears the custom emitter for this Entity"
);

Event EV_IsWithinDistanceOf
(
	"iswithindistanceof",
	EV_DEFAULT,
	"@fef",
	"returnvalue targetEntity distance",
	"returns 1.0 if this entity is within the specified distance of the target entity return 0.0 if it is not"
);
Event EV_NetworkDetail
(
	"networkDetail",
	EV_TIKIONLY,
	NULL,
	NULL,
	"Sets this entity as detail that doesn't get sent across the network of set as low bandwidth by the client"
);

CLASS_DECLARATION( Listener, Entity, NULL )
	{
		{ &EV_DamageModifier,				&Entity::AddDamageModifier },
		{ &EV_TikiNote,				        &Entity::TikiNote },
		{ &EV_TikiTodo,				        &Entity::TikiTodo },
		{ &EV_Damage,				        &Entity::DamageEvent },
		{ &EV_DamageType,			        &Entity::DamageType },
		{ &EV_Kill,							&Entity::Kill },
		{ &EV_FadeNoRemove,  				&Entity::FadeNoRemove },
		{ &EV_FadeOut,				        &Entity::FadeOut },
		{ &EV_FadeIn,  						&Entity::FadeIn },
		{ &EV_Fade,				            &Entity::Fade },
		{ &EV_Hide,					        &Entity::EventHideModel },
		{ &EV_Show,					        &Entity::EventShowModel },
		{ &EV_BecomeSolid,					&Entity::BecomeSolid },
		{ &EV_BecomeNonSolid,				&Entity::BecomeNonSolid },
		{ &EV_Ghost,						&Entity::Ghost },
		{ &EV_TouchTriggers,	            &Entity::TouchTriggersEvent },
		{ &EV_Sound,				        &Entity::Sound },
		{ &EV_StopSound,			        &Entity::StopSound },
		{ &EV_SetHealth,			        &Entity::SetHealth },
		{ &EV_GetHealth,			        &Entity::GetHealth },
		{ &EV_SetMaxHealth,					&Entity::SetMaxHealth	},
		{ &EV_SetSize,				        &Entity::SetSize },
		{ &EV_SetMins,				        &Entity::SetMins },
		{ &EV_SetMaxs,				        &Entity::SetMaxs },
		{ &EV_GetMins,						&Entity::GetMins },
		{ &EV_GetMaxs,						&Entity::GetMaxs },
		{ &EV_SetScale,						&Entity::SetScale },
		{ &EV_SetRandomScale,				&Entity::setRandomScale },
		{ &EV_SetAlpha,						&Entity::SetAlpha },
		{ &EV_SetOrigin,			        &Entity::SetOrigin },
		{ &EV_GetOrigin,			        &Entity::GetOrigin },
		{ &EV_SetTargetName,		        &Entity::SetTargetName },
		{ &EV_GetTargetName,		        &Entity::GetTargetName },
		{ &EV_GetRawTargetName,				&Entity::GetRawTargetName },
		{ &EV_SetTarget,			        &Entity::SetTarget },
		{ &EV_GetTarget,					&Entity::getTarget },
		{ &EV_GetTargetEntity,				&Entity::GetTargetEntity	},
		{ &EV_SetKillTarget,		        &Entity::SetKillTarget },
		{ &EV_GetModelName,					&Entity::GetModelName	},
		{ &EV_SetAngles,			        &Entity::SetAngles },
		{&EV_GetAngles,						&Entity::GetAngles },
		{ &EV_SetAngle,						&Entity::SetAngleEvent },
		{ &EV_SetMass,						&Entity::SetMassEvent },
		{ &EV_SetFullTrace,					&Entity::SetFullTraceEvent },
		{ &EV_RegisterAlias,	            &Entity::RegisterAlias },
		{ &EV_RegisterAliasAndCache,		&Entity::RegisterAliasAndCache },
		{ &EV_Cache,						&Entity::Cache },
		{ &EV_AutoCache,					&Entity::Cache },
		{ &EV_LoopSound,					&Entity::LoopSound },
		{ &EV_StopLoopSound,				&Entity::StopLoopSound },
		{ &EV_Model,				        &Entity::SetModelEvent },
		{ &EV_SetLight,						&Entity::SetLight },
		{ &EV_LightOn,				        &Entity::LightOn },
		{ &EV_LightOff,						&Entity::LightOff },
		{ &EV_LightRed,						&Entity::LightRed },
		{ &EV_LightGreen,		            &Entity::LightGreen },
		{ &EV_LightBlue,		            &Entity::LightBlue },
		{ &EV_LightRadius,					&Entity::LightRadius },
		{ &EV_LightStyle,					&Entity::LightStyle },
		{ &EV_EntityFlags,					&Entity::Flags },
		{ &EV_EntityEffects,				&Entity::Effects },
		{ &EV_EntitySVFlags,	            &Entity::SVFlags },
		{ &EV_EntityRenderEffects,			&Entity::RenderEffects },
		{ &EV_BroadcastSound,				&Entity::BroadcastSound },
		{ &EV_SurfaceModelEvent,			&Entity::SurfaceModelEvent },
		{ &EV_ProcessInitCommands,			&Entity::ProcessInitCommandsEvent },
		{ &EV_Attach,						&Entity::AttachEvent },
		{ &EV_AttachModel,					&Entity::AttachModelEvent },
		{ &EV_RemoveAttachedModel,			&Entity::RemoveAttachedModelEvent },
		{ &EV_RemoveAttachedModelByTargetname,			&Entity::removeAttachedModelByTargetname },
		{ &EV_Detach,						&Entity::DetachEvent },
		{ &EV_IncreaseShotCount,			&Entity::IncreaseShotCount		},
		{ &EV_TakeDamage,					&Entity::TakeDamageEvent },
		{ &EV_NoDamage,						&Entity::NoDamageEvent },
		{ &EV_Gravity,						&Entity::Gravity },
		{ &EV_UseBoundingBox,				&Entity::UseBoundingBoxEvent },
		{ &EV_Hurt,							&Entity::HurtEvent },
		{ &EV_IfSkill,						&Entity::IfSkillEvent },
		{ &EV_Classname,					&Entity::ClassnameEvent },
		{ &EV_SpawnFlags,					&Entity::SpawnFlagsEvent },
		{ &EV_SetTeam,						&Entity::SetTeamEvent },
		{ &EV_Trigger,						&Entity::TriggerEvent },
		{ &EV_Censor,						&Entity::Censor },
		{ &EV_Stationary,					&Entity::StationaryEvent },
		{ &EV_Explosion,					&Entity::Explosion },
		{ &EV_ShaderEvent,					&Entity::Shader },
		{ &EV_ScriptShaderEvent,			&Entity::Shader },
		{ &EV_KillAttach,					&Entity::KillAttach },
		{ &EV_DropToFloor,					&Entity::DropToFloorEvent },
		{ &EV_Bind,				         	&Entity::BindEvent },
		{ &EV_Unbind,				        &Entity::EventUnbind },
		{ &EV_JoinTeam,         			&Entity::JoinTeam },
		{ &EV_QuitTeam,						&Entity::EventQuitTeam },
		{ &EV_AddToSoundManager,			&Entity::AddToSoundManager },
		{ &EV_SetControllerAngles,			&Entity::SetControllerAngles },
		{ &EV_DeathSinkStart,				&Entity::DeathSinkStart },
		{ &EV_DeathSink,					&Entity::DeathSink },
		{ &EV_LookAtMe,						&Entity::LookAtMe },
		{ &EV_ProjectilesCanStickToMe,		&Entity::ProjectilesCanStickToMe },

		{ &EV_DetachAllChildren,			&Entity::DetachAllChildren },
		{ &EV_Morph,						&Entity::MorphEvent },
		{ &EV_Unmorph,						&Entity::UnmorphEvent },
		{ &EV_MorphControl,					&Entity::MorphControl },
		{ &EV_SetCinematicAnim,				&Entity::SetCinematicAnim },
		{ &EV_CinematicAnimDone,			&Entity::CinematicAnimDone },
		{ &EV_SetAnimOnAttachedModel,		&Entity::SetAnimOnAttachedModel		},
		{ &EV_SetEntityExplosionModel,		&Entity::SetEntityExplosionModel		},
		{ &EV_SetObjectProgram,				&Entity::SetObjectProgram		},		
		{ &EV_ExecuteObjectProgram,			&Entity::ExecuteProgram },
		{ &EV_DoRadiusDamage,				&Entity::DoRadiusDamage },
		{ &EV_SelfDetonate,					&Entity::SelfDetonate		},

		{ &EV_Anim,							&Entity::PassToAnimate },
		{ &EV_SetFrame,						&Entity::PassToAnimate },
		{ &EV_StopAnimating,				&Entity::PassToAnimate },
		{ &EV_Torso_StopAnimating,			&Entity::PassToAnimate },
		{ &EV_NewAnim,						&Entity::PassToAnimate },

		{ &EV_ProjectileAtk,				&Entity::ProjectileAtk },
		{ &EV_ProjectileAttackPoint,		&Entity::ProjectileAttackPoint },
		{ &EV_ProjectileAttackEntity,		&Entity::ProjectileAttackEntity },
		{ &EV_ProjectileAttackFromTag,		&Entity::ProjectileAttackFromTag },
		{ &EV_ProjectileAttackFromPoint,	&Entity::ProjectileAttackFromPoint },

		{ &EV_TraceAtk,						&Entity::TraceAtk },
		{ &EV_Contents,						&Entity::Contents },
		{ &EV_Mask,							&Entity::setMask },

		{ &EV_DisplayEffect,				&Entity::DisplayEffect },

		{ &EV_ForceAlpha,					&Entity::ForceAlpha },
		{ &EV_SpawnEffect,					&Entity::SpawnEffect },

		{ &EV_CreateEarthquake,				&Entity::CreateEarthquake },

		{ &EV_SetFloatVar,					&Entity::SetFloatVar },
		{ &EV_SetVectorVar,					&Entity::SetVectorVar },
		{ &EV_SetStringVar,					&Entity::SetStringVar },

		{ &EV_DoesVarExist,					&Entity::doesVarExist },
		{ &EV_RemoveVariable,				&Entity::RemoveVariable },

		{ &EV_GetFloatVar,					&Entity::GetFloatVar },
		{ &EV_GetVectorVar,					&Entity::GetVectorVar },
		{ &EV_GetStringVar,					&Entity::GetStringVar },

		{ &EV_SetUserVar1,					&Entity::SetUserVar1 },
		{ &EV_SetUserVar2,					&Entity::SetUserVar2 },
		{ &EV_SetUserVar3,					&Entity::SetUserVar3 },
		{ &EV_SetUserVar4,					&Entity::SetUserVar4 },

		{ &EV_AffectingViewMode,			&Entity::affectingViewMode },
		{ &EV_SetGroupID,                   &Entity::SetGroupID	},

		{ &EV_Multiplayer,                  &Entity::MultiplayerEvent	},
		{ &EV_SetMoveType,					&Entity::setMoveType			},

		{ &EV_UseDataAnim,					&Entity::useDataAnim			},
		{ &EV_UseDataType,					&Entity::useDataType			},
		{ &EV_UseDataThread,				&Entity::useDataThread		},
		{ &EV_UseData,						&Entity::useDataEvent		},
		{ &EV_UseMaxDist,					&Entity::useDataMaxDist		},
		{ &EV_UseCount,						&Entity::useDataCount		},

		{ &EV_SetArchetype,					&Entity::setArchetype		},
		{ &EV_SetMissionObjective,			&Entity::setMissionObjective },
		{ &EV_SetGameplayHealth,			&Entity::setGameplayHealth   },
		{ &EV_GetVelocity,					&Entity::GetVelocity		},
		{ &EV_SetVelocity,					&Entity::SetVelocity		},
		{ &EV_WatchOffset,					&Entity::SetWatchOffset	},

		{ &EV_StartStasis,					&Entity::startStasis },
		{ &EV_StopStasis,					&Entity::stopStasis },

		{ &EV_SetTargetPos,					&Entity::setTargetPos	},

		{ &EV_AddHealthOverTime,			&Entity::addHealthOverTime },
		{ &EV_SimplePlayDialog,				&Entity::simplePlayDialog },

		{ &EV_Warp,							&Entity::warp },
		{ &EV_TraceHitsEntity,				&Entity::traceHitsEntity },
		{ &EV_SetOriginEveryFrame,			&Entity::setOriginEveryFrame },		

		{ &EV_SetCustomShader,				&Entity::setCustomShader	},
		{ &EV_ClearCustomShader,			&Entity::clearCustomShader },

		{ &EV_SetCustomEmitter,				&Entity::setCustomEmitter },
		{ &EV_ClearCustomEmitter,			&Entity::clearCustomEmitter },
		{ &EV_IsWithinDistanceOf,			&Entity::isWithinDistanceOf },

		{ &EV_NetworkDetail,				&Entity::setNetworkDetail },
	
		{ NULL, NULL }
	};

Entity::Entity()
	{
	Setup();
	}

Entity::Entity( int create_flag )
	{
	Setup();

	if ( create_flag & ENTITY_CREATE_FLAG_ANIMATE )
		animate = new Animate( this );

	if ( create_flag & ENTITY_CREATE_FLAG_MOVER )
		mover = new Mover( this );
	}

void Entity::Setup()
	{
	// Pluggable modules

	animate    = NULL;
	mover      = NULL;
	bind_info  = NULL;
	morph_info = NULL;

   edict = level.AllocEdict( this );
	client = edict->client;
	entnum = edict->s.number;
	edict->s.clientNum = ENTITYNUM_NONE ;

   // spawning variables
	spawnflags = level.spawnflags;
   level.spawnflags = 0;

	// rendering variables
	setAlpha( 1.0f );
	setScale( 1.0f );

	// physics variables
   total_delta             = Vector(0, 0, 0);
	mass							= 0;
	gravity						= 1.0;
	groundentity				= NULL;
   groundcontents          = 0;
	velocity						= vec_zero;
	avelocity					= vec_zero;
   edict->clipmask         = MASK_SOLID;

   // bind variables
	edict->s.bindparent = ENTITYNUM_NONE;

   // this is an generic entity
   edict->s.eType = ET_GENERAL;

   setContents( 0 );

   edict->s.parent      = ENTITYNUM_NONE;
   edict->s.pos.trType  = TR_LERP;
   edict->ownerNum      = ENTITYNUM_NONE;

	setOrigin( vec_zero );
   origin.copyTo( edict->s.origin2 );

   setAngles( vec_zero );

	setMoveType( MOVETYPE_NONE );
	setSolidType( SOLID_NOT );

	// Character state
	health		= 0;
	max_health	= 0;
	deadflag		= DEAD_NO;
	flags			= 0;

	// underwater variables
	watertype		= 0;
	waterlevel		= 0;

	// Pain and damage variables
	takedamage				= DAMAGE_NO;
   damage_type          = -1;

   // Surface variables
   numsurfaces    = 0;

   // Light variables
   lightRadius    = 0;

	look_at_me = false;
	projectilesCanStickToMe = true;

	explosionModel = "";

	_affectingViewModes = 0;

	edict->s.infoIcon = 0;

	addAffectingViewModes( gi.GetViewModeClassMask( "entity" ) );
	_groupID = 0;

	damageModSystem = 0;

	_fulltrace = false ;
	useData = 0;
	setTargetPos( "" );

	ObjectProgram = NULL;

	_missionObjective = false;

	_networkDetail = false;
	}

Entity::~Entity()
{
	Container<Entity *> bindlist;
	Entity *ent;
	int num;
	int i;
	
	if ( bind_info )
	{
		// unbind any entities that are bound to me
		// can't unbind within this loop, so make an array
		// and unbind them outside of it.
		num = 0;
		
		for( ent = bind_info->teamchain; ent; ent = ent->bind_info->teamchain )
		{
			if ( ent->bind_info->bindmaster == this )
			{
				bindlist.AddObject( ent );
			}
		}
		
		num = bindlist.NumObjects();
		for( i = 1; i <= num; i++ )
		{
			bindlist.ObjectAt( i )->unbind();
		}
		
		bindlist.FreeObjectList();
		
		unbind();
		quitTeam();
		
		detach();
		
		//
		// go through and set our children
		//
		num = bind_info->numchildren;
		for( i = 0; ( i < MAX_MODEL_CHILDREN ) && num; i++ )
		{
			if ( bind_info->children[ i ] == ENTITYNUM_NONE )
			{
				continue;
			}
			ent = G_GetEntity( bind_info->children[ i ] );
			if ( ent )
			{
				ent->PostEvent( EV_Remove, 0.0f );
			}
			num--;
		}
	}
	
	if ( targetname.length() && world )
	{
		world->RemoveTargetEntity( targetname, this );
	}
	
	level.FreeEdict( edict );
	
	// Pluggable modules
	
	if ( animate )
		delete animate;
	
	if ( mover )
		delete mover;
	
	if ( bind_info )
		delete bind_info;
	
	if ( morph_info )
		delete morph_info;
	
	entityVars.ClearList();
	
	if ( damageModSystem )
		delete damageModSystem;
	
	if ( useData )
	{
		delete useData;
		useData = NULL;
	}
	
	// Note, the ObjectProgram deletion is handled elsewhere

	// Make sure to remove our selves from the extra list if we are a mission objective

	if ( edict->s.missionObjective )
	{
		G_RemoveEntityFromExtraList(entnum);
	}
}

Entity * Entity::FindEntityByName( const str &entityName )
{
	for ( int i = 0; i < MAX_GENTITIES; i++ )
	{
		if ( g_entities[i].inuse && g_entities[i].entity && ( entityName == g_entities[ i ].entname ) )
		{
			return g_entities[i].entity;
		}
	}
	
	return NULL;
}

void Entity::SetEntNum
   (
   int num
   )

   {
   if ( edict )
      {
      level.FreeEdict( edict );
      }

   level.spawn_entnum = num;
   level.AllocEdict( this );
	client = edict->client;
	entnum = edict->s.number;
   }

void Entity::ClassnameEvent
	(
	Event *ev
   )

   {
	strncpy( edict->entname, ev->GetString( 1 ), sizeof( edict->entname ) - 1 );
	}

void Entity::SpawnFlagsEvent
	(
	Event *ev
   )

   {
	// spawning variables
	spawnflags = ev->GetInteger( 1 );
   if ( spawnflags & SPAWNFLAG_DETAIL )
		{
      edict->s.renderfx |= RF_DETAIL;
		}
	}

void Entity::SetTarget
	(
	const char *text
	)

	{
   if ( text )
		{
      target = text;
		}
	else
		{
		target = "";
		}
	}

void Entity::SetTargetName
	(
	const char *text
	)

	{
   if ( targetname.length() && world )
      {
      world->RemoveTargetEntity( targetname, this );
      }

   if ( text )
		{
      if ( text[ 0 ] == '$' )
         text++;
      targetname = text;
		}
	else
		{
		targetname = "";
		}

   if ( targetname.length() && world )
		{
      //
      // make sure we don't re-targetname the world entity
      //
      if (
            ( this != world ) ||
            ( targetname == str( "world" ) )
         )
         {
         world->AddTargetEntity( targetname, this );
         }
      else
         {
			error( "SetTargetName", "World was re-targeted with targetname %s\n", targetname.c_str() );

         // this is bad
         //assert( 0 );
         //gi.WDPrintf( "world was re-targeted with targetname %s\n", targetname.c_str() );
         //targetname = "world";
         }

		}
	}

void Entity::SetKillTarget
	(
	const char *text
	)

	{
   if ( text )
		{
      killtarget = text;
		}
	else
		{
		killtarget = "";
		}
	}

void Entity::setModel( const char *mdl )
{
	str temp;
	
	if ( LoadingSavegame && ( this == world ) )
	{
		// don't set model on the world
		return;
	}
	
	if ( !mdl )
	{
		mdl = "";
	}
	
	// Prepend 'models/' to make things easier
	temp = "";
	if ( ( strlen( mdl ) > 0 ) && !strchr( mdl, '*' ) && strnicmp( "models/", mdl, 7 ) && !strstr( mdl, ".spr" ) )
	{
		temp = "models/";
	}
	temp += mdl;
	
	// we use a temp string so that if model was passed into here, we don't
	// accidentally free up the string that we're using in the process.
	model = temp;
	
	gi.setmodel( edict, model.c_str() );
	
	if ( gi.IsModel( edict->s.modelindex ) )
	{
		Event *ev;
		
		numsurfaces = gi.NumSurfaces( edict->s.modelindex );
		
		if ( !LoadingSavegame )
		{
			CancelEventsOfType( EV_ProcessInitCommands );
			
			ev = new Event( EV_ProcessInitCommands );
			ev->AddInteger( edict->s.modelindex );
			PostEvent( ev, EV_PROCESS_INIT );
		}
		else
		{
			ProcessInitCommands( edict->s.modelindex, true );
		}
	}
	else if ( strstr( mdl, ".spr" ) )
	{
		edict->s.eType = ET_SPRITE;
	}
	
	// Sanity check to see if we're expecting a B-Model
	assert( !( ( edict->solid == SOLID_BSP ) && !edict->s.modelindex ) );
	if ( ( edict->solid == SOLID_BSP ) && !edict->s.modelindex )
	{
		const char *name;
		
		name = getClassID();
		if ( !name )
		{
			name = getClassname();
		}
		gi.WDPrintf( "%s with SOLID_BSP and no model - '%s'(%d)\n", name, targetname.c_str(), entnum );
		
		// Make it non-solid so that the collision code doesn't kick us out.
		setSolidType( SOLID_NOT );
	}
	
	mins = edict->mins;
	maxs = edict->maxs;
	size = maxs - mins;
	edict->radius = size.length() * 0.5f;
	edict->radius2 = edict->radius * edict->radius;
	
	//
	// see if we have a mins and maxs set for this model
	//
	
	if ( gi.IsModel( edict->s.modelindex ) && !mins.length() && !maxs.length() )
	{
		vec3_t tempmins, tempmaxs;
		int animNum;

		animNum = gi.Anim_NumForName( edict->s.modelindex, "idle" );

		if ( animNum >= 0 )
		{
			gi.Frame_Bounds( edict->s.modelindex, animNum, 0, edict->s.scale, tempmins, tempmaxs );
			setSize( tempmins, tempmaxs );
		}

		//vec3_t tempmins, tempmaxs;
		//gi.CalculateBounds( edict->s.modelindex, edict->s.scale, tempmins, tempmaxs );
		//setSize( tempmins, tempmaxs );
	}

	if ( this->isSubclassOf(Player) )
		{
		//If we're a player, we need to reset the statemachine
		Player* player = (Player*)this;

		if ( player )
			{
			player->SetAnim( "stand_idle", legs, true );
			player->SetAnim( "stand_idle", torso, true );
			player->LoadStateTable();
			}
		}
}

// Added to set the weapon view model
void Entity::setViewModel
	(
	const char *mdl
	)

	{
   str temp;

   if ( LoadingSavegame && ( this == world ) )
      {
      // don't set model on the world
      return;
      }

	if ( !mdl )
		{
		mdl = "";
		}

   // Prepend 'models/' to make things easier
   temp = "";
	if ( ( strlen( mdl ) > 0 ) && !strchr( mdl, '*' ) && strnicmp( "models/", mdl, 7 ) && !strstr( mdl, ".spr" ) )
		{
		temp = "models/";
		}
   temp += mdl;

   // we use a temp string so that if model was passed into here, we don't
   // accidentally free up the string that we're using in the process.
   model = temp;

	gi.setviewmodel( edict, model.c_str() );

   if ( gi.IsModel( edict->s.viewmodelindex ) )
      {
  	   Event *ev;

      numsurfaces = gi.NumSurfaces( edict->s.viewmodelindex );

      if ( !LoadingSavegame )
         {
		   CancelEventsOfType( EV_ProcessInitCommands );

         ev = new Event( EV_ProcessInitCommands );
         ev->AddInteger( edict->s.viewmodelindex );
         PostEvent( ev, EV_PROCESS_INIT );
         }
      else
         {
         ProcessInitCommands( edict->s.viewmodelindex, true );
         }
      }
   else if ( strstr( mdl, ".spr" ) )
      {
      edict->s.eType = ET_SPRITE;
      }

	// Sanity check to see if we're expecting a B-Model
	assert( !( ( edict->solid == SOLID_BSP ) && !edict->s.viewmodelindex ) );
	if ( ( edict->solid == SOLID_BSP ) && !edict->s.viewmodelindex )
		{
      const char *name;

      name = getClassID();
      if ( !name )
         {
         name = getClassname();
         }
      gi.WDPrintf( "%s with SOLID_BSP and no model - '%s'(%d)\n", name, targetname.c_str(), entnum );

      // Make it non-solid so that the collision code doesn't kick us out.
      setSolidType( SOLID_NOT );
      }

	mins = edict->mins;
	maxs = edict->maxs;
   size = maxs - mins;
   edict->radius = size.length() * 0.5f;
	edict->radius2 = edict->radius * edict->radius;

   //
   // see if we have a mins and maxs set for this model
   //
   //FIXME
   //We only did this on startup, but with the spawnargs as events it would have to
   //be here.  Do we still need this?  It may cause strange effects.
   /* if ( gi.IsModel( edict->s.viewmodelindex ) && !mins.length() && !maxs.length() )
      {
      vec3_t tempmins, tempmaxs;
      gi.CalculateBounds( edict->s.viewmodelindex, edict->s.scale, tempmins, tempmaxs );
      setSize( tempmins, tempmaxs );
      } */
	}

void Entity::ProcessInitCommands
	(
	int index,
   qboolean cache
	)

	{
   tiki_cmd_t cmds;

   if ( LoadingSavegame && !cache )
      {
      // Don't process init commands when loading a savegame since
      // it will cause items to be added to inventories unnecessarily.
      // All variables affected by the init commands will be set
      // by the unarchive functions.
      //
      // we do want to process the cache commands though regardless
      return;
      }

   if ( gi.InitCommands( index, &cmds ) )
      {
      int i, j, savedindex;
   	Event		*event;

      // because the model has not necessarily been spawned yet, we need to set
      // this entity to have this index so that precaches go where they are supposed
      // to, this should have no bad effects, since we are only doing it in the
      // cache phase of spawning
      if ( index != edict->s.modelindex )
         {
         savedindex = edict->s.modelindex;
         edict->s.modelindex = index;
         }
      else
         {
         savedindex = -1;
         }
      for( i = 0; i < cmds.num_cmds; i++ )
         {
      	event = new Event( cmds.cmds[ i ].args[ 0 ] );
         if ( !cache || ( event->GetFlags() & EV_CACHE ) )
            {
            for( j = 1; j < cmds.cmds[ i ].num_args; j++ )
               {
      		   event->AddToken( cmds.cmds[ i ].args[ j ] );
               }
            ProcessEvent( event );
            }
         else
            {
            delete event;
            }
         }
      // restore the modelindex, see above
      if ( savedindex != -1 )
         {
         edict->s.modelindex = savedindex;
         }
      }
	}

void Entity::ProcessInitCommandsEvent
	(
	Event *ev
	)

	{
   int index;

   index = ev->GetInteger( 1 );
   ProcessInitCommands( index, false );
	}

void Entity::EventHideModel
	(
	Event *ev
	)

	{
	hideModel();
	}

void Entity::EventShowModel
	(
	Event *ev
	)

	{
	showModel();
	}

void Entity::SetTeamEvent
	(
	Event *ev
	)

	{
	if ( !bind_info )
		bind_info = CreateBindInfo();

   bind_info->moveteam = ev->GetString( 1 );
	}

void Entity::TriggerEvent
	(
	Event *ev
	)

	{
	const char	*name;
	Event		   *event;
	Entity	   *ent;
   TargetList  *tlist;
   int         i;
   int         num;

	name = ev->GetString( 1 );

	if ( !name )
		return;

	// Check for object commands
	if ( name[ 0 ] == '$' )
		{
      tlist = world->GetTargetList( str( name + 1 ) );
      num = tlist->list.NumObjects();
      for ( i = 1; i <= num; i++ )
         {
         ent = tlist->list.ObjectAt( i );

		   assert( ent );

         event = new Event( EV_Activate );
			event->SetSource( ev->GetSource() );
			event->SetThread( ev->GetThread() );
			event->SetLineNumber( ev->GetLineNumber() );
         event->AddEntity( this );
		   ent->ProcessEvent( event );
         }
      }
	else if ( name[ 0 ] == '*' )   // Check for entnum commands
      {
		if ( !IsNumeric( &name[ 1 ] ) )
			{
			ev->Error( "Expecting numeric value for * command, but found '%s'\n", &name[ 1 ] );
			}
		else
         {
         ent = G_GetEntity( atoi( &name[ 1 ] ) );
         if ( ent )
            {
            event = new Event( EV_Activate );
			   event->SetSource( ev->GetSource() );
			   event->SetThread( ev->GetThread() );
			   event->SetLineNumber( ev->GetLineNumber() );
            event->AddEntity( this );
            ent->ProcessEvent( event );
            }
         else
            {
            ev->Error( "Entity not found for * command\n" );
            }
         }
      return;
      }
	else
		{
		ev->Error( "Invalid entity reference '%s'.\n", name );
		}
	}

void Entity::setAlpha
	(
	float alpha
	)

	{
	if ( alpha > 1.0f )
		{
		alpha = 1.0f;
		}
	if ( alpha < 0.0f )
		{
		alpha = 0.0f;
		}
   edict->s.alpha = alpha;
	}

void Entity::setScale
	(
	float scale
	)

	{
   edict->s.scale = scale;
	}

void Entity::setSolidType
	(
	solid_t type
	)

	{
	if (
         ( !LoadingSavegame ) &&
         ( type == SOLID_BSP ) &&
         ( this != world ) &&
         (
            !model.length() ||
            (
               ( model[ 0 ] != '*' ) &&
               ( !strstr( model.c_str(), ".bsp" ) )
            )
         )
      )
		{
      error( "setSolidType", "SOLID_BSP entity at x%.2f y%.2f z%.2f with no BSP model", origin[ 0 ], origin[ 1 ], origin[ 2 ] );
		}
	edict->solid = type;

   //
   // set the appropriate contents type
   if ( edict->solid == SOLID_BBOX )
      {
      if ( !getContents() )
   	   setContents( CONTENTS_SOLID );
      }
   else if ( edict->solid == SOLID_NOT )
      {
      if ( getContents() == CONTENTS_SOLID )
   	   setContents( 0 );
      }
   else if ( edict->solid == SOLID_BSP )
      {
      if ( !getContents() )
   	   setContents( CONTENTS_SOLID );
      }

	link();

	edict->svflags &= ~SVF_NOCLIENT;
	if ( hidden() )
		{
		edict->svflags |= SVF_NOCLIENT;
		}
	}

void Entity::setSize
	(
	Vector min,
	Vector max
	)

	{
   Vector delta;

   if ( flags & FL_ROTATEDBOUNDS )
      {
      vec3_t tempmins, tempmaxs;

      //
      // rotate the mins and maxs for the model
      //
	   min.copyTo( tempmins );
	   max.copyTo( tempmaxs );

      CalculateRotatedBounds2( edict->s.mat, tempmins, tempmaxs );

      mins = Vector( tempmins );
      maxs = Vector( tempmaxs );
	   size = max - min;

	   mins.copyTo( edict->mins );
	   maxs.copyTo( edict->maxs );
      edict->radius = size.length() * 0.5;
		edict->radius2 = edict->radius * edict->radius;
      }
   else
      {
      if ( ( min == edict->mins ) && ( max == edict->maxs ) )
         {
         return;
         }

	   mins = min;
	   maxs = max;
	   size = max - min;

	   mins.copyTo( edict->mins );
	   maxs.copyTo( edict->maxs );

      //
      // get the full mins and maxs for this model
      //
      /* if ( gi.IsModel( edict->s.modelindex ) )
         {
         vec3_t fullmins, fullmaxs;
         Vector delta;

         gi.CalculateBounds( edict->s.modelindex, edict->s.scale, fullmins, fullmaxs );

         delta = Vector( fullmaxs ) - Vector( fullmins );
         edict->radius = delta.length() * 0.5f;
			edict->radius2 = edict->radius * edict->radius;
         }
      else */
         {
         edict->radius = size.length() * 0.5;
			edict->radius2 = edict->radius * edict->radius;
         }
      }

	link();
	}

Vector Entity::getLocalVector
	(
	const Vector &vec
	)

	{
	Vector pos;

	pos[ 0 ] = vec * orientation[ 0 ];
	pos[ 1 ] = vec * orientation[ 1 ];
	pos[ 2 ] = vec * orientation[ 2 ];

	return pos;
	}

void Entity::link
	(
	void
	)

	{
	if ( !level._cleanup )
		gi.linkentity( edict );

	absmin = edict->absmin;
	absmax = edict->absmax;
	centroid = ( absmin + absmax ) * 0.5f;
	centroid.copyTo( edict->centroid );

   // If this has a parent, then set the areanum the same
   // as the parent's
   if ( edict->s.parent != ENTITYNUM_NONE )
      {
      edict->areanum = g_entities[ edict->s.parent ].areanum;
      }
	}

void Entity::addOrigin
	(
	const Vector &add
	)

   {
   setOrigin( GetLocalOrigin() + add );
   }

void Entity::setOrigin
	(
   void
	)

   {
   setOrigin( GetLocalOrigin() );
   }

void Entity::setOrigin
	(
	const Vector &org
	)

	{
   Entity * ent;
   int i,num;

	if ( bind_info && bind_info->bindmaster )
		{
      SetLocalOrigin( org );

		if ( bind_info->bind_use_my_angles )
			MatrixTransformVector( GetLocalOrigin(), orientation, origin );
		else
			MatrixTransformVector( GetLocalOrigin(), bind_info->bindmaster->orientation, origin );

      origin += bind_info->bindmaster->origin;
      origin.copyTo( edict->s.netorigin );
		}
   // If entity has a parent, then set the origin as the
   // centroid of the parent, and set edict->s.netorigin
   // as the local origin of the entity which will be used
   // to position this entity on the client.
   else if ( edict->s.parent != ENTITYNUM_NONE )
      {
		orientation_t orient;

      VectorClear( edict->s.netorigin );
      ent = ( Entity * )G_GetEntity( edict->s.parent );

      //ent->GetTag(( edict->s.tag_num & TAG_MASK, &origin );
		ent->GetTag( edict->s.tag_num & TAG_MASK, &orient );

		MatrixTransformVector( edict->s.attach_offset, orient.axis, origin );

		//origin += edict->s.attach_offset;
		origin += orient.origin;

      SetLocalOrigin( vec_zero );
      }
	else
		{
      origin = org;
      SetLocalOrigin( org );
      origin.copyTo( edict->s.netorigin );
		}

   origin.copyTo( edict->s.origin );
   origin.copyTo( edict->currentOrigin );

	link();

#if 0
   if ( this->isClient() )
      {
      i = CurrentAnim();
      j = CurrentFrame();

      G_DrawCoordSystem( origin, orientation[0], orientation[1], orientation[2], 30 );
      gi.Printf( "%s:legs anim:%s frame %i\n", this->getClassname(), gi.Anim_NameForNum( edict->s.modelindex, i ), j );
      }
#endif

	if ( bind_info )
		{
		// Go through and set our children

		num = bind_info->numchildren;
		for( i = 0; ( i < MAX_MODEL_CHILDREN ) && num; i++ )
			{
			if ( bind_info->children[ i ] == ENTITYNUM_NONE )
				{
				continue;
				}
			ent = ( Entity * )G_GetEntity( bind_info->children[ i ] );
			if ( ent )
			{
				ent->setOrigin();
			}
			num--;
			}


		/* for( ent = bind_info->teamchain; ent != NULL; ent = ent->bind_info->teamchain )
			{
			if ( ent->bind_info->teammaster == this )
				ent->setOrigin();
			} */
		}
	}

void Entity::GetRawTag
	(
   int    tagnum,
   orientation_t * orient,
	bodypart_t part
	)

	{
   int anim;
   int frame;

   anim = CurrentAnim(part);
   frame = CurrentFrame(part);

   //If we don't have a valid animation, we can't get a tag
   if ( anim < 0 ) return;

	*orient = gi.Tag_OrientationEx( edict->s.modelindex, CurrentAnim( legs ), CurrentFrame( legs ), tagnum & TAG_MASK, 
			edict->s.scale, edict->s.bone_tag, edict->s.bone_quat, 0, 0, 1.0f, ( edict->s.anim & ANIM_BLEND ) != 0, 
			( edict->s.torso_anim & ANIM_BLEND ) != 0, CurrentAnim( torso ), CurrentFrame( torso ), 0, 0, 1.0f );
   }

qboolean Entity::GetRawTag
	(
	const char *name,
   orientation_t * orient,
	bodypart_t part
	)
	{
   int      tagnum;

   tagnum = gi.Tag_NumForName( edict->s.modelindex, name );

   if ( tagnum < 0 )
      return false;

   GetRawTag( tagnum, orient, part );
   return true;
   }

void Entity::GetTag
	(
   int    tagnum,
   orientation_t * orient
	)

	{
   orientation_t  orn;
   int            i;

   GetRawTag( tagnum, &orn );

   VectorCopy( origin, orient->origin );

   for ( i = 0 ; i < 3 ; i++ )
      {
		VectorMA( orient->origin, orn.origin[i], orientation[i], orient->origin );
	   }
   MatrixMultiply( orn.axis, orientation, orient->axis );
   }

qboolean Entity::GetTag
	(
	const char *name,
   orientation_t * orient
	)
	{
   int      tagnum;

   tagnum = gi.Tag_NumForName( edict->s.modelindex, name );

   if ( tagnum < 0 )
      return false;

   GetTag( tagnum, orient );
   return true;
   }

void Entity::GetTag
	(
   int    tagnum,
	Vector *pos,
	Vector *forward,
	Vector *left,
	Vector *up
	)

	{
   orientation_t orn;

   GetTag( tagnum, &orn);

	if ( pos )
		{
		*pos = Vector( orn.origin );
		}
	if ( forward )
		{
		*forward = Vector( orn.axis[ 0 ] );
		}
	if ( left )
		{
		*left = Vector( orn.axis[ 1 ] );
		}
	if ( up )
		{
		*up = Vector( orn.axis[ 2 ] );
		}
   }

qboolean Entity::GetTag
	(
	const char *name,
	Vector *pos,
	Vector *forward,
	Vector *left,
	Vector *up
	)

	{
   int      tagnum;

   tagnum = gi.Tag_NumForName( edict->s.modelindex, name );

   if ( tagnum < 0 )
      return false;

   GetTag( tagnum, pos, forward, left, up );
   return true;
   }

void Entity::addAngles
   (
   const Vector &add
   )

   {
   if ( bind_info && bind_info->bindmaster )
      {
      setAngles( localangles + add );
      }
   else
      {
      setAngles( angles + add );
      }
   }

void Entity::setAngles
	(
   void
   )

   {
   if ( bind_info && bind_info->bindmaster )
      {
      setAngles( localangles );
      }
   else
      {
      setAngles( angles );
      }
   }


void Entity::setAngles
	(
	const Vector &ang
	)

	{
   Entity * ent;
		
   int num,i;

	angles[ 0 ] = AngleMod( ang[ 0 ] );
	angles[ 1 ] = AngleMod( ang[ 1 ] );
	angles[ 2 ] = AngleMod( ang[ 2 ] );

   localangles = angles;
   if ( bind_info && bind_info->bindmaster )
      {
      float	mat[3][3];
		AnglesToAxis( localangles, mat );
		R_ConcatRotations( mat, bind_info->bindmaster->orientation, orientation );
      MatrixToEulerAngles( orientation, angles );
      }
   else if ( edict->s.parent != ENTITYNUM_NONE  )
		{
		Entity *parent;		
		Vector tagPos;
		Vector tagForward;
		Vector forwardAngles;

		vec3_t tempAxis[3];
		vec3_t tempAxis2[3];
		vec3_t finalAxis[3];
		vec3_t tempForward;
		vec3_t finalForward;		


		parent = ( Entity * )G_GetEntity( edict->s.parent );
		parent->GetTag( edict->s.tag_num , &tagPos , &tagForward );

		
		forwardAngles = tagForward.toAngles();
		forwardAngles.copyTo( tempForward );
		
		AnglesToAxis( tempForward, tempAxis );
		AnglesToAxis( edict->s.attach_angles_offset , tempAxis2 );
		MatrixMultiply( tempAxis2, tempAxis, finalAxis );
		AxisToAngles( finalAxis, finalForward );
		angles = finalForward;		
		
		AnglesToAxis( angles, orientation );

		}
	else
      {
      AnglesToAxis( angles, orientation );
      }

   angles.copyTo( edict->s.netangles );
   angles.copyTo( edict->s.angles );
   angles.copyTo( edict->currentAngles );
	// Fill the edicts matrix
	VectorCopy( orientation[ 0 ], edict->s.mat[ 0 ] );
	VectorCopy( orientation[ 1 ], edict->s.mat[ 1 ] );
	VectorCopy( orientation[ 2 ], edict->s.mat[ 2 ] );

	if (this->isSubclassOf( Player ) )
	{
		Player *player = (Player*)this ;
		player->GetVAngles().copyTo( edict->s.viewangles );
	}
	else
	{
		edict->s.viewangles[0] = 0.0f ;
		edict->s.viewangles[1] = 0.0f ;
		edict->s.viewangles[2] = 0.0f ;
	}

	if ( bind_info )
		{
		// Go through and set our children

		num = bind_info->numchildren;

		for( i = 0 ; (i < MAX_MODEL_CHILDREN) && num ; i++ )
			{
			if ( bind_info->children[i] == ENTITYNUM_NONE )
				continue;
			ent = ( Entity * )G_GetEntity( bind_info->children[i] );
			if ( ent )
			{
				ent->setAngles();
				VectorClear( ent->edict->s.netangles );
			}
			num--;
			}

		/* for( ent = bind_info->teamchain; ent != NULL; ent = ent->bind_info->teamchain )
			{
			if ( ent->bind_info->teammaster == this )
				ent->setAngles();
			} */
		}
	}

qboolean Entity::droptofloor
	(
	float maxfall
	)

	{
	trace_t	trace;
	Vector	end;
   Vector   start;

   //start = origin + Vector( "0 0 1" );
	start = origin;
   end = origin;
	end[ 2 ]-= maxfall;

	trace = G_Trace( start, mins, maxs, end, this, edict->clipmask, false, "Entity::droptofloor" );
	if ( ( trace.fraction == 1.0f ) || trace.startsolid || trace.allsolid || !trace.ent )
		{
		groundentity = world->edict;
		return false;
		}

	setOrigin( trace.endpos );

	groundentity = trace.ent;

	return true;
	}

void Entity::DamageType
   (
   Event *ev
   )

   {
   str damage;
   damage = ev->GetString( 1 );
   if ( damage == "all" )
      {
      damage_type = -1;
      }
   else
      {
      damage_type = MOD_NameToNum( damage );
      }
   }

void Entity::Damage
   (
   Entity *inflictor,
   Entity *attacker,
   float damage,
   const Vector &position,
   const Vector &direction,
   const Vector &normal,
   int knockback,
   int dflags,
   int meansofdeath,
	int surface_number,
	int bone_number,
	Entity *weapon
   )

   {
	Event	*ev;

   // if our damage types do not match, return
   if ( !MOD_matches( meansofdeath, damage_type ) )
      {
      return;
      }

	if ( !attacker )
		{
		attacker = world;
		}
	if ( !inflictor )
		{
		inflictor = world;
		}

	ev = new Event( EV_Damage );
	ev->AddFloat( damage );
	ev->AddEntity ( inflictor );
	ev->AddEntity ( attacker );
   ev->AddVector ( position );
   ev->AddVector ( direction );
   ev->AddVector ( normal );
   ev->AddInteger( knockback );
   ev->AddInteger( dflags );
   ev->AddInteger( meansofdeath );
	ev->AddInteger( surface_number );
	ev->AddInteger( bone_number );
	ev->AddEntity( weapon );
   ProcessEvent  ( ev );
   }

void Entity::DamageEvent
	(
	Event *ev
	)

	{
	Entity	*inflictor;
	Entity	*attacker;
	float		damage;
	Vector	dir;
	Vector	momentum;
	Event		*event;
	float		m;

	if ( ( takedamage == DAMAGE_NO ) || ( movetype == MOVETYPE_NOCLIP ) )
		{
		return;
		}

	damage		= ev->GetFloat( 1 );
	inflictor	= ev->GetEntity( 2 );
	attacker		= ev->GetEntity( 3 );

	if ( !inflictor || !attacker )
		return;

	// figure momentum add
	if ( ( inflictor != world ) &&
		( movetype != MOVETYPE_NONE ) &&
		( movetype != MOVETYPE_STATIONARY ) &&
		( movetype != MOVETYPE_BOUNCE ) &&
		( movetype != MOVETYPE_PUSH ) &&
		( movetype != MOVETYPE_STOP ) )
		{
      dir = origin - ( inflictor->origin + ( inflictor->mins + inflictor->maxs ) * 0.5f );
		dir.normalize();

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

		momentum = dir * damage * ( 1700.0f / (float)m );
		velocity += momentum;
		}

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

	// team play damage avoidance
	//if ( ( global->teamplay == 1 ) && ( edict->team > 0 ) && ( edict->team == attacker->edict->team ) )
	//	{
	//	return;
	//	}

   if ( !multiplayerManager.inMultiplayer() && isSubclassOf( Player ) )
      {
      damage *= 0.15f;
      }

   if ( deadflag )
      {
      // Check for gib.
      if ( inflictor->isSubclassOf( Projectile ) )
         {
         Event *gibEv;

         health -= damage;

         gibEv = new Event( EV_Gib );
         gibEv->AddEntity( this );
         gibEv->AddFloat( health );
         ProcessEvent( gibEv );
         }
      return;
      }

	// do the damage
	health -= damage;
	if ( health <= 0.0f )
		{
      if ( attacker )
         {
		   event = new Event( EV_GotKill );
		   event->AddEntity( this );
		   event->AddFloat( damage );
		   event->AddEntity( inflictor );
         event->AddInteger( ev->GetInteger( 9 ) );
         event->AddInteger( 0 );
		   attacker->ProcessEvent( event );
         }

		event = new Event( EV_Killed );
		event->AddEntity( attacker );
		event->AddFloat( damage );
		event->AddEntity( inflictor );
		ProcessEvent( event );
		return;
		}

	event = new Event( EV_Pain );
	event->AddFloat( damage );
	event->AddEntity( attacker );
	ProcessEvent( event );
	}

void Entity::Stun
   (
   float time
   )

   {
   Event *ev = new Event( EV_Stun );
   ev->AddFloat( time );
   ProcessEvent( ev );
   }

/*
============
CanDamage

Returns true if the inflictor can directly damage the target.  Used for
explosions and melee attacks.
============
*/
qboolean Entity::CanDamage
	(
	const Entity *target,
	const Entity *skip_ent
	)

	{
	trace_t	trace;
	Vector	pos;
	const Entity *skip_entity;
	//int maskToUse = MASK_SHOT;
	int maskToUse = CONTENTS_SOLID;

	if ( skip_ent )
		skip_entity = skip_ent;
	else
		skip_entity = this;

   trace = G_Trace( origin, vec_origin, vec_origin, target->centroid, skip_entity, maskToUse, false, "Entity::CanDamage 1" );
	if ( ( trace.fraction == 1.0f ) || ( trace.ent == target->edict ) )
		{
		return true;
		}
	pos = target->centroid + Vector( 15.0f, 15.0f, 0.0f );
   trace = G_Trace( origin, vec_origin, vec_origin, pos, skip_entity, maskToUse, false, "Entity::CanDamage 3" );
	if ( ( trace.fraction == 1.0f ) || ( trace.ent == target->edict ) )
		{
		return true;
		}
	pos = target->centroid + Vector( -15.0f, 15.0f, 0.0f );
   trace = G_Trace( origin, vec_zero, vec_zero, pos, skip_entity, maskToUse, false, "Entity::CanDamage 4" );
	if ( ( trace.fraction == 1.0f ) || ( trace.ent == target->edict ) )
		{
		return true;
		}
	pos = target->centroid + Vector( 15.0f, -15.0f, 0.0f );
   trace = G_Trace( origin, vec_zero, vec_zero, pos, skip_entity, maskToUse, false, "Entity::CanDamage 5" );
	if ( ( trace.fraction == 1.0f ) || ( trace.ent == target->edict ) )
		{
		return true;
		}
  	pos = target->centroid + Vector( -15.0f, -15.0f, 0.0f );
   trace = G_Trace( origin, vec_zero, vec_zero, pos, skip_entity, maskToUse, false, "Entity::CanDamage 6" );
	if ( ( trace.fraction == 1.0f ) || ( trace.ent == target->edict ) )
		{
		return true;
		}

	return false;
	}

qboolean Entity::IsTouching
	(
	const Entity *e1
	)

	{
	if ( e1->absmin.x > absmax.x )
		{
		return false;
		}
	if ( e1->absmin.y > absmax.y )
		{
		return false;
		}
	if ( e1->absmin.z > absmax.z )
		{
		return false;
		}
	if ( e1->absmax.x < absmin.x )
		{
		return false;
		}
	if ( e1->absmax.y < absmin.y )
		{
		return false;
		}
	if ( e1->absmax.z < absmin.z )
		{
		return false;
		}

	return true;
	}

void Entity::FadeNoRemove
	(
	Event *ev
	)

	{
   float rate;
   float target;
   float myalpha;

   if ( ev->NumArgs() > 1 )
      {
      target = ev->GetFloat( 2 );
      }
   else
      {
      target = 0;
      }

   if ( ev->NumArgs() > 0 )
      {
      rate = ev->GetFloat( 1 );
      assert( rate );
      if ( rate > 0.0f )
         rate = FRAMETIME / rate;
      }
   else
      {
      rate = 0.03f;
      }

   myalpha = edict->s.alpha;
   myalpha -= rate;

   if ( myalpha < target )
      myalpha = target;

   setAlpha( myalpha );

   if ( myalpha > target )
      {
      PostEvent( *ev, FRAMETIME );
      }

   G_SetConstantLight( &edict->s.constantLight, &myalpha, &myalpha, &myalpha, 0 );
	}

void Entity::FadeOut
	(
	Event *ev
	)

	{
   float myscale;
   float myalpha;

   myscale = edict->s.scale;
   myscale -= 0.03f;
   myalpha = edict->s.alpha;
   myalpha -= 0.03f;
   if ( myscale < 0.0f )
      myscale = 0.0f;
   if ( myalpha < 0.0f )
      myalpha = 0.0f;

	if ( ( myscale <= 0.0f ) && ( myalpha <= 0.0f ) )
		{
	   PostEvent( EV_Remove, 0.0f );
		}
   else
      {
	   PostEvent( *ev, FRAMETIME );
      }

   setScale( myscale );
   setAlpha( myalpha );
	}

void Entity::FadeIn
	(
	Event *ev
	)

	{
   float rate;
   float target;
   float myalpha;

   if ( ev->NumArgs() > 1 )
      {
      target = ev->GetFloat( 2 );
      }
   else
      {
      target = 1;
      }

   if ( ev->NumArgs() > 0 )
      {
      rate = ev->GetFloat( 1 );
      assert( rate );
      if ( rate > 0.0f )
         rate = FRAMETIME / rate;
      }
   else
      {
      rate = 0.03f;
      }

   myalpha = edict->s.alpha;
   myalpha += rate;

   if ( myalpha > target )
      myalpha = target;

   if ( myalpha < target )
		{
   	PostEvent( *ev, FRAMETIME );
		}
   setAlpha( myalpha );
	}

void Entity::Fade
	(
	Event *ev
	)

	{
   float rate;
   float target;
   float myalpha;

   if ( ev->NumArgs() > 1 )
      {
      target = ev->GetFloat( 2 );
      }
   else
      {
      target = 0;
      }

   if ( ev->NumArgs() > 0 )
      {
      rate = ev->GetFloat( 1 );
      assert( rate );
      if ( rate > 0.0f )
         rate = FRAMETIME / rate;
      }
   else
      {
      rate = 0.03f;
      }

   myalpha = edict->s.alpha;
   myalpha -= rate;

   if ( myalpha <= 0.0f )
		{
	   PostEvent( EV_Remove, 0.0f );
      return;
		}

   if ( myalpha < target )
      myalpha = target;

   if ( myalpha > target )
      {
      PostEvent( *ev, FRAMETIME );
      }

   setAlpha( myalpha );
   G_SetConstantLight( &edict->s.constantLight, &myalpha, &myalpha, &myalpha, 0 );
	}

void Entity::SetMassEvent
	(
	Event *ev
	)

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

void Entity::CheckGround
	(
   void
	)

	{
	Vector	point;
	trace_t	trace;

	if ( flags & ( FL_SWIM | FL_FLY ) )
		{
		return;
		}

	if ( velocity.z > 100.0f )
		{
		groundentity = NULL;
		return;
		}

	// if the hull point one-quarter unit down is solid the entity is on ground
	point = origin;
	point.z -= sv_groundtracelength->value;
	
	trace = G_Trace( origin, mins, maxs, point, this, edict->clipmask, false, "Entity::CheckGround" );

	if (!(trace.surfaceFlags & SURF_TERRAIN))
	{
		point.z = origin.z - 0.25f; // put groundtrace dist back to 0.25f for non-terrain check
		trace = G_Trace( origin, mins, maxs, point, this, edict->clipmask, false, "Entity::CheckGround" );
	}

	// check steepness
	if ( ( trace.plane.normal[ 2 ] <= 0.7f ) && !trace.startsolid )
		{
		groundentity = NULL;
		return;
		}

	groundentity = trace.ent;
	groundplane = trace.plane;
	groundcontents = trace.contents;

	if ( !trace.startsolid && !trace.allsolid )
		{
		setOrigin( trace.endpos );
		velocity.z = 0;
		}
	}

void Entity::BecomeSolid
	(
	Event *ev
	)

	{
	if ( ( model.length() ) && ( ( model[ 0 ] == '*' ) || ( strstr( model.c_str(), ".bsp" ) ) ) )
		{
		setSolidType( SOLID_BSP );
		}
	else
		{
		setSolidType( SOLID_BBOX );
		}
	}

void Entity::BecomeNonSolid
	(
	Event *ev
	)

	{
	setSolidType( SOLID_NOT );
	}

void Entity::Ghost
	(
	Event *ev
	)

	{
   // Make not solid, but send still send over whether it is hidden or not
	setSolidType( SOLID_NOT );
   edict->svflags &= ~SVF_NOCLIENT;
	}

void Entity::LoopSound
	(
	Event *ev
	)

	{
	str sound_name;
	float volume   = DEFAULT_VOL;
	float min_dist = DEFAULT_MIN_DIST;
	str min_dist_string;


	if (ev->NumArgs() < 1)
		return;

	// Get parameters

	sound_name = ev->GetString( 1 );

	if ( ev->NumArgs() > 1 )
		volume = ev->GetFloat( 2 );

	if ( ev->NumArgs() > 2 )
		{
		min_dist_string = ev->GetString( 3 );

		if ( min_dist_string == LEVEL_WIDE_STRING )
			min_dist = LEVEL_WIDE_MIN_DIST;
		else
			min_dist = ev->GetFloat( 3 );

		if ( min_dist >= LEVEL_WIDE_MIN_DIST_CUTOFF )
			min_dist = LEVEL_WIDE_MIN_DIST;
		}

	// Add this sound to loop

	LoopSound( sound_name, volume, min_dist );
	}

void Entity::LoopSound( const str &sound_name, float volume, float min_dist )
	{
	const char *name = NULL;
	str random_alias;


	// Get the real sound to be played

	if ( sound_name.length() > 0 )
		{
		// Get the real sound to play

		name = gi.GlobalAlias_FindRandom( sound_name.c_str() );

		if ( !name )
			{
			random_alias = GetRandomAlias( sound_name ).c_str();

			if ( random_alias.length() > 0 )
				name = random_alias.c_str();
			}

		if ( !name )
			name = sound_name.c_str();

		// Add the looping sound to the entity

      edict->s.loopSound        = gi.soundindex( name );
		edict->s.loopSoundVolume  = volume;
		edict->s.loopSoundMinDist = min_dist;
		}
	}

void Entity::StopLoopSound( Event *ev )
	{
   StopLoopSound();
	}

void Entity::StopLoopSound( void )
	{
   edict->s.loopSound = 0;
	}

void Entity::Sound( Event *ev )
	{
	str sound_name;
	float volume;
   int channel;
   float min_dist;
   int i;
	str min_dist_string;


   // Set defaults

   volume   = DEFAULT_VOL;
	min_dist = DEFAULT_MIN_DIST;
   channel  = CHAN_BODY;

	// Get sound parameters

   for ( i = 1 ; i <= ev->NumArgs() ; i++ )
      {
      switch (i-1)
         {
         case 0:
            sound_name = ev->GetString( i );
            break;
         case 1:
            channel = ev->GetInteger( i );
            break;
			case 2:
            volume = ev->GetFloat( i );
            break;
         case 3:
				min_dist_string = ev->GetString( i );

				if ( min_dist_string == LEVEL_WIDE_STRING )
					min_dist = LEVEL_WIDE_MIN_DIST;
				else
					min_dist = ev->GetFloat( i );

				if ( min_dist >= LEVEL_WIDE_MIN_DIST_CUTOFF )
					min_dist = LEVEL_WIDE_MIN_DIST;
            break;
         default:
            break;
         }
      }

	Sound( sound_name, channel, volume, min_dist, NULL );
	}

void Entity::StopSound
	(
	Event *ev
	)

	{
   if (ev->NumArgs() < 1)
      StopSound( CHAN_BODY );
   else
      StopSound( ev->GetInteger( 1 ) );
	}

void Entity::StopSound
	(
	int channel
	)

	{
	gi.StopSound( entnum, channel );
	}

void Entity::SetLight
	(
	Event *ev
	)

	{
   float r, g, b;

   if ( ev->NumArgs() == 1 )
      {
      Vector tmp;

      tmp = ev->GetVector( 1 );
      r = tmp.x;
      g = tmp.y;
      b = tmp.z;
      }
   else
      {
      r = ev->GetFloat( 1 );
      g = ev->GetFloat( 2 );
      b = ev->GetFloat( 3 );
      lightRadius  = ev->GetFloat( 4 );
      }

   G_SetConstantLight( &edict->s.constantLight, &r, &g, &b, &lightRadius );
   }

void Entity::LightOn
	(
	Event *ev
	)

	{
   G_SetConstantLight( &edict->s.constantLight, NULL, NULL, NULL, &lightRadius );
   }

void Entity::LightOff
	(
	Event *ev
	)

	{
   float radius = 0;

   G_SetConstantLight( &edict->s.constantLight, NULL, NULL, NULL, &radius );
   }

void Entity::LightRed
	(
	Event *ev
	)

	{
   float r;

   r = ev->GetFloat( 1 );
   G_SetConstantLight( &edict->s.constantLight, &r, NULL, NULL, NULL );
   }

void Entity::LightGreen
	(
	Event *ev
	)

	{
   float g;

   g = ev->GetFloat( 1 );
   G_SetConstantLight( &edict->s.constantLight, NULL, &g, NULL, NULL );
   }

void Entity::LightBlue
	(
	Event *ev
	)

	{
   float b;

   b = ev->GetFloat( 1 );
   G_SetConstantLight( &edict->s.constantLight, NULL, NULL, &b, NULL );
   }

void Entity::LightRadius
	(
	Event *ev
	)

	{
   lightRadius = ev->GetFloat( 1 );
   G_SetConstantLight( &edict->s.constantLight, NULL, NULL, NULL, &lightRadius );
   }

void Entity::LightStyle
	(
	Event *ev
	)

	{
   int style;

   style = ev->GetInteger( 1 );
   G_SetConstantLight( &edict->s.constantLight, NULL, NULL, NULL, NULL, &style );
   }

void Entity::SetHealth
	(
	Event *ev
	)

	{
	health = ev->GetFloat( 1 );
   if( max_health < health )
		{
		max_health = health;
		}
	
	}


//--------------------------------------------------------------
//
// Name:			setGameplayHealth
// Class:			Entity
//
// Description:		This function acts as a filter to the real function.
//					It gets data from the database, and then passes it
//					along to the original event.  This is here as an attempt
//					to sway people into using the database standard instead of
//					hardcoded numbers.
//
// Parameters:		Event *ev
//						str -- The value keyword from the database (low, medium, high, etc).
//
// Returns:			None
//
//--------------------------------------------------------------
void Entity::setGameplayHealth( Event *ev )
{
	if ( ev->NumArgs() < 1 )
		return;

	GameplayManager *gpm = GameplayManager::getTheGameplayManager();	
	if ( !gpm->hasFormula("Health") )
		return;

	str healthstr = ev->GetString( 1 );
	float healthmod = 1.0f;
	if ( gpm->getDefine(healthstr) != "" )
		healthmod = (float)atof(gpm->getDefine(healthstr));
	GameplayFormulaData fd(this);
	float finalhealth = gpm->calculate("Health", fd, healthmod);
	Event *newev = new Event(EV_SetHealth);
	newev->AddFloat(finalhealth);
	ProcessEvent(newev);
}

//----------------------------------------------------------------
// Name:			addHealth
// Class:			Entity
//
// Description:		Adds health to the entity up to the max health of the entity or the
//					max health specified (if its not 0) 
//
// Parameters:		float healthToAdd				- health we are going to add to the entity
//					float maxHealth					- if not 0, the max health the entity can have
//
// Returns:			none
//----------------------------------------------------------------

void Entity::addHealth( float healthToAdd, float maxHealth )
{
	float tempMaxHealth;
	float newHealth;

	// Get the max health

	if ( maxHealth )
		tempMaxHealth = maxHealth;
	else
		tempMaxHealth = max_health;

	// Calculate the new health

	newHealth = health + healthToAdd;

	// Set the new health
	
	if ( newHealth > tempMaxHealth )
		setHealth( tempMaxHealth );
	else
		setHealth( newHealth );
}

void Entity::GetHealth
	(
	Event *ev
	)

	{
	ev->ReturnFloat( health );
	}

void Entity::SetMaxHealth 
	(
	Event *ev
	)
	{
	max_health = ev->GetFloat( 1 );
	}

void Entity::SetSize
	(
	Event *ev
	)

	{
	Vector min, max;

   min = ev->GetVector( 1 );
   max = ev->GetVector( 2 );
   setSize( min, max );
   }

void Entity::SetMins
	(
	Event *ev
	)

	{
	Vector min;

   min = ev->GetVector( 1 );
   setSize( min, maxs );
   }

void Entity::SetMaxs
	(
	Event *ev
	)

	{
	Vector max;

   max = ev->GetVector( 1 );
   setSize( mins, max );
   }

void Entity::GetMins
	(
	Event *ev
	)

	{
	ev->ReturnVector( mins );
	}
	
void Entity::GetMaxs
	(
	Event *ev
	)

	{
	ev->ReturnVector( maxs );
	}


void Entity::SetScale
	(
	Event *ev
	)

	{
	setScale( ev->GetFloat( 1 ) );
   }

void Entity::setRandomScale( Event *ev )
{
	float minScale;
	float maxScale;

	minScale = ev->GetFloat( 1 );
	maxScale = ev->GetFloat( 2 );

	setScale( G_Random( maxScale - minScale ) + minScale );
}

void Entity::SetAlpha
	(
	Event *ev
	)

	{
	setAlpha( ev->GetFloat( 1 ) );
   }

void Entity::SetOrigin
	(
	Event *ev
	)

	{
	setOrigin( ev->GetVector( 1 ) );
	}

void Entity::GetOrigin
	(
	Event *ev
	)

	{
	ev->ReturnVector( origin );
	}

void Entity::SetTargetName
	(
	Event *ev
	)

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

//----------------------------------------------------------------
// Name:			GetRawTargetName
// Class:			Entity
//
// Description:		Gets the targetname of the entity without the leading $
//
// Parameters:		None
//
// Returns:			str targetname (through ev)		- the targetname of the entity
//----------------------------------------------------------------

void Entity::GetRawTargetName
	(
	Event *ev
	)

	{
	ev->ReturnString( targetname );
	}

//----------------------------------------------------------------
// Name:			GetTargetName
// Class:			Entity
//
// Description:		Gets the targetname of the entity with the leading $
//
// Parameters:		None
//
// Returns:			str targetname (through ev)		- the targetname of the entity
//----------------------------------------------------------------

void Entity::GetTargetName
	(
	Event *ev
	)

	{
	str nameToReturn;

	nameToReturn = "$";
	nameToReturn += targetname;

	ev->ReturnString( nameToReturn );
	}

void Entity::SetTarget
	(
	Event *ev
	)

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

void Entity::getTarget( Event *ev )
{
	str nameToReturn;
	bool wantsPrefix;

	if ( ev->NumArgs() > 0 )
		wantsPrefix = ev->GetBoolean( 1 );
	else
		wantsPrefix = false;

	if ( wantsPrefix )
	{
		nameToReturn = "$";
	}

	nameToReturn += target;

	ev->ReturnString( nameToReturn );
}

//--------------------------------------------------------------
// Name:		GetTargetEntity()
// Class:		Entity
//	
// Description:	Returns the Entity of the target 
//
// Parameters:	Event *ev
//
// Returns:		None ( Entity, though, through the event )
//--------------------------------------------------------------
void Entity::GetTargetEntity( Event *ev )
{
	TargetList *tlist	 = world->GetTargetList( target, false );
   
	if ( tlist )
		{
		 ev->ReturnEntity( tlist->GetNextEntity( NULL ) );
		}
	else
		{
		ev->ReturnEntity( NULL );
		}	
}


void Entity::SetKillTarget
	(
	Event *ev
	)

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

//-----------------------------------------------------
//
// Name:		GetModelName
// Class:		Entity
//
// Description:	Retrieves the model name
//
// Parameters:	event - the event to request the model name
//
// Returns:		None
//-----------------------------------------------------
void Entity::GetModelName(Event* ev)
{
	ev->ReturnString(model.c_str());
}

void Entity::SetAngles
	(
	Event *ev
	)

	{
	setAngles( ev->GetVector( 1 ) );
	}

//-----------------------------------------------------
//
// Name:		GetAngles
// Class:		Entity
//
// Description:	Retrieves the entity's angles
//
// Parameters:	event - event to request the entity's angles
//
// Returns:		None
//-----------------------------------------------------
void Entity::GetAngles(Event* ev)
{
	ev->ReturnVector(angles);
}


Vector Entity::GetControllerAngles
	(
	int num
	)

	{
	Vector controller_angles;

   assert( ( num >= 0 ) && ( num < NUM_BONE_CONTROLLERS ) );

   if ( ( num < 0 ) || ( num >= NUM_BONE_CONTROLLERS ) )
      {
      error( "GetControllerAngles", "Bone controller index out of range (%d)\n", num );
      return vec_zero;
      }

	controller_angles = edict->s.bone_angles[ num ];

   return controller_angles;
   }

void Entity::SetControllerAngles
	(
	int num,
   vec3_t angles
	)

	{
   assert( ( num >= 0 ) && ( num < NUM_BONE_CONTROLLERS ) );

   if ( ( num < 0 ) || ( num >= NUM_BONE_CONTROLLERS ) )
      {
      error( "SetControllerAngles", "Bone controller index out of range (%d)\n", num );
      return;
      }

   VectorCopy( angles, edict->s.bone_angles[ num ] );
   EulerToQuat( edict->s.bone_angles[ num ], edict->s.bone_quat[ num ] );
   }

void Entity::SetControllerAngles
	(
	Event *ev
	)

	{
	int num;
   Vector angles;

	if ( ev->NumArgs() < 2 )
		return;

	num = ev->GetInteger( 1 );
	angles = ev->GetVector( 2 );

	SetControllerAngles( num, angles );
   }

void Entity::SetControllerTag
	(
	int num,
   int tag_num
	)

	{
   assert( ( num >= 0 ) && ( num < NUM_BONE_CONTROLLERS ) );

   if ( ( num < 0 ) || ( num >= NUM_BONE_CONTROLLERS ) )
      {
      error( "SetControllerTag", "Bone controller index out of range (%d)\n", num );
      return;
      }

   edict->s.bone_tag[ num ] = tag_num;
   }



//===============================================================
// Name:		SetFullTraceEvent
// Class:		Entity
//
// Description: Sets the fulltrace flag.  This flag is used by
//				G_PushMove to determine if the object needs a
//				fulltrace or not.  Default for flag is false.
// 
// Parameters:	Event* -- first argument is boolean
//
// Returns:		None
// 
//===============================================================
inline void Entity::SetFullTraceEvent
(
	Event *ev
)
{
	_fulltrace = ev->GetBoolean( 1 );
}


void Entity::RegisterAlias
	(
	Event *ev
	)

	{
	char parameters[100];
	int i;

	// Get the parameters for this alias command

	parameters[0] = 0;

	for( i = 3 ; i <= ev->NumArgs() ; i++ )
	{
		strcat( parameters, ev->GetString( i ) );
		strcat( parameters, " ");
	}

   gi.Alias_Add( edict->s.modelindex, ev->GetString( 1 ), ev->GetString( 2 ),  parameters );
	}

void Entity::Cache
	(
	Event *ev
	)

	{
   CacheResource( ev->GetString( 1 ), this );
   }

void Entity::RegisterAliasAndCache
	(
	Event *ev
	)

	{
	RegisterAlias(ev);

   CacheResource( ev->GetString( 2 ), this );
	}

void Entity::Sound
	(
	const str &sound_name,
   int   channel,
	float volume,
   float min_dist,
	Vector *sound_origin,
	float pitch_modifier,
	qboolean onlySendToThisEntity
	)
	{
	const char *name = NULL;
	vec3_t org;
	str random_alias;


	if ( sound_name.length() > 0 )
		{
		// Get the real sound to play

		name = gi.GlobalAlias_FindRandom( sound_name.c_str() );

		if ( !name )
			{
			random_alias = GetRandomAlias( sound_name ).c_str();

			if ( random_alias.length() > 0 )
				name = random_alias.c_str();
			}

		if ( !name )
			name = sound_name.c_str();

		// Play the sound

		if ( name != NULL )
			{
			if ( sound_origin != NULL)
				{
				sound_origin->copyTo( org );
				entnum = ENTITYNUM_NONE;
				}
			else
				{
				VectorCopy( edict->s.origin, org );
				}

			gi.Sound( &org, entnum, channel, name, volume, min_dist, pitch_modifier, onlySendToThisEntity );
			}
		}
	else
		{
		warning( "Sound", "Null sample pointer" );
		}
	}

qboolean Entity::attach
	(
   int parent_entity_num,
   int tag_num,
	qboolean use_angles,
	Vector offset,
	Vector angles_offset
	)

	{
   int i;
   Entity * parent;

   if ( entnum == parent_entity_num )
      {
      warning("attach","Trying to attach to oneself." );
      return false;
      }

   if ( edict->s.parent != ENTITYNUM_NONE )
      detach();

   //
   // make sure this is a modelanim entity so that the attach works properly
   //
   if ( edict->s.eType == ET_GENERAL )
      {
      edict->s.eType = ET_MODELANIM;
      }

   //
   // get the parent
   //
   parent = ( Entity * )G_GetEntity( parent_entity_num );

	if ( !parent->bind_info )
		parent->bind_info = CreateBindInfo();

   if (parent->bind_info->numchildren < MAX_MODEL_CHILDREN)
      {
      //
      // find a free spot in the parent
      //
      for ( i=0; i < MAX_MODEL_CHILDREN; i++ )
         if ( parent->bind_info->children[i] == ENTITYNUM_NONE )
            {
            break;
            }
      edict->s.parent = parent_entity_num;
      setSolidType( SOLID_NOT );
      parent->bind_info->children[i] = entnum;
      parent->bind_info->numchildren++;
	  if ( tag_num >= 0 )
	  {
		edict->s.tag_num = tag_num;
	  }
		edict->s.attach_use_angles = use_angles;
		offset.copyTo( edict->s.attach_offset );
		angles_offset.copyTo( edict->s.attach_angles_offset );
      setOrigin();
      return true;
      }
   return false;
	}

void Entity::KillAttach
	(
	Event *ev
	)

	{
   int i;
	Entity *child = NULL;


	if ( bind_info )
		{
		// Kill all of this entities children

		for ( i = 0 ; i < MAX_MODEL_CHILDREN; i++ )
			{
			if ( bind_info->children[i] != ENTITYNUM_NONE )
				{
				// Remove child
				child = ( Entity * )G_GetEntity( bind_info->children[i] );

				if ( child )
					child->ProcessEvent( EV_Remove );

				// Remove child from this entity
				bind_info->children[i] = ENTITYNUM_NONE;
				}
			}

		bind_info->numchildren = 0;
		}
	}

void Entity::detach
	(
	void
	)

	{
   int i;
   int num;
   Entity * parent;

   if ( edict->s.parent == ENTITYNUM_NONE )
      return;

   parent = ( Entity * )G_GetEntity( edict->s.parent );

   if (!parent)
      return;

	if ( parent->bind_info)
		{
		for ( i=0,num = parent->bind_info->numchildren; i < MAX_MODEL_CHILDREN; i++ )
			{
			if ( parent->bind_info->children[i] == ENTITYNUM_NONE )
				{
				continue;
				}
			if (parent->bind_info->children[i] == entnum)
				{
				parent->bind_info->children[i] = ENTITYNUM_NONE;
				parent->bind_info->numchildren--;
				break;
				}
			num--;
			if (!num)
				break;
			}
		}

   edict->s.parent = ENTITYNUM_NONE;
   setOrigin( origin );
	}

void Entity::Flags( Event *ev )
   {
   const char *flag;
   int mask;
   int action;
   int i;

   for ( i = 1; i <= ev->NumArgs(); i++ )
      {
      action = FLAG_IGNORE;
      flag = ev->GetString( i );
      switch( flag[0] )
         {
         case '+':
            action = FLAG_ADD;
            flag++;
            break;
         case '-':
            action = FLAG_CLEAR;
            flag++;
            break;
         default:
            ev->Error( "Entity::Flags", "First character is not '+' or '-', assuming '+'\n" );
            action = FLAG_ADD;
            break;
         }

      //
      // WARNING: please change the Event decleration,
      // to match this function, if flags are added or
      // deleted the event must be updated.
      //
      if ( !stricmp( flag, "blood" ) )
         mask = FL_BLOOD;
      else if ( !stricmp( flag, "explode" ) )
         mask = FL_DIE_EXPLODE;
      else if ( !stricmp( flag, "die_gibs" ) )
         mask = FL_DIE_GIBS;
      else if ( !stricmp( flag, "autoaim" ) )
         mask = FL_AUTOAIM;
      else if ( !stricmp( flag, "god" ) )
         mask = FL_GODMODE;
		else if ( !stricmp( flag, "notarget" ) )
			mask = FL_NOTARGET;
      else
         {
         mask = 0;
         action = FLAG_IGNORE;
         ev->Error( "Unknown flag '%s'", flag );
         }
      switch (action)
         {
         case FLAG_ADD:
            flags |= mask;
            break;
         case FLAG_CLEAR:
            flags &= ~mask;
            break;
         case FLAG_IGNORE:
            break;
         }
      }
   if ( !com_blood->integer )
      {
      if ( flags & (FL_BLOOD|FL_DIE_GIBS) )
         {
         flags &= ~FL_BLOOD;
         flags &= ~FL_DIE_GIBS;
         }
      }
   }


void Entity::Effects( Event *ev )
   {
   const char *flag;
   int mask=0;
   int action;
   int i;

   for ( i = 1; i <= ev->NumArgs(); i++ )
      {
      action = 0;
      flag = ev->GetString( i );
      switch( flag[0] )
         {
         case '+':
            action = FLAG_ADD;
            flag++;
            break;
         case '-':
            action = FLAG_CLEAR;
            flag++;
            break;
         default:
            ev->Error( "Entity::Effects", "First character is not '+' or '-', assuming '+'\n" );
            action = FLAG_ADD;
            break;
         }

      //
      // WARNING: please change the Event decleration,
      // to match this function, if flags are added or
      // deleted the event must be updated.
      //
      if ( !stricmp( flag, "everyframe" ) )
         mask = EF_EVERYFRAME;
      else
         {
         action = FLAG_IGNORE;
         ev->Error( "Unknown token %s.", flag );
         }

      switch (action)
         {
         case FLAG_ADD:
            edict->s.eFlags |= mask;
            break;
         case FLAG_CLEAR:
            edict->s.eFlags &= ~mask;
            break;
         case FLAG_IGNORE:
            break;
         }
      }
   }

void Entity::RenderEffects( Event *ev )
   {
   const char *flag;
   int mask=0;
   int action;
   int i;

   for ( i = 1; i <= ev->NumArgs(); i++ )
      {
      action = 0;
      flag = ev->GetString( i );
      switch( flag[0] )
         {
         case '+':
            action = FLAG_ADD;
            flag++;
            break;
         case '-':
            action = FLAG_CLEAR;
            flag++;
            break;
         default:
            ev->Error( "Entity::RenderEffects", "First character is not '+' or '-', assuming '+'\n" );
            action = FLAG_ADD;
            break;
         }

      //
      // WARNING: please change the Event decleration,
      // to match this function, if flags are added or
      // deleted the event must be updated.
      //
      if ( !stricmp( flag, "dontdraw" ) )
         mask = RF_DONTDRAW;
      else if ( !stricmp( flag, "betterlighting" ) )
         mask = RF_EXTRALIGHT;
      else if ( !stricmp ( flag, "lensflare" ) )
         mask = RF_LENSFLARE;
      else if ( !stricmp ( flag, "viewlensflare" ) )
         mask = RF_VIEWLENSFLARE;
      else if ( !stricmp ( flag, "lightoffset" ) )
         mask = RF_LIGHTOFFSET;
      else if ( !stricmp( flag, "skyorigin" ) )
         mask = RF_SKYORIGIN;
      else if ( !stricmp( flag, "fullbright" ) )
         mask = RF_FULLBRIGHT;
      else if ( !stricmp( flag, "minlight" ) )
         mask = RF_MINLIGHT;
      else if ( !stricmp( flag, "additivedynamiclight" ) )
         mask = RF_ADDITIVE_DLIGHT;
      else if ( !stricmp( flag, "lightstyledynamiclight" ) )
         mask = RF_LIGHTSTYLE_DLIGHT;
      else if ( !stricmp( flag, "shadow" ) )
         mask = RF_SHADOW;
	  else if ( !stricmp( flag, "shadowFromBip01" ) )
         mask = RF_SHADOW_FROM_BIP01;
      else if ( !stricmp( flag, "preciseshadow" ) )
         mask = RF_SHADOW_PRECISE;
	  else if ( !stricmp( flag, "dontInheritAlpha" ) )
         mask = RF_CHILDREN_DONT_INHERIT_ALPHA;
      else if ( !stricmp( flag, "invisible" ) )
         mask = RF_INVISIBLE;
	  else if ( !stricmp( flag, "depthhack" ) )
         mask = RF_DEPTHHACK;
      else
         {
         action = FLAG_IGNORE;
         ev->Error( "Unknown token %s.", flag );
         }

      switch (action)
         {
         case FLAG_ADD:
            edict->s.renderfx |= mask;
            break;
         case FLAG_CLEAR:
            edict->s.renderfx &= ~mask;
            break;
         case FLAG_IGNORE:
            break;
         }
      }
   }

void Entity::SVFlags
   (
   Event *ev
   )

   {
   const char *flag;
   int mask=0;
   int action;
   int i;

   for ( i = 1; i <= ev->NumArgs(); i++ )
      {
      action = 0;
      flag = ev->GetString( i );
      switch( flag[0] )
         {
         case '+':
            action = FLAG_ADD;
            flag++;
            break;
         case '-':
            action = FLAG_CLEAR;
            flag++;
            break;
         default:
            ev->Error( "Entity::SVFlags", "First character is not '+' or '-', assuming '+'\n" );
            action = FLAG_ADD;
            break;
         }

      //
      // WARNING: please change the Event decleration,
      // to match this function, if flags are added or
      // deleted the event must be updated.
      //
      if ( !stricmp( flag, "broadcast" ) )
         mask = SVF_BROADCAST;
      else if ( !stricmp( flag, "sendonce" ) )
         mask = SVF_SENDONCE;
      else
         {
         action = FLAG_IGNORE;
         ev->Error( "Unknown token %s.", flag );
         }

      switch (action)
         {
         case FLAG_ADD:
            edict->svflags |= mask;
            break;
         case FLAG_CLEAR:
            edict->svflags &= ~mask;
            break;
         case FLAG_IGNORE:
            break;
         }
      }

   if ( edict->svflags & SVF_SENDONCE )
      {
      // Turn this entity into an event if the SENDONCE flag is sent
      edict->s.eType = ET_EVENTS;
		edict->svflags &= ~SVF_SENT;
      }
   }

void Entity::BroadcastSound
	(
	float rad,
	int soundType	//Defaults to SOUNDTYPE_GENERAL
	)

	{
	if ( !( this->flags & FL_NOTARGET ) )
		{
      G_BroadcastSound( this, centroid, rad, soundType );
      }
	}

void Entity::BroadcastSound
	(
	Event *ev
	)

	{
   float rad		  = SOUND_RADIUS;
	int soundTypeIdx = SOUNDTYPE_GENERAL;
	str soundTypeStr = "";
		
	if ( !( this->flags & FL_NOTARGET ) )
		{
		
		if (ev->NumArgs() > 0 )	//<-- At least 1 Parameter
			{
			rad = ev->GetFloat( 1 );

			if(ev->NumArgs() > 1 )	//<-- At least 2 Parameters
				{
				soundTypeStr = ev->GetString( 2 );			
				soundTypeIdx = Soundtype_string_to_int( soundTypeStr );	
				}
			}
		
		if (soundTypeIdx == SOUNDTYPE_FOOTSTEPS_RUN || soundTypeIdx == SOUNDTYPE_FOOTSTEPS_WALK )
			rad = ModifyFootstepSoundRadius( rad , soundTypeIdx );


		BroadcastSound( rad, soundTypeIdx );
      }
	}

float Entity::ModifyFootstepSoundRadius
   (
	float radius,
	int soundTypeIdx
	)

	{
	trace_t	trace;
	Vector	end;
   Vector   start;

   start = origin; 
   end = origin;
	end[2]-= 1000.0f;
	int surftype;

	trace = G_Trace( start, mins, maxs, end, this, edict->clipmask, false, "Entity::ModifyFootstepsRadius" );
	surftype = trace.surfaceFlags & MASK_SURF_TYPE;
	
	switch ( surftype )
		{
		case SURF_TYPE_DIRT:
			radius *= .5f;
			break;
		case SURF_TYPE_ROCK:
			break;
		case SURF_TYPE_METAL:
			radius *= 1.5;
			break;
		case SURF_TYPE_GRILL:
			radius *= 1.25f;
			break;
		case SURF_TYPE_ORGANIC:
			radius *= .5f;
			break;
		case SURF_TYPE_SQUISHY:
			radius *= .5f;
			break;
		case SURF_TYPE_SAND:
			radius *= .5f;
			break;
		case SURF_TYPE_SNOW:
			radius *= .5f;
			break;
		case SURF_TYPE_METAL_DUCT:
			radius *= 1.25f;
			break;
		case SURF_TYPE_METAL_HOLLOW:
			radius *= 1.25f;
			break;
		case SURF_TYPE_CARPET:
			radius *= .5f;
			break;
      }
	
	//Tone Radius Down for Walking
	if (soundTypeIdx == SOUNDTYPE_FOOTSTEPS_WALK )
		radius *= .75f;

	return radius;
	}

void Entity::Think
	(
	void
	)

	{
	}

void Entity::SetWaterType
   (
   void
   )

   {
   qboolean isinwater;

   watertype = gi.pointcontents( origin, 0 );
	isinwater = watertype & MASK_WATER;

	if ( isinwater )
		{
		waterlevel = 1;
		}
	else
		{
		waterlevel = 0;
		}
   }

void Entity::DamageSkin
   (
   trace_t * trace,
   float damage
   )

   {
   /* FIXME : Do we need damage skins?
   int surface;

   // FIXME handle different bodyparts
   surface = trace->intersect.surface;
   if ( !edict->s.surfaces[ surface ] )
		{
      edict->s.surfaces[ surface ]++;
		}
   */
   }

void Entity::Kill
	(
	Event *ev
	)

	{
	health = 0.0f;
   Damage( this, this, 10.0f, origin, vec_zero, vec_zero, 0, 0, MOD_SUICIDE );
	}


void Entity::SurfaceCommand
	(
   const char * surf_name,
   const char * token
	)

	{
	const char * current_surface_name;
   int surface_num;
   int mask;
   int action;
   qboolean do_all = false;
	qboolean mult = false;


	if ( surf_name[ strlen( surf_name ) - 1 ] == '*' )
		{
		mult = true;
		surface_num = 0;
		}
	else if ( str( surf_name ) != str( "all" ) )
      {
      surface_num = gi.Surface_NameToNum( edict->s.modelindex, surf_name );

      if (surface_num < 0)
         {
		   warning( "SurfaceCommand", "group %s not found for entity %s (%d), model %s.\n", surf_name, targetname.c_str(), entnum, model.c_str() );
         return;
         }
      }
   else
      {
      surface_num = 0;
      do_all = true;
      }

   action = 0;
   switch( token[0] )
      {
      case '+':
         action = FLAG_ADD;
         token++;
         break;
      case '-':
         action = FLAG_CLEAR;
         token++;
         break;
      default:
         warning( "Entity::SurfaceModelEvent", "First character is not '+' or '-', assuming '+' for entity %s (%d), model %s\n", targetname.c_str(), entnum, model.c_str() );
         action = FLAG_ADD;
         break;
      }
   //
   // WARNING: please change the Event decleration,
   // to match this function, if flags are added or
   // deleted the event must be updated.
   //
   if (!stricmp( token, "skin1"))
      {
      mask = MDL_SURFACE_SKINOFFSET_BIT0;
      }
   else if (!strcmpi (token, "skin2"))
      {
      mask = MDL_SURFACE_SKINOFFSET_BIT1;
      }
   else if (!strcmpi (token, "nodraw"))
      {
      mask = MDL_SURFACE_NODRAW;
      }
   else if (!strcmpi (token, "crossfade"))
      {
      mask = MDL_SURFACE_CROSSFADE_SKINS;
      }
   else
      {
      mask = 0;
      warning( "SurfaceCommand", "Unknown token %s. for entity %s (%d), model %s", token, targetname.c_str(), entnum, model.c_str() );
      action = FLAG_IGNORE;
      }
   for( ; surface_num < numsurfaces ; surface_num++ )
      {
		if ( mult )
			{
			current_surface_name = gi.Surface_NumToName( edict->s.modelindex, surface_num );

			if ( Q_stricmpn( current_surface_name, surf_name, strlen( surf_name ) - 1) != 0 )
				continue;
			}

      switch (action)
         {
         case FLAG_ADD:
            edict->s.surfaces[ surface_num ] |= mask;
            break;
         case FLAG_CLEAR:
            edict->s.surfaces[ surface_num ] &= ~mask;
            break;
         case FLAG_IGNORE:
            break;
         }

      if ( !do_all && !mult )
         break;
      }
	}

void Entity::SurfaceModelEvent
	(
	Event *ev
	)

	{
   const char * surf_name;
   const char * token;
   int i;

   surf_name = ev->GetString( 1 );

   for ( i = 2; i <= ev->NumArgs() ; i++ )
      {
      token = ev->GetString( i );
      SurfaceCommand( surf_name, token );
      }
	}

void Entity::AttachEvent
	(
	Event * ev
	)
	{
   Entity * parent;
   const char * bone;
   int tagnum;
	qboolean use_angles = true;
	Vector offset;
	Vector angles_offset;

	parent = ev->GetEntity( 1 );
   bone = ev->GetString( 2 );

	if ( ev->NumArgs() > 2 )
		use_angles = ev->GetInteger( 3 );

	if ( ev->NumArgs() > 3 )
		offset = ev->GetVector( 4 );

	if ( ev->NumArgs() > 4 )
		angles_offset = ev->GetVector( 5 );

   if ( !parent )
      return;

   tagnum = gi.Tag_NumForName( parent->edict->s.modelindex, bone );
   if ( tagnum >= 0 )
      {
      attach( parent->entnum, tagnum, use_angles, offset, angles_offset );
      }
   else
      {
      warning( "AttachEvent", "Tag %s not found", bone );
      }
   }

void Entity::AttachModelEvent
	(
	Event * ev
	)
	{
   Entity * obj;
   const char * bone;
   str modelname;
   int tagnum;
	float remove_time,fade_time,fade_delay;
	Vector offset;
	Vector angles_offset;
	qboolean use_angles = false;

   obj = new Entity( ENTITY_CREATE_FLAG_ANIMATE );

	obj->bind_info = CreateBindInfo();

	modelname = ev->GetString( 1 );
   bone = ev->GetString( 2 );
   if ( ev->NumArgs() > 2 )
		{
      obj->setScale( ev->GetFloat( 3 ) );
		}
   if ( ev->NumArgs() > 3 )
		{
      obj->SetTargetName( ev->GetString( 4 ) );
		}

	if ( ev->NumArgs() > 4 )
      obj->bind_info->detach_at_death = ev->GetInteger( 5 );

	if ( ev->NumArgs() > 5 )
		{
		remove_time = ev->GetFloat( 6 );

		if ( remove_time > 0.0f )
			{
			Event *remove_event = new Event( EV_Remove );
			obj->PostEvent( remove_event, remove_time );
			}
		}

	if ( ev->NumArgs() > 6 )
		{
		Event *fade_event;

      fade_time = ev->GetFloat( 7 );

      if ( fade_time > 0.0f )
         {
   		obj->setAlpha( 0.0f );

	   	fade_event = new Event( EV_FadeIn );
		   fade_event->AddFloat( fade_time );
		   obj->PostEvent( fade_event, 0.0f );
         }
		}

 	if ( ev->NumArgs() > 7 )
		{
		Event *fade_event;

      fade_delay = ev->GetFloat( 8 );

      if ( fade_delay != -1.0f )
         {
         if ( ev->NumArgs() > 8 )
            fade_time = ev->GetFloat( 9 );
         else
            fade_time = 0.0f;

	   	fade_event = new Event( EV_Fade );

         if ( fade_time > 0.0f )
            fade_event->AddFloat( fade_time );

		   obj->PostEvent( fade_event, fade_delay );
         }
		}

	if ( ev->NumArgs() > 9 )
		offset = ev->GetVector( 10 );

	if ( ev->NumArgs() > 10 )
		{
		angles_offset = ev->GetVector( 11 );
		use_angles = false;
		}

   obj->setModel( modelname );
	
	if ( !obj->animate )
		{
		Animate *newAnimate = 0;
		newAnimate = new Animate;
		if ( newAnimate )
			obj->animate = newAnimate;
		}
				
	int anim_num = gi.Anim_Random ( obj->edict->s.modelindex, "idle" );
	if ( anim_num != -1 && obj->animate )
		{
		obj->animate->NewAnim( anim_num );
		}

   tagnum = gi.Tag_NumForName( edict->s.modelindex, bone );
   if ( tagnum >= 0 )
      {
      if ( !obj->attach( this->entnum, tagnum, use_angles, offset, angles_offset ) )
         {
         //warning( "AttachModelEvent", "Could not attach model %s", modelname.c_str() );
         delete obj;
         return;
         }
      }
   else
      {
      warning( "AttachModelEvent", "Tag %s not found", bone );
      }
   }

void Entity::RemoveAttachedModelEvent
	(
	Event *ev
	)
	{
   const char *tag_name;
   int tag_num;
	int num;
	int i;
	Entity *ent;
	float fade_rate = 0;
	Event *fade_event;
	str model_name;

	if ( bind_info )
		{
		tag_name = ev->GetString( 1 );
		tag_num = gi.Tag_NumForName( edict->s.modelindex, tag_name );

		if ( ev->NumArgs() > 1 )
			fade_rate = ev->GetFloat( 2 );

		if ( ev->NumArgs() > 2 )
			model_name = ev->GetString( 3 );

		if ( tag_num >= 0 )
			{
			num = bind_info->numchildren;

			for ( i = 0 ; (i < MAX_MODEL_CHILDREN) && num ; i++ )
				{
				if ( bind_info->children[i] == ENTITYNUM_NONE )
					continue;

				ent = ( Entity * )G_GetEntity( bind_info->children[i] );

				if ( ent && ent->edict->s.tag_num == tag_num )
					{
					if ( !model_name.length() || ( model_name == ent->model ) )
						{
						if ( fade_rate )
							{
							fade_event = new Event( EV_Fade );
							fade_event->AddFloat( fade_rate );
							fade_event->AddFloat( 0.0f );
							ent->PostEvent( fade_event, 0.0f );
							}

						ent->PostEvent( EV_Remove, fade_rate );
						}
					}

				num--;
				}
			}
		}
   }

void Entity::removeAttachedModelByTargetname( Event *ev )
{
	str targetNameToRemove;

	targetNameToRemove = ev->GetString( 1 );

	removeAttachedModelByTargetname( targetNameToRemove );
}

void Entity::removeAttachedModelByTargetname( const str &targetNameToRemove )
{
	int num;
	int i;
	Entity *ent;

	if ( bind_info )
	{	
		num = bind_info->numchildren;
		
		for ( i = 0 ; (i < MAX_MODEL_CHILDREN) && num ; i++ )
		{
			if ( bind_info->children[i] == ENTITYNUM_NONE )
				continue;
			
			ent = ( Entity * )G_GetEntity( bind_info->children[i] );
			
			if ( ent && stricmp( ent->targetname, targetNameToRemove.c_str() ) == 0 )
			{
				ent->PostEvent( EV_Remove, 0.0f );
			}
			
			num--;
		}
	}
}

void Entity::DetachEvent
	(
	Event * ev
	)

	{
   if ( edict->s.parent == ENTITYNUM_NONE  )
		{
      return;
		}
   detach();
   }

void Entity::TakeDamageEvent
	(
	Event * ev
	)
	{
   takedamage = DAMAGE_YES;
   }

void Entity::NoDamageEvent
	(
	Event * ev
	)
	{
   takedamage = DAMAGE_NO;
   }

void Entity::Gravity
   (
   Event *ev
   )

   {
   gravity = ev->GetFloat( 1 );
   }

void Entity::UseBoundingBoxEvent
   (
   Event *ev
   )
   {
	edict->svflags |= SVF_USEBBOX;
   }

void Entity::HurtEvent
   (
   Event *ev
   )
   {
   Vector normal;
   float dmg;
	int means_of_death;
	Vector direction;

   if ( ev->NumArgs() < 1 )
      {
      dmg = 50.0f;
      }
   else
      {
      dmg = ev->GetFloat( 1 );
      }

	if ( ev->NumArgs() > 1 )
		means_of_death = MOD_NameToNum( ev->GetString( 2 ) );
	else
		means_of_death = MOD_CRUSH;

	if ( ev->NumArgs() > 2 )
		{
		direction = ev->GetVector( 3 );
		direction.normalize();
		}
	else
		{
		direction = vec_zero;
		}

   normal = Vector( orientation[ 0 ] );
   Damage( world, world, dmg, centroid, direction, normal, (int)dmg, 0, means_of_death );
   }

void Entity::IfSkillEvent
	(
	Event *ev
	)

	{
   float skilllevel;

	skilllevel = ev->GetFloat( 1 );

   if ( skill->value == skilllevel )
      {
	   int			argc;
	   int			numargs;
      Event       *event;
	   int			i;

	   numargs = ev->NumArgs();
	   argc = numargs - 2 + 1;

      event = new Event( ev->GetToken( 2 ) );

	   for( i = 1; i < argc; i++ )
		   {
         event->AddToken( ev->GetToken( 2 + i ) );
		   }
      ProcessEvent( event );
		}
	}

void Entity::Censor
	(
	Event *ev
	)

	{
   Vector delta;
   float oldsize;
   float newsize;

   if ( com_blood->integer )
      return;

   oldsize = size.length();
	setSolidType( SOLID_NOT );
   setModel( "censored.tik" );
   gi.CalculateBounds( edict->s.modelindex, 1.0f, mins, maxs );
   delta = maxs - mins;
   newsize = delta.length();
   edict->s.scale = oldsize / newsize;
   mins *= edict->s.scale;
   maxs *= edict->s.scale;
   setSize( mins, maxs );
   setOrigin();
	}

void Entity::StationaryEvent
   (
   Event *ev
   )

	{
	setMoveType( MOVETYPE_STATIONARY );
	}

void Entity::Explosion
   (
   Event *ev
   )

   {
   str expmodel;
	str tag_name;
	//orientation_t orient;
	Vector explosion_origin;

	expmodel = ev->GetString( 1 );
	explosion_origin = origin;

	if ( ev->NumArgs() > 1 )
		{
		tag_name = ev->GetString( 2 );

		//if ( GetRawTag( tag_name.c_str(), &orient, legs ) )
		//	VectorAdd( orient.origin, origin, explosion_origin );

		GetTag( tag_name.c_str(), &explosion_origin );
		}

   ExplosionAttack( explosion_origin, this, expmodel );
   }

//----------------------------------------------------------------
// Name:			DoRadiusDamage
// Class:			Entity
//
// Description:		Does radius damage from entity origin,
//					optionally re-posting itself to some future time
//
// Parameters:		Event *ev
// Event params:	(1) float damage
//					(2) const char * means of death string
//					(3) float radius
//					(4) float knockback
//					(5) (optional) bool constant damage over distance
//					(6) (optional) float forward re-posting time
//
// Returns:			NULL
//----------------------------------------------------------------

void Entity::DoRadiusDamage( Event *ev )
{
	Entity *owner = this;
	float damage = ev->GetFloat(1);
	const char *modstring = ev->GetString(2);
	float radius = ev->GetFloat(3);
	float knockback = ev->GetFloat(4);
	bool constant_damage = false;
	float damageDone;

	if (ev->NumArgs() >= 5) // constant damage info is supplied
		constant_damage = ev->GetBoolean(5);

	if ( this->isSubclassOf( Projectile ) )
	{
		Projectile *projectile = (Projectile *)this;

		owner = projectile->getOwner();
	}

	if ( owner && owner->isSubclassOf( Player ) )
	{
		Player *player = (Player *)owner;
		
		damage = player->getDamageDone( damage, MOD_NameToNum( modstring ), false );
	}

	damageDone = RadiusDamage(	this,
					owner,
					damage,
					this,
					MOD_NameToNum(modstring),
					radius,
					knockback,
					constant_damage
					);

	if ( damageDone && this->isSubclassOf( Projectile ) )
	{
		Projectile *projectile = (Projectile *)this;

		projectile->didDamage();
	}

	if (ev->NumArgs() == 6)
	{
		// if repost time is set, re-post this event
		float postTime = ev->GetFloat(6);
		if (postTime >= FRAMETIME) 
		{
			Event *ev2 = new Event(ev);
			PostEvent(ev2,postTime);
		}	
	}
}

void Entity::SelfDetonate
   (
	Event *ev
	)
	{
	if ( explosionModel.length() == 0 )
		explosionModel = "fx/fx-sml-exp.tik";

	ExplosionAttack( origin , this , explosionModel );	
	}

void Entity::Shader
	(
	Event *ev
	)

	{
   const char * token;

   if ( gi.IsModel( edict->s.modelindex ) )
      {
      ev->Error( "shader event being called on TIKI model\n" );
      }
   //
   // get sub shader command
   //
   token = ev->GetString( 1 );

   //
   // WARNING: please change the Event decleration,
   // to match this function, if flags are added or
   // deleted the event must be updated.
   //
   if (!strcmpi( token, "translation"))
      {
      float x, y;

      x = ev->GetFloat( 2 );
      y = ev->GetFloat( 3 );
      TRANSLATION_TO_PKT( (int)x, edict->s.tag_num );
      TRANSLATION_TO_PKT( (int)y, edict->s.skinNum );
      }
   else if (!strcmpi( token, "offset"))
      {
      float x, y;

      x = ev->GetFloat( 2 );
      y = ev->GetFloat( 3 );
      OFFSET_TO_PKT( x, edict->s.tag_num );
      OFFSET_TO_PKT( y, edict->s.skinNum );
      }
   else if (!strcmpi (token, "rotation"))
      {
      float rot;

      rot = ev->GetFloat( 2 );
      ROTATE_TO_PKT( rot, edict->s.tag_num );
      }
   else if (!strcmpi (token, "frame"))
      {
      edict->s.frame = ev->GetInteger( 2 );
      }
   else if (!strcmpi (token, "wavebase"))
      {
      float base;

      base = ev->GetFloat( 2 );
      BASE_TO_PKT( base, edict->s.surfaces[ 0 ] );
      }
   else if (!strcmpi (token, "waveamp"))
      {
      float amp;

      amp = ev->GetFloat( 2 );
      AMPLITUDE_TO_PKT( amp, edict->s.surfaces[ 1 ] );
      }
   else if (!strcmpi (token, "wavephase"))
      {
      float phase;

      phase = ev->GetFloat( 2 );
      PHASE_TO_PKT( phase, edict->s.surfaces[ 2 ] );
      }
   else if (!strcmpi (token, "wavefreq"))
      {
      float freq;

      freq = ev->GetFloat( 2 );
      FREQUENCY_TO_PKT( freq, edict->s.surfaces[ 3 ] );
      }
	}

void Entity::DropToFloorEvent
   (
   Event *ev
   )

   {
   float range;

	if ( ev->NumArgs() > 0 )
      {
      range = ev->GetFloat( 1 );
      }
   else
      {
      range = WORLD_SIZE;
      }
   if ( !droptofloor( range ) )
      {
      }
	}


//*************************************************************************
//
// BIND code
//
//*************************************************************************

qboolean Entity::isBoundTo
   (
   const Entity *master
   )

   {
   Entity *ent;

	if ( bind_info )
		{
		for( ent = bind_info->bindmaster; ent != NULL; ent = ent->bind_info->bindmaster )
			{
			if ( ent == master )
				{
				return true;
				}
			}
		}

   return false;
   }

void Entity::bind
	(
	Entity *master,
	qboolean use_my_angles
	)

	{
	float  mat[ 3 ][ 3 ];
	float  local[ 3 ][ 3 ];
	Vector ang;

	assert( master );
	if ( !master )
		{
		warning( "bind", "Null master entity" );
		return;
		}

   if ( master == this )
      {
      warning( "bind", "Trying to bind to oneself." );
      return;
      }

	if ( !bind_info )
		bind_info = CreateBindInfo();

   // unbind myself from my master
   unbind();

	bind_info->bindmaster = master;
	edict->s.bindparent = master->entnum;
	bind_info->bind_use_my_angles = use_my_angles;

   // We are now separated from our previous team and are either
   // an individual, or have a team of our own.  Now we can join
   // the new bindmaster's team.  Bindmaster must be set before
   // joining the team, or we will be placed in the wrong position
   // on the team.
   joinTeam( master );

	// calculate local angles
	TransposeMatrix( bind_info->bindmaster->orientation, mat );
	R_ConcatRotations( mat, orientation, local );
	MatrixToEulerAngles( local, ang );
	setAngles( ang );

   setOrigin( getParentVector( GetLocalOrigin() - bind_info->bindmaster->origin ) );

   return;
   }

void Entity::unbind
	(
	void
	)

	{
   Entity *prev;
   Entity *next;
   Entity *last;
   Entity *ent;


	if ( !bind_info || !bind_info->bindmaster )
		return;

	//bindmaster = NULL;

   // Check this GAMEFIX - should it be origin?
	SetLocalOrigin( edict->s.origin );
	localangles = Vector( edict->s.angles );

   if ( !bind_info->teammaster )
      {
      bind_info->bindmaster = NULL;
		edict->s.bindparent = ENTITYNUM_NONE;
      //Teammaster already has been freed
      return;
      }

   // We're still part of a team, so that means I have to extricate myself
   // and any entities that are bound to me from the old team.
   // Find the node previous to me in the team
   prev = bind_info->teammaster;

	for( ent = bind_info->teammaster->bind_info->teamchain; ent && ( ent != this ); ent = ent->bind_info->teamchain )
		{
      prev = ent;
		}

   // If ent is not pointing to me, then something is very wrong.
   assert( ent );
   if ( !ent )
      {
      error( "unbind", "corrupt team chain\n" );
      }

   // Find the last node in my team that is bound to me.
   // Also find the first node not bound to me, if one exists.
   last = this;
   for( next = bind_info->teamchain; next != NULL; next = next->bind_info->teamchain )
      {
      if ( !next->isBoundTo( this ) )
         {
         break;
         }

      // Tell them I'm now the teammaster
      next->bind_info->teammaster = this;
      last = next;
		}

   // disconnect the last member of our team from the old team
   last->bind_info->teamchain = NULL;

   // connect up the previous member of the old team to the node that
   // follow the last node bound to me (if one exists).
   if ( bind_info->teammaster != this )
      {
      prev->bind_info->teamchain = next;
      if ( !next && ( bind_info->teammaster == prev ) )
         {
         prev->bind_info->teammaster = NULL;
         }
      }
   else if ( next )
      {
      // If we were the teammaster, then the nodes that were not bound to me are now
      // a disconnected chain.  Make them into their own team.
		for( ent = next; ent->bind_info->teamchain != NULL; ent = ent->bind_info->teamchain )
         {
         ent->bind_info->teammaster = next;
			}
      next->bind_info->teammaster = next;
	   next->flags &= ~FL_TEAMSLAVE;
      }

   // If we don't have anyone on our team, then clear the team variables.
   if ( bind_info->teamchain )
      {
      // make myself my own team
      bind_info->teammaster = this;
      }
   else
      {
      // no longer a team
      bind_info->teammaster = NULL;
      }

	flags &= ~FL_TEAMSLAVE;
   bind_info->bindmaster = NULL;
	edict->s.bindparent = ENTITYNUM_NONE;
	}

void Entity::EventUnbind
	(
	Event *ev
	)

	{
	unbind();
	}

void Entity::BindEvent
	(
	Event *ev
	)

	{
	Entity *ent;

	ent = ev->GetEntity( 1 );
	if ( ent )
		{
		bind( ent );
		}
	}


Vector Entity::getParentVector
	(
	const Vector &vec
	)

	{
	Vector pos;

	if ( !bind_info || !bind_info->bindmaster )
		{
		return vec;
		}

	pos[ 0 ] = vec * bind_info->bindmaster->orientation[ 0 ];
	pos[ 1 ] = vec * bind_info->bindmaster->orientation[ 1 ];
	pos[ 2 ] = vec * bind_info->bindmaster->orientation[ 2 ];

	return pos;
	}

//
// Team methods
//

void Entity::joinTeam
	(
	Entity *teammember
	)

	{
	Entity *ent;
   Entity *master;
   Entity *prev;
   Entity *next;

	if ( !bind_info )
		bind_info = CreateBindInfo();

	if ( bind_info->teammaster && ( bind_info->teammaster != this ) )
		{
		quitTeam();
		}

	assert( teammember );
	if ( !teammember )
		{
		warning( "joinTeam", "Null entity" );
		return;
		}

	if ( !teammember->bind_info )
		teammember->bind_info = CreateBindInfo();

	master = teammember->bind_info->teammaster;
	if ( !master )
		{
		master = teammember;
		teammember->bind_info->teammaster = teammember;
      teammember->bind_info->teamchain = this;

      // make anyone who's bound to me part of the new team
      for( ent = bind_info->teamchain; ent != NULL; ent = ent->bind_info->teamchain )
         {
         ent->bind_info->teammaster = master;
         }
      }
   else
      {
      // skip past the chain members bound to the entity we're teaming up with
      prev = teammember;
	   next = teammember->bind_info->teamchain;
      if ( bind_info->bindmaster )
         {
         // if we have a bindmaster, joing after any entities bound to the entity
         // we're joining
	      while( next && (( Entity *)next)->isBoundTo( teammember ) )
		      {
            prev = next;
		      next = next->bind_info->teamchain;
		      }
         }
      else
         {
         // if we're not bound to someone, then put us at the end of the team
	      while( next )
		      {
            prev = next;
		      next = next->bind_info->teamchain;
		      }
         }

      // make anyone who's bound to me part of the new team and
      // also find the last member of my team
      for( ent = this; ent->bind_info->teamchain != NULL; ent = ent->bind_info->teamchain )
         {
         ent->bind_info->teamchain->bind_info->teammaster = master;
         }

    	prev->bind_info->teamchain = this;
      ent->bind_info->teamchain = next;
      }

   bind_info->teammaster = master;
	flags |= FL_TEAMSLAVE;
	}

void Entity::quitTeam
	(
	void
	)

	{
	Entity *ent;

	if ( !bind_info || !bind_info->teammaster )
		{
		return;
		}

	if ( bind_info->teammaster == this )
		{
      if ( !bind_info->teamchain->bind_info->teamchain )
         {
         bind_info->teamchain->bind_info->teammaster = NULL;
         }
      else
         {
		   // make next teammate the teammaster
		   for( ent = bind_info->teamchain; ent; ent = ent->bind_info->teamchain )
			   {
			   ent->bind_info->teammaster = bind_info->teamchain;
			   }
         }

      bind_info->teamchain->flags &= ~FL_TEAMSLAVE;
		}
	else
		{
		assert( flags & FL_TEAMSLAVE );
		assert( bind_info->teammaster->bind_info->teamchain );

		ent = bind_info->teammaster;
		while( ent->bind_info->teamchain != this )
			{
			// this should never happen
			assert( ent->bind_info->teamchain );

			ent = ent->bind_info->teamchain;
			}

		ent->bind_info->teamchain = bind_info->teamchain;

		if ( !bind_info->teammaster->bind_info->teamchain )
			{
			bind_info->teammaster->bind_info->teammaster = NULL;
			}
		}

	bind_info->teammaster = NULL;
	bind_info->teamchain = NULL;
	flags &= ~FL_TEAMSLAVE;
	}

void Entity::EventQuitTeam
	(
	Event *ev
	)

	{
	quitTeam();
	}


void Entity::JoinTeam
	(
	Event *ev
	)

	{
	Entity *ent;

	ent = ev->GetEntity( 1 );
	if ( ent )
		{
		joinTeam( ent );
		}
	}

void Entity::AddToSoundManager
	(
	Event *ev
	)

	{
   SoundMan.AddEntity( this );
	}

inline qboolean Entity::HitSky
	(
	const trace_t *trace
	)

	{
	assert( trace );
   if ( trace->surfaceFlags & SURF_SKY )
		{
		return true;
		}
	return false;
	}

qboolean Entity::HitSky
	(
	void
	)

	{
	return HitSky( &level.impact_trace );
	}

void Entity::SetAngleEvent
	(
	Event *ev
	)
	{
   Vector movedir;

   movedir = G_GetMovedir( ev->GetFloat( 1 ) );
	setAngles( movedir.toAngles() );
   }

void Entity::NoLerpThisFrame( void )
{
	gentity_t *checkEdict;

	edict->s.eFlags ^= EF_TELEPORT_BIT;

	// Make sure no one is standing on us

	for( checkEdict = active_edicts.next ; checkEdict != &active_edicts ; checkEdict = checkEdict->next )
	{
		assert( checkEdict );
		assert( checkEdict->inuse );
		
		if ( checkEdict->entity && checkEdict->entity->groundentity == edict )
		{
			checkEdict->entity->groundentity = NULL;
		}
	}
}

void Entity::Postthink
	(
	void
	)

	{
	}


//-----------------------------------------------------
//
// Name:		TouchTriggersEvent
// Class:		Entity
//
// Description:	Specifies the entity can touch triggers by setting
//				the touch triggers flag.
//
// Parameters:	ev - the event that specifies whether to turn
//				touch triggers on or off. If no param is specified, 
//				touchtriggers is true.
//
// Returns:		None
//-----------------------------------------------------
void Entity::TouchTriggersEvent(Event *ev)
{
	if ( ( ev->NumArgs() == 0 ) || ( ev->GetBoolean( 1 ) == true ) )
	{
		flags |= FL_TOUCH_TRIGGERS;
		turnThinkOn();
	}
	else
	{
		flags &= ~FL_TOUCH_TRIGGERS;
	}

}

void Entity::IncreaseShotCount 
   (
	Event *ev
	)
	{
	int parent_ent_num = edict->s.parent;
	Entity *parent = ( Entity * )G_GetEntity( parent_ent_num );

	if ( !parent->isSubclassOf(Actor) )
		return;
   
	Actor* act;
	act = (Actor*)parent;

	act->shotsFired++;	
	}

void Entity::DeathSinkStart
	(
	Event *ev
	)
	{
	float time;

	// Stop the sink when we can't be seen anymore

	if ( ( maxs[2] >= 0.0f ) && ( maxs[2] < 200.0f ) )
		time = maxs[2] / 20.0f;
	else
		time = 1.0f;

	PostEvent( EV_Remove, time );

	// Start the sinking

	ProcessEvent( EV_DeathSink );
	}

void Entity::DeathSink
	(
	Event *ev
	)
	{
	// Sink just a little

	origin[2] -= 1.0f;
	setOrigin( origin );

	// Make sure the sink happens again next frame

	PostEvent( EV_DeathSink, FRAMETIME );
	}

void Entity::LookAtMe
	(
	Event *ev
	)
	{
	if ( ev->NumArgs() > 0 )
		look_at_me = ev->GetBoolean( 1 );
	else
		look_at_me = true;
	}

void Entity::ProjectilesCanStickToMe( Event *ev )
{
	projectilesCanStickToMe = ev->GetBoolean( 1 );
}

void Entity::VelocityModified
	(
   void
	)
	{
	}

//--------------------------------------------------------------
//
// Name:			DetachAllChildren
// Class:			Entity
//
// Description:		Detaches all attached models to this entity
//
// Parameters:		Event *ev
//
// Returns:			None
//
//--------------------------------------------------------------
void Entity::DetachAllChildren(Event *ev)
	{
	if ( !bind_info ) // Abort if bind_info is NULL for some reason
		return;

	for ( int i=0; i<MAX_MODEL_CHILDREN; i++)
		{
		if ( bind_info->children[i] == ENTITYNUM_NONE )
			continue;

		Entity *ent = ( Entity * )G_GetEntity( bind_info->children[i] );
		if ( ent )
			ent->PostEvent( EV_Remove, 0.0f );
		}
	}

inline void Entity::Archive( Archiver &arc )
{
	int tempInt;
	qboolean is_archived;
	qboolean true_bool = true;
	qboolean false_bool = false;


	Listener::Archive( arc );

	arc.ArchiveVector( &_localOrigin );

	_lastTouchedList.Archive( arc );

	arc.ArchiveBool( &_fulltrace );
	arc.ArchiveInteger( &_groupID );

	// Don't archive entnum, it will be set elsewhere
	//int					entnum;

	G_ArchiveEdict( arc, edict );

	arc.ArchiveString(&_archetype);
	if(arc.Loading())
	{
		edict->s.archeTypeIndex = gi.archetypeindex(_archetype);
	}

	arc.ArchiveBool( &_missionObjective );
	arc.ArchiveString( &_targetPos );
	arc.ArchiveBool( &_networkDetail );

	if(arc.Loading())
	{
		edict->s.missionObjective = _missionObjective;
		if(_missionObjective == true)
			G_AddEntityToExtraList(entnum);
	}

	// Don't archive client
	//gclient_t			*client;

	arc.ArchiveInteger( &spawnflags );

	arc.ArchiveString( &model );

	if ( arc.Loading() && model.length() )
      setModel( model.c_str() );

	arc.ArchiveVector( &total_delta );
	arc.ArchiveVector( &mins );
	arc.ArchiveVector( &maxs );
	arc.ArchiveVector( &absmin );
	arc.ArchiveVector( &absmax );
	arc.ArchiveVector( &centroid );
	arc.ArchiveVector( &velocity );
	arc.ArchiveVector( &avelocity );
	arc.ArchiveVector( &origin );
	arc.ArchiveVector( &angles );
	arc.ArchiveVector( &size );
	arc.ArchiveInteger( &movetype );
	arc.ArchiveInteger( &mass );
	arc.ArchiveFloat( &gravity );
	arc.ArchiveRaw( orientation, sizeof( orientation ) );

	arc.ArchiveVector( &localangles );

	if ( arc.Saving() )
	{
		if ( groundentity )
		{
			tempInt = groundentity - g_entities;
		}
		else
		{
			tempInt = -1;
		}
	}

	arc.ArchiveInteger( &tempInt );

	if ( arc.Loading() )
	{
		if ( tempInt == -1 )
		{
			groundentity = NULL;
		}
		else
		{
		groundentity = &g_entities[ tempInt ];
		}
	}

	arc.ArchiveRaw( &groundplane, sizeof( groundplane ) );
	arc.ArchiveInteger( &groundcontents );

	arc.ArchiveInteger( &numsurfaces );

	arc.ArchiveFloat( &lightRadius );

	arc.ArchiveString( &target );
	arc.ArchiveString( &targetname );
	arc.ArchiveString( &killtarget );

	if ( arc.Loading() )
	{
		// Don't set this here, they are handled in the world
		//SetTargetName( targetname.c_str() );

		// Not needed
		//SetTarget( target.c_str() );
	}

	arc.ArchiveFloat( &health );
	arc.ArchiveFloat( &max_health );
	arc.ArchiveInteger( &deadflag );
	arc.ArchiveInteger( &flags );

	arc.ArchiveInteger( &watertype );
	arc.ArchiveInteger( &waterlevel );

	ArchiveEnum( takedamage, damage_t );
	arc.ArchiveInteger( &damage_type );

	arc.ArchiveBoolean( &look_at_me );
	arc.ArchiveBool( &projectilesCanStickToMe );

	arc.ArchiveString( &explosionModel );

	entityVars.Archive( arc );

	arc.ArchiveUnsigned( &_affectingViewModes );

	arc.ArchiveVector( &watch_offset );

	//  Pluggable modules

	if ( arc.Loading() )
	{
		arc.ArchiveBoolean( &is_archived );

		if ( is_archived )
		{
			animate = new Animate( this );
			arc.ArchiveObject( animate );
		}

		arc.ArchiveBoolean( &is_archived );

		if ( is_archived )
		{
			mover = new Mover( this );
			arc.ArchiveObject( mover );
		}

		arc.ArchiveBoolean( &is_archived );

		if ( is_archived )
		{
			bind_info = CreateBindInfo();
			bind_info->Archive( arc );
		}

		arc.ArchiveBoolean( &is_archived );

		if ( is_archived )
		{
			morph_info = CreateMorphInfo();
			morph_info->Archive( arc );
		}
	}
	else
	{
		if ( animate )
		{
			arc.ArchiveBoolean( &true_bool );
			arc.ArchiveObject( animate );
		}
		else
		{
			arc.ArchiveBoolean( &false_bool );
		}

		if ( mover )
		{
			arc.ArchiveBoolean( &true_bool );
			arc.ArchiveObject( mover );
		}
		else
		{
			arc.ArchiveBoolean( &false_bool );
		}

		if ( bind_info )
		{
			arc.ArchiveBoolean( &true_bool );
			bind_info->Archive( arc );
		}
		else
		{
			arc.ArchiveBoolean( &false_bool );
		}

		if ( morph_info )
		{
			arc.ArchiveBoolean( &true_bool );
			morph_info->Archive( arc );
		}
		else
		{
			arc.ArchiveBoolean( &false_bool );
		}
	}

	if ( arc.Saving() )
	{
		if ( ObjectProgram )
		{
			arc.ArchiveBoolean( &true_bool );
			ObjectProgram->Archive( arc );
		}
		else
		{
			arc.ArchiveBoolean( &false_bool );
		}
	}
	else
	{
		arc.ArchiveBoolean( &is_archived );

		if ( is_archived )
			ObjectProgram->Archive( arc );
		else
			ObjectProgram = NULL;
	}

	// Archiving of the Damage Modification System
	if ( arc.Saving() )
		{
		bool exists;
		int type;
		if ( damageModSystem )
			{
			exists = true;
			arc.ArchiveBool( &exists );

			int numobj = damageModSystem->getModifierList().NumObjects();
			arc.ArchiveInteger( &numobj );
			for ( tempInt = 1; tempInt <= numobj; tempInt++ )
				{
				DamageModifier *dmod = damageModSystem->getModifierList().ObjectAt ( tempInt );
				if ( dmod )
					{
					type = (int)dmod->getType();
					arc.ArchiveInteger( &type );
					dmod->Archive(arc);
					}
				else
					{
					// How did a NULL get in the container??
					assert( 0 );
					}
				}
			}
		else
			{
			exists = false;
			arc.ArchiveBool( &exists );
			}
		}
	else // Loading
	{
		bool exists;
		int numobj, type;
		arc.ArchiveBool( &exists );
		if ( exists )
		{
			damageModSystem = new DamageModificationSystem();
			arc.ArchiveInteger( &numobj );
			for ( tempInt = 1; tempInt <= numobj; tempInt++ )
			{
				arc.ArchiveInteger( &type );
				DamageModifier *newMod = 0;
				switch ( type )
				{
					case TIKI_NAME:
						newMod = new DamageModifierTikiName();
						break;
					case NAME:
						newMod = new DamageModifierName();
						break;
					case GROUP:
						newMod = new DamageModifierGroup();
						break;
					case ACTOR_TYPE:
						newMod = new DamageModifierActorType();
						break;
					case TARGETNAME:
						newMod = new DamageModifierTargetName();
						break;
					case DAMAGE_TYPE:
						newMod = new DamageModifierDamageType();
						break;
				}

				if ( newMod )
				{
					newMod->Archive(arc);

					damageModSystem->addDamageModifier( newMod );
				}
			}
		}
	}

	// Archive the useData member if it exists
	if ( arc.Saving() )
		{
		bool exists = false;
		if ( useData )
			{
			exists = true;
			arc.ArchiveBool( &exists );
			useData->Archive(arc);
			}
		else
			arc.ArchiveBool( &exists );
		}
	else // Loading
		{
		bool exists;
		arc.ArchiveBool( &exists );
		if ( exists )
			{
			useData = new UseData();
			useData->Archive(arc);
			}
		}


	
}

// Animate interface

inline int Entity::CurrentFrame
	(
   bodypart_t part
	)

	{
	if ( animate )
		return animate->CurrentFrame( part );
	else
		return 0;
	}

inline int Entity::CurrentAnim
	(
   bodypart_t part
	)

	{
	if ( animate )
		return animate->CurrentAnim( part );
	else
		return 0;
	}

void Entity::PassToAnimate
	(
	Event *ev
	)

	{
	Event *new_event;

	if ( !animate )
		animate = new Animate( this );

	new_event = new Event( ev );
	animate->ProcessEvent( new_event );
	}

void Entity::SetObjectProgram
   (
	Event *ev
	)
	{
	ObjectProgram = new Program;
	
	if ( !ObjectProgram )
		return;

	ObjectProgram->Load( ev->GetString( 1 )  );


	//CThread *gamescript = 0;

	//gamescript = Director.CreateThread( "obj_main" , ObjectProgram );
	//gamescript->DelayedStart( 0 );

	}

void Entity::SetWatchOffset( Event *ev )
{
	watch_offset = ev->GetVector( 1 );
}


void Entity::ExecuteProgram
   (
	Event *ev
	)
	{
	float exeTime = 0;
	
	if ( !ObjectProgram )
		return;

	if ( ev->NumArgs() > 0 )
		exeTime = ev->GetFloat( 1 );

	CThread *gamescript = 0;
	gamescript = Director.CreateThread( "obj_main" , ObjectProgram );
	gamescript->DelayedStart( exeTime );
	}


// BindInfo interface

inline BindInfo *CreateBindInfo( void )
	{
	BindInfo *new_bind_info;

	new_bind_info = new BindInfo;

	if ( !new_bind_info )
		gi.Error( ERR_DROP, "Couldn't alloc BindInfo" );

	return new_bind_info;
	}

// MorphInfo interface

void Entity::MorphEvent
	(
	Event *ev
	)
	{
	str	morph_target_name;
	int	morph_index;
	float	final_percent = 100;
	float	morph_time = 0.5;
	qboolean return_to_zero = false;
	int i;
	qboolean override = true;
	int morph_channel = MORPH_CHAN_NONE;
	qboolean channel_being_used;
	qboolean override_all = false;
	qboolean matching_channel;
	qboolean unmorph = false;

	// Get parms

	morph_target_name = ev->GetString( 1 );

	if ( ev->NumArgs() > 1 )
		final_percent = ev->GetFloat( 2 );
	if ( ev->NumArgs() > 2 )
		morph_time = ev->GetFloat( 3 );
	if ( ev->NumArgs() > 3 )
		return_to_zero = ev->GetBoolean( 4 );
	if ( ev->NumArgs() > 4 )
		override = ev->GetBoolean( 5 );
	if ( ev->NumArgs() > 5 )
		morph_channel = ev->GetInteger( 6 );

	// See if this is an expression

	if ( strnicmp( morph_target_name.c_str(), "exp_", 4 ) == 0 )
		{
		// Process this expression

		dtikimorphtarget_t *morph_targets;
		Event *new_event;
		const char *morph_name;
		int number_of_morph_targets;

		morph_targets = gi.GetExpression( edict->s.modelindex, morph_target_name.c_str(), &number_of_morph_targets );

		if ( morph_targets )
			{
			for ( i = 0 ; i < number_of_morph_targets ; i++ )
				{
				morph_name = gi.Morph_NameForNum( edict->s.modelindex, morph_targets[ i ].morph_index );

				if ( morph_name )
					{
					new_event = new Event( EV_Morph );
					new_event->AddString( morph_name );
					new_event->AddFloat( morph_targets[ i ].percent );
					new_event->AddFloat( morph_time );
					new_event->AddInteger( return_to_zero );
					new_event->AddInteger( override );
					new_event->AddInteger( morph_channel );
					ProcessEvent( new_event );
					}
				}

			return;
			}
		}

	// Find this morph target

	morph_index = gi.Morph_NumForName( edict->s.modelindex, morph_target_name.c_str() );

	// Check unmorphing stuff

	if ( ( stricmp( morph_target_name.c_str(), "morph_base" ) == 0 ) || 
		  ( stricmp( morph_target_name.c_str(), "morph_mouth_base" ) == 0 ) || 
		  ( stricmp( morph_target_name.c_str(), "morph_brows_base" ) == 0 ) || 
		  ( stricmp( morph_target_name.c_str(), "morph_eyes_base" ) == 0 ) )
		unmorph = true;

	if ( morph_index == -1 && !unmorph )
		return;

	if ( morph_channel == MORPH_CHAN_NONE )
		morph_channel = GetMorphChannel( morph_target_name.c_str() );

	// Make sure we have a morph controller block

	if ( !morph_info )
		morph_info = CreateMorphInfo();

	// Deal with current morphs

	channel_being_used = false;

	if ( unmorph && ( morph_channel == MORPH_CHAN_NONE ) )
		override_all = true;

	for( i = 0 ; i < NUM_MORPH_CONTROLLERS ; i++ )
		{
		if ( morph_info->controllers[ i ].index != -1 )
			{
			// See if this is a matching channel

			if ( MorphChannelMatches( morph_channel, morph_info->controllers[ i ].channel ) )
				matching_channel = true;
			else 
				matching_channel = false;

			if ( override_all || ( matching_channel && override ) )
				{
				if ( morph_info->controllers[ i ].final_percent != 0 )
				{
					// Override this morph

					morph_info->controllers[ i ].speed = ( morph_info->controllers[ i ].current_percent * FRAMETIME ) / morph_time;
					morph_info->controllers[ i ].final_percent = 0;

					StartMorphController();
				}
				}
			else if ( matching_channel )
				{
				channel_being_used = true;
				}
			}
		}

	// If just unmorphing stuff, stop here

	if ( unmorph )
		return;

	// If not overriding and the channel is already being used, stop here

	if ( !override && channel_being_used )
		return;

	// Find a free morph controller & add this morph

	for( i = 0 ; i < NUM_MORPH_CONTROLLERS ; i++ )
		{
		if ( morph_info->controllers[ i ].index == -1 )
			{
			morph_info->controllers[ i ].index           = morph_index;
			morph_info->controllers[ i ].current_percent = 0;
			morph_info->controllers[ i ].final_percent   = final_percent;
			morph_info->controllers[ i ].speed           = (final_percent * FRAMETIME ) / morph_time;
			morph_info->controllers[ i ].return_to_zero  = return_to_zero;
			morph_info->controllers[ i ].channel         = morph_channel;

			StartMorphController();

			break;
			}
		}
	}

void Entity::UnmorphEvent
	(
	Event *ev
	)
	{
	str	morph_target_name;
	int	morph_index;
	int	i;
	float morph_time = 0.5;

	morph_target_name = ev->GetString( 1 );

	if ( ev->NumArgs() > 2 )
		morph_time = ev->GetFloat( 3 );

	// See if this is an expression

	if ( strnicmp( morph_target_name.c_str(), "exp_", 4 ) == 0 )
		{
		// Process this expression

		dtikimorphtarget_t *morph_targets;
		Event *new_event;
		const char *morph_name;
		int number_of_morph_targets;

		morph_targets = gi.GetExpression( edict->s.modelindex, morph_target_name.c_str(), &number_of_morph_targets );

		if ( morph_targets )
			{
			for ( i = 0 ; i < number_of_morph_targets ; i++ )
				{
				morph_name = gi.Morph_NameForNum( edict->s.modelindex, morph_targets[ i ].morph_index );

				if ( morph_name )
					{
					new_event = new Event( EV_Unmorph );
					new_event->AddString( morph_name );
					new_event->AddFloat( morph_time );
					ProcessEvent( new_event );
					}
				}

			return;
			}
		}

	morph_index = gi.Morph_NumForName( edict->s.modelindex, morph_target_name.c_str() );

	if ( morph_index == -1 || !morph_info )
		return;

	// Find this morph controller

	for( i = 0 ; i < NUM_MORPH_CONTROLLERS ; i++ )
		{
		if ( ( morph_info->controllers[ i ].index == morph_index ) && ( morph_info->controllers[ i ].final_percent != 0 ) )
			{
			morph_info->controllers[ i ].speed = (morph_info->controllers[ i ].final_percent * FRAMETIME ) / morph_time;
			morph_info->controllers[ i ].final_percent = 0.0f;

			StartMorphController();

			break;
			}
		}
	}

void Entity::MorphControl
	(
	Event *ev
	)
	{
	int i;
	qboolean process_next_frame = false;
	morph_t *controller;

	for( i = 0 ; i < NUM_MORPH_CONTROLLERS ; i++ )
		{
		controller = &morph_info->controllers[ i ];

		if ( controller->index != -1 )
			{
			// Lerp the morph percent

			if ( controller->current_percent != controller->final_percent )
				{
				if ( controller->current_percent < controller->final_percent )
					{
					controller->current_percent += controller->speed;

					if ( controller->current_percent > controller->final_percent )
						controller->current_percent = controller->final_percent;
					}
				else
					{
					controller->current_percent -= controller->speed;

					if ( controller->current_percent < controller->final_percent )
						controller->current_percent = controller->final_percent;
					}
				}

			if ( controller->current_percent == 0.0f )
				{
				controller->index = -1;
				controller->current_percent = 0.0f;
				}

			// Return to zero if necessary

			if ( controller->current_percent == controller->final_percent && controller->return_to_zero )
				controller->final_percent = 0.0f;

			if ( controller->current_percent != controller->final_percent )
				process_next_frame = true;
			}

		// Copy to edict

		edict->s.morph_controllers[ i ].index   = controller->index;
		edict->s.morph_controllers[ i ].percent = controller->current_percent / 100.0f;
		}

	if ( process_next_frame )
		PostEvent( EV_MorphControl, FRAMETIME );
	else
		morph_info->controller_on = false;
	}

int Entity::GetMorphChannel
	(
	const char *morph_name
	)
	{
	int morph_channel;

	if ( stricmp( morph_name, "morph_a-i" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;
	else if ( stricmp( morph_name, "morph_c-t" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;
	else if ( stricmp( morph_name, "morph_e" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;
	else if ( stricmp( morph_name, "morph_f-v" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;
	else if ( stricmp( morph_name, "morph_l-th" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;
	else if ( stricmp( morph_name, "morph_m-b-p" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;
	else if ( stricmp( morph_name, "morph_o" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;
	else if ( stricmp( morph_name, "morph_q-w" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;
	else if ( stricmp( morph_name, "morph_u" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;
	else if ( stricmp( morph_name, "morph_frown" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;
	else if ( stricmp( morph_name, "morph_sneer-l" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;
	else if ( stricmp( morph_name, "morph_sneer-r" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;
	else if ( stricmp( morph_name, "morph_mouth_base" ) == 0 )
		morph_channel = MORPH_CHAN_MOUTH;

	else if ( stricmp( morph_name, "morph_brows-up" ) == 0 )
		morph_channel = MORPH_CHAN_BROW;
	else if ( stricmp( morph_name, "morph_brows_base" ) == 0 )
		morph_channel = MORPH_CHAN_BROW;

	else if ( stricmp( morph_name, "morph_brow-ldn" ) == 0 )
		morph_channel = MORPH_CHAN_LEFT_BROW;

	else if ( stricmp( morph_name, "morph_brow-rdn" ) == 0 )
		morph_channel = MORPH_CHAN_RIGHT_BROW;

	else if ( stricmp( morph_name, "morph_lid-lshut" ) == 0 )
		morph_channel = MORPH_CHAN_LEFT_LID;

	else if ( stricmp( morph_name, "morph_lid-rshut" ) == 0 )
		morph_channel = MORPH_CHAN_RIGHT_LID;

	else if ( stricmp( morph_name, "morph_eyeshut" ) == 0 )
		morph_channel = MORPH_CHAN_EYES;
	else if ( stricmp( morph_name, "morph_eyes_base" ) == 0 )
		morph_channel = MORPH_CHAN_EYES;

	else 
		morph_channel = MORPH_CHAN_NONE;

	return morph_channel;
	}

void Entity::StartMorphController
	(
	void
	)
	{
	if ( !morph_info->controller_on )
		{
		morph_info->controller_on = true;
		CancelEventsOfType( EV_MorphControl );
		PostEvent( EV_MorphControl, FRAMETIME );
		}
	}


void Entity::SetAnimOnAttachedModel
   (
	const str &AnimName,
	const str &TagName
	)

	{
	int tag_num = gi.Tag_NumForName( this->edict->s.modelindex , TagName.c_str() );

	if ( bind_info )
		{
		Entity *attachment = 0;

		for ( int i = 0; i < MAX_MODEL_CHILDREN; i++ )
			{
			
			//Check for valid entities
         if( bind_info->children[i] == ENTITYNUM_NONE )
				continue;

			attachment = ( Entity * )G_GetEntity( bind_info->children[i] );
			
			if ( attachment->edict->s.tag_num == tag_num )
				{
				if ( !attachment->animate )
					{
					attachment->animate = new Animate;
					}
				
				int anim_num = gi.Anim_Random ( attachment->edict->s.modelindex, AnimName.c_str() );
				if ( anim_num != -1 )
					{
					attachment->animate->NewAnim( anim_num );
					}
				}
			}
		}
	}

void Entity::SetAnimOnAttachedModel
   (
	Event *ev
	)
	{
	str attachmentAnim = ev->GetString( 1 );
	str TagName = ev->GetString( 2 );

	SetAnimOnAttachedModel( attachmentAnim , TagName );	
	}


void Entity::SetCinematicAnim
	(
	const str &AnimName
	)
	{
	if (!animate)
		{
		animate = new Animate( this );
		}
				
	int anim_num = gi.Anim_Random ( edict->s.modelindex, AnimName.c_str() );
	if ( anim_num != -1 )
		{
		animate->NewAnim( anim_num );
		animate->SetAnimDoneEvent( new Event (EV_CinematicAnimDone) );
		}

	gravity = 0.0f;
	edict->contents = CONTENTS_SETCLIP ;
	edict->clipmask = MASK_SETCLIP ;
	}


void Entity::SetCinematicAnim
   (
	Event *ev
	)
	{
	str animName = ev->GetString( 1 );
	SetCinematicAnim( animName);	
	}


void Entity::CinematicAnimDone
	( 
	void 
	)
	{
	gravity = 1.0f ;
	edict->contents &= ~CONTENTS_SETCLIP ;
	edict->clipmask = MASK_SOLID ;
	}

void Entity::CinematicAnimDone
	(
	Event *ev
	)
	{
	CinematicAnimDone();
	}


void Entity::SetEntityExplosionModel
   (
	Event *ev
	)
	{
	explosionModel = ev->GetString( 1 );
	}

//----------------------------------------------------------------
// Name:			ProjectileAtk
// Class:			Entity
//
// Description:		launches a projectile either from the player 
//					or from a tag
//
// Parameters:		event ev contains projectile name and an
//					optional tag name
//
// Returns:			None
//----------------------------------------------------------------
void Entity::ProjectileAtk( Event *ev )
{
	str projectileName = ev->GetString( 1 );
	
	Vector position;
	Vector direction;
	
	if ( ev->NumArgs() > 1 )
	{
		// Projectile name, tagName
		str tagName( ev->GetString( 2 ) );
		GetTag( tagName.c_str(), &position, &direction );
	}
	else
	{
		// Projectile name, Player is the target
		position = origin;
		gentity_t *ed;
		Entity* enemy = NULL;
		for( int i = 0 ; i < game.maxclients; i++ )
		{
			ed = &g_entities[ i ];
			
			if ( !ed->inuse || !ed->entity )
				continue;
			
			enemy = ed->entity;
		}
		if ( enemy )
		{
			direction = enemy->origin - origin;
			direction.normalize();
		}
		else
		{
			angles.AngleVectors( &direction, NULL, NULL );
		}
	}
	
	ProjectileAttack( position, direction, this, projectileName.c_str(), 1.0f, 0.0f );
}

//----------------------------------------------------------------
// Name:			ProjectileAttackPoint
// Class:			Entity
//
// Description:		launches a projectile towards the given point
//
// Parameters:		event ev contains projectile name and entity name
//
// Returns:			None
//----------------------------------------------------------------
void Entity::ProjectileAttackPoint( Event *ev )
{
	const str projectileName( ev->GetString( 1 ) );
	const Vector targetPosition( ev->GetVector( 2 ) );
	
	Vector direction( targetPosition - origin );
	direction.normalize();
	Projectile *projectile = ProjectileAttack( origin, direction, this, projectileName.c_str(), 1.0f, 0.0f );
	if ( ev->NumArgs() > 2 )
	{
		Angle launchAngle( ev->GetFloat( 3 ) );
		Trajectory trajectory( origin, targetPosition, launchAngle, projectile->gravity * sv_currentGravity->value );

		projectile->velocity = trajectory.GetInitialVelocity();
		Vector launchDirection( projectile->velocity );
		launchDirection.normalize();
		projectile->angles = launchDirection.toAngles();
		
		projectile->CancelEventsOfType( EV_Projectile_Explode );
		Event *event = new Event( EV_Projectile_Explode );
		if ( ev->NumArgs() > 3 )
		{
			projectile->PostEvent( event, ev->GetFloat( 4 ) );
		}
		else
		{
			projectile->PostEvent( event, trajectory.GetTravelTime() );
		}
	}
}

//----------------------------------------------------------------
// Name:			ProjectileAttackEntity
// Class:			Entity
//
// Description:		launches a projectile either from the named entity
//
// Parameters:		event ev contains projectile name and entity name
//
// Returns:			None
//----------------------------------------------------------------
void Entity::ProjectileAttackEntity( Event *ev )
{
	const str projectileName( ev->GetString( 1 ) );
	
	Entity *target = ev->GetEntity( 2 );
	if ( target )
	{
		Vector direction( target->origin - origin );
		direction.normalize();
		Projectile *projectile = ProjectileAttack( origin, direction, this, projectileName.c_str(), 1.0f, 0.0f );

		if ( !projectile )
			return;

		if ( ev->NumArgs() > 2 )
		{
			Angle launchAngle( ev->GetFloat( 3 ) );
			Trajectory trajectory( origin, target->centroid, launchAngle, projectile->gravity * -sv_currentGravity->value );

			projectile->velocity = trajectory.GetInitialVelocity();
			Vector launchDirection( projectile->velocity );
			launchDirection.normalize();
			projectile->angles = launchDirection.toAngles();
			
			projectile->CancelEventsOfType( EV_Projectile_Explode );
			Event *event = new Event( EV_Projectile_Explode );
			if ( ev->NumArgs() > 3 )
			{
				projectile->PostEvent( event, ev->GetFloat( 4 ) );
			}
			else
			{
				projectile->PostEvent( event, trajectory.GetTravelTime() );
			}
		}
	}
}

//----------------------------------------------------------------
// Name:			ProjectileAttackFromTag
// Class:			Entity
//
// Description:		launches a projectile either from the named tag
//
// Parameters:		event ev contains projectile name and tag name
//
// Returns:			None
//----------------------------------------------------------------
void Entity::ProjectileAttackFromTag( Event *ev )
{
	str projectileName( ev->GetString( 1 ) );
	str tagName( ev->GetString( 2 ) );
	
	Vector position;
	Vector direction;
	GetTag( tagName.c_str(), &position, &direction );
	
	float speed = 0.0f;
	if ( ev->NumArgs() > 3 )
	{
		speed = ev->GetFloat( 4 );
	}

	Projectile *projectile = ProjectileAttack( position, direction, this, projectileName.c_str(), 1.0f, speed );
	if ( ev->NumArgs() > 4 )
	{
		projectile->CancelEventsOfType( EV_Projectile_Explode );
		Event *event = new Event( EV_Projectile_Explode );
		projectile->PostEvent( event, ev->GetFloat( 5 ) );
	}
}

//----------------------------------------------------------------
// Name:			ProjectileAttackFromPoint
// Class:			Entity
//
// Description:		launches a projectile either from the desired
//					location facing the desired direction
//
// Parameters:		event ev contains projectile name, the 
//					position and direction for the new projectile
//
// Returns:			None
//----------------------------------------------------------------
void Entity::ProjectileAttackFromPoint( Event *ev )
{
	str projectileName( ev->GetString( 1 ) );

	Vector position( ev->GetVector( 2 ) );
	Vector direction( ev->GetVector( 3 ) );

	float speed = 0.0f;
	if ( ev->NumArgs() > 3 )
	{
		speed = ev->GetFloat( 4 );
	}

	Vector forward;
	direction.AngleVectors( &forward );
	Projectile *projectile = ProjectileAttack( origin + position, forward, this, projectileName.c_str(), 1.0f, speed );
	if ( ev->NumArgs() > 4 )
	{
		projectile->CancelEventsOfType( EV_Projectile_Explode );
		Event *event = new Event( EV_Projectile_Explode );
		projectile->PostEvent( event, ev->GetFloat( 5 ) );
	}
}

void Entity::TraceAtk
   (
	Event *ev
	)
	{
	Vector position;
	Vector forward;
	Vector right;
	Vector up;
	float range;
	float damage;
	float knockback = 0.0;
	str means_of_death_string = "bullet";
	int means_of_death;
	//int offsetPitch = 0;

	damage = ev->GetFloat( 1 );
	range  = ev->GetFloat( 2 );

	if ( ev->NumArgs() > 2 )
		means_of_death_string = ev->GetString( 3 );

	if ( ev->NumArgs() > 3 )
		knockback = ev->GetFloat( 4 );

	if ( ev->NumArgs() > 4 )
		{
		str tag_name;

		tag_name = ev->GetString( 5 );

		GetTag( tag_name.c_str(), &position, &forward, &right, &up );
		}
	else
		{
		position = origin;
		angles.AngleVectors( &forward, &right, &up );
		}

	means_of_death = MOD_NameToNum( means_of_death_string );
	
	/*
	if ( ev->NumArgs() > 5 )
		offsetPitch = ev->GetInteger( 6 );

	if ( offsetPitch )
		{
		Vector ForAngles;
		ForAngles = forward.toAngles();

		ForAngles[YAW] = AngleNormalize180( ForAngles[YAW] );
		ForAngles[PITCH] = AngleNormalize180( ForAngles[PITCH] );
		ForAngles[ROLL] = AngleNormalize180( ForAngles[ROLL] );
		offsetPitch = AngleNormalize180(offsetPitch);

		ForAngles[PITCH] += offsetPitch;


		ForAngles[YAW] = AngleNormalize360( ForAngles[YAW] );
		ForAngles[PITCH] = AngleNormalize360( ForAngles[PITCH] );
		ForAngles[ROLL] = AngleNormalize360( ForAngles[ROLL] );

		ForAngles.AngleVectors( &forward );
		}
   */

	BulletAttack( position, forward, right, up, range, damage, knockback, 0, means_of_death, vec_zero, 1, this );
	}

qboolean Entity::MorphChannelMatches
	(
	int morph_channel1,
	int morph_channel2
	)
	{
	// Nothing matches with non

	if ( morph_channel1 == MORPH_CHAN_NONE )
		return false;

	// See if they match exactly
		
	if ( morph_channel1 == morph_channel2  )
		return true;

	// Check special cases

	if ( ( morph_channel1 == MORPH_CHAN_BROW ) && ( ( morph_channel2 == MORPH_CHAN_LEFT_BROW ) || ( morph_channel2 == MORPH_CHAN_RIGHT_BROW ) ) )
		return true;

	if ( ( morph_channel2 == MORPH_CHAN_BROW ) && ( ( morph_channel1 == MORPH_CHAN_LEFT_BROW ) || ( morph_channel1 == MORPH_CHAN_RIGHT_BROW ) ) )
		return true;

	if ( ( morph_channel1 == MORPH_CHAN_EYES ) && ( ( morph_channel2 == MORPH_CHAN_LEFT_LID ) || ( morph_channel2 == MORPH_CHAN_RIGHT_LID ) ) )
		return true;

	if ( ( morph_channel2 == MORPH_CHAN_EYES ) && ( ( morph_channel1 == MORPH_CHAN_LEFT_LID ) || ( morph_channel1 == MORPH_CHAN_RIGHT_LID ) ) )
		return true;

	return false;
	}

inline MorphInfo *CreateMorphInfo( void )
	{
	MorphInfo *new_morph_info;

	new_morph_info = new MorphInfo;

	if ( !new_morph_info )
		gi.Error( ERR_DROP, "Couldn't alloc MorphInfo" );

	return new_morph_info;
	}

#define CONTENTS_OPERATION_ADD			0
#define CONTENTS_OPERATION_SUBTRACT		1
#define CONTENTS_OPERATION_SET			2

void Entity::Contents
	(
	Event* ev
	)
	{
	if(ev == 0)
		return;

	int operation;
	const char* contentType;
	unsigned long contents = 0;
	unsigned long newFlags = 0;

	contents = getContents();

	for(int i = 1; i <= ev->NumArgs(); i++)
		{
		contentType = ev->GetString(i);

		if( ( contentType == 0 ) || ( strlen( contentType ) == 0 ) )
			continue;

		// Get operation type

		if(contentType[0] == '+')
			{
			operation = CONTENTS_OPERATION_ADD;
			contentType++;
			}
		else if(contentType[0] == '-')
			{
			operation = CONTENTS_OPERATION_SUBTRACT;
			contentType++;
			}
		else 
			operation = CONTENTS_OPERATION_SET;

		// Get contents type

		if(stricmp(contentType, "shootable") == 0)
			newFlags = CONTENTS_SHOOTABLE_ONLY;
		else if(stricmp(contentType, "targetable") == 0)
		{
			newFlags = CONTENTS_TARGETABLE;
			setSolidType(SOLID_BBOX);
		}
		else if(stricmp(contentType, "body") == 0)
			newFlags = CONTENTS_BODY;
		else if(stricmp(contentType, "solid") == 0)
			newFlags = CONTENTS_SOLID;
		else if(stricmp(contentType, "usable") == 0)
			newFlags = CONTENTS_USABLE;
		else if(stricmp(contentType, "setclip") == 0)
			newFlags = CONTENTS_SETCLIP;
		else if(stricmp(contentType, "playerclip") == 0)
			newFlags = CONTENTS_PLAYERCLIP;
		else if(stricmp(contentType, "monsterclip") == 0)
			newFlags = CONTENTS_MONSTERCLIP;
		else if(stricmp(contentType, "cameraclip") == 0)
			newFlags = CONTENTS_CAMERACLIP;
		else if(stricmp(contentType, "weaponclip") == 0)
			newFlags = CONTENTS_WEAPONCLIP;
		else if(stricmp(contentType, "corpse") == 0)
			newFlags = CONTENTS_CORPSE;
		else if(stricmp(contentType, "all") == 0)
			newFlags = 0xFFFFFFFF;

		// Change contents appropriatly

		if ( operation == CONTENTS_OPERATION_ADD )
			contents |= newFlags;
		else if ( operation == CONTENTS_OPERATION_SUBTRACT )
			contents &= ~newFlags;
		else if ( operation == CONTENTS_OPERATION_SET )
			contents = newFlags;
		}

		setContents(contents);
		link();
	}

void Entity::setMask( Event* ev )
{
	int i;
	int operation;
	const char* maskType;
	unsigned long currentMask;
	unsigned long newMask = 0;


	// Get the current mask

	currentMask = edict->clipmask;

	// Loop through all of the parms and change the mask appropriately

	for( i = 1 ; i <= ev->NumArgs() ; i++ )
	{
		maskType = ev->GetString( i );

		if( ( !maskType ) || ( strlen( maskType ) == 0 ) )
			continue;

		// Get operation type

		if ( maskType[0] == '+' )
		{
			operation = CONTENTS_OPERATION_ADD;
			maskType++;
		}
		else if ( maskType[0] == '-' )
		{
			operation = CONTENTS_OPERATION_SUBTRACT;
			maskType++;
		}
		else 
		{
			operation = CONTENTS_OPERATION_SET;
		}

		// Get contents type

		// Masks

		if ( stricmp( maskType, "solid" ) == 0 )
			newMask = MASK_SOLID;
		else if ( stricmp( maskType, "usable" ) == 0 )
			newMask = MASK_USABLE;
		else if ( stricmp( maskType, "playersolid" ) == 0 )
			newMask = MASK_PLAYERSOLID;
		else if ( stricmp( maskType, "deadsolid" ) == 0 )
			newMask = MASK_DEADSOLID;
		else if ( stricmp( maskType, "monstersolid" ) == 0 )
			newMask = MASK_MONSTERSOLID;
		else if ( stricmp( maskType, "water" ) == 0 )
			newMask = MASK_WATER;
		else if ( stricmp( maskType, "opaque" ) == 0 )
			newMask = MASK_OPAQUE;
		else if ( stricmp( maskType, "shot" ) == 0 )
			newMask = MASK_SHOT;
		else if ( stricmp( maskType, "projectile" ) == 0 )
			newMask = MASK_PROJECTILE;
		else if ( stricmp( maskType, "melee" ) == 0 )
			newMask = MASK_MELEE;
		else if ( stricmp( maskType, "pathsolid" ) == 0 )
			newMask = MASK_PATHSOLID;
		else if ( stricmp( maskType, "camerasolid" ) == 0 )
			newMask = MASK_CAMERASOLID;
		else if ( stricmp( maskType, "setclip" ) == 0 )
			newMask = MASK_SETCLIP;

		// Contents

		else if ( stricmp( maskType, "contents_solid" ) == 0 )
			newMask = CONTENTS_SOLID;
		else if ( stricmp( maskType, "contents_usable" ) == 0 )
			newMask = CONTENTS_USABLE;
		else if ( stricmp( maskType, "contents_setclip" ) == 0 )
			newMask = CONTENTS_SETCLIP;
		else if ( stricmp( maskType, "contents_targetable" ) == 0 )
			newMask = CONTENTS_TARGETABLE;
		else if ( stricmp( maskType, "contents_playerclip" ) == 0 )
			newMask = CONTENTS_PLAYERCLIP;
		else if ( stricmp( maskType, "contents_monsterclip" ) == 0 )
			newMask = CONTENTS_MONSTERCLIP;
		else if ( stricmp( maskType, "contents_cameraclip" ) == 0 )
			newMask = CONTENTS_CAMERACLIP;
		else if ( stricmp( maskType, "contents_weaponclip" ) == 0 )
			newMask = CONTENTS_WEAPONCLIP;
		else if ( stricmp( maskType, "contents_shootable" ) == 0 )
			newMask = CONTENTS_SHOOTABLE_ONLY;
		else if ( stricmp( maskType, "contents_body" ) == 0 )
			newMask = CONTENTS_BODY;
		else if ( stricmp( maskType, "contents_corpse" ) == 0 )
			newMask = CONTENTS_CORPSE;

		// All

		else if ( stricmp( maskType, "all" ) == 0 )
			newMask = 0xFFFFFFFF;

		// Change mask appropriately

		if ( operation == CONTENTS_OPERATION_ADD )
			currentMask |= newMask;
		else if ( operation == CONTENTS_OPERATION_SUBTRACT )
			currentMask &= ~newMask;
		else if ( operation == CONTENTS_OPERATION_SET )
			currentMask = newMask;
	}

	// Save the new mask

	edict->clipmask = currentMask;
}

void Entity::getCustomShaderInfo( const str &customShader, str &shaderName, str &soundName )
{
	// Setup the defaults

	shaderName = customShader;
	soundName = "";

	// See if we need to get info from the database

	if ( ( customShader.length() > 4 ) && ( stricmp( customShader.c_str() + customShader.length() - 4, ".gdb" ) == 0 ) )
	{
		str gameplayObjectName = customShader;
		gameplayObjectName.CapLength( customShader.length() - 4 );

		shaderName = G_GetDatabaseString( "CustomShader", gameplayObjectName, "ShaderName" );
		soundName  = G_GetDatabaseString( "CustomShader", gameplayObjectName, "SoundName" );
	}
}

//----------------------------------------------------------------
// Name:			setCustomShader
// Class:			Entity
//
// Description:		Sets the custom shader for this entity
//
// Parameters:		const char *customShader		- name of the shader
//
// Returns:			none
//----------------------------------------------------------------

void Entity::setCustomShader( const char *customShader )
{
	str shaderName;
	str soundName;

	if ( !customShader || ( strlen( customShader ) == 0 ) )
		return;

	getCustomShaderInfo( customShader, shaderName, soundName );

	// Apply the custom shader

	edict->s.customShader = gi.imageindex( shaderName );
	edict->s.eFlags |= EF_EFFECT_CUSTOM;

	// Start the loop sound associated with the customshader

	if ( soundName.length() )
	{
		LoopSound( soundName );
	}
}

//----------------------------------------------------------------
// Name:			setCustomShader
// Class:			Entity
//
// Description:		Sets the custom shader for this entity
//
// Parameters:		Event *ev						- event that contains the name of the shader
//
// Returns:			none
//----------------------------------------------------------------

void Entity::setCustomShader( Event *ev )
{
	setCustomShader( ev->GetString( 1 ) );
}

//----------------------------------------------------------------
// Name:			clearCustomShader
// Class:			Entity
//
// Description:		Clears the custom shader for this entity if it matches the shader name passed in
//
// Parameters:		const char *customShader		- name of the shader to clear, if NULL will always clear
//
// Returns:			none
//----------------------------------------------------------------

void Entity::clearCustomShader( const char *customShader )
{
	int tempImageIndex;
	str shaderName;
	str soundName;

	if ( customShader && edict->s.customShader )
	{
		getCustomShaderInfo( customShader, shaderName, soundName );

		// Only clear the custom shader if it matches the one passed in

		tempImageIndex = gi.imageindex( shaderName );

		if ( edict->s.customShader == tempImageIndex )
		{
			edict->s,customShader = 0;
			edict->s.eFlags &= ~EF_EFFECT_CUSTOM;
		}

		// Get rid of the loopsound associated with this custom shader

		if ( soundName.length() )
		{
			StopLoopSound();
		}
	}
	else
	{
		edict->s,customShader = 0;
		edict->s.eFlags &= ~EF_EFFECT_CUSTOM;
	}
}

//----------------------------------------------------------------
// Name:			clearCustomShader
// Class:			Entity
//
// Description:		Clears the custom shader for this entity if it matches the shader name passed in
//
// Parameters:		Event *ev				- event that optionally contains the name of the shader to clear
//
// Returns:			none
//----------------------------------------------------------------

void Entity::clearCustomShader( Event *ev )
{
	if ( ev->NumArgs() > 0 )
		clearCustomShader( ev->GetString( 1 ) );
	else
		clearCustomShader();
}

bool Entity::hasCustomShader( const char *customShader )
{
	// See if any custom shader is currently being used

	if ( !( edict->s.eFlags & EF_EFFECT_CUSTOM ) )
		return false;

	if ( customShader && edict->s.customShader )
	{
		int tempImageIndex;

		// Check to see if the shader matches the one passed in

		tempImageIndex = gi.imageindex( customShader );

		if ( edict->s.customShader != tempImageIndex )
		{
			// Not the correct shader

			return false;
		}
	}

	// Everything matches

	return true;
}

void Entity::setCustomEmitter( const char *customEmitter )
{
	if ( !customEmitter )
		return;

	edict->s.customEmitter = gi.imageindex( customEmitter );
	edict->s.eFlags |= EF_EMITTER_CUSTOM;
}

void Entity::setCustomEmitter( Event *ev )
{
	setCustomEmitter( ev->GetString( 1 ) );
}

void Entity::clearCustomEmitter( const char *customEmitter )
{
	int tempImageIndex;

	if ( customEmitter && edict->s.customEmitter )
	{
		// Only clear the custom shader if it matches the one passed in

		tempImageIndex = gi.imageindex( customEmitter );

		if ( edict->s.customEmitter == tempImageIndex )
		{
			edict->s,customEmitter = 0;
			edict->s.eFlags &= ~EF_EMITTER_CUSTOM;
		}

	}
	else
	{
		edict->s,customEmitter = 0;
		edict->s.eFlags &= ~EF_EMITTER_CUSTOM;
	}
}

void Entity::clearCustomEmitter( Event *ev )
{
	if ( ev->NumArgs() > 0 )
		clearCustomEmitter( ev->GetString( 1 ) );
	else
		clearCustomEmitter();
}

void Entity::hideFeaturesForFade( void )
{
	Event *event;

	// Shut the eyes

	event = new Event( EV_Morph );
	event->AddString( "morph_lid-lshut" );
	event->AddFloat( 100.0f );
	event->AddFloat( 0.05f );
	ProcessEvent ( event );

	event = new Event( EV_Morph );
	event->AddString( "morph_lid-rshut" );
	event->AddFloat( 100.0f );
	event->AddFloat( 0.05f );
	ProcessEvent ( event );

	// Hide the eyes and mouth surfaces

	event = new Event( EV_SurfaceModelEvent );
	event->AddString( "material3" );
	event->AddString( "+nodraw" );
	ProcessEvent ( event );

	// Don't let the entity blink

	event = new Event( EV_Actor_Blink );
	event->AddInteger( 0 );
	ProcessEvent ( event );
}

void Entity::showFeaturesForFade( void )
{
	Event *event;

	// Open the eyes

	event = new Event( EV_Unmorph );
	event->AddString( "morph_lid-lshut" );
	event->AddFloat( 100.0f );
	event->AddFloat( 0.5f );
	ProcessEvent ( event );

	event = new Event( EV_Unmorph );
	event->AddString( "morph_lid-rshut" );
	event->AddFloat( 100.0f );
	event->AddFloat( 0.5f );
	ProcessEvent ( event );

	// Show the eyes and mouth surfaces

	event = new Event( EV_SurfaceModelEvent );
	event->AddString( "material3" );
	event->AddString( "-nodraw" );
	ProcessEvent ( event );

	// Allow the entity to blink again

	event = new Event( EV_Actor_Blink );
	event->AddInteger( 1 );
	ProcessEvent ( event );
}

void Entity::DisplayEffect ( Event *ev )
{
	str effectType;
	str effectName;
	Event *event;
	int i;
	Entity *ent;
	bool passEvent = false;
	bool cancelEvents = false;
	Vector effectPosition;
	GameplayManager *gpm;
	str gameplayObjectName;


	// Get the parms

	effectType = ev->GetString( 1 );

	if ( ev->NumArgs() > 1 )
	{
		effectName = ev->GetString( 2 );
	}
	else
	{
		const char *delimiterPtr;

		// There is only 1 parm, so lets see if the type and name are both crammed into the 1 parm

		delimiterPtr = strstr( effectType.c_str(), "-" );

		if ( delimiterPtr )
		{
			// Effect name is everything after the -
			effectName = delimiterPtr + 1;

			// Effect type is everything before the -
			effectType.CapLength( delimiterPtr - effectType );
		}
	}

	// Get a pointer to the gameplay manager

	gpm = GameplayManager::getTheGameplayManager();

	// See if there is a gameplay object (if necessary)

	if ( ( strnicmp( effectType.c_str(), "TransportOut", strlen( "TransportOut" ) ) == 0 ) ||
		 ( strnicmp( effectType.c_str(), "TransportIn", strlen( "TransportIn" ) ) == 0 ) ||
		 ( strnicmp( effectType.c_str(), "FadeOut", strlen( "FadeOut" ) ) == 0 ) ||
		 ( strnicmp( effectType.c_str(), "FadeIn", strlen( "FadeIn" ) ) == 0 ) )
	{
		if ( ( strnicmp( effectType.c_str(), "TransportOut", strlen( "TransportOut" ) ) == 0 ) )
		{
			gameplayObjectName = "TransportOut";
		}
		else if ( ( strnicmp( effectType.c_str(), "TransportIn", strlen( "TransportIn" ) ) == 0 ) )
		{
			gameplayObjectName = "TransportIn";
		}
		else if ( ( strnicmp( effectType.c_str(), "FadeOut", strlen( "FadeOut" ) ) == 0 ) )
		{
			gameplayObjectName = "FadeOut";
		}
		else if ( ( strnicmp( effectType.c_str(), "FadeIn", strlen( "FadeIn" ) ) == 0 ) )
		{
			gameplayObjectName = "FadeIn";
		}

		gameplayObjectName += effectName;

		if ( !gpm->hasObject( gameplayObjectName ) )
		{
			gi.WDPrintf( "Can't find object called %s to use in DisplayEffect\n", gameplayObjectName.c_str() );
			return;
		}
	}

	if ( effectType == "TransportOut" )
	{
		str shaderName;
		str soundName;
		str effectTikiName;
		str animName;
		str effectPos;
		str currentEffectPos;
		float effectTime;
		float transportTime;
		int numEffects;
		int immobilize;
		int hideFeatures;
		int attach;


		// Get all of the info from the gameplay database

		shaderName		= gpm->getStringValue( gameplayObjectName, "ShaderName" );
		soundName		= gpm->getStringValue( gameplayObjectName, "SoundName" );
		effectTikiName	= gpm->getStringValue( gameplayObjectName, "EffectName" );
		attach			= (int) gpm->getFloatValue( gameplayObjectName, "AttachEffect" );
		animName		= gpm->getStringValue( gameplayObjectName, "AnimName" );

		effectPos		= gpm->getStringValue( gameplayObjectName, "EffectPosName" );
		numEffects		= (int) gpm->getFloatValue( gameplayObjectName, "NumEffects" );

		effectTime		= gpm->getFloatValue( gameplayObjectName, "EffectTime" );
		transportTime	= gpm->getFloatValue( gameplayObjectName, "TransportTime" );

		immobilize		= (int) gpm->getFloatValue( gameplayObjectName, "Immobilize" );
		hideFeatures	= (int) gpm->getFloatValue( gameplayObjectName, "HideFeatures" );

		setCustomShader( shaderName );
		setAlpha( 0.0f );

		edict->s.renderfx |= RF_FORCE_ALPHA_EFFECTS;
		edict->s.renderfx &= ~RF_FORCE_ALPHA;

		event = new Event( EV_FadeIn );
		event->AddFloat( effectTime );
		ProcessEvent( event );

		event = new Event( EV_DisplayEffect );
		event->AddString( "TransportOut2" );
		event->AddString( effectName );
		PostEvent( event, effectTime );

		if ( hideFeatures )
			hideFeaturesForFade();

		if ( edict->s.parent == ENTITYNUM_NONE )
		{
			if ( soundName.length() )
			{
				Sound( soundName );
			}

			if ( effectTikiName.length() > 4 )
			{
				Vector pos;

				currentEffectPos = effectPos;

				for ( i = 0 ; i < numEffects ; i++ )
				{
					if ( !effectPos.length() || effectPos == "centroid" )
						pos = centroid;
					else if ( effectPos == "origin" )
						pos = origin;
					else if ( effectPos == "randombone" )
					{
						int tagNum;

						tagNum = (int) G_Random( gi.NumTags( edict->s.modelindex ) );
						currentEffectPos = gi.Tag_NameForNum( edict->s.modelindex, tagNum );
						
						GetTag( tagNum, &pos, NULL );
					}
					else if ( gi.Tag_NumForName( edict->s.modelindex, effectPos.c_str() ) >= 0 )
						GetTag( effectPos, &pos, NULL );
					else
						pos = centroid;

					if ( attach )
						attachEffect( effectTikiName, currentEffectPos, effectTime + transportTime );
					else
						SpawnEffect( effectTikiName, pos, angles, effectTime + transportTime );
				}
			}
		}

		if ( animate && animName.length() && animate->HasAnim( animName.c_str() ) )
		{
			animate->RandomAnimate( animName.c_str() );
		}

		if ( immobilize )
		{
			takedamage = DAMAGE_NO;
			flags |= FL_IMMOBILE;
		}

		passEvent = true;
	}
	else if ( effectType == "TransportOut2" )
	{
		str shaderName;
		float transportTime;

		// Get all of the info from the gameplay database

		shaderName    = gpm->getStringValue( gameplayObjectName, "ShaderName" );
		transportTime = gpm->getFloatValue( gameplayObjectName, "TransportTime" );

		CancelEventsOfType( EV_FadeIn );

		edict->s.renderfx &= ~RF_FORCE_ALPHA_EFFECTS;

		setCustomShader( shaderName.c_str() );
		setAlpha( 1.0f );
		edict->s.renderfx |= RF_FORCE_ALPHA;

		event = new Event( EV_FadeNoRemove );
		event->AddFloat( transportTime );
		event->AddFloat( 0.0f );
		ProcessEvent( event );

		event = new Event( EV_DisplayEffect );
		event->AddString( "TransportOut3" );
		event->AddString( effectName );
		PostEvent( event, transportTime );
	}
	else if ( effectType == "TransportOut3" )
	{
		str shaderName;
		int hideFeatures;

		// Get all of the info from the gameplay database

		shaderName    = gpm->getStringValue( gameplayObjectName, "ShaderName" );

		hideFeatures = (int) gpm->getFloatValue( gameplayObjectName, "HideFeatures" );

		if ( hideFeatures )
			showFeaturesForFade();

		if ( shaderName.length() )
		{
			clearCustomShader( shaderName );
		}

		// Finish up the transport out

		event = new Event( EV_EntityRenderEffects );
		event->AddString( "-shadow" );
		ProcessEvent( event );

		takedamage = DAMAGE_YES;
		flags &= ~FL_IMMOBILE;
	}
	else if ( effectType == "TransportIn" )
	{
		str shaderName;
		str soundName;
		str effectPos;
		str currentEffectPos;
		str effectTikiName;
		float effectTime;
		float transportTime;
		int numEffects;
		int immobilize;
		int attach;
		int hideFeatures;

		// Cancel other display events so we don't get any overlap (can't do this because it breaks animations that
		//   have both since animate posts all frame commands un front

		//CancelEventsOfType( EV_DisplayEffect ); 
		clearCustomShader();

		// Get all of the info from the gameplay database

		shaderName = gpm->getStringValue( gameplayObjectName, "ShaderName" );
		soundName = gpm->getStringValue( gameplayObjectName, "SoundName" );
		effectTikiName	= gpm->getStringValue( gameplayObjectName, "EffectName" );
		attach			= (int) gpm->getFloatValue( gameplayObjectName, "AttachEffect" );

		effectPos		= gpm->getStringValue( gameplayObjectName, "EffectPosName" );
		numEffects		= (int) gpm->getFloatValue( gameplayObjectName, "NumEffects" );

		effectTime		= gpm->getFloatValue( gameplayObjectName, "EffectTime" );
		transportTime   = gpm->getFloatValue( gameplayObjectName, "TransportTime" );

		immobilize		= (int) gpm->getFloatValue( gameplayObjectName, "Immobilize" );
		hideFeatures	= (int) gpm->getFloatValue( gameplayObjectName, "HideFeatures" );

		edict->s.renderfx &= ~RF_FORCE_ALPHA_EFFECTS;

		if ( shaderName.length() )
		{
			setCustomShader( shaderName );
		}

		setAlpha( 0.0f );
		edict->s.renderfx |= RF_FORCE_ALPHA;

		event = new Event( EV_FadeIn );
		event->AddFloat( transportTime );
		ProcessEvent( event );

		event = new Event( EV_DisplayEffect );
		event->AddString( "TransportIn2" );
		event->AddString( effectName );
		PostEvent( event, transportTime );

		if ( hideFeatures )
			hideFeaturesForFade();

		if ( edict->s.parent == ENTITYNUM_NONE )
		{
			if ( soundName.length() )
			{
				Sound( soundName );
			}

			if ( effectTikiName.length() > 4 )
			{
				Vector pos;

				currentEffectPos = effectPos;

				for ( i = 0 ; i < numEffects ; i++ )
				{
					if ( !effectPos.length() || effectPos == "centroid" )
						pos = centroid;
					else if ( effectPos == "origin" )
						pos = origin;
					else if ( effectPos == "randombone" )
					{
						int tagNum;

						tagNum = (int) G_Random( gi.NumTags( edict->s.modelindex ) );
						currentEffectPos = gi.Tag_NameForNum( edict->s.modelindex, tagNum );
						
						GetTag( tagNum, &pos, NULL );
					}
					else if ( gi.Tag_NumForName( edict->s.modelindex, effectPos.c_str() ) >= 0 )
						GetTag( effectPos, &pos, NULL );
					else
						pos = centroid;

					if ( attach )
						attachEffect( effectTikiName, currentEffectPos, effectTime + transportTime );
					else
						SpawnEffect( effectTikiName, pos, angles, effectTime + transportTime );
				}
			}
		}

		if ( immobilize )
		{
			takedamage = DAMAGE_NO;
			flags |= FL_IMMOBILE;
		}

		passEvent = true;
		cancelEvents = true;
	}
	else if ( effectType == "TransportIn2" )
	{
		str shaderName;
		float effectTime;

		// Get all of the info from the gameplay database

		shaderName     = gpm->getStringValue( gameplayObjectName, "ShaderName" );
		effectTime    = gpm->getFloatValue( gameplayObjectName, "EffectTime" );

		CancelEventsOfType( EV_FadeIn );
		edict->s.renderfx &= ~RF_FORCE_ALPHA;

		if ( shaderName.length() )
		{
			setCustomShader( shaderName );
		}

		setAlpha( 1.0f );

		if ( shaderName.length() )
		{
			edict->s.renderfx |= RF_FORCE_ALPHA_EFFECTS;

			event = new Event( EV_FadeNoRemove );
			event->AddFloat( effectTime );
			event->AddFloat( 0.0f );
			ProcessEvent( event );
		}

		event = new Event( EV_DisplayEffect );
		event->AddString( "TransportIn3" );
		event->AddString( effectName );
		PostEvent( event, effectTime  );
	}
	else if ( effectType == "TransportIn3" )
	{
		str shaderName;
		str animName;
		int hideFeatures;

		// Get all of the info from the gameplay database

		shaderName		= gpm->getStringValue( gameplayObjectName, "ShaderName" );
		animName		= gpm->getStringValue( gameplayObjectName, "AnimName" );

		hideFeatures	= (int) gpm->getFloatValue( gameplayObjectName, "HideFeatures" );

		if ( shaderName.length() )
		{
			clearCustomShader( shaderName );
			edict->s.renderfx &= ~RF_FORCE_ALPHA_EFFECTS;
		}

		if ( animate && animName.length() && animate->HasAnim( animName.c_str() ) )
		{
			animate->RandomAnimate( animName.c_str() );
		}

		CancelEventsOfType( EV_FadeNoRemove );

		if ( hideFeatures )
			showFeaturesForFade();

		setAlpha( 1.0f );

		event = new Event( EV_EntityRenderEffects );
		event->AddString( "+shadow" );
		ProcessEvent( event );

		takedamage = DAMAGE_YES;
		flags &= ~FL_IMMOBILE;
	}
	else if ( effectType == "FadeOut" )
	{
		str shaderName;
		str soundName;
		str effectTikiName;
		str effectPos;
		str currentEffectPos;
		float effectTime;
		float fadeTime;
		int numEffects;
		int attach;
		int hideFeatures;

		// Get all of the info from the gameplay database

		shaderName		= gpm->getStringValue( gameplayObjectName, "ShaderName" );
		soundName		= gpm->getStringValue( gameplayObjectName, "SoundName" );
		effectTikiName	= gpm->getStringValue( gameplayObjectName, "EffectName" );
		attach			= (int) gpm->getFloatValue( gameplayObjectName, "AttachEffect" );

		effectPos		= gpm->getStringValue( gameplayObjectName, "EffectPosName" );
		numEffects		= (int) gpm->getFloatValue( gameplayObjectName, "NumEffects" );

		effectTime		= gpm->getFloatValue( gameplayObjectName, "EffectTime" );
		fadeTime		= gpm->getFloatValue( gameplayObjectName, "FadeTime" );
		hideFeatures	= (int) gpm->getFloatValue( gameplayObjectName, "HideFeatures" );

		setCustomShader( shaderName );

		setAlpha( 0.0f );

		edict->s.renderfx |= RF_FORCE_ALPHA_EFFECTS;
		edict->s.renderfx &= ~RF_FORCE_ALPHA;

		if ( effectTime > 0.0f )
		{
			event = new Event( EV_FadeIn );
			event->AddFloat( effectTime );
			ProcessEvent( event );
		}

		event = new Event( EV_DisplayEffect );
		event->AddString( "FadeOut2" );
		event->AddString( effectName );
		PostEvent( event, effectTime  );

		if ( hideFeatures )
			hideFeaturesForFade();

		if ( edict->s.parent == ENTITYNUM_NONE )
		{
			// Play sound

			if ( soundName.length() )
			{
				Sound( soundName );
			}

			// Spawn an effect 

			if ( effectTikiName.length() > 4 )
			{
				Vector pos;

				currentEffectPos = effectPos;

				for ( i = 0 ; i < numEffects ; i++ )
				{
					if ( !effectPos.length() || effectPos == "centroid" )
						pos = centroid;
					else if ( effectPos == "origin" )
						pos = origin;
					else if ( effectPos == "randombone" )
					{
						int tagNum;

						tagNum = (int) G_Random( gi.NumTags( edict->s.modelindex ) );
						currentEffectPos = gi.Tag_NameForNum( edict->s.modelindex, tagNum );
						
						GetTag( tagNum, &pos, NULL );
					}
					else if ( gi.Tag_NumForName( edict->s.modelindex, effectPos.c_str() ) >= 0 )
						GetTag( effectPos, &pos, NULL );
					else
						pos = centroid;

					if ( attach )
						attachEffect( effectTikiName, currentEffectPos, effectTime + fadeTime );
					else
						SpawnEffect( effectTikiName, pos, angles, effectTime + fadeTime );
				}
			}
		}

		passEvent = true;
	}
	else if ( effectType == "FadeOut2" )
	{
		str shaderName;
		float fadeTime;

		// Get all of the info from the gameplay database

		shaderName = gpm->getStringValue( gameplayObjectName, "ShaderName" );
		fadeTime   = gpm->getFloatValue( gameplayObjectName, "FadeTime" );

		CancelEventsOfType( EV_FadeIn );
		edict->s.renderfx &= ~RF_FORCE_ALPHA_EFFECTS;

		setCustomShader( shaderName );
		setAlpha( 1.0f );
		edict->s.renderfx |= RF_FORCE_ALPHA;

		event = new Event( EV_FadeNoRemove );
		event->AddFloat( fadeTime );
		event->AddFloat( 0.0f );
		ProcessEvent( event );

		event = new Event( EV_DisplayEffect );
		event->AddString( "FadeOut3" );
		event->AddString( effectName );
		PostEvent( event, fadeTime  );
	}
	else if ( effectType == "FadeOut3" )
	{
		/* int hideFeatures;

		hideFeatures = gpm->getFloatValue( gameplayObjectName, "HideFeatures" );

		if ( hideFeatures )
			showFeaturesForFade(); */
	}
	else if ( effectType == "FadeIn" )
	{
		str shaderName;
		str soundName;
		str effectTikiName;
		str effectPos;
		str currentEffectPos;
		//float effectTime;
		float fadeTime;
		int numEffects;
		int attach;
		int hideFeatures;

		// Get all of the info from the gameplay database

		shaderName		= gpm->getStringValue( gameplayObjectName, "ShaderName" );
		soundName		= gpm->getStringValue( gameplayObjectName, "SoundName" );
		effectTikiName	= gpm->getStringValue( gameplayObjectName, "EffectName" );
		attach			= (int) gpm->getFloatValue( gameplayObjectName, "AttachEffect" );

		effectPos		= gpm->getStringValue( gameplayObjectName, "EffectPosName" );
		numEffects		= (int) gpm->getFloatValue( gameplayObjectName, "NumEffects" );

		//effectTime   = gpm->getFloatValue( gameplayObjectName, "EffectTime" );
		fadeTime		= gpm->getFloatValue( gameplayObjectName, "FadeTime" );
		hideFeatures	= (int) gpm->getFloatValue( gameplayObjectName, "HideFeatures" );

		setCustomShader( shaderName );

		setAlpha( 0.0f );

		edict->s.renderfx &= ~RF_FORCE_ALPHA_EFFECTS;
		edict->s.renderfx |= RF_FORCE_ALPHA;

		event = new Event( EV_FadeIn );
		event->AddFloat( fadeTime );
		ProcessEvent( event );

		event = new Event( EV_DisplayEffect );
		event->AddString( "FadeIn2" );
		event->AddString( effectName );
		PostEvent( event, fadeTime  );

		if ( hideFeatures )
			hideFeaturesForFade();

		if ( edict->s.parent == ENTITYNUM_NONE )
		{
			// Play sound

			if ( soundName.length() )
			{
				Sound( soundName );
			}

			// Spawn an effect 

			if ( effectTikiName.length() > 4 )
			{
				Vector pos;

				currentEffectPos = effectPos;

				for ( i = 0 ; i < numEffects ; i++ )
				{
					if ( !effectPos.length() || effectPos == "centroid" )
						pos = centroid;
					else if ( effectPos == "origin" )
						pos = origin;
					else if ( effectPos == "randombone" )
					{
						int tagNum;

						tagNum = (int) G_Random( gi.NumTags( edict->s.modelindex ) );
						currentEffectPos = gi.Tag_NameForNum( edict->s.modelindex, tagNum );
						
						GetTag( tagNum, &pos, NULL );
					}
					else if ( gi.Tag_NumForName( edict->s.modelindex, effectPos.c_str() ) >= 0 )
						GetTag( effectPos, &pos, NULL );
					else
						pos = centroid;

					if ( attach )
						attachEffect( effectTikiName, currentEffectPos, fadeTime + fadeTime );
					else
						SpawnEffect( effectTikiName, pos, angles, fadeTime + fadeTime );
				}
			}
		}

		passEvent = true;
	}
	else if ( effectType == "FadeIn2" )
	{
		str shaderName;
		float effectTime;

		// Get all of the info from the gameplay database

		shaderName = gpm->getStringValue( gameplayObjectName, "ShaderName" );
		effectTime   = gpm->getFloatValue( gameplayObjectName, "EffectTime" );

		CancelEventsOfType( EV_FadeIn );

		setAlpha( 1.0f );

		if ( shaderName.length() > 0 )
		{
			setCustomShader( shaderName );

			edict->s.renderfx |= RF_FORCE_ALPHA_EFFECTS;
			edict->s.renderfx |= RF_FORCE_ALPHA;

			event = new Event( EV_FadeNoRemove );
			event->AddFloat( effectTime );
			event->AddFloat( 0.0f );
			ProcessEvent( event );
		}

		event = new Event( EV_DisplayEffect );
		event->AddString( "FadeIn3" );
		event->AddString( effectName );
		PostEvent( event, effectTime  );
	}
	else if ( effectType == "FadeIn3" )
	{
		str shaderName;
		int hideFeatures;

		// Get all of the info from the gameplay database

		shaderName = gpm->getStringValue( gameplayObjectName, "ShaderName" );
		hideFeatures = (int) gpm->getFloatValue( gameplayObjectName, "HideFeatures" );

		CancelEventsOfType( EV_FadeNoRemove );

		edict->s.renderfx &= ~RF_FORCE_ALPHA_EFFECTS;
		edict->s.renderfx &= ~RF_FORCE_ALPHA;

		if ( hideFeatures )
			showFeaturesForFade();

		clearCustomShader( shaderName );
		setAlpha( 1.0f );
	}
	else if ( effectType == "start_invisibility" )
	{
		edict->s.eFlags |= EF_EFFECT_ELECTRIC;
		setAlpha( 0.1f );

		edict->s.renderfx |= RF_FORCE_ALPHA;

		addAffectingViewModes( gi.GetViewModeMask( "forcevisible" ) );

		passEvent = true;
	}
	else if ( effectType == "stop_invisibility" )
	{
		edict->s.eFlags &= ~EF_EFFECT_ELECTRIC;
		setAlpha( 1.0f );

		edict->s.renderfx &= ~RF_FORCE_ALPHA;

		removeAffectingViewModes( gi.GetViewModeMask( "forcevisible" ) );

		passEvent = true;
	}
	else if ( effectType == "electric" )
	{
		edict->s.eFlags |= EF_EFFECT_ELECTRIC;
		passEvent = true;
	}
	else if ( effectType == "noelectric" )
	{
		edict->s.eFlags &= ~EF_EFFECT_ELECTRIC;
		passEvent = true;
	}
	else if ( effectType == "failure" )
	{
		edict->s.eFlags |= EF_BEHAVIOR_FAILURE;
		passEvent = true;
	}
	else if ( effectType == "nofailure" )
	{
		edict->s.eFlags &= ~EF_BEHAVIOR_FAILURE;
		passEvent = true;
	}
	else if ( ( effectType == "transport_out" ) || ( effectType == "transport_in" ) || ( effectType == "borg_transport_out" ) ||
			  ( effectType == "borg_transport_in" ) )
	{
		gi.WDPrintf( "Support for %s will soon be removed please use the new way\n", effectType.c_str() );

		event = new Event( EV_DisplayEffect );

		if ( effectType == "transport_out" )
		{
			event->AddString( "TransportOut" );
			event->AddString( "Federation" );
		}
		else if ( effectType == "transport_in" )
		{
			event->AddString( "TransportIn" );
			event->AddString( "Federation" );
		}
		else if ( effectType == "borg_transport_out" )
		{
			event->AddString( "TransportOut" );
			event->AddString( "Borg" );
		}
		else if ( effectType == "borg_transport_in" )
		{
			event->AddString( "TransportIn" );
			event->AddString( "Borg" );
		}

		ProcessEvent( event );
		return;
	}

	if ( passEvent && bind_info && bind_info->numchildren )
	{
		for( i = 0 ; i < MAX_MODEL_CHILDREN ; i++ )
		{
			if ( bind_info->children[ i ] == ENTITYNUM_NONE )
				continue;

			ent = G_GetEntity( bind_info->children[ i ] );

			if ( ent )
			{
				/* if ( cancelEvents )
				{
					// Cancel other display events so we don't get any overlap

					ent->CancelEventsOfType( EV_DisplayEffect ); 
				} */

				ent->ProcessEvent( *ev );
			}
		}
	}
}

//----------------------------------------------------------------
// Name:			clearDisplayEffects
// Class:			Entity
//
// Description:		Clears all of the display type of effects and sets the alpha back to normal
//
// Parameters:		None
//
// Returns:			None
//----------------------------------------------------------------

void Entity::clearDisplayEffects( void ) 
{
	if ( edict->s.eFlags | EF_EFFECTS )
	{
		edict->s.eFlags &= ~EF_EFFECTS;
		setAlpha( 1.0f );

		edict->s.renderfx &= ~RF_FORCE_ALPHA_EFFECTS;
		edict->s.renderfx &= ~RF_FORCE_ALPHA;
	}
}

void Entity::SpawnEffect( Event *ev ) 
	{
	//const str &name, const Vector &origin, const Vector &angles, float removeTime )
	str tagName;
	str modelName;
	Vector tagPos;
	Vector tagForward;
	Vector tagAngles;
	float removeTime;


	modelName = ev->GetString( 1 );

	tagName = ev->GetString( 2 );
	GetTag( tagName, &tagPos, &tagForward );

	tagAngles = tagForward.toAngles();

	if ( ev->NumArgs() > 2 )
		removeTime = ev->GetFloat( 3 );
	else
		removeTime = 0.0f;

	SpawnEffect( modelName, tagPos, tagAngles, removeTime );
	}

Entity *Entity::SpawnEffect( const str &name, const Vector &origin, const Vector &angles, float removeTime )
{
	Entity *newEntity;
	str modelName;
	int nameLength;

	nameLength = name.length();

	if ( stricmp( name.c_str() + nameLength - 4, ".gdb" ) == 0 )
	{
		str gameplayObjectName;
		GameplayManager *gpm;

		gpm = GameplayManager::getTheGameplayManager();

		gameplayObjectName = name;
		gameplayObjectName.CapLength( nameLength - 4 );

		if ( gpm->hasObject( gameplayObjectName ) )
		{
			modelName = gpm->getStringValue( gameplayObjectName, "ModelName" );
		}
		else
		{
			const char *dash;

			dash = strstr( gameplayObjectName.c_str(), "-" );

			if ( dash )
			{
				gameplayObjectName.CapLength( dash - gameplayObjectName.c_str() );
				gameplayObjectName += "-default";

				if ( gpm->hasObject( gameplayObjectName ) )
				{
					modelName = gpm->getStringValue( gameplayObjectName, "ModelName" );
				}
				else
				{
					gi.WDPrintf( "%s not find in the gameplay database\n", name.c_str() );
					return NULL;
				}
			}
			else
			{
				gi.WDPrintf( "%s not find in the gameplay database\n", name.c_str() );
				return NULL;
			}
		}
	}
	else
	{
		modelName = name;
	}

	newEntity = new Entity( ENTITY_CREATE_FLAG_ANIMATE );

	newEntity->setModel( modelName );

	newEntity->angles = angles;
	newEntity->setAngles();

	newEntity->setOrigin( origin );

	newEntity->setSolidType( SOLID_NOT );

	if ( removeTime > 0.0f )
		newEntity->PostEvent( EV_Remove, removeTime );

	newEntity->CancelEventsOfType( EV_ProcessInitCommands );
	newEntity->ProcessInitCommands( newEntity->edict->s.modelindex );

	newEntity->animate->RandomAnimate( "idle" );

	return newEntity;
}

Entity* Entity::SpawnSound( const str &sound, const Vector &pos, float volume, float removeTime )
{
	Entity *newEntity;
	Vector soundOrigin;
	newEntity = new Entity( ENTITY_CREATE_FLAG_ANIMATE );
	newEntity->setOrigin( pos );
	newEntity->setSolidType( SOLID_NOT );

	if ( removeTime > 0.0f )
		newEntity->PostEvent( EV_Remove, removeTime );

	soundOrigin = pos;
	newEntity->CancelEventsOfType( EV_ProcessInitCommands );
	newEntity->ProcessInitCommands( newEntity->edict->s.modelindex );
	newEntity->Sound( sound , CHAN_BODY, volume, -1.0f, &soundOrigin );
	return newEntity;
}

void Entity::attachEffect( Event *ev ) 
	{
	str tagName;
	str modelName;
	//Vector tagPos;
	//Vector tagForward;
	//Vector tagAngles;
	float removeTime;


	modelName = ev->GetString( 1 );

	tagName = ev->GetString( 2 );
	//GetTag( tagName, &tagPos, &tagForward );

	//tagAngles = tagForward.toAngles();

	if ( ev->NumArgs() > 2 )
		removeTime = ev->GetFloat( 3 );
	else
		removeTime = 0.0f;

	attachEffect( modelName, tagName, removeTime );
	}

void Entity::attachEffect( const str &modelName, const str &tagName, float removeTime )
{
	Event *newEvent = new Event( EV_AttachModel );
	newEvent->AddString( modelName );
	newEvent->AddString( tagName );
	newEvent->AddFloat( 1.0f );
	newEvent->AddString( "" );
	newEvent->AddInteger( 0 );
	newEvent->AddFloat( removeTime );
	ProcessEvent( newEvent );
}

void Entity::ForceAlpha( Event *ev )
	{
	if ( ev->NumArgs() == 0 )
		edict->s.renderfx |= RF_FORCE_ALPHA;
	else if ( ev->GetBoolean( 1 ) )
		edict->s.renderfx |= RF_FORCE_ALPHA;
	else
		edict->s.renderfx &= ~RF_FORCE_ALPHA;
	}

void Entity::CreateEarthquake( Event *ev )
   {
	Earthquake *earthquake;
	float duration;
	float magnitude;
	float distance = 0;
	Event *newEvent;


	if ( origin == vec_zero )
	{
		gi.WDPrintf( "Earthquake being started when origin hasn't been set yet in model %s\n", model.c_str() ); 
		return;
	}

	magnitude = ev->GetFloat( 1 );
	duration  = ev->GetFloat( 2 );

	if ( ev->NumArgs() > 2 )
		distance = ev->GetFloat( 3 );

	earthquake = new Earthquake;

	newEvent = new Event( EV_SetOrigin );
	newEvent->AddVector( origin );
	earthquake->ProcessEvent( newEvent );

	newEvent = new Event( EV_Earthquake_SetMagnitude );
	newEvent->AddFloat( magnitude );
	earthquake->ProcessEvent( newEvent );

	newEvent = new Event( EV_Earthquake_SetDuration );
	newEvent->AddFloat( duration );
	earthquake->ProcessEvent( newEvent );

	if ( distance )
		{
		newEvent = new Event( EV_Earthquake_SetDistance );
		newEvent->AddFloat( distance );
		earthquake->ProcessEvent( newEvent );
		}

	earthquake->ProcessEvent( EV_Trigger_Effect );

	earthquake->PostEvent( EV_Remove, duration );
   }

void Entity::SetFloatVar
	(
   Event *ev
	)

	{
	str var_name;
	float value;

	var_name = ev->GetString( 1 );
	value    = ev->GetFloat( 2 );

	entityVars.SetVariable( var_name, value );
	}

void Entity::SetVectorVar
	(
   Event *ev
	)

	{
	str var_name;
	Vector value;

	var_name = ev->GetString( 1 );
	value    = ev->GetVector( 2 );

	entityVars.SetVariable( var_name, value );
	}

void Entity::SetStringVar
	(
   Event *ev
	)

	{
	str var_name;
	str value;

	var_name = ev->GetString( 1 );
	value    = ev->GetString( 2 );

	entityVars.SetVariable( var_name, value );
	}

void Entity::doesVarExist( Event *ev )
{
	ScriptVariable *var = NULL;


	var = entityVars.GetVariable( ev->GetString( 1 ) );

	if ( var )
		ev->ReturnFloat( 1.0f );
	else
		ev->ReturnFloat( 0.0f );
}

void Entity::GetFloatVar
	(
   Event *ev
	)

	{
	str var_name;
	ScriptVariable *var = NULL;

	var_name = ev->GetString( 1 );

	var = entityVars.GetVariable( var_name );

	if ( var )
		ev->ReturnFloat( var->floatValue() );
	else
		{
		gi.WDPrintf( "%s variable not found\n", var_name.c_str() );
		ev->ReturnFloat( 0.0f );
		}
	}

void Entity::RemoveVariable( Event* ev )
{
	str var_name;
	if( ev->NumArgs() > 0 )	
	{
		var_name = ev->GetString( 1 );
		if( var_name.length() > 0 ) 
		{
			entityVars.RemoveVariable( var_name );
		}
	}
}

void Entity::GetVectorVar
	(
   Event *ev
	)

	{
	str var_name;
	ScriptVariable *var = NULL;

	var_name = ev->GetString( 1 );

	var = entityVars.GetVariable( var_name );

	if ( var )
		ev->ReturnVector( var->vectorValue() );
	else
		{
		gi.WDPrintf( "%s variable not found\n", var_name.c_str() );
		ev->ReturnVector( Vector(0, 0, 0) );
		}
	}

void Entity::GetStringVar
	(
   Event *ev
	)

	{
	str var_name;
	ScriptVariable *var = NULL;

	var_name = ev->GetString( 1 );

	var = entityVars.GetVariable( var_name );

	if ( var )
		ev->ReturnString( var->stringValue() );
	else
		{
		gi.WDPrintf( "%s variable not found\n", var_name.c_str() );
		ev->ReturnString( "" );
		}
	}

void Entity::SetUserVar1
	(
   Event *ev
	)

	{
	entityVars.SetVariable( "uservar1", ev->GetString( 1 ) );
	}

void Entity::SetUserVar2
	(
   Event *ev
	)

	{
	entityVars.SetVariable( "uservar2", ev->GetString( 1 ) );
	}

void Entity::SetUserVar3
	(
   Event *ev
	)

	{
	entityVars.SetVariable( "uservar3", ev->GetString( 1 ) );
	}

void Entity::SetUserVar4
	(
   Event *ev
	)

	{
	entityVars.SetVariable( "uservar4", ev->GetString( 1 ) );
	}

Vector Entity::GetClosestCorner( const Vector &position )
   {
   Vector corner;  

   Vector closestCorner;
   Vector compare;
   float distance;
   float length;

   distance = 999999999.9f;

   for ( int i = 0 ; i < 4 ; i++ )
      {
      // corner's based on a top down view of the bounding box -- I am returning
      // the vector for the corner on a plane with the origin only.
      switch ( i )
         {
         // Upper Left
         case 0:
            corner.x = origin.x + mins.x;
            corner.y = origin.y + maxs.y;
            corner.z = origin.z;
         break;

         // Upper Right
         case 1:
            corner.x = origin.x + maxs.x;
            corner.y = origin.y + maxs.y;
            corner.z = origin.z;
         break;

         // Lower Left
         case 2:
            corner.x = origin.x + mins.x;
            corner.y = origin.y + mins.y;
            corner.z = origin.z;
         break;

         case 3:
            corner.x = origin.x + maxs.x;
            corner.y = origin.y + mins.y;
            corner.z = origin.z;
         break;
         }

      compare = corner - position;
      length = compare.length();

      if ( length < distance )
         {
         closestCorner = corner;
         distance = length;
         }
      }

   return closestCorner;
   
   }

//----------------------------------------------------------------
// Name:			affectingViewMode
// Class:			Entity
//
// Description:		Adds a new viewmode  to the entities applicable viewmodes
//
// Parameters:		Event *ev								- event (name of the view mode)
//
// Returns:			None
//----------------------------------------------------------------

void Entity::affectingViewMode( Event *ev )
	{
	addAffectingViewModes( gi.GetViewModeMask( ev->GetString( 1 ) ) );
	}

//----------------------------------------------------------------
// Name:			addAffectingViewMode
// Class:			Entity
//
// Description:		Adds the specified viewmode bits to the entities applicable viewmodes
//
// Parameters:		unsigned int mask						- the bit mask of the relevant viewmodes
//
// Returns:			None
//----------------------------------------------------------------

void Entity::addAffectingViewModes( unsigned int mask )
{
	_affectingViewModes |= mask;
	edict->s.affectingViewModes = _affectingViewModes;
}

void Entity::removeAffectingViewModes( unsigned int mask )
{
	_affectingViewModes &= ~mask;
	edict->s.affectingViewModes = _affectingViewModes;
}


//--------------------------------------------------------------
// Name:		SetGroupID()
// Class:		Entity
//
// Description:	Grabs the ID from the event, and sends it to the
//				group coordinator for registration.  In the future
//				we need to migrate this so that all group registration
//				is done throught he group coordinator alone.
//
// Parameters:	Event *ev
//
// Returns:		None
//--------------------------------------------------------------
void Entity::SetGroupID( Event *ev )
{
	AddToGroup( ev->GetInteger( 1 ) );
}

void Entity::AddToGroup( int ID )
{
	groupcoordinator->AddEntityToGroup( this , ID );	
}

//----------------------------------------------------------------
// Name:			TikiTodo and TikiNote
// Class:			Entity
//
// Description:		These commands may come from tiki files (via TikiMaster).
//					They are here so the commands are not considered errors.
//					In the future we might want cvars to print todo items.
//
// Parameters:		Event *ev
//
// Returns:			None
//----------------------------------------------------------------
void Entity::TikiTodo( Event *ev )
	{
	}
void Entity::TikiNote( Event *ev )
	{
	}

//----------------------------------------------------------------
// Name:			MultiplayerEvent
// Class:			Entity
//
// Description:		This is a passthrough event.  It only allows the contained event to be called
//					if we are in a multiplayer game
//
// Parameters:		Event *ev					- contains the real event to process
//
// Returns:			None
//----------------------------------------------------------------

void Entity::MultiplayerEvent( Event *ev )
{
	// Make sure we are in a multiplayer game

	if ( multiplayerManager.inMultiplayer() )
	{
		Event *event;
		str eventName;
		str token;
		int i;

		// Get the event name

		eventName = ev->GetString( 1 );

		event = new Event( eventName );

		// Get all of the event parms

		for ( i = 2 ; i <= ev->NumArgs() ; i++ )
		{
			event->AddToken( ev->GetToken( i ) );
		}

		// Process the event

		ProcessEvent( event );
	}
}


//--------------------------------------------------------------
//
// Name:			AddDamageModifier
// Class:			Entity
//
// Description:		Adds a new damage modifier to this entities list
//
// Parameters:		Event *ev
//
// Returns:			None
//
//--------------------------------------------------------------
void Entity::AddDamageModifier( Event *ev )
{
	str damagemodtype, value;
	float multiplier, chance = 1.0f, painBaseLine = 50.0f;

	damagemodtype = ev->GetString( 1 );
	value = ev->GetString( 2 );
	multiplier = ev->GetFloat( 3 );
	if ( ev->NumArgs() > 3 )
		chance = ev->GetFloat( 4 );
	if ( ev->NumArgs() > 4 )
		painBaseLine = ev->GetFloat( 5 );

	if ( !damageModSystem )
		damageModSystem = new DamageModificationSystem;

	damageModSystem->addDamageModifier(damagemodtype, value, multiplier, chance, painBaseLine );
}

//--------------------------------------------------------------
//
// Name:			ResolveDamage
// Class:			Entity
//
// Description:		Calls the DamageModificationSystem to resolve damage
//
// Parameters:		Damage &damage -- Reference to damage to modifiy
//
// Returns:			
//
//--------------------------------------------------------------
void Entity::ResolveDamage( ::Damage &damage )
{
	if ( damageModSystem )
		damageModSystem->resolveDamage(damage);
}

//--------------------------------------------------------------
// Name:		setMoveType()
// Class:		Entity
//
// Description:	Will convert a string to the appropriate moveType
//				and then call setMoveType( type )
//
// Parameters:	Event *ev
//
// Returns:		None
//--------------------------------------------------------------
void Entity::setMoveType( Event *ev )
{
	str type;
	type = ev->GetString( 1 );

	if ( !stricmp( type.c_str() , "none"			) )
		{
		velocity = vec_zero;
		setMoveType( MOVETYPE_NONE );
		}
	else if ( !stricmp( type.c_str() , "stationary" ) )
		setMoveType( MOVETYPE_STATIONARY );
	else if ( !stricmp( type.c_str() , "noclip"		) )
		setMoveType( MOVETYPE_NOCLIP );
	else if ( !stricmp( type.c_str() , "push"		) )
		setMoveType( MOVETYPE_PUSH );
	else if ( !stricmp( type.c_str() , "stop"		) )
		setMoveType( MOVETYPE_STOP );
	else if ( !stricmp( type.c_str() , "walk"		) )
		setMoveType( MOVETYPE_WALK );
	else if ( !stricmp( type.c_str() , "step"		) )
		setMoveType( MOVETYPE_STEP );
	else if ( !stricmp( type.c_str() , "fly"		) )
		setMoveType( MOVETYPE_FLY );
	else if ( !stricmp( type.c_str() , "toss"		) )
		setMoveType( MOVETYPE_TOSS );
	else if ( !stricmp( type.c_str() , "flymissile"	) )
		setMoveType( MOVETYPE_FLYMISSILE );
	else if ( !stricmp( type.c_str() , "bounce"		) )
		setMoveType( MOVETYPE_BOUNCE );
	else if ( !stricmp( type.c_str() , "slide"		) )
		setMoveType( MOVETYPE_SLIDE );
	else if ( !stricmp( type.c_str() , "rope"		) )
		setMoveType( MOVETYPE_ROPE );
	else if ( !stricmp( type.c_str() , "gib"		) )
		setMoveType( MOVETYPE_GIB );
	else if ( !stricmp( type.c_str() , "vehicle"	) )
		setMoveType( MOVETYPE_VEHICLE );
}


//===============================================================
// Name:		buildUseData
// Class:		Entity
//
// Description: Creates a usedata structure if need be.  Also
//				ensures the contents type of a usable object is
//				set to something that can be detected by the
//				use trace (so it can indeed be used).
//
//				Testing this idea out.
// 
// Parameters:	None
//
// Returns:		None
// 
//===============================================================
void Entity::buildUseData
(
	void
)
{
	if ( useData ) return ;

	useData = new UseData();
}


//--------------------------------------------------------------
// Name:		useDataAnim
// Class:		Entity
//
// Description:	Sets the useData anim member
//
// Parameters:	Event *ev
//
// Returns:		None
//--------------------------------------------------------------
void Entity::useDataAnim( Event *ev )
{
	buildUseData();	
	useData->setUseAnim(ev->GetString( 1 ));
}

//--------------------------------------------------------------
// Name:		useDataType
// Class:		Entity
//
// Description:	Sets the useData type member
//
// Parameters:	Event *ev
//
// Returns:		None
//--------------------------------------------------------------
void Entity::useDataType( Event *ev )
{
	buildUseData();	
	useData->setUseType(ev->GetString( 1 ));
}

//--------------------------------------------------------------
// Name:		useDataThread
// Class:		Entity
//
// Description:	Sets the useData thread member
//
// Parameters:	Event *ev
//
// Returns:		None
//--------------------------------------------------------------
void Entity::useDataThread( Event *ev )
{
	buildUseData();	
	useData->setUseThread(ev->GetString( 1 ));
}

//--------------------------------------------------------------
// Name:		useDataEvent
// Class:		Entity
//
// Description:	Sets the useData variables
//
// Parameters:	Event *ev
//
// Returns:		None
//--------------------------------------------------------------
void Entity::useDataEvent( Event *ev )
{
	buildUseData();	

	useData->setUseAnim(ev->GetString( 1 ));
	useData->setUseType(ev->GetString( 2 ));
	useData->setUseThread(ev->GetString( 3 ));
}

//--------------------------------------------------------------
// Name:		useDataMaxDist
// Class:		Entity
//
// Description:	Sets the maximum distance this entity can be used.
//
// Parameters:	Event *ev
//
// Returns:		None
//--------------------------------------------------------------
void Entity::useDataMaxDist( Event *ev )
{
	buildUseData();	
	useData->setUseMaxDist(ev->GetFloat( 1 ));
}

//--------------------------------------------------------------
// Name:		useDataCount
// Class:		Entity
//
// Description:	Sets the number of times this entity can be used.
//
// Parameters:	Event *ev
//
// Returns:		None
//--------------------------------------------------------------
void Entity::useDataCount( Event *ev )
{
	buildUseData();	
	useData->setUseCount(ev->GetInteger( 1 ));
}


//--------------------------------------------------------------
// Name:		setArchetype
// Class:		Entity
//
// Description:	Sets the archetype name for this entity
//
// Parameters:	Event *ev
//
// Returns:		None
//--------------------------------------------------------------
void Entity::setArchetype( Event *ev )
{
	_archetype = ev->GetString(1);

	//Sets the archetype index
	edict->s.archeTypeIndex = gi.archetypeindex(_archetype);
}


//--------------------------------------------------------------
// Name:		getArchetype
// Class:		Entity
//
// Description:	Gets the archetype name for this entity,
//
// Parameters:	None
//
// Returns:		const str
//--------------------------------------------------------------
const str Entity::getArchetype() const
{
	if ( _archetype.length() == 0 )
		return getName();

	return _archetype;
}

//-----------------------------------------------------
//
// Name:		setMissionObjective
// Class:		Entity
//
// Description:	Sets the entity to be a mission objective or not.
//
// Parameters:	ev 
//
// Returns:		None
//-----------------------------------------------------
void Entity::setMissionObjective(Event* ev)
{
	_missionObjective = ev->GetBoolean(1);
	edict->s.missionObjective = ev->GetBoolean(1);
	if( edict->s.missionObjective )
	{
		G_AddEntityToExtraList(entnum);
	}
	else
	{
		G_RemoveEntityFromExtraList(entnum);
	}
}


//--------------------------------------------------------------
// Name:		GetVelocity
// Class:		Entity
//
// Description:	Gets the Velocity of the Entity
//
// Parameters:	Event *ev
//
// Returns:		None
//--------------------------------------------------------------
void Entity::GetVelocity( Event *ev )
{
	ev->ReturnVector( velocity );
}

//--------------------------------------------------------------
// Name:		SetVelocity
// Class:		Entity
//
// Description: Sets the Velocity of the Entity
//
// Parameters:	Event *ev
//
// Returns:		None
//--------------------------------------------------------------
void Entity::SetVelocity( Event *ev )
{
	velocity = ev->GetVector( 1 );
}

void Entity::startStasis( Event *ev )
{
	startStasis();
}

void Entity::stopStasis( Event *ev )
{
	stopStasis();
}

void Entity::startStasis( void )
{
	// Immobilize the character

	flags |= FL_IMMOBILE;
	flags |= FL_STUNNED;

	// Show an effect

	setCustomShader( "stasis" );

	if ( animate )
	{
		animate->StopAnimating();

		if ( edict->s.torso_anim & ANIM_BLEND )
			animate->StopAnimating( torso );
	}
}

void Entity::stopStasis( void )
{
	// Unimmobilize the character

	flags &= ~FL_IMMOBILE;
	flags &= ~FL_STUNNED;

	// Stop the effect

	clearCustomShader( "stasis" );

	if ( this->isSubclassOf( Actor ) )
	{
		Actor *actor = (Actor *)this;

		actor->resetStateMachine();
	}
	else if ( this->isSubclassOf( Player ) )
	{
		Player *player = (Player *)this;

		player->SetState("STAND", "START");
	}

}

void Entity::setTargetPos( Event *ev )
{
	setTargetPos( ev->GetString( 1 ) );
}

void Entity::setTargetPos( const str &targetPos )
{
	_targetPos = targetPos;
}

str	Entity::getTargetPos()
{
	return _targetPos;
}

void Entity::addHealthOverTime( Event *ev )
{
	Event *event;
	float healthToAdd;
	float healthToAddThisFrame;
	float timeLeft;
	int numFrames;

	healthToAdd = ev->GetFloat( 1 );
	timeLeft = ev->GetFloat( 2 );

	// Figure out how much health to add this frame

	if ( timeLeft < level.frametime )
		numFrames = 1;
	else
		numFrames = (int) (timeLeft / level.frametime);

	healthToAddThisFrame = healthToAdd / numFrames;

	// Actually add the health to the entity

	addHealth( healthToAddThisFrame );

	// Post the event for the next frame

	healthToAdd -= healthToAddThisFrame;
	timeLeft -= level.frametime;

	//CancelEventsOfType( EV_AddHealthOverTime );

	if ( timeLeft > 0.0f )
	{
		event = new Event( EV_AddHealthOverTime );
		event->AddFloat( healthToAdd );
		event->AddFloat( timeLeft );
		PostEvent( event, level.frametime );
	}
}

void Entity::simplePlayDialog( Event *ev )
{
	str dialogName;
	float volume   = DEFAULT_VOL;
	float min_dist = DEFAULT_MIN_DIST;
	char localizedDialogName[MAX_QPATH];
	Player *player;


	// Get all of the parms

	dialogName = ev->GetString( 1 );

	if ( ev->NumArgs() > 1 )
		volume = ev->GetFloat( 2 );

	if ( ev->NumArgs() > 2 )
	{
		str minDistString;

		min_dist = ev->GetFloat( 3 );

		minDistString = ev->GetString( 3 );

		if ( stricmp( minDistString.c_str(), LEVEL_WIDE_STRING ) == 0 )
			min_dist = LEVEL_WIDE_MIN_DIST;
		else
			min_dist = ev->GetFloat( 3 );

		if ( min_dist >= LEVEL_WIDE_MIN_DIST_CUTOFF )
			min_dist = LEVEL_WIDE_MIN_DIST;
	}

	// Get the localized name of the dialog

	gi.LocalizeFilePath( dialogName.c_str(), localizedDialogName );

	// Play the sound

	Sound( localizedDialogName, CHAN_DIALOG, volume, min_dist );

	// Tell the player about the dialog

	player = GetPlayer( 0 );
	
	if ( player )
	{
		player->SetupDialog( NULL, localizedDialogName );
	}
}

void Entity::warp( Event *ev )
{
	Entity *ent;
	int i;

	if ( ev->NumArgs() > 0 )
		setOrigin( ev->GetVector( 1 ) );
	else
		setOrigin();

	setAngles();

	NoLerpThisFrame();

	if ( bind_info )
	{
		// Make sure everyone bound to us doesn't lerp

		for( ent = bind_info->teamchain; ent != NULL; ent = ent->bind_info->teamchain )
		{
			if ( ent->bind_info->teammaster == this )
			{
				ent->ProcessEvent( EV_Warp );
			}
		}

		// Make sure everyone attached bound to us doesn't lerp

		for( i = 0; i < MAX_MODEL_CHILDREN ; i++ )
		{
			if ( bind_info->children[ i ] == ENTITYNUM_NONE )
			{
				continue;
			}
			
			ent = G_GetEntity( bind_info->children[ i ] );

			if ( ent )
			{
				ent->ProcessEvent( EV_Warp );
			}
		}
	}
}

void Entity::traceHitsEntity( Event *ev )
{
	trace_t	trace;
	Vector end;
	Vector start;
	Vector dir;
	str tagName;
	float length;
	Entity *entityToCheck;


	// Get the event info

	tagName = ev->GetString( 1 );
	length = ev->GetFloat( 2 );
	entityToCheck = ev->GetEntity( 3 );

	// Determine the start and end point of the trace

	GetTag( tagName, &start, &dir );

	end = start + dir * length;

	// Do the actual trace

	trace = G_Trace( start, vec_zero, vec_zero, end, NULL, MASK_SHOT, false, "traceHitsEntity" );

	// Determine if we hit this entity

	if ( trace.ent && entityToCheck && trace.ent->entity == entityToCheck )
		ev->ReturnFloat( 1.0f );
	else
		ev->ReturnFloat( 0.0f );
}

void Entity::setOriginEveryFrame( Event *ev )
{
	Event *repost;
	repost = new Event(EV_SetOriginEveryFrame);

	setOrigin();

	PostEvent( repost , FRAMETIME );
	
}

void Entity::isWithinDistanceOf( Event *ev )
{
	Entity *destination;
	float distance;
	float returnValue;

	destination = ev->GetEntity( 1 );
	distance = ev->GetFloat( 2 );
	returnValue = 0.0f;

	if ( WithinDistance( destination , distance ) )
		returnValue = 1.0;

	ev->ReturnFloat( returnValue );
}

void Entity::setNetworkDetail( Event *ev )
{
	_networkDetail = true;
}

bool Entity::isNetworkDetail( void )
{
	return _networkDetail;
}