import of Jake2 version sunrisesunrise

17 files changed, 7090 insertions, 0 deletions

diff --git a/src/jake2/server/SV.java b/src/jake2/server/SV.java
new file mode 100644
index 0000000..d00b104
--- /dev/null
+++ b/src/jake2/server/SV.java
@@ -0,0 +1,1110 @@
+/*
+ * SV.java
+ * Copyright (C) 2003
+ * 
+ * $Id: SV.java,v 1.1 2004-07-07 19:59:46 hzi Exp $
+ */
+ /*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+package jake2.server;
+
+import jake2.*;
+import jake2.game.*;
+import jake2.qcommon.Com;
+import jake2.util.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.game.trace_t;
+
+/**
+ * SV
+ */
+public final class SV {	
+
+	//file_io
+	//=====================================================================
+	//g_phys
+	
+	///////////////////////////////////////
+	public static edict_t[] SV_TestEntityPosition(edict_t ent) {
+		trace_t trace;
+		int mask;
+	
+		if (ent.clipmask != 0)
+			mask = ent.clipmask;
+		else
+			mask = Defines.MASK_SOLID;
+	
+		trace = GameBase.gi.trace(ent.s.origin, ent.mins, ent.maxs, ent.s.origin, ent, mask);
+	
+		if (trace.startsolid)
+			return GameBase.g_edicts;
+	
+		return null;
+	}
+
+	///////////////////////////////////////
+	public static void SV_CheckVelocity(edict_t ent) {
+		int i;
+	
+		//
+		//	   bound velocity
+		//
+		for (i = 0; i < 3; i++) {
+			if (ent.velocity[i] > GameBase.sv_maxvelocity.value)
+				ent.velocity[i] = GameBase.sv_maxvelocity.value;
+			else if (ent.velocity[i] < -GameBase.sv_maxvelocity.value)
+				ent.velocity[i] = -GameBase.sv_maxvelocity.value;
+		}
+	}
+
+	/**
+	 * Runs thinking code for this frame if necessary.
+	 */
+	public static boolean SV_RunThink(edict_t ent) {
+		float thinktime;
+	
+		thinktime = ent.nextthink;
+		if (thinktime <= 0)
+			return true;
+		if (thinktime > GameBase.level.time + 0.001)
+			return true;
+	
+		ent.nextthink = 0;
+	
+		if (ent.think == null)
+			GameBase.gi.error("NULL ent.think");
+	
+		ent.think.think(ent);
+	
+		return false;
+	}
+
+	/** 
+	 * Two entities have touched, so run their touch functions.
+	 */
+	public static void SV_Impact(edict_t e1, trace_t trace) {
+		edict_t e2;
+		// cplane_t	backplane;
+	
+		e2 = trace.ent;
+	
+		if (e1.touch != null && e1.solid != Defines.SOLID_NOT)
+			e1.touch.touch(e1, e2, trace.plane, trace.surface);
+	
+		if (e2.touch != null && e2.solid != Defines.SOLID_NOT)
+			e2.touch.touch(e2, e1, null, null);
+	}
+
+	public static int SV_FlyMove(edict_t ent, float time, int mask) {
+		edict_t hit;
+		int bumpcount, numbumps;
+		float[] dir = { 0.0f, 0.0f, 0.0f };
+		float d;
+		int numplanes;
+		float[][] planes = new float[3][GameBase.MAX_CLIP_PLANES];
+		float[] primal_velocity = { 0.0f, 0.0f, 0.0f };
+		float[] original_velocity = { 0.0f, 0.0f, 0.0f };
+		float[] new_velocity = { 0.0f, 0.0f, 0.0f };
+		int i, j;
+		trace_t trace;
+		float[] end = { 0.0f, 0.0f, 0.0f };
+		float time_left;
+		int blocked;
+	
+		numbumps = 4;
+	
+		blocked = 0;
+		Math3D.VectorCopy(ent.velocity, original_velocity);
+		Math3D.VectorCopy(ent.velocity, primal_velocity);
+		numplanes = 0;
+	
+		time_left = time;
+	
+		ent.groundentity = null;
+		for (bumpcount = 0; bumpcount < numbumps; bumpcount++) {
+			for (i = 0; i < 3; i++)
+				end[i] = ent.s.origin[i] + time_left * ent.velocity[i];
+	
+			trace = GameBase.gi.trace(ent.s.origin, ent.mins, ent.maxs, end, ent, mask);
+	
+			if (trace.allsolid) { // entity is trapped in another solid
+				Math3D.VectorCopy(GameBase.vec3_origin, ent.velocity);
+				return 3;
+			}
+	
+			if (trace.fraction > 0) { // actually covered some distance
+				Math3D.VectorCopy(trace.endpos, ent.s.origin);
+				Math3D.VectorCopy(ent.velocity, original_velocity);
+				numplanes = 0;
+			}
+	
+			if (trace.fraction == 1)
+				break; // moved the entire distance
+	
+			hit = trace.ent;
+	
+			if (trace.plane.normal[2] > 0.7) {
+				blocked |= 1; // floor
+				if (hit.solid == Defines.SOLID_BSP) {
+					ent.groundentity = hit;
+					ent.groundentity_linkcount = hit.linkcount;
+				}
+			}
+			if (trace.plane.normal[2] == 0.0f) {
+				blocked |= 2; // step
+			}
+	
+			//
+			//	   run the impact function
+			//
+			SV_Impact(ent, trace);
+			if (!ent.inuse)
+				break; // removed by the impact function
+	
+			time_left -= time_left * trace.fraction;
+	
+			// cliped to another plane
+			if (numplanes >= GameBase.MAX_CLIP_PLANES) { // this shouldn't really happen
+				Math3D.VectorCopy(GameBase.vec3_origin, ent.velocity);
+				return 3;
+			}
+	
+			Math3D.VectorCopy(trace.plane.normal, planes[numplanes]);
+			numplanes++;
+	
+			//
+			//	   modify original_velocity so it parallels all of the clip planes
+			//
+			for (i = 0; i < numplanes; i++) {
+				GameBase.ClipVelocity(original_velocity, planes[i], new_velocity, 1);
+	
+				for (j = 0; j < numplanes; j++)
+					if ((j != i) && Math3D.VectorCompare(planes[i], planes[j]) == 0.0f) {
+						if (Math3D.DotProduct(new_velocity, planes[j]) < 0)
+							break; // not ok
+					}
+				if (j == numplanes)
+					break;
+			}
+	
+			if (i != numplanes) { // go along this plane
+				Math3D.VectorCopy(new_velocity, ent.velocity);
+			} else { // go along the crease
+				if (numplanes != 2) {
+					//					gi.dprintf ("clip velocity, numplanes == %i\n",numplanes);
+					Math3D.VectorCopy(GameBase.vec3_origin, ent.velocity);
+					return 7;
+				}
+				Math3D.CrossProduct(planes[0], planes[1], dir);
+				d = Math3D.DotProduct(dir, ent.velocity);
+				Math3D.VectorScale(dir, d, ent.velocity);
+			}
+	
+			//
+			//	   if original velocity is against the original velocity, stop dead
+			//	   to avoid tiny occilations in sloping corners
+			//
+			if (Math3D.DotProduct(ent.velocity, primal_velocity) <= 0) {
+				Math3D.VectorCopy(GameBase.vec3_origin, ent.velocity);
+				return blocked;
+			}
+		}
+	
+		return blocked;
+	}
+
+	/*
+	============
+	SV_AddGravity
+	
+	============
+	*/
+	public static void SV_AddGravity(edict_t ent) {
+		ent.velocity[2] -= ent.gravity * GameBase.sv_gravity.value * Defines.FRAMETIME;
+	}
+
+	/**
+	 * Does not change the entities velocity at all
+	*/
+	public static trace_t SV_PushEntity(edict_t ent, float[] push) {
+		trace_t trace;
+		float[] start = { 0, 0, 0 };
+		float[] end = { 0, 0, 0 };
+		int mask;
+	
+		Math3D.VectorCopy(ent.s.origin, start);
+		Math3D.VectorAdd(start, push, end);
+	
+		// FIXME: test this
+		// a goto statement was replaced.
+		boolean retry;
+	
+		do {
+			if (ent.clipmask != 0)
+				mask = ent.clipmask;
+			else
+				mask = Defines.MASK_SOLID;
+	
+			trace = GameBase.gi.trace(start, ent.mins, ent.maxs, end, ent, mask);
+	
+			Math3D.VectorCopy(trace.endpos, ent.s.origin);
+			GameBase.gi.linkentity(ent);
+	
+			retry = false;
+			if (trace.fraction != 1.0) {
+				SV_Impact(ent, trace);
+	
+				// if the pushed entity went away and the pusher is still there
+				if (!trace.ent.inuse && ent.inuse) {
+					// move the pusher back and try again
+					Math3D.VectorCopy(start, ent.s.origin);
+					GameBase.gi.linkentity(ent);
+					//goto retry;
+					retry = true;
+				}
+			}
+		} while (retry);
+	
+		if (ent.inuse)
+			GameBase.G_TouchTriggers(ent);
+	
+		return trace;
+	}
+
+	/*
+	============
+	SV_Push
+	
+	Objects need to be moved back on a failed push,
+	otherwise riders would continue to slide.
+	============
+	*/
+	public static boolean SV_Push(edict_t pusher, float[] move, float[] amove) {
+		int i, e;
+		edict_t check, block[];
+		float[] mins = { 0, 0, 0 };
+		float[] maxs = { 0, 0, 0 };
+		pushed_t p;
+		float[] org = { 0, 0, 0 };
+		float[] org2 = { 0, 0, 0 };
+		float[] move2 = { 0, 0, 0 };
+		float[] forward = { 0, 0, 0 };
+		float[] right = { 0, 0, 0 };
+		float[] up = { 0, 0, 0 };
+	
+		// clamp the move to 1/8 units, so the position will
+		// be accurate for client side prediction
+		for (i = 0; i < 3; i++) {
+			float temp;
+			temp = move[i] * 8.0f;
+			if (temp > 0.0)
+				temp += 0.5;
+			else
+				temp -= 0.5;
+			move[i] = 0.125f * (int) temp;
+		}
+	
+		// find the bounding box
+		for (i = 0; i < 3; i++) {
+			mins[i] = pusher.absmin[i] + move[i];
+			maxs[i] = pusher.absmax[i] + move[i];
+		}
+	
+		//	   we need this for pushing things later
+		Math3D.VectorSubtract(GameBase.vec3_origin, amove, org);
+		Math3D.AngleVectors(org, forward, right, up);
+	
+		//	   save the pusher's original position
+		GameBase.pushed[GameBase.pushed_p].ent = pusher;
+		Math3D.VectorCopy(pusher.s.origin, GameBase.pushed[GameBase.pushed_p].origin);
+		Math3D.VectorCopy(pusher.s.angles, GameBase.pushed[GameBase.pushed_p].angles);
+	
+		if (pusher.client != null)
+			GameBase.pushed[GameBase.pushed_p].deltayaw = pusher.client.ps.pmove.delta_angles[Defines.YAW];
+	
+		GameBase.pushed_p++;
+	
+		//	   move the pusher to it's final position
+		Math3D.VectorAdd(pusher.s.origin, move, pusher.s.origin);
+		Math3D.VectorAdd(pusher.s.angles, amove, pusher.s.angles);
+		GameBase.gi.linkentity(pusher);
+	
+		//	   see if any solid entities are inside the final position
+	
+		//check= g_edicts + 1;
+		for (e = 1; e < GameBase.globals.num_edicts; e++) {
+			check = GameBase.g_edicts[e];
+			if (!check.inuse)
+				continue;
+			if (check.movetype == Defines.MOVETYPE_PUSH
+				|| check.movetype == Defines.MOVETYPE_STOP
+				|| check.movetype == Defines.MOVETYPE_NONE
+				|| check.movetype == Defines.MOVETYPE_NOCLIP)
+				continue;
+	
+			if (check.area.prev == null)
+				continue; // not linked in anywhere
+	
+			// if the entity is standing on the pusher, it will definitely be moved
+			if (check.groundentity != pusher) {
+				// see if the ent needs to be tested
+				if (check.absmin[0] >= maxs[0]
+					|| check.absmin[1] >= maxs[1]
+					|| check.absmin[2] >= maxs[2]
+					|| check.absmax[0] <= mins[0]
+					|| check.absmax[1] <= mins[1]
+					|| check.absmax[2] <= mins[2])
+					continue;
+	
+				// see if the ent's bbox is inside the pusher's final position
+				if (SV_TestEntityPosition(check) == null)
+					continue;
+			}
+	
+			if ((pusher.movetype == Defines.MOVETYPE_PUSH) || (check.groundentity == pusher)) {
+				// move this entity
+				GameBase.pushed[GameBase.pushed_p].ent = check;
+				Math3D.VectorCopy(check.s.origin, GameBase.pushed[GameBase.pushed_p].origin);
+				Math3D.VectorCopy(check.s.angles, GameBase.pushed[GameBase.pushed_p].angles);
+				GameBase.pushed_p++;
+	
+				// try moving the contacted entity 
+				Math3D.VectorAdd(check.s.origin, move, check.s.origin);
+				if (check.client != null) { // FIXME: doesn't rotate monsters?
+					check.client.ps.pmove.delta_angles[Defines.YAW] += amove[Defines.YAW];
+				}
+	
+				// figure movement due to the pusher's amove
+				Math3D.VectorSubtract(check.s.origin, pusher.s.origin, org);
+				org2[0] = Math3D.DotProduct(org, forward);
+				org2[1] = -Math3D.DotProduct(org, right);
+				org2[2] = Math3D.DotProduct(org, up);
+				Math3D.VectorSubtract(org2, org, move2);
+				Math3D.VectorAdd(check.s.origin, move2, check.s.origin);
+	
+				// may have pushed them off an edge
+				if (check.groundentity != pusher)
+					check.groundentity = null;
+	
+				block = SV_TestEntityPosition(check);
+				if (block == null) { // pushed ok
+					GameBase.gi.linkentity(check);
+					// impact?
+					continue;
+				}
+	
+				// if it is ok to leave in the old position, do it
+				// this is only relevent for riding entities, not pushed
+				// FIXME: this doesn't acount for rotation
+				Math3D.VectorSubtract(check.s.origin, move, check.s.origin);
+				block = SV_TestEntityPosition(check);
+	
+				if (block == null) {
+					GameBase.pushed_p--;
+					continue;
+				}
+			}
+	
+			// save off the obstacle so we can call the block function
+			GameBase.obstacle = check;
+	
+			// move back any entities we already moved
+			// go backwards, so if the same entity was pushed
+			// twice, it goes back to the original position
+			for (int ip = GameBase.pushed_p - 1; ip >= 0; ip--) {
+				p = GameBase.pushed[ip];
+				Math3D.VectorCopy(p.origin, p.ent.s.origin);
+				Math3D.VectorCopy(p.angles, p.ent.s.angles);
+				if (p.ent.client != null) {
+					p.ent.client.ps.pmove.delta_angles[Defines.YAW] = (short) p.deltayaw;
+				}
+				GameBase.gi.linkentity(p.ent);
+			}
+			return false;
+		}
+	
+		//	  FIXME: is there a better way to handle this?
+		// see if anything we moved has touched a trigger
+		for (int ip = GameBase.pushed_p - 1; ip >= 0; ip--)
+			GameBase.G_TouchTriggers(GameBase.pushed[ip].ent);
+	
+		return true;
+	}
+
+	/*
+	================
+	SV_Physics_Pusher
+	
+	Bmodel objects don't interact with each other, but
+	push all box objects
+	================
+	*/
+	public static void SV_Physics_Pusher(edict_t ent) {
+		float[] move = { 0, 0, 0 };
+		float[] amove = { 0, 0, 0 };
+		edict_t part, mv;
+	
+		// if not a team captain, so movement will be handled elsewhere
+		if ((ent.flags & Defines.FL_TEAMSLAVE) != 0)
+			return;
+	
+		// make sure all team slaves can move before commiting
+		// any moves or calling any think functions
+		// if the move is blocked, all moved objects will be backed out
+		//	  retry:
+		GameBase.pushed_p = 0;
+		for (part = ent; part != null; part = part.teamchain) {
+			if (part.velocity[0] != 0
+				|| part.velocity[1] != 0
+				|| part.velocity[2] != 0
+				|| part.avelocity[0] != 0
+				|| part.avelocity[1] != 0
+				|| part.avelocity[2] != 0) { // object is moving
+				Math3D.VectorScale(part.velocity, Defines.FRAMETIME, move);
+				Math3D.VectorScale(part.avelocity, Defines.FRAMETIME, amove);
+	
+				if (!SV_Push(part, move, amove))
+					break; // move was blocked
+			}
+		}
+		if (GameBase.pushed_p > Defines.MAX_EDICTS)
+			GameBase.gi.error(Defines.ERR_FATAL, "pushed_p > &pushed[MAX_EDICTS], memory corrupted");
+	
+		if (part != null) {
+			// the move failed, bump all nextthink times and back out moves
+			for (mv = ent; mv != null; mv = mv.teamchain) {
+				if (mv.nextthink > 0)
+					mv.nextthink += Defines.FRAMETIME;
+			}
+	
+			// if the pusher has a "blocked" function, call it
+			// otherwise, just stay in place until the obstacle is gone
+			if (part.blocked != null)
+				part.blocked.blocked(part, GameBase.obstacle);
+		} else { // the move succeeded, so call all think functions
+			for (part = ent; part != null; part = part.teamchain) {
+				SV_RunThink(part);
+			}
+		}
+	}
+
+	//	  ==================================================================
+	
+	/*
+	=============
+	SV_Physics_None
+	
+	Non moving objects can only think
+	=============
+	*/
+	public static void SV_Physics_None(edict_t ent) {
+		//	   regular thinking
+		SV_RunThink(ent);
+	}
+
+	/*
+	=============
+	SV_Physics_Noclip
+	
+	A moving object that doesn't obey physics
+	=============
+	*/
+	public static void SV_Physics_Noclip(edict_t ent) {
+		//	   regular thinking
+		if (!SV_RunThink(ent))
+			return;
+	
+		Math3D.VectorMA(ent.s.angles, Defines.FRAMETIME, ent.avelocity, ent.s.angles);
+		Math3D.VectorMA(ent.s.origin, Defines.FRAMETIME, ent.velocity, ent.s.origin);
+	
+		GameBase.gi.linkentity(ent);
+	}
+
+	/*
+	==============================================================================
+	
+	TOSS / BOUNCE
+	
+	==============================================================================
+	*/
+	
+	/*
+	=============
+	SV_Physics_Toss
+	
+	Toss, bounce, and fly movement.  When onground, do nothing.
+	=============
+	*/
+	public static void SV_Physics_Toss(edict_t ent) {
+		trace_t trace;
+		float[] move = { 0, 0, 0 };
+		float backoff;
+		edict_t slave;
+		boolean wasinwater;
+		boolean isinwater;
+		float[] old_origin = { 0, 0, 0 };
+	
+		//	   regular thinking
+		SV_RunThink(ent);
+	
+		// if not a team captain, so movement will be handled elsewhere
+		if ((ent.flags & Defines.FL_TEAMSLAVE) != 0)
+			return;
+	
+		if (ent.velocity[2] > 0)
+			ent.groundentity = null;
+	
+		//	   check for the groundentity going away
+		if (ent.groundentity != null)
+			if (!ent.groundentity.inuse)
+				ent.groundentity = null;
+	
+		//	   if onground, return without moving
+		if (ent.groundentity != null)
+			return;
+	
+		Math3D.VectorCopy(ent.s.origin, old_origin);
+	
+		SV_CheckVelocity(ent);
+	
+		//	   add gravity
+		if (ent.movetype != Defines.MOVETYPE_FLY && ent.movetype != Defines.MOVETYPE_FLYMISSILE)
+			SV_AddGravity(ent);
+	
+		//	   move angles
+		Math3D.VectorMA(ent.s.angles, Defines.FRAMETIME, ent.avelocity, ent.s.angles);
+	
+		//	   move origin
+		Math3D.VectorScale(ent.velocity, Defines.FRAMETIME, move);
+		trace = SV_PushEntity(ent, move);
+		if (!ent.inuse)
+			return;
+	
+		if (trace.fraction < 1) {
+			if (ent.movetype == Defines.MOVETYPE_BOUNCE)
+				backoff = 1.5f;
+			else
+				backoff = 1;
+	
+			GameBase.ClipVelocity(ent.velocity, trace.plane.normal, ent.velocity, backoff);
+	
+			// stop if on ground
+			if (trace.plane.normal[2] > 0.7) {
+				if (ent.velocity[2] < 60 || ent.movetype != Defines.MOVETYPE_BOUNCE) {
+					ent.groundentity = trace.ent;
+					ent.groundentity_linkcount = trace.ent.linkcount;
+					Math3D.VectorCopy(GameBase.vec3_origin, ent.velocity);
+					Math3D.VectorCopy(GameBase.vec3_origin, ent.avelocity);
+				}
+			}
+	
+			//			if (ent.touch)
+			//				ent.touch (ent, trace.ent, &trace.plane, trace.surface);
+		}
+	
+		//	   check for water transition
+		wasinwater = (ent.watertype & Defines.MASK_WATER) != 0;
+		ent.watertype = GameBase.gi.pointcontents.pointcontents(ent.s.origin);
+		isinwater = (ent.watertype & Defines.MASK_WATER) != 0;
+	
+		if (isinwater)
+			ent.waterlevel = 1;
+		else
+			ent.waterlevel = 0;
+	
+		if (!wasinwater && isinwater)
+			GameBase.gi.positioned_sound(old_origin, ent, Defines.CHAN_AUTO, GameBase.gi.soundindex("misc/h2ohit1.wav"), 1, 1, 0);
+		else if (wasinwater && !isinwater)
+			GameBase.gi.positioned_sound(ent.s.origin, ent, Defines.CHAN_AUTO, GameBase.gi.soundindex("misc/h2ohit1.wav"), 1, 1, 0);
+	
+		//	   move teamslaves
+		for (slave = ent.teamchain; slave != null; slave = slave.teamchain) {
+			Math3D.VectorCopy(ent.s.origin, slave.s.origin);
+			GameBase.gi.linkentity(slave);
+		}
+	}
+
+	/*
+	===============================================================================
+	
+	STEPPING MOVEMENT
+	
+	===============================================================================
+	*/
+	
+	/*
+	=============
+	SV_Physics_Step
+	
+	Monsters freefall when they don't have a ground entity, otherwise
+	all movement is done with discrete steps.
+	
+	This is also used for objects that have become still on the ground, but
+	will fall if the floor is pulled out from under them.
+	FIXME: is this true?
+	=============
+	*/
+	
+	//	  FIXME: hacked in for E3 demo
+	
+	public static void SV_AddRotationalFriction(edict_t ent) {
+		int n;
+		float adjustment;
+	
+		Math3D.VectorMA(ent.s.angles, Defines.FRAMETIME, ent.avelocity, ent.s.angles);
+		adjustment = Defines.FRAMETIME * Defines.sv_stopspeed * Defines.sv_friction;
+		for (n = 0; n < 3; n++) {
+			if (ent.avelocity[n] > 0) {
+				ent.avelocity[n] -= adjustment;
+				if (ent.avelocity[n] < 0)
+					ent.avelocity[n] = 0;
+			} else {
+				ent.avelocity[n] += adjustment;
+				if (ent.avelocity[n] > 0)
+					ent.avelocity[n] = 0;
+			}
+		}
+	}
+
+	public static void SV_Physics_Step(edict_t ent) {
+		boolean wasonground;
+		boolean hitsound = false;
+		float vel[];
+		float speed, newspeed, control;
+		float friction;
+		edict_t groundentity;
+		int mask;
+	
+		// airborn monsters should always check for ground
+		if (ent.groundentity == null)
+			M.M_CheckGround(ent);
+	
+		groundentity = ent.groundentity;
+	
+		SV_CheckVelocity(ent);
+	
+		if (groundentity != null)
+			wasonground = true;
+		else
+			wasonground = false;
+	
+		if (ent.avelocity[0] != 0 || ent.avelocity[1] != 0 || ent.avelocity[2] != 0)
+			SV_AddRotationalFriction(ent);
+	
+		// add gravity except:
+		//   flying monsters
+		//   swimming monsters who are in the water
+		if (!wasonground)
+			if (0 == (ent.flags & Defines.FL_FLY))
+				if (!((ent.flags & Defines.FL_SWIM) != 0 && (ent.waterlevel > 2))) {
+					if (ent.velocity[2] < GameBase.sv_gravity.value * -0.1)
+						hitsound = true;
+					if (ent.waterlevel == 0)
+						SV_AddGravity(ent);
+				}
+	
+		// friction for flying monsters that have been given vertical velocity
+		if ((ent.flags & Defines.FL_FLY) != 0 && (ent.velocity[2] != 0)) {
+			speed = Math.abs(ent.velocity[2]);
+			control = speed < Defines.sv_stopspeed ? Defines.sv_stopspeed : speed;
+			friction = Defines.sv_friction / 3;
+			newspeed = speed - (Defines.FRAMETIME * control * friction);
+			if (newspeed < 0)
+				newspeed = 0;
+			newspeed /= speed;
+			ent.velocity[2] *= newspeed;
+		}
+	
+		// friction for flying monsters that have been given vertical velocity
+		if ((ent.flags & Defines.FL_SWIM) != 0 && (ent.velocity[2] != 0)) {
+			speed = Math.abs(ent.velocity[2]);
+			control = speed < Defines.sv_stopspeed ? Defines.sv_stopspeed : speed;
+			newspeed = speed - (Defines.FRAMETIME * control * Defines.sv_waterfriction * ent.waterlevel);
+			if (newspeed < 0)
+				newspeed = 0;
+			newspeed /= speed;
+			ent.velocity[2] *= newspeed;
+		}
+	
+		if (ent.velocity[2] != 0 || ent.velocity[1] != 0 || ent.velocity[0] != 0) {
+			// apply friction
+			// let dead monsters who aren't completely onground slide
+			if ((wasonground) || 0 != (ent.flags & (Defines.FL_SWIM | Defines.FL_FLY)))
+				if (!(ent.health <= 0.0 && !M.M_CheckBottom(ent))) {
+					vel = ent.velocity;
+					speed = (float) Math.sqrt(vel[0] * vel[0] + vel[1] * vel[1]);
+					if (speed != 0) {
+						friction = Defines.sv_friction;
+	
+						control = speed < Defines.sv_stopspeed ? Defines.sv_stopspeed : speed;
+						newspeed = speed - Defines.FRAMETIME * control * friction;
+	
+						if (newspeed < 0)
+							newspeed = 0;
+						newspeed /= speed;
+	
+						vel[0] *= newspeed;
+						vel[1] *= newspeed;
+					}
+				}
+	
+			if ((ent.svflags & Defines.SVF_MONSTER) != 0)
+				mask = Defines.MASK_MONSTERSOLID;
+			else
+				mask = Defines.MASK_SOLID;
+	
+			SV_FlyMove(ent, Defines.FRAMETIME, mask);
+	
+			GameBase.gi.linkentity(ent);
+			GameBase.G_TouchTriggers(ent);
+			if (!ent.inuse)
+				return;
+	
+			if (ent.groundentity != null)
+				if (!wasonground)
+					if (hitsound)
+						GameBase.gi.sound(ent, 0, GameBase.gi.soundindex("world/land.wav"), 1, 1, 0);
+		}
+	
+		//	   regular thinking
+		SV_RunThink(ent);
+	}
+
+	/*
+	=============
+	SV_movestep
+	
+	Called by monster program code.
+	The move will be adjusted for slopes and stairs, but if the move isn't
+	possible, no move is done, false is returned, and
+	pr_global_struct.trace_normal is set to the normal of the blocking wall
+	=============
+	*/
+	//	  FIXME since we need to test end position contents here, can we avoid doing
+	//	  it again later in catagorize position?
+	public static boolean SV_movestep(edict_t ent, float[] move, boolean relink) {
+		float dz;
+		float[] oldorg = { 0, 0, 0 };
+		float[] neworg = { 0, 0, 0 };
+		float[] end = { 0, 0, 0 };
+	
+		trace_t trace = null;// = new trace_t();
+		int i;
+		float stepsize;
+		float[] test = { 0, 0, 0 };
+		int contents;
+	
+		//	   try the move	
+		Math3D.VectorCopy(ent.s.origin, oldorg);
+		Math3D.VectorAdd(ent.s.origin, move, neworg);
+	
+		//	   flying monsters don't step up
+		if ((ent.flags & (Defines.FL_SWIM | Defines.FL_FLY)) != 0) {
+			// try one move with vertical motion, then one without
+			for (i = 0; i < 2; i++) {
+				Math3D.VectorAdd(ent.s.origin, move, neworg);
+				if (i == 0 && ent.enemy != null) {
+					if (ent.goalentity == null)
+						ent.goalentity = ent.enemy;
+					dz = ent.s.origin[2] - ent.goalentity.s.origin[2];
+					if (ent.goalentity.client != null) {
+						if (dz > 40)
+							neworg[2] -= 8;
+						if (!((ent.flags & Defines.FL_SWIM) != 0 && (ent.waterlevel < 2)))
+							if (dz < 30)
+								neworg[2] += 8;
+					} else {
+						if (dz > 8)
+							neworg[2] -= 8;
+						else if (dz > 0)
+							neworg[2] -= dz;
+						else if (dz < -8)
+							neworg[2] += 8;
+						else
+							neworg[2] += dz;
+					}
+				}
+				trace = GameBase.gi.trace(ent.s.origin, ent.mins, ent.maxs, neworg, ent, Defines.MASK_MONSTERSOLID);
+	
+				// fly monsters don't enter water voluntarily
+				if ((ent.flags & Defines.FL_FLY) != 0) {
+					if (ent.waterlevel == 0) {
+						test[0] = trace.endpos[0];
+						test[1] = trace.endpos[1];
+						test[2] = trace.endpos[2] + ent.mins[2] + 1;
+						contents = GameBase.gi.pointcontents.pointcontents(test);
+						if ((contents & Defines.MASK_WATER) != 0)
+							return false;
+					}
+				}
+	
+				// swim monsters don't exit water voluntarily
+				if ((ent.flags & Defines.FL_SWIM) != 0) {
+					if (ent.waterlevel < 2) {
+						test[0] = trace.endpos[0];
+						test[1] = trace.endpos[1];
+						test[2] = trace.endpos[2] + ent.mins[2] + 1;
+						contents = GameBase.gi.pointcontents.pointcontents(test);
+						if ((contents & Defines.MASK_WATER) == 0)
+							return false;
+					}
+				}
+	
+				if (trace.fraction == 1) {
+					Math3D.VectorCopy(trace.endpos, ent.s.origin);
+					if (relink) {
+						GameBase.gi.linkentity(ent);
+						GameBase.G_TouchTriggers(ent);
+					}
+					return true;
+				}
+	
+				if (ent.enemy == null)
+					break;
+			}
+	
+			return false;
+		}
+	
+		//	   push down from a step height above the wished position
+		if ((ent.monsterinfo.aiflags & Defines.AI_NOSTEP) == 0)
+			stepsize = GameBase.STEPSIZE;
+		else
+			stepsize = 1;
+	
+		neworg[2] += stepsize;
+		Math3D.VectorCopy(neworg, end);
+		end[2] -= stepsize * 2;
+	
+		trace = GameBase.gi.trace(neworg, ent.mins, ent.maxs, end, ent, Defines.MASK_MONSTERSOLID);
+	
+		if (trace.allsolid)
+			return false;
+	
+		if (trace.startsolid) {
+			neworg[2] -= stepsize;
+			trace = GameBase.gi.trace(neworg, ent.mins, ent.maxs, end, ent, Defines.MASK_MONSTERSOLID);
+			if (trace.allsolid || trace.startsolid)
+				return false;
+		}
+	
+		// don't go in to water
+		if (ent.waterlevel == 0) {
+			test[0] = trace.endpos[0];
+			test[1] = trace.endpos[1];
+			test[2] = trace.endpos[2] + ent.mins[2] + 1;
+			contents = GameBase.gi.pointcontents.pointcontents(test);
+	
+			if ((contents & Defines.MASK_WATER) != 0)
+				return false;
+		}
+	
+		if (trace.fraction == 1) {
+			// if monster had the ground pulled out, go ahead and fall
+			if ((ent.flags & Defines.FL_PARTIALGROUND) != 0) {
+				Math3D.VectorAdd(ent.s.origin, move, ent.s.origin);
+				if (relink) {
+					GameBase.gi.linkentity(ent);
+					GameBase.G_TouchTriggers(ent);
+				}
+				ent.groundentity = null;
+				return true;
+			}
+	
+			return false; // walked off an edge
+		}
+	
+		//	   check point traces down for dangling corners
+		Math3D.VectorCopy(trace.endpos, ent.s.origin);
+	
+		if (!M.M_CheckBottom(ent)) {
+			if ((ent.flags & Defines.FL_PARTIALGROUND) != 0) {
+				// entity had floor mostly pulled out from underneath it
+				// and is trying to correct
+				if (relink) {
+					GameBase.gi.linkentity(ent);
+					GameBase.G_TouchTriggers(ent);
+				}
+				return true;
+			}
+			Math3D.VectorCopy(oldorg, ent.s.origin);
+			return false;
+		}
+	
+		if ((ent.flags & Defines.FL_PARTIALGROUND) != 0) {
+			ent.flags &= ~Defines.FL_PARTIALGROUND;
+		}
+		ent.groundentity = trace.ent;
+		ent.groundentity_linkcount = trace.ent.linkcount;
+	
+		//	   the move is ok
+		if (relink) {
+			GameBase.gi.linkentity(ent);
+			GameBase.G_TouchTriggers(ent);
+		}
+		return true;
+	}
+
+	/*
+	======================
+	SV_StepDirection
+	
+	Turns to the movement direction, and walks the current distance if
+	facing it.
+	
+	======================
+	*/
+	public static boolean SV_StepDirection(edict_t ent, float yaw, float dist) {
+		float[] move = { 0, 0, 0 };
+		float[] oldorigin = { 0, 0, 0 };
+		float delta;
+	
+		ent.ideal_yaw = yaw;
+		M.M_ChangeYaw(ent);
+	
+		yaw = (float) (yaw * Math.PI * 2 / 360);
+		move[0] = (float) Math.cos(yaw) * dist;
+		move[1] = (float) Math.sin(yaw) * dist;
+		move[2] = 0;
+	
+		Math3D.VectorCopy(ent.s.origin, oldorigin);
+		if (SV_movestep(ent, move, false)) {
+			delta = ent.s.angles[Defines.YAW] - ent.ideal_yaw;
+			if (delta > 45 && delta < 315) { // not turned far enough, so don't take the step
+				Math3D.VectorCopy(oldorigin, ent.s.origin);
+			}
+			GameBase.gi.linkentity(ent);
+			GameBase.G_TouchTriggers(ent);
+			return true;
+		}
+		GameBase.gi.linkentity(ent);
+		GameBase.G_TouchTriggers(ent);
+		return false;
+	}
+
+	/*
+	======================
+	SV_FixCheckBottom
+	
+	======================
+	*/
+	public static void SV_FixCheckBottom(edict_t ent) {
+		ent.flags |= Defines.FL_PARTIALGROUND;
+	}
+
+	public static void SV_NewChaseDir(edict_t actor, edict_t enemy, float dist) {
+		float deltax, deltay;
+		float d[] = { 0, 0, 0 };
+		float tdir, olddir, turnaround;
+	
+		//FIXME: how did we get here with no enemy
+		if (enemy == null)
+		{
+			Com.d("SV_NewChaseDir without enemy!");
+			return;
+		}
+		olddir = Math3D.anglemod((int) (actor.ideal_yaw / 45) * 45);
+		turnaround = Math3D.anglemod(olddir - 180);
+	
+		deltax = enemy.s.origin[0] - actor.s.origin[0];
+		deltay = enemy.s.origin[1] - actor.s.origin[1];
+		if (deltax > 10)
+			d[1] = 0;
+		else if (deltax < -10)
+			d[1] = 180;
+		else
+			d[1] = GameBase.DI_NODIR;
+		if (deltay < -10)
+			d[2] = 270;
+		else if (deltay > 10)
+			d[2] = 90;
+		else
+			d[2] = GameBase.DI_NODIR;
+	
+		//	   try direct route
+		if (d[1] != GameBase.DI_NODIR && d[2] != GameBase.DI_NODIR) {
+			if (d[1] == 0)
+				tdir = d[2] == 90 ? 45 : 315;
+			else
+				tdir = d[2] == 90 ? 135 : 215;
+	
+			if (tdir != turnaround && SV_StepDirection(actor, tdir, dist))
+				return;
+		}
+	
+		//	   try other directions
+		if (((Lib.rand() & 3) & 1) != 0 || Math.abs(deltay) > Math.abs(deltax)) {
+			tdir = d[1];
+			d[1] = d[2];
+			d[2] = tdir;
+		}
+	
+		if (d[1] != GameBase.DI_NODIR && d[1] != turnaround && SV_StepDirection(actor, d[1], dist))
+			return;
+	
+		if (d[2] != GameBase.DI_NODIR && d[2] != turnaround && SV_StepDirection(actor, d[2], dist))
+			return;
+	
+		/* there is no direct path to the player, so pick another direction */
+	
+		if (olddir != GameBase.DI_NODIR && SV_StepDirection(actor, olddir, dist))
+			return;
+	
+		if ((Lib.rand() & 1) != 0) /*randomly determine direction of search*/ {
+			for (tdir = 0; tdir <= 315; tdir += 45)
+				if (tdir != turnaround && SV_StepDirection(actor, tdir, dist))
+					return;
+		} else {
+			for (tdir = 315; tdir >= 0; tdir -= 45)
+				if (tdir != turnaround && SV_StepDirection(actor, tdir, dist))
+					return;
+		}
+	
+		if (turnaround != GameBase.DI_NODIR && SV_StepDirection(actor, turnaround, dist))
+			return;
+	
+		actor.ideal_yaw = olddir; // can't move
+	
+		//	   if a bridge was pulled out from underneath a monster, it may not have
+		//	   a valid standing position at all
+	
+		if (!M.M_CheckBottom(actor))
+			SV_FixCheckBottom(actor);
+	}
+
+	/*
+	======================
+	SV_CloseEnough
+	
+	======================
+	*///ok
+	public static boolean SV_CloseEnough(edict_t ent, edict_t goal, float dist) {
+		int i;
+	
+		for (i = 0; i < 3; i++) {
+			if (goal.absmin[i] > ent.absmax[i] + dist)
+				return false;
+			if (goal.absmax[i] < ent.absmin[i] - dist)
+				return false;
+		}
+		return true;
+	}
+}
diff --git a/src/jake2/server/SV_CCMDS.java b/src/jake2/server/SV_CCMDS.java
new file mode 100644
index 0000000..baa1478
--- /dev/null
+++ b/src/jake2/server/SV_CCMDS.java
@@ -0,0 +1,1190 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 18.01.2004 by RST.
+// $Id: SV_CCMDS.java,v 1.1 2004-07-07 19:59:47 hzi Exp $
+
+package jake2.server;
+
+import jake2.Globals;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.sys.NET;
+import jake2.sys.Sys;
+import jake2.util.Lib;
+import jake2.util.Vargs;
+
+import java.io.*;
+import java.util.Date;
+
+public class SV_CCMDS extends SV_ENTS {
+
+	/*
+	===============================================================================
+	
+	OPERATOR CONSOLE ONLY COMMANDS
+	
+	These commands can only be entered from stdin or by a remote operator datagram
+	===============================================================================
+	*/
+
+	/*
+	====================
+	SV_SetMaster_f
+	
+	Specify a list of master servers
+	====================
+	*/
+	public static void SV_SetMaster_f() {
+		int i, slot;
+
+		// only dedicated servers send heartbeats
+		if (dedicated.value == 0) {
+			Com.Printf("Only dedicated servers use masters.\n");
+			return;
+		}
+
+		// make sure the server is listed public
+		Cvar.Set("public", "1");
+
+		for (i = 1; i < MAX_MASTERS; i++)
+			//memset (&master_adr[i], 0, sizeof(master_adr[i]));
+			master_adr[i] = new netadr_t();
+
+		slot = 1; // slot 0 will always contain the id master
+		for (i = 1; i < Cmd.Argc(); i++) {
+			if (slot == MAX_MASTERS)
+				break;
+
+			if (!NET.StringToAdr(Cmd.Argv(i), master_adr[i])) {
+				Com.Printf("Bad address: " + Cmd.Argv(i) + "\n");
+				continue;
+			}
+			if (master_adr[slot].port == 0)
+					master_adr[slot].port = //BigShort (PORT_MASTER);
+	PORT_MASTER;
+
+			Com.Printf("Master server at " + NET.AdrToString(master_adr[slot]) + "\n");
+
+			Com.Printf("Sending a ping.\n");
+
+			Netchan.OutOfBandPrint(NS_SERVER, master_adr[slot], "ping");
+
+			slot++;
+		}
+
+		svs.last_heartbeat = -9999999;
+	}
+
+	/*
+	==================
+	SV_SetPlayer
+	
+	Sets sv_client and sv_player to the player with idnum Cmd.Argv(1)
+	==================
+	*/
+	public static boolean SV_SetPlayer() {
+		client_t cl;
+		int i;
+		int idnum;
+		String s;
+
+		if (Cmd.Argc() < 2)
+			return false;
+
+		s = Cmd.Argv(1);
+
+		// numeric values are just slot numbers
+		if (s.charAt(0) >= '0' && s.charAt(0) <= '9') {
+			idnum = atoi(Cmd.Argv(1));
+			if (idnum < 0 || idnum >= maxclients.value) {
+				Com.Printf("Bad client slot: " + idnum + "\n");
+				return false;
+			}
+
+			sv_client = svs.clients[idnum];
+			sv_player = sv_client.edict;
+			if (0 == sv_client.state) {
+				Com.Printf("Client " + idnum + " is not active\n");
+				return false;
+			}
+			return true;
+		}
+
+		// check for a name match
+		for (i = 0; i < maxclients.value; i++) {
+			cl = svs.clients[i];
+			if (0 == cl.state)
+				continue;
+			if (0 == strcmp(cl.name, s)) {
+				sv_client = cl;
+				sv_player = sv_client.edict;
+				return true;
+			}
+		}
+
+		Com.Printf("Userid " + s + " is not on the server\n");
+		return false;
+	}
+
+	/*
+	===============================================================================
+	
+	SAVEGAME FILES
+	
+	===============================================================================
+	*/
+
+	public static void remove(String name) {
+		try {
+			new File(name).delete();
+		}
+		catch (Exception e) {
+		}
+	}
+
+	/*
+	=====================
+	SV_WipeSavegame
+	
+	Delete save/<XXX>/
+	=====================
+	*/
+	public static void SV_WipeSavegame(String savename) {
+		//char	name[MAX_OSPATH];
+		//char	*s;
+
+		String name, s;
+
+		Com.DPrintf("SV_WipeSaveGame(" + savename + ")\n");
+
+		name = FS.Gamedir() + "/save/" + savename + "/server.ssv";
+		remove(name);
+
+		name = FS.Gamedir() + "/save/" + savename + "/game.ssv";
+		remove(name);
+
+		name = FS.Gamedir() + "/save/" + savename + "/*.sav";
+
+		File f = Sys.FindFirst(name, 0, 0);
+		while (f != null) {
+			f.delete();
+			f = Sys.FindNext();
+		}
+		Sys.FindClose();
+
+		name = FS.Gamedir() + "/save/" + savename + "/*.sv2";
+
+		f = Sys.FindFirst(name, 0, 0);
+
+		while (f != null) {
+			f.delete();
+			f = Sys.FindNext();
+		}
+		Sys.FindClose();
+	}
+
+	/*
+	================
+	CopyFile
+	================
+	*/
+	public static void CopyFile(String src, String dst) {
+		RandomAccessFile f1, f2;
+		int l = -1;
+		byte buffer[] = new byte[65536];
+
+		Com.DPrintf("CopyFile (" + src + ", " + dst + ")\n");
+
+		try {
+			f1 = new RandomAccessFile(src, "r");
+		}
+		catch (Exception e) {
+			return;
+		}
+		try {
+
+			f2 = new RandomAccessFile(dst, "rw");
+		}
+		catch (Exception e) {
+			try {
+				f1.close();
+			}
+			catch (IOException e1) {
+				// TODO Auto-generated catch block
+				e1.printStackTrace();
+			}
+			return;
+		}
+
+		while (true) {
+
+			try {
+				l = f1.read(buffer, 0, 65536);
+			}
+			catch (IOException e1) {
+
+				e1.printStackTrace();
+			}
+			if (l == -1)
+				break;
+			try {
+				f2.write(buffer, 0, l);
+			}
+			catch (IOException e2) {
+
+				e2.printStackTrace();
+			}
+		}
+
+		try {
+			f1.close();
+		}
+		catch (IOException e1) {
+
+			e1.printStackTrace();
+		}
+		try {
+			f2.close();
+		}
+		catch (IOException e2) {
+
+			e2.printStackTrace();
+		}
+	}
+
+	/*
+	================
+	SV_CopySaveGame
+	================
+	*/
+	public static void SV_CopySaveGame(String src, String dst) {
+		//char name[MAX_OSPATH], name2[MAX_OSPATH];
+		int l, len;
+		File found;
+
+		String name, name2;
+
+		Com.DPrintf("SV_CopySaveGame(" + src + "," + dst + ")\n");
+
+		SV_WipeSavegame(dst);
+
+		// copy the savegame over
+		name = FS.Gamedir() + "/save/" + src + "/server.ssv";
+		name2 = FS.Gamedir() + "/save/" + dst + "/server.ssv";
+		FS.CreatePath(name2);
+		CopyFile(name, name2);
+
+		name = FS.Gamedir() + "/save/" + src + "/game.ssv";
+		name2 = "/save/" + dst + "/game.ssv";
+		CopyFile(name, name2);
+
+		String name1 = FS.Gamedir() + "/save/" + src + "/";
+		len = strlen(name1);
+		name = FS.Gamedir() + "/save/" + src + "/*.sav";
+
+		found = Sys.FindFirst(name, 0, 0);
+
+		while (found != null) {
+			name = name1 + '/' + found.getName();
+			name2 = FS.Gamedir() + "/save/" + dst + "/" + found.getName();
+			CopyFile(name, name2);
+
+			// change sav to sv2
+			//l = strlen(name);
+			//strcpy(name + l - 3, "sv2");
+			//l = strlen(name2);
+			//strcpy(name2 + l - 3, "sv2");
+			name = name.substring(0, name.length() - 3) + "sv2";
+			name2 = name.substring(0, name2.length() - 3) + "sv2";
+
+			CopyFile(name, name2);
+
+			found = Sys.FindNext();
+		}
+		Sys.FindClose();
+	}
+
+	/*
+	==============
+	SV_WriteLevelFile
+	
+	==============
+	*/
+	public static void SV_WriteLevelFile() {
+		//char name[MAX_OSPATH];
+		//FILE * f;
+
+		String name;
+		RandomAccessFile f;
+
+		Com.DPrintf("SV_WriteLevelFile()\n");
+
+		name = FS.Gamedir() + "/save/current/" + sv.name + ".sv2";
+
+		try {
+			f = new RandomAccessFile(name, "rw");
+		}
+		catch (Exception e) {
+			Com.Printf("Failed to open " + name + "\n");
+			return;
+		}
+		try {
+			//fwrite(sv.configstrings, sizeof(sv.configstrings), 1, f);
+			for (int i = 0; i < sv.configstrings.length; i++)
+				Lib.fwriteString(sv.configstrings[i], MAX_QPATH, f);
+
+			CM.CM_WritePortalState(f);
+			f.close();
+		}
+		catch (Exception e) {
+			Com.Printf("IOError in SV_WriteLevelFile: " + e);
+			e.printStackTrace();
+		}
+
+		name = FS.Gamedir() + "/save/current/" + sv.name + ".sav";
+		ge.WriteLevel(name);
+	}
+
+	/*
+	==============
+	SV_ReadLevelFile
+	
+	==============
+	*/
+	public static void SV_ReadLevelFile() {
+		//char name[MAX_OSPATH];
+		String name;
+		RandomAccessFile f;
+
+		Com.DPrintf("SV_ReadLevelFile()\n");
+
+		name = FS.Gamedir() + "/save/current/" + sv.name + ".sv2";
+		try {
+			f = new RandomAccessFile(name, "r");
+		}
+		catch (Exception e) {
+			Com.Printf("Failed to open " + name + "\n");
+			return;
+		}
+		//		FS.Read(sv.configstrings, sizeof(sv.configstrings), f);
+		for (int n = 0; n < MAX_CONFIGSTRINGS; n++)
+			sv.configstrings[n] = Lib.freadString(f, MAX_QPATH);
+
+		CM.CM_ReadPortalState(f);
+
+		try {
+			f.close();
+		}
+		catch (IOException e1) {
+			e1.printStackTrace();
+		}
+
+		name = FS.Gamedir() + "/save/current/" + sv.name + ".sav";
+		ge.ReadLevel(name);
+	}
+
+	/*
+	==============
+	SV_WriteServerFile
+	
+	==============
+	*/
+	public static void SV_WriteServerFile(boolean autosave) {
+		RandomAccessFile f;
+		cvar_t var;
+		//char name[MAX_OSPATH], string[128];
+		//char comment[32];
+		//time_t aclock;
+		//struct tm * newtime;
+		String name, string, comment;
+
+		Com.DPrintf("SV_WriteServerFile(" + (autosave ? "true" : "false") + ")\n");
+
+		name = FS.Gamedir() + "/save/current/server.ssv";
+		try {
+			f = new RandomAccessFile(name, "rw");
+		} catch (FileNotFoundException e) {
+			f = null;
+		}
+		if (f == null) {
+			Com.Printf("Couldn't write " + name + "\n");
+			return;
+		}
+		// write the comment field
+		//memset(comment, 0, sizeof(comment));
+
+		if (!autosave) {
+			//time( aclock);
+			//newtime = localtime( aclock);
+			Date newtime = new Date();
+			comment =
+				Com.sprintf(
+					"%2i:%2i %2i/%2i  ",
+					new Vargs().add(newtime.getHours()).add(newtime.getMinutes()).add(newtime.getMonth() + 1).add(newtime.getDay()));
+			comment += sv.configstrings[CS_NAME];
+		}
+		else { // autosaved
+			comment = "ENTERING " + sv.configstrings[CS_NAME];
+		}
+
+		try {
+			fwriteString(comment, 32, f);
+			fwriteString(svs.mapcmd, MAX_TOKEN_CHARS, f);
+
+		} catch (IOException e1) {}
+
+		// write the mapcmd
+		
+		// write all CVAR_LATCH cvars
+		// these will be things like coop, skill, deathmatch, etc
+		for (var = Globals.cvar_vars; var != null; var = var.next) {
+			if (0 == (var.flags & CVAR_LATCH))
+				continue;
+			if (strlen(var.name) >= MAX_OSPATH - 1 || strlen(var.string) >= 128 - 1) {
+				Com.Printf("Cvar too long: " + var.name + " = " + var.string + "\n");
+				continue;
+			}
+			//memset(name, 0, sizeof(name));
+			//memset(string, 0, sizeof(string));
+			name = var.name;
+			string = var.string;
+			try {
+				fwriteString(name, MAX_OSPATH, f);
+				fwriteString(string, 128, f);
+			} catch (IOException e2) {}
+			
+		}
+
+		try {
+			f.close();
+		} catch (IOException e2) {}
+
+		// write game state
+		name = FS.Gamedir() + "/save/current/game.ssv";
+		ge.WriteGame(name, autosave);
+	}
+
+	/*
+	==============
+	SV_ReadServerFile
+	
+	==============
+	*/
+	public static void SV_ReadServerFile() {
+		RandomAccessFile f;
+		//char	name[MAX_OSPATH], string[128];
+		//char	comment[32];
+		//char	mapcmd[MAX_TOKEN_CHARS];
+
+		String name, string, comment, mapcmd;
+
+		Com.DPrintf("SV_ReadServerFile()\n");
+
+		name = FS.Gamedir() + "/save/current/server.ssv";
+		try {
+			f = new RandomAccessFile(name, "r");
+		}
+		catch (FileNotFoundException e1) {
+			Com.Printf("Couldn't read " + name + "\n");
+			e1.printStackTrace();
+			return;
+		}
+		// read the comment field
+		comment = Lib.freadString(f, 32);
+
+		// read the mapcmd
+		mapcmd = Lib.freadString(f, MAX_TOKEN_CHARS);
+
+		// read all CVAR_LATCH cvars
+		// these will be things like coop, skill, deathmatch, etc
+		while (true) {
+			name = Lib.freadString(f, MAX_OSPATH);
+			//if (!fread(name, 1, sizeof(name), f))
+			if (name == null)
+				break;
+			string = Lib.freadString(f, 128);
+			Com.DPrintf("Set " + name + " = " + string + "\n");
+			Cvar.ForceSet(name, string);
+		}
+
+		try {
+			f.close();
+		}
+		catch (IOException e) {
+			e.printStackTrace();
+		}
+
+		// start a new game fresh with new cvars
+		SV_InitGame();
+
+		svs.mapcmd = mapcmd;
+
+		// read game state
+		name = FS.Gamedir() + "/save/current/game.ssv";
+		ge.ReadGame(name);
+	}
+
+	//=========================================================
+
+	/*
+	==================
+	SV_DemoMap_f
+	
+	Puts the server in demo mode on a specific map/cinematic
+	==================
+	*/
+	public static void SV_DemoMap_f() {
+		SV_Map(true, Cmd.Argv(1), false);
+	}
+
+	/*
+	==================
+	SV_GameMap_f
+	
+	Saves the state of the map just being exited and goes to a new map.
+	
+	If the initial character of the map string is '*', the next map is
+	in a new unit, so the current savegame directory is cleared of
+	map files.
+	
+	Example:
+	
+	*inter.cin+jail
+	
+	Clears the archived maps, plays the inter.cin cinematic, then
+	goes to map jail.bsp.
+	==================
+	*/
+	public static void SV_GameMap_f() {
+		String map;
+		int i;
+		client_t cl;
+		boolean savedInuse[];
+
+		if (Cmd.Argc() != 2) {
+			Com.Printf("USAGE: gamemap <map>\n");
+			return;
+		}
+
+		Com.DPrintf("SV_GameMap(" + Cmd.Argv(1) + ")\n");
+
+		FS.CreatePath(FS.Gamedir() + "/save/current/");
+
+		// check for clearing the current savegame
+		map = Cmd.Argv(1);
+		if (map.charAt(0) == '*') {
+			// wipe all the *.sav files
+			SV_WipeSavegame("current");
+		}
+		else { // save the map just exited
+			if (sv.state == ss_game) {
+				// clear all the client inuse flags before saving so that
+				// when the level is re-entered, the clients will spawn
+				// at spawn points instead of occupying body shells
+				savedInuse = new boolean[(int) maxclients.value];
+				for (i = 0; i < maxclients.value; i++) {
+					cl = svs.clients[i];
+					savedInuse[i] = cl.edict.inuse;
+					cl.edict.inuse = false;
+				}
+
+				SV_WriteLevelFile();
+
+				// we must restore these for clients to transfer over correctly
+				for (i = 0; i < maxclients.value; i++) {
+					cl = svs.clients[i];
+					cl.edict.inuse = savedInuse[i];
+
+				}
+				savedInuse = null;
+			}
+		}
+
+		// start up the next map
+		SV_Map(false, Cmd.Argv(1), false);
+
+		// archive server state
+		svs.mapcmd = Cmd.Argv(1);
+
+		// copy off the level to the autosave slot
+		if (0 == dedicated.value) {
+
+			//TODO: SV_WriteServerFile!
+			//SV_WriteServerFile(true);
+
+			//SV_CopySaveGame("current", "save0");
+		}
+	}
+
+	/*
+	==================
+	SV_Map_f
+	
+	Goes directly to a given map without any savegame archiving.
+	For development work
+	==================
+	*/
+	public static void SV_Map_f() {
+		String map;
+		//char expanded[MAX_QPATH];
+		String expanded;
+
+		// if not a pcx, demo, or cinematic, check to make sure the level exists
+		map = Cmd.Argv(1);
+		if (!strstr(map, ".")) {
+			expanded = "maps/" + map + ".bsp";
+			if (FS.LoadFile(expanded) == null) {
+				Com.Printf("Can't find " + expanded + "\n");
+				return;
+			}
+		}
+
+		sv.state = ss_dead; // don't save current level when changing
+		//TODO: RST: disabled for debugging
+		//SV_WipeSavegame("current");
+		SV_GameMap_f();
+	}
+
+	/*
+	=====================================================================
+	
+	  SAVEGAMES
+	
+	=====================================================================
+	*/
+
+	/*
+	==============
+	SV_Loadgame_f
+	
+	==============
+	*/
+	public static void SV_Loadgame_f() {
+		//char name[MAX_OSPATH];
+		//FILE * f;
+		//char * dir;
+
+		String name;
+		RandomAccessFile f;
+		String dir;
+
+		if (Cmd.Argc() != 2) {
+			Com.Printf("USAGE: loadgame <directory>\n");
+			return;
+		}
+
+		Com.Printf("Loading game...\n");
+
+		dir = Cmd.Argv(1);
+		if (strstr(dir, "..") || strstr(dir, "/") || strstr(dir, "\\")) {
+			Com.Printf("Bad savedir.\n");
+		}
+
+		// make sure the server.ssv file exists
+		name = FS.Gamedir() + "/save/" + Cmd.Argv(1) + "/server.ssv";
+		try {
+			f = new RandomAccessFile(name, "r");
+		}
+		catch (FileNotFoundException e) {
+			Com.Printf("No such savegame: " + name + "\n");
+			return;
+		}
+
+		try {
+			f.close();
+		}
+		catch (IOException e1) {
+			e1.printStackTrace();
+		}
+
+		SV_CopySaveGame(Cmd.Argv(1), "current");
+
+		SV_ReadServerFile();
+
+		// go to the map
+		sv.state = ss_dead; // don't save current level when changing
+		SV_INIT.SV_Map(false, svs.mapcmd, true);
+	}
+
+	/*
+	==============
+	SV_Savegame_f
+	
+	==============
+	*/
+	public static void SV_Savegame_f() {
+		String dir;
+
+		if (sv.state != ss_game) {
+			Com.Printf("You must be in a game to save.\n");
+			return;
+		}
+
+		if (Cmd.Argc() != 2) {
+			Com.Printf("USAGE: savegame <directory>\n");
+			return;
+		}
+
+		if (Cvar.VariableValue("deathmatch") != 0) {
+			Com.Printf("Can't savegame in a deathmatch\n");
+			return;
+		}
+
+		if (0 == strcmp(Cmd.Argv(1), "current")) {
+			Com.Printf("Can't save to 'current'\n");
+			return;
+		}
+
+		if (maxclients.value == 1 && svs.clients[0].edict.client.ps.stats[STAT_HEALTH] <= 0) {
+			Com.Printf("\nCan't savegame while dead!\n");
+			return;
+		}
+
+		dir = Cmd.Argv(1);
+		if (strstr(dir, "..") || strstr(dir, "/") || strstr(dir, "\\")) {
+			Com.Printf("Bad savedir.\n");
+		}
+
+		Com.Printf("Saving game...\n");
+
+		// archive current level, including all client edicts.
+		// when the level is reloaded, they will be shells awaiting
+		// a connecting client
+		SV_WriteLevelFile();
+
+		// save server state
+		try {
+			SV_WriteServerFile(false);
+		}
+		catch (Exception e) {
+			Com.Printf("IOError in SV_WriteServerFile: " + e);
+		}
+
+		// copy it off
+		SV_CopySaveGame("current", dir);
+
+		Com.Printf("Done.\n");
+	}
+
+	//===============================================================
+
+	/*
+	==================
+	SV_Kick_f
+	
+	Kick a user off of the server
+	==================
+	*/
+	public static void SV_Kick_f() {
+		if (!svs.initialized) {
+			Com.Printf("No server running.\n");
+			return;
+		}
+
+		if (Cmd.Argc() != 2) {
+			Com.Printf("Usage: kick <userid>\n");
+			return;
+		}
+
+		if (!SV_SetPlayer())
+			return;
+
+		SV_BroadcastPrintf(PRINT_HIGH, sv_client.name + " was kicked\n");
+		// print directly, because the dropped client won't get the
+		// SV_BroadcastPrintf message
+		SV_ClientPrintf(sv_client, PRINT_HIGH, "You were kicked from the game\n");
+		SV_DropClient(sv_client);
+		sv_client.lastmessage = svs.realtime; // min case there is a funny zombie
+	}
+
+	/*
+	================
+	SV_Status_f
+	================
+	*/
+	public static void SV_Status_f() {
+		int i, j, l;
+		client_t cl;
+		String s;
+		int ping;
+		if (svs.clients == null) {
+			Com.Printf("No server running.\n");
+			return;
+		}
+		Com.Printf("map              : " + sv.name + "\n");
+
+		Com.Printf("num score ping name            lastmsg address               qport \n");
+		Com.Printf("--- ----- ---- --------------- ------- --------------------- ------\n");
+		for (i = 0; i < maxclients.value; i++) {
+			cl = svs.clients[i];
+			if (0 == cl.state)
+				continue;
+
+			Com.Printf("%3i ", new Vargs().add(i));
+			Com.Printf("%5i ", new Vargs().add(cl.edict.client.ps.stats[STAT_FRAGS]));
+
+			if (cl.state == cs_connected)
+				Com.Printf("CNCT ");
+			else if (cl.state == cs_zombie)
+				Com.Printf("ZMBI ");
+			else {
+				ping = cl.ping < 9999 ? cl.ping : 9999;
+				Com.Printf("%4i ", new Vargs().add(ping));
+			}
+
+			Com.Printf("%s", new Vargs().add(cl.name));
+			l = 16 - strlen(cl.name);
+			for (j = 0; j < l; j++)
+				Com.Printf(" ");
+
+			Com.Printf("%7i ", new Vargs().add(svs.realtime - cl.lastmessage));
+
+			s = NET.AdrToString(cl.netchan.remote_address);
+			Com.Printf(s);
+			l = 22 - strlen(s);
+			for (j = 0; j < l; j++)
+				Com.Printf(" ");
+
+			Com.Printf("%5i", new Vargs().add(cl.netchan.qport));
+
+			Com.Printf("\n");
+		}
+		Com.Printf("\n");
+	}
+
+	/*
+	==================
+	SV_ConSay_f
+	==================
+	*/
+	public static void SV_ConSay_f() {
+		client_t client;
+		int j;
+		String p;
+		String text; // char[1024];
+
+		if (Cmd.Argc() < 2)
+			return;
+
+		text = "console: ";
+		p = Cmd.Args();
+
+		if (p.charAt(0) == '"') {
+			p = p.substring(1, p.length() - 1);
+		}
+
+		text += p;
+
+		for (j = 0; j < maxclients.value; j++) {
+			client = svs.clients[j];
+			if (client.state != cs_spawned)
+				continue;
+			SV_ClientPrintf(client, PRINT_CHAT, text + "\n");
+		}
+	}
+
+	/*
+	==================
+	SV_Heartbeat_f
+	==================
+	*/
+	public static void SV_Heartbeat_f() {
+		svs.last_heartbeat = -9999999;
+	}
+
+	/*
+	===========
+	SV_Serverinfo_f
+	
+	  Examine or change the serverinfo string
+	===========
+	*/
+	public static void SV_Serverinfo_f() {
+		Com.Printf("Server info settings:\n");
+		Info.Print(Cvar.Serverinfo());
+	}
+
+	/*
+	===========
+	SV_DumpUser_f
+	
+	Examine all a users info strings
+	===========
+	*/
+	public static void SV_DumpUser_f() {
+		if (Cmd.Argc() != 2) {
+			Com.Printf("Usage: info <userid>\n");
+			return;
+		}
+
+		if (!SV_SetPlayer())
+			return;
+
+		Com.Printf("userinfo\n");
+		Com.Printf("--------\n");
+		Info.Print(sv_client.userinfo);
+
+	}
+
+	/*
+	==============
+	SV_ServerRecord_f
+	
+	Begins server demo recording.  Every entity and every message will be
+	recorded, but no playerinfo will be stored.  Primarily for demo merging.
+	==============
+	*/
+	public static void SV_ServerRecord_f() {
+		//char	name[MAX_OSPATH];
+		String name;
+		byte buf_data[] = new byte[32768];
+		sizebuf_t buf = new sizebuf_t();
+		int len;
+		int i;
+
+		if (Cmd.Argc() != 2) {
+			Com.Printf("serverrecord <demoname>\n");
+			return;
+		}
+
+		if (svs.demofile != null) {
+			Com.Printf("Already recording.\n");
+			return;
+		}
+
+		if (sv.state != ss_game) {
+			Com.Printf("You must be in a level to record.\n");
+			return;
+		}
+
+		//
+		// open the demo file
+		//
+		name = FS.Gamedir() + "/demos/" + Cmd.Argv(1) + ".dm2";
+
+		Com.Printf("recording to " + name + ".\n");
+		FS.CreatePath(name);
+		try {
+			svs.demofile = new RandomAccessFile(name, "rw");
+		}
+		catch (Exception e) {
+			Com.Printf("ERROR: couldn't open.\n");
+			return;
+		}
+
+		// setup a buffer to catch all multicasts
+		SZ.Init(svs.demo_multicast, svs.demo_multicast_buf, svs.demo_multicast_buf.length);
+
+		//
+		// write a single giant fake message with all the startup info
+		//
+		SZ.Init(buf, buf_data, buf_data.length);
+
+		//
+		// serverdata needs to go over for all types of servers
+		// to make sure the protocol is right, and to set the gamedir
+		//
+		// send the serverdata
+		MSG.WriteByte(buf, svc_serverdata);
+		MSG.WriteLong(buf, PROTOCOL_VERSION);
+		MSG.WriteLong(buf, svs.spawncount);
+		// 2 means server demo
+		MSG.WriteByte(buf, 2); // demos are always attract loops
+		MSG.WriteString(buf, Cvar.VariableString("gamedir"));
+		MSG.WriteShort(buf, -1);
+		// send full levelname
+		MSG.WriteString(buf, sv.configstrings[CS_NAME]);
+
+		for (i = 0; i < MAX_CONFIGSTRINGS; i++)
+			if (sv.configstrings[i].length() == 0) {
+				MSG.WriteByte(buf, svc_configstring);
+				MSG.WriteShort(buf, i);
+				MSG.WriteString(buf, sv.configstrings[i]);
+			}
+
+		// write it to the demo file
+		Com.DPrintf("signon message length: " + buf.cursize + "\n");
+		len = EndianHandler.swapInt(buf.cursize);
+		//fwrite(len, 4, 1, svs.demofile);
+		//fwrite(buf.data, buf.cursize, 1, svs.demofile);
+		try {
+			svs.demofile.writeInt(len);
+			svs.demofile.write(buf.data);
+		}
+		catch (IOException e1) {
+			// TODO: do quake2 error handling!
+			e1.printStackTrace();
+		}
+
+		// the rest of the demo file will be individual frames
+	}
+
+	/*
+	==============
+	SV_ServerStop_f
+	
+	Ends server demo recording
+	==============
+	*/
+	public static void SV_ServerStop_f() {
+		if (svs.demofile == null) {
+			Com.Printf("Not doing a serverrecord.\n");
+			return;
+		}
+		try {
+			svs.demofile.close();
+		}
+		catch (IOException e) {
+			e.printStackTrace();
+		}
+		svs.demofile = null;
+		Com.Printf("Recording completed.\n");
+	}
+
+	/*
+	===============
+	SV_KillServer_f
+	
+	Kick everyone off, possibly in preparation for a new game
+	
+	===============
+	*/
+	public static void SV_KillServer_f() {
+		if (!svs.initialized)
+			return;
+		SV_Shutdown("Server was killed.\n", false);
+		NET.Config(false); // close network sockets
+	}
+
+	/*
+	===============
+	SV_ServerCommand_f
+	
+	Let the game dll handle a command
+	===============
+	*/
+	public static void SV_ServerCommand_f() {
+		if (SV_GAME.ge == null) {
+			Com.Printf("No game loaded.\n");
+			return;
+		}
+
+		SV_GAME.ge.ServerCommand();
+	}
+
+	//===========================================================
+
+	/*
+	==================
+	SV_InitOperatorCommands
+	==================
+	*/
+	public static void SV_InitOperatorCommands() {
+		Cmd.AddCommand("heartbeat", new xcommand_t() {
+			public void execute() {
+				SV_Heartbeat_f();
+			}
+		});
+		Cmd.AddCommand("kick", new xcommand_t() {
+			public void execute() {
+				SV_Kick_f();
+			}
+		});
+		Cmd.AddCommand("status", new xcommand_t() {
+			public void execute() {
+				SV_Status_f();
+			}
+		});
+		Cmd.AddCommand("serverinfo", new xcommand_t() {
+			public void execute() {
+				SV_Serverinfo_f();
+			}
+		});
+		Cmd.AddCommand("dumpuser", new xcommand_t() {
+			public void execute() {
+				SV_DumpUser_f();
+			}
+		});
+
+		Cmd.AddCommand("map", new xcommand_t() {
+			public void execute() {
+				SV_Map_f();
+			}
+		});
+		Cmd.AddCommand("demomap", new xcommand_t() {
+			public void execute() {
+				SV_DemoMap_f();
+			}
+		});
+		Cmd.AddCommand("gamemap", new xcommand_t() {
+			public void execute() {
+				SV_GameMap_f();
+			}
+		});
+		Cmd.AddCommand("setmaster", new xcommand_t() {
+			public void execute() {
+				SV_SetMaster_f();
+			}
+		});
+
+		if (dedicated.value != 0)
+			Cmd.AddCommand("say", new xcommand_t() {
+			public void execute() {
+				SV_ConSay_f();
+			}
+		});
+
+		Cmd.AddCommand("serverrecord", new xcommand_t() {
+			public void execute() {
+				SV_ServerRecord_f();
+			}
+		});
+		Cmd.AddCommand("serverstop", new xcommand_t() {
+			public void execute() {
+				SV_ServerStop_f();
+			}
+		});
+
+		Cmd.AddCommand("save", new xcommand_t() {
+			public void execute() {
+				SV_Savegame_f();
+			}
+		});
+		Cmd.AddCommand("load", new xcommand_t() {
+			public void execute() {
+				SV_Loadgame_f();
+			}
+		});
+
+		Cmd.AddCommand("killserver", new xcommand_t() {
+			public void execute() {
+				SV_KillServer_f();
+			}
+		});
+
+		Cmd.AddCommand("sv", new xcommand_t() {
+			public void execute() {
+				SV_ServerCommand_f();
+			}
+		});
+	}
+
+}
diff --git a/src/jake2/server/SV_ENTS.java b/src/jake2/server/SV_ENTS.java
new file mode 100644
index 0000000..de27378
--- /dev/null
+++ b/src/jake2/server/SV_ENTS.java
@@ -0,0 +1,605 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 17.01.2004 by RST.
+// $Id: SV_ENTS.java,v 1.1 2004-07-07 19:59:45 hzi Exp $
+
+package jake2.server;
+
+import java.io.IOException;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.util.Vargs;
+
+public class SV_ENTS extends SV_USER {
+
+	/*
+	=============================================================================
+	
+	Encode a client frame onto the network channel
+	
+	=============================================================================
+	*/
+
+	/*
+	=============
+	SV_EmitPacketEntities
+	
+	Writes a delta update of an entity_state_t list to the message.
+	=============
+	*/
+	static void SV_EmitPacketEntities(client_frame_t from, client_frame_t to, sizebuf_t msg) {
+		entity_state_t oldent = null, newent = null;
+		int oldindex, newindex;
+		int oldnum, newnum;
+		int from_num_entities;
+		int bits;
+
+		MSG.WriteByte(msg, svc_packetentities);
+
+		if (from == null)
+			from_num_entities = 0;
+		else
+			from_num_entities = from.num_entities;
+
+		newindex = 0;
+		oldindex = 0;
+		while (newindex < to.num_entities || oldindex < from_num_entities) {
+			if (newindex >= to.num_entities)
+				newnum = 9999;
+			else {
+				newent = svs.client_entities[(to.first_entity + newindex) % svs.num_client_entities];
+				newnum = newent.number;
+			}
+
+			if (oldindex >= from_num_entities)
+				oldnum = 9999;
+			else {
+				oldent = svs.client_entities[(from.first_entity + oldindex) % svs.num_client_entities];
+				oldnum = oldent.number;
+			}
+
+			if (newnum == oldnum) { // delta update from old position
+				// because the force parm is false, this will not result
+				// in any bytes being emited if the entity has not changed at all
+				// note that players are always 'newentities', this updates their oldorigin always
+				// and prevents warping
+				MSG.WriteDeltaEntity(oldent, newent, msg, false, newent.number <= maxclients.value);
+				oldindex++;
+				newindex++;
+				continue;
+			}
+
+			if (newnum < oldnum) { // this is a new entity, send it from the baseline
+				MSG.WriteDeltaEntity(sv.baselines[newnum], newent, msg, true, true);
+				newindex++;
+				continue;
+			}
+
+			if (newnum > oldnum) { // the old entity isn't present in the new message
+				bits = U_REMOVE;
+				if (oldnum >= 256)
+					bits |= U_NUMBER16 | U_MOREBITS1;
+
+				MSG.WriteByte(msg, bits & 255);
+				if ((bits & 0x0000ff00) != 0)
+					MSG.WriteByte(msg, (bits >> 8) & 255);
+
+				if ((bits & U_NUMBER16) != 0)
+					MSG.WriteShort(msg, oldnum);
+				else
+					MSG.WriteByte(msg, oldnum);
+
+				oldindex++;
+				continue;
+			}
+		}
+
+		MSG.WriteShort(msg, 0); // end of packetentities
+
+	}
+
+	/*
+	=============
+	SV_WritePlayerstateToClient
+	
+	=============
+	*/
+	static void SV_WritePlayerstateToClient(client_frame_t from, client_frame_t to, sizebuf_t msg) {
+		int i;
+		int pflags;
+		player_state_t ps, ops;
+		player_state_t dummy;
+		int statbits;
+
+		ps = to.ps;
+		if (from == null) {
+			//memset (dummy, 0, sizeof(dummy));
+			dummy = new player_state_t();
+			ops = dummy;
+		}
+		else
+			ops = from.ps;
+
+		//
+		// determine what needs to be sent
+		//
+		pflags = 0;
+
+		if (ps.pmove.pm_type != ops.pmove.pm_type)
+			pflags |= PS_M_TYPE;
+
+		if (ps.pmove.origin[0] != ops.pmove.origin[0]
+			|| ps.pmove.origin[1] != ops.pmove.origin[1]
+			|| ps.pmove.origin[2] != ops.pmove.origin[2])
+			pflags |= PS_M_ORIGIN;
+
+		if (ps.pmove.velocity[0] != ops.pmove.velocity[0]
+			|| ps.pmove.velocity[1] != ops.pmove.velocity[1]
+			|| ps.pmove.velocity[2] != ops.pmove.velocity[2])
+			pflags |= PS_M_VELOCITY;
+
+		if (ps.pmove.pm_time != ops.pmove.pm_time)
+			pflags |= PS_M_TIME;
+
+		if (ps.pmove.pm_flags != ops.pmove.pm_flags)
+			pflags |= PS_M_FLAGS;
+
+		if (ps.pmove.gravity != ops.pmove.gravity)
+			pflags |= PS_M_GRAVITY;
+
+		if (ps.pmove.delta_angles[0] != ops.pmove.delta_angles[0]
+			|| ps.pmove.delta_angles[1] != ops.pmove.delta_angles[1]
+			|| ps.pmove.delta_angles[2] != ops.pmove.delta_angles[2])
+			pflags |= PS_M_DELTA_ANGLES;
+
+		if (ps.viewoffset[0] != ops.viewoffset[0] || ps.viewoffset[1] != ops.viewoffset[1] || ps.viewoffset[2] != ops.viewoffset[2])
+			pflags |= PS_VIEWOFFSET;
+
+		if (ps.viewangles[0] != ops.viewangles[0] || ps.viewangles[1] != ops.viewangles[1] || ps.viewangles[2] != ops.viewangles[2])
+			pflags |= PS_VIEWANGLES;
+
+		if (ps.kick_angles[0] != ops.kick_angles[0]
+			|| ps.kick_angles[1] != ops.kick_angles[1]
+			|| ps.kick_angles[2] != ops.kick_angles[2])
+			pflags |= PS_KICKANGLES;
+
+		if (ps.blend[0] != ops.blend[0] || ps.blend[1] != ops.blend[1] || ps.blend[2] != ops.blend[2] || ps.blend[3] != ops.blend[3])
+			pflags |= PS_BLEND;
+
+		if (ps.fov != ops.fov)
+			pflags |= PS_FOV;
+
+		if (ps.rdflags != ops.rdflags)
+			pflags |= PS_RDFLAGS;
+
+		if (ps.gunframe != ops.gunframe)
+			pflags |= PS_WEAPONFRAME;
+
+		pflags |= PS_WEAPONINDEX;
+
+		//
+		// write it
+		//
+		MSG.WriteByte(msg, svc_playerinfo);
+		MSG.WriteShort(msg, pflags);
+
+		//
+		// write the pmove_state_t
+		//
+		if ((pflags & PS_M_TYPE) != 0)
+			MSG.WriteByte(msg, ps.pmove.pm_type);
+
+		if ((pflags & PS_M_ORIGIN) != 0) {
+			MSG.WriteShort(msg, ps.pmove.origin[0]);
+			MSG.WriteShort(msg, ps.pmove.origin[1]);
+			MSG.WriteShort(msg, ps.pmove.origin[2]);
+		}
+
+		if ((pflags & PS_M_VELOCITY) != 0) {
+			MSG.WriteShort(msg, ps.pmove.velocity[0]);
+			MSG.WriteShort(msg, ps.pmove.velocity[1]);
+			MSG.WriteShort(msg, ps.pmove.velocity[2]);
+		}
+
+		if ((pflags & PS_M_TIME) != 0)
+			MSG.WriteByte(msg, ps.pmove.pm_time);
+
+		if ((pflags & PS_M_FLAGS) != 0)
+			MSG.WriteByte(msg, ps.pmove.pm_flags);
+
+		if ((pflags & PS_M_GRAVITY) != 0)
+			MSG.WriteShort(msg, ps.pmove.gravity);
+
+		if ((pflags & PS_M_DELTA_ANGLES) != 0) {
+			MSG.WriteShort(msg, ps.pmove.delta_angles[0]);
+			MSG.WriteShort(msg, ps.pmove.delta_angles[1]);
+			MSG.WriteShort(msg, ps.pmove.delta_angles[2]);
+		}
+
+		//
+		// write the rest of the player_state_t
+		//
+		if ((pflags & PS_VIEWOFFSET) != 0) {
+			MSG.WriteChar(msg, ps.viewoffset[0] * 4);
+			MSG.WriteChar(msg, ps.viewoffset[1] * 4);
+			MSG.WriteChar(msg, ps.viewoffset[2] * 4);
+		}
+
+		if ((pflags & PS_VIEWANGLES) != 0) {
+			MSG.WriteAngle16(msg, ps.viewangles[0]);
+			MSG.WriteAngle16(msg, ps.viewangles[1]);
+			MSG.WriteAngle16(msg, ps.viewangles[2]);
+		}
+
+		if ((pflags & PS_KICKANGLES) != 0) {
+			MSG.WriteChar(msg, ps.kick_angles[0] * 4);
+			MSG.WriteChar(msg, ps.kick_angles[1] * 4);
+			MSG.WriteChar(msg, ps.kick_angles[2] * 4);
+		}
+
+		if ((pflags & PS_WEAPONINDEX) != 0) {
+			MSG.WriteByte(msg, ps.gunindex);
+		}
+
+		if ((pflags & PS_WEAPONFRAME) != 0) {
+			MSG.WriteByte(msg, ps.gunframe);
+			MSG.WriteChar(msg, ps.gunoffset[0] * 4);
+			MSG.WriteChar(msg, ps.gunoffset[1] * 4);
+			MSG.WriteChar(msg, ps.gunoffset[2] * 4);
+			MSG.WriteChar(msg, ps.gunangles[0] * 4);
+			MSG.WriteChar(msg, ps.gunangles[1] * 4);
+			MSG.WriteChar(msg, ps.gunangles[2] * 4);
+		}
+
+		if ((pflags & PS_BLEND) != 0) {
+			MSG.WriteByte(msg, ps.blend[0] * 255);
+			MSG.WriteByte(msg, ps.blend[1] * 255);
+			MSG.WriteByte(msg, ps.blend[2] * 255);
+			MSG.WriteByte(msg, ps.blend[3] * 255);
+		}
+		if ((pflags & PS_FOV) != 0)
+			MSG.WriteByte(msg, ps.fov);
+		if ((pflags & PS_RDFLAGS) != 0)
+			MSG.WriteByte(msg, ps.rdflags);
+
+		// send stats
+		statbits = 0;
+		for (i = 0; i < MAX_STATS; i++)
+			if (ps.stats[i] != ops.stats[i])
+				statbits |= 1 << i;
+		MSG.WriteLong(msg, statbits);
+		for (i = 0; i < MAX_STATS; i++)
+			if ((statbits & (1 << i)) != 0)
+				MSG.WriteShort(msg, ps.stats[i]);
+	}
+
+	/*
+	==================
+	SV_WriteFrameToClient
+	==================
+	*/
+	public static void SV_WriteFrameToClient(client_t client, sizebuf_t msg) {
+		client_frame_t frame, oldframe;
+		int lastframe;
+
+		//Com.Printf ("%i . %i\n", new Vargs().add(client.lastframe).add(sv.framenum));
+		// this is the frame we are creating
+		frame = client.frames[sv.framenum & UPDATE_MASK];
+
+		if (client.lastframe <= 0) { // client is asking for a retransmit
+			oldframe = null;
+			lastframe = -1;
+		}
+		else if (
+			sv.framenum - client.lastframe >= (UPDATE_BACKUP - 3)) { // client hasn't gotten a good message through in a long time
+			// Com_Printf ("%s: Delta request from out-of-date packet.\n", client.name);
+			oldframe = null;
+			lastframe = -1;
+		}
+		else { // we have a valid message to delta from
+			oldframe = client.frames[client.lastframe & UPDATE_MASK];
+			lastframe = client.lastframe;
+		}
+
+		MSG.WriteByte(msg, svc_frame);
+		MSG.WriteLong(msg, sv.framenum);
+		MSG.WriteLong(msg, lastframe); // what we are delta'ing from
+		MSG.WriteByte(msg, client.surpressCount); // rate dropped packets
+		client.surpressCount = 0;
+
+		// send over the areabits
+		MSG.WriteByte(msg, frame.areabytes);
+		SZ.Write(msg, frame.areabits, frame.areabytes);
+
+		// delta encode the playerstate
+		SV_WritePlayerstateToClient(oldframe, frame, msg);
+
+		// delta encode the entities
+		SV_EmitPacketEntities(oldframe, frame, msg);
+	}
+
+	/*
+	=============================================================================
+	
+	Build a client frame structure
+	
+	=============================================================================
+	*/
+
+	static byte fatpvs[] = new byte[65536 / 8]; // 32767 is MAX_MAP_LEAFS
+
+	/*
+	============
+	SV_FatPVS
+	
+	The client will interpolate the view position,
+	so we can't use a single PVS point
+	===========
+	*/
+	public static void SV_FatPVS(float[] org) {
+		int leafs[] = new int[64];
+		int i, j, count;
+		int longs;
+		byte src[];
+		float[] mins = { 0, 0, 0 }, maxs = { 0, 0, 0 };
+
+		for (i = 0; i < 3; i++) {
+			mins[i] = org[i] - 8;
+			maxs[i] = org[i] + 8;
+		}
+
+		count = CM.CM_BoxLeafnums(mins, maxs, leafs, 64, null);
+
+		if (count < 1)
+			Com.Error(ERR_FATAL, "SV_FatPVS: count < 1");
+
+		longs = (CM.CM_NumClusters() + 31) >> 5;
+
+		// convert leafs to clusters
+		for (i = 0; i < count; i++)
+			leafs[i] = CM.CM_LeafCluster(leafs[i]);
+
+		memcpy(fatpvs, CM.CM_ClusterPVS(leafs[0]), longs << 2);
+		// or in all the other leaf bits
+		for (i = 1; i < count; i++) {
+			for (j = 0; j < i; j++)
+				if (leafs[i] == leafs[j])
+					break;
+			if (j != i)
+				continue; // already have the cluster we want
+
+			src = CM.CM_ClusterPVS(leafs[i]);
+
+			//for (j=0 ; j<longs ; j++)
+			//	((long *)fatpvs)[j] |= ((long *)src)[j];
+			int k=0;
+			for (j = 0; j < longs; j++) {
+				fatpvs[k] |= src[k++];
+				fatpvs[k] |= src[k++];
+				fatpvs[k] |= src[k++];
+				fatpvs[k] |= src[k++];
+			}
+		}
+	}
+
+	/*
+	=============
+	SV_BuildClientFrame
+	
+	Decides which entities are going to be visible to the client, and
+	copies off the playerstat and areabits.
+	=============
+	*/
+	public static void SV_BuildClientFrame(client_t client) {
+		int e, i;
+		float[] org = { 0, 0, 0 };
+		edict_t ent;
+		edict_t clent;
+		client_frame_t frame;
+		entity_state_t state;
+		int l;
+		int clientarea, clientcluster;
+		int leafnum;
+		int c_fullsend;
+		byte clientphs[];
+		byte bitvector[];
+
+		clent = client.edict;
+		if (clent.client == null)
+			return; // not in game yet
+
+		// this is the frame we are creating
+		frame = client.frames[sv.framenum & UPDATE_MASK];
+
+		frame.senttime = svs.realtime; // save it for ping calc later
+
+		// find the client's PVS
+		for (i = 0; i < 3; i++)
+			org[i] = clent.client.ps.pmove.origin[i] * 0.125f + clent.client.ps.viewoffset[i];
+
+		leafnum = CM.CM_PointLeafnum(org);
+		clientarea = CM.CM_LeafArea(leafnum);
+		clientcluster = CM.CM_LeafCluster(leafnum);
+
+		// calculate the visible areas
+		frame.areabytes = CM.CM_WriteAreaBits(frame.areabits, clientarea);
+
+		// grab the current player_state_t
+		frame.ps = clent.client.ps;
+
+		SV_FatPVS(org);
+		clientphs = CM.CM_ClusterPHS(clientcluster);
+
+		// build up the list of visible entities
+		frame.num_entities = 0;
+		frame.first_entity = svs.next_client_entities;
+
+		c_fullsend = 0;
+
+		for (e = 1; e < SV_GAME.ge.num_edicts; e++) {
+			ent = SV_GAME.ge.edicts[e];
+
+			// ignore ents without visible models
+			if ((ent.svflags & SVF_NOCLIENT) != 0)
+				continue;
+
+			// ignore ents without visible models unless they have an effect
+			if (0 == ent.s.modelindex && 0 == ent.s.effects && 0 == ent.s.sound && 0 == ent.s.event)
+				continue;
+
+			// ignore if not touching a PV leaf
+			if (ent != clent) {
+				// check area
+				if (!CM.CM_AreasConnected(clientarea, ent.areanum)) { // doors can legally straddle two areas, so
+					// we may need to check another one
+					if (0 == ent.areanum2 || !CM.CM_AreasConnected(clientarea, ent.areanum2))
+						continue; // blocked by a door
+				}
+
+				// beams just check one point for PHS
+				if ((ent.s.renderfx & RF_BEAM) != 0) {
+					l = ent.clusternums[0];
+					if (0 == (clientphs[l >> 3] & (1 << (l & 7))))
+						continue;
+				}
+				else {
+					// FIXME: if an ent has a model and a sound, but isn't
+					// in the PVS, only the PHS, clear the model
+					if (ent.s.sound == 0) {
+						bitvector = fatpvs; //clientphs;
+					}
+					else
+						bitvector = fatpvs;
+
+					if (ent.num_clusters == -1) { // too many leafs for individual check, go by headnode
+						if (!CM.CM_HeadnodeVisible(ent.headnode, bitvector))
+							continue;
+						c_fullsend++;
+					}
+					else { // check individual leafs
+						for (i = 0; i < ent.num_clusters; i++) {
+							l = ent.clusternums[i];
+							if ((bitvector[l >> 3] & (1 << (l & 7))) != 0)
+								break;
+						}
+						if (i == ent.num_clusters)
+							continue; // not visible
+					}
+
+					if (ent.s.modelindex == 0) { // don't send sounds if they will be attenuated away
+						float[] delta = { 0, 0, 0 };
+						float len;
+
+						VectorSubtract(org, ent.s.origin, delta);
+						len = VectorLength(delta);
+						if (len > 400)
+							continue;
+					}
+				}
+			}
+
+			// add it to the circular client_entities array
+			int ix = svs.next_client_entities % svs.num_client_entities;
+			state = svs.client_entities[ix];
+			if (ent.s.number != e) {
+				Com.DPrintf("FIXING ENT.S.NUMBER!!!\n");
+				ent.s.number = e;
+			}
+
+			//*state = ent.s;
+			svs.client_entities[ix] = ent.s;
+
+			// don't mark players missiles as solid
+			if (ent.owner == client.edict)
+				state.solid = 0;
+
+			svs.next_client_entities++;
+			frame.num_entities++;
+		}
+	}
+
+	/*
+	==================
+	SV_RecordDemoMessage
+	
+	Save everything in the world out without deltas.
+	Used for recording footage for merged or assembled demos
+	==================
+	*/
+	public static void SV_RecordDemoMessage() {
+		int e;
+		edict_t ent;
+		entity_state_t nostate = new entity_state_t(null);
+		sizebuf_t buf = new sizebuf_t();
+		byte buf_data[] = new byte[32768];
+		int len;
+
+		if (svs.demofile == null)
+			return;
+
+		//memset (nostate, 0, sizeof(nostate));
+		SZ.Init(buf, buf_data, buf_data.length);
+
+		// write a frame message that doesn't contain a player_state_t
+		MSG.WriteByte(buf, svc_frame);
+		MSG.WriteLong(buf, sv.framenum);
+
+		MSG.WriteByte(buf, svc_packetentities);
+
+		e = 1;
+		ent = SV_GAME.ge.edicts[e];
+
+		while (e < SV_GAME.ge.num_edicts) {
+			// ignore ents without visible models unless they have an effect
+			if (ent.inuse
+				&& ent.s.number != 0
+				&& (ent.s.modelindex != 0 || ent.s.effects != 0 || ent.s.sound != 0 || ent.s.event != 0)
+				&& 0 == (ent.svflags & SVF_NOCLIENT))
+				MSG.WriteDeltaEntity(nostate, ent.s, buf, false, true);
+
+			e++;
+			ent = SV_GAME.ge.edicts[e];
+		}
+
+		MSG.WriteShort(buf, 0); // end of packetentities
+
+		// now add the accumulated multicast information
+		SZ.Write(buf, svs.demo_multicast.data, svs.demo_multicast.cursize);
+		SZ.Clear(svs.demo_multicast);
+
+		// now write the entire message to the file, prefixed by the length
+		len = EndianHandler.swapInt(buf.cursize);
+		
+		try {
+			//fwrite (len, 4, 1, svs.demofile);
+			svs.demofile.writeInt(len);
+			//fwrite (buf.data, buf.cursize, 1, svs.demofile);
+			svs.demofile.write(buf.data, 0, buf.cursize);
+		}
+		catch (IOException e1) {
+			Com.Printf("Error writing demo file:" + e);
+		}
+	}
+}
diff --git a/src/jake2/server/SV_GAME.java b/src/jake2/server/SV_GAME.java
new file mode 100644
index 0000000..eba5a84
--- /dev/null
+++ b/src/jake2/server/SV_GAME.java
@@ -0,0 +1,356 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 14.01.2004 by RST.
+// $Id: SV_GAME.java,v 1.1 2004-07-07 19:59:47 hzi Exp $
+
+package jake2.server;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.sys.Sys;
+
+public class SV_GAME extends SV_INIT {
+
+	// sv_game.c -- interface to the game dll
+
+	public static game_export_t ge;
+
+	/*
+	===============
+	PF_Unicast
+	
+	Sends the contents of the mutlicast buffer to a single client
+	===============
+	*/
+	public static void PF_Unicast(edict_t ent, boolean reliable) {
+		int p;
+		client_t client;
+
+		if (ent == null)
+			return;
+
+		//p = NUM_FOR_EDICT(ent);
+		p = ent.index;
+		if (p < 1 || p > SV_MAIN.maxclients.value)
+			return;
+
+		client = SV_INIT.svs.clients[p - 1];
+
+		if (reliable)
+			SZ.Write(client.netchan.message, SV_INIT.sv.multicast.data, SV_INIT.sv.multicast.cursize);
+		else
+			SZ.Write(client.datagram, sv.multicast.data, sv.multicast.cursize);
+
+		SZ.Clear(sv.multicast);
+	}
+
+	/*
+	===============
+	PF_dprintf
+	
+	Debug print to server console
+	===============
+	*/
+	public static void PF_dprintf(String fmt) {
+		/*
+		char		msg[1024];
+		va_list		argptr;
+		
+		va_start (argptr,fmt);
+		vsprintf (msg, fmt, argptr);
+		va_end (argptr);
+		
+		*/
+
+		Com.Printf(fmt);
+	}
+
+	/*
+	===============
+	PF_cprintf
+	
+	Print to a single client
+	===============
+	*/
+	public static void PF_cprintf(edict_t ent, int level, String fmt) {
+		//char		msg[1024];
+		//va_list		argptr;
+		int n = 0;
+
+		if (ent != null) {
+
+			//n = NUM_FOR_EDICT(ent);
+			n = ent.index;
+			if (n < 1 || n > SV_MAIN.maxclients.value)
+				Com.Error(ERR_DROP, "cprintf to a non-client");
+		}
+
+		//		va_start (argptr,fmt);
+		//		vsprintf (msg, fmt, argptr);
+		//		va_end (argptr);
+
+		if (ent != null)
+			SV_SEND.SV_ClientPrintf(svs.clients[n - 1], level, fmt);
+		else
+			Com.Printf(fmt);
+	}
+
+	/*
+	===============
+	PF_centerprintf
+	
+	centerprint to a single client
+	===============
+	*/
+	public static void PF_centerprintf(edict_t ent, String fmt) {
+		//char		msg[1024];
+		//va_list		argptr;
+		int n;
+
+		//TODO:  NUM_FOR_EDICT
+		//n = NUM_FOR_EDICT(ent);
+		n = ent.index;
+		if (n < 1 || n > SV_MAIN.maxclients.value)
+			return; // Com_Error (ERR_DROP, "centerprintf to a non-client");
+
+		//		va_start (argptr,fmt);
+		//		vsprintf (msg, fmt, argptr);
+		//		va_end (argptr);
+
+		MSG.WriteByte(sv.multicast, svc_centerprint);
+		MSG.WriteString(sv.multicast, fmt);
+		PF_Unicast(ent, true);
+	}
+
+	/*
+	===============
+	PF_error
+	
+	Abort the server with a game error
+	===============
+	*/
+	public static void PF_error(String fmt) {
+		Com.Error(ERR_DROP, "Game Error: " + fmt);
+	}
+
+	public static void PF_error(int level, String fmt) {
+		Com.Error(level, fmt);
+	}
+
+	/*
+	=================
+	PF_setmodel
+	
+	Also sets mins and maxs for inline bmodels
+	=================
+	*/
+	public static void PF_setmodel(edict_t ent, String name) {
+		int i;
+		cmodel_t mod;
+
+		if (name == null)
+			Com.Error(ERR_DROP, "PF_setmodel: NULL");
+
+		i = SV_ModelIndex(name);
+
+		//	ent.model = name;
+		ent.s.modelindex = i;
+
+		// if it is an inline model, get the size information for it
+		if (name.startsWith("*")) {
+			mod = CM.InlineModel(name);
+			VectorCopy(mod.mins, ent.mins);
+			VectorCopy(mod.maxs, ent.maxs);
+			SV_WORLD.SV_LinkEdict(ent);
+		}
+	}
+
+	/*
+	===============
+	PF_Configstring
+	
+	===============
+	*/
+	public static void PF_Configstring(int index, String val) {
+		if (index < 0 || index >= MAX_CONFIGSTRINGS)
+			Com.Error(ERR_DROP, "configstring: bad index " + index + "\n");
+
+		if (val == null)
+			val = "";
+
+		// change the string in sv
+		sv.configstrings[index] = val;
+
+		if (sv.state != ss_loading) { // send the update to everyone
+			SZ.Clear(sv.multicast);
+			MSG.WriteChar(sv.multicast, svc_configstring);
+			MSG.WriteShort(sv.multicast, index);
+			MSG.WriteString(sv.multicast, val);
+
+			SV_SEND.SV_Multicast(vec3_origin, MULTICAST_ALL_R);
+		}
+	}
+
+	public static void PF_WriteChar(int c) {
+		MSG.WriteChar(sv.multicast, c);
+	}
+	public static void PF_WriteByte(int c) {
+		MSG.WriteByte(sv.multicast, c);
+	}
+	public static void PF_WriteShort(int c) {
+		MSG.WriteShort(sv.multicast, c);
+	}
+	public static void PF_WriteLong(int c) {
+		MSG.WriteLong(sv.multicast, c);
+	}
+	public static void PF_WriteFloat(float f) {
+		MSG.WriteFloat(sv.multicast, f);
+	}
+	public static void PF_WriteString(String s) {
+		MSG.WriteString(sv.multicast, s);
+	}
+	public static void PF_WritePos(float[] pos) {
+		MSG.WritePos(sv.multicast, pos);
+	}
+	public static void PF_WriteDir(float[] dir) {
+		MSG.WriteDir(sv.multicast, dir);
+	}
+	public static void PF_WriteAngle(float f) {
+		MSG.WriteAngle(sv.multicast, f);
+	}
+
+	/*
+	=================
+	PF_inPVS
+	
+	Also checks portalareas so that doors block sight
+	=================
+	*/
+	public static boolean PF_inPVS(float[] p1, float[] p2) {
+		int leafnum;
+		int cluster;
+		int area1, area2;
+		byte mask[];
+
+		leafnum = CM.CM_PointLeafnum(p1);
+		cluster = CM.CM_LeafCluster(leafnum);
+		area1 = CM.CM_LeafArea(leafnum);
+		mask = CM.CM_ClusterPVS(cluster);
+
+		leafnum = CM.CM_PointLeafnum(p2);
+		cluster = CM.CM_LeafCluster(leafnum);
+		area2 = CM.CM_LeafArea(leafnum);
+
+		if (mask != null && (0 == (mask[cluster >> 3] & (1 << (cluster & 7)))))
+			return false;
+
+		if (!CM.CM_AreasConnected(area1, area2))
+			return false; // a door blocks sight
+
+		return true;
+	}
+
+	/*
+	=================
+	PF_inPHS
+	
+	Also checks portalareas so that doors block sound
+	=================
+	*/
+	public static boolean PF_inPHS(float[] p1, float[] p2) {
+		int leafnum;
+		int cluster;
+		int area1, area2;
+		byte mask[];
+
+		leafnum = CM.CM_PointLeafnum(p1);
+		cluster = CM.CM_LeafCluster(leafnum);
+		area1 = CM.CM_LeafArea(leafnum);
+		mask = CM.CM_ClusterPHS(cluster);
+
+		leafnum = CM.CM_PointLeafnum(p2);
+		cluster = CM.CM_LeafCluster(leafnum);
+		area2 = CM.CM_LeafArea(leafnum);
+
+		if (mask != null && (0 == (mask[cluster >> 3] & (1 << (cluster & 7)))))
+			return false; // more than one bounce away
+		if (!CM.CM_AreasConnected(area1, area2))
+			return false; // a door blocks hearing
+
+		return true;
+	}
+
+	public static void PF_StartSound(edict_t entity, int channel, int sound_num, float volume, float attenuation, float timeofs) {
+		if (null == entity)
+			return;
+			
+		//TODO: impl SV_StartSound
+		//SV_SEND.SV_StartSound (null, entity, channel, sound_num, volume, attenuation, timeofs);
+	}
+
+	//==============================================
+
+	/*
+	===============
+	SV_ShutdownGameProgs
+	
+	Called when either the entire server is being killed, or
+	it is changing to a different game directory.
+	===============
+	*/
+	public static void SV_ShutdownGameProgs() {
+		if (ge == null)
+			return;
+		ge.Shutdown();
+		Sys.UnloadGame();
+		ge = null;
+	}
+
+	/*
+	===============
+	SV_InitGameProgs
+	
+	Init the game subsystem for a new map
+	===============
+	*/
+
+	public static void SV_InitGameProgs() {
+
+		// unload anything we have now
+		if (ge != null)
+			SV_ShutdownGameProgs();
+
+		game_import_t gimport = new game_import_t();
+
+		// all functions set in game_export_t (rst) 
+		ge = GameBase.GetGameApi(gimport);
+
+		if (ge == null)
+			Com.Error(ERR_DROP, "failed to load game DLL");
+		if (ge.apiversion != GAME_API_VERSION)
+			Com.Error(ERR_DROP, "game is version " + ge.apiversion + " not " + GAME_API_VERSION);
+
+		ge.Init();
+	}
+}
diff --git a/src/jake2/server/SV_INIT.java b/src/jake2/server/SV_INIT.java
new file mode 100644
index 0000000..021c60c
--- /dev/null
+++ b/src/jake2/server/SV_INIT.java
@@ -0,0 +1,498 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 14.01.2004 by RST.
+// $Id: SV_INIT.java,v 1.1 2004-07-07 19:59:47 hzi Exp $
+
+package jake2.server;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.sys.NET;
+import jake2.util.Lib;
+
+public class SV_INIT extends Globals  {
+
+	public static server_static_t svs = new server_static_t(); // persistant server info
+	public static server_t sv = new server_t(); // local server
+
+	/*
+	================
+	SV_FindIndex
+	
+	================
+	*/
+	public static int SV_FindIndex(String name, int start, int max, boolean create) {
+		int i;
+
+		if (name == null || name.length() == 0)
+			return 0;
+
+		for (i = 1; i < max && sv.configstrings[start + i] != null; i++)
+			if (0 == strcmp(sv.configstrings[start + i], name))
+				return i;
+
+		if (!create)
+			return 0;
+
+		if (i == max)
+			Com.Error(ERR_DROP, "*Index: overflow");
+
+		//strncpy (sv.configstrings[start+i], name, sizeof(sv.configstrings[i]));
+		sv.configstrings[start + i] = name;
+
+		if (sv.state != ss_loading) { // send the update to everyone
+			SZ.Clear(sv.multicast);
+			MSG.WriteChar(sv.multicast, svc_configstring);
+			MSG.WriteShort(sv.multicast, start + i);
+			MSG.WriteString(sv.multicast, name);
+			SV_SEND.SV_Multicast(Game.vec3_origin, MULTICAST_ALL_R);
+		}
+
+		return i;
+	}
+
+	public static int SV_ModelIndex(String name) {
+		return SV_FindIndex(name, CS_MODELS, MAX_MODELS, true);
+	}
+
+	public static int SV_SoundIndex(String name) {
+		return SV_FindIndex(name, CS_SOUNDS, MAX_SOUNDS, true);
+	}
+
+	public static int SV_ImageIndex(String name) {
+		return SV_FindIndex(name, CS_IMAGES, MAX_IMAGES, true);
+	}
+
+	/*
+	================
+	SV_CreateBaseline
+	
+	Entity baselines are used to compress the update messages
+	to the clients -- only the fields that differ from the
+	baseline will be transmitted
+	================
+	*/
+	public static void SV_CreateBaseline() {
+		edict_t svent;
+		int entnum;
+
+		for (entnum = 1; entnum < SV_GAME.ge.num_edicts; entnum++) {
+			//svent = EDICT_NUM(entnum);
+			svent = SV_GAME.ge.edicts[entnum];
+
+			if (!svent.inuse)
+				continue;
+			if (0 == svent.s.modelindex && 0 == svent.s.sound && 0 == svent.s.effects)
+				continue;
+			svent.s.number = entnum;
+
+			//
+			// take current state as baseline
+			//
+			VectorCopy(svent.s.origin, svent.s.old_origin);
+			// rst: bugfix
+			sv.baselines[entnum] = svent.s.getClone();
+		}
+	}
+
+	/*
+	=================
+	SV_CheckForSavegame
+	=================
+	*/
+	public static void SV_CheckForSavegame() {
+		//char		name[MAX_OSPATH];
+		String name;
+		//FILE		*f;
+		RandomAccessFile f;
+
+		int i;
+
+		if (SV_MAIN.sv_noreload.value != 0)
+			return;
+
+		if (Cvar.VariableValue("deathmatch") != 0)
+			return;
+
+		name = FS.Gamedir() + "/save/current/" + sv.name + ".sav";
+		try {
+			f = new RandomAccessFile(name, "r");
+		}
+
+		catch (Exception e) {
+			return; // no savegame
+		}
+
+		try {
+			f.close();
+		}
+		catch (IOException e1) {
+			e1.printStackTrace();
+		}
+
+		SV_WORLD.SV_ClearWorld();
+
+		// get configstrings and areaportals
+		SV_CCMDS.SV_ReadLevelFile();
+
+		if (!sv.loadgame) { // coming back to a level after being in a different
+			// level, so run it for ten seconds
+
+			// rlava2 was sending too many lightstyles, and overflowing the
+			// reliable data. temporarily changing the server state to loading
+			// prevents these from being passed down.
+			int previousState; // PGM
+
+			previousState = sv.state; // PGM
+			sv.state = ss_loading; // PGM
+			for (i = 0; i < 100; i++)
+				SV_GAME.ge.RunFrame();
+
+			sv.state = previousState; // PGM
+		}
+	}
+
+	/*
+	================
+	SV_SpawnServer
+	
+	Change the server to a new map, taking all connected
+	clients along with it.
+	
+	================
+	*/
+	public static void SV_SpawnServer(
+		String server,
+		String spawnpoint,
+		int serverstate,
+		boolean attractloop,
+		boolean loadgame) {
+		int i;
+		int checksum = 0;
+
+		if (attractloop)
+			Cvar.Set("paused", "0");
+
+		Com.Printf("------- Server Initialization -------\n");
+
+		Com.DPrintf("SpawnServer: " + server + "\n");
+		if (sv.demofile != null)
+			try {
+				sv.demofile.close();
+			}
+			catch (Exception e) {
+			}
+
+		svs.spawncount++; // any partially connected client will be
+		// restarted
+		sv.state = ss_dead;
+		
+		Com.SetServerState(sv.state);
+
+		// wipe the entire per-level structure
+		//memset(sv, 0, sizeof(sv));
+		sv = new server_t();
+		
+		svs.realtime = 0;
+		sv.loadgame = loadgame;
+		sv.attractloop = attractloop;
+
+		// save name for levels that don't set message
+		sv.configstrings[CS_NAME]= server;
+		
+		if (Cvar.VariableValue("deathmatch")!=0) {
+			sv.configstrings[CS_AIRACCEL] = ""+SV_MAIN.sv_airaccelerate.value;
+			PMove.pm_airaccelerate = SV_MAIN.sv_airaccelerate.value;
+		}
+		else {
+			sv.configstrings[CS_AIRACCEL] = "0";
+			PMove.pm_airaccelerate = 0;
+		}
+
+		SZ.Init(sv.multicast, sv.multicast_buf, sv.multicast_buf.length);
+
+		sv.name = server;
+
+		// leave slots at start for clients only
+		for (i = 0; i < SV_MAIN.maxclients.value; i++) {
+			// needs to reconnect
+			if (svs.clients[i].state > cs_connected)
+				svs.clients[i].state = cs_connected;
+			svs.clients[i].lastframe = -1;
+		}
+
+		sv.time = 1000;
+
+		sv.name=server;
+		sv.configstrings[CS_NAME] = server;
+		
+		CM.intwrap checksum_iw = new CM.intwrap(checksum);
+
+		if (serverstate != ss_game) {
+			sv.models[1] = CM.CM_LoadMap("", false, checksum_iw); // no real map
+		}
+		else {
+			sv.configstrings[CS_MODELS + 1] = "maps/" + server + ".bsp";
+			sv.models[1] = CM.CM_LoadMap(sv.configstrings[CS_MODELS + 1], false, checksum_iw);
+		}
+		checksum = checksum_iw.i;
+		sv.configstrings[CS_MAPCHECKSUM] = "" + checksum;
+
+		//
+		// clear physics interaction links
+		//
+		SV_WORLD.SV_ClearWorld();
+
+		for (i = 1; i < CM.CM_NumInlineModels(); i++) {
+			sv.configstrings[CS_MODELS + 1 + i] = "*" + i;
+			// copy references
+			sv.models[i + 1] = CM.InlineModel(sv.configstrings[CS_MODELS + 1 + i]);
+		}
+
+		//
+		// spawn the rest of the entities on the map
+		//	
+
+		// precache and static commands can be issued during
+		// map initialization
+		sv.state = ss_loading;
+		Com.SetServerState(sv.state);
+
+		// load and spawn all other entities
+		SV_GAME.ge.SpawnEntities(sv.name, CM.CM_EntityString(), spawnpoint);
+
+		// run two frames to allow everything to settle
+		SV_GAME.ge.RunFrame();
+		SV_GAME.ge.RunFrame();
+
+		// all precaches are complete
+		sv.state = serverstate;
+		Com.SetServerState(sv.state);
+
+		// create a baseline for more efficient communications
+		SV_CreateBaseline();
+
+		// check for a savegame
+		SV_CheckForSavegame();
+
+		// set serverinfo variable
+		Cvar.FullSet("mapname", sv.name, CVAR_SERVERINFO | CVAR_NOSET);
+
+		Com.Printf("-------------------------------------\n");
+	}
+
+	/*
+	==============
+	SV_InitGame
+	
+	A brand new game has been started
+	==============
+	*/
+	public static void SV_InitGame() {
+		int i;
+		edict_t  ent;
+		//char idmaster[32];
+		String idmaster;
+
+		if (svs.initialized) {
+			// cause any connected clients to reconnect
+			SV_MAIN.SV_Shutdown("Server restarted\n", true);
+		}
+		else {
+			// make sure the client is down
+			CL.Drop();
+			SCR.BeginLoadingPlaque();
+		}
+
+		// get any latched variable changes (maxclients, etc)
+		Cvar.GetLatchedVars();
+
+		svs.initialized = true;
+
+		if (Cvar.VariableValue("coop")!=0 && Cvar.VariableValue("deathmatch")!=0) {
+			Com.Printf("Deathmatch and Coop both set, disabling Coop\n");
+			Cvar.FullSet("coop", "0", CVAR_SERVERINFO | CVAR_LATCH);
+		}
+
+		// dedicated servers are can't be single player and are usually DM
+		// so unless they explicity set coop, force it to deathmatch
+		if (dedicated.value!=0) {
+			if (0==Cvar.VariableValue("coop"))
+				Cvar.FullSet("deathmatch", "1", CVAR_SERVERINFO | CVAR_LATCH);
+		}
+
+		// init clients
+		if (Cvar.VariableValue("deathmatch")!=0) {
+			if (SV_MAIN.maxclients.value <= 1)
+				Cvar.FullSet("maxclients", "8", CVAR_SERVERINFO | CVAR_LATCH);
+			else if (SV_MAIN.maxclients.value > MAX_CLIENTS)
+				Cvar.FullSet("maxclients", "" +  MAX_CLIENTS, CVAR_SERVERINFO | CVAR_LATCH);
+		}
+		else if (Cvar.VariableValue("coop")!=0) {
+			if (SV_MAIN.maxclients.value <= 1 || SV_MAIN.maxclients.value > 4)
+				Cvar.FullSet("maxclients", "4", CVAR_SERVERINFO | CVAR_LATCH);
+
+		}
+		else // non-deathmatch, non-coop is one player
+			{
+			Cvar.FullSet("maxclients", "1", CVAR_SERVERINFO | CVAR_LATCH);
+		}
+
+		svs.spawncount = rand();
+		//svs.clients = Z_Malloc(sizeof(client_t) * maxclients.value);
+		svs.clients = new client_t[(int) SV_MAIN.maxclients.value];
+		for (int n=0; n < svs.clients.length; n++)
+			svs.clients[n]= new client_t();
+		
+		svs.num_client_entities = ((int) SV_MAIN.maxclients.value) * UPDATE_BACKUP * 64; //ok.
+		
+		//svs.client_entities = Z_Malloc(sizeof(entity_state_t) * svs.num_client_entities);
+		svs.client_entities = new entity_state_t[svs.num_client_entities];
+		for (int n=0; n < svs.client_entities.length; n++)
+			svs.client_entities[n] = new entity_state_t(null);
+
+		// init network stuff
+		NET.Config((SV_MAIN.maxclients.value > 1)); //ok!
+
+		// heartbeats will always be sent to the id master
+		svs.last_heartbeat = -99999; // send immediately
+		idmaster =  "192.246.40.37:" +  PORT_MASTER;
+		NET.StringToAdr(idmaster, SV_MAIN.master_adr[0]);
+
+		// init game
+		SV_GAME.SV_InitGameProgs(); // bis hier alles ok!
+		
+		for (i = 0; i < SV_MAIN.maxclients.value; i++) {
+			ent = SV_GAME.ge.edicts[i + 1];
+			
+			//ent.s.number = i + 1;	//dont need this, ent.s.number already set.
+			svs.clients[i].edict = ent;
+			//memset(& svs.clients[i].lastcmd, 0, sizeof(svs.clients[i].lastcmd));
+			svs.clients[i].lastcmd = new usercmd_t();
+		}
+	}
+
+	/*
+	======================
+	SV_Map
+	
+	  the full syntax is:
+	
+	  map [*]<map>$<startspot>+<nextserver>
+	
+	command from the console or progs.
+	Map can also be a.cin, .pcx, or .dm2 file
+	Nextserver is used to allow a cinematic to play, then proceed to
+	another level:
+	
+		map tram.cin+jail_e3
+	======================
+	*/
+	public static void SV_Map(boolean attractloop, String levelstring, boolean loadgame) {
+		//char	level[MAX_QPATH];
+		//char	*ch;
+		int l;
+		//char	spawnpoint[MAX_QPATH];
+
+		String level, ch, spawnpoint;
+
+		sv.loadgame = loadgame;
+		sv.attractloop = attractloop;
+
+		if (sv.state == ss_dead && !sv.loadgame)
+			SV_InitGame(); // the game is just starting
+
+		level = levelstring;	// bis hier her ok.
+
+		// if there is a + in the map, set nextserver to the remainder
+
+		//was:
+		//	ch = strstr(level, "+");
+		//	if (ch)
+		//	{
+		//		*ch = 0;
+		//			Cvar_Set ("nextserver", va("gamemap \"%s\"", ch+1));
+		//	}
+		//	else
+		//		Cvar_Set ("nextserver", "");
+
+		int c = level.indexOf('+');
+		if (c != -1) {
+			Cvar.Set("nextserver","gamemap \"" + level.substring(c+1) + "\"");
+			level = level.substring(0, c);
+		}
+		else {
+			Cvar.Set("nextserver", "");
+		}
+
+		//ZOID special hack for end game screen in coop mode
+		if (Cvar.VariableValue("coop")!=0 && !level.equals( "victory.pcx"))
+			Cvar.Set("nextserver", "gamemap \"*base1\"");
+
+		// if there is a $, use the remainder as a spawnpoint
+		int pos = level.indexOf('$');
+		if (pos!=-1) {
+			//* ch = 0;
+			spawnpoint = level.substring(pos + 1);
+			level = level.substring(0,pos);			
+			
+		}
+		else
+			//spawnpoint[0] = 0;
+			spawnpoint = "";
+
+		// skip the end-of-unit flag if necessary
+		if (level.charAt(0) == '*')
+			level = level.substring(1);
+
+		l = strlen(level);
+		if (l > 4 && level.endsWith(".cin")) {
+			SCR.BeginLoadingPlaque(); // for local system
+			SV_SEND.SV_BroadcastCommand("changing\n");
+			SV_SpawnServer(level, spawnpoint, ss_cinematic, attractloop, loadgame);
+		}
+		else if (l > 4 && level.endsWith(".dm2")) {
+			SCR.BeginLoadingPlaque(); // for local system
+			SV_SEND.SV_BroadcastCommand("changing\n");
+			SV_SpawnServer(level, spawnpoint, ss_demo, attractloop, loadgame);
+		}
+		else if (l > 4 && level.endsWith(".pcx")) {
+			SCR.BeginLoadingPlaque(); // for local system
+			SV_SEND.SV_BroadcastCommand("changing\n");
+			SV_SpawnServer(level, spawnpoint, ss_pic, attractloop, loadgame);
+		}
+		else {
+			SCR.BeginLoadingPlaque(); // for local system
+			SV_SEND.SV_BroadcastCommand("changing\n");
+			SV_SEND.SV_SendClientMessages();
+			SV_SpawnServer(level, spawnpoint, ss_game, attractloop, loadgame);
+			Cbuf.CopyToDefer();
+		}
+
+		SV_SEND.SV_BroadcastCommand("reconnect\n");
+	}
+}
diff --git a/src/jake2/server/SV_MAIN.java b/src/jake2/server/SV_MAIN.java
new file mode 100644
index 0000000..e3059ec
--- /dev/null
+++ b/src/jake2/server/SV_MAIN.java
@@ -0,0 +1,1030 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 13.01.2004 by RST.
+// $Id: SV_MAIN.java,v 1.1 2004-07-07 19:59:49 hzi Exp $
+
+package jake2.server;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.sys.NET;
+import jake2.sys.Sys;
+import jake2.util.Lib;
+
+public class SV_MAIN extends SV_GAME {
+
+	static netadr_t master_adr[] = new netadr_t[MAX_MASTERS]; // address of group servers
+	static {
+		for (int i = 0; i < MAX_MASTERS; i++) {
+			master_adr[i] = new netadr_t();
+		}
+	}
+	public static client_t sv_client; // current client
+
+	public static cvar_t sv_paused;
+	public static cvar_t sv_timedemo;
+
+	public static cvar_t sv_enforcetime;
+
+	public static cvar_t timeout; // seconds without any message
+	public static cvar_t zombietime; // seconds to sink messages after disconnect
+
+	public static cvar_t rcon_password; // password for remote server commands
+
+	public static cvar_t allow_download;
+	public static cvar_t allow_download_players;
+	public static cvar_t allow_download_models;
+	public static cvar_t allow_download_sounds;
+	public static cvar_t allow_download_maps;
+
+	public static cvar_t sv_airaccelerate;
+
+	public static cvar_t sv_noreload; // don't reload level state when reentering
+
+	public static cvar_t maxclients; // FIXME: rename sv_maxclients
+	public static cvar_t sv_showclamp;
+
+	public static cvar_t hostname;
+	public static cvar_t public_server; // should heartbeats be sent
+
+	public static cvar_t sv_reconnect_limit; // minimum seconds between connect messages
+
+	//============================================================================
+
+	/*
+	=====================
+	SV_DropClient
+	
+	Called when the player is totally leaving the server, either willingly
+	or unwillingly.  This is NOT called if the entire server is quiting
+	or crashing.
+	=====================
+	*/
+	public static void SV_DropClient(client_t drop) {
+		// add the disconnect
+		MSG.WriteByte(drop.netchan.message, Defines.svc_disconnect);
+
+		if (drop.state == Defines.cs_spawned) {
+			// call the prog function for removing a client
+			// this will remove the body, among other things
+			SV_GAME.ge.ClientDisconnect(drop.edict);
+		}
+
+		if (drop.download != null) {
+			FS.FreeFile(drop.download);
+			drop.download = null;
+		}
+
+		drop.state = Defines.cs_zombie; // become free in a few seconds
+		drop.name = "";
+	}
+
+	/*
+	==============================================================================
+	
+	CONNECTIONLESS COMMANDS
+	
+	==============================================================================
+	*/
+
+	/*
+	===============
+	SV_StatusString
+	
+	Builds the string that is sent as heartbeats and status replies
+	===============
+	*/
+	public static String SV_StatusString() {
+		String player;
+		String status = "";
+		int i;
+		client_t cl;
+		int statusLength;
+		int playerLength;
+
+		status = Cvar.Serverinfo() + "\n";
+
+		for (i = 0; i < maxclients.value; i++) {
+			cl = svs.clients[i];
+			if (cl.state == Defines.cs_connected || cl.state == Defines.cs_spawned) {
+				player = "" + cl.edict.client.ps.stats[Defines.STAT_FRAGS] + " " + cl.ping + "\"" + cl.name + "\"\n";
+
+				playerLength = player.length();
+				statusLength = status.length();
+
+				if (statusLength + playerLength >= 1024)
+					break; // can't hold any more
+
+				status += player;
+			}
+		}
+
+		return status;
+	}
+
+	/*
+	================
+	SVC_Status
+	
+	Responds with all the info that qplug or qspy can see
+	================
+	*/
+	public static void SVC_Status() {
+		Netchan.OutOfBandPrint(NS_SERVER, Netchan.net_from, "print\n" + SV_StatusString());
+	}
+
+	/*
+	================
+	SVC_Ack
+	
+	================
+	*/
+	public static void SVC_Ack() {
+		Com.Printf("Ping acknowledge from " + NET.AdrToString(Netchan.net_from) + "\n");
+	}
+
+	/*
+	================
+	SVC_Info
+	
+	Responds with short info for broadcast scans
+	The second parameter should be the current protocol version number.
+	================
+	*/
+	public static void SVC_Info() {
+		String string;
+		int i, count;
+		int version;
+
+		if (maxclients.value == 1)
+			return; // ignore in single player
+
+		version = atoi(Cmd.Argv(1));
+
+		if (version != PROTOCOL_VERSION)
+			string = hostname.string + ": wrong version\n";
+		else {
+			count = 0;
+			for (i = 0; i < maxclients.value; i++)
+				if (svs.clients[i].state >= cs_connected)
+					count++;
+
+			string = hostname.string + " " + sv.name + " " + count + "/" + (int) maxclients.value + "\n";
+		}
+
+		Netchan.OutOfBandPrint(NS_SERVER, Netchan.net_from, "info\n" + string);
+	}
+
+	/*
+	================
+	SVC_Ping
+	
+	Just responds with an acknowledgement
+	================
+	*/
+	public static void SVC_Ping() {
+		Netchan.OutOfBandPrint(NS_SERVER, Netchan.net_from, "ack");
+	}
+
+	/*
+	=================
+	SVC_GetChallenge
+	
+	Returns a challenge number that can be used
+	in a subsequent client_connect command.
+	We do this to prevent denial of service attacks that
+	flood the server with invalid connection IPs.  With a
+	challenge, they must give a valid IP address.
+	=================
+	*/
+	public static void SVC_GetChallenge() {
+		int i;
+		int oldest;
+		int oldestTime;
+
+		oldest = 0;
+		oldestTime = 0x7fffffff;
+
+		// see if we already have a challenge for this ip
+		for (i = 0; i < MAX_CHALLENGES; i++) {
+			if (NET.NET_CompareBaseAdr(Netchan.net_from, svs.challenges[i].adr))
+				break;
+			if (svs.challenges[i].time < oldestTime) {
+				oldestTime = svs.challenges[i].time;
+				oldest = i;
+			}
+		}
+
+		if (i == MAX_CHALLENGES) {
+			// overwrite the oldest
+			svs.challenges[oldest].challenge = rand() & 0x7fff;
+			svs.challenges[oldest].adr = Netchan.net_from;
+			svs.challenges[oldest].time = (int) Globals.curtime;
+			i = oldest;
+		}
+
+		// send it back
+		Netchan.OutOfBandPrint(NS_SERVER, Netchan.net_from, "challenge " + svs.challenges[i].challenge);
+	}
+
+	/*
+	==================
+	SVC_DirectConnect
+	
+	A connection request that did not come from the master
+	==================
+	*/
+	public static void SVC_DirectConnect() {
+		//char		userinfo[MAX_INFO_STRING];
+		String userinfo;
+		netadr_t adr;
+		int i;
+		client_t cl;
+		
+		edict_t ent;
+		int edictnum;
+		int version;
+		int qport;
+
+		adr = Netchan.net_from;
+
+		Com.DPrintf("SVC_DirectConnect ()\n");
+
+		version = atoi(Cmd.Argv(1));
+		if (version != PROTOCOL_VERSION) {
+			Netchan.OutOfBandPrint(NS_SERVER, adr, "print\nServer is version " + VERSION + "\n");
+			Com.DPrintf("    rejected connect from version " + version + "\n");
+			return;
+		}
+
+		qport = atoi(Cmd.Argv(2));
+		int challenge = atoi(Cmd.Argv(3));
+		userinfo = Cmd.Argv(4);
+
+		//userinfo[sizeof(userinfo) - 1] = 0;
+
+		// force the IP key/value pair so the game can filter based on ip
+		userinfo = Info.Info_SetValueForKey1(userinfo, "ip", NET.AdrToString(Netchan.net_from));
+
+		// attractloop servers are ONLY for local clients
+		if (sv.attractloop) {
+			if (!NET.IsLocalAddress(adr)) {
+				Com.Printf("Remote connect in attract loop.  Ignored.\n");
+				Netchan.OutOfBandPrint(NS_SERVER, adr, "print\nConnection refused.\n");
+				return;
+			}
+		}
+
+		// see if the challenge is valid
+		if (!NET.IsLocalAddress(adr)) {
+			for (i = 0; i < MAX_CHALLENGES; i++) {
+				if (NET.NET_CompareBaseAdr(Netchan.net_from, svs.challenges[i].adr)) {
+					if (challenge == svs.challenges[i].challenge)
+						break; // good
+					Netchan.OutOfBandPrint(NS_SERVER, adr, "print\nBad challenge.\n");
+					return;
+				}
+			}
+			if (i == MAX_CHALLENGES) {
+				Netchan.OutOfBandPrint(NS_SERVER, adr, "print\nNo challenge for address.\n");
+				return;
+			}
+		}
+
+		//newcl = temp;
+		//memset (newcl, 0, sizeof(client_t));
+		//newcl = new client_t();
+
+		// if there is already a slot for this ip, reuse it
+		for (i = 0; i < maxclients.value; i++) {
+			cl = svs.clients[i];
+
+			if (cl.state == cs_free)
+				continue;
+			if (NET.NET_CompareBaseAdr(adr, cl.netchan.remote_address)
+				&& (cl.netchan.qport == qport || adr.port == cl.netchan.remote_address.port)) {
+				if (!NET.IsLocalAddress(adr) && (svs.realtime - cl.lastconnect) < ((int) sv_reconnect_limit.value * 1000)) {
+					Com.DPrintf(NET.AdrToString(adr) + ":reconnect rejected : too soon\n");
+					return;
+				}
+				Com.Printf(NET.AdrToString(adr) + ":reconnect\n");
+
+				gotnewcl(i, challenge, userinfo, adr, qport);
+				return;
+			}
+		}
+
+		// find a client slot
+		//newcl = null;
+		int index = -1;
+		for (i = 0; i < maxclients.value; i++) {
+			cl = svs.clients[i];
+			if (cl.state == cs_free) {
+				index = i;
+				break;
+			}
+		}
+		if (index == -1) {
+			Netchan.OutOfBandPrint(NS_SERVER, adr, "print\nServer is full.\n");
+			Com.DPrintf("Rejected a connection.\n");
+			return;
+		}
+		gotnewcl(index, challenge, userinfo, adr, qport);
+	}
+
+	public static void gotnewcl(int i, int challenge, String userinfo, netadr_t adr, int qport) {
+		// build a new connection
+		// accept the new client
+		// this is the only place a client_t is ever initialized
+		//*newcl = temp;
+
+		sv_client = svs.clients[i];
+		//edictnum = (newcl-svs.clients)+1;
+		int edictnum = i + 1;
+		edict_t ent = ge.edicts[edictnum];
+		svs.clients[i].edict = ent;
+		svs.clients[i].challenge = challenge; // save challenge for checksumming
+
+		// get the game a chance to reject this connection or modify the userinfo
+		if (!(ge.ClientConnect(ent, userinfo))) {
+			if (Info.Info_ValueForKey(userinfo, "rejmsg") != null)
+				Netchan.OutOfBandPrint(
+					NS_SERVER,
+					adr,
+					"print\n" + Info.Info_ValueForKey(userinfo, "rejmsg") + "\nConnection refused.\n");
+			else
+				Netchan.OutOfBandPrint(NS_SERVER, adr, "print\nConnection refused.\n");
+			Com.DPrintf("Game rejected a connection.\n");
+			return;
+		}
+
+		// parse some info from the info strings
+		svs.clients[i].userinfo = userinfo;
+		SV_UserinfoChanged(svs.clients[i]);
+
+		// send the connect packet to the client
+		Netchan.OutOfBandPrint(NS_SERVER, adr, "client_connect");
+
+		Netchan.Setup(NS_SERVER, svs.clients[i].netchan, adr, qport);
+
+		svs.clients[i].state = cs_connected;
+
+		SZ.Init(svs.clients[i].datagram, svs.clients[i].datagram_buf, svs.clients[i].datagram_buf.length);
+		svs.clients[i].datagram.allowoverflow = true;
+		svs.clients[i].lastmessage = svs.realtime; // don't timeout
+		svs.clients[i].lastconnect = svs.realtime;
+		Com.DPrintf("new client added.\n");
+	}
+
+	public static int Rcon_Validate() {
+		if (0 == strlen(rcon_password.string))
+			return 0;
+
+		if (0 != strcmp(Cmd.Argv(1), rcon_password.string))
+			return 0;
+
+		return 1;
+	}
+
+	/*
+	===============
+	SVC_RemoteCommand
+	
+	A client issued an rcon command.
+	Shift down the remaining args
+	Redirect all printfs
+	===============
+	*/
+	public static void SVC_RemoteCommand() {
+		int i;
+		//char		remaining[1024];
+		String remaining;
+
+		i = Rcon_Validate();
+
+		String msg = new String(net_message.data, 4, -1);
+
+		if (i == 0)
+			Com.Printf("Bad rcon from " + NET.AdrToString(Netchan.net_from) + ":\n" + msg + "\n");
+		else
+			Com.Printf("Rcon from " + NET.AdrToString(Netchan.net_from) + ":\n" + msg + "\n");
+
+		Com.BeginRedirect(RD_PACKET, SV_SEND.sv_outputbuf, SV_OUTPUTBUF_LENGTH, new Com.RD_Flusher() {
+			public void rd_flush(int target, byte[] buffer) {
+				SV_SEND.SV_FlushRedirect(target, buffer);
+			}
+		});
+
+		if (0 == Rcon_Validate()) {
+			Com.Printf("Bad rcon_password.\n");
+		}
+		else {
+			remaining = "";
+
+			for (i = 2; i < Cmd.Argc(); i++) {
+				strcat(remaining, Cmd.Argv(i));
+				strcat(remaining, " ");
+			}
+
+			Cmd.ExecuteString(remaining);
+		}
+
+		Com.EndRedirect();
+	}
+
+	/*
+	=================
+	SV_ConnectionlessPacket
+	
+	A connectionless packet has four leading 0xff
+	characters to distinguish it from a game channel.
+	Clients that are in the game can still send
+	connectionless packets.
+	=================
+	*/
+	public static void SV_ConnectionlessPacket() {
+		String s;
+		String c;
+
+		MSG.BeginReading(net_message);
+		MSG.ReadLong(net_message); // skip the -1 marker
+
+		s = MSG.ReadStringLine(net_message);
+
+		Cmd.TokenizeString(s.toCharArray(), false);
+
+		c = Cmd.Argv(0);
+		Com.Printf("Packet " + NET.AdrToString(Netchan.net_from) + " : " + c + "\n");
+		//Com.Printf(Lib.hexDump(net_message.data, 64, false) + "\n");
+
+		if (0 == strcmp(c, "ping"))
+			SVC_Ping();
+		else if (0 == strcmp(c, "ack"))
+			SVC_Ack();
+		else if (0 == strcmp(c, "status"))
+			SVC_Status();
+		else if (0 == strcmp(c, "info"))
+			SVC_Info();
+		else if (0 == strcmp(c, "getchallenge"))
+			SVC_GetChallenge();
+		else if (0 == strcmp(c, "connect"))
+			SVC_DirectConnect();
+		else if (0 == strcmp(c, "rcon"))
+			SVC_RemoteCommand();
+		else
+		{
+			Com.Printf("bad connectionless packet from " + NET.AdrToString(Netchan.net_from) + "\n");
+			Com.Printf("[" + s + "]\n");
+			Com.Printf("" + Lib.hexDump(net_message.data, 128, false));
+		}
+	}
+
+	//============================================================================
+
+	/*
+	===================
+	SV_CalcPings
+	
+	Updates the cl.ping variables
+	===================
+	*/
+	public static void SV_CalcPings() {
+		int i, j;
+		client_t cl;
+		int total, count;
+
+		for (i = 0; i < maxclients.value; i++) {
+			cl = svs.clients[i];
+			if (cl.state != cs_spawned)
+				continue;
+
+			total = 0;
+			count = 0;
+			for (j = 0; j < LATENCY_COUNTS; j++) {
+				if (cl.frame_latency[j] > 0) {
+					count++;
+					total += cl.frame_latency[j];
+				}
+			}
+			if (0 == count)
+				cl.ping = 0;
+			else
+				cl.ping = total / count;
+
+			// let the game dll know about the ping
+			cl.edict.client.ping = cl.ping;
+		}
+	}
+
+	/*
+	===================
+	SV_GiveMsec
+	
+	Every few frames, gives all clients an allotment of milliseconds
+	for their command moves.  If they exceed it, assume cheating.
+	===================
+	*/
+	public static void SV_GiveMsec() {
+		int i;
+		client_t cl;
+
+		if ((sv.framenum & 15) != 0)
+			return;
+
+		for (i = 0; i < maxclients.value; i++) {
+			cl = svs.clients[i];
+			if (cl.state == cs_free)
+				continue;
+
+			cl.commandMsec = 1800; // 1600 + some slop
+		}
+	}
+
+	/*
+	=================
+	SV_ReadPackets
+	=================
+	*/
+	public static void SV_ReadPackets() {
+		int i;
+		client_t cl;
+		int qport =0;
+
+		while (NET.GetPacket(NS_SERVER, Netchan.net_from, net_message)) {
+
+			// check for connectionless packet (0xffffffff) first
+			if ((net_message.data[0] == -1)
+				&& (net_message.data[1] == -1)
+				&& (net_message.data[2] == -1)
+				&& (net_message.data[3] == -1)) {
+				SV_ConnectionlessPacket();
+				continue;
+			}
+
+			// read the qport out of the message so we can fix up
+			// stupid address translating routers
+			MSG.BeginReading(net_message);
+			MSG.ReadLong(net_message); // sequence number
+			MSG.ReadLong(net_message); // sequence number
+			qport = MSG.ReadShort(net_message) & 0xffff;
+
+			// check for packets from connected clients
+			for (i = 0; i < maxclients.value; i++) {
+				cl = svs.clients[i];
+				if (cl.state == cs_free)
+					continue;
+				if (!NET.NET_CompareBaseAdr(Netchan.net_from, cl.netchan.remote_address))
+					continue;
+				if (cl.netchan.qport != qport)
+					continue;
+				if (cl.netchan.remote_address.port != Netchan.net_from.port) {
+					Com.Printf("SV_ReadPackets: fixing up a translated port\n");
+					cl.netchan.remote_address.port = Netchan.net_from.port;
+				}
+
+				if (Netchan.Process(cl.netchan, net_message)) { // this is a valid, sequenced packet, so process it
+					if (cl.state != cs_zombie) {
+						cl.lastmessage = svs.realtime; // don't timeout
+						SV_USER.SV_ExecuteClientMessage(cl);
+					}
+				}
+				break;
+			}
+
+			if (i != maxclients.value)
+				continue;
+		}
+	}
+
+	/*
+	==================
+	SV_CheckTimeouts
+	
+	If a packet has not been received from a client for timeout.value
+	seconds, drop the conneciton.  Server frames are used instead of
+	realtime to avoid dropping the local client while debugging.
+	
+	When a client is normally dropped, the client_t goes into a zombie state
+	for a few seconds to make sure any final reliable message gets resent
+	if necessary
+	==================
+	*/
+	public static void SV_CheckTimeouts() {
+		int i;
+		client_t cl;
+		int droppoint;
+		int zombiepoint;
+
+		droppoint = (int) (svs.realtime - 1000 * timeout.value);
+		zombiepoint = (int) (svs.realtime - 1000 * zombietime.value);
+
+		for (i = 0; i < maxclients.value; i++) {
+			cl = svs.clients[i];
+			// message times may be wrong across a changelevel
+			if (cl.lastmessage > svs.realtime)
+				cl.lastmessage = svs.realtime;
+
+			if (cl.state == cs_zombie && cl.lastmessage < zombiepoint) {
+				cl.state = cs_free; // can now be reused
+				continue;
+			}
+			if ((cl.state == cs_connected || cl.state == cs_spawned) && cl.lastmessage < droppoint) {
+				SV_SEND.SV_BroadcastPrintf(PRINT_HIGH, cl.name + " timed out\n");
+				SV_DropClient(cl);
+				cl.state = cs_free; // don't bother with zombie state
+			}
+		}
+	}
+
+	/*
+	================
+	SV_PrepWorldFrame
+	
+	This has to be done before the world logic, because
+	player processing happens outside RunWorldFrame
+	================
+	*/
+	public static void SV_PrepWorldFrame() {
+		edict_t ent;
+		int i;
+
+		for (i = 0; i < ge.num_edicts; i++) {
+			ent = SV_GAME.ge.edicts[i];
+			// events only last for a single message
+			ent.s.event = 0;
+		}
+
+	}
+
+	/*
+	=================
+	SV_RunGameFrame
+	=================
+	*/
+	public static void SV_RunGameFrame() {
+		if (host_speeds.value != 0)
+			time_before_game = Sys.Milliseconds();
+
+		// we always need to bump framenum, even if we
+		// don't run the world, otherwise the delta
+		// compression can get confused when a client
+		// has the "current" frame
+		sv.framenum++;
+		sv.time = sv.framenum * 100;
+
+		// don't run if paused
+		if (0 == sv_paused.value || maxclients.value > 1) {
+			ge.RunFrame();
+
+			// never get more than one tic behind
+			if (sv.time < svs.realtime) {
+				//if (sv_showclamp.value != 0)
+					Com.Printf("sv highclamp\n");
+				svs.realtime = sv.time;
+			}
+		}
+
+		if (host_speeds.value != 0)
+			time_after_game = Sys.Milliseconds();
+
+	}
+
+	/*
+	==================
+	SV_Frame
+	
+	==================
+	*/
+	public static void SV_Frame(long msec) {
+		Globals.time_before_game = Globals.time_after_game = 0;
+
+		// if server is not active, do nothing
+		if (!svs.initialized)
+			return;
+
+		svs.realtime += msec;
+
+		// keep the random time dependent
+		Lib.rand();
+
+		// check timeouts
+		SV_CheckTimeouts();
+
+		// get packets from clients
+		SV_ReadPackets();
+		
+		//if (Game.g_edicts[1] !=null)
+		//	Com.p("player at:" + Lib.vtofsbeaty(Game.g_edicts[1].s.origin  ));
+
+		// move autonomous things around if enough time has passed
+		if (0== sv_timedemo.value && svs.realtime < sv.time) {
+			// never let the time get too far off
+			if (sv.time - svs.realtime > 100) {
+				//if (sv_showclamp.value != 0)
+					Com.Printf("sv lowclamp\n");
+				svs.realtime = sv.time - 100;
+			}
+			NET.NET_Sleep(sv.time - svs.realtime);
+			return;
+		}
+
+		// update ping based on the last known frame from all clients
+		//TODO: dont need yet
+		SV_CalcPings();
+
+		// give the clients some timeslices
+		//TODO: dont need yet
+		SV_GiveMsec();
+
+		// let everything in the world think and move
+		SV_RunGameFrame();
+
+		// send messages back to the clients that had packets read this frame
+		SV_SEND.SV_SendClientMessages();
+
+		// save the entire world state if recording a serverdemo
+		//TODO: dont need yet
+		//SV_WORLD.SV_RecordDemoMessage();
+
+		// send a heartbeat to the master if needed
+		//TODO: dont need yet
+		Master_Heartbeat();
+
+		// clear teleport flags, etc for next frame
+		SV_PrepWorldFrame();
+
+	}
+
+	//============================================================================
+
+	/*
+	================
+	Master_Heartbeat
+	
+	Send a message to the master every few minutes to
+	let it know we are alive, and log information
+	================
+	*/
+	public static final int HEARTBEAT_SECONDS = 300;
+	public static void Master_Heartbeat() {
+		String string;
+		int i;
+
+		// pgm post3.19 change, cvar pointer not validated before dereferencing
+		if (dedicated == null || 0 == dedicated.value)
+			return; // only dedicated servers send heartbeats
+
+		// pgm post3.19 change, cvar pointer not validated before dereferencing
+		if (null == public_server || 0 == public_server.value)
+			return; // a private dedicated game
+
+		// check for time wraparound
+		if (svs.last_heartbeat > svs.realtime)
+			svs.last_heartbeat = svs.realtime;
+
+		if (svs.realtime - svs.last_heartbeat < HEARTBEAT_SECONDS * 1000)
+			return; // not time to send yet
+
+		svs.last_heartbeat = svs.realtime;
+
+		// send the same string that we would give for a status OOB command
+		string = SV_StatusString();
+
+		// send to group master
+		for (i = 0; i < MAX_MASTERS; i++)
+			if (master_adr[i].port != 0) {
+				Com.Printf("Sending heartbeat to " + NET.AdrToString(master_adr[i]) + "\n");
+				Netchan.OutOfBandPrint(NS_SERVER, master_adr[i], "heartbeat\n" + string);
+			}
+	}
+
+	/*
+	=================
+	Master_Shutdown
+	
+	Informs all masters that this server is going down
+	=================
+	*/
+	static void Master_Shutdown() {
+		int i;
+
+		// pgm post3.19 change, cvar pointer not validated before dereferencing
+		if (null == dedicated || 0 == dedicated.value)
+			return; // only dedicated servers send heartbeats
+
+		// pgm post3.19 change, cvar pointer not validated before dereferencing
+		if (null == public_server || 0 == public_server.value)
+			return; // a private dedicated game
+
+		// send to group master
+		for (i = 0; i < MAX_MASTERS; i++)
+			if (master_adr[i].port != 0) {
+				if (i > 0)
+					Com.Printf("Sending heartbeat to " + NET.AdrToString(master_adr[i]) + "\n");
+				Netchan.OutOfBandPrint(NS_SERVER, master_adr[i], "shutdown");
+			}
+	}
+
+	//============================================================================
+
+	/*
+	=================
+	SV_UserinfoChanged
+	
+	Pull specific info from a newly changed userinfo string
+	into a more C freindly form.
+	=================
+	*/
+	public static void SV_UserinfoChanged(client_t cl) {
+		String val;
+		int i;
+
+		// call prog code to allow overrides
+		SV_GAME.ge.ClientUserinfoChanged(cl.edict, cl.userinfo);
+
+		// name for C code
+		cl.name = Info.Info_ValueForKey(cl.userinfo, "name");
+
+		// mask off high bit
+		//TODO: masking for german umlaute
+		//for (i=0 ; i<sizeof(cl.name) ; i++)
+		//	cl.name[i] &= 127;
+
+		// rate command
+		val = Info.Info_ValueForKey(cl.userinfo, "rate");
+		if (val.length() > 0) {
+			i = atoi(val);
+			cl.rate = i;
+			if (cl.rate < 100)
+				cl.rate = 100;
+			if (cl.rate > 15000)
+				cl.rate = 15000;
+		}
+		else
+			cl.rate = 5000;
+
+		// msg command
+		val = Info.Info_ValueForKey(cl.userinfo, "msg");
+		if (strlen(val) > 0) {
+			cl.messagelevel = atoi(val);
+		}
+
+	}
+
+	//============================================================================
+
+	/*
+	===============
+	SV_Init
+	
+	Only called at quake2.exe startup, not for each game
+	===============
+	*/
+	public static void SV_Init() {
+		SV_CCMDS.SV_InitOperatorCommands ();		//ok.
+
+		rcon_password = Cvar.Get("rcon_password", "", 0);
+		Cvar.Get("skill", "1", 0);
+		Cvar.Get("deathmatch", "0", CVAR_LATCH);
+		Cvar.Get("coop", "0", CVAR_LATCH);
+		Cvar.Get("dmflags", "" + DF_INSTANT_ITEMS, CVAR_SERVERINFO);
+		Cvar.Get("fraglimit", "0", CVAR_SERVERINFO);
+		Cvar.Get("timelimit", "0", CVAR_SERVERINFO);
+		Cvar.Get("cheats", "0", CVAR_SERVERINFO | CVAR_LATCH);
+		Cvar.Get("protocol", "" + PROTOCOL_VERSION, CVAR_SERVERINFO | CVAR_NOSET);
+	 
+		SV_MAIN.maxclients = Cvar.Get("maxclients", "1", CVAR_SERVERINFO | CVAR_LATCH);
+		hostname = Cvar.Get("hostname", "noname", CVAR_SERVERINFO | CVAR_ARCHIVE);
+		timeout = Cvar.Get("timeout", "125", 0);
+		zombietime = Cvar.Get("zombietime", "2", 0);
+		sv_showclamp = Cvar.Get("showclamp", "0", 0);
+		sv_paused = Cvar.Get("paused", "0", 0);
+		sv_timedemo = Cvar.Get("timedemo", "0", 0);
+		sv_enforcetime = Cvar.Get("sv_enforcetime", "0", 0);
+		
+		// TODO: carsten, re-allow downloads per default
+		allow_download = Cvar.Get("allow_download", "0", CVAR_ARCHIVE);
+		allow_download_players = Cvar.Get("allow_download_players", "0", CVAR_ARCHIVE);
+		allow_download_models = Cvar.Get("allow_download_models", "1", CVAR_ARCHIVE);
+		allow_download_sounds = Cvar.Get("allow_download_sounds", "1", CVAR_ARCHIVE);
+		allow_download_maps = Cvar.Get("allow_download_maps", "1", CVAR_ARCHIVE);
+
+		sv_noreload = Cvar.Get("sv_noreload", "0", 0);
+		sv_airaccelerate = Cvar.Get("sv_airaccelerate", "0", CVAR_LATCH);
+		public_server = Cvar.Get("public", "0", 0);
+		sv_reconnect_limit = Cvar.Get("sv_reconnect_limit", "3", CVAR_ARCHIVE);
+
+		SZ.Init(net_message, net_message_buffer, net_message_buffer.length);
+	}
+
+	/*
+	==================
+	SV_FinalMessage
+	
+	Used by SV_Shutdown to send a final message to all
+	connected clients before the server goes down.  The messages are sent immediately,
+	not just stuck on the outgoing message list, because the server is going
+	to totally exit after returning from this function.
+	==================
+	*/
+	public static void SV_FinalMessage(String message, boolean reconnect) {
+		int i;
+		client_t cl;
+
+		SZ.Clear(net_message);
+		MSG.WriteByte(net_message, svc_print);
+		MSG.WriteByte(net_message, PRINT_HIGH);
+		MSG.WriteString(net_message, message);
+
+		if (reconnect)
+			MSG.WriteByte(net_message, svc_reconnect);
+		else
+			MSG.WriteByte(net_message, svc_disconnect);
+
+		// send it twice
+		// stagger the packets to crutch operating system limited buffers
+
+		for (i = 0; i < maxclients.value; i++) {
+			cl = svs.clients[i];
+			if (cl.state >= cs_connected)
+				Netchan.Transmit(cl.netchan, net_message.cursize, net_message.data);
+		}
+		for (i = 0; i < maxclients.value; i++) {
+			cl = svs.clients[i];
+			if (cl.state >= cs_connected)
+				Netchan.Transmit(cl.netchan, net_message.cursize, net_message.data);
+		}
+	}
+
+	/*
+	================
+	SV_Shutdown
+	
+	Called when each game quits,
+	before Sys_Quit or Sys_Error
+	================
+	*/
+	public static void SV_Shutdown(String finalmsg, boolean reconnect) {
+		if (svs.clients != null)
+			SV_FinalMessage(finalmsg, reconnect);
+
+		Master_Shutdown();
+		
+		SV_GAME.SV_ShutdownGameProgs ();
+
+		// free current level
+		if (sv.demofile != null)
+			try {
+				sv.demofile.close();
+			}
+			catch (IOException e) {
+				e.printStackTrace();
+			}
+
+		//memset (&sv, 0, sizeof(sv));
+		sv = new server_t();
+
+		
+		Com.SetServerState (sv.state);
+
+		// free server static data
+		//if (svs.clients!=null)
+		//	Z_Free (svs.clients);
+		//if (svs.client_entities)
+		//	Z_Free (svs.client_entities);
+
+		if (svs.demofile != null)
+			try {
+				svs.demofile.close();
+			}
+			catch (IOException e1) {
+				e1.printStackTrace();
+			}
+		//memset (&svs, 0, sizeof(svs));
+		svs = new server_static_t();
+	}
+}
diff --git a/src/jake2/server/SV_SEND.java b/src/jake2/server/SV_SEND.java
new file mode 100644
index 0000000..ca6b07e
--- /dev/null
+++ b/src/jake2/server/SV_SEND.java
@@ -0,0 +1,562 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 17.01.2004 by RST.
+// $Id: SV_SEND.java,v 1.1 2004-07-07 19:59:49 hzi Exp $
+
+package jake2.server;
+
+import java.io.IOException;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+
+public class SV_SEND extends SV_MAIN {
+	/*
+	=============================================================================
+	
+	Com_Printf redirection
+	
+	=============================================================================
+	*/
+
+	public static byte sv_outputbuf[] = new byte[SV_OUTPUTBUF_LENGTH];
+
+	public static void SV_FlushRedirect(int sv_redirected, byte outputbuf[]) {
+		if (sv_redirected == RD_PACKET) {
+			String s = ("print\n" + outputbuf);
+			Netchan.Netchan_OutOfBand(NS_SERVER, Netchan.net_from, s.length(), s.getBytes());
+		}
+		else if (sv_redirected == RD_CLIENT) {
+			MSG.WriteByte(SV_MAIN.sv_client.netchan.message, svc_print);
+			MSG.WriteByte(SV_MAIN.sv_client.netchan.message, PRINT_HIGH);
+			MSG.WriteString(SV_MAIN.sv_client.netchan.message, outputbuf);
+		}
+	}
+
+	/*
+	=============================================================================
+	
+	EVENT MESSAGES
+	
+	=============================================================================
+	*/
+
+	/*
+	=================
+	SV_ClientPrintf
+	
+	Sends text across to be displayed if the level passes
+	=================
+	*/
+	public static void SV_ClientPrintf(client_t cl, int level, String s) {
+		//	va_list		argptr;
+		//	char		string[1024];
+		//	
+		if (level < cl.messagelevel)
+			return;
+
+		//	va_start (argptr,fmt);
+		//	vsprintf (string, fmt,argptr);
+		//	va_end (argptr);
+
+		MSG.WriteByte(cl.netchan.message, svc_print);
+		MSG.WriteByte(cl.netchan.message, level);
+		MSG.WriteString(cl.netchan.message, s);
+	}
+
+	/*
+	=================
+	SV_BroadcastPrintf
+	
+	Sends text to all active clients
+	=================
+	*/
+	public static void SV_BroadcastPrintf(int level, String s) {
+		//va_list		argptr;
+		//char		string[2048];
+		client_t cl;
+		//int			i;
+
+		//	va_start (argptr,fmt);
+		//	vsprintf (string, fmt,argptr);
+		//	va_end (argptr);
+
+		// echo to console
+			if (dedicated.value!=0)
+			{
+				
+				//char	copy[1024];
+				//int		i;
+				
+				// mask off high bits
+				//for (i=0 ; i<1023 && string[i] ; i++)
+					//copy[i] = string[i]&127;
+				//copy[i] = 0;
+				//Com_Printf ("%s", copy);
+				
+				Com.Printf(s);
+			}
+
+		for (int i = 0; i < SV_MAIN.maxclients.value; i++) {
+			cl = SV_MAIN.svs.clients[i];
+			if (level < cl.messagelevel)
+				continue;
+			if (cl.state != cs_spawned)
+				continue;
+			MSG.WriteByte(cl.netchan.message, svc_print);
+			MSG.WriteByte(cl.netchan.message, level);
+			MSG.WriteString(cl.netchan.message, s);
+		}
+	}
+
+	/*
+	=================
+	SV_BroadcastCommand
+	
+	Sends text to all active clients
+	=================
+	*/
+	public static void SV_BroadcastCommand(String s) {
+		//	va_list		argptr;
+		//	char		string[1024];
+
+		if (sv.state == 0)
+			return;
+
+		//	va_start (argptr,fmt);
+		//	vsprintf (string, fmt,argptr);
+		//	va_end (argptr);
+
+		MSG.WriteByte(sv.multicast, svc_stufftext);
+		MSG.WriteString(sv.multicast, s);
+		SV_Multicast(null, MULTICAST_ALL_R);
+	}
+
+	/*
+	=================
+	SV_Multicast
+	
+	Sends the contents of sv.multicast to a subset of the clients,
+	then clears sv.multicast.
+	
+	MULTICAST_ALL	same as broadcast (origin can be null)
+	MULTICAST_PVS	send to clients potentially visible from org
+	MULTICAST_PHS	send to clients potentially hearable from org
+	=================
+	*/
+	public static void SV_Multicast(float[] origin, int to) {
+		client_t client;
+		byte mask[];
+		int leafnum, cluster;
+		int j;
+		boolean reliable;
+		int area1, area2;
+
+		reliable = false;
+
+		if (to != MULTICAST_ALL_R && to != MULTICAST_ALL) {
+			leafnum = CM.CM_PointLeafnum(origin);
+			area1 = CM.CM_LeafArea(leafnum);
+		}
+		else {
+			leafnum = 0; // just to avoid compiler warnings
+			area1 = 0;
+		}
+
+		// if doing a serverrecord, store everything
+		if (svs.demofile != null)
+			SZ.Write(svs.demo_multicast, sv.multicast.data, sv.multicast.cursize);
+
+		switch (to) {
+			case MULTICAST_ALL_R :
+				reliable = true; // intentional fallthrough, no break here
+			case MULTICAST_ALL :
+				leafnum = 0;
+				mask = null;
+				break;
+
+			case MULTICAST_PHS_R :
+				reliable = true; // intentional fallthrough
+			case MULTICAST_PHS :
+				leafnum = CM.CM_PointLeafnum(origin);
+				cluster = CM.CM_LeafCluster(leafnum);
+				mask = CM.CM_ClusterPHS(cluster);
+				break;
+
+			case MULTICAST_PVS_R :
+				reliable = true; // intentional fallthrough
+			case MULTICAST_PVS :
+				leafnum = CM.CM_PointLeafnum(origin);
+				cluster = CM.CM_LeafCluster(leafnum);
+				mask = CM.CM_ClusterPVS(cluster);
+				break;
+
+			default :
+				mask = null;
+				Com.Error(ERR_FATAL, "SV_Multicast: bad to:" + to + "\n");
+		}
+
+		// send the data to all relevent clients
+		for (j = 0; j < maxclients.value; j++) {
+			client = svs.clients[j];
+
+			if (client.state == cs_free || client.state == cs_zombie)
+				continue;
+			if (client.state != cs_spawned && !reliable)
+				continue;
+
+			if (mask != null) {
+				leafnum = CM.CM_PointLeafnum(client.edict.s.origin);
+				cluster = CM.CM_LeafCluster(leafnum);
+				area2 = CM.CM_LeafArea(leafnum);
+				if (!CM.CM_AreasConnected(area1, area2))
+					continue;
+				if (mask != null && (0 == (mask[cluster >> 3] & (1 << (cluster & 7)))))
+					continue;
+			}
+
+			if (reliable)
+				SZ.Write(client.netchan.message, sv.multicast.data, sv.multicast.cursize);
+			else
+				SZ.Write(client.datagram, sv.multicast.data, sv.multicast.cursize);
+		}
+
+		SZ.Clear(sv.multicast);
+	}
+
+	/*  
+	==================
+	SV_StartSound
+	
+	Each entity can have eight independant sound sources, like voice,
+	weapon, feet, etc.
+	
+	If cahnnel & 8, the sound will be sent to everyone, not just
+	things in the PHS.
+	
+	FIXME: if entity isn't in PHS, they must be forced to be sent or
+	have the origin explicitly sent.
+	
+	Channel 0 is an auto-allocate channel, the others override anything
+	already running on that entity/channel pair.
+	
+	An attenuation of 0 will play full volume everywhere in the level.
+	Larger attenuations will drop off.  (max 4 attenuation)
+	
+	Timeofs can range from 0.0 to 0.1 to cause sounds to be started
+	later in the frame than they normally would.
+	
+	If origin is null, the origin is determined from the entity origin
+	or the midpoint of the entity box for bmodels.
+	==================
+	*/
+	public static void SV_StartSound(
+		float[] origin,
+		edict_t entity,
+		int channel,
+		int soundindex,
+		float volume,
+		float attenuation,
+		float timeofs) {
+		int sendchan;
+		int flags;
+		int i;
+		int ent;
+		float[] origin_v = null;
+		boolean use_phs;
+
+		if (volume < 0 || volume > 1.0)
+			Com.Error(ERR_FATAL, "SV_StartSound: volume = " + volume);
+
+		if (attenuation < 0 || attenuation > 4)
+			Com.Error(ERR_FATAL, "SV_StartSound: attenuation = " + attenuation);
+
+		//	if (channel < 0 || channel > 15)
+		//		Com_Error (ERR_FATAL, "SV_StartSound: channel = %i", channel);
+
+		if (timeofs < 0 || timeofs > 0.255)
+			Com.Error(ERR_FATAL, "SV_StartSound: timeofs = " + timeofs);
+
+		//ent = NUM_FOR_EDICT(entity);
+		//TODO: somehow risky (dont know if constant correct index)
+		ent = entity.index;
+
+		if ((channel & 8) != 0) // no PHS flag
+			{
+			use_phs = false;
+			channel &= 7;
+		}
+		else
+			use_phs = true;
+
+		sendchan = (ent << 3) | (channel & 7);
+
+		flags = 0;
+		if (volume != Defines.DEFAULT_SOUND_PACKET_VOLUME)
+			flags |= SND_VOLUME;
+		if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
+			flags |= SND_ATTENUATION;
+
+		// the client doesn't know that bmodels have weird origins
+		// the origin can also be explicitly set
+		if ((entity.svflags & SVF_NOCLIENT) != 0 || (entity.solid == SOLID_BSP) || origin != null)
+			flags |= SND_POS;
+
+		// always send the entity number for channel overrides
+		flags |= SND_ENT;
+
+		if (timeofs != 0)
+			flags |= SND_OFFSET;
+
+		// use the entity origin unless it is a bmodel or explicitly specified
+		if (origin == null) {
+			origin = origin_v;
+			if (entity.solid == SOLID_BSP) {
+				for (i = 0; i < 3; i++)
+					origin_v[i] = entity.s.origin[i] + 0.5f * (entity.mins[i] + entity.maxs[i]);
+			}
+			else {
+				VectorCopy(entity.s.origin, origin_v);
+			}
+		}
+
+		MSG.WriteByte(sv.multicast, svc_sound);
+		MSG.WriteByte(sv.multicast, flags);
+		MSG.WriteByte(sv.multicast, soundindex);
+
+		if ((flags & SND_VOLUME) != 0)
+			MSG.WriteByte(sv.multicast, volume * 255);
+		if ((flags & SND_ATTENUATION) != 0)
+			MSG.WriteByte(sv.multicast, attenuation * 64);
+		if ((flags & SND_OFFSET) != 0)
+			MSG.WriteByte(sv.multicast, timeofs * 1000);
+
+		if ((flags & SND_ENT) != 0)
+			MSG.WriteShort(sv.multicast, sendchan);
+
+		if ((flags & SND_POS) != 0)
+			MSG.WritePos(sv.multicast, origin);
+
+		// if the sound doesn't attenuate,send it to everyone
+		// (global radio chatter, voiceovers, etc)
+		if (attenuation == ATTN_NONE)
+			use_phs = false;
+
+		if ((channel & CHAN_RELIABLE) != 0) {
+			if (use_phs)
+				SV_Multicast(origin, MULTICAST_PHS_R);
+			else
+				SV_Multicast(origin, MULTICAST_ALL_R);
+		}
+		else {
+			if (use_phs)
+				SV_Multicast(origin, MULTICAST_PHS);
+			else
+				SV_Multicast(origin, MULTICAST_ALL);
+		}
+	}
+
+	/*
+	===============================================================================
+	
+	FRAME UPDATES
+	
+	===============================================================================
+	*/
+
+	/*
+	=======================
+	SV_SendClientDatagram
+	=======================
+	*/
+	public static boolean SV_SendClientDatagram(client_t client) {
+		byte msg_buf[] = new byte[MAX_MSGLEN];
+		sizebuf_t msg = new sizebuf_t();
+
+		SV_ENTS.SV_BuildClientFrame(client);
+
+		SZ.Init(msg, msg_buf, msg_buf.length);
+		msg.allowoverflow = true;
+
+		// send over all the relevant entity_state_t
+		// and the player_state_t
+		SV_CCMDS.SV_WriteFrameToClient (client, msg);
+
+		// copy the accumulated multicast datagram
+		// for this client out to the message
+		// it is necessary for this to be after the WriteEntities
+		// so that entity references will be current
+		if (client.datagram.overflowed)
+			Com.Printf("WARNING: datagram overflowed for " + client.name + "\n");
+		else
+			SZ.Write(msg, client.datagram.data, client.datagram.cursize);
+		SZ.Clear(client.datagram);
+
+		if (msg.overflowed) { // must have room left for the packet header
+			Com.Printf("WARNING: msg overflowed for " + client.name + "\n");
+			SZ.Clear(msg);
+		}
+
+		// send the datagram
+		Netchan.Transmit(client.netchan, msg.cursize, msg.data);
+
+		// record the size for rate estimation
+		client.message_size[sv.framenum % RATE_MESSAGES] = msg.cursize;
+
+		return true;
+	}
+
+	/*
+	==================
+	SV_DemoCompleted
+	==================
+	*/
+	public static void SV_DemoCompleted() {
+		if (sv.demofile != null) {
+			try {
+				sv.demofile.close();
+			}
+			catch (IOException e) {
+				Com.Printf("IOError closing d9emo fiele:" + e);
+			}
+			sv.demofile = null;
+		}
+		SV_ENTS.SV_Nextserver();
+	}
+
+	/*
+	=======================
+	SV_RateDrop
+	
+	Returns true if the client is over its current
+	bandwidth estimation and should not be sent another packet
+	=======================
+	*/
+	public static boolean SV_RateDrop(client_t c) {
+		int total;
+		int i;
+
+		// never drop over the loopback
+		if (c.netchan.remote_address.type == NA_LOOPBACK)
+			return false;
+
+		total = 0;
+
+		for (i = 0; i < RATE_MESSAGES; i++) {
+			total += c.message_size[i];
+		}
+
+		if (total > c.rate) {
+			c.surpressCount++;
+			c.message_size[sv.framenum % RATE_MESSAGES] = 0;
+			return true;
+		}
+
+		return false;
+	}
+
+	/*
+	=======================
+	SV_SendClientMessages
+	=======================
+	*/
+	public static void SV_SendClientMessages() {
+		int i;
+		client_t c;
+		int msglen;
+		byte msgbuf[] = new byte[MAX_MSGLEN];
+		int r;
+
+		msglen = 0;
+
+		// read the next demo message if needed
+		if (sv.state == ss_demo && sv.demofile != null) {
+			if (sv_paused.value != 0)
+				msglen = 0;
+			else {
+				// get the next message
+				//r = fread (&msglen, 4, 1, sv.demofile);
+				try {
+					msglen = EndianHandler.swapInt(sv.demofile.readInt());
+				}
+				catch (Exception e) {
+					SV_DemoCompleted();
+					return;
+				}
+
+				//msglen = LittleLong (msglen);
+				if (msglen == -1) {
+					SV_DemoCompleted();
+					return;
+				}
+				if (msglen > MAX_MSGLEN)
+					Com.Error(ERR_DROP, "SV_SendClientMessages: msglen > MAX_MSGLEN");
+
+				//r = fread (msgbuf, msglen, 1, sv.demofile);
+				r = 0;
+				try {
+					r = sv.demofile.read(msgbuf, 0, msglen);
+				}
+				catch (IOException e1) {
+					Com.Printf("IOError: reading demo file, " + e1);
+				}
+				if (r != msglen) {
+					SV_DemoCompleted();
+					return;
+				}
+			}
+		}
+
+		// send a message to each connected client
+		for (i = 0; i < maxclients.value; i++) {
+			c = svs.clients[i];
+
+			if (c.state == 0)
+				continue;
+			// if the reliable message overflowed,
+			// drop the client
+			if (c.netchan.message.overflowed) {
+				SZ.Clear(c.netchan.message);
+				SZ.Clear(c.datagram);
+				SV_BroadcastPrintf(PRINT_HIGH, c.name + " overflowed\n");
+				SV_DropClient(c);
+			}
+
+			if (sv.state == ss_cinematic || sv.state == ss_demo || sv.state == ss_pic)
+				Netchan.Transmit(c.netchan, msglen, msgbuf);
+			else if (c.state == cs_spawned) {
+				// don't overrun bandwidth
+				if (SV_RateDrop(c))
+					continue;
+
+				SV_SendClientDatagram(c);
+			}
+			else {
+				// just update reliable	if needed
+				if (c.netchan.message.cursize != 0 || Globals.curtime - c.netchan.last_sent > 1000)
+					Netchan.Transmit(c.netchan, 0, new byte[0]);
+			}
+		}
+	}
+}
diff --git a/src/jake2/server/SV_USER.java b/src/jake2/server/SV_USER.java
new file mode 100644
index 0000000..7662c30
--- /dev/null
+++ b/src/jake2/server/SV_USER.java
@@ -0,0 +1,662 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 17.01.2004 by RST.
+// $Id: SV_USER.java,v 1.1 2004-07-07 19:59:50 hzi Exp $
+
+package jake2.server;
+
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.util.Lib;
+
+import java.io.IOException;
+
+public class SV_USER extends SV_SEND {
+
+	static edict_t sv_player;
+
+	/*
+	============================================================
+	
+	USER STRINGCMD EXECUTION
+	
+	sv_client and sv_player will be valid.
+	============================================================
+	*/
+
+	/*
+	==================
+	SV_BeginDemoServer
+	==================
+	*/
+	public static void SV_BeginDemoserver() {
+		String name;
+
+		name = "demos/" + sv.name;
+		try {
+			sv.demofile = FS.FOpenFile(name);
+		}
+		catch (IOException e) {
+			Com.Error(ERR_DROP, "Couldn't open " + name + "\n");
+		}
+		if (sv.demofile == null)
+			Com.Error(ERR_DROP, "Couldn't open " + name + "\n");
+	}
+
+	/*
+	================
+	SV_New_f
+	
+	Sends the first message from the server to a connected client.
+	This will be sent on the initial connection and upon each server load.
+	================
+	*/
+	public static void SV_New_f() {
+		String gamedir;
+		int playernum;
+		edict_t ent;
+
+		Com.DPrintf("New() from " + sv_client.name + "\n");
+
+		if (sv_client.state != cs_connected) {
+			Com.Printf("New not valid -- already spawned\n");
+			return;
+		}
+
+		// demo servers just dump the file message
+		if (sv.state == ss_demo) {
+			SV_BeginDemoserver();
+			return;
+		}
+
+		//
+		// serverdata needs to go over for all types of servers
+		// to make sure the protocol is right, and to set the gamedir
+		//
+		gamedir = Cvar.VariableString("gamedir");
+
+		// send the serverdata
+		MSG.WriteByte(sv_client.netchan.message, svc_serverdata);
+		MSG.WriteInt(sv_client.netchan.message, PROTOCOL_VERSION);
+		MSG.WriteLong(sv_client.netchan.message, svs.spawncount);
+		MSG.WriteByte(sv_client.netchan.message, sv.attractloop ? 1 : 0);
+		MSG.WriteString(sv_client.netchan.message, gamedir);
+
+		if (sv.state == ss_cinematic || sv.state == ss_pic)
+			playernum = -1;
+		else
+			//playernum = sv_client - svs.clients;
+			playernum = sv_client.serverindex;
+
+		MSG.WriteShort(sv_client.netchan.message, playernum);
+
+		// send full levelname
+		MSG.WriteString(sv_client.netchan.message, sv.configstrings[CS_NAME]);
+
+		//
+		// game server
+		// 
+		if (sv.state == ss_game) {
+			// set up the entity for the client
+			ent = SV_GAME.ge.edicts[playernum + 1];
+			ent.s.number = playernum + 1;
+			sv_client.edict = ent;
+			sv_client.lastcmd = new usercmd_t();
+
+			// begin fetching configstrings
+			MSG.WriteByte(sv_client.netchan.message, svc_stufftext);
+			MSG.WriteString(sv_client.netchan.message, "cmd configstrings " + svs.spawncount + " 0\n");
+		}
+
+	}
+
+	/*
+	==================
+	SV_Configstrings_f
+	==================
+	*/
+	public static void SV_Configstrings_f() {
+		int start;
+
+		Com.DPrintf("Configstrings() from " + sv_client.name + "\n");
+
+		if (sv_client.state != cs_connected) {
+			Com.Printf("configstrings not valid -- already spawned\n");
+			return;
+		}
+
+		// handle the case of a level changing while a client was connecting
+		if (atoi(Cmd.Argv(1)) != svs.spawncount) {
+			Com.Printf("SV_Configstrings_f from different level\n");
+			SV_New_f();
+			return;
+		}
+
+		start = atoi(Cmd.Argv(2));
+
+		// write a packet full of data
+
+		while (sv_client.netchan.message.cursize < MAX_MSGLEN / 2 && start < MAX_CONFIGSTRINGS) {
+			if (sv.configstrings[start] != null && sv.configstrings[start].length() != 0) {
+				MSG.WriteByte(sv_client.netchan.message, svc_configstring);
+				MSG.WriteShort(sv_client.netchan.message, start);
+				MSG.WriteString(sv_client.netchan.message, sv.configstrings[start]);
+			}
+			start++;
+		}
+
+		// send next command
+
+		if (start == MAX_CONFIGSTRINGS) {
+			MSG.WriteByte(sv_client.netchan.message, svc_stufftext);
+			MSG.WriteString(sv_client.netchan.message, "cmd baselines " + svs.spawncount + " 0\n");
+		}
+		else {
+			MSG.WriteByte(sv_client.netchan.message, svc_stufftext);
+			MSG.WriteString(sv_client.netchan.message, "cmd configstrings " + svs.spawncount + " " + start + "\n");
+		}
+	}
+
+	/*
+	==================
+	SV_Baselines_f
+	==================
+	*/
+	public static void SV_Baselines_f() {
+		int start;
+		entity_state_t nullstate;
+		entity_state_t base;
+
+		Com.DPrintf("Baselines() from " + sv_client.name + "\n");
+
+		if (sv_client.state != cs_connected) {
+			Com.Printf("baselines not valid -- already spawned\n");
+			return;
+		}
+
+		// handle the case of a level changing while a client was connecting
+		if (atoi(Cmd.Argv(1)) != svs.spawncount) {
+			Com.Printf("SV_Baselines_f from different level\n");
+			SV_New_f();
+			return;
+		}
+
+		start = atoi(Cmd.Argv(2));
+
+		//memset (&nullstate, 0, sizeof(nullstate));
+		nullstate = new entity_state_t(null);
+
+		// write a packet full of data
+
+		while (sv_client.netchan.message.cursize < MAX_MSGLEN / 2 && start < MAX_EDICTS) {
+			base = sv.baselines[start];
+			if (base.modelindex != 0 || base.sound != 0 || base.effects != 0) {
+				MSG.WriteByte(sv_client.netchan.message, svc_spawnbaseline);
+				MSG.WriteDeltaEntity(nullstate, base, sv_client.netchan.message, true, true);
+			}
+			start++;
+		}
+
+		// send next command
+
+		if (start == MAX_EDICTS) {
+			MSG.WriteByte(sv_client.netchan.message, svc_stufftext);
+			MSG.WriteString(sv_client.netchan.message, "precache " + svs.spawncount + "\n");
+		}
+		else {
+			MSG.WriteByte(sv_client.netchan.message, svc_stufftext);
+			MSG.WriteString(sv_client.netchan.message, "cmd baselines " + svs.spawncount + " " + start + "\n");
+		}
+	}
+
+	/*
+	==================
+	SV_Begin_f
+	==================
+	*/
+	public static void SV_Begin_f() {
+		Com.DPrintf("Begin() from " + sv_client.name + "\n");
+
+		// handle the case of a level changing while a client was connecting
+		if (atoi(Cmd.Argv(1)) != svs.spawncount) {
+			Com.Printf("SV_Begin_f from different level\n");
+			SV_New_f();
+			return;
+		}
+
+		sv_client.state = cs_spawned;
+
+		// call the game begin function
+		SV_GAME.ge.ClientBegin(sv_player);
+
+		Cbuf.InsertFromDefer();
+	}
+
+	//=============================================================================
+
+	/*
+	==================
+	SV_NextDownload_f
+	==================
+	*/
+	public static void SV_NextDownload_f() {
+		int r;
+		int percent;
+		int size;
+
+		if (sv_client.download == null)
+			return;
+
+		r = sv_client.downloadsize - sv_client.downloadcount;
+		if (r > 1024)
+			r = 1024;
+
+		MSG.WriteByte(sv_client.netchan.message, svc_download);
+		MSG.WriteShort(sv_client.netchan.message, r);
+
+		sv_client.downloadcount += r;
+		size = sv_client.downloadsize;
+		if (size == 0)
+			size = 1;
+		percent = sv_client.downloadcount * 100 / size;
+		MSG.WriteByte(sv_client.netchan.message, percent);
+		SZ.Write(sv_client.netchan.message, sv_client.download, sv_client.downloadcount - r, r);
+
+		if (sv_client.downloadcount != sv_client.downloadsize)
+			return;
+
+		FS.FreeFile(sv_client.download);
+		sv_client.download = null;
+	}
+
+	/*
+	==================
+	SV_BeginDownload_f
+	==================
+	*/
+	public static void SV_BeginDownload_f() {
+		String name;
+		int offset = 0;
+
+		name = Cmd.Argv(1);
+
+		if (Cmd.Argc() > 2)
+			offset = atoi(Cmd.Argv(2)); // downloaded offset
+
+		// hacked by zoid to allow more conrol over download
+		// first off, no .. or global allow check
+
+		if (name.indexOf("..") != -1
+			|| allow_download.value == 0 // leading dot is no good
+			|| name.charAt(0) == '.' // leading slash bad as well, must be in subdir
+			|| name.charAt(0) == '/' // next up, skin check
+			|| (strncmp(name, "players/", 6) == 0 && 0 == allow_download_players.value) // now models
+			|| (strncmp(name, "models/", 6) == 0 && 0 == allow_download_models.value) // now sounds
+			|| (strncmp(name, "sound/", 6) == 0
+				&& 0 == allow_download_sounds.value) // now maps (note special case for maps, must not be in pak)
+			|| (strncmp(name, "maps/", 6) == 0 && 0 == allow_download_maps.value) // MUST be in a subdirectory	
+			|| name.indexOf('/') == -1) { // don't allow anything with .. path
+			MSG.WriteByte(sv_client.netchan.message, svc_download);
+			MSG.WriteShort(sv_client.netchan.message, -1);
+			MSG.WriteByte(sv_client.netchan.message, 0);
+			return;
+		}
+
+		if (sv_client.download != null)
+			FS.FreeFile(sv_client.download);
+
+		sv_client.download = FS.LoadFile(name);
+		sv_client.downloadsize = sv_client.download.length;
+		sv_client.downloadcount = offset;
+
+		if (offset > sv_client.downloadsize)
+			sv_client.downloadcount = sv_client.downloadsize;
+
+		if (sv_client.download == null // special check for maps, if it came from a pak file, don't allow
+		// download  ZOID
+			|| (strncmp(name, "maps/", 5) == 0 && FS.file_from_pak != 0)) {
+			Com.DPrintf("Couldn't download " + name + " to " + sv_client.name + "\n");
+			if (sv_client.download != null) {
+				FS.FreeFile(sv_client.download);
+				sv_client.download = null;
+			}
+
+			MSG.WriteByte(sv_client.netchan.message, svc_download);
+			MSG.WriteShort(sv_client.netchan.message, -1);
+			MSG.WriteByte(sv_client.netchan.message, 0);
+			return;
+		}
+
+		SV_NextDownload_f();
+		Com.DPrintf("Downloading " + name + " to " + sv_client.name + "\n");
+	}
+
+	//============================================================================
+
+	/*
+	=================
+	SV_Disconnect_f
+	
+	The client is going to disconnect, so remove the connection immediately
+	=================
+	*/
+	public static void SV_Disconnect_f() {
+		//	SV_EndRedirect ();
+		SV_DropClient(sv_client);
+	}
+
+	/*
+	==================
+	SV_ShowServerinfo_f
+	
+	Dumps the serverinfo info string
+	==================
+	*/
+	public static void SV_ShowServerinfo_f() {
+		Info.Print(Cvar.Serverinfo());
+	}
+
+	public static void SV_Nextserver() {
+		String v;
+
+		//ZOID, ss_pic can be nextserver'd in coop mode
+		if (sv.state == ss_game || (sv.state == ss_pic && 0 == Cvar.VariableValue("coop")))
+			return; // can't nextserver while playing a normal game
+
+		svs.spawncount++; // make sure another doesn't sneak in
+		v = Cvar.VariableString("nextserver");
+		//if (!v[0])
+		if (v.length() == 0)
+			Cbuf.AddText("killserver\n");
+		else {
+			Cbuf.AddText(v);
+			Cbuf.AddText("\n");
+		}
+		Cvar.Set("nextserver", "");
+	}
+
+	/*
+	==================
+	SV_Nextserver_f
+	
+	A cinematic has completed or been aborted by a client, so move
+	to the next server,
+	==================
+	*/
+	public static void SV_Nextserver_f() {
+		if (Lib.atoi(Cmd.Argv(1)) != svs.spawncount) {
+			Com.DPrintf("Nextserver() from wrong level, from " + sv_client.name + "\n");
+			return; // leftover from last server
+		}
+
+		Com.DPrintf("Nextserver() from " + sv_client.name + "\n");
+
+		SV_Nextserver();
+	}
+
+	public static class ucmd_t {
+		public ucmd_t(String n, Runnable r) {
+			name = n;
+			this.r = r;
+		}
+		String name;
+		Runnable r;
+	}
+
+	static ucmd_t u1 = new ucmd_t("new", new Runnable() {
+		public void run() {
+			SV_New_f();
+		}
+	});
+
+	static ucmd_t ucmds[] = {
+		// auto issued
+		new ucmd_t("new", new Runnable() { public void run() { SV_New_f();
+			}
+		}), new ucmd_t("configstrings", new Runnable() {
+			public void run() {
+				SV_Configstrings_f();
+			}
+		}), new ucmd_t("baselines", new Runnable() {
+			public void run() {
+				SV_Baselines_f();
+			}
+		}), new ucmd_t("begin", new Runnable() {
+			public void run() {
+				SV_Begin_f();
+			}
+		}), new ucmd_t("nextserver", new Runnable() {
+			public void run() {
+				SV_Nextserver_f();
+			}
+		}), new ucmd_t("disconnect", new Runnable() {
+			public void run() {
+				SV_Disconnect_f();
+			}
+		}),
+
+		// issued by hand at client consoles	
+		new ucmd_t("info", new Runnable() {
+			public void run() {
+				SV_ShowServerinfo_f();
+			}
+		}), new ucmd_t("download", new Runnable() {
+			public void run() {
+				SV_BeginDownload_f();
+			}
+		}), new ucmd_t("nextdl", new Runnable() {
+			public void run() {
+				SV_NextDownload_f();
+			}
+		})
+		};
+
+	/*
+	==================
+	SV_ExecuteUserCommand
+	==================
+	*/
+	public static void SV_ExecuteUserCommand(String s) {
+		ucmd_t u = null;
+
+		Cmd.TokenizeString(s.toCharArray(), true);
+		sv_player = sv_client.edict;
+
+		//	SV_BeginRedirect (RD_CLIENT);
+
+		for (int i = 0; i < ucmds.length; i++) {
+			u = ucmds[i];
+			if (0 == strcmp(Cmd.Argv(0), u.name)) {
+				u.r.run();
+				break;
+			}
+		}
+		if (u.name == null && sv.state == ss_game)
+			SV_GAME.ge.ClientCommand(sv_player);
+
+		//	SV_EndRedirect ();
+	}
+
+	/*
+	===========================================================================
+	
+	USER CMD EXECUTION
+	
+	===========================================================================
+	*/
+
+	public static void SV_ClientThink(client_t cl, usercmd_t cmd) {
+		cl.commandMsec -= cmd.msec & 0xFF;
+
+		if (cl.commandMsec < 0 && sv_enforcetime.value != 0) {
+			Com.DPrintf("commandMsec underflow from " + cl.name + "\n");
+			return;
+		}
+
+		SV_GAME.ge.ClientThink(cl.edict, cmd);
+	}
+
+	public static final int MAX_STRINGCMDS = 8;
+	/*
+	===================
+	SV_ExecuteClientMessage
+	
+	The current net_message is parsed for the given client
+	===================
+	*/
+	public static void SV_ExecuteClientMessage(client_t cl) {
+		int c;
+		String s;
+
+		usercmd_t nullcmd=new usercmd_t();
+		usercmd_t oldest=new usercmd_t(), oldcmd=new usercmd_t(), newcmd=new usercmd_t();
+		int net_drop;
+		int stringCmdCount;
+		int checksum, calculatedChecksum;
+		int checksumIndex;
+		boolean move_issued;
+		int lastframe;
+
+		sv_client = cl;
+		sv_player = sv_client.edict;
+
+		// only allow one move command
+		move_issued = false;
+		stringCmdCount = 0;
+
+		while (true) {
+			if (net_message.readcount > net_message.cursize) {
+				Com.Printf("SV_ReadClientMessage: bad read:\n");
+				Com.Printf(Lib.hexDump(net_message.data, 32, false));
+				SV_DropClient(cl);
+				return;
+			}
+
+			c = MSG.ReadByte(net_message);
+			if (c == -1)
+				break;
+
+			switch (c) {
+				default :
+					Com.Printf("SV_ReadClientMessage: unknown command char\n");
+					SV_DropClient(cl);
+					return;
+
+				case clc_nop :
+					break;
+
+				case clc_userinfo :
+					cl.userinfo = MSG.ReadString(net_message);
+					SV_MAIN.SV_UserinfoChanged(cl);
+					break;
+
+				case clc_move :
+					if (move_issued)
+						return; // someone is trying to cheat...
+
+					move_issued = true;
+					checksumIndex = net_message.readcount;
+					checksum = MSG.ReadByte(net_message);
+					lastframe = MSG.ReadLong(net_message);
+		
+					if (lastframe != cl.lastframe) {
+						cl.lastframe = lastframe;
+						if (cl.lastframe > 0) {
+							cl.frame_latency[cl.lastframe & (LATENCY_COUNTS - 1)] =
+								svs.realtime - cl.frames[cl.lastframe & UPDATE_MASK].senttime;
+						}
+					}
+
+					//memset (nullcmd, 0, sizeof(nullcmd));
+					nullcmd = new usercmd_t();
+					MSG.ReadDeltaUsercmd(net_message, nullcmd, oldest);
+					MSG.ReadDeltaUsercmd(net_message, oldest, oldcmd);
+					MSG.ReadDeltaUsercmd(net_message, oldcmd, newcmd);
+
+					if (cl.state != cs_spawned) {
+						cl.lastframe = -1;
+						break;
+					}
+
+					// if the checksum fails, ignore the rest of the packet
+					
+					calculatedChecksum = 0;
+					/*
+						 = Com.BlockSequenceCRCByte(
+							net_message.data + checksumIndex + 1,
+							net_message.readcount - checksumIndex - 1,
+							cl.netchan.incoming_sequence);
+							*/
+
+					if (calculatedChecksum != checksum) {
+						Com.DPrintf(
+							"Failed command checksum for "
+								+ cl.name
+								+ " ("
+								+ calculatedChecksum
+								+ " != "
+								+ checksum
+								+ ")/"
+								+ cl.netchan.incoming_sequence
+								+ "\n");
+						return;
+					}
+
+					if (0 == sv_paused.value) {
+						net_drop = cl.netchan.dropped;
+						if (net_drop < 20) {
+
+							//if (net_drop > 2)
+
+							//	Com.Printf ("drop %i\n", net_drop);
+							while (net_drop > 2) {
+								SV_ClientThink(cl, cl.lastcmd);
+
+								net_drop--;
+							}
+							if (net_drop > 1)
+								SV_ClientThink(cl, oldest);
+
+							if (net_drop > 0)
+								SV_ClientThink(cl, oldcmd);
+
+						}
+						SV_ClientThink(cl, newcmd);
+					}
+
+					// copy.
+					cl.lastcmd.set(newcmd);
+					break;
+
+				case clc_stringcmd :
+					s = MSG.ReadString(net_message);
+
+					// malicious users may try using too many string commands
+					if (++stringCmdCount < MAX_STRINGCMDS)
+						SV_ExecuteUserCommand(s);
+
+					if (cl.state == cs_zombie)
+						return; // disconnect command
+					break;
+			}
+		}
+	}
+}
diff --git a/src/jake2/server/SV_WORLD.java b/src/jake2/server/SV_WORLD.java
new file mode 100644
index 0000000..6df2512
--- /dev/null
+++ b/src/jake2/server/SV_WORLD.java
@@ -0,0 +1,654 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 07.01.2000 by RST.
+// $Id: SV_WORLD.java,v 1.1 2004-07-07 19:59:50 hzi Exp $
+
+package jake2.server;
+
+import jake2.game.edict_t;
+import jake2.game.trace_t;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.util.Vargs;
+
+public class SV_WORLD extends SV_CCMDS {
+
+	// world.c -- world query functions
+
+	//
+	///*
+	//===============================================================================
+	//
+	//ENTITY AREA CHECKING
+	//
+	//FIXME: this use of "area" is different from the bsp file use
+	//===============================================================================
+	//*/
+
+	//// (type *)STRUCT_FROM_LINK(link_t *link, type, member)
+	//// ent = STRUCT_FROM_LINK(link,entity_t,order)
+
+	//// FIXME: remove this mess!
+	//#define	STRUCT_FROM_LINK(l,t,m) ((t *)((byte *)l - (int)&(((t *)0).m)))
+	//
+	//#define	EDICT_FROM_AREA(l) STRUCT_FROM_LINK(l,edict_t,area)
+
+	//
+
+	public static void initNodes() {
+		for (int n = 0; n < AREA_NODES; n++)
+			sv_areanodes[n] = new areanode_t();
+	}
+
+	public static areanode_t sv_areanodes[] = new areanode_t[AREA_NODES];
+
+	static {
+		initNodes();
+	}
+	public static int sv_numareanodes;
+
+	public static float area_mins[], area_maxs[];
+	public static edict_t area_list[];
+	public static int area_count, area_maxcount;
+	public static int area_type;
+
+	// ClearLink is used for new headnodes
+	public static void ClearLink(link_t l) {
+		l.prev = l.next = l;
+	}
+
+	public static void RemoveLink(link_t l) {
+		l.next.prev = l.prev;
+		l.prev.next = l.next;
+	}
+
+	public static void InsertLinkBefore(link_t l, link_t before) {
+		l.next = before;
+		l.prev = before.prev;
+		l.prev.next = l;
+		l.next.prev = l;
+	}
+
+	/*
+	===============
+	SV_CreateAreaNode
+	
+	Builds a uniformly subdivided tree for the given world size
+	===============
+	*/
+	public static areanode_t SV_CreateAreaNode(int depth, float[] mins, float[] maxs) {
+		areanode_t anode;
+		float[] size = { 0, 0, 0 };
+		float[] mins1 = { 0, 0, 0 }, maxs1 = { 0, 0, 0 }, mins2 = { 0, 0, 0 }, maxs2 = { 0, 0, 0 };
+
+		Com.Printf("SV_CreateAreaNode " + depth + "\n");
+		anode = sv_areanodes[sv_numareanodes];
+		
+		// just for debugging (rst)
+		VectorCopy(mins, anode.mins_rst);
+		VectorCopy(maxs, anode.maxs_rst);
+		
+		sv_numareanodes++;
+
+		ClearLink(anode.trigger_edicts);
+		ClearLink(anode.solid_edicts);
+
+		if (depth == AREA_DEPTH) {
+			anode.axis = -1;
+			anode.children[0] = anode.children[1] = null;
+			return anode;
+		}
+
+		VectorSubtract(maxs, mins, size);
+		if (size[0] > size[1])
+			anode.axis = 0;
+		else
+			anode.axis = 1;
+
+		anode.dist = 0.5f * (maxs[anode.axis] + mins[anode.axis]);
+		VectorCopy(mins, mins1);
+		VectorCopy(mins, mins2);
+		VectorCopy(maxs, maxs1);
+		VectorCopy(maxs, maxs2);
+
+		maxs1[anode.axis] = mins2[anode.axis] = anode.dist;
+
+		anode.children[0] = SV_CreateAreaNode(depth + 1, mins2, maxs2);
+		anode.children[1] = SV_CreateAreaNode(depth + 1, mins1, maxs1);
+
+		return anode;
+	}
+
+	/*
+	===============
+	SV_ClearWorld
+	
+	===============
+	*/
+	public static void SV_ClearWorld() {
+		initNodes();
+		sv_numareanodes = 0;
+		SV_CreateAreaNode(0, sv.models[1].mins, sv.models[1].maxs);
+
+		Com.Println("areanodes:" + sv_numareanodes + " (sollten 32 sein).");
+		for (int n = 0; n < sv_numareanodes; n++) {
+			Com.Printf(
+				"|%3i|%2i|%8.2f  |%8.2f|%8.2f|%8.2f|  %8.2f|%8.2f|%8.2f|\n",
+				new Vargs()
+					.add(n)
+					.add(sv_areanodes[n].axis)
+					.add(sv_areanodes[n].dist)
+					.add(sv_areanodes[n].mins_rst[0])
+					.add(sv_areanodes[n].mins_rst[1])
+					.add(sv_areanodes[n].mins_rst[2])
+					.add(sv_areanodes[n].maxs_rst[0])
+					.add(sv_areanodes[n].maxs_rst[1])
+					.add(sv_areanodes[n].maxs_rst[2]));
+		}
+	}
+
+	/*
+	===============
+	SV_UnlinkEdict
+	
+	===============
+	*/
+	public static void SV_UnlinkEdict(edict_t ent) {
+		if (null == ent.area.prev)
+			return; // not linked in anywhere
+		RemoveLink(ent.area);
+		ent.area.prev = ent.area.next = null;
+	}
+
+	/*
+	===============
+	SV_LinkEdict
+	
+	===============
+	*/
+	public static final int MAX_TOTAL_ENT_LEAFS = 128;
+
+	public static void SV_LinkEdict(edict_t ent) {
+		areanode_t node;
+		// TODO: make static instead of new
+		int leafs[] = new int[MAX_TOTAL_ENT_LEAFS];
+		int clusters[] = new int[MAX_TOTAL_ENT_LEAFS];
+		int num_leafs;
+		int j, k;
+		int area;
+		int topnode = 0;
+
+		if (ent.area.prev != null)
+			SV_UnlinkEdict(ent); // unlink from old position
+
+		if (ent == ge.edicts[0])
+			return; // don't add the world
+
+		if (!ent.inuse)
+			return;
+
+		// set the size
+		VectorSubtract(ent.maxs, ent.mins, ent.size);
+
+		// encode the size into the entity_state for client prediction
+		if (ent.solid == SOLID_BBOX && 0 == (ent.svflags & SVF_DEADMONSTER)) { // assume that x/y are equal and symetric
+			int i = (int) (ent.maxs[0] / 8);
+			if (i < 1)
+				i = 1;
+			if (i > 31)
+				i = 31;
+
+			// z is not symetric
+			j = (int) ((-ent.mins[2]) / 8);
+			if (j < 1)
+				j = 1;
+			if (j > 31)
+				j = 31;
+
+			// and z maxs can be negative...
+			k = (int) ((ent.maxs[2] + 32) / 8);
+			if (k < 1)
+				k = 1;
+			if (k > 63)
+				k = 63;
+
+			ent.s.solid = (k << 10) | (j << 5) | i;
+		}
+		else if (ent.solid == SOLID_BSP) {
+			ent.s.solid = 31; // a solid_bbox will never create this value
+		}
+		else
+			ent.s.solid = 0;
+
+		// set the abs box
+		if (ent.solid == SOLID_BSP && (ent.s.angles[0] != 0 || ent.s.angles[1] != 0 || ent.s.angles[2] != 0)) { // expand for rotation
+			float max, v;
+
+			max = 0;
+			for (int i = 0; i < 3; i++) {
+				v = Math.abs(ent.mins[i]);
+				if (v > max)
+					max = v;
+				v = Math.abs(ent.maxs[i]);
+				if (v > max)
+					max = v;
+			}
+			for (int i = 0; i < 3; i++) {
+				ent.absmin[i] = ent.s.origin[i] - max;
+				ent.absmax[i] = ent.s.origin[i] + max;
+			}
+		}
+		else { // normal
+			VectorAdd(ent.s.origin, ent.mins, ent.absmin);
+			VectorAdd(ent.s.origin, ent.maxs, ent.absmax);
+		}
+
+		// because movement is clipped an epsilon away from an actual edge,
+		// we must fully check even when bounding boxes don't quite touch
+
+		ent.absmin[0]--;
+		ent.absmin[1]--;
+		ent.absmin[2]--;
+		ent.absmax[0]++;
+		ent.absmax[1]++;
+		ent.absmax[2]++;
+
+		// link to PVS leafs
+		ent.num_clusters = 0;
+		ent.areanum = 0;
+		ent.areanum2 = 0;
+
+		//get all leafs, including solids
+
+		CM.intwrap iw = new CM.intwrap(topnode);
+
+		num_leafs = CM.CM_BoxLeafnums(ent.absmin, ent.absmax, leafs, MAX_TOTAL_ENT_LEAFS, iw);
+
+		topnode = iw.i;
+
+		// set areas
+		for (int i = 0; i < num_leafs; i++) {
+			clusters[i] = CM.CM_LeafCluster(leafs[i]);
+			area = CM.CM_LeafArea(leafs[i]);
+			if (area != 0) { // doors may legally straggle two areas,
+				// but nothing should evern need more than that
+				if (ent.areanum != 0 && ent.areanum != area) {
+					if (ent.areanum2 != 0 && ent.areanum2 != area && sv.state == ss_loading)
+						Com.DPrintf("Object touching 3 areas at " + ent.absmin[0] + " " + ent.absmin[1] + " " + ent.absmin[2] + "\n");
+					ent.areanum2 = area;
+				}
+				else
+					ent.areanum = area;
+			}
+		}
+
+		if (num_leafs >= MAX_TOTAL_ENT_LEAFS) { // assume we missed some leafs, and mark by headnode
+			ent.num_clusters = -1;
+			ent.headnode = topnode;
+		}
+		else {
+			ent.num_clusters = 0;
+			for (int i = 0; i < num_leafs; i++) {
+				if (clusters[i] == -1)
+					continue; // not a visible leaf
+				for (j = 0; j < i; j++)
+					if (clusters[j] == clusters[i])
+						break;
+				if (j == i) {
+					if (ent.num_clusters == MAX_ENT_CLUSTERS) { // assume we missed some leafs, and mark by headnode
+						ent.num_clusters = -1;
+						ent.headnode = topnode;
+						break;
+					}
+
+					ent.clusternums[ent.num_clusters++] = clusters[i];
+				}
+			}
+		}
+
+		// if first time, make sure old_origin is valid
+		if (0 == ent.linkcount) {
+			VectorCopy(ent.s.origin, ent.s.old_origin);
+		}
+		ent.linkcount++;
+
+		if (ent.solid == SOLID_NOT)
+			return;
+
+		// find the first node that the ent's box crosses
+		node = sv_areanodes[0];
+
+		while (true) {
+			if (node.axis == -1)
+				break;
+			if (ent.absmin[node.axis] > node.dist)
+				node = node.children[0];
+			else if (ent.absmax[node.axis] < node.dist)
+				node = node.children[1];
+			else
+				break; // crosses the node
+		}
+
+		// link it in	
+		if (ent.solid == SOLID_TRIGGER)
+			InsertLinkBefore(ent.area, node.trigger_edicts);
+		else
+			InsertLinkBefore(ent.area, node.solid_edicts);
+
+	}
+
+	/*
+	====================
+	SV_AreaEdicts_r
+	
+	====================
+	*/
+	public static void SV_AreaEdicts_r(areanode_t node) {
+		link_t l, next, start;
+		edict_t check;
+		int count;
+
+		count = 0;
+
+		// touch linked edicts
+		if (area_type == AREA_SOLID)
+			start = node.solid_edicts;
+		else
+			start = node.trigger_edicts;
+
+		for (l = start.next; l != start; l = next) {
+			next = l.next;
+				check = //EDICT_FROM_AREA(l);
+	 (edict_t) l.o;
+
+			if (check.solid == SOLID_NOT)
+				continue; // deactivated
+			if (check.absmin[0] > area_maxs[0]
+				|| check.absmin[1] > area_maxs[1]
+				|| check.absmin[2] > area_maxs[2]
+				|| check.absmax[0] < area_mins[0]
+				|| check.absmax[1] < area_mins[1]
+				|| check.absmax[2] < area_mins[2])
+				continue; // not touching
+
+			if (area_count == area_maxcount) {
+				Com.Printf("SV_AreaEdicts: MAXCOUNT\n");
+				return;
+			}
+
+			area_list[area_count] = check;
+			area_count++;
+		}
+
+		if (node.axis == -1)
+			return; // terminal node
+
+		// recurse down both sides
+		if (area_maxs[node.axis] > node.dist)
+			SV_AreaEdicts_r(node.children[0]);
+
+		if (area_mins[node.axis] < node.dist)
+			SV_AreaEdicts_r(node.children[1]);
+	}
+
+	/*
+	================
+	SV_AreaEdicts
+	================
+	*/
+	public static int SV_AreaEdicts(float[] mins, float[] maxs, edict_t list[], int maxcount, int areatype) {
+		area_mins = mins;
+		area_maxs = maxs;
+		area_list = list;
+		area_count = 0;
+		area_maxcount = maxcount;
+		area_type = areatype;
+
+		SV_AreaEdicts_r(sv_areanodes[0]);
+		
+		/*
+		Com.Printf("found edicts in area:" + area_count + "\n");
+		for (int n = 0; n < area_count; n++) {
+			Com.Printf("%4i : %25s", new Vargs().add(n).add(list[n].classname));
+		}
+		*/
+		return area_count;
+	}
+
+	//===========================================================================
+
+	/*
+	=============
+	SV_PointContents
+	=============
+	*/
+	public static int SV_PointContents(float[] p) {
+		// TODO: make static instead new
+		edict_t touch[] = new edict_t[MAX_EDICTS], hit;
+		int i, num;
+		int contents, c2;
+		int headnode;
+		float angles[];
+
+		// get base contents from world
+		contents = CM.PointContents(p, sv.models[1].headnode);
+
+		// or in contents from all the other entities
+		num = SV_AreaEdicts(p, p, touch, MAX_EDICTS, AREA_SOLID);
+
+		for (i = 0; i < num; i++) {
+			hit = touch[i];
+
+			// might intersect, so do an exact clip
+			headnode = SV_HullForEntity(hit);
+			angles = hit.s.angles;
+			if (hit.solid != SOLID_BSP)
+				angles = vec3_origin; // boxes don't rotate
+
+			c2 = CM.TransformedPointContents(p, headnode, hit.s.origin, hit.s.angles);
+
+			contents |= c2;
+		}
+
+		return contents;
+	}
+
+	/*
+	================
+	SV_HullForEntity
+	
+	Returns a headnode that can be used for testing or clipping an
+	object of mins/maxs size.
+	Offset is filled in to contain the adjustment that must be added to the
+	testing object's origin to get a point to use with the returned hull.
+	================
+	*/
+	public static int SV_HullForEntity(edict_t ent) {
+
+		cmodel_t model;
+
+		// decide which clipping hull to use, based on the size
+		if (ent.solid == SOLID_BSP) { // explicit hulls in the BSP model
+			model = sv.models[ent.s.modelindex];
+
+			if (null == model)
+				Com.Error(ERR_FATAL, "MOVETYPE_PUSH with a non bsp model");
+
+			return model.headnode;
+		}
+
+		// create a temp hull from bounding box sizes
+
+		return CM.HeadnodeForBox(ent.mins, ent.maxs);
+	}
+
+	//===========================================================================
+
+	/*
+	====================
+	SV_ClipMoveToEntities
+	
+	====================
+	*/
+	public static void SV_ClipMoveToEntities(moveclip_t clip) {
+		int i, num;
+		// TODO: make static instead of new
+		edict_t touchlist[] = new edict_t[MAX_EDICTS];
+		edict_t touch;
+		trace_t trace;
+		int headnode;
+		float angles[];
+
+		num = SV_AreaEdicts(clip.boxmins, clip.boxmaxs, touchlist, MAX_EDICTS, AREA_SOLID);
+
+		// 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++) {
+			touch = touchlist[i];
+			if (touch.solid == SOLID_NOT)
+				continue;
+			if (touch == clip.passedict)
+				continue;
+			if (clip.trace.allsolid)
+				return;
+			if (clip.passedict != null) {
+				if (touch.owner == clip.passedict)
+					continue; // don't clip against own missiles
+				if (clip.passedict.owner == touch)
+					continue; // don't clip against owner
+			}
+
+			if (0 == (clip.contentmask & CONTENTS_DEADMONSTER) && 0 != (touch.svflags & SVF_DEADMONSTER))
+				continue;
+
+			// might intersect, so do an exact clip
+			headnode = SV_HullForEntity(touch);
+			angles = touch.s.angles;
+			if (touch.solid != SOLID_BSP)
+				angles = vec3_origin; // boxes don't rotate
+
+			if ((touch.svflags & SVF_MONSTER) != 0)
+				trace =
+					CM.TransformedBoxTrace(
+						clip.start,
+						clip.end,
+						clip.mins2,
+						clip.maxs2,
+						headnode,
+						clip.contentmask,
+						touch.s.origin,
+						angles);
+			else
+				trace =
+					CM.TransformedBoxTrace(
+						clip.start,
+						clip.end,
+						clip.mins,
+						clip.maxs,
+						headnode,
+						clip.contentmask,
+						touch.s.origin,
+						angles);
+
+			if (trace.allsolid || trace.startsolid || trace.fraction < clip.trace.fraction) {
+				trace.ent = touch;
+				if (clip.trace.startsolid) {
+					clip.trace = trace;
+					clip.trace.startsolid = true;
+				}
+				else
+					clip.trace = trace.getClone();
+			}
+			else if (trace.startsolid)
+				clip.trace.startsolid = true;
+		}
+	}
+
+	/*
+	==================
+	SV_TraceBounds
+	==================
+	*/
+	public static void SV_TraceBounds(float[] start, float[] mins, float[] maxs, float[] end, float[] boxmins, float[] boxmaxs) {
+		int i;
+
+		for (i = 0; i < 3; i++) {
+			if (end[i] > start[i]) {
+				boxmins[i] = start[i] + mins[i] - 1;
+				boxmaxs[i] = end[i] + maxs[i] + 1;
+			}
+			else {
+				boxmins[i] = end[i] + mins[i] - 1;
+				boxmaxs[i] = start[i] + maxs[i] + 1;
+			}
+		}
+
+	}
+
+	/*
+	==================
+	SV_Trace
+	
+	Moves the given mins/maxs volume through the world from start to end.
+	
+	Passedict and edicts owned by passedict are explicitly not checked.
+	
+	==================
+	*/
+	public static trace_t SV_Trace(float[] start, float[] mins, float[] maxs, float[] end, edict_t passedict, int contentmask) {
+		moveclip_t clip = new moveclip_t();
+
+		if (mins == null)
+			mins = vec3_origin;
+		if (maxs == null)
+			maxs = vec3_origin;
+
+		//memset ( clip, 0, sizeof ( moveclip_t ) );
+
+		// clip to world
+		clip.trace = CM.BoxTrace(start, end, mins, maxs, 0, contentmask);
+		clip.trace.ent = ge.edicts[0];
+		if (clip.trace.fraction == 0)
+			return clip.trace; // blocked by the world
+
+		clip.contentmask = contentmask;
+		clip.start = start;
+		clip.end = end;
+		clip.mins = mins;
+		clip.maxs = maxs;
+		clip.passedict = passedict;
+
+		VectorCopy(mins, clip.mins2);
+		VectorCopy(maxs, clip.maxs2);
+
+		// create the bounding box of the entire move
+		SV_TraceBounds(start, clip.mins2, clip.maxs2, end, clip.boxmins, clip.boxmaxs);
+
+		// clip to other solid entities
+		SV_ClipMoveToEntities(clip);
+
+		return clip.trace;
+	}
+}
diff --git a/src/jake2/server/areanode_t.java b/src/jake2/server/areanode_t.java
new file mode 100644
index 0000000..64e4e3a
--- /dev/null
+++ b/src/jake2/server/areanode_t.java
@@ -0,0 +1,43 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 09.12.2003 by RST.
+// $Id: areanode_t.java,v 1.1 2004-07-07 19:59:50 hzi Exp $
+
+package jake2.server;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.server.*;
+
+public class areanode_t {
+	int axis; // -1 = leaf node
+	float dist;
+	areanode_t children[] = new areanode_t[2];
+	link_t trigger_edicts = new link_t(this);
+	link_t solid_edicts = new link_t(this);
+	
+	// used for debugging
+	float mins_rst[] = {0,0,0};
+	float maxs_rst[] = {0,0,0};
+}
diff --git a/src/jake2/server/challenge_t.java b/src/jake2/server/challenge_t.java
new file mode 100644
index 0000000..ba1dd36
--- /dev/null
+++ b/src/jake2/server/challenge_t.java
@@ -0,0 +1,39 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 14.01.2004 by RST.
+// $Id: challenge_t.java,v 1.1 2004-07-07 19:59:50 hzi Exp $
+
+package jake2.server;
+
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.server.*;
+
+public class challenge_t {
+	//mem
+	netadr_t		adr = new netadr_t();
+	int			challenge;
+	int			time;
+}
diff --git a/src/jake2/server/client_frame_t.java b/src/jake2/server/client_frame_t.java
new file mode 100644
index 0000000..3f841da
--- /dev/null
+++ b/src/jake2/server/client_frame_t.java
@@ -0,0 +1,42 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 13.01.2004 by RST.
+// $Id: client_frame_t.java,v 1.1 2004-07-07 19:59:50 hzi Exp $
+
+package jake2.server;
+
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.server.*;
+
+public class client_frame_t {
+
+	int					areabytes;
+	byte				areabits[] = new byte[Defines.MAX_MAP_AREAS/8];		// portalarea visibility bits
+	player_state_t		ps = new player_state_t();
+	int					num_entities;
+	int					first_entity;		// into the circular sv_packet_entities[]
+	int					senttime;			// for ping calculations
+}
diff --git a/src/jake2/server/client_t.java b/src/jake2/server/client_t.java
new file mode 100644
index 0000000..2bbadf9
--- /dev/null
+++ b/src/jake2/server/client_t.java
@@ -0,0 +1,90 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 13.01.2004 by RST.
+// $Id: client_t.java,v 1.1 2004-07-07 19:59:50 hzi Exp $
+
+package jake2.server;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.server.*;
+
+public class client_t {
+
+	public client_t() {
+		for (int n = 0; n < Defines.UPDATE_BACKUP; n++) {
+			frames[n] = new client_frame_t();
+		}
+	}
+
+	public static final int LATENCY_COUNTS = 16;
+	public static final int RATE_MESSAGES = 10;
+
+	int state;
+
+	//char				userinfo[MAX_INFO_STRING];		// name, etc
+	String userinfo = "";
+
+	int lastframe; // for delta compression
+	usercmd_t lastcmd = new usercmd_t(); // for filling in big drops
+
+	int commandMsec; // every seconds this is reset, if user
+	// commands exhaust it, assume time cheating
+
+	int frame_latency[] = new int[LATENCY_COUNTS];
+	int ping;
+
+	int message_size[] = new int[RATE_MESSAGES]; // used to rate drop packets
+	int rate;
+	int surpressCount; // number of messages rate supressed
+
+	// pointer
+	edict_t edict; // EDICT_NUM(clientnum+1)
+
+	//char				name[32];			// extracted from userinfo, high bits masked
+	String name = ""; // extracted from userinfo, high bits masked
+
+	int messagelevel; // for filtering printed messages
+
+	// The datagram is written to by sound calls, prints, temp ents, etc.
+	// It can be harmlessly overflowed.
+	sizebuf_t datagram = new sizebuf_t();
+	byte datagram_buf[] = new byte[Defines.MAX_MSGLEN];
+
+	client_frame_t frames[] = new client_frame_t[Defines.UPDATE_BACKUP]; // updates can be delta'd from here
+
+	byte download[]; // file being downloaded
+	int downloadsize; // total bytes (can't use EOF because of paks)
+	int downloadcount; // bytes sent
+
+	int lastmessage; // sv.framenum when packet was last received
+	int lastconnect;
+
+	int challenge; // challenge of this user, randomly generated
+
+	netchan_t netchan = new netchan_t();
+
+	//TODO: this was introduced by rst, since java can't calculate the index out of the address.
+	int serverindex;
+}
diff --git a/src/jake2/server/moveclip_t.java b/src/jake2/server/moveclip_t.java
new file mode 100644
index 0000000..7bec554
--- /dev/null
+++ b/src/jake2/server/moveclip_t.java
@@ -0,0 +1,44 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 09.12.2003 by RST.
+// $Id: moveclip_t.java,v 1.1 2004-07-07 19:59:50 hzi Exp $
+
+package jake2.server;
+
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.server.*;
+
+public class moveclip_t 
+{
+	float [] boxmins={0,0,0}, boxmaxs={0,0,0};// enclose the test object along entire move
+	float [] mins, maxs;	// size of the moving object
+	float [] mins2={0,0,0}, maxs2={0,0,0};	// size when clipping against mosnters
+	float [] start, end;
+	// mem
+	trace_t	trace	= new trace_t();
+	edict_t	passedict;
+	int contentmask;
+}
diff --git a/src/jake2/server/scrap.jpage b/src/jake2/server/scrap.jpage
new file mode 100644
index 0000000..1666502
--- /dev/null
+++ b/src/jake2/server/scrap.jpage
@@ -0,0 +1,24 @@
+
+
+String p="\"123456\"";
+
+System.out.println(p.substring(1,p.length()-1));
+
+
	String path ="c:/baseq2/game/*.sav";
+	String findbase;
+	String findpattern;
+	
+	int i = path.lastIndexOf('/');
+	if (i!=-1)
+	{
+		findbase = path.substring(0,i);
+		findpattern = path.substring(i+1,path.length());
+	}
+	else
+	{
+		findpattern = "*";
+		findbase = path;
+	}
+	
+	
+	System.out.println(findbase + ":" + findpattern);
\ No newline at end of file
diff --git a/src/jake2/server/server_static_t.java b/src/jake2/server/server_static_t.java
new file mode 100644
index 0000000..c9f94a2
--- /dev/null
+++ b/src/jake2/server/server_static_t.java
@@ -0,0 +1,65 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 14.01.2004 by RST.
+// $Id: server_static_t.java,v 1.1 2004-07-07 19:59:51 hzi Exp $
+
+package jake2.server;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+import jake2.server.*;
+
+import java.io.*;
+
+public class server_static_t {
+	public server_static_t() {
+		for (int n = 0; n < Defines.MAX_CHALLENGES; n++) {
+			challenges[n] = new challenge_t();
+		}
+	}
+
+	boolean initialized; // sv_init has completed
+	int realtime; // always increasing, no clamping, etc
+
+	//char		mapcmd[MAX_TOKEN_CHARS];	// ie: *intro.cin+base
+	String mapcmd = ""; // ie: *intro.cin+base 
+
+	int spawncount; // incremented each server start
+	// used to check late spawns
+
+	client_t clients[]; // [maxclients->value];
+
+	int num_client_entities; // maxclients->value*UPDATE_BACKUP*MAX_PACKET_ENTITIES
+	int next_client_entities; // next client_entity to use
+	entity_state_t client_entities[]; // [num_client_entities]
+
+	int last_heartbeat;
+
+	challenge_t challenges[] = new challenge_t[Defines.MAX_CHALLENGES]; // to prevent invalid IPs from connecting
+
+	// serverrecord values
+	RandomAccessFile demofile;
+	sizebuf_t demo_multicast = new sizebuf_t();
+	byte demo_multicast_buf[] = new byte[Defines.MAX_MSGLEN];
+}
diff --git a/src/jake2/server/server_t.java b/src/jake2/server/server_t.java
new file mode 100644
index 0000000..8e260a2
--- /dev/null
+++ b/src/jake2/server/server_t.java
@@ -0,0 +1,76 @@
+/*
+Copyright (C) 1997-2001 Id Software, Inc.
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+// Created on 14.01.2004 by RST.
+// $Id: server_t.java,v 1.1 2004-07-07 19:59:51 hzi Exp $
+
+package jake2.server;
+
+import java.io.File;
+import java.io.RandomAccessFile;
+
+import jake2.*;
+import jake2.client.*;
+import jake2.game.*;
+import jake2.qcommon.*;
+import jake2.render.*;
+
+public class server_t {
+
+	public server_t() {
+		models = new cmodel_t[Defines.MAX_MODELS];
+		for (int n = 0; n < Defines.MAX_MODELS; n++) 
+			models[n] = new cmodel_t();
+		
+		for (int n=0; n < Defines.MAX_EDICTS; n++)
+			baselines[n] = new entity_state_t(null);
+		
+		//for (int n=0; n < Defines.MAX_CONFIGSTRINGS; n++)
+			//configstrings[n] = "";
+
+	}
+	//server_state_t state;
+	int state; // precache commands are only valid during load
+
+	boolean attractloop; // running cinematics and demos for the local system only
+	boolean loadgame; // client begins should reuse existing entity
+
+	int time; // always sv.framenum * 100 msec
+	int framenum;
+
+	//char name[MAX_QPATH];
+	String name = ""; // map name, or cinematic name
+
+	//struct cmodel_s *models[MAX_MODELS];
+	cmodel_t models[];
+
+	//char		configstrings[MAX_CONFIGSTRINGS][MAX_QPATH];
+	String configstrings[] = new String[Defines.MAX_CONFIGSTRINGS];
+	entity_state_t baselines[] = new entity_state_t[Defines.MAX_EDICTS];
+
+	// the multicast buffer is used to send a message to a set of clients
+	// it is only used to marshall data until SV_Multicast is called
+	sizebuf_t multicast = new sizebuf_t();
+	byte multicast_buf[] = new byte[Defines.MAX_MSGLEN];
+
+	// demo server information
+	RandomAccessFile demofile;
+	boolean timedemo; // don't time sync
+}