cleanups and base3 bugfix for the load and save routines.

6 files changed, 882 insertions, 1304 deletions

diff --git a/src/jake2/game/GameBase.java b/src/jake2/game/GameBase.java
index db2b3f0..cdec20b 100644
--- a/src/jake2/game/GameBase.java
+++ b/src/jake2/game/GameBase.java
@@ -19,7 +19,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 
 // Created on 30.11.2003 by RST.
-// $Id: GameBase.java,v 1.4 2004-08-20 21:29:58 salomo Exp $
+// $Id: GameBase.java,v 1.5 2004-08-22 14:25:11 salomo Exp $
 
 /** Father of all GameObjects. */
 
@@ -33,181 +33,88 @@ import jake2.qcommon.Com;
 import jake2.server.*;
 import jake2.util.*;
 
-public class GameBase extends Globals
-{
-	public static cplane_t dummyplane = new cplane_t(); 
-	public static game_locals_t game = new game_locals_t();
-	public static level_locals_t level = new level_locals_t();
-	public static game_import_t gi = new game_import_t();
-	public static game_export_t globals = new game_export_t();
-	public static spawn_temp_t st = new spawn_temp_t();
+public class GameBase extends Globals {
+	public static cplane_t dummyplane= new cplane_t();
+	public static game_locals_t game= new game_locals_t();
+	public static level_locals_t level= new level_locals_t();
+	public static game_import_t gi= new game_import_t();
+	public static game_export_t globals= new game_export_t();
+	public static spawn_temp_t st= new spawn_temp_t();
 
 	public static int sm_meat_index;
 	public static int snd_fry;
 	public static int meansOfDeath;
 
-	public static edict_t g_edicts[] = new edict_t[MAX_EDICTS];
+	public static edict_t g_edicts[]= new edict_t[MAX_EDICTS];
 	static {
-		for (int n = 0; n < MAX_EDICTS; n++)
-			g_edicts[n] = new edict_t(n);
+		for (int n= 0; n < MAX_EDICTS; n++)
+			g_edicts[n]= new edict_t(n);
 	}
 
-	public static cvar_t deathmatch = new cvar_t();
-	public static cvar_t coop = new cvar_t();
-	public static cvar_t dmflags = new cvar_t();
+	public static cvar_t deathmatch= new cvar_t();
+	public static cvar_t coop= new cvar_t();
+	public static cvar_t dmflags= new cvar_t();
 	public static cvar_t skill; // = new cvar_t();
-	public static cvar_t fraglimit = new cvar_t();
-	public static cvar_t timelimit = new cvar_t();
-	public static cvar_t password = new cvar_t();
-	public static cvar_t spectator_password = new cvar_t();
-	public static cvar_t needpass = new cvar_t();
-	public static cvar_t maxclients = new cvar_t();
-	public static cvar_t maxspectators = new cvar_t();
-	public static cvar_t maxentities = new cvar_t();
-	public static cvar_t g_select_empty = new cvar_t();
-	public static cvar_t dedicated = new cvar_t();
-
-	public static cvar_t filterban = new cvar_t();
-
-	public static cvar_t sv_maxvelocity = new cvar_t();
-	public static cvar_t sv_gravity = new cvar_t();
-
-	public static cvar_t sv_rollspeed = new cvar_t();
-	public static cvar_t sv_rollangle = new cvar_t();
-	public static cvar_t gun_x = new cvar_t();
-	public static cvar_t gun_y = new cvar_t();
-	public static cvar_t gun_z = new cvar_t();
-
-	public static cvar_t run_pitch = new cvar_t();
-	public static cvar_t run_roll = new cvar_t();
-	public static cvar_t bob_up = new cvar_t();
-	public static cvar_t bob_pitch = new cvar_t();
-	public static cvar_t bob_roll = new cvar_t();
-
-	public static cvar_t sv_cheats = new cvar_t();
-
-	public static cvar_t flood_msgs = new cvar_t();
-	public static cvar_t flood_persecond = new cvar_t();
-	public static cvar_t flood_waitdelay = new cvar_t();
-
-	public static cvar_t sv_maplist = new cvar_t();
-
-	public final static float STOP_EPSILON = 0.1f;
-
-	static field_t fields_ent[] =
-		new field_t[] {
-			new field_t("classname", F_LSTRING),
-			new field_t("model", F_LSTRING),
-			new field_t("spawnflags", F_INT),
-			new field_t("speed", F_FLOAT),
-			new field_t("accel", F_FLOAT),
-			new field_t("decel", F_FLOAT),
-			new field_t("target", F_LSTRING),
-			new field_t("targetname", F_LSTRING),
-			new field_t("pathtarget", F_LSTRING),
-			new field_t("deathtarget", F_LSTRING),
-			new field_t("killtarget", F_LSTRING),
-			new field_t("combattarget", F_LSTRING),
-			new field_t("message", F_LSTRING),
-			new field_t("team", F_LSTRING),
-			new field_t("wait", F_FLOAT),
-			new field_t("delay", F_FLOAT),
-			new field_t("random", F_FLOAT),
-			new field_t("move_origin", F_VECTOR),
-			new field_t("move_angles", F_VECTOR),
-			new field_t("style", F_INT),
-			new field_t("count", F_INT),
-			new field_t("health", F_INT),
-			new field_t("sounds", F_INT),
-			new field_t("light", F_IGNORE),
-			new field_t("dmg", F_INT),
-			new field_t("mass", F_INT),
-			new field_t("volume", F_FLOAT),
-			new field_t("attenuation", F_FLOAT),
-			new field_t("map", F_LSTRING),
-			new field_t("origin", F_VECTOR),
-			new field_t("angles", F_VECTOR),
-			new field_t("angle", F_ANGLEHACK),
-			new field_t("goalentity", F_EDICT, FFL_NOSPAWN),
-			new field_t("movetarget", F_EDICT, FFL_NOSPAWN),
-			new field_t("enemy", F_EDICT, FFL_NOSPAWN),
-			new field_t("oldenemy", F_EDICT, FFL_NOSPAWN),
-			new field_t("activator", F_EDICT, FFL_NOSPAWN),
-			new field_t("groundentity", F_EDICT, FFL_NOSPAWN),
-			new field_t("teamchain", F_EDICT, FFL_NOSPAWN),
-			new field_t("teammaster", F_EDICT, FFL_NOSPAWN),
-			new field_t("owner", F_EDICT, FFL_NOSPAWN),
-			new field_t("mynoise", F_EDICT, FFL_NOSPAWN),
-			new field_t("mynoise2", F_EDICT, FFL_NOSPAWN),
-			new field_t("target_ent", F_EDICT, FFL_NOSPAWN),
-			new field_t("chain", F_EDICT, FFL_NOSPAWN),
-			new field_t("prethink", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("think", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("blocked", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("touch", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("use", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("pain", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("die", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("stand", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("idle", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("search", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("walk", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("run", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("dodge", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("attack", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("melee", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("sight", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("checkattack", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("currentmove", F_MMOVE, FFL_NOSPAWN),
-			new field_t("endfunc", F_FUNCTION, FFL_NOSPAWN),
-			new field_t("item", F_ITEM)
-		//need for item field in edict struct, FFL_SPAWNTEMP item will be skipped on saves
-	};
+	public static cvar_t fraglimit= new cvar_t();
+	public static cvar_t timelimit= new cvar_t();
+	public static cvar_t password= new cvar_t();
+	public static cvar_t spectator_password= new cvar_t();
+	public static cvar_t needpass= new cvar_t();
+	public static cvar_t maxclients= new cvar_t();
+	public static cvar_t maxspectators= new cvar_t();
+	public static cvar_t maxentities= new cvar_t();
+	public static cvar_t g_select_empty= new cvar_t();
+	public static cvar_t dedicated= new cvar_t();
+
+	public static cvar_t filterban= new cvar_t();
+
+	public static cvar_t sv_maxvelocity= new cvar_t();
+	public static cvar_t sv_gravity= new cvar_t();
+
+	public static cvar_t sv_rollspeed= new cvar_t();
+	public static cvar_t sv_rollangle= new cvar_t();
+	public static cvar_t gun_x= new cvar_t();
+	public static cvar_t gun_y= new cvar_t();
+	public static cvar_t gun_z= new cvar_t();
+
+	public static cvar_t run_pitch= new cvar_t();
+	public static cvar_t run_roll= new cvar_t();
+	public static cvar_t bob_up= new cvar_t();
+	public static cvar_t bob_pitch= new cvar_t();
+	public static cvar_t bob_roll= new cvar_t();
+
+	public static cvar_t sv_cheats= new cvar_t();
+
+	public static cvar_t flood_msgs= new cvar_t();
+	public static cvar_t flood_persecond= new cvar_t();
+	public static cvar_t flood_waitdelay= new cvar_t();
+
+	public static cvar_t sv_maplist= new cvar_t();
 
-	// temp spawn vars -- only valid when the spawn function is called
-	static field_t fields_st[] =
-		{
-			new field_t("lip", F_INT, FFL_SPAWNTEMP),
-			new field_t("distance", F_INT, FFL_SPAWNTEMP),
-			new field_t("height", F_INT, FFL_SPAWNTEMP),
-			new field_t("noise", F_LSTRING, FFL_SPAWNTEMP),
-			new field_t("pausetime", F_FLOAT, FFL_SPAWNTEMP),
-			new field_t("item", F_LSTRING, FFL_SPAWNTEMP),
-			new field_t("gravity", F_LSTRING, FFL_SPAWNTEMP),
-			new field_t("sky", F_LSTRING, FFL_SPAWNTEMP),
-			new field_t("skyrotate", F_FLOAT, FFL_SPAWNTEMP),
-			new field_t("skyaxis", F_VECTOR, FFL_SPAWNTEMP),
-			new field_t("minyaw", F_FLOAT, FFL_SPAWNTEMP),
-			new field_t("maxyaw", F_FLOAT, FFL_SPAWNTEMP),
-			new field_t("minpitch", F_FLOAT, FFL_SPAWNTEMP),
-			new field_t("maxpitch", F_FLOAT, FFL_SPAWNTEMP),
-			new field_t("nextmap", F_LSTRING, FFL_SPAWNTEMP),
-			};
+	public final static float STOP_EPSILON= 0.1f;
 
 	/**
 	 * Slide off of the impacting object
 	 * returns the blocked flags (1 = floor, 2 = step / wall).
 	 */
-	public static int ClipVelocity(float[] in, float[] normal, float[] out, float overbounce)
-	{
+	public static int ClipVelocity(float[] in, float[] normal, float[] out, float overbounce) {
 		float backoff;
 		float change;
 		int i, blocked;
 
-		blocked = 0;
+		blocked= 0;
 		if (normal[2] > 0)
 			blocked |= 1; // floor
 		if (normal[2] == 0.0f)
 			blocked |= 2; // step
 
-		backoff = Math3D.DotProduct(in, normal) * overbounce;
+		backoff= Math3D.DotProduct(in, normal) * overbounce;
 
-		for (i = 0; i < 3; i++)
-		{
-			change = normal[i] * backoff;
-			out[i] = in[i] - change;
+		for (i= 0; i < 3; i++) {
+			change= normal[i] * backoff;
+			out[i]= in[i] - change;
 			if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
-				out[i] = 0;
+				out[i]= 0;
 		}
 
 		return blocked;
@@ -222,7 +129,7 @@ public class GameBase extends Globals
 	2 = wall / step
 	4 = dead stop
 	*/
-	public final static int MAX_CLIP_PLANES = 5;
+	public final static int MAX_CLIP_PLANES= 5;
 
 	/*
 	=============
@@ -242,19 +149,16 @@ public class GameBase extends Globals
 	 * Call with null as from parameter to search from array beginning.
 	 */
 
-	public static EdictIterator G_Find(EdictIterator from, EdictFindFilter eff, String s)
-	{
+	public static EdictIterator G_Find(EdictIterator from, EdictFindFilter eff, String s) {
 
 		if (from == null)
-			from = new EdictIterator(0);
+			from= new EdictIterator(0);
 		else
 			from.i++;
 
-		for (; from.i < globals.num_edicts; from.i++)
-		{
-			from.o = g_edicts[from.i];
-			if (from.o.classname == null)
-			{
+		for (; from.i < globals.num_edicts; from.i++) {
+			from.o= g_edicts[from.i];
+			if (from.o.classname == null) {
 				Com.Printf("edict with classname = null" + from.o.index);
 			}
 
@@ -269,9 +173,8 @@ public class GameBase extends Globals
 	}
 
 	// comfort version (rst)
-	public static edict_t G_FindEdict(EdictIterator from, EdictFindFilter eff, String s)
-	{
-		EdictIterator ei = G_Find(from, eff, s);
+	public static edict_t G_FindEdict(EdictIterator from, EdictFindFilter eff, String s) {
+		EdictIterator ei= G_Find(from, eff, s);
 		if (ei == null)
 			return null;
 		else
@@ -281,27 +184,25 @@ public class GameBase extends Globals
 	/** 
 	 * Returns entities that have origins within a spherical area.
 	*/
-	public static EdictIterator findradius(EdictIterator from, float[] org, float rad)
-	{
-		float[] eorg = { 0, 0, 0 };
+	public static EdictIterator findradius(EdictIterator from, float[] org, float rad) {
+		float[] eorg= { 0, 0, 0 };
 		int j;
 
 		if (from == null)
-			from = new EdictIterator(0);
+			from= new EdictIterator(0);
 		else
 			from.i++;
 
-		for (; from.i < globals.num_edicts; from.i++)
-		{
-			from.o = g_edicts[from.i];
+		for (; from.i < globals.num_edicts; from.i++) {
+			from.o= g_edicts[from.i];
 			if (!from.o.inuse)
 				continue;
 
 			if (from.o.solid == SOLID_NOT)
 				continue;
 
-			for (j = 0; j < 3; j++)
-				eorg[j] = org[j] - (from.o.s.origin[j] + (from.o.mins[j] + from.o.maxs[j]) * 0.5f);
+			for (j= 0; j < 3; j++)
+				eorg[j]= org[j] - (from.o.s.origin[j] + (from.o.mins[j] + from.o.maxs[j]) * 0.5f);
 
 			if (Math3D.VectorLength(eorg) > rad)
 				continue;
@@ -319,30 +220,26 @@ public class GameBase extends Globals
 	 *	null will be returned if the end of the list is reached.
 	 */
 
-	public static int MAXCHOICES = 8;
+	public static int MAXCHOICES= 8;
 
-	public static edict_t G_PickTarget(String targetname)
-	{
-		int num_choices = 0;
-		edict_t choice[] = new edict_t[MAXCHOICES];
+	public static edict_t G_PickTarget(String targetname) {
+		int num_choices= 0;
+		edict_t choice[]= new edict_t[MAXCHOICES];
 
-		if (targetname == null)
-		{
+		if (targetname == null) {
 			gi.dprintf("G_PickTarget called with null targetname\n");
 			return null;
 		}
 
-		EdictIterator es = null;
+		EdictIterator es= null;
 
-		while ((es = G_Find(es, findByTarget, targetname)) != null)
-		{
-			choice[num_choices++] = es.o;
+		while ((es= G_Find(es, findByTarget, targetname)) != null) {
+			choice[num_choices++]= es.o;
 			if (num_choices == MAXCHOICES)
 				break;
 		}
 
-		if (num_choices == 0)
-		{
+		if (num_choices == 0) {
 			gi.dprintf("G_PickTarget: target " + targetname + " not found\n");
 			return null;
 		}
@@ -350,31 +247,26 @@ public class GameBase extends Globals
 		return choice[Lib.rand() % num_choices];
 	}
 
-	public static float[] VEC_UP = { 0, -1, 0 };
-	public static float[] MOVEDIR_UP = { 0, 0, 1 };
-	public static float[] VEC_DOWN = { 0, -2, 0 };
-	public static float[] MOVEDIR_DOWN = { 0, 0, -1 };
+	public static float[] VEC_UP= { 0, -1, 0 };
+	public static float[] MOVEDIR_UP= { 0, 0, 1 };
+	public static float[] VEC_DOWN= { 0, -2, 0 };
+	public static float[] MOVEDIR_DOWN= { 0, 0, -1 };
 
-	public static void G_SetMovedir(float[] angles, float[] movedir)
-	{
-		if (Math3D.VectorCompare(angles, VEC_UP) != 0)
-		{
+	public static void G_SetMovedir(float[] angles, float[] movedir) {
+		if (Math3D.VectorCompare(angles, VEC_UP) != 0) {
 			Math3D.VectorCopy(MOVEDIR_UP, movedir);
 		}
-		else if (Math3D.VectorCompare(angles, VEC_DOWN) != 0)
-		{
+		else if (Math3D.VectorCompare(angles, VEC_DOWN) != 0) {
 			Math3D.VectorCopy(MOVEDIR_DOWN, movedir);
 		}
-		else
-		{
+		else {
 			Math3D.AngleVectors(angles, movedir, null, null);
 		}
 
 		Math3D.VectorClear(angles);
 	}
 
-	public static String G_CopyString(String in)
-	{
+	public static String G_CopyString(String in) {
 		return new String(in);
 	}
 
@@ -384,35 +276,42 @@ public class GameBase extends Globals
 	
 	============
 	*/
-	public static void G_TouchTriggers(edict_t ent)
-	{
+	
+	static edict_t touch[]= new edict_t[MAX_EDICTS];
+	public static void G_TouchTriggers(edict_t ent) {
 		int i, num;
-		edict_t touch[] = new edict_t[MAX_EDICTS], hit;
+		edict_t hit;
+		
 
 		// dead things don't activate triggers!
 		if ((ent.client != null || (ent.svflags & SVF_MONSTER) != 0) && (ent.health <= 0))
 			return;
 
-		num = gi.BoxEdicts(ent.absmin, ent.absmax, touch, MAX_EDICTS, AREA_TRIGGERS);
+		num= gi.BoxEdicts(ent.absmin, ent.absmax, touch, MAX_EDICTS, AREA_TRIGGERS);
 
 		// be careful, it is possible to have an entity in this
 		// list removed before we get to it (killtriggered)
-		for (i = 0; i < num; i++)
-		{
-			hit = touch[i];
+		for (i= 0; i < num; i++) {
+			hit= touch[i];
+
 			if (!hit.inuse)
 				continue;
 
 			if (hit.touch == null)
 				continue;
+				
+			//rst: just for debugging player triggers
+			//if (ent.index == 1)
+				//Com.Printf("trigger:" + hit.classname + "(" + hit.index + ")\n");
+				
 			hit.touch.touch(hit, ent, GameBase.dummyplane, null);
 		}
 	}
 
-	public static pushed_t pushed[] = new pushed_t[MAX_EDICTS];
+	public static pushed_t pushed[]= new pushed_t[MAX_EDICTS];
 	static {
-		for (int n = 0; n < MAX_EDICTS; n++)
-			pushed[n] = new pushed_t();
+		for (int n= 0; n < MAX_EDICTS; n++)
+			pushed[n]= new pushed_t();
 	}
 
 	public static int pushed_p;
@@ -430,7 +329,7 @@ public class GameBase extends Globals
 	*/
 	public static int c_yes, c_no;
 
-	public static int STEPSIZE = 18;
+	public static int STEPSIZE= 18;
 
 	//	  ============================================================================
 	/*
@@ -439,14 +338,12 @@ public class GameBase extends Globals
 	
 	================
 	*/
-	public static void G_RunEntity(edict_t ent)
-	{
-		
+	public static void G_RunEntity(edict_t ent) {
+
 		if (ent.prethink != null)
 			ent.prethink.think(ent);
 
-		switch ((int) ent.movetype)
-		{
+		switch ((int) ent.movetype) {
 			case MOVETYPE_PUSH :
 			case MOVETYPE_STOP :
 				SV.SV_Physics_Pusher(ent);
@@ -477,20 +374,16 @@ public class GameBase extends Globals
 	
 	================
 	*/
-	public static int DI_NODIR = -1;
-	public static void assert1(boolean cond)
-	{
-		if (!cond)
-		{
+	public static int DI_NODIR= -1;
+	public static void assert1(boolean cond) {
+		if (!cond) {
 
-			try
-			{
+			try {
 
-				int a[] = null;
-				int b = a[0];
+				int a[]= null;
+				int b= a[0];
 			}
-			catch (Exception e)
-			{
+			catch (Exception e) {
 				System.err.println("assertion failed!");
 				e.printStackTrace();
 			}
@@ -498,49 +391,41 @@ public class GameBase extends Globals
 		}
 	}
 
-	public static void ClearBounds(float[] mins, float[] maxs)
-	{
-		mins[0] = mins[1] = mins[2] = 99999;
-		maxs[0] = maxs[1] = maxs[2] = -99999;
+	public static void ClearBounds(float[] mins, float[] maxs) {
+		mins[0]= mins[1]= mins[2]= 99999;
+		maxs[0]= maxs[1]= maxs[2]= -99999;
 	}
 
-	public static void AddPointToBounds(float[] v, float[] mins, float[] maxs)
-	{
+	public static void AddPointToBounds(float[] v, float[] mins, float[] maxs) {
 		int i;
 		float val;
 
-		for (i = 0; i < 3; i++)
-		{
-			val = v[i];
+		for (i= 0; i < 3; i++) {
+			val= v[i];
 			if (val < mins[i])
-				mins[i] = val;
+				mins[i]= val;
 			if (val > maxs[i])
-				maxs[i] = val;
+				maxs[i]= val;
 		}
 	}
 
-	public static EdictFindFilter findByTarget = new EdictFindFilter()
-	{
-		public boolean matches(edict_t e, String s)
-		{
+	public static EdictFindFilter findByTarget= new EdictFindFilter() {
+		public boolean matches(edict_t e, String s) {
 			if (e.targetname == null)
 				return false;
 			return e.targetname.equalsIgnoreCase(s);
 		}
 	};
 
-	public static EdictFindFilter findByClass = new EdictFindFilter()
-	{
-		public boolean matches(edict_t e, String s)
-		{
+	public static EdictFindFilter findByClass= new EdictFindFilter() {
+		public boolean matches(edict_t e, String s) {
 			return e.classname.equalsIgnoreCase(s);
 		}
 	};
 
 	//===================================================================
 
-	public static void ShutdownGame()
-	{
+	public static void ShutdownGame() {
 		gi.dprintf("==== ShutdownGame ====\n");
 
 		//gi.FreeTags (TAG_LEVEL);
@@ -554,16 +439,14 @@ public class GameBase extends Globals
 	ClientEndServerFrames
 	=================
 	*/
-	public static void ClientEndServerFrames()
-	{
+	public static void ClientEndServerFrames() {
 		int i;
 		edict_t ent;
 
 		// calc the player views now that all pushing
 		// and damage has been added
-		for (i = 0; i < maxclients.value; i++)
-		{
-			ent = g_edicts[1 + i];
+		for (i= 0; i < maxclients.value; i++) {
+			ent= g_edicts[1 + i];
 			if (!ent.inuse || null == ent.client)
 				continue;
 			Game.ClientEndServerFrame(ent);
@@ -578,14 +461,13 @@ public class GameBase extends Globals
 	Returns the created target changelevel
 	=================
 	*/
-	public static edict_t CreateTargetChangeLevel(String map)
-	{
+	public static edict_t CreateTargetChangeLevel(String map) {
 		edict_t ent;
 
-		ent = Game.G_Spawn();
-		ent.classname = "target_changelevel";
-		level.nextmap = map;
-		ent.map = level.nextmap;
+		ent= Game.G_Spawn();
+		ent.classname= "target_changelevel";
+		level.nextmap= map;
+		ent.map= level.nextmap;
 		return ent;
 	}
 
@@ -596,37 +478,31 @@ public class GameBase extends Globals
 	The timelimit or fraglimit has been exceeded
 	=================
 	*/
-	public static void EndDMLevel()
-	{
+	public static void EndDMLevel() {
 		edict_t ent;
 		//char * s, * t, * f;
 		//static const char * seps = " ,\n\r";
 		String s, t, f;
-		String seps = " ,\n\r";
+		String seps= " ,\n\r";
 
 		// stay on same level flag
-		if (((int) dmflags.value & DF_SAME_LEVEL) != 0)
-		{
+		if (((int) dmflags.value & DF_SAME_LEVEL) != 0) {
 			Game.BeginIntermission(CreateTargetChangeLevel(level.mapname));
 			return;
 		}
 
 		// see if it's in the map list
-		if (sv_maplist.string.length() > 0)
-		{
-			s = sv_maplist.string;
-			f = null;
-			StringTokenizer tk = new StringTokenizer(s, seps);
-			t = tk.nextToken();
+		if (sv_maplist.string.length() > 0) {
+			s= sv_maplist.string;
+			f= null;
+			StringTokenizer tk= new StringTokenizer(s, seps);
+			t= tk.nextToken();
 			//t = strtok(s, seps);
-			while (t != null)
-			{
-				if (Q_stricmp(t, level.mapname) == 0)
-				{
+			while (t != null) {
+				if (Q_stricmp(t, level.mapname) == 0) {
 					// it's in the list, go to the next one
-					t = tk.nextToken();
-					if (t == null)
-					{ // end of list, go to first one
+					t= tk.nextToken();
+					if (t == null) { // end of list, go to first one
 						if (f == null) // there isn't a first one, same level
 							Game.BeginIntermission(CreateTargetChangeLevel(level.mapname));
 						else
@@ -637,25 +513,23 @@ public class GameBase extends Globals
 					return;
 				}
 				if (f == null)
-					f = t;
-				t = tk.nextToken();
+					f= t;
+				t= tk.nextToken();
 			}
 
 		}
 
 		if (level.nextmap.length() > 0) // go to a specific map
 			Game.BeginIntermission(CreateTargetChangeLevel(level.nextmap));
-		else
-		{ // search for a changelevel
-			EdictIterator edit = null;
-			edit = G_Find(edit, findByClass, "target_changelevel");
-			if (edit == null)
-			{ // the map designer didn't include a changelevel,
+		else { // search for a changelevel
+			EdictIterator edit= null;
+			edit= G_Find(edit, findByClass, "target_changelevel");
+			if (edit == null) { // the map designer didn't include a changelevel,
 				// so create a fake ent that goes back to the same level
 				Game.BeginIntermission(CreateTargetChangeLevel(level.mapname));
 				return;
 			}
-			ent = edit.o;
+			ent= edit.o;
 			Game.BeginIntermission(ent);
 		}
 	}
@@ -665,17 +539,15 @@ public class GameBase extends Globals
 	CheckNeedPass
 	=================
 	*/
-	public static void CheckNeedPass()
-	{
+	public static void CheckNeedPass() {
 		int need;
 
 		// if password or spectator_password has changed, update needpass
 		// as needed
-		if (password.modified || spectator_password.modified)
-		{
-			password.modified = spectator_password.modified = false;
+		if (password.modified || spectator_password.modified) {
+			password.modified= spectator_password.modified= false;
 
-			need = 0;
+			need= 0;
 
 			if ((password.string.length() > 0) && 0 != Q_stricmp(password.string, "none"))
 				need |= 1;
@@ -691,8 +563,7 @@ public class GameBase extends Globals
 	CheckDMRules
 	=================
 	*/
-	public static void CheckDMRules()
-	{
+	public static void CheckDMRules() {
 		int i;
 		gclient_t cl;
 
@@ -702,26 +573,21 @@ public class GameBase extends Globals
 		if (0 == deathmatch.value)
 			return;
 
-		if (timelimit.value != 0)
-		{
-			if (level.time >= timelimit.value * 60)
-			{
+		if (timelimit.value != 0) {
+			if (level.time >= timelimit.value * 60) {
 				gi.bprintf(PRINT_HIGH, "Timelimit hit.\n");
 				EndDMLevel();
 				return;
 			}
 		}
 
-		if (fraglimit.value != 0)
-		{
-			for (i = 0; i < maxclients.value; i++)
-			{
-				cl = game.clients[i];
+		if (fraglimit.value != 0) {
+			for (i= 0; i < maxclients.value; i++) {
+				cl= game.clients[i];
 				if (!g_edicts[i + 1].inuse)
 					continue;
 
-				if (cl.resp.score >= fraglimit.value)
-				{
+				if (cl.resp.score >= fraglimit.value) {
 					gi.bprintf(PRINT_HIGH, "Fraglimit hit.\n");
 					EndDMLevel();
 					return;
@@ -735,28 +601,26 @@ public class GameBase extends Globals
 	ExitLevel
 	=============
 	*/
-	public static void ExitLevel()
-	{
+	public static void ExitLevel() {
 		int i;
 		edict_t ent;
 		//char command[256];
 		String command;
 
-		command = "gamemap \"" + level.changemap + "\"\n";
+		command= "gamemap \"" + level.changemap + "\"\n";
 		gi.AddCommandString(command);
-		level.changemap = null;
-		level.exitintermission = false;
-		level.intermissiontime = 0;
+		level.changemap= null;
+		level.exitintermission= false;
+		level.intermissiontime= 0;
 		ClientEndServerFrames();
 
 		// clear some things before going to next level
-		for (i = 0; i < maxclients.value; i++)
-		{
-			ent = g_edicts[1 + i];
+		for (i= 0; i < maxclients.value; i++) {
+			ent= g_edicts[1 + i];
 			if (!ent.inuse)
 				continue;
 			if (ent.health > ent.client.pers.max_health)
-				ent.health = ent.client.pers.max_health;
+				ent.health= ent.client.pers.max_health;
 		}
 
 	}
@@ -768,21 +632,19 @@ public class GameBase extends Globals
 	Advances the world by 0.1 seconds
 	================
 	*/
-	public static void G_RunFrame()
-	{
+	public static void G_RunFrame() {
 		int i;
 		edict_t ent;
 
 		level.framenum++;
-		level.time = level.framenum * FRAMETIME;
+		level.time= level.framenum * FRAMETIME;
 
 		// choose a client for monsters to target this frame
 		Game.AI_SetSightClient();
 
 		// exit intermissions
 
-		if (level.exitintermission)
-		{
+		if (level.exitintermission) {
 			ExitLevel();
 			return;
 		}
@@ -792,33 +654,28 @@ public class GameBase extends Globals
 		// even the world gets a chance to think
 		//
 
-		for (i = 0; i < globals.num_edicts; i++)
-		{
-			ent = g_edicts[i];
+		for (i= 0; i < globals.num_edicts; i++) {
+			ent= g_edicts[i];
 			if (!ent.inuse)
 				continue;
 
-			level.current_entity = ent;
+			level.current_entity= ent;
 
 			VectorCopy(ent.s.origin, ent.s.old_origin);
 
 			// if the ground entity moved, make sure we are still on it
-			if ((ent.groundentity != null) && (ent.groundentity.linkcount != ent.groundentity_linkcount))
-			{
-				ent.groundentity = null;
-				if (0 == (ent.flags & (FL_SWIM | FL_FLY)) && (ent.svflags & SVF_MONSTER) != 0)
-				{
+			if ((ent.groundentity != null) && (ent.groundentity.linkcount != ent.groundentity_linkcount)) {
+				ent.groundentity= null;
+				if (0 == (ent.flags & (FL_SWIM | FL_FLY)) && (ent.svflags & SVF_MONSTER) != 0) {
 					M.M_CheckGround(ent);
 				}
 			}
 
-			if (i > 0 && i <= maxclients.value)
-			{
+			if (i > 0 && i <= maxclients.value) {
 				Game.ClientBeginServerFrame(ent);
 				continue;
 			}
 
-
 			G_RunEntity(ent);
 		}
 
@@ -841,19 +698,16 @@ public class GameBase extends Globals
 	=================
 	*/
 
-	public static game_export_t GetGameApi(game_import_t imp)
-	{
-		gi = imp;
+	public static game_export_t GetGameApi(game_import_t imp) {
+		gi= imp;
 
-		gi.pointcontents = new pmove_t.PointContentsAdapter()
-		{
-			public int pointcontents(float[] o)
-			{
+		gi.pointcontents= new pmove_t.PointContentsAdapter() {
+			public int pointcontents(float[] o) {
 				return SV_WORLD.SV_PointContents(o);
 			}
 		};
 
-		globals.apiversion = GAME_API_VERSION;
+		globals.apiversion= GAME_API_VERSION;
 		/*
 		globals.Init = InitGame;
 		globals.Shutdown = ShutdownGame;
diff --git a/src/jake2/game/GameFuncAdapters.java b/src/jake2/game/GameFuncAdapters.java
index 5d48a6e..a381091 100644
--- a/src/jake2/game/GameFuncAdapters.java
+++ b/src/jake2/game/GameFuncAdapters.java
@@ -19,7 +19,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 
 // Created on 26.02.2004 by RST.
-// $Id: GameFuncAdapters.java,v 1.1 2004-07-08 15:58:44 hzi Exp $
+// $Id: GameFuncAdapters.java,v 1.2 2004-08-22 14:25:11 salomo Exp $
 
 package jake2.game;
 
@@ -30,8 +30,7 @@ import jake2.Globals;
 import jake2.util.*;
 import jake2.util.*;
 
-public class GameFuncAdapters
-{
+public class GameFuncAdapters {
 
 	/*
 	=========================================================
@@ -67,66 +66,58 @@ public class GameFuncAdapters
 	=========================================================
 	*/
 
-	public final static int PLAT_LOW_TRIGGER = 1;
-	public final static int STATE_TOP = 0;
-	public final static int STATE_BOTTOM = 1;
-	public final static int STATE_UP = 2;
-	public final static int STATE_DOWN = 3;
-	public final static int DOOR_START_OPEN = 1;
-	public final static int DOOR_REVERSE = 2;
-	public final static int DOOR_CRUSHER = 4;
-	public final static int DOOR_NOMONSTER = 8;
-	public final static int DOOR_TOGGLE = 32;
-	public final static int DOOR_X_AXIS = 64;
-	public final static int DOOR_Y_AXIS = 128;
+	public final static int PLAT_LOW_TRIGGER= 1;
+	public final static int STATE_TOP= 0;
+	public final static int STATE_BOTTOM= 1;
+	public final static int STATE_UP= 2;
+	public final static int STATE_DOWN= 3;
+	public final static int DOOR_START_OPEN= 1;
+	public final static int DOOR_REVERSE= 2;
+	public final static int DOOR_CRUSHER= 4;
+	public final static int DOOR_NOMONSTER= 8;
+	public final static int DOOR_TOGGLE= 32;
+	public final static int DOOR_X_AXIS= 64;
+	public final static int DOOR_Y_AXIS= 128;
 	//
 	//	   Support routines for movement (changes in origin using velocity)
 	//
 
-	static EntThinkAdapter Move_Done = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
+	static EntThinkAdapter Move_Done= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
 			Math3D.VectorClear(ent.velocity);
 			ent.moveinfo.endfunc.think(ent);
 			return true;
 		}
 	};
-	static EntThinkAdapter Move_Final = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
+	static EntThinkAdapter Move_Final= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
 
-			if (ent.moveinfo.remaining_distance == 0)
-			{
+			if (ent.moveinfo.remaining_distance == 0) {
 				Move_Done.think(ent);
 				return true;
 			}
 
 			Math3D.VectorScale(ent.moveinfo.dir, ent.moveinfo.remaining_distance / Defines.FRAMETIME, ent.velocity);
 
-			ent.think = Move_Done;
-			ent.nextthink = GameBase.level.time + Defines.FRAMETIME;
+			ent.think= Move_Done;
+			ent.nextthink= GameBase.level.time + Defines.FRAMETIME;
 			return true;
 		}
 	};
-	static EntThinkAdapter Move_Begin = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
+	static EntThinkAdapter Move_Begin= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
 
 			float frames;
 
-			if ((ent.moveinfo.speed * Defines.FRAMETIME) >= ent.moveinfo.remaining_distance)
-			{
+			if ((ent.moveinfo.speed * Defines.FRAMETIME) >= ent.moveinfo.remaining_distance) {
 				Move_Final.think(ent);
 				return true;
 			}
 			Math3D.VectorScale(ent.moveinfo.dir, ent.moveinfo.speed, ent.velocity);
-			frames = (float) Math.floor((ent.moveinfo.remaining_distance / ent.moveinfo.speed) / Defines.FRAMETIME);
+			frames= (float) Math.floor((ent.moveinfo.remaining_distance / ent.moveinfo.speed) / Defines.FRAMETIME);
 			ent.moveinfo.remaining_distance -= frames * ent.moveinfo.speed * Defines.FRAMETIME;
-			ent.nextthink = GameBase.level.time + (frames * Defines.FRAMETIME);
-			ent.think = Move_Final;
+			ent.nextthink= GameBase.level.time + (frames * Defines.FRAMETIME);
+			ent.think= Move_Final;
 			return true;
 		}
 	};
@@ -134,44 +125,37 @@ public class GameFuncAdapters
 	//	   Support routines for angular movement (changes in angle using avelocity)
 	//
 
-	static EntThinkAdapter AngleMove_Done = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
+	static EntThinkAdapter AngleMove_Done= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
 			Math3D.VectorClear(ent.avelocity);
 			ent.moveinfo.endfunc.think(ent);
 			return true;
 		}
 	};
-	static EntThinkAdapter AngleMove_Final = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
-			float[] move = { 0, 0, 0 };
+	static EntThinkAdapter AngleMove_Final= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
+			float[] move= { 0, 0, 0 };
 
 			if (ent.moveinfo.state == STATE_UP)
 				Math3D.VectorSubtract(ent.moveinfo.end_angles, ent.s.angles, move);
 			else
 				Math3D.VectorSubtract(ent.moveinfo.start_angles, ent.s.angles, move);
 
-			if (Math3D.VectorCompare(move, Globals.vec3_origin) != 0)
-			{
+			if (Math3D.VectorCompare(move, Globals.vec3_origin) != 0) {
 				AngleMove_Done.think(ent);
 				return true;
 			}
 
 			Math3D.VectorScale(move, 1.0f / Defines.FRAMETIME, ent.avelocity);
 
-			ent.think = AngleMove_Done;
-			ent.nextthink = GameBase.level.time + Defines.FRAMETIME;
+			ent.think= AngleMove_Done;
+			ent.nextthink= GameBase.level.time + Defines.FRAMETIME;
 			return true;
 		}
 	};
-	static EntThinkAdapter AngleMove_Begin = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
-			float[] destdelta = { 0, 0, 0 };
+	static EntThinkAdapter AngleMove_Begin= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
+			float[] destdelta= { 0, 0, 0 };
 			float len;
 			float traveltime;
 			float frames;
@@ -183,32 +167,29 @@ public class GameFuncAdapters
 				Math3D.VectorSubtract(ent.moveinfo.start_angles, ent.s.angles, destdelta);
 
 			// calculate length of vector
-			len = Math3D.VectorLength(destdelta);
+			len= Math3D.VectorLength(destdelta);
 
 			// divide by speed to get time to reach dest
-			traveltime = len / ent.moveinfo.speed;
+			traveltime= len / ent.moveinfo.speed;
 
-			if (traveltime < Defines.FRAMETIME)
-			{
+			if (traveltime < Defines.FRAMETIME) {
 				AngleMove_Final.think(ent);
 				return true;
 			}
 
-			frames = (float) (Math.floor(traveltime / Defines.FRAMETIME));
+			frames= (float) (Math.floor(traveltime / Defines.FRAMETIME));
 
 			// scale the destdelta vector by the time spent traveling to get velocity
 			Math3D.VectorScale(destdelta, 1.0f / traveltime, ent.avelocity);
 
 			// set nextthink to trigger a think when dest is reached
-			ent.nextthink = GameBase.level.time + frames * Defines.FRAMETIME;
-			ent.think = AngleMove_Final;
+			ent.nextthink= GameBase.level.time + frames * Defines.FRAMETIME;
+			ent.think= AngleMove_Final;
 			return true;
 		}
 	};
-	static EntThinkAdapter Think_AccelMove = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
+	static EntThinkAdapter Think_AccelMove= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
 			ent.moveinfo.remaining_distance -= ent.moveinfo.current_speed;
 
 			if (ent.moveinfo.current_speed == 0) // starting or blocked
@@ -217,24 +198,20 @@ public class GameFuncAdapters
 			GameFunc.plat_Accelerate(ent.moveinfo);
 
 			// will the entire move complete on next frame?
-			if (ent.moveinfo.remaining_distance <= ent.moveinfo.current_speed)
-			{
+			if (ent.moveinfo.remaining_distance <= ent.moveinfo.current_speed) {
 				Move_Final.think(ent);
 				return true;
 			}
 
 			Math3D.VectorScale(ent.moveinfo.dir, ent.moveinfo.current_speed * 10, ent.velocity);
-			ent.nextthink = GameBase.level.time + Defines.FRAMETIME;
-			ent.think = Think_AccelMove;
+			ent.nextthink= GameBase.level.time + Defines.FRAMETIME;
+			ent.think= Think_AccelMove;
 			return true;
 		}
 	};
-	static EntThinkAdapter plat_hit_top = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
-			if (0 == (ent.flags & Defines.FL_TEAMSLAVE))
-			{
+	static EntThinkAdapter plat_hit_top= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
+			if (0 == (ent.flags & Defines.FL_TEAMSLAVE)) {
 				if (ent.moveinfo.sound_end != 0)
 					GameBase.gi.sound(
 						ent,
@@ -243,22 +220,19 @@ public class GameFuncAdapters
 						1,
 						Defines.ATTN_STATIC,
 						0);
-				ent.s.sound = 0;
+				ent.s.sound= 0;
 			}
-			ent.moveinfo.state = STATE_TOP;
+			ent.moveinfo.state= STATE_TOP;
 
-			ent.think = plat_go_down;
-			ent.nextthink = GameBase.level.time + 3;
+			ent.think= plat_go_down;
+			ent.nextthink= GameBase.level.time + 3;
 			return true;
 		}
 	};
-	static EntThinkAdapter plat_hit_bottom = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
+	static EntThinkAdapter plat_hit_bottom= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
 
-			if (0 == (ent.flags & Defines.FL_TEAMSLAVE))
-			{
+			if (0 == (ent.flags & Defines.FL_TEAMSLAVE)) {
 				if (ent.moveinfo.sound_end != 0)
 					GameBase.gi.sound(
 						ent,
@@ -267,18 +241,15 @@ public class GameFuncAdapters
 						1,
 						Defines.ATTN_STATIC,
 						0);
-				ent.s.sound = 0;
+				ent.s.sound= 0;
 			}
-			ent.moveinfo.state = STATE_BOTTOM;
+			ent.moveinfo.state= STATE_BOTTOM;
 			return true;
 		}
 	};
-	static EntThinkAdapter plat_go_down = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
-			if (0 == (ent.flags & Defines.FL_TEAMSLAVE))
-			{
+	static EntThinkAdapter plat_go_down= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
+			if (0 == (ent.flags & Defines.FL_TEAMSLAVE)) {
 				if (ent.moveinfo.sound_start != 0)
 					GameBase.gi.sound(
 						ent,
@@ -287,19 +258,16 @@ public class GameFuncAdapters
 						1,
 						Defines.ATTN_STATIC,
 						0);
-				ent.s.sound = ent.moveinfo.sound_middle;
+				ent.s.sound= ent.moveinfo.sound_middle;
 			}
-			ent.moveinfo.state = STATE_DOWN;
+			ent.moveinfo.state= STATE_DOWN;
 			GameFunc.Move_Calc(ent, ent.moveinfo.end_origin, plat_hit_bottom);
 			return true;
 		}
 	};
-	static EntBlockedAdapter plat_blocked = new EntBlockedAdapter()
-	{
-		public void blocked(edict_t self, edict_t other)
-		{
-			if (0 == (other.svflags & Defines.SVF_MONSTER) && (null == other.client))
-			{
+	static EntBlockedAdapter plat_blocked= new EntBlockedAdapter() {
+		public void blocked(edict_t self, edict_t other) {
+			if (0 == (other.svflags & Defines.SVF_MONSTER) && (null == other.client)) {
 				// give it a chance to go away on it's own terms (like gibs)
 				GameUtil.T_Damage(
 					other,
@@ -337,31 +305,26 @@ public class GameFuncAdapters
 
 		}
 	};
-	static EntUseAdapter Use_Plat = new EntUseAdapter()
-	{
-		public void use(edict_t ent, edict_t other, edict_t activator)
-		{
+	static EntUseAdapter Use_Plat= new EntUseAdapter() {
+		public void use(edict_t ent, edict_t other, edict_t activator) {
 			if (ent.think != null)
 				return; // already down
 			plat_go_down.think(ent);
 		}
 	};
-	static EntTouchAdapter Touch_Plat_Center = new EntTouchAdapter()
-	{
-		public void touch(edict_t ent, edict_t other, cplane_t plane, csurface_t surf)
-		{
+	static EntTouchAdapter Touch_Plat_Center= new EntTouchAdapter() {
+		public void touch(edict_t ent, edict_t other, cplane_t plane, csurface_t surf) {
 			if (other.client == null)
 				return;
 
 			if (other.health <= 0)
 				return;
 
-			ent = ent.enemy; // now point at the plat, not the trigger
+			ent= ent.enemy; // now point at the plat, not the trigger
 			if (ent.moveinfo.state == STATE_BOTTOM)
 				GameFunc.plat_go_up(ent);
-			else if (ent.moveinfo.state == STATE_TOP)
-			{
-				ent.nextthink = GameBase.level.time + 1; // the player is still on the plat, so delay going down
+			else if (ent.moveinfo.state == STATE_TOP) {
+				ent.nextthink= GameBase.level.time + 1; // the player is still on the plat, so delay going down
 			}
 		}
 	};
@@ -379,10 +342,8 @@ public class GameFuncAdapters
 	STOP mean it will stop moving instead of pushing entities
 	*/
 
-	static EntBlockedAdapter rotating_blocked = new EntBlockedAdapter()
-	{
-		public void blocked(edict_t self, edict_t other)
-		{
+	static EntBlockedAdapter rotating_blocked= new EntBlockedAdapter() {
+		public void blocked(edict_t self, edict_t other) {
 			GameUtil.T_Damage(
 				other,
 				self,
@@ -396,10 +357,8 @@ public class GameFuncAdapters
 				Defines.MOD_CRUSH);
 		}
 	};
-	static EntTouchAdapter rotating_touch = new EntTouchAdapter()
-	{
-		public void touch(edict_t self, edict_t other, cplane_t plane, csurface_t surf)
-		{
+	static EntTouchAdapter rotating_touch= new EntTouchAdapter() {
+		public void touch(edict_t self, edict_t other, cplane_t plane, csurface_t surf) {
 			if (self.avelocity[0] != 0 || self.avelocity[1] != 0 || self.avelocity[2] != 0)
 				GameUtil.T_Damage(
 					other,
@@ -414,58 +373,52 @@ public class GameFuncAdapters
 					Defines.MOD_CRUSH);
 		}
 	};
-	static EntUseAdapter rotating_use = new EntUseAdapter()
-	{
-		public void use(edict_t self, edict_t other, edict_t activator)
-		{
-			if (0 == Math3D.VectorCompare(self.avelocity, Globals.vec3_origin))
-			{
-				self.s.sound = 0;
+	static EntUseAdapter rotating_use= new EntUseAdapter() {
+		public void use(edict_t self, edict_t other, edict_t activator) {
+			if (0 == Math3D.VectorCompare(self.avelocity, Globals.vec3_origin)) {
+				self.s.sound= 0;
 				Math3D.VectorClear(self.avelocity);
-				self.touch = null;
+				self.touch= null;
 			}
-			else
-			{
-				self.s.sound = self.moveinfo.sound_middle;
+			else {
+				self.s.sound= self.moveinfo.sound_middle;
 				Math3D.VectorScale(self.movedir, self.speed, self.avelocity);
 				if ((self.spawnflags & 16) != 0)
-					self.touch = rotating_touch;
+					self.touch= rotating_touch;
 			}
 		}
 	};
-	static EntThinkAdapter SP_func_rotating = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
-			ent.solid = Defines.SOLID_BSP;
+	static EntThinkAdapter SP_func_rotating= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
+			ent.solid= Defines.SOLID_BSP;
 			if ((ent.spawnflags & 32) != 0)
-				ent.movetype = Defines.MOVETYPE_STOP;
+				ent.movetype= Defines.MOVETYPE_STOP;
 			else
-				ent.movetype = Defines.MOVETYPE_PUSH;
+				ent.movetype= Defines.MOVETYPE_PUSH;
 
 			// set the axis of rotation
 			Math3D.VectorClear(ent.movedir);
 			if ((ent.spawnflags & 4) != 0)
-				ent.movedir[2] = 1.0f;
+				ent.movedir[2]= 1.0f;
 			else if ((ent.spawnflags & 8) != 0)
-				ent.movedir[0] = 1.0f;
+				ent.movedir[0]= 1.0f;
 			else // Z_AXIS
-				ent.movedir[1] = 1.0f;
+				ent.movedir[1]= 1.0f;
 
 			// check for reverse rotation
 			if ((ent.spawnflags & 2) != 0)
 				Math3D.VectorNegate(ent.movedir, ent.movedir);
 
 			if (0 == ent.speed)
-				ent.speed = 100;
+				ent.speed= 100;
 			if (0 == ent.dmg)
-				ent.dmg = 2;
+				ent.dmg= 2;
 
 			//		ent.moveinfo.sound_middle = "doors/hydro1.wav";
 
-			ent.use = rotating_use;
+			ent.use= rotating_use;
 			if (ent.dmg != 0)
-				ent.blocked = rotating_blocked;
+				ent.blocked= rotating_blocked;
 
 			if ((ent.spawnflags & 1) != 0)
 				ent.use.use(ent, null, null);
@@ -505,58 +458,49 @@ public class GameFuncAdapters
 	5) in-out
 	*/
 
-	static EntThinkAdapter button_done = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
+	static EntThinkAdapter button_done= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
 
-			self.moveinfo.state = STATE_BOTTOM;
+			self.moveinfo.state= STATE_BOTTOM;
 			self.s.effects &= ~Defines.EF_ANIM23;
 			self.s.effects |= Defines.EF_ANIM01;
 			return true;
 		}
 	};
-	static EntThinkAdapter button_return = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
-			self.moveinfo.state = STATE_DOWN;
+	static EntThinkAdapter button_return= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
+			self.moveinfo.state= STATE_DOWN;
 
 			GameFunc.Move_Calc(self, self.moveinfo.start_origin, button_done);
 
-			self.s.frame = 0;
+			self.s.frame= 0;
 
 			if (self.health != 0)
-				self.takedamage = Defines.DAMAGE_YES;
+				self.takedamage= Defines.DAMAGE_YES;
 			return true;
 		}
 	};
-	static EntThinkAdapter button_wait = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
-			self.moveinfo.state = STATE_TOP;
+	static EntThinkAdapter button_wait= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
+			self.moveinfo.state= STATE_TOP;
 			self.s.effects &= ~Defines.EF_ANIM01;
 			self.s.effects |= Defines.EF_ANIM23;
 
 			GameUtil.G_UseTargets(self, self.activator);
-			self.s.frame = 1;
-			if (self.moveinfo.wait >= 0)
-			{
-				self.nextthink = GameBase.level.time + self.moveinfo.wait;
-				self.think = button_return;
+			self.s.frame= 1;
+			if (self.moveinfo.wait >= 0) {
+				self.nextthink= GameBase.level.time + self.moveinfo.wait;
+				self.think= button_return;
 			}
 			return true;
 		}
 	};
-	static EntThinkAdapter button_fire = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
+	static EntThinkAdapter button_fire= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
 			if (self.moveinfo.state == STATE_UP || self.moveinfo.state == STATE_TOP)
 				return true;
 
-			self.moveinfo.state = STATE_UP;
+			self.moveinfo.state= STATE_UP;
 			if (self.moveinfo.sound_start != 0 && 0 == (self.flags & Defines.FL_TEAMSLAVE))
 				GameBase.gi.sound(
 					self,
@@ -569,93 +513,84 @@ public class GameFuncAdapters
 			return true;
 		}
 	};
-	static EntUseAdapter button_use = new EntUseAdapter()
-	{
-		public void use(edict_t self, edict_t other, edict_t activator)
-		{
-			self.activator = activator;
+	static EntUseAdapter button_use= new EntUseAdapter() {
+		public void use(edict_t self, edict_t other, edict_t activator) {
+			self.activator= activator;
 			button_fire.think(self);
 			return;
 		}
 	};
-	static EntTouchAdapter button_touch = new EntTouchAdapter()
-	{
-		public void touch(edict_t self, edict_t other, cplane_t plane, csurface_t surf)
-		{
+	static EntTouchAdapter button_touch= new EntTouchAdapter() {
+		public void touch(edict_t self, edict_t other, cplane_t plane, csurface_t surf) {
 			if (null == other.client)
 				return;
 
 			if (other.health <= 0)
 				return;
 
-			self.activator = other;
+			self.activator= other;
 			button_fire.think(self);
 
 		}
 	};
-	static EntDieAdapter button_killed = new EntDieAdapter()
-	{
-		public void die(edict_t self, edict_t inflictor, edict_t attacker, int damage, float[] point)
-		{
-			self.activator = attacker;
-			self.health = self.max_health;
-			self.takedamage = Defines.DAMAGE_NO;
+	static EntDieAdapter button_killed= new EntDieAdapter() {
+		public void die(edict_t self, edict_t inflictor, edict_t attacker, int damage, float[] point) {
+			self.activator= attacker;
+			self.health= self.max_health;
+			self.takedamage= Defines.DAMAGE_NO;
 			button_fire.think(self);
 
 		}
 	};
-	static EntThinkAdapter SP_func_button = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
-			float[] abs_movedir = { 0, 0, 0 };
+	static EntThinkAdapter SP_func_button= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
+			float[] abs_movedir= { 0, 0, 0 };
 			float dist;
 
 			GameBase.G_SetMovedir(ent.s.angles, ent.movedir);
-			ent.movetype = Defines.MOVETYPE_STOP;
-			ent.solid = Defines.SOLID_BSP;
+			ent.movetype= Defines.MOVETYPE_STOP;
+			ent.solid= Defines.SOLID_BSP;
 			GameBase.gi.setmodel(ent, ent.model);
 
 			if (ent.sounds != 1)
-				ent.moveinfo.sound_start = GameBase.gi.soundindex("switches/butn2.wav");
+				ent.moveinfo.sound_start= GameBase.gi.soundindex("switches/butn2.wav");
 
 			if (0 == ent.speed)
-				ent.speed = 40;
+				ent.speed= 40;
 			if (0 == ent.accel)
-				ent.accel = ent.speed;
+				ent.accel= ent.speed;
 			if (0 == ent.decel)
-				ent.decel = ent.speed;
+				ent.decel= ent.speed;
 
 			if (0 == ent.wait)
-				ent.wait = 3;
+				ent.wait= 3;
 			if (0 == GameBase.st.lip)
-				GameBase.st.lip = 4;
+				GameBase.st.lip= 4;
 
 			Math3D.VectorCopy(ent.s.origin, ent.pos1);
-			abs_movedir[0] = (float) Math.abs(ent.movedir[0]);
-			abs_movedir[1] = (float) Math.abs(ent.movedir[1]);
-			abs_movedir[2] = (float) Math.abs(ent.movedir[2]);
-			dist = abs_movedir[0] * ent.size[0] + abs_movedir[1] * ent.size[1] + abs_movedir[2] * ent.size[2] - GameBase.st.lip;
+			abs_movedir[0]= (float) Math.abs(ent.movedir[0]);
+			abs_movedir[1]= (float) Math.abs(ent.movedir[1]);
+			abs_movedir[2]= (float) Math.abs(ent.movedir[2]);
+			dist= abs_movedir[0] * ent.size[0] + abs_movedir[1] * ent.size[1] + abs_movedir[2] * ent.size[2] - GameBase.st.lip;
 			Math3D.VectorMA(ent.pos1, dist, ent.movedir, ent.pos2);
 
-			ent.use = button_use;
+			ent.use= button_use;
 			ent.s.effects |= Defines.EF_ANIM01;
 
-			if (ent.health != 0)
-			{
-				ent.max_health = ent.health;
-				ent.die = button_killed;
-				ent.takedamage = Defines.DAMAGE_YES;
+			if (ent.health != 0) {
+				ent.max_health= ent.health;
+				ent.die= button_killed;
+				ent.takedamage= Defines.DAMAGE_YES;
 			}
 			else if (null == ent.targetname)
-				ent.touch = button_touch;
+				ent.touch= button_touch;
 
-			ent.moveinfo.state = STATE_BOTTOM;
+			ent.moveinfo.state= STATE_BOTTOM;
 
-			ent.moveinfo.speed = ent.speed;
-			ent.moveinfo.accel = ent.accel;
-			ent.moveinfo.decel = ent.decel;
-			ent.moveinfo.wait = ent.wait;
+			ent.moveinfo.speed= ent.speed;
+			ent.moveinfo.accel= ent.accel;
+			ent.moveinfo.decel= ent.decel;
+			ent.moveinfo.wait= ent.wait;
 			Math3D.VectorCopy(ent.pos1, ent.moveinfo.start_origin);
 			Math3D.VectorCopy(ent.s.angles, ent.moveinfo.start_angles);
 			Math3D.VectorCopy(ent.pos2, ent.moveinfo.end_origin);
@@ -665,12 +600,9 @@ public class GameFuncAdapters
 			return true;
 		}
 	};
-	static EntThinkAdapter door_hit_top = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
-			if (0 == (self.flags & Defines.FL_TEAMSLAVE))
-			{
+	static EntThinkAdapter door_hit_top= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
+			if (0 == (self.flags & Defines.FL_TEAMSLAVE)) {
 				if (self.moveinfo.sound_end != 0)
 					GameBase.gi.sound(
 						self,
@@ -679,25 +611,21 @@ public class GameFuncAdapters
 						1,
 						Defines.ATTN_STATIC,
 						0);
-				self.s.sound = 0;
+				self.s.sound= 0;
 			}
-			self.moveinfo.state = STATE_TOP;
+			self.moveinfo.state= STATE_TOP;
 			if ((self.spawnflags & DOOR_TOGGLE) != 0)
 				return true;
-			if (self.moveinfo.wait >= 0)
-			{
-				self.think = door_go_down;
-				self.nextthink = GameBase.level.time + self.moveinfo.wait;
+			if (self.moveinfo.wait >= 0) {
+				self.think= door_go_down;
+				self.nextthink= GameBase.level.time + self.moveinfo.wait;
 			}
 			return true;
 		}
 	};
-	static EntThinkAdapter door_hit_bottom = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
-			if (0 == (self.flags & Defines.FL_TEAMSLAVE))
-			{
+	static EntThinkAdapter door_hit_bottom= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
+			if (0 == (self.flags & Defines.FL_TEAMSLAVE)) {
 				if (self.moveinfo.sound_end != 0)
 					GameBase.gi.sound(
 						self,
@@ -706,19 +634,16 @@ public class GameFuncAdapters
 						1,
 						Defines.ATTN_STATIC,
 						0);
-				self.s.sound = 0;
+				self.s.sound= 0;
 			}
-			self.moveinfo.state = STATE_BOTTOM;
+			self.moveinfo.state= STATE_BOTTOM;
 			GameFunc.door_use_areaportals(self, false);
 			return true;
 		}
 	};
-	static EntThinkAdapter door_go_down = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
-			if (0 == (self.flags & Defines.FL_TEAMSLAVE))
-			{
+	static EntThinkAdapter door_go_down= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
+			if (0 == (self.flags & Defines.FL_TEAMSLAVE)) {
 				if (self.moveinfo.sound_start != 0)
 					GameBase.gi.sound(
 						self,
@@ -727,15 +652,14 @@ public class GameFuncAdapters
 						1,
 						Defines.ATTN_STATIC,
 						0);
-				self.s.sound = self.moveinfo.sound_middle;
+				self.s.sound= self.moveinfo.sound_middle;
 			}
-			if (self.max_health != 0)
-			{
-				self.takedamage = Defines.DAMAGE_YES;
-				self.health = self.max_health;
+			if (self.max_health != 0) {
+				self.takedamage= Defines.DAMAGE_YES;
+				self.health= self.max_health;
 			}
 
-			self.moveinfo.state = STATE_DOWN;
+			self.moveinfo.state= STATE_DOWN;
 			if (Lib.strcmp(self.classname, "func_door") == 0)
 				GameFunc.Move_Calc(self, self.moveinfo.start_origin, door_hit_bottom);
 			else if (Lib.strcmp(self.classname, "func_door_rotating") == 0)
@@ -743,24 +667,19 @@ public class GameFuncAdapters
 			return true;
 		}
 	};
-	static EntUseAdapter door_use = new EntUseAdapter()
-	{
-		public void use(edict_t self, edict_t other, edict_t activator)
-		{
+	static EntUseAdapter door_use= new EntUseAdapter() {
+		public void use(edict_t self, edict_t other, edict_t activator) {
 			edict_t ent;
 
 			if ((self.flags & Defines.FL_TEAMSLAVE) != 0)
 				return;
 
-			if ((self.spawnflags & DOOR_TOGGLE) != 0)
-			{
-				if (self.moveinfo.state == STATE_UP || self.moveinfo.state == STATE_TOP)
-				{
+			if ((self.spawnflags & DOOR_TOGGLE) != 0) {
+				if (self.moveinfo.state == STATE_UP || self.moveinfo.state == STATE_TOP) {
 					// trigger all paired doors
-					for (ent = self; ent != null; ent = ent.teamchain)
-					{
-						ent.message = null;
-						ent.touch = null;
+					for (ent= self; ent != null; ent= ent.teamchain) {
+						ent.message= null;
+						ent.touch= null;
 						door_go_down.think(ent);
 					}
 					return;
@@ -768,18 +687,15 @@ public class GameFuncAdapters
 			}
 
 			// trigger all paired doors
-			for (ent = self; ent != null; ent = ent.teamchain)
-			{
-				ent.message = null;
-				ent.touch = null;
+			for (ent= self; ent != null; ent= ent.teamchain) {
+				ent.message= null;
+				ent.touch= null;
 				GameFunc.door_go_up(ent, activator);
 			}
 		}
 	};
-	static EntTouchAdapter Touch_DoorTrigger = new EntTouchAdapter()
-	{
-		public void touch(edict_t self, edict_t other, cplane_t plane, csurface_t surf)
-		{
+	static EntTouchAdapter Touch_DoorTrigger= new EntTouchAdapter() {
+		public void touch(edict_t self, edict_t other, cplane_t plane, csurface_t surf) {
 			if (other.health <= 0)
 				return;
 
@@ -791,15 +707,13 @@ public class GameFuncAdapters
 
 			if (GameBase.level.time < self.touch_debounce_time)
 				return;
-			self.touch_debounce_time = GameBase.level.time + 1.0f;
+			self.touch_debounce_time= GameBase.level.time + 1.0f;
 
 			door_use.use(self.owner, other, other);
 		}
 	};
-	static EntThinkAdapter Think_CalcMoveSpeed = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
+	static EntThinkAdapter Think_CalcMoveSpeed= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
 			edict_t ent;
 			float min;
 			float time;
@@ -811,41 +725,37 @@ public class GameFuncAdapters
 				return true; // only the team master does this
 
 			// find the smallest distance any member of the team will be moving
-			min = Math.abs(self.moveinfo.distance);
-			for (ent = self.teamchain; ent != null; ent = ent.teamchain)
-			{
-				dist = Math.abs(ent.moveinfo.distance);
+			min= Math.abs(self.moveinfo.distance);
+			for (ent= self.teamchain; ent != null; ent= ent.teamchain) {
+				dist= Math.abs(ent.moveinfo.distance);
 				if (dist < min)
-					min = dist;
+					min= dist;
 			}
 
-			time = min / self.moveinfo.speed;
+			time= min / self.moveinfo.speed;
 
 			// adjust speeds so they will all complete at the same time
-			for (ent = self; ent != null; ent = ent.teamchain)
-			{
-				newspeed = Math.abs(ent.moveinfo.distance) / time;
-				ratio = newspeed / ent.moveinfo.speed;
+			for (ent= self; ent != null; ent= ent.teamchain) {
+				newspeed= Math.abs(ent.moveinfo.distance) / time;
+				ratio= newspeed / ent.moveinfo.speed;
 				if (ent.moveinfo.accel == ent.moveinfo.speed)
-					ent.moveinfo.accel = newspeed;
+					ent.moveinfo.accel= newspeed;
 				else
 					ent.moveinfo.accel *= ratio;
 				if (ent.moveinfo.decel == ent.moveinfo.speed)
-					ent.moveinfo.decel = newspeed;
+					ent.moveinfo.decel= newspeed;
 				else
 					ent.moveinfo.decel *= ratio;
-				ent.moveinfo.speed = newspeed;
+				ent.moveinfo.speed= newspeed;
 			}
 			return true;
 		}
 	};
-	
-	static EntThinkAdapter Think_SpawnDoorTrigger = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
+
+	static EntThinkAdapter Think_SpawnDoorTrigger= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
 			edict_t other;
-			float[] mins = { 0, 0, 0 }, maxs = { 0, 0, 0 };
+			float[] mins= { 0, 0, 0 }, maxs= { 0, 0, 0 };
 
 			if ((ent.flags & Defines.FL_TEAMSLAVE) != 0)
 				return true; // only the team leader spawns a trigger
@@ -853,8 +763,7 @@ public class GameFuncAdapters
 			Math3D.VectorCopy(ent.absmin, mins);
 			Math3D.VectorCopy(ent.absmax, maxs);
 
-			for (other = ent.teamchain; other != null; other = other.teamchain)
-			{
+			for (other= ent.teamchain; other != null; other= other.teamchain) {
 				GameBase.AddPointToBounds(other.absmin, mins, maxs);
 				GameBase.AddPointToBounds(other.absmax, mins, maxs);
 			}
@@ -865,13 +774,13 @@ public class GameFuncAdapters
 			maxs[0] += 60;
 			maxs[1] += 60;
 
-			other = GameUtil.G_Spawn();
+			other= GameUtil.G_Spawn();
 			Math3D.VectorCopy(mins, other.mins);
 			Math3D.VectorCopy(maxs, other.maxs);
-			other.owner = ent;
-			other.solid = Defines.SOLID_TRIGGER;
-			other.movetype = Defines.MOVETYPE_NONE;
-			other.touch = Touch_DoorTrigger;
+			other.owner= ent;
+			other.solid= Defines.SOLID_TRIGGER;
+			other.movetype= Defines.MOVETYPE_NONE;
+			other.touch= Touch_DoorTrigger;
 			GameBase.gi.linkentity(other);
 
 			if ((ent.spawnflags & DOOR_START_OPEN) != 0)
@@ -881,14 +790,11 @@ public class GameFuncAdapters
 			return true;
 		}
 	};
-	static EntBlockedAdapter door_blocked = new EntBlockedAdapter()
-	{
-		public void blocked(edict_t self, edict_t other)
-		{
+	static EntBlockedAdapter door_blocked= new EntBlockedAdapter() {
+		public void blocked(edict_t self, edict_t other) {
 			edict_t ent;
 
-			if (0 == (other.svflags & Defines.SVF_MONSTER) && (null == other.client))
-			{
+			if (0 == (other.svflags & Defines.SVF_MONSTER) && (null == other.client)) {
 				// give it a chance to go away on it's own terms (like gibs)
 				GameUtil.T_Damage(
 					other,
@@ -924,124 +830,110 @@ public class GameFuncAdapters
 
 			//	   if a door has a negative wait, it would never come back if blocked,
 			//	   so let it just squash the object to death real fast
-			if (self.moveinfo.wait >= 0)
-			{
-				if (self.moveinfo.state == STATE_DOWN)
-				{
-					for (ent = self.teammaster; ent != null; ent = ent.teamchain)
+			if (self.moveinfo.wait >= 0) {
+				if (self.moveinfo.state == STATE_DOWN) {
+					for (ent= self.teammaster; ent != null; ent= ent.teamchain)
 						GameFunc.door_go_up(ent, ent.activator);
 				}
-				else
-				{
-					for (ent = self.teammaster; ent != null; ent = ent.teamchain)
+				else {
+					for (ent= self.teammaster; ent != null; ent= ent.teamchain)
 						door_go_down.think(ent);
 				}
 			}
 		}
 	};
-	static EntDieAdapter door_killed = new EntDieAdapter()
-	{
-		public void die(edict_t self, edict_t inflictor, edict_t attacker, int damage, float[] point)
-		{
+	static EntDieAdapter door_killed= new EntDieAdapter() {
+		public void die(edict_t self, edict_t inflictor, edict_t attacker, int damage, float[] point) {
 			edict_t ent;
 
-			for (ent = self.teammaster; ent != null; ent = ent.teamchain)
-			{
-				ent.health = ent.max_health;
-				ent.takedamage = Defines.DAMAGE_NO;
+			for (ent= self.teammaster; ent != null; ent= ent.teamchain) {
+				ent.health= ent.max_health;
+				ent.takedamage= Defines.DAMAGE_NO;
 			}
 			door_use.use(self.teammaster, attacker, attacker);
 		}
 	};
-	static EntTouchAdapter door_touch = new EntTouchAdapter()
-	{
-		public void touch(edict_t self, edict_t other, cplane_t plane, csurface_t surf)
-		{
+	static EntTouchAdapter door_touch= new EntTouchAdapter() {
+		public void touch(edict_t self, edict_t other, cplane_t plane, csurface_t surf) {
 			if (null == other.client)
 				return;
 
 			if (GameBase.level.time < self.touch_debounce_time)
 				return;
-			self.touch_debounce_time = GameBase.level.time + 5.0f;
+			self.touch_debounce_time= GameBase.level.time + 5.0f;
 
 			GameBase.gi.centerprintf(other, self.message);
 			GameBase.gi.sound(other, Defines.CHAN_AUTO, GameBase.gi.soundindex("misc/talk1.wav"), 1, Defines.ATTN_NORM, 0);
 		}
 	};
-	static EntThinkAdapter SP_func_door = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
-			float[] abs_movedir = { 0, 0, 0 };
-
-			if (ent.sounds != 1)
-			{
-				ent.moveinfo.sound_start = GameBase.gi.soundindex("doors/dr1_strt.wav");
-				ent.moveinfo.sound_middle = GameBase.gi.soundindex("doors/dr1_mid.wav");
-				ent.moveinfo.sound_end = GameBase.gi.soundindex("doors/dr1_end.wav");
+	static EntThinkAdapter SP_func_door= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
+			float[] abs_movedir= { 0, 0, 0 };
+
+			if (ent.sounds != 1) {
+				ent.moveinfo.sound_start= GameBase.gi.soundindex("doors/dr1_strt.wav");
+				ent.moveinfo.sound_middle= GameBase.gi.soundindex("doors/dr1_mid.wav");
+				ent.moveinfo.sound_end= GameBase.gi.soundindex("doors/dr1_end.wav");
 			}
 
 			GameBase.G_SetMovedir(ent.s.angles, ent.movedir);
-			ent.movetype = Defines.MOVETYPE_PUSH;
-			ent.solid = Defines.SOLID_BSP;
+			ent.movetype= Defines.MOVETYPE_PUSH;
+			ent.solid= Defines.SOLID_BSP;
 			GameBase.gi.setmodel(ent, ent.model);
 
-			ent.blocked = door_blocked;
-			ent.use = door_use;
+			ent.blocked= door_blocked;
+			ent.use= door_use;
 
 			if (0 == ent.speed)
-				ent.speed = 100;
+				ent.speed= 100;
 			if (GameBase.deathmatch.value != 0)
 				ent.speed *= 2;
 
 			if (0 == ent.accel)
-				ent.accel = ent.speed;
+				ent.accel= ent.speed;
 			if (0 == ent.decel)
-				ent.decel = ent.speed;
+				ent.decel= ent.speed;
 
 			if (0 == ent.wait)
-				ent.wait = 3;
+				ent.wait= 3;
 			if (0 == GameBase.st.lip)
-				GameBase.st.lip = 8;
+				GameBase.st.lip= 8;
 			if (0 == ent.dmg)
-				ent.dmg = 2;
+				ent.dmg= 2;
 
 			// calculate second position
 			Math3D.VectorCopy(ent.s.origin, ent.pos1);
-			abs_movedir[0] = Math.abs(ent.movedir[0]);
-			abs_movedir[1] = Math.abs(ent.movedir[1]);
-			abs_movedir[2] = Math.abs(ent.movedir[2]);
-			ent.moveinfo.distance =
+			abs_movedir[0]= Math.abs(ent.movedir[0]);
+			abs_movedir[1]= Math.abs(ent.movedir[1]);
+			abs_movedir[2]= Math.abs(ent.movedir[2]);
+			ent.moveinfo.distance=
 				abs_movedir[0] * ent.size[0] + abs_movedir[1] * ent.size[1] + abs_movedir[2] * ent.size[2] - GameBase.st.lip;
 
 			Math3D.VectorMA(ent.pos1, ent.moveinfo.distance, ent.movedir, ent.pos2);
 
 			// if it starts open, switch the positions
-			if ((ent.spawnflags & DOOR_START_OPEN) != 0)
-			{
+			if ((ent.spawnflags & DOOR_START_OPEN) != 0) {
 				Math3D.VectorCopy(ent.pos2, ent.s.origin);
 				Math3D.VectorCopy(ent.pos1, ent.pos2);
 				Math3D.VectorCopy(ent.s.origin, ent.pos1);
 			}
 
-			ent.moveinfo.state = STATE_BOTTOM;
+			ent.moveinfo.state= STATE_BOTTOM;
 
-			if (ent.health != 0)
-			{
-				ent.takedamage = Defines.DAMAGE_YES;
-				ent.die = door_killed;
-				ent.max_health = ent.health;
+			if (ent.health != 0) {
+				ent.takedamage= Defines.DAMAGE_YES;
+				ent.die= door_killed;
+				ent.max_health= ent.health;
 			}
-			else if (ent.targetname != null && ent.message != null)
-			{
+			else if (ent.targetname != null && ent.message != null) {
 				GameBase.gi.soundindex("misc/talk.wav");
-				ent.touch = door_touch;
+				ent.touch= door_touch;
 			}
 
-			ent.moveinfo.speed = ent.speed;
-			ent.moveinfo.accel = ent.accel;
-			ent.moveinfo.decel = ent.decel;
-			ent.moveinfo.wait = ent.wait;
+			ent.moveinfo.speed= ent.speed;
+			ent.moveinfo.accel= ent.accel;
+			ent.moveinfo.decel= ent.decel;
+			ent.moveinfo.wait= ent.wait;
 			Math3D.VectorCopy(ent.pos1, ent.moveinfo.start_origin);
 			Math3D.VectorCopy(ent.s.angles, ent.moveinfo.start_angles);
 			Math3D.VectorCopy(ent.pos2, ent.moveinfo.end_origin);
@@ -1054,15 +946,15 @@ public class GameFuncAdapters
 
 			// to simplify logic elsewhere, make non-teamed doors into a team of one
 			if (null == ent.team)
-				ent.teammaster = ent;
+				ent.teammaster= ent;
 
 			GameBase.gi.linkentity(ent);
 
-			ent.nextthink = GameBase.level.time + Defines.FRAMETIME;
+			ent.nextthink= GameBase.level.time + Defines.FRAMETIME;
 			if (ent.health != 0 || ent.targetname != null)
-				ent.think = Think_CalcMoveSpeed;
+				ent.think= Think_CalcMoveSpeed;
 			else
-				ent.think = Think_SpawnDoorTrigger;
+				ent.think= Think_SpawnDoorTrigger;
 			return true;
 		}
 	};
@@ -1095,88 +987,81 @@ public class GameFuncAdapters
 	4)	heavy
 	*/
 
-	static EntThinkAdapter SP_func_door_rotating = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
+	static EntThinkAdapter SP_func_door_rotating= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
 			Math3D.VectorClear(ent.s.angles);
 
 			// set the axis of rotation
 			Math3D.VectorClear(ent.movedir);
 			if ((ent.spawnflags & DOOR_X_AXIS) != 0)
-				ent.movedir[2] = 1.0f;
+				ent.movedir[2]= 1.0f;
 			else if ((ent.spawnflags & DOOR_Y_AXIS) != 0)
-				ent.movedir[0] = 1.0f;
+				ent.movedir[0]= 1.0f;
 			else // Z_AXIS
-				ent.movedir[1] = 1.0f;
+				ent.movedir[1]= 1.0f;
 
 			// check for reverse rotation
 			if ((ent.spawnflags & DOOR_REVERSE) != 0)
 				Math3D.VectorNegate(ent.movedir, ent.movedir);
 
-			if (0 == GameBase.st.distance)
-			{
+			if (0 == GameBase.st.distance) {
 				GameBase.gi.dprintf(ent.classname + " at " + Lib.vtos(ent.s.origin) + " with no distance set\n");
-				GameBase.st.distance = 90;
+				GameBase.st.distance= 90;
 			}
 
 			Math3D.VectorCopy(ent.s.angles, ent.pos1);
 			Math3D.VectorMA(ent.s.angles, GameBase.st.distance, ent.movedir, ent.pos2);
-			ent.moveinfo.distance = GameBase.st.distance;
+			ent.moveinfo.distance= GameBase.st.distance;
 
-			ent.movetype = Defines.MOVETYPE_PUSH;
-			ent.solid = Defines.SOLID_BSP;
+			ent.movetype= Defines.MOVETYPE_PUSH;
+			ent.solid= Defines.SOLID_BSP;
 			GameBase.gi.setmodel(ent, ent.model);
 
-			ent.blocked = door_blocked;
-			ent.use = door_use;
+			ent.blocked= door_blocked;
+			ent.use= door_use;
 
 			if (0 == ent.speed)
-				ent.speed = 100;
+				ent.speed= 100;
 			if (0 == ent.accel)
-				ent.accel = ent.speed;
+				ent.accel= ent.speed;
 			if (0 == ent.decel)
-				ent.decel = ent.speed;
+				ent.decel= ent.speed;
 
 			if (0 == ent.wait)
-				ent.wait = 3;
+				ent.wait= 3;
 			if (0 == ent.dmg)
-				ent.dmg = 2;
+				ent.dmg= 2;
 
-			if (ent.sounds != 1)
-			{
-				ent.moveinfo.sound_start = GameBase.gi.soundindex("doors/dr1_strt.wav");
-				ent.moveinfo.sound_middle = GameBase.gi.soundindex("doors/dr1_mid.wav");
-				ent.moveinfo.sound_end = GameBase.gi.soundindex("doors/dr1_end.wav");
+			if (ent.sounds != 1) {
+				ent.moveinfo.sound_start= GameBase.gi.soundindex("doors/dr1_strt.wav");
+				ent.moveinfo.sound_middle= GameBase.gi.soundindex("doors/dr1_mid.wav");
+				ent.moveinfo.sound_end= GameBase.gi.soundindex("doors/dr1_end.wav");
 			}
 
 			// if it starts open, switch the positions
-			if ((ent.spawnflags & DOOR_START_OPEN) != 0)
-			{
+			if ((ent.spawnflags & DOOR_START_OPEN) != 0) {
 				Math3D.VectorCopy(ent.pos2, ent.s.angles);
 				Math3D.VectorCopy(ent.pos1, ent.pos2);
 				Math3D.VectorCopy(ent.s.angles, ent.pos1);
 				Math3D.VectorNegate(ent.movedir, ent.movedir);
 			}
 
-			if (ent.health != 0)
-			{
-				ent.takedamage = Defines.DAMAGE_YES;
-				ent.die = door_killed;
-				ent.max_health = ent.health;
+			if (ent.health != 0) {
+				ent.takedamage= Defines.DAMAGE_YES;
+				ent.die= door_killed;
+				ent.max_health= ent.health;
 			}
 
-			if (ent.targetname != null && ent.message != null)
-			{
+			if (ent.targetname != null && ent.message != null) {
 				GameBase.gi.soundindex("misc/talk.wav");
-				ent.touch = door_touch;
+				ent.touch= door_touch;
 			}
 
-			ent.moveinfo.state = STATE_BOTTOM;
-			ent.moveinfo.speed = ent.speed;
-			ent.moveinfo.accel = ent.accel;
-			ent.moveinfo.decel = ent.decel;
-			ent.moveinfo.wait = ent.wait;
+			ent.moveinfo.state= STATE_BOTTOM;
+			ent.moveinfo.speed= ent.speed;
+			ent.moveinfo.accel= ent.accel;
+			ent.moveinfo.decel= ent.decel;
+			ent.moveinfo.wait= ent.wait;
 			Math3D.VectorCopy(ent.s.origin, ent.moveinfo.start_origin);
 			Math3D.VectorCopy(ent.pos1, ent.moveinfo.start_angles);
 			Math3D.VectorCopy(ent.s.origin, ent.moveinfo.end_origin);
@@ -1187,21 +1072,21 @@ public class GameFuncAdapters
 
 			// to simplify logic elsewhere, make non-teamed doors into a team of one
 			if (ent.team == null)
-				ent.teammaster = ent;
+				ent.teammaster= ent;
 
 			GameBase.gi.linkentity(ent);
 
-			ent.nextthink = GameBase.level.time + Defines.FRAMETIME;
+			ent.nextthink= GameBase.level.time + Defines.FRAMETIME;
 			if (ent.health != 0 || ent.targetname != null)
-				ent.think = Think_CalcMoveSpeed;
+				ent.think= Think_CalcMoveSpeed;
 			else
-				ent.think = Think_SpawnDoorTrigger;
+				ent.think= Think_SpawnDoorTrigger;
 			return true;
 		}
 	};
-	public final static int TRAIN_START_ON = 1;
-	public final static int TRAIN_TOGGLE = 2;
-	public final static int TRAIN_BLOCK_STOPS = 4;
+	public final static int TRAIN_START_ON= 1;
+	public final static int TRAIN_TOGGLE= 2;
+	public final static int TRAIN_BLOCK_STOPS= 4;
 	/*QUAKED func_train (0 .5 .8) ? START_ON TOGGLE BLOCK_STOPS
 	Trains are moving platforms that players can ride.
 	The targets origin specifies the min point of the train at each corner.
@@ -1213,13 +1098,10 @@ public class GameFuncAdapters
 	
 	*/
 
-	static EntBlockedAdapter train_blocked = new EntBlockedAdapter()
-	{
+	static EntBlockedAdapter train_blocked= new EntBlockedAdapter() {
 
-		public void blocked(edict_t self, edict_t other)
-		{
-			if (0 == (other.svflags & Defines.SVF_MONSTER) && (null == other.client))
-			{
+		public void blocked(edict_t self, edict_t other) {
+			if (0 == (other.svflags & Defines.SVF_MONSTER) && (null == other.client)) {
 				// give it a chance to go away on it's own terms (like gibs)
 				GameUtil.T_Damage(
 					other,
@@ -1243,7 +1125,7 @@ public class GameFuncAdapters
 
 			if (self.dmg == 0)
 				return;
-			self.touch_debounce_time = GameBase.level.time + 0.5f;
+			self.touch_debounce_time= GameBase.level.time + 0.5f;
 			GameUtil.T_Damage(
 				other,
 				self,
@@ -1257,43 +1139,37 @@ public class GameFuncAdapters
 				Defines.MOD_CRUSH);
 		}
 	};
-	static EntThinkAdapter train_wait = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
-			if (self.target_ent.pathtarget != null)
-			{
+	static EntThinkAdapter train_wait= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
+			if (self.target_ent.pathtarget != null) {
 				String savetarget;
 				edict_t ent;
 
-				ent = self.target_ent;
-				savetarget = ent.target;
-				ent.target = ent.pathtarget;
+				ent= self.target_ent;
+				savetarget= ent.target;
+				ent.target= ent.pathtarget;
 				GameUtil.G_UseTargets(ent, self.activator);
-				ent.target = savetarget;
+				ent.target= savetarget;
 
 				// make sure we didn't get killed by a killtarget
 				if (!self.inuse)
 					return true;
 			}
 
-			if (self.moveinfo.wait != 0)
-			{
-				if (self.moveinfo.wait > 0)
-				{
-					self.nextthink = GameBase.level.time + self.moveinfo.wait;
-					self.think = train_next;
+			if (self.moveinfo.wait != 0) {
+				if (self.moveinfo.wait > 0) {
+					self.nextthink= GameBase.level.time + self.moveinfo.wait;
+					self.think= train_next;
 				}
 				else if (0 != (self.spawnflags & TRAIN_TOGGLE)) // && wait < 0
-				{
+					{
 					train_next.think(self);
 					self.spawnflags &= ~TRAIN_START_ON;
 					Math3D.VectorClear(self.velocity);
-					self.nextthink = 0;
+					self.nextthink= 0;
 				}
 
-				if (0 == (self.flags & Defines.FL_TEAMSLAVE))
-				{
+				if (0 == (self.flags & Defines.FL_TEAMSLAVE)) {
 					if (self.moveinfo.sound_end != 0)
 						GameBase.gi.sound(
 							self,
@@ -1302,66 +1178,57 @@ public class GameFuncAdapters
 							1,
 							Defines.ATTN_STATIC,
 							0);
-					self.s.sound = 0;
+					self.s.sound= 0;
 				}
 			}
-			else
-			{
+			else {
 				train_next.think(self);
 			}
 			return true;
 		}
 	};
-	static EntThinkAdapter train_next = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
-			edict_t ent = null;
-			float[] dest = { 0, 0, 0 };
+	static EntThinkAdapter train_next= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
+			edict_t ent= null;
+			float[] dest= { 0, 0, 0 };
 			boolean first;
 
-			first = true;
+			first= true;
 
-			boolean dogoto = true;
-			while (dogoto)
-			{
-				if (null == self.target)
-				{
+			boolean dogoto= true;
+			while (dogoto) {
+				if (null == self.target) {
 					//			gi.dprintf ("train_next: no next target\n");
 					return true;
 				}
 
-				ent = GameBase.G_PickTarget(self.target);
-				if (null == ent)
-				{
+				ent= GameBase.G_PickTarget(self.target);
+				if (null == ent) {
 					GameBase.gi.dprintf("train_next: bad target " + self.target + "\n");
 					return true;
 				}
 
-				self.target = ent.target;
-				dogoto = false;
+				self.target= ent.target;
+				dogoto= false;
 				// check for a teleport path_corner
-				if ((ent.spawnflags & 1) != 0)
-				{
-					if (!first)
-					{
+				if ((ent.spawnflags & 1) != 0) {
+					if (!first) {
 						GameBase.gi.dprintf(
 							"connected teleport path_corners, see " + ent.classname + " at " + Lib.vtos(ent.s.origin) + "\n");
 						return true;
 					}
-					first = false;
+					first= false;
 					Math3D.VectorSubtract(ent.s.origin, self.mins, self.s.origin);
 					Math3D.VectorCopy(self.s.origin, self.s.old_origin);
-					self.s.event = Defines.EV_OTHER_TELEPORT;
+					self.s.event= Defines.EV_OTHER_TELEPORT;
 					GameBase.gi.linkentity(self);
-					dogoto = true;
+					dogoto= true;
 				}
 			}
-			self.moveinfo.wait = ent.wait;
-			self.target_ent = ent;
+			self.moveinfo.wait= ent.wait;
+			self.target_ent= ent;
 
-			if (0 == (self.flags & Defines.FL_TEAMSLAVE))
-			{
+			if (0 == (self.flags & Defines.FL_TEAMSLAVE)) {
 				if (self.moveinfo.sound_start != 0)
 					GameBase.gi.sound(
 						self,
@@ -1370,11 +1237,11 @@ public class GameFuncAdapters
 						1,
 						Defines.ATTN_STATIC,
 						0);
-				self.s.sound = self.moveinfo.sound_middle;
+				self.s.sound= self.moveinfo.sound_middle;
 			}
 
 			Math3D.VectorSubtract(ent.s.origin, self.mins, dest);
-			self.moveinfo.state = STATE_TOP;
+			self.moveinfo.state= STATE_TOP;
 			Math3D.VectorCopy(self.s.origin, self.moveinfo.start_origin);
 			Math3D.VectorCopy(dest, self.moveinfo.end_origin);
 			GameFunc.Move_Calc(self, dest, train_wait);
@@ -1382,24 +1249,20 @@ public class GameFuncAdapters
 			return true;
 		}
 	};
-	public static EntThinkAdapter func_train_find = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
+	public static EntThinkAdapter func_train_find= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
 			edict_t ent;
 
-			if (null == self.target)
-			{
+			if (null == self.target) {
 				GameBase.gi.dprintf("train_find: no target\n");
 				return true;
 			}
-			ent = GameBase.G_PickTarget(self.target);
-			if (null == ent)
-			{
+			ent= GameBase.G_PickTarget(self.target);
+			if (null == ent) {
 				GameBase.gi.dprintf("train_find: target " + self.target + " not found\n");
 				return true;
 			}
-			self.target = ent.target;
+			self.target= ent.target;
 
 			Math3D.VectorSubtract(ent.s.origin, self.mins, self.s.origin);
 			GameBase.gi.linkentity(self);
@@ -1408,31 +1271,26 @@ public class GameFuncAdapters
 			if (null == self.targetname)
 				self.spawnflags |= TRAIN_START_ON;
 
-			if ((self.spawnflags & TRAIN_START_ON) != 0)
-			{
-				self.nextthink = GameBase.level.time + Defines.FRAMETIME;
-				self.think = train_next;
-				self.activator = self;
+			if ((self.spawnflags & TRAIN_START_ON) != 0) {
+				self.nextthink= GameBase.level.time + Defines.FRAMETIME;
+				self.think= train_next;
+				self.activator= self;
 			}
 			return true;
 		}
 	};
-	public static EntUseAdapter train_use = new EntUseAdapter()
-	{
-		public void use(edict_t self, edict_t other, edict_t activator)
-		{
-			self.activator = activator;
-
-			if ((self.spawnflags & TRAIN_START_ON) != 0)
-			{
+	public static EntUseAdapter train_use= new EntUseAdapter() {
+		public void use(edict_t self, edict_t other, edict_t activator) {
+			self.activator= activator;
+
+			if ((self.spawnflags & TRAIN_START_ON) != 0) {
 				if (0 == (self.spawnflags & TRAIN_TOGGLE))
 					return;
 				self.spawnflags &= ~TRAIN_START_ON;
 				Math3D.VectorClear(self.velocity);
-				self.nextthink = 0;
+				self.nextthink= 0;
 			}
-			else
-			{
+			else {
 				if (self.target_ent != null)
 					GameFunc.train_resume(self);
 				else
@@ -1442,68 +1300,56 @@ public class GameFuncAdapters
 	};
 	/*QUAKED trigger_elevator (0.3 0.1 0.6) (-8 -8 -8) (8 8 8)
 	*/
-	static EntUseAdapter trigger_elevator_use = new EntUseAdapter()
-	{
+	static EntUseAdapter trigger_elevator_use= new EntUseAdapter() {
 
-		public void use(edict_t self, edict_t other, edict_t activator)
-		{
+		public void use(edict_t self, edict_t other, edict_t activator) {
 			edict_t target;
 
-			if (0 != self.movetarget.nextthink)
-			{
+			if (0 != self.movetarget.nextthink) {
 				//			gi.dprintf("elevator busy\n");
 				return;
 			}
 
-			if (null == other.pathtarget)
-			{
+			if (null == other.pathtarget) {
 				GameBase.gi.dprintf("elevator used with no pathtarget\n");
 				return;
 			}
 
-			target = GameBase.G_PickTarget(other.pathtarget);
-			if (null == target)
-			{
+			target= GameBase.G_PickTarget(other.pathtarget);
+			if (null == target) {
 				GameBase.gi.dprintf("elevator used with bad pathtarget: " + other.pathtarget + "\n");
 				return;
 			}
 
-			self.movetarget.target_ent = target;
+			self.movetarget.target_ent= target;
 			GameFunc.train_resume(self.movetarget);
 		}
 	};
-	static EntThinkAdapter trigger_elevator_init = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
-			if (null == self.target)
-			{
+	static EntThinkAdapter trigger_elevator_init= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
+			if (null == self.target) {
 				GameBase.gi.dprintf("trigger_elevator has no target\n");
 				return true;
 			}
-			self.movetarget = GameBase.G_PickTarget(self.target);
-			if (null == self.movetarget)
-			{
+			self.movetarget= GameBase.G_PickTarget(self.target);
+			if (null == self.movetarget) {
 				GameBase.gi.dprintf("trigger_elevator unable to find target " + self.target + "\n");
 				return true;
 			}
-			if (Lib.strcmp(self.movetarget.classname, "func_train") != 0)
-			{
+			if (Lib.strcmp(self.movetarget.classname, "func_train") != 0) {
 				GameBase.gi.dprintf("trigger_elevator target " + self.target + " is not a train\n");
 				return true;
 			}
 
-			self.use = trigger_elevator_use;
-			self.svflags = Defines.SVF_NOCLIENT;
+			self.use= trigger_elevator_use;
+			self.svflags= Defines.SVF_NOCLIENT;
 			return true;
 		}
 	};
-	static EntThinkAdapter SP_trigger_elevator = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
-			self.think = trigger_elevator_init;
-			self.nextthink = GameBase.level.time + Defines.FRAMETIME;
+	static EntThinkAdapter SP_trigger_elevator= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
+			self.think= trigger_elevator_init;
+			self.nextthink= GameBase.level.time + Defines.FRAMETIME;
 			return true;
 		}
 	};
@@ -1522,31 +1368,26 @@ public class GameFuncAdapters
 	These can used but not touched.
 	*/
 
-	static EntThinkAdapter func_timer_think = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
+	static EntThinkAdapter func_timer_think= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
 			GameUtil.G_UseTargets(self, self.activator);
-			self.nextthink = GameBase.level.time + self.wait + Lib.crandom() * self.random;
+			self.nextthink= GameBase.level.time + self.wait + Lib.crandom() * self.random;
 			return true;
 		}
 	};
-	static EntUseAdapter func_timer_use = new EntUseAdapter()
-	{
-		public void use(edict_t self, edict_t other, edict_t activator)
-		{
-			self.activator = activator;
+	static EntUseAdapter func_timer_use= new EntUseAdapter() {
+		public void use(edict_t self, edict_t other, edict_t activator) {
+			self.activator= activator;
 
 			// if on, turn it off
-			if (self.nextthink != 0)
-			{
-				self.nextthink = 0;
+			if (self.nextthink != 0) {
+				self.nextthink= 0;
 				return;
 			}
 
 			// turn it on
 			if (self.delay != 0)
-				self.nextthink = GameBase.level.time + self.delay;
+				self.nextthink= GameBase.level.time + self.delay;
 			else
 				func_timer_think.think(self);
 		}
@@ -1557,43 +1398,36 @@ public class GameFuncAdapters
 	speed	default 100
 	*/
 
-	static EntUseAdapter func_conveyor_use = new EntUseAdapter()
-	{
-		public void use(edict_t self, edict_t other, edict_t activator)
-		{
-			if ((self.spawnflags & 1) != 0)
-			{
-				self.speed = 0;
+	static EntUseAdapter func_conveyor_use= new EntUseAdapter() {
+		public void use(edict_t self, edict_t other, edict_t activator) {
+			if ((self.spawnflags & 1) != 0) {
+				self.speed= 0;
 				self.spawnflags &= ~1;
 			}
-			else
-			{
-				self.speed = self.count;
+			else {
+				self.speed= self.count;
 				self.spawnflags |= 1;
 			}
 
 			if (0 == (self.spawnflags & 2))
-				self.count = 0;
+				self.count= 0;
 		}
 	};
-	static EntThinkAdapter SP_func_conveyor = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
+	static EntThinkAdapter SP_func_conveyor= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
 
 			if (0 == self.speed)
-				self.speed = 100;
+				self.speed= 100;
 
-			if (0 == (self.spawnflags & 1))
-			{
-				self.count = (int) self.speed;
-				self.speed = 0;
+			if (0 == (self.spawnflags & 1)) {
+				self.count= (int) self.speed;
+				self.speed= 0;
 			}
 
-			self.use = func_conveyor_use;
+			self.use= func_conveyor_use;
 
 			GameBase.gi.setmodel(self, self.model);
-			self.solid = Defines.SOLID_BSP;
+			self.solid= Defines.SOLID_BSP;
 			GameBase.gi.linkentity(self);
 			return true;
 		}
@@ -1611,14 +1445,12 @@ public class GameFuncAdapters
 	"wait"		how long to hold in the open position (default 5, -1 means hold)
 	*/
 
-	public final static int SECRET_ALWAYS_SHOOT = 1;
-	public final static int SECRET_1ST_LEFT = 2;
-	public final static int SECRET_1ST_DOWN = 4;
-	static EntUseAdapter door_secret_use = new EntUseAdapter()
-	{
+	public final static int SECRET_ALWAYS_SHOOT= 1;
+	public final static int SECRET_1ST_LEFT= 2;
+	public final static int SECRET_1ST_DOWN= 4;
+	static EntUseAdapter door_secret_use= new EntUseAdapter() {
 
-		public void use(edict_t self, edict_t other, edict_t activator)
-		{
+		public void use(edict_t self, edict_t other, edict_t activator) {
 				// make sure we're not already moving
 	if (0 == Math3D.VectorCompare(self.s.origin, Globals.vec3_origin))
 				return;
@@ -1627,80 +1459,62 @@ public class GameFuncAdapters
 			GameFunc.door_use_areaportals(self, true);
 		}
 	};
-	static EntThinkAdapter door_secret_move1 = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
-			self.nextthink = GameBase.level.time + 1.0f;
-			self.think = door_secret_move2;
+	static EntThinkAdapter door_secret_move1= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
+			self.nextthink= GameBase.level.time + 1.0f;
+			self.think= door_secret_move2;
 			return true;
 		}
 	};
-	static EntThinkAdapter door_secret_move2 = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
+	static EntThinkAdapter door_secret_move2= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
 			GameFunc.Move_Calc(self, self.pos2, door_secret_move3);
 			return true;
 		}
 	};
-	static EntThinkAdapter door_secret_move3 = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
+	static EntThinkAdapter door_secret_move3= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
 			if (self.wait == -1)
 				return true;
-			self.nextthink = GameBase.level.time + self.wait;
-			self.think = door_secret_move4;
+			self.nextthink= GameBase.level.time + self.wait;
+			self.think= door_secret_move4;
 			return true;
 		}
 	};
-	static EntThinkAdapter door_secret_move4 = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
+	static EntThinkAdapter door_secret_move4= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
 			GameFunc.Move_Calc(self, self.pos1, door_secret_move5);
 			return true;
 		}
 	};
-	static EntThinkAdapter door_secret_move5 = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
-			self.nextthink = GameBase.level.time + 1.0f;
-			self.think = door_secret_move6;
+	static EntThinkAdapter door_secret_move5= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
+			self.nextthink= GameBase.level.time + 1.0f;
+			self.think= door_secret_move6;
 			return true;
 		}
 	};
-	static EntThinkAdapter door_secret_move6 = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
+	static EntThinkAdapter door_secret_move6= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
 
 			GameFunc.Move_Calc(self, Globals.vec3_origin, door_secret_done);
 			return true;
 		}
 	};
-	static EntThinkAdapter door_secret_done = new EntThinkAdapter()
-	{
-		public boolean think(edict_t self)
-		{
-			if (null == (self.targetname) || 0 != (self.spawnflags & SECRET_ALWAYS_SHOOT))
-			{
-				self.health = 0;
-				self.takedamage = Defines.DAMAGE_YES;
+	static EntThinkAdapter door_secret_done= new EntThinkAdapter() {
+		public boolean think(edict_t self) {
+			if (null == (self.targetname) || 0 != (self.spawnflags & SECRET_ALWAYS_SHOOT)) {
+				self.health= 0;
+				self.takedamage= Defines.DAMAGE_YES;
 			}
 			GameFunc.door_use_areaportals(self, false);
 			return true;
 		}
 	};
-	static EntBlockedAdapter door_secret_blocked = new EntBlockedAdapter()
-	{
+	static EntBlockedAdapter door_secret_blocked= new EntBlockedAdapter() {
 
-		public void blocked(edict_t self, edict_t other)
-		{
-			if (0 == (other.svflags & Defines.SVF_MONSTER) && (null == other.client))
-			{
+		public void blocked(edict_t self, edict_t other) {
+			if (0 == (other.svflags & Defines.SVF_MONSTER) && (null == other.client)) {
 				// give it a chance to go away on it's own terms (like gibs)
 				GameUtil.T_Damage(
 					other,
@@ -1721,7 +1535,7 @@ public class GameFuncAdapters
 
 			if (GameBase.level.time < self.touch_debounce_time)
 				return;
-			self.touch_debounce_time = GameBase.level.time + 0.5f;
+			self.touch_debounce_time= GameBase.level.time + 0.5f;
 
 			GameUtil.T_Damage(
 				other,
@@ -1736,77 +1550,70 @@ public class GameFuncAdapters
 				Defines.MOD_CRUSH);
 		}
 	};
-	static EntDieAdapter door_secret_die = new EntDieAdapter()
-	{
-		public void die(edict_t self, edict_t inflictor, edict_t attacker, int damage, float[] point)
-		{
-			self.takedamage = Defines.DAMAGE_NO;
+	static EntDieAdapter door_secret_die= new EntDieAdapter() {
+		public void die(edict_t self, edict_t inflictor, edict_t attacker, int damage, float[] point) {
+			self.takedamage= Defines.DAMAGE_NO;
 			door_secret_use.use(self, attacker, attacker);
 		}
 	};
-	static EntThinkAdapter SP_func_door_secret = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
-			float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 }, up = { 0, 0, 0 };
+	static EntThinkAdapter SP_func_door_secret= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
+			float[] forward= { 0, 0, 0 }, right= { 0, 0, 0 }, up= { 0, 0, 0 };
 			float side;
 			float width;
 			float length;
 
-			ent.moveinfo.sound_start = GameBase.gi.soundindex("doors/dr1_strt.wav");
-			ent.moveinfo.sound_middle = GameBase.gi.soundindex("doors/dr1_mid.wav");
-			ent.moveinfo.sound_end = GameBase.gi.soundindex("doors/dr1_end.wav");
+			ent.moveinfo.sound_start= GameBase.gi.soundindex("doors/dr1_strt.wav");
+			ent.moveinfo.sound_middle= GameBase.gi.soundindex("doors/dr1_mid.wav");
+			ent.moveinfo.sound_end= GameBase.gi.soundindex("doors/dr1_end.wav");
 
-			ent.movetype = Defines.MOVETYPE_PUSH;
-			ent.solid = Defines.SOLID_BSP;
+			ent.movetype= Defines.MOVETYPE_PUSH;
+			ent.solid= Defines.SOLID_BSP;
 			GameBase.gi.setmodel(ent, ent.model);
 
-			ent.blocked = door_secret_blocked;
-			ent.use = door_secret_use;
+			ent.blocked= door_secret_blocked;
+			ent.use= door_secret_use;
 
-			if (null == (ent.targetname) || 0 != (ent.spawnflags & SECRET_ALWAYS_SHOOT))
-			{
-				ent.health = 0;
-				ent.takedamage = Defines.DAMAGE_YES;
-				ent.die = door_secret_die;
+			if (null == (ent.targetname) || 0 != (ent.spawnflags & SECRET_ALWAYS_SHOOT)) {
+				ent.health= 0;
+				ent.takedamage= Defines.DAMAGE_YES;
+				ent.die= door_secret_die;
 			}
 
 			if (0 == ent.dmg)
-				ent.dmg = 2;
+				ent.dmg= 2;
 
 			if (0 == ent.wait)
-				ent.wait = 5;
+				ent.wait= 5;
 
-			ent.moveinfo.accel = ent.moveinfo.decel = ent.moveinfo.speed = 50;
+			ent.moveinfo.accel= ent.moveinfo.decel= ent.moveinfo.speed= 50;
 
 			// calculate positions
 			Math3D.AngleVectors(ent.s.angles, forward, right, up);
 			Math3D.VectorClear(ent.s.angles);
-			side = 1.0f - (ent.spawnflags & SECRET_1ST_LEFT);
+			side= 1.0f - (ent.spawnflags & SECRET_1ST_LEFT);
 			if ((ent.spawnflags & SECRET_1ST_DOWN) != 0)
-				width = Math.abs(Math3D.DotProduct(up, ent.size));
+				width= Math.abs(Math3D.DotProduct(up, ent.size));
 			else
-				width = Math.abs(Math3D.DotProduct(right, ent.size));
-			length = Math.abs(Math3D.DotProduct(forward, ent.size));
+				width= Math.abs(Math3D.DotProduct(right, ent.size));
+			length= Math.abs(Math3D.DotProduct(forward, ent.size));
 			if ((ent.spawnflags & SECRET_1ST_DOWN) != 0)
 				Math3D.VectorMA(ent.s.origin, -1 * width, up, ent.pos1);
 			else
 				Math3D.VectorMA(ent.s.origin, side * width, right, ent.pos1);
 			Math3D.VectorMA(ent.pos1, length, forward, ent.pos2);
 
-			if (ent.health != 0)
-			{
-				ent.takedamage = Defines.DAMAGE_YES;
-				ent.die = door_killed;
-				ent.max_health = ent.health;
+			if (ent.health != 0) {
+				ent.takedamage= Defines.DAMAGE_YES;
+				ent.die= door_killed;
+				ent.max_health= ent.health;
 			}
-			else if (ent.targetname != null && ent.message != null)
-			{
+			else if (ent.targetname != null && ent.message != null) {
 				GameBase.gi.soundindex("misc/talk.wav");
-				ent.touch = door_touch;
+				ent.touch= door_touch;
 			}
 
-			ent.classname = "func_door";
+			ent.classname= "func_door";
 
 			GameBase.gi.linkentity(ent);
 			return true;
@@ -1815,20 +1622,16 @@ public class GameFuncAdapters
 	/*QUAKED func_killbox (1 0 0) ?
 	Kills everything inside when fired, irrespective of protection.
 	*/
-	static EntUseAdapter use_killbox = new EntUseAdapter()
-	{
-		public void use(edict_t self, edict_t other, edict_t activator)
-		{
+	static EntUseAdapter use_killbox= new EntUseAdapter() {
+		public void use(edict_t self, edict_t other, edict_t activator) {
 			GameUtil.KillBox(self);
 		}
 	};
-	static EntThinkAdapter SP_func_killbox = new EntThinkAdapter()
-	{
-		public boolean think(edict_t ent)
-		{
+	static EntThinkAdapter SP_func_killbox= new EntThinkAdapter() {
+		public boolean think(edict_t ent) {
 			GameBase.gi.setmodel(ent, ent.model);
-			ent.use = use_killbox;
-			ent.svflags = Defines.SVF_NOCLIENT;
+			ent.use= use_killbox;
+			ent.svflags= Defines.SVF_NOCLIENT;
 			return true;
 		}
 	};
diff --git a/src/jake2/game/GameSave.java b/src/jake2/game/GameSave.java
index ba36e06..7db262e 100644
--- a/src/jake2/game/GameSave.java
+++ b/src/jake2/game/GameSave.java
@@ -19,7 +19,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 
 // Created on 29.12.2003 by RST.
-// $Id: GameSave.java,v 1.2 2004-08-20 21:29:57 salomo Exp $
+// $Id: GameSave.java,v 1.3 2004-08-22 14:25:12 salomo Exp $
 
 package jake2.game;
 
@@ -37,7 +37,7 @@ import jake2.util.*;
 
 public class GameSave extends GameFunc {
 
-	public static field_t levelfields[] =
+	public static field_t levelfields[]=
 		{
 			new field_t("changemap", F_LSTRING),
 			new field_t("sight_client", F_EDICT),
@@ -46,7 +46,7 @@ public class GameSave extends GameFunc {
 			new field_t("sound2_entity", F_EDICT),
 			new field_t(null, F_INT)};
 
-	public static field_t clientfields[] =
+	public static field_t clientfields[]=
 		{
 			new field_t("pers.weapon", F_ITEM),
 			new field_t("pers.lastweapon", F_ITEM),
@@ -54,16 +54,16 @@ public class GameSave extends GameFunc {
 			new field_t(null, F_INT)};
 
 	public static void CreateEdicts() {
-		g_edicts = new edict_t[game.maxentities];
-		for (int i = 0; i < game.maxentities; i++)
-			g_edicts[i] = new edict_t(i);
-		SV_GAME.ge.edicts = g_edicts;
+		g_edicts= new edict_t[game.maxentities];
+		for (int i= 0; i < game.maxentities; i++)
+			g_edicts[i]= new edict_t(i);
+		SV_GAME.ge.edicts= g_edicts;
 	}
 
 	public static void CreateClients() {
-		game.clients = new gclient_t[game.maxclients];
-		for (int i = 0; i < game.maxclients; i++)
-			game.clients[i] = new gclient_t(i);
+		game.clients= new gclient_t[game.maxclients];
+		for (int i= 0; i < game.maxclients; i++)
+			game.clients[i]= new gclient_t(i);
 
 	}
 
@@ -79,75 +79,75 @@ public class GameSave extends GameFunc {
 	public static void InitGame() {
 		gi.dprintf("==== InitGame ====\n");
 
-		gun_x = gi.cvar("gun_x", "0", 0);
-		gun_y = gi.cvar("gun_y", "0", 0);
-		gun_z = gi.cvar("gun_z", "0", 0);
+		gun_x= gi.cvar("gun_x", "0", 0);
+		gun_y= gi.cvar("gun_y", "0", 0);
+		gun_z= gi.cvar("gun_z", "0", 0);
 
 		//FIXME: sv_ prefix is wrong for these
-		sv_rollspeed = gi.cvar("sv_rollspeed", "200", 0);
-		sv_rollangle = gi.cvar("sv_rollangle", "2", 0);
-		sv_maxvelocity = gi.cvar("sv_maxvelocity", "2000", 0);
-		sv_gravity = gi.cvar("sv_gravity", "800", 0);
+		sv_rollspeed= gi.cvar("sv_rollspeed", "200", 0);
+		sv_rollangle= gi.cvar("sv_rollangle", "2", 0);
+		sv_maxvelocity= gi.cvar("sv_maxvelocity", "2000", 0);
+		sv_gravity= gi.cvar("sv_gravity", "800", 0);
 
 		// noset vars
-		dedicated = gi.cvar("dedicated", "0", CVAR_NOSET);
+		dedicated= gi.cvar("dedicated", "0", CVAR_NOSET);
 
 		// latched vars
-		sv_cheats = gi.cvar("cheats", "0", CVAR_SERVERINFO | CVAR_LATCH);
+		sv_cheats= gi.cvar("cheats", "0", CVAR_SERVERINFO | CVAR_LATCH);
 		gi.cvar("gamename", GAMEVERSION, CVAR_SERVERINFO | CVAR_LATCH);
 		gi.cvar("gamedate", __DATE__, CVAR_SERVERINFO | CVAR_LATCH);
 
-		maxclients = gi.cvar("maxclients", "4", CVAR_SERVERINFO | CVAR_LATCH);
-		maxspectators = gi.cvar("maxspectators", "4", CVAR_SERVERINFO);
-		deathmatch = gi.cvar("deathmatch", "0", CVAR_LATCH);
-		coop = gi.cvar("coop", "0", CVAR_LATCH);
-		skill = gi.cvar("skill", "0", CVAR_LATCH);
-		maxentities = gi.cvar("maxentities", "1024", CVAR_LATCH);
+		maxclients= gi.cvar("maxclients", "4", CVAR_SERVERINFO | CVAR_LATCH);
+		maxspectators= gi.cvar("maxspectators", "4", CVAR_SERVERINFO);
+		deathmatch= gi.cvar("deathmatch", "0", CVAR_LATCH);
+		coop= gi.cvar("coop", "0", CVAR_LATCH);
+		skill= gi.cvar("skill", "0", CVAR_LATCH);
+		maxentities= gi.cvar("maxentities", "1024", CVAR_LATCH);
 
 		// change anytime vars
-		dmflags = gi.cvar("dmflags", "0", CVAR_SERVERINFO);
-		fraglimit = gi.cvar("fraglimit", "0", CVAR_SERVERINFO);
-		timelimit = gi.cvar("timelimit", "0", CVAR_SERVERINFO);
-		password = gi.cvar("password", "", CVAR_USERINFO);
-		spectator_password = gi.cvar("spectator_password", "", CVAR_USERINFO);
-		needpass = gi.cvar("needpass", "0", CVAR_SERVERINFO);
-		filterban = gi.cvar("filterban", "1", 0);
-
-		g_select_empty = gi.cvar("g_select_empty", "0", CVAR_ARCHIVE);
-
-		run_pitch = gi.cvar("run_pitch", "0.002", 0);
-		run_roll = gi.cvar("run_roll", "0.005", 0);
-		bob_up = gi.cvar("bob_up", "0.005", 0);
-		bob_pitch = gi.cvar("bob_pitch", "0.002", 0);
-		bob_roll = gi.cvar("bob_roll", "0.002", 0);
+		dmflags= gi.cvar("dmflags", "0", CVAR_SERVERINFO);
+		fraglimit= gi.cvar("fraglimit", "0", CVAR_SERVERINFO);
+		timelimit= gi.cvar("timelimit", "0", CVAR_SERVERINFO);
+		password= gi.cvar("password", "", CVAR_USERINFO);
+		spectator_password= gi.cvar("spectator_password", "", CVAR_USERINFO);
+		needpass= gi.cvar("needpass", "0", CVAR_SERVERINFO);
+		filterban= gi.cvar("filterban", "1", 0);
+
+		g_select_empty= gi.cvar("g_select_empty", "0", CVAR_ARCHIVE);
+
+		run_pitch= gi.cvar("run_pitch", "0.002", 0);
+		run_roll= gi.cvar("run_roll", "0.005", 0);
+		bob_up= gi.cvar("bob_up", "0.005", 0);
+		bob_pitch= gi.cvar("bob_pitch", "0.002", 0);
+		bob_roll= gi.cvar("bob_roll", "0.002", 0);
 
 		// flood control
-		flood_msgs = gi.cvar("flood_msgs", "4", 0);
-		flood_persecond = gi.cvar("flood_persecond", "4", 0);
-		flood_waitdelay = gi.cvar("flood_waitdelay", "10", 0);
+		flood_msgs= gi.cvar("flood_msgs", "4", 0);
+		flood_persecond= gi.cvar("flood_persecond", "4", 0);
+		flood_waitdelay= gi.cvar("flood_waitdelay", "10", 0);
 
 		// dm map list
-		sv_maplist = gi.cvar("sv_maplist", "", 0);
+		sv_maplist= gi.cvar("sv_maplist", "", 0);
 
 		// items
 		InitItems();
 
-		game.helpmessage1 = "";
-		game.helpmessage2 = "";
+		game.helpmessage1= "";
+		game.helpmessage2= "";
 
 		// initialize all entities for this game
-		game.maxentities = (int) maxentities.value;
+		game.maxentities= (int) maxentities.value;
 		CreateEdicts();
 
-		globals.edicts = g_edicts;
-		globals.max_edicts = game.maxentities;
+		globals.edicts= g_edicts;
+		globals.max_edicts= game.maxentities;
 
 		// initialize all clients for this game
-		game.maxclients = (int) maxclients.value;
+		game.maxclients= (int) maxclients.value;
 
 		CreateClients();
-		
-		globals.num_edicts = game.maxclients + 1;
+
+		globals.num_edicts= game.maxclients + 1;
 	}
 
 	/*
@@ -164,53 +164,49 @@ public class GameSave extends GameFunc {
 	last save position.
 	============
 	*/
-	public static void WriteGame (String filename, boolean autosave)
-	{
-		try
-		{
-			QuakeFile	f;
-			
+	public static void WriteGame(String filename, boolean autosave) {
+		try {
+			QuakeFile f;
+
 			if (!autosave)
 				SaveClientData();
-			
-			f = new QuakeFile(filename, "rw");
-			
+
+			f= new QuakeFile(filename, "rw");
+
 			if (f == null)
-				gi.error ("Couldn't write to " + filename);
-			
-			game.autosaved = autosave;
+				gi.error("Couldn't write to " + filename);
+
+			game.autosaved= autosave;
 			game.write(f);
-			game.autosaved = false;
-			
-			for (int i=0 ; i<game.maxclients ; i++)
-				game.clients[i]. write(f);
-				
-			fclose (f);
+			game.autosaved= false;
+
+			for (int i= 0; i < game.maxclients; i++)
+				game.clients[i].write(f);
+
+			fclose(f);
 		}
-		catch (Exception e)
-		{
+		catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
-	
 
 	public static void ReadGame(String filename) {
 
-		QuakeFile f = null;
+		QuakeFile f= null;
 
 		try {
 
-			f = new QuakeFile(filename, "r");
+			f= new QuakeFile(filename, "r");
 			Com.Printf("loading game:" + filename);
 			CreateEdicts();
 
 			game.load(f);
 
-			for (int i = 0; i < game.maxclients; i++) {
-				game.clients[i] = new gclient_t(i);
+			for (int i= 0; i < game.maxclients; i++) {
+				game.clients[i]= new gclient_t(i);
 				game.clients[i].read(f);
 			}
-			
+
 			f.close();
 		}
 
@@ -218,51 +214,46 @@ public class GameSave extends GameFunc {
 			e.printStackTrace();
 		}
 	}
-	
+
 	/*
 	=================
 	WriteLevel
 	
 	=================
 	*/
-	static void WriteLevel (String filename)
-	{
-		try
-		{
+	static void WriteLevel(String filename) {
+		try {
 			int i;
 			edict_t ent;
 			QuakeFile f;
-			
+
 			f= new QuakeFile(filename, "rw");
-			if (f==null)
+			if (f == null)
 				gi.error("Couldn't open for writing: " + filename);
-			
+
 			// write out level_locals_t
 			level.write(f);
-			
+
 			// write out all the entities
-			for (i= 0; i < globals.num_edicts; i++)
-			{
+			for (i= 0; i < globals.num_edicts; i++) {
 				ent= g_edicts[i];
 				if (!ent.inuse)
-					continue;				
-				f.writeInt(i);			
+					continue;
+				f.writeInt(i);
 				ent.write(f);
-				
+
 			}
-			
+
 			i= -1;
 			f.writeInt(-1);
-			
+
 			f.close();
 		}
-		catch (Exception e)
-		{
+		catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
-	
-	
+
 	/*
 	=================
 	ReadLevel
@@ -279,62 +270,63 @@ public class GameSave extends GameFunc {
 	No clients are connected yet.
 	=================
 	*/
-	static void ReadLevel (String filename) throws IOException
-	{
-		edict_t		ent;
-		
-		QuakeFile f = new QuakeFile(filename, "r");
-		
-		if (f==null)
-			gi.error ("Couldn't read level file " + filename);
-	
-		// wipe all the entities
-		Game.CreateEdicts();
-		
-		globals.num_edicts = (int) maxclients.value + 1;
+	static void ReadLevel(String filename) {
+		try {
+			edict_t ent;
 
-		// load the level locals
-		level.read(f);
-	
-		// load all the entities
-		while (true)
-		{
-			int entnum = f.readInt();
-			if (entnum == -1)
-				break;
-				
-			if (entnum >= globals.num_edicts)
-				globals.num_edicts = entnum + 1;
-	
-			ent = g_edicts[entnum];
-			System.out.println("readint ent" + entnum);
-			ent.read(f);
-			ent.cleararealinks();
-			gi.linkentity(ent);
-		}
-	
-		fclose (f);
-	
-		// mark all clients as unconnected
-		for (int i=0 ; i<maxclients.value ; i++)
-		{
-			ent = g_edicts[i+1];
-			ent.client = game.clients[i];
-			ent.client.pers.connected = false;
+			QuakeFile f= new QuakeFile(filename, "r");
+
+			if (f == null)
+				gi.error("Couldn't read level file " + filename);
+
+			// wipe all the entities
+			Game.CreateEdicts();
+
+			globals.num_edicts= (int) maxclients.value + 1;
+
+			// load the level locals
+			level.read(f);
+
+			// load all the entities
+			while (true) {
+				int entnum= f.readInt();
+				if (entnum == -1)
+					break;
+
+				if (entnum >= globals.num_edicts)
+					globals.num_edicts= entnum + 1;
+
+				ent= g_edicts[entnum];
+				System.out.println("readint ent" + entnum);
+				ent.read(f);
+				ent.cleararealinks();
+				gi.linkentity(ent);
+			}
+
+			fclose(f);
+
+			// mark all clients as unconnected
+			for (int i= 0; i < maxclients.value; i++) {
+				ent= g_edicts[i + 1];
+				ent.client= game.clients[i];
+				ent.client.pers.connected= false;
+			}
+
+			// do any load time things at this point
+			for (int i= 0; i < globals.num_edicts; i++) {
+				ent= g_edicts[i];
+
+				if (!ent.inuse)
+					continue;
+
+				// fire any cross-level triggers
+				if (ent.classname != null)
+					if (strcmp(ent.classname, "target_crosslevel_target") == 0)
+						ent.nextthink= level.time + ent.delay;
+			}
 		}
-	
-		// do any load time things at this point
-		for (int i=0 ; i<globals.num_edicts ; i++)
-		{
-			ent = g_edicts[i];
-	
-			if (!ent.inuse)
-				continue;
-	
-			// fire any cross-level triggers
-			if (ent.classname != null)
-				if (strcmp(ent.classname, "target_crosslevel_target") == 0)
-					ent.nextthink = level.time + ent.delay;
+		catch (Exception e) {
+			e.printStackTrace();
 		}
 	}
 }
diff --git a/src/jake2/game/edict_t.java b/src/jake2/game/edict_t.java
index a132072..ef2e4a6 100644
--- a/src/jake2/game/edict_t.java
+++ b/src/jake2/game/edict_t.java
@@ -19,7 +19,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 
 // Created on 04.11.2003 by RST.
-// $Id: edict_t.java,v 1.3 2004-08-20 21:29:57 salomo Exp $
+// $Id: edict_t.java,v 1.4 2004-08-22 14:25:12 salomo Exp $
 
 package jake2.game;
 
@@ -29,19 +29,16 @@ import java.io.RandomAccessFile;
 import jake2.*;
 import jake2.util.*;
 
-public class edict_t
-{
+public class edict_t {
 
 	/** Constructor. */
-	public edict_t(int i)
-	{
+	public edict_t(int i) {
 		s.number= i;
 		index= i;
 	}
 
 	/** Used during level loading. */
-	public void cleararealinks()
-	{
+	public void cleararealinks() {
 		area= new link_t(this);
 	}
 
@@ -219,201 +216,167 @@ public class edict_t
 
 	/////////////////////////////////////////////////
 
-	public boolean set(String key, String value)
-	{
+	public boolean set(String key, String value) {
 
-		if (key.equals("classname"))
-		{
+		if (key.equals("classname")) {
 			classname= GameSpawn.ED_NewString(value);
 			return true;
 		} // F_LSTRING),
 
-		if (key.equals("model"))
-		{
+		if (key.equals("model")) {
 			model= GameSpawn.ED_NewString(value);
 			return true;
 		} // F_LSTRING),
 
-		if (key.equals("spawnflags"))
-		{
+		if (key.equals("spawnflags")) {
 			spawnflags= Lib.atoi(value);
 			return true;
 		} // F_INT),
 
-		if (key.equals("speed"))
-		{
+		if (key.equals("speed")) {
 			speed= Lib.atof(value);
 			return true;
 		} // F_FLOAT),
 
-		if (key.equals("accel"))
-		{
+		if (key.equals("accel")) {
 			accel= Lib.atof(value);
 			return true;
 		} // F_FLOAT),
 
-		if (key.equals("decel"))
-		{
+		if (key.equals("decel")) {
 			decel= Lib.atof(value);
 			return true;
 		} // F_FLOAT),
 
-		if (key.equals("target"))
-		{
+		if (key.equals("target")) {
 			target= GameSpawn.ED_NewString(value);
 			return true;
 		} // F_LSTRING),
 
-		if (key.equals("targetname"))
-		{
+		if (key.equals("targetname")) {
 			targetname= GameSpawn.ED_NewString(value);
 			return true;
 		} // F_LSTRING),
 
-		if (key.equals("pathtarget"))
-		{
+		if (key.equals("pathtarget")) {
 			pathtarget= GameSpawn.ED_NewString(value);
 			return true;
 		} // F_LSTRING),
 
-		if (key.equals("deathtarget"))
-		{
+		if (key.equals("deathtarget")) {
 			deathtarget= GameSpawn.ED_NewString(value);
 			return true;
 		} // F_LSTRING),
-		if (key.equals("killtarget"))
-		{
+		if (key.equals("killtarget")) {
 			killtarget= GameSpawn.ED_NewString(value);
 			return true;
 		} // F_LSTRING),
 
-		if (key.equals("combattarget"))
-		{
+		if (key.equals("combattarget")) {
 			combattarget= GameSpawn.ED_NewString(value);
 			return true;
 		} // F_LSTRING),
 
-		if (key.equals("message"))
-		{
+		if (key.equals("message")) {
 			message= GameSpawn.ED_NewString(value);
 			return true;
 		} // F_LSTRING),
 
-		if (key.equals("team"))
-		{
+		if (key.equals("team")) {
 			team= GameSpawn.ED_NewString(value);
 			return true;
 		} // F_LSTRING),
 
-		if (key.equals("wait"))
-		{
+		if (key.equals("wait")) {
 			wait= Lib.atof(value);
 			return true;
 		} // F_FLOAT),
 
-		if (key.equals("delay"))
-		{
+		if (key.equals("delay")) {
 			delay= Lib.atof(value);
 			return true;
 		} // F_FLOAT),
 
-		if (key.equals("random"))
-		{
+		if (key.equals("random")) {
 			random= Lib.atof(value);
 			return true;
 		} // F_FLOAT),
 
-		if (key.equals("move_origin"))
-		{
+		if (key.equals("move_origin")) {
 			move_origin= Lib.atov(value);
 			return true;
 		} // F_VECTOR),
 
-		if (key.equals("move_angles"))
-		{
+		if (key.equals("move_angles")) {
 			move_angles= Lib.atov(value);
 			return true;
 		} // F_VECTOR),
 
-		if (key.equals("style"))
-		{
+		if (key.equals("style")) {
 			style= Lib.atoi(value);
 			return true;
 		} // F_INT),
 
-		if (key.equals("count"))
-		{
+		if (key.equals("count")) {
 			count= Lib.atoi(value);
 			return true;
 		} // F_INT),
 
-		if (key.equals("health"))
-		{
+		if (key.equals("health")) {
 			health= Lib.atoi(value);
 			return true;
 		} // F_INT),
 
-		if (key.equals("sounds"))
-		{
+		if (key.equals("sounds")) {
 			sounds= Lib.atoi(value);
 			return true;
 		} // F_INT),
 
-		if (key.equals("light"))
-		{
+		if (key.equals("light")) {
 			return true;
 		} // F_IGNORE),
 
-		if (key.equals("dmg"))
-		{
+		if (key.equals("dmg")) {
 			dmg= Lib.atoi(value);
 			return true;
 		} // F_INT),
 
-		if (key.equals("mass"))
-		{
+		if (key.equals("mass")) {
 			mass= Lib.atoi(value);
 			return true;
 		} // F_INT),
 
-		if (key.equals("volume"))
-		{
+		if (key.equals("volume")) {
 			volume= Lib.atof(value);
 			return true;
 		} // F_FLOAT),
 
-		if (key.equals("attenuation"))
-		{
+		if (key.equals("attenuation")) {
 			attenuation= Lib.atof(value);
 			return true;
 		} // F_FLOAT),
 
-		if (key.equals("map"))
-		{
+		if (key.equals("map")) {
 			map= GameSpawn.ED_NewString(value);
 			return true;
 		} // F_LSTRING),
 
-		if (key.equals("origin"))
-		{
+		if (key.equals("origin")) {
 			s.origin= Lib.atov(value);
 			return true;
 		} // F_VECTOR),
 
-		if (key.equals("angles"))
-		{
+		if (key.equals("angles")) {
 			s.angles= Lib.atov(value);
 			return true;
 		} // F_VECTOR),
 
-		if (key.equals("angle"))
-		{
+		if (key.equals("angle")) {
 			s.angles= new float[] { 0, Lib.atof(value), 0 };
 			return true;
 		} // F_ANGLEHACK),
 
-		if (key.equals("item"))
-		{
+		if (key.equals("item")) {
 			Game.gi.error("ent.set(\"item\") called.");
 			return true;
 		} // F_ITEM)
@@ -422,8 +385,7 @@ public class edict_t
 	}
 
 	/** Writes the entity to the file. */
-	public void write(QuakeFile f) throws IOException
-	{
+	public void write(QuakeFile f) throws IOException {
 
 		s.write(f);
 		f.writeBoolean(inuse);
@@ -434,8 +396,7 @@ public class edict_t
 
 		if (clusternums == null)
 			f.writeInt(-1);
-		else
-		{
+		else {
 			f.writeInt(Defines.MAX_ENT_CLUSTERS);
 			for (int n= 0; n < Defines.MAX_ENT_CLUSTERS; n++)
 				f.writeInt(clusternums[n]);
@@ -467,6 +428,7 @@ public class edict_t
 
 		f.writeString(target);
 		f.writeString(targetname);
+		f.writeString(killtarget);
 		f.writeString(team);
 		f.writeString(pathtarget);
 		f.writeString(deathtarget);
@@ -582,8 +544,7 @@ public class edict_t
 	}
 
 	/** Reads the entity from the file.*/
-	public void read(QuakeFile f) throws IOException
-	{
+	public void read(QuakeFile f) throws IOException {
 		s.read(f);
 		inuse= f.readBoolean();
 		linkcount= f.readInt();
@@ -596,8 +557,7 @@ public class edict_t
 
 		if (len == -1)
 			clusternums= null;
-		else
-		{
+		else {
 			clusternums= new int[Defines.MAX_ENT_CLUSTERS];
 			for (int n= 0; n < Defines.MAX_ENT_CLUSTERS; n++)
 				clusternums[n]= f.readInt();
@@ -629,6 +589,7 @@ public class edict_t
 
 		target= f.readString();
 		targetname= f.readString();
+		killtarget= f.readString();
 		team= f.readString();
 		pathtarget= f.readString();
 		deathtarget= f.readString();
diff --git a/src/jake2/game/game_export_t.java b/src/jake2/game/game_export_t.java
index 38df9db..cfc0610 100644
--- a/src/jake2/game/game_export_t.java
+++ b/src/jake2/game/game_export_t.java
@@ -19,7 +19,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 
 // Created on 31.10.2003 by RST.
-// $Id: game_export_t.java,v 1.4 2004-08-20 21:29:58 salomo Exp $
+// $Id: game_export_t.java,v 1.5 2004-08-22 14:25:11 salomo Exp $
 
 package jake2.game;
 
@@ -34,26 +34,22 @@ import jake2.util.QuakeFile;
 //functions exported by the game subsystem
 //
 
-public class game_export_t
-{
+public class game_export_t {
 
 	public int apiversion;
 
 	// the init function will only be called when a game starts,
 	// not each time a level is loaded.  Persistant data for clients
 	// and the server can be allocated in init
-	public void Init()
-	{
+	public void Init() {
 		Game.InitGame();
 	}
-	public void Shutdown()
-	{
+	public void Shutdown() {
 		Game.ShutdownGame();
 	}
 
 	// each new level entered will cause a call to SpawnEntities
-	public void SpawnEntities(String mapname, String entstring, String spawnpoint)
-	{
+	public void SpawnEntities(String mapname, String entstring, String spawnpoint) {
 		Game.SpawnEntities(mapname, entstring, spawnpoint);
 	}
 
@@ -61,73 +57,48 @@ public class game_export_t
 	// about the world state and the clients.
 	// WriteGame is called every time a level is exited.
 	// ReadGame is called on a loadgame.
-	public void WriteGame(String filename, boolean autosave)
-	{
+	public void WriteGame(String filename, boolean autosave) {
 		GameSave.WriteGame(filename, autosave);
 	}
 
-	public void ReadGame(String filename)
-	{
+	public void ReadGame(String filename) {
 		Game.ReadGame(filename);
 	}
 
 	// ReadLevel is called after the default map information has been
 	// loaded with SpawnEntities
-	public void WriteLevel(String filename)
-	{
-		try
-		{
-			GameSave.WriteLevel(filename);
-		}
-		catch (IOException e)
-		{
-			e.printStackTrace();
-		}		
+	public void WriteLevel(String filename) {
+		GameSave.WriteLevel(filename);
 	}
 
-	public void ReadLevel(String filename)
-	{
-		try
-		{
-			GameSave.ReadLevel(filename);
-		}
-		catch (IOException e)
-		{
-			e.printStackTrace();
-		}
+	public void ReadLevel(String filename) {
+		GameSave.ReadLevel(filename);
 	}
 
-	public boolean ClientConnect(edict_t ent, String userinfo)
-	{
+	public boolean ClientConnect(edict_t ent, String userinfo) {
 		return PlayerClient.ClientConnect(ent, userinfo);
 	}
-	
-	public void ClientBegin(edict_t ent)
-	{
+
+	public void ClientBegin(edict_t ent) {
 		PlayerClient.ClientBegin(ent);
 	}
-	
-	public void ClientUserinfoChanged(edict_t ent, String userinfo)
-	{
+
+	public void ClientUserinfoChanged(edict_t ent, String userinfo) {
 		PlayerClient.ClientUserinfoChanged(ent, userinfo);
 	}
-	
-	public void ClientDisconnect(edict_t ent)
-	{
+
+	public void ClientDisconnect(edict_t ent) {
 		PlayerClient.ClientDisconnect(ent);
 	}
-	public void ClientCommand(edict_t ent)
-	{
+	public void ClientCommand(edict_t ent) {
 		PlayerClient.ClientCommand(ent);
 	}
 
-	public void ClientThink(edict_t ent, usercmd_t cmd)
-	{
+	public void ClientThink(edict_t ent, usercmd_t cmd) {
 		PlayerClient.ClientThink(ent, cmd);
 	}
 
-	public void RunFrame()
-	{
+	public void RunFrame() {
 		Game.G_RunFrame();
 	}
 
@@ -135,8 +106,7 @@ public class game_export_t
 	// server console.
 	// the game can issue gi.argc() / gi.argv() commands to get the rest
 	// of the parameters
-	public void ServerCommand()
-	{
+	public void ServerCommand() {
 		Game.ServerCommand();
 	}
 
@@ -148,7 +118,7 @@ public class game_export_t
 	// can vary in size from one game to another.
 
 	// the size will be fixed when ge.Init() is called
-	public edict_t edicts[] = Game.g_edicts;
+	public edict_t edicts[]= Game.g_edicts;
 	public int num_edicts; // current number, <= max_edicts
 	public int max_edicts;
-}
\ No newline at end of file
+}
diff --git a/src/jake2/game/game_import_t.java b/src/jake2/game/game_import_t.java
index 8c7bd5f..940867f 100644
--- a/src/jake2/game/game_import_t.java
+++ b/src/jake2/game/game_import_t.java
@@ -19,7 +19,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 
 // Created on 31.10.2003 by RST.
-// $Id: game_import_t.java,v 1.2 2004-07-08 15:58:44 hzi Exp $
+// $Id: game_import_t.java,v 1.3 2004-08-22 14:25:11 salomo Exp $
 
 package jake2.game;
 
@@ -40,8 +40,6 @@ import jake2.server.SV_WORLD;
 //
 public class game_import_t
 {
-	// R S T:    SEE   SV_InitGameProgs() ! 
-
 	// special messages
 	public void bprintf(int printlevel, String s)
 	{