// Copyright (C) 1999-2000 Id Software, Inc.
//

#include "g_active.h"
#include "g_client.h"
#include "g_spawn.h"
#include "g_cmds.h"
#include "g_items.h"
#include "g_combat.h"
#include "g_lua.h"
#include "g_mover.h"
#include "g_syscalls.h"
#include "g_logger.h"

extern void ammo_station_finish_spawning(gentity_t *self);

/*
==============
TryUse
==============
*/

static const double USE_DISTANCE = 64.0;
/**
*	Try and use an entity in the world, directly ahead of us
*/
static void TryUse(gentity_t* ent)
{
  gentity_t* target;
  trace_t		trace;
  vec3_t		src, dest, vf;
  clientSession_t* sess;

  if(ent == NULL)
  {
    return;
  }

  sess = &ent->client->sess;

  VectorCopy(ent->r.currentOrigin, src);
  src[2] += ent->client->ps.viewheight * ent->client->pers.pms_height; //TiM - include height offset for tall players

  AngleVectors(ent->client->ps.viewangles, vf, NULL, NULL);

  //extend to find end of use trace
  VectorMA(src, -6, vf, src);//in case we're inside something?
  VectorMA(src, 134, vf, dest);//128+6

  //Trace ahead to find a valid target
  memset(&trace, 0, sizeof(trace_t));
  trap_Trace(&trace, src, vec3_origin, vec3_origin, dest, ent->s.number, MASK_OPAQUE | CONTENTS_BODY | CONTENTS_ITEM | CONTENTS_CORPSE);

  if(trace.fraction == 1.0f || trace.entityNum < 0)
  {
    //FIXME: Play a failure sound
    return;
  }

  target = &g_entities[trace.entityNum];

  //Check for a use command
  if((target != NULL) && (target->use != NULL) && (target->type == EntityType::ENT_FUNC_USABLE))
  {//usable brush
    if(target->team && atoi(target->team) != 0)
    {//usable has a team
      if(atoi(target->team) != sess->sessionTeam)
      {//not on my team
        //TiM - return
        return;
      }
    }
    //FIXME: play sound?
    target->use(target, ent, ent);
#ifdef G_LUA
    if(target->luaUse)
      LuaHook_G_EntityUse(target->luaUse, target - g_entities, ent - g_entities, ent - g_entities);
#endif
    return;
  }
  else if((target != NULL) && (target->use != NULL) && (ent->type == EntityType::ENT_MISC_AMMOSTATION))
  {//ammo station
    if(sess->sessionTeam)
    {
      if(target->team)
      {
        if(atoi(target->team) != sess->sessionTeam)
        {
          //FIXME: play sound?
          return;
        }
      }
    }
    target->use(target, ent, ent);
#ifdef G_LUA
    if(target->luaUse)
      LuaHook_G_EntityUse(target->luaUse, target - g_entities, ent - g_entities, ent - g_entities);
#endif
    return;
  }
  else if((target && target->s.number == ENTITYNUM_WORLD) || (target->s.pos.trType == TR_STATIONARY && !(trace.surfaceFlags & SURF_NOIMPACT) && !target->takedamage))
  {
    return;
  }
  //FIXME: Play a failure sound
}

/*
===============
P_DamageFeedback
===============
*/
/**
*	Called just before a snapshot is sent to the given player.
*	Totals up all damage and generates both the player_state_t
*	damage values to that client for pain blends and kicks, and
*	global pain sound events for all clients.
*/
static void P_DamageFeedback(gentity_t* player)
{
  gclient_t* client;
  float	count;
  vec3_t	angles;
  playerState_t* ps;

  client = player->client;
  ps = &client->ps;
  if(client->ps.pm_type == PM_DEAD)
  {
    return;
  }

  // total points of damage shot at the player this frame
  count = client->damage_blood + client->damage_armor;
  if(count == 0)
  {
    return;		// didn't take any damage
  }

  if(count > 255)
  {
    count = 255;
  }

  // send the information to the client

  // world damage (falling, slime, etc) uses a special code
  // to make the blend blob centered instead of positional
  if(client->damage_fromWorld)
  {
    ps->damagePitch = 255;
    ps->damageYaw = 255;

    client->damage_fromWorld = qfalse;
  }
  else
  {
    vectoangles(client->damage_from, angles);
    ps->damagePitch = angles[PITCH] / 360.0 * 256;
    ps->damageYaw = angles[YAW] / 360.0 * 256;
  }

  // play an apropriate pain sound
  if((level.time > player->pain_debounce_time) && !(player->flags & FL_GODMODE))
  {
    player->pain_debounce_time = level.time + 700;
    G_AddEvent(player, EV_PAIN, player->health);
    ps->damageEvent++;
  }

  ps->damageCount = client->damage_blood;
  if(ps->damageCount > 255)
  {
    ps->damageCount = 255;
  }

  ps->damageShieldCount = client->damage_armor;
  if(ps->damageShieldCount > 255)
  {
    ps->damageShieldCount = 255;
  }

  //
  // clear totals
  //
  client->damage_blood = 0;
  client->damage_armor = 0;
  client->damage_knockback = 0;
}



/*
=============
P_WorldEffects
=============
*/
/**
*	Check for lava / slime contents and drowning
*/
static void P_WorldEffects(gentity_t *ent)
{
  int32_t waterlevel;

  if(ent->client->noclip)
  {
    ent->client->airOutTime = level.time + 12000;	// don't need air
    return;
  }

  waterlevel = ent->waterlevel;

  //
  // check for drowning
  //
  if(waterlevel == 3 && !(ent->watertype&CONTENTS_LADDER))
  {
    // envirosuit give air, techs can't drown
    if(g_classData[ent->client->sess.sessionClass].isMarine)
    {
      ent->client->airOutTime = level.time + 10000;
    }

    // if out of air, start drowning
    if(ent->client->airOutTime < level.time)
    {
      // drown!
      ent->client->airOutTime += 1000;
      if(ent->health > 1)
      { //TiM : used to be 0, but to fix red's medic code
// take more damage the longer underwater
        ent->damage += 2;
        if(ent->damage > 15)
          ent->damage = 15;

        // play a gurp sound instead of a normal pain sound
        if(ent->health <= ent->damage)
        {
          G_Sound(ent, G_SoundIndex("*drown.wav"));
        }
        else if(rand() & 1)
        {
          G_Sound(ent, G_SoundIndex("sound/player/gurp1.wav"));
        }
        else
        {
          G_Sound(ent, G_SoundIndex("sound/player/gurp2.wav"));
        }

        // don't play a normal pain sound
        ent->pain_debounce_time = level.time + 200;

        G_Combat_Damage(ent, NULL, NULL, NULL, NULL,
          ent->damage, DAMAGE_NO_ARMOR, MOD_WATER);
      }
    }
  }
  else
  {
    ent->client->airOutTime = level.time + 12000;
    ent->damage = 2;
  }

  //
  // check for sizzle damage (move to pmove?)
  //
  if(waterlevel &&
    (ent->watertype&(CONTENTS_LAVA | CONTENTS_SLIME)))
  {
    if(ent->health > 0
      && ent->pain_debounce_time < level.time)
    {

      if(ent->watertype & CONTENTS_LAVA)
      {
        G_Combat_Damage(ent, NULL, NULL, NULL, NULL,
          30 * waterlevel, 0, MOD_LAVA);
      }

      if(ent->watertype & CONTENTS_SLIME)
      {
        G_Combat_Damage(ent, NULL, NULL, NULL, NULL,
          10 * waterlevel, 0, MOD_SLIME);
      }
    }
  }
}



/*
===============
G_SetClientSound
===============
*/
static void G_SetClientSound(gentity_t *ent)
{	// 3/28/00 kef -- this is dumb.
  if(ent->waterlevel && (ent->watertype&(CONTENTS_LAVA | CONTENTS_SLIME)))
    ent->s.loopSound = level.snd_fry;
  else
    ent->s.loopSound = 0;
}



//==============================================================

/*
==============
ClientImpacts
==============
*/
static void ClientImpacts(gentity_t* ent, pmove_t* pm)
{
  int32_t	i, j;
  trace_t	trace;
  gentity_t* other;

  memset(&trace, 0, sizeof(trace));
  for(i = 0; i < pm->numtouch; i++)
  {
    for(j = 0; j < i; j++)
    {
      if(pm->touchents[j] == pm->touchents[i])
      {
        break;
      }
    }
    if(j != i)
    {
      continue;	// duplicated
    }
    other = &g_entities[pm->touchents[i]];

    if((ent->r.svFlags & SVF_BOT) && (ent->touch))
    {
      ent->touch(ent, other, &trace);
    }

    if(!other->touch)
    {
      continue;
    }

    other->touch(other, ent, &trace);
  }

}

void G_TouchTriggers(gentity_t *ent)
{
  int32_t		i, num;
  int32_t		touch[MAX_GENTITIES];
  gentity_t	*hit;
  trace_t		trace;
  vec3_t		mins, maxs;
  vec3_t	range = { 40, 40, 52 };
  playerState_t *ps;

  if(ent == NULL || ent->client == NULL)
  {
    return;
  }

  ps = &ent->client->ps;

  // dead clients don't activate triggers!
  if(ps->stats[STAT_HEALTH] <= 0)
  {
    return;
  }

  VectorSubtract(ps->origin, range, mins);
  VectorAdd(ps->origin, range, maxs);

  num = trap_EntitiesInBox(mins, maxs, touch, MAX_GENTITIES);

  // can't use ent->absmin, because that has a one unit pad
  VectorAdd(ps->origin, ent->r.mins, mins);
  VectorAdd(ps->origin, ent->r.maxs, maxs);

  for(i = 0; i < num; i++)
  {
    hit = &g_entities[touch[i]];

#ifdef G_LUA
    if(hit->luaTouch)
    {
      LuaHook_G_EntityTouch(hit->luaTouch, hit->s.number, ent->s.number);
    }
#endif

    if(!hit->touch && !ent->touch)
    {
      continue;
    }
    if(!(hit->r.contents & CONTENTS_TRIGGER))
    {
      continue;
    }

    // ignore most entities if a spectator
    if(ent->client->sess.sessionTeam == TEAM_SPECTATOR)
    {
      // this is ugly but adding a new ET_? type will
      // most likely cause network incompatibilities
      if(hit->s.eType != ET_TELEPORT_TRIGGER && hit->touch != G_Mover_TouchDoorTrigger)
      {
        continue;
      }
    }

    // use seperate code for determining if an item is picked up
    // so you don't have to actually contact its bounding box
    if(hit->s.eType == ET_ITEM)
    {
      if(!BG_PlayerTouchesItem(&ent->client->ps, &hit->s, level.time))
      {
        continue;
      }
    }
    else
    {
      if(!trap_EntityContact(mins, maxs, hit))
      {
        continue;
      }
    }

    memset(&trace, 0, sizeof(trace));

    if(hit->touch)
    {
      hit->touch(hit, ent, &trace);
    }

    if((ent->r.svFlags & SVF_BOT) && (ent->touch))
    {
      ent->touch(ent, hit, &trace);
    }
  }
}

/*
=================
SpectatorThink
=================
*/
static void SpectatorThink(gentity_t* ent, usercmd_t* ucmd)
{
  pmove_t	pm;
  gclient_t* client;

  client = ent->client;

  if(client->sess.spectatorState != SPECTATOR_FOLLOW)
  {
    client->ps.pm_type = PM_SPECTATOR;
    client->ps.speed = 400;	// faster than normal

    // set up for pmove
    memset(&pm, 0, sizeof(pm));
    pm.ps = &client->ps;
    pm.cmd = *ucmd;
    pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;	// spectators can fly through bodies
    pm.trace = trap_Trace;
    pm.pointcontents = trap_PointContents;

    // perform a pmove
    Pmove(&pm);

    // save results of pmove
    VectorCopy(client->ps.origin, ent->s.origin);

    G_TouchTriggers(ent);
    trap_UnlinkEntity(ent);
  }

  client->oldbuttons = client->buttons;
  client->buttons = ucmd->buttons;

  // attack button cycles through spectators
  if((client->buttons & BUTTON_ATTACK) && !(client->oldbuttons & BUTTON_ATTACK))
  {
    Cmd_FollowCycle_f(ent, 1);
  }
  else if((client->buttons & BUTTON_ALT_ATTACK) && !(client->oldbuttons & BUTTON_ALT_ATTACK))
  {
    if(ent->client->sess.spectatorState == SPECTATOR_FOLLOW)
    {
      StopFollowing(ent);
    }
  }
}



/*
=================
ClientInactivityTimer
=================
*/
/**
*	Returns qfalse if the client is dropped
*/
static qboolean ClientInactivityTimer(gclient_t *client)
{
  usercmd_t *cmd = &client->pers.cmd;

  if(g_inactivity.integer == 0)
  {
    // give everyone some time, so if the operator sets g_inactivity during
    // gameplay, everyone isn't kicked
    client->inactivityTime = level.time + 60 * 1000;
    client->inactivityWarning = qfalse;
  }
  else if(cmd->forwardmove ||
    cmd->rightmove ||
    cmd->upmove ||
    (cmd->buttons & BUTTON_ATTACK) ||
    (cmd->buttons & BUTTON_ALT_ATTACK))
  {
    client->inactivityTime = level.time + g_inactivity.integer * 1000;
    client->inactivityWarning = qfalse;
  }
  else if(!client->pers.localClient)
  {
    if(level.time > client->inactivityTime)
    {
      trap_DropClient(client - level.clients, "Dropped due to inactivity");
      return qfalse;
    }
    if(level.time > client->inactivityTime - 10000 && !client->inactivityWarning)
    {
      client->inactivityWarning = qtrue;
      trap_SendServerCommand(client - level.clients, "cp \"Ten seconds until inactivity drop!\n\"");
    }
  }
  return qtrue;
}


/*
==================
TimedMessage

RPG-X - RedTechie: Returns the message requested.
If the message is blank go to next. (Based off of SFEFMOD)

TiM: Huh... O_o.  Damn Red, you're right.  If the admin
puts in values, but not in a consistent consecutive order,
we'll get some mighty painful errors. >.<

I guess what we really need is a for loop that goes
thru, and checks to see if each and every CVAR has a value
currently in it....
==================
*/

/**
*	\author Ubergames
*/
std::string TimedMessage()
{
  if(level.timedMessages.empty())
  {
    return "^1RPG-X ERROR: No messages to display";
  }

  if(level.timedMessageIndex >= level.timedMessages.size())
  {
    level.timedMessageIndex = 0;
  }

  auto message = level.timedMessages.at(level.timedMessageIndex);
  level.timedMessageIndex++;
  return message;
}


/*
==================
ClientTimerActions
==================
*/
/**
*	Actions that happen once a second
*/
static void ClientTimerActions(gentity_t* ent, int32_t msec)
{
  gclient_t* client;
  float messageTime;

  client = ent->client;
  client->timeResidual += msec;

  if(rpg_timedmessagetime.value > 0.0f)
  {
    //Make sure its not less then one //TiM: Well... we can have under 1, just not toooo far under 1

    if(rpg_timedmessagetime.value < 0.2f)
    { //1
      messageTime = 0.2f;
    }
    else
    {
      messageTime = rpg_timedmessagetime.value;
    }

    if(level.time > (level.message + (messageTime * 60000)))
    {
      level.message = level.time;

      //TiM - There.  So with this working in conjunction with that reset
      //code above, this should be more efficient. :)
      auto message = "cp \"" + TimedMessage() + "\n\""; //Since we're working with a gloabl scope variable, there's no need for this thing to have parameters:)
      trap_SendServerCommand(-1, message.c_str());  //Shows the message on their main screen
    }
  }



  while(client->timeResidual >= 1000)
  {
    client->timeResidual -= 1000;

    if(ent->health > client->ps.stats[STAT_MAX_HEALTH])
    {
      ent->health--;
    }

    // NOW IT ONCE AGAIN counts down armor when over max, once per second
    if(client->ps.stats[STAT_ARMOR] > client->ps.stats[STAT_MAX_HEALTH])
    {
      client->ps.stats[STAT_ARMOR]--;
    }

    if(!client->ps.stats[STAT_HOLDABLE_ITEM])
    {//holding nothing...
      if(client->ps.stats[STAT_USEABLE_PLACED] > 0)
      {//we're in some kind of countdown
        //so count down
        client->ps.stats[STAT_USEABLE_PLACED]--;
      }
    }

  }
}

/*
====================
ClientIntermissionThink
====================
*/
static void ClientIntermissionThink(gclient_t* client)
{
  client->ps.eFlags &= ~EF_TALK;
  client->ps.eFlags &= ~EF_FIRING;

  // the level will exit when everyone wants to or after timeouts

  // swap and latch button actions
  client->oldbuttons = client->buttons;
  client->buttons = client->pers.cmd.buttons;
  if(g_gametype.integer != GT_SINGLE_PLAYER)
  {
    if(client->buttons & (BUTTON_ATTACK | BUTTON_USE_HOLDABLE) & (client->oldbuttons ^ client->buttons))
    {
      client->readyToExit = (qboolean)(!client->readyToExit);
    }
  }
}



typedef struct detHit_s
{
  gentity_t*	detpack;
  gentity_t*	player;
  int32_t		time;
} detHit_t;

enum g_activeDetPackLimits_e
{
  MAX_DETHITS = 32		// never define this to be 0
};

static detHit_t	detHits[MAX_DETHITS];
static qboolean	bDetInit = qfalse;

//-----------------------------------------------------------------------------DECOY TEMP
extern qboolean FinishSpawningDecoy(gentity_t* ent, int32_t itemIndex);
//-----------------------------------------------------------------------------DECOY TEMP

static const uint16_t DETPACK_DAMAGE = 750;
static const uint16_t DETPACK_RADIUS = 500;

void detpack_shot(gentity_t* self, gentity_t* inflictor, gentity_t* attacker, int32_t damage, int32_t meansOfDeath)
{
  int32_t i = 0;
  gentity_t *ent = NULL;

  //so we can't be blown up by things we're blowing up
  self->takedamage = qfalse;

  G_TempEntity(self->s.origin, EV_GRENADE_EXPLODE);
  G_Combat_RadiusDamage(self->s.origin, self->parent ? self->parent : self, DETPACK_DAMAGE*0.125, DETPACK_RADIUS*0.25,
    self, DAMAGE_ALL_TEAMS, MOD_DETPACK);
  // we're blowing up cuz we've been shot, so make sure we remove ourselves
  //from our parent's inventory (so to speak)
  for(i = 0; i < MAX_CLIENTS; i++)
  {
    if(((ent = &g_entities[i]) != NULL) && ent->inuse && (self->parent == ent))
    {
      ent->client->ps.stats[STAT_USEABLE_PLACED] = 0;
      ent->client->ps.stats[STAT_HOLDABLE_ITEM] = 0;
      break;
    }
  }
  G_FreeEntity(self);
}

/**
*	Place the detpack
*/
static qboolean PlaceDetpack(gentity_t* ent)
{
  gentity_t*		detpack = NULL;
  static gitem_t* detpackItem = NULL;
  float			detDistance = 80;
  trace_t			tr;
  vec3_t			fwd;
  vec3_t			right;
  vec3_t			up;
  vec3_t			end;
  vec3_t			mins = { -16, -16, -16 };
  vec3_t			maxs = { 16, 16, 16 };
  playerState_t* ps = &ent->client->ps;

  if(detpackItem == NULL)
  {
    detpackItem = BG_FindItemForHoldable(HI_DETPACK);
  }

  // make sure our detHit info is init'd
  if(bDetInit == qfalse)
  {
    memset(detHits, 0, MAX_DETHITS * sizeof(detHit_t));
    bDetInit = qtrue;
  }

  // can we place this in front of us?
  AngleVectors(ps->viewangles, fwd, right, up);
  fwd[2] = 0;
  VectorMA(ps->origin, detDistance, fwd, end);
  memset(&tr, 0, sizeof(trace_t));
  trap_Trace(&tr, ps->origin, mins, maxs, end, ent->s.number, MASK_SHOT);
  if(tr.fraction > 0.9)
  {
    // got enough room so place the detpack
    detpack = G_Spawn();
    G_SpawnItem(detpack, detpackItem);
    detpack->physicsBounce = 0.0f;//detpacks are *not* bouncy
    VectorMA(ps->origin, detDistance + mins[0], fwd, detpack->s.origin);
    if(FinishSpawningDetpack(detpack, detpackItem - bg_itemlist) == qfalse)
    {
      return qfalse;
    }
    VectorNegate(fwd, fwd);
    vectoangles(fwd, detpack->s.angles);
    detpack->think = DetonateDetpack;
    detpack->nextthink = level.time + 120000;	// if not used after 2 minutes it blows up anyway
    detpack->parent = ent;
    return qtrue;
  }
  else
  {
    // no room
    return qfalse;
  }
}

/**
*	Was a player hit by a detpack.
*/
static qboolean PlayerHitByDet(gentity_t* det, gentity_t* player)
{
  int32_t i = 0;

  if(!bDetInit)
  {
    // detHit stuff not initialized. who knows what's going on?
    return qfalse;
  }
  for(i = 0; i < MAX_DETHITS; i++)
  {
    if((detHits[i].detpack == det) && (detHits[i].player == player))
    {
      return qtrue;
    }
  }
  return qfalse;
}

/**
*	Addes a player to the detpack hits
*/
static void AddPlayerToDetHits(gentity_t* det, gentity_t* player)
{
  int32_t		i = 0;
  detHit_t*	lastHit = NULL;
  detHit_t*	curHit = NULL;

  for(i = 0; i < MAX_DETHITS; i++)
  {
    if(0 == detHits[i].time)
    {
      // empty slot. add our player here.
      detHits[i].detpack = det;
      detHits[i].player = player;
      detHits[i].time = level.time;
    }
    lastHit = &detHits[i];
  }
  // getting here means we've filled our list of detHits, so begin recycling them, starting with the oldest hit.
  curHit = &detHits[0];
  while(lastHit->time < curHit->time)
  {
    lastHit = curHit;
    curHit++;
    // just a safety check here
    if(curHit == &detHits[0])
    {
      break;
    }
  }
  curHit->detpack = det;
  curHit->player = player;
  curHit->time = level.time;
}

/**
*	Clear the hits for this detpack
*/
static void ClearThisDetpacksHits(gentity_t* det)
{
  int32_t	i = 0;

  for(i = 0; i < MAX_DETHITS; i++)
  {
    if(detHits[i].detpack == det)
    {
      detHits[i].player = NULL;
      detHits[i].detpack = NULL;
      detHits[i].time = 0;
    }
  }
}

static void DetpackBlammoThink(gentity_t* ent)
{
  int32_t		i = 0;
  int32_t		lifetime = 3000;	// how long (in msec) the shockwave lasts
  int32_t		knockback = 400;
  float		curBlastRadius = 50.0 * ent->count;
  float		radius = 0;
  vec3_t		vTemp;
  trace_t		tr;
  gentity_t*	pl = NULL;

  if(ent->count++ > (lifetime*0.01))
  {
    ClearThisDetpacksHits(ent);
    G_FreeEntity(ent);
    return;
  }

  // get a list of players within the blast radius at this time.
  // only hit the ones we can see from the center of the explosion.
  for(i = 0; i < MAX_CLIENTS; i++)
  {
    if(g_entities[i].client && g_entities[i].takedamage)
    {
      pl = &g_entities[i];
      VectorSubtract(pl->s.pos.trBase, ent->s.origin, vTemp);
      radius = VectorNormalize(vTemp);
      if((radius <= curBlastRadius) && !PlayerHitByDet(ent, pl))
      {
        // within the proper radius. do we have LOS to the player?
        memset(&tr, 0, sizeof(trace_t));
        trap_Trace(&tr, ent->s.origin, NULL, NULL, pl->s.pos.trBase, ent->s.number, MASK_SHOT);
        if(tr.entityNum == i)
        {
          // oh yeah. you're gettin' hit.
          AddPlayerToDetHits(ent, pl);
          VectorMA(pl->client->ps.velocity, knockback, vTemp, pl->client->ps.velocity);
          // make sure the player goes up some
          if(pl->client->ps.velocity[2] < 100)
          {
            pl->client->ps.velocity[2] = 100;
          }
          if(!pl->client->ps.pm_time)
          {
            int32_t	t;

            t = knockback * 2;
            if(t < 50)
            {
              t = 50;
            }
            if(t > 200)
            {
              t = 200;
            }
            pl->client->ps.pm_time = t;
            pl->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
          }
        }
      }
    }
  }

  ent->nextthink = level.time + FRAMETIME;
}

/**
*	Detonate a detpack
*/
void DetonateDetpack(gentity_t *ent)
{
  // find all detpacks. the one whose parent is ent...blow up
  gentity_t*	detpack = NULL;
  char*		classname = BG_FindClassnameForHoldable(HI_DETPACK);

  if(classname == NULL)
  {
    return;
  }

  while((detpack = G_Find(detpack, FOFS(classname), classname)) != NULL)
  {
    if(detpack->parent == ent)
    {
      // found it. BLAMMO!
      // play explosion sound to all clients
      gentity_t	*te = NULL;

      te = G_TempEntity(detpack->s.pos.trBase, EV_GLOBAL_SOUND);
      te->s.eventParm = G_SoundIndex("sound/weapons/explosions/detpakexplode.wav");//cgs.media.detpackExplodeSound
      te->r.svFlags |= SVF_BROADCAST;

      //so we can't be blown up by things we're blowing up
      detpack->takedamage = qfalse;

      G_AddEvent(detpack, EV_DETPACK, 0);
      G_Combat_RadiusDamage(detpack->s.origin, detpack->parent, DETPACK_DAMAGE, DETPACK_RADIUS,
        detpack, DAMAGE_HALF_NOTLOS | DAMAGE_ALL_TEAMS, MOD_DETPACK);
      // just turn the model invisible and let the entity think for a bit to deliver a shockwave
      //G_FreeEntity(detpack);
      detpack->classname = NULL;
      detpack->s.modelindex = 0;
      detpack->think = DetpackBlammoThink;
      detpack->count = 1;
      detpack->nextthink = level.time + FRAMETIME;
      return;
    }
    else if(detpack == ent)	// if detpack == ent, we're blowing up this detpack cuz it's been sitting too long
    {
      detpack_shot(detpack, NULL, NULL, 0, 0);
      return;
    }
  }
  // hmm. couldn't find it.
  detpack = NULL;
}





static const uint8_t SHIELD_HEALTH = 250;
static const uint8_t SHIELD_HEALTH_DEC = 10;		// 25 seconds
static const uint16_t MAX_SHIELD_HEIGHT = 1022; //254
static const uint16_t MAX_SHIELD_HALFWIDTH = 1023; //255
static const uint8_t SHIELD_HALFTHICKNESS = 4;
static const uint8_t SHIELD_PLACEDIST = 64;


static qhandle_t	shieldAttachSound = 0;
static qhandle_t	shieldActivateSound = 0;
static qhandle_t	shieldDamageSound = 0;
//RPG-X: - RedTechie Added shild ZAPZPZAAAAAAppPPP sound!
static qhandle_t	shieldMurderSound = 0;
static qhandle_t	shieldDeactivateSound = 0;

void G_Active_ShieldRemove(gentity_t* self)
{
  self->think = G_FreeEntity;
  self->nextthink = level.time + 300;

  self->s.eFlags |= EF_ITEMPLACEHOLDER;

  // Play raising sound...
  G_AddEvent(self, EV_GENERAL_SOUND, shieldDeactivateSound);

  return;
}


/**
*	The think function of a forcefield
*	Does not do much anymore, once, counted down the health of a forcefield and removed
*	it when healt got equal or below zero.
*/
void ShieldThink(gentity_t* self)
{
  self->s.eFlags &= ~(EF_ITEMPLACEHOLDER | EF_NODRAW);
  self->nextthink = 0;

  return;
}

/**
*	The shield was damaged to below zero health.
*/
void ShieldDie(gentity_t* self, gentity_t* inflictor, gentity_t* attacker, int32_t damage, int32_t mod)
{
  // Play damaging sound...
  G_AddEvent(self, EV_GENERAL_SOUND, shieldDamageSound);

  G_Active_ShieldRemove(self);
}


/**
*	The shield had damage done to it.  Make it flicker.
*/
void ShieldPain(gentity_t* self, gentity_t* attacker, int32_t damage)
{
  // Set the itemplaceholder flag to indicate the the shield drawing that the shield pain should be drawn.
  self->s.eFlags |= EF_ITEMPLACEHOLDER;
  self->think = ShieldThink;
  self->nextthink = level.time + 400;

  // Play damaging sound...
  G_AddEvent(self, EV_GENERAL_SOUND, shieldDamageSound);

  return;
}


/**
*	Try to turn the shield back on after a delay.
*/
void ShieldGoSolid(gentity_t* self)
{
  trace_t	tr;

  if(self->health <= 0)
  {
    G_Active_ShieldRemove(self);
    return;
  }

  memset(&tr, 0, sizeof(trace_t));
  trap_Trace(&tr, self->r.currentOrigin, self->r.mins, self->r.maxs, self->r.currentOrigin, self->s.number, CONTENTS_BODY);
  if(tr.startsolid)
  {	// gah, we can't activate yet
    self->nextthink = level.time + 200;
    self->think = ShieldGoSolid;
    trap_LinkEntity(self);
  }
  else
  { // get hard... huh-huh...
    self->r.contents = CONTENTS_SOLID;
    self->s.eFlags &= ~(EF_ITEMPLACEHOLDER);
    self->nextthink = level.time + 1000;
    self->think = ShieldThink;
    self->takedamage = qtrue;//RPG-X: - RedTechie use to be qtrue //TiM - made true again. should be okay so long as the health isn't decremented

    trap_LinkEntity(self);
  }

  return;
}

/**
*	Turn the shield off to allow a friend to pass through.
*/
//RPG-X J2J EDIT here:
void ShieldGoNotSolid(gentity_t* self)
{
  // make the shield non-solid very briefly
  self->r.contents = CONTENTS_NONE;

  // nextthink needs to have a large enough interval to avoid excess accumulation of Activate messages
  self->nextthink = level.time + 200;
  self->think = ShieldGoSolid;

  //TiM - Make the field visible
  self->s.eFlags |= EF_ITEMPLACEHOLDER;

  self->takedamage = qfalse;
  trap_LinkEntity(self);

  // Play raising sound...
  G_AddEvent(self, EV_GENERAL_SOUND, shieldActivateSound);
}


/**
*	Somebody (a player) has touched the shield.  See if it is a "friend".
*/
void ShieldTouch(gentity_t* self, gentity_t* other, trace_t* trace)
{
  if(other == NULL || other->client == NULL)
    return;

  if(G_Client_IsAdmin(other) || (rpg_borgAdapt.integer && rpg_borgMoveThroughFields.integer != 0 && G_Client_IsBorg(other))/*other->client->sess.sessionClass == PC_ADMIN*/)
  {
    ShieldGoNotSolid(self);
  }
  //RPG-X:J2J Damage for shields 
  else
  {
    if((int32_t)(self->s.angles[PITCH]) == 0)
    {
      vec3_t	dir;

      //OPTIMIZE ME: If anyone can figure a quick, non hacky way to get the normal vector
      //of the side of the forcefield they touch, PLEASE put it here lol. THis way works, but feels very half-assed lol
      //Get the directional vector
      VectorSubtract(self->r.currentOrigin, other->r.currentOrigin, dir);
      VectorNormalize(dir);
      //depending on angle, negate the perpendicular direction (else they zap back sideways)
      //and set the other as absolute 
      if(self->s.angles[YAW] == 0)
      {
        dir[1] = 0.0;
        if(dir[0] < 0)
          dir[0] = -1.0;
        else
          dir[0] = 1.0;
      }
      else
      {
        dir[0] = 0.0;
        if(dir[1] < 0)
          dir[1] = -1.0;
        else
          dir[1] = 1.0;
      }

      //Invert it otherwise we'd be like, sucked into the field lol
      VectorScale(dir, -1, dir);
      //Un-normalize it to represent a scalar quantity
      VectorScale(dir, 50, dir);
      //Copy it straight to our velocity (this will mean the player will literally be thrown back)
      VectorCopy(dir, other->client->ps.velocity);
      other->client->ps.pm_time = 160;		// hold time
      other->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;

      other->flags |= EF_MOVER_STOP;	//Attempt to not let non admins thru.
      //RPG-X: RedTechie - Added code for zap sound also a cvar to control damage a non admin walks into if cvar is set to 0 disables health from being drained (happens every 1 second)
      //if ( level.time >= level.message + 1000 ) {
      //	level.message = level.time;
      G_AddEvent(self, EV_GENERAL_SOUND, shieldMurderSound);//RPG-X: RedTechie - ZAPtacular! sound to my ears
      if(rpg_forcefielddamage.integer != 0)
      {
        if(rpg_forcefielddamage.integer > 999)
        {
          rpg_forcefielddamage.integer = 999;
        }
        other->health -= rpg_forcefielddamage.integer;

        //RPG-X: RedTechie - Fixed free ent if medic revive on
        if(rpg_medicsrevive.integer == 1)
        {
          if(other->health <= 1)
          {
            other->client->ps.stats[STAT_WEAPONS] = (1 << WP_0);
            other->client->ps.stats[STAT_HOLDABLE_ITEM] = HI_NONE;
            other->client->ps.stats[STAT_HEALTH] = other->health = 1;
            G_Client_Die(other, other, other, 1, MOD_FORCEFIELD);
          }
        }
        else
        {
          if(other->health <= 1)
          {
            other->client->ps.stats[STAT_HEALTH] = other->health = 0;
            G_Client_Die(other, other, other, 100000, MOD_FORCEFIELD);
          }
        }
      }

      //TiM: make it flicker when touched, and then throw bak the person
      self->s.eFlags |= EF_ITEMPLACEHOLDER;
      self->nextthink = level.time + 150;
      self->think = ShieldThink;
    }

  }
}

/**
*	After a short delay, create the shield by expanding in all directions.
*/
void CreateShield(gentity_t *ent)
{
  trace_t		tr;
  vec3_t		end, posTraceEnd, negTraceEnd, start;
  int32_t		height, posWidth, negWidth, halfWidth = 0;
  qboolean	xaxis;
  int32_t		paramData = 0;

  // trace upward to find height of shield
  VectorCopy(ent->r.currentOrigin, end);
  end[2] += MAX_SHIELD_HEIGHT;
  memset(&tr, 0, sizeof(trace_t));
  trap_Trace(&tr, ent->r.currentOrigin, NULL, NULL, end, ent->s.number, MASK_SHOT);
  height = (int32_t)(MAX_SHIELD_HEIGHT * tr.fraction);

  // use angles to find the proper axis along which to align the shield
  VectorCopy(ent->r.currentOrigin, posTraceEnd);
  VectorCopy(ent->r.currentOrigin, negTraceEnd);

  if((int32_t)(ent->s.angles[YAW]) == 0) // shield runs along y-axis
  {
    ent->s.eFlags |= EF_SHIELD_BOX_Y;
    posTraceEnd[1] += MAX_SHIELD_HALFWIDTH;
    negTraceEnd[1] -= MAX_SHIELD_HALFWIDTH;
    xaxis = qfalse;
  }
  else  // shield runs along x-axis
  {
    ent->s.eFlags |= EF_SHIELD_BOX_X;
    posTraceEnd[0] += MAX_SHIELD_HALFWIDTH;
    negTraceEnd[0] -= MAX_SHIELD_HALFWIDTH;
    xaxis = qtrue;
  }

  // trace horizontally to find extend of shield
  // positive trace
  VectorCopy(ent->r.currentOrigin, start);
  start[2] += (height >> 1);
  trap_Trace(&tr, start, 0, 0, posTraceEnd, ent->s.number, MASK_SHOT);
  posWidth = MAX_SHIELD_HALFWIDTH * tr.fraction;
  // negative trace
  trap_Trace(&tr, start, 0, 0, negTraceEnd, ent->s.number, MASK_SHOT);
  negWidth = MAX_SHIELD_HALFWIDTH * tr.fraction;

  // kef -- monkey with dimensions and place origin in center
  halfWidth = (posWidth + negWidth) >> 1;
  if(xaxis)
  {
    ent->r.currentOrigin[0] = ent->r.currentOrigin[0] - negWidth + halfWidth;
  }
  else
  {
    ent->r.currentOrigin[1] = ent->r.currentOrigin[1] - negWidth + halfWidth;
  }
  ent->r.currentOrigin[2] += (height >> 1);

  // set entity's mins and maxs to new values, make it solid, and link it
  if(xaxis)
  {
    VectorSet(ent->r.mins, -halfWidth, -SHIELD_HALFTHICKNESS, -(height >> 1));
    VectorSet(ent->r.maxs, halfWidth, SHIELD_HALFTHICKNESS, height);
  }
  else
  {
    VectorSet(ent->r.mins, -SHIELD_HALFTHICKNESS, -halfWidth, -(height >> 1));
    VectorSet(ent->r.maxs, SHIELD_HALFTHICKNESS, halfWidth, height >> 1);
  }
  ent->clipmask = MASK_SHOT;

  //	xaxis - 1 bit
  //	height - 0-254 8 bits //10
  //	posWidth - 0-255 8 bits //10
  //  negWidth - 0 - 255 8 bits

  paramData = (xaxis << 30) | ((height & 1023) << 20) | ((posWidth & 1023) << 10) | (negWidth & 1023); //24 16 8
  ent->s.time2 = paramData;

  if(ent->s.otherEntityNum2 == TEAM_RED)
  {
    ent->team = "1";
  }
  else if(ent->s.otherEntityNum2 == TEAM_BLUE)
  {
    ent->team = "2";
  }

  ent->health = ceil(SHIELD_HEALTH*g_dmgmult.value);

  ent->s.time = ent->health;//???
  ent->pain = ShieldPain;
  ent->die = ShieldDie;
  ent->touch = ShieldTouch;

  ent->r.svFlags |= SVF_SHIELD_BBOX;

  // see if we're valid
  trap_Trace(&tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ent->r.currentOrigin, ent->s.number, CONTENTS_BODY);

  if(tr.startsolid)
  {	// Something in the way!
    // make the shield non-solid very briefly
    ent->r.contents = CONTENTS_NONE;
    ent->s.eFlags |= EF_NODRAW;
    // nextthink needs to have a large enough interval to avoid excess accumulation of Activate messages
    ent->nextthink = level.time + 200;
    ent->think = ShieldGoSolid;
    ent->takedamage = qfalse;
    trap_LinkEntity(ent);
  }
  else
  {	// Get solid.
    ent->r.contents = CONTENTS_PLAYERCLIP | CONTENTS_SHOTCLIP;//CONTENTS_SOLID;

    ent->nextthink = level.time + 400; //1000
    ent->think = ShieldThink;

    ent->takedamage = qtrue;//RPG-X: - RedTechie Use to be qtrue //TiM - made true again. should be okay so long as the health isn't decremented
    trap_LinkEntity(ent);

    ent->s.eFlags |= EF_ITEMPLACEHOLDER;

    // Play raising sound...
    G_AddEvent(ent, EV_GENERAL_SOUND, shieldActivateSound);
  }

  return;
}

/**
*	Place a forcefield
*/
static qboolean PlaceShield(gentity_t* playerent)
{
  static const gitem_t*	shieldItem = NULL;
  gentity_t*				shield = NULL;
  trace_t					tr;
  vec3_t					fwd, pos, dest, mins = { -16, -16, 0 }, maxs = { 16, 16, 16 };
  playerState_t*			ps = &playerent->client->ps;

  if(shieldAttachSound == 0)
  {
    shieldAttachSound = G_SoundIndex("sound/weapons/detpacklatch.wav");
    shieldActivateSound = G_SoundIndex("sound/movers/forcefield/forcefieldon.wav"); //"sound/movers/forceup.wav"
    shieldDamageSound = G_SoundIndex("sound/ambience/spark5.wav");
    shieldMurderSound = G_SoundIndex("sound/movers/forcefield/forcefieldtouch.wav"); //RPG-X: - RedTechie Added shild ZAP! sound //sound/world/electro.wav
    shieldDeactivateSound = G_SoundIndex("sound/movers/forcefield/forcefieldoff.wav");
    shieldItem = BG_FindItemForHoldable(HI_SHIELD);
  }

  // can we place this in front of us?
  AngleVectors(ps->viewangles, fwd, NULL, NULL);
  fwd[2] = 0;
  VectorMA(ps->origin, SHIELD_PLACEDIST, fwd, dest);
  trap_Trace(&tr, ps->origin, mins, maxs, dest, playerent->s.number, MASK_SHOT);
  if(tr.fraction > 0.9)
  {//room in front
    VectorCopy(tr.endpos, pos);
    // drop to floor
    VectorSet(dest, pos[0], pos[1], pos[2] - 4096);
    trap_Trace(&tr, pos, mins, maxs, dest, playerent->s.number, MASK_SOLID);
    if(!tr.startsolid && !tr.allsolid)
    {
      // got enough room so place the portable shield
      shield = G_Spawn();

      if(!shield || !shieldItem) return qfalse;

      // Figure out what direction the shield is facing.
      if(fabs(fwd[0]) > fabs(fwd[1]))
      {	// shield is north/south, facing east.
        shield->s.angles[YAW] = 0;
      }
      else
      {	// shield is along the east/west axis, facing north
        shield->s.angles[YAW] = 90;
      }
      shield->think = CreateShield;
      shield->nextthink = level.time + 500;	// power up after .5 seconds
      shield->parent = playerent;

      // Set team number.
      shield->s.otherEntityNum2 = playerent->client->sess.sessionTeam;

      shield->s.eType = ET_USEABLE;
      shield->s.modelindex = HI_SHIELD;	// this'll be used in CG_Useable() for rendering.
      shield->classname = shieldItem->classname;

      shield->r.contents = CONTENTS_TRIGGER;

      shield->touch = 0;
      // using an item causes it to respawn
      shield->use = 0; //Use_Item;

      // allow to ride movers
      shield->s.groundEntityNum = tr.entityNum;

      G_SetOrigin(shield, tr.endpos);

      shield->s.origin2[0] = rpg_forceFieldColor.integer;

      shield->s.eFlags &= ~EF_NODRAW;
      shield->r.svFlags &= ~SVF_NOCLIENT;

      trap_LinkEntity(shield);

      // Play placing sound...
      G_AddEvent(shield, EV_GENERAL_SOUND, shieldAttachSound);

      return qtrue;
    }
  }

  return qfalse;
}



//-------------------------------------------------------------- DECOY ACTIVITIES
/**
*	Think function for decoys, decoys are spawnchars in RPG-X
*/
void DecoyThink(gentity_t *ent)
{
  ent->s.apos = (ent->parent)->s.apos;					// Update Current Rotation
  ent->nextthink = level.time + irandom(2000, 6000);	// Next think between 2 & 8 seconds

  (ent->count)--;									// Count Down
  if(ent->count < 0)			G_FreeEntity(ent);		// Time To Erase The Ent
}

//TiM : I was just able to spawn 600 copies of me...
//my fps died and my PC started making weird noises
//We'd better instigate a limit to our spawning here...
//Borrowed from the tripMines
/**
*	Safety function to limit ammount of decoys spawned at one time and overall.
*	Stops spawning if to many are spawned a a time, stop spawning is a limit was hit.
*	\author Ubergames - TiM
*/
void flushDecoys(gentity_t	*ent)
{
  gentity_t*	decoy = NULL;
  int32_t		foundDecoys[MAX_GENTITIES] = { ENTITYNUM_NONE };
  int32_t		lowestTimeStamp;
  int32_t		orgCount;
  int32_t		decoyCount = 0;
  int32_t		removeMe;
  int32_t		i;

  //limit to 10 placed at any one time
  //see how many there are now
  while((decoy = G_Find(decoy, FOFS(classname), "decoy")) != NULL)
  {
    if(decoy->parent != ent)
      //if ( decoy->s.clientNum != ent->client->ps.clientNum )
    {
      continue;
    }
    foundDecoys[decoyCount++] = decoy->s.clientNum;
  }

  //now remove first ones we find until there are only 9 left
  decoy = NULL;
  orgCount = decoyCount;
  lowestTimeStamp = level.time;

  //RPG-X: TiM - Let's limit it to say... 64 decoys per player
  while(decoyCount > 64) //9
  {
    removeMe = -1;
    for(i = 0; i < orgCount; i++)
    {
      if(foundDecoys[i] == ENTITYNUM_NONE)
      {
        continue;
      }
      decoy = &g_entities[foundDecoys[i]];

      if(decoy && decoy->timestamp < lowestTimeStamp)
      {
        removeMe = i;
        lowestTimeStamp = decoy->timestamp;
      }
    }

    if(removeMe != -1)
    {
      //remove it... or blow it?
      if(&g_entities[foundDecoys[removeMe]] == NULL)
      {
        break;
      }
      else
      {
        G_FreeEntity(&g_entities[foundDecoys[removeMe]]);
      }
      foundDecoys[removeMe] = ENTITYNUM_NONE;
      decoyCount--;
    }
    else
    {
      break;
    }
  }
}

/**
*	entities spawn non solid and through this function,
*	they'll become solid once nothing's detected in their boundaries. :)
*	\author TiM
*/
void Decoy_CheckForSolidity(gentity_t	*ent)
{
  int32_t		i, num;
  int32_t		touch[MAX_GENTITIES];
  qboolean	canGoSolid = qtrue;
  gentity_t*	hit = NULL;
  vec3_t		mins, maxs;

  VectorAdd(ent->s.origin, ent->r.mins, mins);
  VectorAdd(ent->s.origin, ent->r.maxs, maxs);

  num = trap_EntitiesInBox(mins, maxs, touch, MAX_GENTITIES);

  for(i = 0; i < num; i++)
  {
    hit = &g_entities[touch[i]];

    if(hit  && hit->client)
    {
      canGoSolid = qfalse;
      break;
    }
  }

  if(canGoSolid)
  {
    ent->r.contents = MASK_PLAYERSOLID;
    ent->nextthink = 0;
    ent->think = 0;
  }
  else
  {
    ent->nextthink = level.time + 1000;
    ent->r.contents = CONTENTS_NONE;
  }
}

/**
*	Use function for decoy, removes it if activator is an player and admin
*/
void DecoyUse(gentity_t *self, gentity_t *other, gentity_t *activator)
{
  if(activator == NULL || !G_Client_IsAdmin(activator) || activator->client == NULL)
    return;

  G_FreeEntity(self);

}

/**
*	Spawn a char
*/
qboolean PlaceDecoy(gentity_t *ent)
{
  gentity_t*		decoy = NULL;
  static gitem_t*	decoyItem = NULL;
  vec3_t			mins = { -16, -16, -24 };
  char			userinfo[MAX_INFO_STRING];
  int32_t			i;

  if(decoyItem == NULL)
  {
    decoyItem = BG_FindItemForHoldable(HI_DECOY);
  }

  //If we just hit our 129th decoy (...holy crap), reset the counter
  if(level.decoyIndex >= MAX_CLIENTS)
  {
    level.decoyIndex = 0;
  }
  //Now check if there is already a decoy with the same eventParm index.  If there is, terminate it
  {
    gentity_t* oldDecoy = NULL;

    for(i = 0; i < level.num_entities; i++)
    {
      oldDecoy = &g_entities[i];

      if(Q_stricmp(oldDecoy->classname, "decoy") == 0 && oldDecoy->s.eventParm == level.decoyIndex)
      {
        G_FreeEntity(oldDecoy);
        break;
      }
    }
  }

  //--------------------------- SPAWN AND PLACE DECOY ON GROUND
  decoy = G_Spawn();

  G_SpawnItem(decoy, decoyItem);				// Generate it as an item, temporarly
  decoy->physicsBounce = 0.0f;//decoys are *not* bouncy
  //VectorMA(ent->client->ps.origin, detDistance + mins[0], fwd, decoy->s.origin);
  VectorCopy(ent->client->ps.origin, decoy->s.origin);
  decoy->r.mins[2] = mins[2];//keep it off the floor
  //VectorNegate(fwd, fwd);					// ???  What does this do??
  //vectoangles(fwd, decoy->s.angles);
  VectorCopy(ent->client->ps.viewangles, decoy->s.angles);
  if(!FinishSpawningDecoy(decoy, decoyItem - bg_itemlist))
  {
    return qfalse;		// Drop to ground and trap to clients
  }
  decoy->s.clientNum = ent->client->ps.clientNum;
  decoy->s.number = decoy - g_entities;

  //--------------------------- SPECIALIZED DECOY SETUP
  decoy->s.time = -1; // tell cgame this is a decoy so it does not mess up the radar

  decoy->parent = ent;

  (decoy->s).eType = (ent->s).eType;		// set to type PLAYER
  (decoy->s).eFlags = (ent->s).eFlags;
  (decoy->s).eFlags |= EF_ITEMPLACEHOLDER;// set the HOLOGRAM FLAG to ON
  (decoy->s).powerups = (ent->s).powerups;

  //TiM - attach the rotate flag if we need to
  if((ent->s).powerups & (1 << PW_FLIGHT) || ent->client->ps.gravity == 0)
    (decoy->s).eFlags |= EF_FULL_ROTATE;

  decoy->s.eFlags &= ~(EF_FIRING | EF_ALT_FIRING);

  decoy->s.weapon = ent->s.weapon;		// get Player's Wepon Type

  decoy->s.apos = ent->s.apos;			// copy angle of player to decoy
  decoy->s.pos = ent->s.pos;

  //TiM: Set it's anim to whatever anims we're playing right now
  decoy->s.legsAnim = ent->client->ps.stats[LEGSANIM];
  decoy->s.torsoAnim = ent->client->ps.stats[TORSOANIM];

  decoy->timestamp = level.time;

  //--------------------------- WEAPON ADJUST
  //   The Phaser and Dreadnought (Arc Welder) weapons are rendered on the
  //   client side differently, and cannot be used by the decoy
  decoy->classname = "decoy";

  //TiM-Set up data for transmission to client
  decoy->s.eventParm = level.decoyIndex;
  decoy->r.contents = CONTENTS_SOLID;	//has to start off solid, or CGame won't realise this

  VectorSet(decoy->r.mins, DEFAULT_MINS_0, DEFAULT_MINS_1, DEFAULT_MINS_2);
  VectorSet(decoy->r.maxs, DEFAULT_MAXS_0, DEFAULT_MAXS_1, DEFAULT_MAXS_2);

  decoy->nextthink = level.time + FRAMETIME;
  decoy->think = Decoy_CheckForSolidity;
  decoy->use = DecoyUse;

  trap_GetUserinfo(ent->client->ps.clientNum, userinfo, sizeof(userinfo));
  {
    char buffer[MAX_TOKEN_CHARS];
    char model[64];
    char height[9];
    char weight[9];
    char offset[6];

    //TiM - ensure that we encapsulate this data better or else it sometimes
    //becomes null
    Q_strncpyz(model, Info_ValueForKey(userinfo, "model"), sizeof(model));
    Q_strncpyz(height, Info_ValueForKey(userinfo, "height"), sizeof(height));
    Q_strncpyz(weight, Info_ValueForKey(userinfo, "weight"), sizeof(weight));
    Q_strncpyz(offset, Info_ValueForKey(userinfo, "modelOffset"), sizeof(offset));

    Com_sprintf(buffer, sizeof(buffer), "model\\%s\\height\\%s\\weight\\%s\\moOf\\%s\\c\\%i",
      model,
      height,
      weight,
      offset,
      ent->client->sess.sessionClass);

    trap_SetConfigstring(CS_DECOYS + level.decoyIndex, buffer);
  }
  level.decoyIndex++;

  return qtrue;						// SUCCESS
}
//-------------------------------------------------------------- DECOY ACTIVITIES

void G_Rematerialize(gentity_t *ent)
{
  playerState_t *ps = &ent->client->ps;

  ent->client->teleportTime = level.time + (15 * 1000);
  ps->stats[STAT_USEABLE_PLACED] = 15;

  ent->flags &= ~FL_NOTARGET;
  ent->takedamage = qtrue;
  ent->r.contents = MASK_PLAYERSOLID;
  ent->s.eFlags &= ~EF_NODRAW;
  ps->eFlags &= ~EF_NODRAW;
  TeleportPlayer(ent, ps->origin, ps->viewangles, TP_BORG);
  //take it away
  ps->stats[STAT_HOLDABLE_ITEM] = 0;
}

static void G_GiveHoldable(gclient_t *client, holdable_t item)
{
  gitem_t	*holdable = BG_FindItemForHoldable(item);

  client->ps.stats[STAT_HOLDABLE_ITEM] = holdable - bg_itemlist;//teleport spots should be on other side of map
  RegisterItem(holdable);
}

/*
================
ClientEvents
================
*/
/**
*	Events will be passed on to the clients for presentation,
*	but any server game effects are handled here
*/
static void ClientEvents(gentity_t *ent, int oldEventSequence)
{
  int32_t		i;
  int32_t		event;
  gclient_t*	client = NULL;
  int32_t		damage;
  playerState_t* ps = NULL;

  client = ent->client;
  ps = &client->ps;

  if(oldEventSequence < ps->eventSequence - MAX_PS_EVENTS)
  {
    oldEventSequence = ps->eventSequence - MAX_PS_EVENTS;
  }
  for(i = oldEventSequence; i < ps->eventSequence; i++)
  {
    event = ps->events[i & (MAX_PS_EVENTS - 1)];

    switch(event)
    {
    case EV_FALL_MEDIUM:
    case EV_FALL_FAR:
      if(ent->s.eType != ET_PLAYER)
      {
        break;		// not in the player model
      }
      if(g_dmflags.integer & DF_NO_FALLING)
      {
        break;
      }
      if(rpg_selfdamage.integer != 0)
      {
        if(event == EV_FALL_FAR)
        {
          damage = 110; //10 -TiM : Make the falling more realistc!
        }
        else
        {
          damage = 90; //5
        }
      }
      else
      {
        damage = 0;
      }
      ent->pain_debounce_time = level.time + 200;	// no normal pain sound
      G_Combat_Damage(ent, NULL, NULL, NULL, NULL, damage, DAMAGE_ARMOR_PIERCING, MOD_FALLING);

      break;

    case EV_FIRE_WEAPON:
      FireWeapon(ent, qfalse);
      break;

    case EV_ALT_FIRE:
      FireWeapon(ent, qtrue);
      break;

    case EV_FIRE_EMPTY_PHASER:
      FireWeapon(ent, qfalse);
      break;

    case EV_USE_ITEM1:		// transporter
      //TiM: Since we purge the vectors each cycle.  I'll save us some memory by using the vectors themselves as a check.
      if(TransDat[ps->clientNum].beamTime == 0 &&
        VectorCompare(vec3_origin, TransDat[ps->clientNum].storedCoord[TPT_PORTABLE].origin) &&
        VectorCompare(vec3_origin, TransDat[ps->clientNum].storedCoord[TPT_PORTABLE].angles))
      {
        VectorCopy(ps->origin, TransDat[ps->clientNum].storedCoord[TPT_PORTABLE].origin);
        VectorCopy(ps->viewangles, TransDat[ps->clientNum].storedCoord[TPT_PORTABLE].angles);
        trap_SendServerCommand(ent - g_entities, va("chat \"Site to Site Transporter Location Confirmed.\nPress again to Energize.\""));
        ps->stats[STAT_HOLDABLE_ITEM] = BG_FindItemForHoldable(HI_TRANSPORTER) - bg_itemlist;
        ps->stats[STAT_USEABLE_PLACED] = 2; // = 1
        break;
      }

      if(TransDat[ps->clientNum].beamTime == 0 && level.time > ps->powerups[PW_QUAD])
      {
        G_InitTransport(ps->clientNum, TransDat[ps->clientNum].storedCoord[TPT_PORTABLE].origin,
          TransDat[ps->clientNum].storedCoord[TPT_PORTABLE].angles);

        memset(&TransDat[ps->clientNum].storedCoord[TPT_PORTABLE], 0, sizeof(TransDat[ps->clientNum].storedCoord[TPT_PORTABLE]));
      }
      else
      {
        trap_SendServerCommand(ent - g_entities, va("chat \"Unable to comply. Already within transport cycle.\""));
      }

      ps->stats[STAT_USEABLE_PLACED] = 0;

      if(g_classData[client->sess.sessionClass].isMarine)
      {
        client->teleportTime = level.time + (3 * 1000); // 15 * 1000
        ps->stats[STAT_USEABLE_PLACED] = 1; // = 1
      }
      break;

    case EV_USE_ITEM2:		// medkit
      // New set of rules.  You get either 100 health, or an extra 25, whichever is higher.
      // Give 1/4 health.
      ent->health += ps->stats[STAT_MAX_HEALTH] * 0.25;

      if(ent->health < ps->stats[STAT_MAX_HEALTH])
      {	// If that doesn't bring us up to 100, make it go up to 100.
        ent->health = ps->stats[STAT_MAX_HEALTH];
      }
      else if(ent->health > ps->stats[STAT_MAX_HEALTH] * 2)
      {	// Otherwise, 25 is all you get.  Just make sure we don't go above 200.
        ent->health = ps->stats[STAT_MAX_HEALTH] * 2;
      }
      break;

    case EV_USE_ITEM3:		// detpack
      // if we haven't placed it yet, place it
      if(0 == ps->stats[STAT_USEABLE_PLACED])
      {
        if(PlaceDetpack(ent))
        {
          ps->stats[STAT_USEABLE_PLACED] = 1;
          trap_SendServerCommand(ent - g_entities, "cp \"CHARGE PLACED\"");
        }
        else
        {//couldn't place it
          ps->stats[STAT_HOLDABLE_ITEM] = (BG_FindItemForHoldable(HI_DETPACK) - bg_itemlist);
          trap_SendServerCommand(ent - g_entities, "cp \"NO ROOM TO PLACE CHARGE\"");
        }
      }
      else
      {
        // ok, we placed it earlier. blow it up.
        ps->stats[STAT_USEABLE_PLACED] = 0;
        DetonateDetpack(ent);
      }
      break;

    case EV_USE_ITEM4:		// portable shield
      if(!PlaceShield(ent))	// fixme if we fail, perhaps just spawn it as a pickup
      {//couldn't place it
        ps->stats[STAT_HOLDABLE_ITEM] = (BG_FindItemForHoldable(HI_SHIELD) - bg_itemlist);
        trap_SendServerCommand(ent - g_entities, "cp \"NO ROOM TO PLACE FORCE FIELD\"");
      }
      else
      {
        trap_SendServerCommand(ent - g_entities, "cp \"FORCE FIELD PLACED\"");
      }
      break;

    case EV_USE_ITEM5:		// decoy
      if(!PlaceDecoy(ent))
      {//couldn't place it
        ps->stats[STAT_HOLDABLE_ITEM] = (BG_FindItemForHoldable(HI_DECOY) - bg_itemlist);
        trap_SendServerCommand(ent - g_entities, "cp \"NO ROOM TO PLACE DECOY\"");
      }
      else
      {
        trap_SendServerCommand(ent - g_entities, "cp \"DECOY PLACED\"");
      }
      break;

    default:
      break;
    }
  }

}

void AI_main_BotTestSolid(vec3_t origin);

void G_ThrowWeapon(gentity_t *ent, char *txt)
{
  gclient_t*	client = NULL;
  usercmd_t*	ucmd = NULL;
  gitem_t*	item = NULL;
  gentity_t*	drop = NULL;
  byte i;
  playerState_t* ps = NULL;

  client = ent->client;
  ucmd = &ent->client->pers.cmd;
  ps = &client->ps;

  if(rpg_allowWeaponDrop.integer == 0)
  {
    return;
  }

  if(numTotalDropped >= MAX_DROPPED)
  {
    G_LocLogger(LL_WARN, "RPG-X Warning: maximum of dropped items of %i reached.\n", MAX_DROPPED);
    return;
  }

  if(ps->weapon == WP_0 || ps->weapon == WP_1 || (ucmd->buttons & BUTTON_ATTACK))
  {
    return;
  }

  numTotalDropped++;

  item = BG_FindItemForWeapon(weapon_t(ps->weapon));

  // admins don't lose weapon when thrown
  if(G_Client_IsAdmin(ent) == qfalse)
  {
    ps->ammo[ps->weapon] -= 1;
    if(ps->ammo[ps->weapon] <= 0)
    {
      ps->stats[STAT_WEAPONS] &= ~(1 << ps->weapon);
      ps->weapon = WP_1;
      for(i = WP_NUM_WEAPONS - 1; i > 0; i--)
      {
        if(ps->stats[STAT_WEAPONS] & (1 << i))
        {
          ps->weapon = i;
          break;
        }
      }
    }
  }

  drop = DropWeapon(ent, item, 0, FL_DROPPED_ITEM | FL_THROWN_ITEM, txt);
  drop->parent = ent;
  drop->count = 1;
}


/*
==============
SendPendingPredictableEvents
==============
*/
static void SendPendingPredictableEvents(playerState_t *ps)
{
  gentity_t* t = NULL;
  int32_t event, seq;
  int32_t extEvent;

  // if there are still events pending
  if(ps->entityEventSequence < ps->eventSequence)
  {
    // create a temporary entity for this event which is sent to everyone
    // except the client generated the event
    seq = ps->entityEventSequence & (MAX_PS_EVENTS - 1);
    event = ps->events[seq] | ((ps->entityEventSequence & 3) << 8);
    // set external event to zero before calling BG_PlayerStateToEntityState
    extEvent = ps->externalEvent;
    ps->externalEvent = 0;
    // create temporary entity for event
    t = G_TempEntity(ps->origin, event);
    BG_PlayerStateToEntityState(ps, &t->s, qtrue);
    t->s.eType = ET_EVENTS + event;
    // send to everyone except the client who generated the event
    t->r.svFlags |= SVF_NOTSINGLECLIENT;
    t->r.singleClient = ps->clientNum;
    // set back external event
    ps->externalEvent = extEvent;
  }
}

static void ClientCamThink(gentity_t* client)
{
  if(client == NULL || client->client == NULL || client->client->cam == NULL)
  {
    if(client->flags & FL_CCAM)
    {
      client->flags ^= FL_CCAM;
    }
    client->client->ps.pm_type = PM_NORMAL;
    return;
  }

  G_SetOrigin(client, client->client->cam->s.origin);
  G_Client_SetViewAngle(client, client->client->cam->s.angles);
  trap_LinkEntity(client);
}

/*
==============
ClientThink
==============
*/
/**
* This will be called once for each client frame, which will
* usually be a couple times for each server frame on fast clients.
*
* If "g_synchronousClients 1" is set, this will be called exactly
* once for each server frame, which makes for smooth demo recording.
*/
static void ClientThink_real(gentity_t *ent)
{
  gclient_t*	client = NULL;
  pmove_t		pm;
  int32_t		oldEventSequence;
  int32_t		msec;
  usercmd_t*	ucmd = NULL;
  playerState_t* ps = NULL;

  client = ent->client;
  ps = &client->ps;

  // don't think if the client is not yet connected (and thus not yet spawned in)
  if(client->pers.connected != CON_CONNECTED)
  {
    return;
  }
  // mark the time, so the connection sprite can be removed
  ucmd = &client->pers.cmd;

  // sanity check the command time to prevent speedup cheating
  if(ucmd->serverTime > level.time + 200)
  {
    ucmd->serverTime = level.time + 200;
  }
  if(ucmd->serverTime < level.time - 1000)
  {
    ucmd->serverTime = level.time - 1000;
  }

  msec = ucmd->serverTime - ps->commandTime;
  // following others may result in bad times, but we still want
  // to check for follow toggles
  if(msec < 1 && client->sess.spectatorState != SPECTATOR_FOLLOW)
  {
    return;
  }
  if(msec > 200)
  {
    msec = 200;
  }

  //
  // check for exiting intermission
  //
  if(level.intermissiontime)
  {
    ClientIntermissionThink(client);
    return;
  }

  if(ent->flags & FL_CCAM)
  {
    ClientCamThink(ent);
    return;
  }

  // spectators don't do much
  if(client->sess.sessionTeam == TEAM_SPECTATOR)
  {
    if(client->sess.spectatorState == SPECTATOR_SCOREBOARD)
    {
      return;
    }
    SpectatorThink(ent, ucmd);
    return;
  }

  // check for inactivity timer, but never drop the local client of a non-dedicated server
  if(!ClientInactivityTimer(client))
  {
    return;
  }

  //TiM - If we're null content... see what's up
  if(ent->r.contents == CONTENTS_NONE)
  {
    if(!G_MoveBox(ent))
    {
      if(ps->stats[STAT_HEALTH] > 1)
        ent->r.contents = CONTENTS_BODY;
      else
        ent->r.contents = CONTENTS_CORPSE;
    }
  }

  //RPG-X: Checked to see if medics revive is on if so do as following
  if(rpg_medicsrevive.integer == 1)
  {
    if(client->noclip)
    {
      ps->pm_type = PM_NOCLIP;
    }
    else if(ps->stats[STAT_HEALTH] == 1)
    {
      ps->pm_type = PM_DEAD;
    }
    else
    {
      ps->pm_type = PM_NORMAL;
    }
  }
  else
  {
    if(client->noclip)
    {
      ps->pm_type = PM_NOCLIP;
    }
    else if(ps->stats[STAT_HEALTH] <= 0)
    {
      ps->pm_type = PM_DEAD;
    }
    else
    {
      ps->pm_type = PM_NORMAL;
    }
  }

  //RPG-X: J2J & Phenix - For the gravity ent
  if(client->SpecialGrav != qtrue)
  {
    ps->gravity = g_gravity.value;
  }

  // set speed
  ps->speed = g_speed.value;

  if(ps->powerups[PW_HASTE])
  {
    ps->speed *= 1.5;
  }
  else if(ps->powerups[PW_FLIGHT])
  {//flying around
    ps->speed *= 1.3;
  }
  else if(ps->stats[STAT_HEALTH] <= 20)
  {
    ps->speed *= 0.55;
  }

  if((ps->powerups[PW_EVOSUIT]) && (ps->gravity == 0))
  {//Evosuit time.. RPG-X | Phenix | 8/8/2004
    ps->speed *= 1.3;
  }

  //RPG-X: Redtechie - n00bie stay.....good boy!
  if(g_classData[client->sess.sessionClass].isn00b)
  {
    ps->speed = 0;
  }

  //TiM : SP Style Transporter. :)
  //first check to see if we should be beaming
  if(level.time < TransDat[ps->clientNum].beamTime)
  {

    //if we're past the mid point of each materialization cycle, make it
    //so bullets and other players will pass thru the transportee. :)
    if((level.time > TransDat[ps->clientNum].beamTime - 6000) &&
      (level.time < TransDat[ps->clientNum].beamTime - 2000))
    {
      if(ps->stats[STAT_HEALTH] > 1)
      {
        ent->r.contents = CONTENTS_NONE;
      }
    }
    else
    {
      if(ps->stats[STAT_HEALTH] > 1)
      {
        ent->r.contents = MASK_PLAYERSOLID;
      }
    }

    //If we're half-way thru the cycle, teleport the player now
    if(level.time > TransDat[ps->clientNum].beamTime - 4000 &&
      !TransDat[ps->clientNum].beamed)
    {
      TeleportPlayer(ent, TransDat[ps->clientNum].currentCoord.origin,
        TransDat[ps->clientNum].currentCoord.angles,
        TP_TRI_TP);

      TransDat[ps->clientNum].beamed = qtrue;
    }
  }
  else
  {
    //all done, let's reset :)
    if(TransDat[ps->clientNum].beamTime > 0)
    {
      TransDat[ps->clientNum].beamTime = 0;
      ps->powerups[PW_BEAM_OUT] = 0;
      ps->powerups[PW_QUAD] = 0;
      TransDat[ps->clientNum].beamed = qfalse;

      memset(&TransDat[ps->clientNum].currentCoord, 0,
        sizeof(TransDat[ps->clientNum].currentCoord.origin));

      if(g_entities[ps->clientNum].flags & FL_CLAMPED)
      {
        //reset everything if player was beamed by trigger_transporter
        g_entities[ps->clientNum].flags ^= FL_CLAMPED;
      }
    }
  }

  //TiM : Freeze their movement if they're halfway through a transport cycle
  if(level.time < TransDat[ps->clientNum].beamTime &&
    level.time > TransDat[ps->clientNum].beamTime - 4000)
  {
    vec3_t	endPoint;
    trace_t	tr;
    VectorSet(endPoint, ps->origin[0], ps->origin[1], ps->origin[2] - 48);
    //Do a trace down. If we're near ground, just re-enable gravity. Else we we get weird animations O_o
    trap_Trace(&tr, ps->origin, NULL, NULL, endPoint, ps->clientNum, CONTENTS_SOLID);

    if(tr.fraction == 1.0)
    {
      ps->gravity = 0;
      ps->velocity[2] = 0;
    }

    ps->speed = 0;

    ps->velocity[0] = ps->velocity[1] = 0.0;
  }

  // set up for pmove
  oldEventSequence = ps->eventSequence;

  memset(&pm, 0, sizeof(pm));

  pm.ps = &client->ps;
  pm.cmd = *ucmd;
  if(pm.ps->pm_type == PM_DEAD)
  {
    pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
  }
  else
  {
    pm.tracemask = MASK_PLAYERSOLID;
  }

  pm.trace = trap_Trace;
  pm.pointcontents = trap_PointContents;
  pm.debugLevel = g_debugMove.integer;
  pm.noFootsteps = (qboolean)((g_dmflags.integer & DF_NO_FOOTSTEPS) > 0);
  pm.pModDisintegration = qfalse;

  //pm.admin = IsAdmin(ent); // we use this way now the old way didn't work for adminlogin
  // y call a function though???
  pm.admin = (qboolean)(g_classData[client->sess.sessionClass].isAdmin || client->LoggedAsAdmin);
  //pm.admin = g_classData[client->sess.sessionClass].isAdmin;
  pm.medic = (qboolean)g_classData[client->sess.sessionClass].isMedical;
  pm.borg = (qboolean)g_classData[client->sess.sessionClass].isBorg;

  // perform a pmove
  Pmove(&pm);

  // save results of pmove
  if(ps->eventSequence != oldEventSequence)
  {
    ent->eventTime = level.time;
  }
  BG_PlayerStateToEntityState(ps, &ent->s, qtrue);

  SendPendingPredictableEvents(ps);

  // use the snapped origin for linking so it matches client predicted versions
  VectorCopy(ent->s.pos.trBase, ent->r.currentOrigin);

  VectorCopy(pm.mins, ent->r.mins);
  VectorCopy(pm.maxs, ent->r.maxs);

  ent->waterlevel = pm.waterlevel;
  ent->watertype = pm.watertype;

  // execute client events
  ClientEvents(ent, oldEventSequence);

  if(pm.useEvent)
  {	//TODO: Use
    TryUse(ent);
  }

  // link entity now, after any personal teleporters have been used
  trap_LinkEntity(ent);
  G_TouchTriggers(ent);

  // NOTE: now copy the exact origin over otherwise clients can be snapped into solid
  VectorCopy(ps->origin, ent->r.currentOrigin);

  //test for solid areas in the AAS file
  AI_main_BotTestSolid(ent->r.currentOrigin);

  // touch other objects
  ClientImpacts(ent, &pm);

  // save results of triggers and client events
  if(ps->eventSequence != oldEventSequence)
  {
    ent->eventTime = level.time;
  }

  // swap and latch button actions
  client->oldbuttons = client->buttons;
  client->buttons = ucmd->buttons;
  client->latched_buttons |= client->buttons & ~client->oldbuttons;

  // check for respawning
  if(client->ps.stats[STAT_HEALTH] <= 0)
  {
    // wait for the attack button to be pressed
    if(level.time > client->respawnTime)
    {
      // pressing attack or use is the normal respawn method
      if(ucmd->buttons & (BUTTON_ATTACK | BUTTON_USE_HOLDABLE))
      {
        G_Client_Respawn(ent);
        return;
      }
    }
    return;
  }

  // perform once-a-second actions
  ClientTimerActions(ent, msec);

  if(client->teleportTime > 0 && client->teleportTime < level.time)
  {
    if(g_classData[client->sess.sessionClass].isMarine)
    {
      G_GiveHoldable(client, HI_TRANSPORTER);
      ps->stats[STAT_USEABLE_PLACED] = 0;
      client->teleportTime = 0;
    }
    else if(g_classData[client->sess.sessionClass].isAdmin)
    {
      G_GiveHoldable(client, HI_SHIELD);
      ps->stats[STAT_USEABLE_PLACED] = 0;
      client->teleportTime = 0;
    }
  }

}

void ClientThink(int clientNum)
{
  gentity_t* ent = NULL;

  ent = g_entities + clientNum;
  trap_GetUsercmd(clientNum, &ent->client->pers.cmd);

  // mark the time we got info, so we can display the
  // phone jack if they don't get any for a while
  ent->client->lastCmdTime = level.time;

  if(!g_synchronousClients.integer)
  {
    ClientThink_real(ent);
  }
}


void G_RunClient(gentity_t* ent)
{
  if(g_synchronousClients.integer == 0)
  {
    return;
  }

  ent->client->pers.cmd.serverTime = level.time;
  ClientThink_real(ent);
}


/*
==================
SpectatorClientEndFrame

==================
*/
static void SpectatorClientEndFrame(gentity_t *ent)
{
  gclient_t* cl = NULL;
  clientSession_t* sess = &ent->client->sess;
  playerState_t* ps = &ent->client->ps;

  // if we are doing a chase cam or a remote view, grab the latest info
  if(sess->spectatorState == SPECTATOR_FOLLOW)
  {
    int32_t	clientNum;

    clientNum = sess->spectatorClient;

    // team follow1 and team follow2 go to whatever clients are playing
    if(clientNum == -1)
    {
      clientNum = level.follow1;
    }
    else if(clientNum == -2)
    {
      clientNum = level.follow2;
    }
    if(clientNum >= 0)
    {
      cl = &level.clients[clientNum];
      if(cl->pers.connected == CON_CONNECTED && cl->sess.sessionTeam != TEAM_SPECTATOR)
      {
        ent->client->ps = cl->ps;
        ps->pm_flags |= PMF_FOLLOW;
        return;
      }
      else
      {
        // drop them to free spectators unless they are dedicated camera followers
        if(sess->spectatorClient >= 0)
        {
          sess->spectatorState = SPECTATOR_FREE;
          G_Client_Begin(ent->client - level.clients, qfalse, qfalse, qfalse);
        }
      }
    }
  }

  if(sess->spectatorState == SPECTATOR_SCOREBOARD)
  {
    ps->pm_flags |= PMF_SCOREBOARD;
  }
  else
  {
    ps->pm_flags &= ~PMF_SCOREBOARD;
  }
}

void ClientEndFrame(gentity_t *ent)
{
  int32_t	i;
  playerState_t *ps = &ent->client->ps;

  if(ent->client->sess.sessionTeam == TEAM_SPECTATOR /*|| (ps->eFlags&EF_ELIMINATED)*/)
  {
    SpectatorClientEndFrame(ent);
    ent->client->noclip = qtrue;
    return;
  }

  // turn off any expired powerups
  for(i = 0; i < MAX_POWERUPS; i++)
  {
    if(ps->powerups[i] < level.time)
    {
      ps->powerups[i] = 0;
    }
  }

  // save network bandwidth
#if 0
  if(!g_synchronousClients->integer && ps->pm_type == PM_NORMAL)
  {
    // FIXME: this must change eventually for non-sync demo recording
    VectorClear(ps->viewangles);
  }
#endif

  //
  // If the end of unit layout is displayed, don't give
  // the player any normal movement attributes
  //
  if(level.intermissiontime)
  {
    return;
  }

  // burn from lava, etc
  P_WorldEffects(ent);

  // apply all the damage taken this frame
  P_DamageFeedback(ent);

  // add the EF_CONNECTION flag if we haven't gotten commands recently
  if(level.time - ent->client->lastCmdTime > 1000)
  {
    ent->s.eFlags |= EF_CONNECTION;
  }
  else
  {
    ent->s.eFlags &= ~EF_CONNECTION;
  }

  ps->stats[STAT_HEALTH] = ent->health;	// FIXME: get rid of ent->health...

  G_SetClientSound(ent);

  // set the latest infor
  BG_PlayerStateToEntityState(ps, &ent->s, qtrue);
  SendPendingPredictableEvents(ps);

}