import of Jake2 version hannover

1 files changed, 1175 insertions, 0 deletions

diff --git a/src/jake2/game/GameAIAdapters.java b/src/jake2/game/GameAIAdapters.java
new file mode 100644
index 0000000..ea20995
--- /dev/null
+++ b/src/jake2/game/GameAIAdapters.java
@@ -0,0 +1,1175 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 26.02.2004 by RST.
+// $Id: GameAIAdapters.java,v 1.1 2004-07-08 15:58:44 hzi Exp $
+
+package jake2.game;
+
+import jake2.Defines;
+import jake2.client.M;
+import jake2.qcommon.Com;
+import jake2.util.*;
+
+import java.util.*;
+
+public class GameAIAdapters
+{
+	/** Common Boss explode animation.*/
+
+	public static EntThinkAdapter BossExplode = new EntThinkAdapter()
+	{
+		public boolean think(edict_t self)
+		{
+			float[] org = { 0, 0, 0 };
+
+			int n;
+
+			self.think = BossExplode;
+			Math3D.VectorCopy(self.s.origin, org);
+			org[2] += 24 + (Lib.rand() & 15);
+			switch (self.count++)
+			{
+				case 0 :
+					org[0] -= 24;
+					org[1] -= 24;
+					break;
+				case 1 :
+					org[0] += 24;
+					org[1] += 24;
+					break;
+				case 2 :
+					org[0] += 24;
+					org[1] -= 24;
+					break;
+				case 3 :
+					org[0] -= 24;
+					org[1] += 24;
+					break;
+				case 4 :
+					org[0] -= 48;
+					org[1] -= 48;
+					break;
+				case 5 :
+					org[0] += 48;
+					org[1] += 48;
+					break;
+				case 6 :
+					org[0] -= 48;
+					org[1] += 48;
+					break;
+				case 7 :
+					org[0] += 48;
+					org[1] -= 48;
+					break;
+				case 8 :
+					self.s.sound = 0;
+					for (n = 0; n < 4; n++)
+						GameAI.ThrowGib(self, "models/objects/gibs/sm_meat/tris.md2", 500, Defines.GIB_ORGANIC);
+					for (n = 0; n < 8; n++)
+						GameAI.ThrowGib(self, "models/objects/gibs/sm_metal/tris.md2", 500, Defines.GIB_METALLIC);
+					GameAI.ThrowGib(self, "models/objects/gibs/chest/tris.md2", 500, Defines.GIB_ORGANIC);
+					GameAI.ThrowHead(self, "models/objects/gibs/gear/tris.md2", 500, Defines.GIB_METALLIC);
+					self.deadflag = Defines.DEAD_DEAD;
+					return true;
+			}
+
+			GameBase.gi.WriteByte(Defines.svc_temp_entity);
+			GameBase.gi.WriteByte(Defines.TE_EXPLOSION1);
+			GameBase.gi.WritePosition(org);
+			GameBase.gi.multicast(self.s.origin, Defines.MULTICAST_PVS);
+
+			self.nextthink = GameBase.level.time + 0.1f;
+			return true;
+		}
+	};
+	public static EntThinkAdapter walkmonster_start_go = new EntThinkAdapter()
+	{
+		public boolean think(edict_t self)
+		{
+
+			if (0 == (self.spawnflags & 2) && GameBase.level.time < 1)
+			{
+				M.M_droptofloor.think(self);
+
+				if (self.groundentity != null)
+					if (!M.M_walkmove(self, 0, 0))
+						GameBase.gi.dprintf(self.classname + " in solid at " + Lib.vtos(self.s.origin) + "\n");
+			}
+
+			if (0 == self.yaw_speed)
+				self.yaw_speed = 20;
+			self.viewheight = 25;
+
+			Monster.monster_start_go(self);
+
+			if ((self.spawnflags & 2) != 0)
+				MonsterAdapters.monster_triggered_start.think(self);
+			return true;
+		}
+	};
+	public static EntThinkAdapter walkmonster_start = new EntThinkAdapter()
+	{
+		public boolean think(edict_t self)
+		{
+
+			self.think = walkmonster_start_go;
+			Monster.monster_start(self);
+			return true;
+		}
+	};
+	public static EntThinkAdapter flymonster_start_go = new EntThinkAdapter()
+	{
+		public boolean think(edict_t self)
+		{
+			if (!M.M_walkmove(self, 0, 0))
+				GameBase.gi.dprintf(self.classname + " in solid at " + Lib.vtos(self.s.origin) + "\n");
+
+			if (0 == self.yaw_speed)
+				self.yaw_speed = 10;
+			self.viewheight = 25;
+
+			Monster.monster_start_go(self);
+
+			if ((self.spawnflags & 2) != 0)
+				MonsterAdapters.monster_triggered_start.think(self);
+			return true;
+		}
+	};
+	public static EntThinkAdapter flymonster_start = new EntThinkAdapter()
+	{
+		public boolean think(edict_t self)
+		{
+			self.flags |= Defines.FL_FLY;
+			self.think = flymonster_start_go;
+			Monster.monster_start(self);
+			return true;
+		}
+	};
+	public static EntThinkAdapter swimmonster_start_go = new EntThinkAdapter()
+	{
+		public boolean think(edict_t self)
+		{
+			if (0 == self.yaw_speed)
+				self.yaw_speed = 10;
+			self.viewheight = 10;
+
+			Monster.monster_start_go(self);
+
+			if ((self.spawnflags & 2) != 0)
+				MonsterAdapters.monster_triggered_start.think(self);
+			return true;
+		}
+	};
+	public static EntThinkAdapter swimmonster_start = new EntThinkAdapter()
+	{
+		public boolean think(edict_t self)
+		{
+
+			{
+				self.flags |= Defines.FL_SWIM;
+				self.think = swimmonster_start_go;
+				Monster.monster_start(self);
+				return true;
+			}
+		}
+	};
+	/*
+	=============
+	ai_turn
+	
+	don't move, but turn towards ideal_yaw
+	Distance is for slight position adjustments needed by the animations
+	=============
+	*/
+	public static AIAdapter ai_turn = new AIAdapter()
+	{
+		public void ai(edict_t self, float dist)
+		{
+
+			if (dist != 0)
+				M.M_walkmove(self, self.s.angles[Defines.YAW], dist);
+
+			if (GameUtil.FindTarget(self))
+				return;
+
+			M.M_ChangeYaw(self);
+		}
+	};
+	/*
+	=============
+	ai_move
+	
+	Move the specified distance at current facing.
+	This replaces the QC functions: ai_forward, ai_back, ai_pain, and ai_painforward
+	==============
+	*/
+	public static AIAdapter ai_move = new AIAdapter()
+	{
+		public void ai(edict_t self, float dist)
+		{
+			M.M_walkmove(self, self.s.angles[Defines.YAW], dist);
+		}
+	};
+	/*
+	=============
+	ai_walk
+	
+	The monster is walking it's beat
+	=============
+	*/
+	public static AIAdapter ai_walk = new AIAdapter()
+	{
+		public void ai(edict_t self, float dist)
+		{
+			if (self.index == 312)
+				self.index = 312;
+
+			M.M_MoveToGoal(self, dist);
+
+			// check for noticing a player
+			if (GameUtil.FindTarget(self))
+				return;
+
+			if ((self.monsterinfo.search != null) && (GameBase.level.time > self.monsterinfo.idle_time))
+			{
+				if (self.monsterinfo.idle_time != 0)
+				{
+					self.monsterinfo.search.think(self);
+					self.monsterinfo.idle_time = GameBase.level.time + 15 + Lib.random() * 15;
+				}
+				else
+				{
+					self.monsterinfo.idle_time = GameBase.level.time + Lib.random() * 15;
+				}
+			}
+		}
+	};
+	/*
+	=============
+	ai_stand
+	
+	Used for standing around and looking for players
+	Distance is for slight position adjustments needed by the animations
+	==============
+	*/
+
+	public static AIAdapter ai_stand = new AIAdapter()
+	{
+		public void ai(edict_t self, float dist)
+		{
+			float[] v = { 0, 0, 0 };
+
+			if (dist != 0)
+				M.M_walkmove(self, self.s.angles[Defines.YAW], dist);
+
+			if ((self.monsterinfo.aiflags & Defines.AI_STAND_GROUND) != 0)
+			{
+				if (self.enemy != null)
+				{
+					Math3D.VectorSubtract(self.enemy.s.origin, self.s.origin, v);
+					self.ideal_yaw = Math3D.vectoyaw(v);
+					if (self.s.angles[Defines.YAW] != self.ideal_yaw
+						&& 0 != (self.monsterinfo.aiflags & Defines.AI_TEMP_STAND_GROUND))
+					{
+						self.monsterinfo.aiflags &= ~(Defines.AI_STAND_GROUND | Defines.AI_TEMP_STAND_GROUND);
+						self.monsterinfo.run.think(self);
+					}
+					M.M_ChangeYaw(self);
+					GameAI.ai_checkattack(self, 0);
+				}
+				else
+					GameUtil.FindTarget(self);
+				return;
+			}
+
+			if (GameUtil.FindTarget(self))
+				return;
+
+			if (GameBase.level.time > self.monsterinfo.pausetime)
+			{
+				self.monsterinfo.walk.think(self);
+				return;
+			}
+
+			if (0 == (self.spawnflags & 1) && (self.monsterinfo.idle != null) && (GameBase.level.time > self.monsterinfo.idle_time))
+			{
+				if (self.monsterinfo.idle_time != 0)
+				{
+					self.monsterinfo.idle.think(self);
+					self.monsterinfo.idle_time = GameBase.level.time + 15 + Lib.random() * 15;
+				}
+				else
+				{
+					self.monsterinfo.idle_time = GameBase.level.time + Lib.random() * 15;
+				}
+			}
+		}
+	};
+	/*
+	=============
+	ai_charge
+	
+	Turns towards target and advances
+	Use this call with a distnace of 0 to replace ai_face
+	==============
+	*/
+	public static AIAdapter ai_charge = new AIAdapter()
+	{
+
+		public void ai(edict_t self, float dist)
+		{
+			float[] v = { 0, 0, 0 };
+
+			Math3D.VectorSubtract(self.enemy.s.origin, self.s.origin, v);
+			self.ideal_yaw = Math3D.vectoyaw(v);
+			M.M_ChangeYaw(self);
+
+			if (dist != 0)
+				M.M_walkmove(self, self.s.angles[Defines.YAW], dist);
+		}
+	};
+	/*
+	=============
+	ai_run
+	
+	The monster has an enemy it is trying to kill
+	=============
+	*/ //ok
+	public static AIAdapter ai_run = new AIAdapter()
+	{
+		public void ai(edict_t self, float dist)
+		{
+			float[] v = { 0, 0, 0 };
+
+			edict_t tempgoal;
+			edict_t save;
+			boolean new1;
+			edict_t marker;
+			float d1, d2;
+			trace_t tr; // mem
+			float[] v_forward = { 0, 0, 0 }, v_right = { 0, 0, 0 };
+			float left, center, right;
+			float[] left_target = { 0, 0, 0 }, right_target = { 0, 0, 0 };
+
+			// if we're going to a combat point, just proceed
+			if ((self.monsterinfo.aiflags & Defines.AI_COMBAT_POINT) != 0)
+			{
+				M.M_MoveToGoal(self, dist);
+				return;
+			}
+
+			if ((self.monsterinfo.aiflags & Defines.AI_SOUND_TARGET) != 0)
+			{
+				Math3D.VectorSubtract(self.s.origin, self.enemy.s.origin, v);
+				if (Math3D.VectorLength(v) < 64)
+				{
+					self.monsterinfo.aiflags |= (Defines.AI_STAND_GROUND | Defines.AI_TEMP_STAND_GROUND);
+					self.monsterinfo.stand.think(self);
+					return;
+				}
+
+				M.M_MoveToGoal(self, dist);
+
+				if (!GameUtil.FindTarget(self))
+					return;
+			}
+
+			if (GameAI.ai_checkattack(self, dist))
+				return;
+
+			if (self.monsterinfo.attack_state == Defines.AS_SLIDING)
+			{
+				GameAI.ai_run_slide(self, dist);
+				return;
+			}
+
+			if (GameUtilAdapters.enemy_vis)
+			{
+				//			if (self.aiflags & AI_LOST_SIGHT)
+				//				dprint("regained sight\n");
+				M.M_MoveToGoal(self, dist);
+				self.monsterinfo.aiflags &= ~Defines.AI_LOST_SIGHT;
+				Math3D.VectorCopy(self.enemy.s.origin, self.monsterinfo.last_sighting);
+				self.monsterinfo.trail_time = GameBase.level.time;
+				return;
+			}
+
+			// coop will change to another enemy if visible
+			if (GameBase.coop.value != 0)
+			{
+				// FIXME: insane guys get mad with this, which causes crashes!
+				if (GameUtil.FindTarget(self))
+					return;
+			}
+
+			if ((self.monsterinfo.search_time != 0) && (GameBase.level.time > (self.monsterinfo.search_time + 20)))
+			{
+				M.M_MoveToGoal(self, dist);
+				self.monsterinfo.search_time = 0;
+				//			dprint("search timeout\n");
+				return;
+			}
+
+			save = self.goalentity;
+			tempgoal = GameUtil.G_Spawn();
+			self.goalentity = tempgoal;
+
+			new1 = false;
+
+			if (0 == (self.monsterinfo.aiflags & Defines.AI_LOST_SIGHT))
+			{
+				// just lost sight of the player, decide where to go first
+				//			dprint("lost sight of player, last seen at "); dprint(vtos(self.last_sighting)); dprint("\n");
+				self.monsterinfo.aiflags |= (Defines.AI_LOST_SIGHT | Defines.AI_PURSUIT_LAST_SEEN);
+				self.monsterinfo.aiflags &= ~(Defines.AI_PURSUE_NEXT | Defines.AI_PURSUE_TEMP);
+				new1 = true;
+			}
+
+			if ((self.monsterinfo.aiflags & Defines.AI_PURSUE_NEXT) != 0)
+			{
+				self.monsterinfo.aiflags &= ~Defines.AI_PURSUE_NEXT;
+				//			dprint("reached current goal: "); dprint(vtos(self.origin)); dprint(" "); dprint(vtos(self.last_sighting)); dprint(" "); dprint(ftos(vlen(self.origin - self.last_sighting))); dprint("\n");
+
+				// give ourself more time since we got this far
+				self.monsterinfo.search_time = GameBase.level.time + 5;
+
+				if ((self.monsterinfo.aiflags & Defines.AI_PURSUE_TEMP) != 0)
+				{
+					//				dprint("was temp goal; retrying original\n");
+					self.monsterinfo.aiflags &= ~Defines.AI_PURSUE_TEMP;
+					marker = null;
+					Math3D.VectorCopy(self.monsterinfo.saved_goal, self.monsterinfo.last_sighting);
+					new1 = true;
+				}
+				else if ((self.monsterinfo.aiflags & Defines.AI_PURSUIT_LAST_SEEN) != 0)
+				{
+					self.monsterinfo.aiflags &= ~Defines.AI_PURSUIT_LAST_SEEN;
+					marker = PlayerTrail.PickFirst(self);
+				}
+				else
+				{
+					marker = PlayerTrail.PickNext(self);
+				}
+
+				if (marker != null)
+				{
+					Math3D.VectorCopy(marker.s.origin, self.monsterinfo.last_sighting);
+					self.monsterinfo.trail_time = marker.timestamp;
+					self.s.angles[Defines.YAW] = self.ideal_yaw = marker.s.angles[Defines.YAW];
+					//				dprint("heading is "); dprint(ftos(self.ideal_yaw)); dprint("\n");
+
+					//				debug_drawline(self.origin, self.last_sighting, 52);
+					new1 = true;
+				}
+			}
+
+			Math3D.VectorSubtract(self.s.origin, self.monsterinfo.last_sighting, v);
+			d1 = Math3D.VectorLength(v);
+			if (d1 <= dist)
+			{
+				self.monsterinfo.aiflags |= Defines.AI_PURSUE_NEXT;
+				dist = d1;
+			}
+
+			Math3D.VectorCopy(self.monsterinfo.last_sighting, self.goalentity.s.origin);
+
+			if (new1)
+			{
+				//			gi.dprintf("checking for course correction\n");
+
+				tr =
+					GameBase.gi.trace(
+						self.s.origin,
+						self.mins,
+						self.maxs,
+						self.monsterinfo.last_sighting,
+						self,
+						Defines.MASK_PLAYERSOLID);
+				if (tr.fraction < 1)
+				{
+					Math3D.VectorSubtract(self.goalentity.s.origin, self.s.origin, v);
+					d1 = Math3D.VectorLength(v);
+					center = tr.fraction;
+					d2 = d1 * ((center + 1) / 2);
+					self.s.angles[Defines.YAW] = self.ideal_yaw = Math3D.vectoyaw(v);
+					Math3D.AngleVectors(self.s.angles, v_forward, v_right, null);
+
+					Math3D.VectorSet(v, d2, -16, 0);
+					Math3D.G_ProjectSource(self.s.origin, v, v_forward, v_right, left_target);
+					tr = GameBase.gi.trace(self.s.origin, self.mins, self.maxs, left_target, self, Defines.MASK_PLAYERSOLID);
+					left = tr.fraction;
+
+					Math3D.VectorSet(v, d2, 16, 0);
+					Math3D.G_ProjectSource(self.s.origin, v, v_forward, v_right, right_target);
+					tr = GameBase.gi.trace(self.s.origin, self.mins, self.maxs, right_target, self, Defines.MASK_PLAYERSOLID);
+					right = tr.fraction;
+
+					center = (d1 * center) / d2;
+					if (left >= center && left > right)
+					{
+						if (left < 1)
+						{
+							Math3D.VectorSet(v, d2 * left * 0.5f, -16f, 0f);
+							Math3D.G_ProjectSource(self.s.origin, v, v_forward, v_right, left_target);
+							//						gi.dprintf("incomplete path, go part way and adjust again\n");
+						}
+						Math3D.VectorCopy(self.monsterinfo.last_sighting, self.monsterinfo.saved_goal);
+						self.monsterinfo.aiflags |= Defines.AI_PURSUE_TEMP;
+						Math3D.VectorCopy(left_target, self.goalentity.s.origin);
+						Math3D.VectorCopy(left_target, self.monsterinfo.last_sighting);
+						Math3D.VectorSubtract(self.goalentity.s.origin, self.s.origin, v);
+						self.s.angles[Defines.YAW] = self.ideal_yaw = Math3D.vectoyaw(v);
+						//					gi.dprintf("adjusted left\n");
+						//					debug_drawline(self.origin, self.last_sighting, 152);
+					}
+					else if (right >= center && right > left)
+					{
+						if (right < 1)
+						{
+							Math3D.VectorSet(v, d2 * right * 0.5f, 16f, 0f);
+							Math3D.G_ProjectSource(self.s.origin, v, v_forward, v_right, right_target);
+							//						gi.dprintf("incomplete path, go part way and adjust again\n");
+						}
+						Math3D.VectorCopy(self.monsterinfo.last_sighting, self.monsterinfo.saved_goal);
+						self.monsterinfo.aiflags |= Defines.AI_PURSUE_TEMP;
+						Math3D.VectorCopy(right_target, self.goalentity.s.origin);
+						Math3D.VectorCopy(right_target, self.monsterinfo.last_sighting);
+						Math3D.VectorSubtract(self.goalentity.s.origin, self.s.origin, v);
+						self.s.angles[Defines.YAW] = self.ideal_yaw = Math3D.vectoyaw(v);
+						//					gi.dprintf("adjusted right\n");
+						//					debug_drawline(self.origin, self.last_sighting, 152);
+					}
+				}
+				//			else gi.dprintf("course was fine\n");
+			}
+
+			M.M_MoveToGoal(self, dist);
+
+			GameUtil.G_FreeEdict(tempgoal);
+
+			if (self != null)
+				self.goalentity = save;
+		}
+	};
+	public static EntInteractAdapter Pickup_Ammo = new EntInteractAdapter()
+	{
+		public boolean interact(edict_t ent, edict_t other)
+		{
+			int oldcount;
+			int count;
+			boolean weapon;
+
+			weapon = (ent.item.flags & Defines.IT_WEAPON) != 0;
+			if ((weapon) && ((int) GameBase.dmflags.value & Defines.DF_INFINITE_AMMO) != 0)
+				count = 1000;
+			else if (ent.count != 0)
+				count = ent.count;
+			else
+				count = ent.item.quantity;
+
+			oldcount = other.client.pers.inventory[GameUtil.ITEM_INDEX(ent.item)];
+
+			if (!GameAI.Add_Ammo(other, ent.item, count))
+				return false;
+
+			if (weapon && 0 == oldcount)
+			{
+				if (other.client.pers.weapon != ent.item
+					&& (0 == GameBase.deathmatch.value || other.client.pers.weapon == GameUtil.FindItem("blaster")))
+					other.client.newweapon = ent.item;
+			}
+
+			if (0 == (ent.spawnflags & (Defines.DROPPED_ITEM | Defines.DROPPED_PLAYER_ITEM)) && (GameBase.deathmatch.value != 0))
+				GameUtil.SetRespawn(ent, 30);
+			return true;
+		}
+	};
+	public static EntInteractAdapter Pickup_Armor = new EntInteractAdapter()
+	{
+		public boolean interact(edict_t ent, edict_t other)
+		{
+			int old_armor_index;
+			gitem_armor_t oldinfo;
+			gitem_armor_t newinfo;
+			int newcount;
+			float salvage;
+			int salvagecount;
+
+			// get info on new armor
+			newinfo = (gitem_armor_t) ent.item.info;
+
+			old_armor_index = GameUtil.ArmorIndex(other);
+
+			// handle armor shards specially
+			if (ent.item.tag == Defines.ARMOR_SHARD)
+			{
+				if (0 == old_armor_index)
+					other.client.pers.inventory[GameUtilAdapters.jacket_armor_index] = 2;
+				else
+					other.client.pers.inventory[old_armor_index] += 2;
+			}
+
+			// if player has no armor, just use it
+			else if (0 == old_armor_index)
+			{
+				other.client.pers.inventory[GameUtil.ITEM_INDEX(ent.item)] = newinfo.base_count;
+			}
+
+			// use the better armor
+			else
+			{
+				// get info on old armor
+				if (old_armor_index == GameUtilAdapters.jacket_armor_index)
+					oldinfo = jacketarmor_info;
+
+				else if (old_armor_index == GameUtilAdapters.combat_armor_index)
+					oldinfo = combatarmor_info;
+
+				else // (old_armor_index == body_armor_index)
+					oldinfo = bodyarmor_info;
+
+				if (newinfo.normal_protection > oldinfo.normal_protection)
+				{
+					// calc new armor values
+					salvage = oldinfo.normal_protection / newinfo.normal_protection;
+					salvagecount = (int) salvage * other.client.pers.inventory[old_armor_index];
+					newcount = newinfo.base_count + salvagecount;
+					if (newcount > newinfo.max_count)
+						newcount = newinfo.max_count;
+
+					// zero count of old armor so it goes away
+					other.client.pers.inventory[old_armor_index] = 0;
+
+					// change armor to new item with computed value
+					other.client.pers.inventory[GameUtil.ITEM_INDEX(ent.item)] = newcount;
+				}
+				else
+				{
+					// calc new armor values
+					salvage = newinfo.normal_protection / oldinfo.normal_protection;
+					salvagecount = (int) salvage * newinfo.base_count;
+					newcount = other.client.pers.inventory[old_armor_index] + salvagecount;
+					if (newcount > oldinfo.max_count)
+						newcount = oldinfo.max_count;
+
+					// if we're already maxed out then we don't need the new armor
+					if (other.client.pers.inventory[old_armor_index] >= newcount)
+						return false;
+
+					// update current armor value
+					other.client.pers.inventory[old_armor_index] = newcount;
+				}
+			}
+
+			if (0 == (ent.spawnflags & Defines.DROPPED_ITEM) && (GameBase.deathmatch.value == 0))
+				GameUtil.SetRespawn(ent, 20);
+
+			return true;
+		}
+	};
+	public static EntInteractAdapter Pickup_PowerArmor = new EntInteractAdapter()
+	{
+		public boolean interact(edict_t ent, edict_t other)
+		{
+
+			int quantity;
+
+			quantity = other.client.pers.inventory[GameUtil.ITEM_INDEX(ent.item)];
+
+			other.client.pers.inventory[GameUtil.ITEM_INDEX(ent.item)]++;
+
+			if (GameBase.deathmatch.value != 0)
+			{
+				if (0 == (ent.spawnflags & Defines.DROPPED_ITEM))
+					GameUtil.SetRespawn(ent, ent.item.quantity);
+				// auto-use for DM only if we didn't already have one
+				if (0 == quantity)
+					ent.item.use.use(other, ent.item);
+			}
+			return true;
+		}
+	};
+	//	======================================================================
+
+	public static EntInteractAdapter Pickup_Powerup = new EntInteractAdapter()
+	{
+
+		public boolean interact(edict_t ent, edict_t other)
+		{
+			int quantity;
+
+			quantity = other.client.pers.inventory[GameUtil.ITEM_INDEX(ent.item)];
+			if ((GameBase.skill.value == 1 && quantity >= 2) || (GameBase.skill.value >= 2 && quantity >= 1))
+				return false;
+
+			if ((GameBase.coop.value != 0) && (ent.item.flags & Defines.IT_STAY_COOP) != 0 && (quantity > 0))
+				return false;
+
+			other.client.pers.inventory[GameUtil.ITEM_INDEX(ent.item)]++;
+
+			if (GameBase.deathmatch.value != 0)
+			{
+				if (0 == (ent.spawnflags & Defines.DROPPED_ITEM))
+					GameUtil.SetRespawn(ent, ent.item.quantity);
+				if (((int) GameBase.dmflags.value & Defines.DF_INSTANT_ITEMS) != 0
+					|| ((ent.item.use == GameUtilAdapters.Use_Quad) && 0 != (ent.spawnflags & Defines.DROPPED_PLAYER_ITEM)))
+				{
+					if ((ent.item.use == GameUtilAdapters.Use_Quad) && 0 != (ent.spawnflags & Defines.DROPPED_PLAYER_ITEM))
+						GameUtilAdapters.quad_drop_timeout_hack = (int) ((ent.nextthink - GameBase.level.time) / Defines.FRAMETIME);
+
+					ent.item.use.use(other, ent.item);
+				}
+			}
+
+			return true;
+		}
+	};
+	public static EntInteractAdapter Pickup_Adrenaline = new EntInteractAdapter()
+	{
+		public boolean interact(edict_t ent, edict_t other)
+		{
+			if (GameBase.deathmatch.value == 0)
+				other.max_health += 1;
+
+			if (other.health < other.max_health)
+				other.health = other.max_health;
+
+			if (0 == (ent.spawnflags & Defines.DROPPED_ITEM) && (GameBase.deathmatch.value != 0))
+				GameUtil.SetRespawn(ent, ent.item.quantity);
+
+			return true;
+
+		}
+	};
+	public static EntInteractAdapter Pickup_AncientHead = new EntInteractAdapter()
+	{
+		public boolean interact(edict_t ent, edict_t other)
+		{
+			other.max_health += 2;
+
+			if (0 == (ent.spawnflags & Defines.DROPPED_ITEM) && (GameBase.deathmatch.value != 0))
+				GameUtil.SetRespawn(ent, ent.item.quantity);
+
+			return true;
+		}
+	};
+	public static EntInteractAdapter Pickup_Bandolier = new EntInteractAdapter()
+	{
+		public boolean interact(edict_t ent, edict_t other)
+		{
+			gitem_t item;
+			int index;
+
+			if (other.client.pers.max_bullets < 250)
+				other.client.pers.max_bullets = 250;
+			if (other.client.pers.max_shells < 150)
+				other.client.pers.max_shells = 150;
+			if (other.client.pers.max_cells < 250)
+				other.client.pers.max_cells = 250;
+			if (other.client.pers.max_slugs < 75)
+				other.client.pers.max_slugs = 75;
+
+			item = GameUtil.FindItem("Bullets");
+			if (item != null)
+			{
+				index = GameUtil.ITEM_INDEX(item);
+				other.client.pers.inventory[index] += item.quantity;
+				if (other.client.pers.inventory[index] > other.client.pers.max_bullets)
+					other.client.pers.inventory[index] = other.client.pers.max_bullets;
+			}
+
+			item = GameUtil.FindItem("Shells");
+			if (item != null)
+			{
+				index = GameUtil.ITEM_INDEX(item);
+				other.client.pers.inventory[index] += item.quantity;
+				if (other.client.pers.inventory[index] > other.client.pers.max_shells)
+					other.client.pers.inventory[index] = other.client.pers.max_shells;
+			}
+
+			if (0 == (ent.spawnflags & Defines.DROPPED_ITEM) && (GameBase.deathmatch.value != 0))
+				GameUtil.SetRespawn(ent, ent.item.quantity);
+
+			return true;
+
+		}
+	};
+	public static EntUseAdapter Use_Item = new EntUseAdapter()
+	{
+		public void use(edict_t ent, edict_t other, edict_t activator)
+		{
+			ent.svflags &= ~Defines.SVF_NOCLIENT;
+			ent.use = null;
+
+			if ((ent.spawnflags & Defines.ITEM_NO_TOUCH) != 0)
+			{
+				ent.solid = Defines.SOLID_BBOX;
+				ent.touch = null;
+			}
+			else
+			{
+				ent.solid = Defines.SOLID_TRIGGER;
+				ent.touch = GameUtilAdapters.Touch_Item;
+			}
+
+			GameBase.gi.linkentity(ent);
+		}
+	};
+	/*
+	================
+	droptofloor
+	================
+	*/
+
+	public static EntThinkAdapter droptofloor = new EntThinkAdapter()
+	{
+		public boolean think(edict_t ent)
+		{
+			trace_t tr;
+			float[] dest = { 0, 0, 0 };
+
+			float v[];
+
+			v = Lib.tv(-15, -15, -15);
+			Math3D.VectorCopy(v, ent.mins);
+			v = Lib.tv(15, 15, 15);
+			Math3D.VectorCopy(v, ent.maxs);
+
+			if (ent.model != null)
+				GameBase.gi.setmodel(ent, ent.model);
+			else
+				GameBase.gi.setmodel(ent, ent.item.world_model);
+			ent.solid = Defines.SOLID_TRIGGER;
+			ent.movetype = Defines.MOVETYPE_TOSS;
+			ent.touch = GameUtilAdapters.Touch_Item;
+
+			v = Lib.tv(0, 0, -128);
+			Math3D.VectorAdd(ent.s.origin, v, dest);
+
+			tr = GameBase.gi.trace(ent.s.origin, ent.mins, ent.maxs, dest, ent, Defines.MASK_SOLID);
+			if (tr.startsolid)
+			{
+				GameBase.gi.dprintf("droptofloor: " + ent.classname + " startsolid at " + Lib.vtos(ent.s.origin) + "\n");
+				GameUtil.G_FreeEdict(ent);
+				return true;
+			}
+
+			Math3D.VectorCopy(tr.endpos, ent.s.origin);
+
+			if (ent.team != null)
+			{
+				ent.flags &= ~Defines.FL_TEAMSLAVE;
+				ent.chain = ent.teamchain;
+				ent.teamchain = null;
+
+				ent.svflags |= Defines.SVF_NOCLIENT;
+				ent.solid = Defines.SOLID_NOT;
+				if (ent == ent.teammaster)
+				{
+					ent.nextthink = GameBase.level.time + Defines.FRAMETIME;
+					ent.think = GameUtilAdapters.DoRespawn;
+				}
+			}
+
+			if ((ent.spawnflags & Defines.ITEM_NO_TOUCH) != 0)
+			{
+				ent.solid = Defines.SOLID_BBOX;
+				ent.touch = null;
+				ent.s.effects &= ~Defines.EF_ROTATE;
+				ent.s.renderfx &= ~Defines.RF_GLOW;
+			}
+
+			if ((ent.spawnflags & Defines.ITEM_TRIGGER_SPAWN) != 0)
+			{
+				ent.svflags |= Defines.SVF_NOCLIENT;
+				ent.solid = Defines.SOLID_NOT;
+				ent.use = Use_Item;
+			}
+
+			GameBase.gi.linkentity(ent);
+			return true;
+		}
+	};
+	public static EntThinkAdapter gib_think = new EntThinkAdapter()
+	{
+		public boolean think(edict_t self)
+		{
+			self.s.frame++;
+			self.nextthink = GameBase.level.time + Defines.FRAMETIME;
+
+			if (self.s.frame == 10)
+			{
+				self.think = GameUtilAdapters.G_FreeEdictA;
+				self.nextthink = GameBase.level.time + 8 + Lib.random() * 10;
+			}
+			return true;
+		}
+	};
+	public static EntTouchAdapter gib_touch = new EntTouchAdapter()
+	{
+		public void touch(edict_t self, edict_t other, cplane_t plane, csurface_t surf)
+		{
+			float[] normal_angles = { 0, 0, 0 }, right = { 0, 0, 0 };
+
+			if (null == self.groundentity)
+				return;
+
+			self.touch = null;
+
+			if (plane != null)
+			{
+				GameBase.gi.sound(self, Defines.CHAN_VOICE, GameBase.gi.soundindex("misc/fhit3.wav"), 1, Defines.ATTN_NORM, 0);
+
+				Math3D.vectoangles(plane.normal, normal_angles);
+				Math3D.AngleVectors(normal_angles, null, right, null);
+				Math3D.vectoangles(right, self.s.angles);
+
+				if (self.s.modelindex == GameBase.sm_meat_index)
+				{
+					self.s.frame++;
+					self.think = gib_think;
+					self.nextthink = GameBase.level.time + Defines.FRAMETIME;
+				}
+			}
+		}
+	};
+	public static EntDieAdapter gib_die = new EntDieAdapter()
+	{
+		public void die(edict_t self, edict_t inflictor, edict_t attacker, int damage, float[] point)
+		{
+			GameUtil.G_FreeEdict(self);
+		}
+	};
+	/*
+	=================
+	debris
+	=================
+	*/
+	public static EntDieAdapter debris_die = new EntDieAdapter()
+	{
+
+		public void die(edict_t self, edict_t inflictor, edict_t attacker, int damage, float[] point)
+		{
+			GameUtil.G_FreeEdict(self);
+		}
+	};
+	public static int player_die_i = 0;
+	/*
+	==================
+	player_die
+	==================
+	*/
+	static EntDieAdapter player_die = new EntDieAdapter()
+	{
+		public void die(edict_t self, edict_t inflictor, edict_t attacker, int damage, float[] point)
+		{
+			int n;
+
+			Math3D.VectorClear(self.avelocity);
+
+			self.takedamage = Defines.DAMAGE_YES;
+			self.movetype = Defines.MOVETYPE_TOSS;
+
+			self.s.modelindex2 = 0; // remove linked weapon model
+
+			self.s.angles[0] = 0;
+			self.s.angles[2] = 0;
+
+			self.s.sound = 0;
+			self.client.weapon_sound = 0;
+
+			self.maxs[2] = -8;
+
+			//		self.solid = SOLID_NOT;
+			self.svflags |= Defines.SVF_DEADMONSTER;
+
+			if (self.deadflag == 0)
+			{
+				self.client.respawn_time = GameBase.level.time + 1.0f;
+				GameAI.LookAtKiller(self, inflictor, attacker);
+				self.client.ps.pmove.pm_type = Defines.PM_DEAD;
+				GameAI.ClientObituary(self, inflictor, attacker);
+				GameAI.TossClientWeapon(self);
+				if (GameBase.deathmatch.value != 0)
+					Cmd.Help_f(self); // show scores
+
+				// clear inventory
+				// this is kind of ugly, but it's how we want to handle keys in coop
+				for (n = 0; n < GameBase.game.num_items; n++)
+				{
+					if (GameBase.coop.value != 0 && (GameAI.itemlist[n].flags & Defines.IT_KEY) != 0)
+						self.client.resp.coop_respawn.inventory[n] = self.client.pers.inventory[n];
+					self.client.pers.inventory[n] = 0;
+				}
+			}
+
+			// remove powerups
+			self.client.quad_framenum = 0;
+			self.client.invincible_framenum = 0;
+			self.client.breather_framenum = 0;
+			self.client.enviro_framenum = 0;
+			self.flags &= ~Defines.FL_POWER_ARMOR;
+
+			if (self.health < -40)
+			{ // gib
+				GameBase.gi.sound(self, Defines.CHAN_BODY, GameBase.gi.soundindex("misc/udeath.wav"), 1, Defines.ATTN_NORM, 0);
+				for (n = 0; n < 4; n++)
+					GameAI.ThrowGib(self, "models/objects/gibs/sm_meat/tris.md2", damage, Defines.GIB_ORGANIC);
+				GameAI.ThrowClientHead(self, damage);
+
+				self.takedamage = Defines.DAMAGE_NO;
+			}
+			else
+			{ // normal death
+				if (self.deadflag == 0)
+				{
+
+					player_die_i = (player_die_i + 1) % 3;
+					// start a death animation
+					self.client.anim_priority = Defines.ANIM_DEATH;
+					if ((self.client.ps.pmove.pm_flags & Defines.PMF_DUCKED) != 0)
+					{
+						self.s.frame = M_Player.FRAME_crdeath1 - 1;
+						self.client.anim_end = M_Player.FRAME_crdeath5;
+					}
+					else
+						switch (player_die_i)
+						{
+							case 0 :
+								self.s.frame = M_Player.FRAME_death101 - 1;
+								self.client.anim_end = M_Player.FRAME_death106;
+								break;
+							case 1 :
+								self.s.frame = M_Player.FRAME_death201 - 1;
+								self.client.anim_end = M_Player.FRAME_death206;
+								break;
+							case 2 :
+								self.s.frame = M_Player.FRAME_death301 - 1;
+								self.client.anim_end = M_Player.FRAME_death308;
+								break;
+						}
+
+					GameBase.gi.sound(
+						self,
+						Defines.CHAN_VOICE,
+						GameBase.gi.soundindex("*death" + ((Lib.rand() % 4) + 1) + ".wav"),
+						1,
+						Defines.ATTN_NORM,
+						0);
+				}
+			}
+
+			self.deadflag = Defines.DEAD_DEAD;
+
+			GameBase.gi.linkentity(self);
+		}
+	};
+	public static Comparator PlayerSort = new Comparator()
+	{
+		public int compare(Object o1, Object o2)
+		{
+			int anum = ((Integer) o1).intValue();
+			int bnum = ((Integer) o2).intValue();
+
+			int anum1 = GameBase.game.clients[anum].ps.stats[Defines.STAT_FRAGS];
+			int bnum1 = GameBase.game.clients[bnum].ps.stats[Defines.STAT_FRAGS];
+
+			if (anum1 < bnum1)
+				return -1;
+			if (anum1 > bnum1)
+				return 1;
+			return 0;
+		}
+	};
+	public static ItemUseAdapter Use_PowerArmor = new ItemUseAdapter()
+	{
+		public void use(edict_t ent, gitem_t item)
+		{
+			int index;
+
+			if ((ent.flags & Defines.FL_POWER_ARMOR) != 0)
+			{
+				ent.flags &= ~Defines.FL_POWER_ARMOR;
+				GameBase.gi.sound(ent, Defines.CHAN_AUTO, GameBase.gi.soundindex("misc/power2.wav"), 1, Defines.ATTN_NORM, 0);
+			}
+			else
+			{
+				index = GameUtil.ITEM_INDEX(GameUtil.FindItem("cells"));
+				if (0 == ent.client.pers.inventory[index])
+				{
+					GameBase.gi.cprintf(ent, Defines.PRINT_HIGH, "No cells for power armor.\n");
+					return;
+				}
+				ent.flags |= Defines.FL_POWER_ARMOR;
+				GameBase.gi.sound(ent, Defines.CHAN_AUTO, GameBase.gi.soundindex("misc/power1.wav"), 1, Defines.ATTN_NORM, 0);
+			}
+		}
+	};
+	public static ItemDropAdapter Drop_Ammo = new ItemDropAdapter()
+	{
+		public void drop(edict_t ent, gitem_t item)
+		{
+			edict_t dropped;
+			int index;
+
+			index = GameUtil.ITEM_INDEX(item);
+			dropped = GameUtil.Drop_Item(ent, item);
+			if (ent.client.pers.inventory[index] >= item.quantity)
+				dropped.count = item.quantity;
+			else
+				dropped.count = ent.client.pers.inventory[index];
+
+			if (ent.client.pers.weapon != null
+				&& ent.client.pers.weapon.tag == Defines.AMMO_GRENADES
+				&& item.tag == Defines.AMMO_GRENADES
+				&& ent.client.pers.inventory[index] - dropped.count <= 0)
+			{
+				GameBase.gi.cprintf(ent, Defines.PRINT_HIGH, "Can't drop current weapon\n");
+				GameUtil.G_FreeEdict(dropped);
+				return;
+			}
+
+			ent.client.pers.inventory[index] -= dropped.count;
+			GameAI.ValidateSelectedItem(ent);
+		}
+	};
+	public static ItemDropAdapter Drop_General = new ItemDropAdapter()
+	{
+		public void drop(edict_t ent, gitem_t item)
+		{
+			GameUtil.Drop_Item(ent, item);
+			ent.client.pers.inventory[GameUtil.ITEM_INDEX(item)]--;
+			GameAI.ValidateSelectedItem(ent);
+		}
+	};
+	public static ItemDropAdapter Drop_PowerArmor = new ItemDropAdapter()
+	{
+		public void drop(edict_t ent, gitem_t item)
+		{
+			if (0 != (ent.flags & Defines.FL_POWER_ARMOR) && (ent.client.pers.inventory[GameUtil.ITEM_INDEX(item)] == 1))
+				Use_PowerArmor.use(ent, item);
+			Drop_General.drop(ent, item);
+		}
+	};
+	public static gitem_armor_t jacketarmor_info = new gitem_armor_t(25, 50, .30f, .00f, Defines.ARMOR_JACKET);
+	public static gitem_armor_t combatarmor_info = new gitem_armor_t(50, 100, .60f, .30f, Defines.ARMOR_COMBAT);
+	public static gitem_armor_t bodyarmor_info = new gitem_armor_t(100, 200, .80f, .60f, Defines.ARMOR_BODY);
+}