path: root/src/jake2/qcommon/CM.java

/*
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 02.01.2004 by RST.
// $Id: CM.java,v 1.5 2004-07-28 12:01:27 hzi Exp $

package jake2.qcommon;

import jake2.Defines;
import jake2.game.*;
import jake2.util.*;

import java.io.RandomAccessFile;
import java.nio.*;
import java.util.Arrays;

public class CM extends Game {

	public static class cnode_t {
		cplane_t plane; // ptr
		int children[] = { 0, 0 }; // negative numbers are leafs
	}

	public static class cbrushside_t {
		cplane_t plane; // ptr
		mapsurface_t surface; // ptr 
	}

	public static class cleaf_t {
		int contents;
		int cluster;
		int area;

		// was unsigned short, but is ok (rst)
		short firstleafbrush;
		// was unsigned short, but is ok (rst)
		short numleafbrushes;
	}

	public static class cbrush_t {
		int contents;
		int numsides;
		int firstbrushside;
		int checkcount; // to avoid repeated testings
	}

	public static class carea_t {
		int numareaportals;
		int firstareaportal;
		int floodnum; // if two areas have equal floodnums, they are connected
		int floodvalid;
	}

	static int checkcount;

	static String map_name = "";

	static int numbrushsides;
	static cbrushside_t map_brushsides[] = new cbrushside_t[MAX_MAP_BRUSHSIDES];
	static {
		for (int n = 0; n < MAX_MAP_BRUSHSIDES; n++)
			map_brushsides[n] = new cbrushside_t();
	}

	public static int numtexinfo;
	public static mapsurface_t map_surfaces[] = new mapsurface_t[MAX_MAP_TEXINFO];
	static {
		for (int n = 0; n < MAX_MAP_TEXINFO; n++)
			map_surfaces[n] = new mapsurface_t();
	}

	static int numplanes;
	// extra for box hull ( +6)
	static cplane_t map_planes[] = new cplane_t[MAX_MAP_PLANES + 6];

	static {
		for (int n = 0; n < MAX_MAP_PLANES + 6; n++)
			map_planes[n] = new cplane_t();
	}

	static int numnodes;
	// extra for box hull ( +6)
	static cnode_t map_nodes[] = new cnode_t[MAX_MAP_NODES + 6];

	static {
		for (int n = 0; n < MAX_MAP_NODES + 6; n++)
			map_nodes[n] = new cnode_t();
	}

	static int numleafs = 1; // allow leaf funcs to be called without a map
	static cleaf_t map_leafs[] = new cleaf_t[MAX_MAP_LEAFS];
	static {
		for (int n = 0; n < MAX_MAP_LEAFS; n++)
			map_leafs[n] = new cleaf_t();
	}

	static int emptyleaf, solidleaf;

	static int numleafbrushes;
	//static unsigned short map_leafbrushes[MAX_MAP_LEAFBRUSHES];
	public static int map_leafbrushes[] = new int[MAX_MAP_LEAFBRUSHES];
	public static int numcmodels;
	public static cmodel_t map_cmodels[] = new cmodel_t[MAX_MAP_MODELS];
	static {
		for (int n = 0; n < MAX_MAP_MODELS; n++)
			map_cmodels[n] = new cmodel_t();

	}

	public static int numbrushes;
	public static cbrush_t map_brushes[] = new cbrush_t[MAX_MAP_BRUSHES];
	static {
		for (int n = 0; n < MAX_MAP_BRUSHES; n++)
			map_brushes[n] = new cbrush_t();

	}

	public static int numvisibility;
	public static byte map_visibility[] = new byte[MAX_MAP_VISIBILITY];

	// main visibility data. rst
	// was: static dvis_t *map_vis = (dvis_t *)map_visibility;
	public static qfiles.dvis_t map_vis = new qfiles.dvis_t(ByteBuffer.wrap(map_visibility));

	public static int numentitychars;
	public static String map_entitystring;

	public static int numareas = 1;
	public static carea_t map_areas[] = new carea_t[MAX_MAP_AREAS];
	static {
		for (int n = 0; n < MAX_MAP_AREAS; n++)
			map_areas[n] = new carea_t();

	}
	public static int numareaportals;
	public static qfiles.dareaportal_t map_areaportals[] = new qfiles.dareaportal_t[MAX_MAP_AREAPORTALS];

	static {
		for (int n = 0; n < MAX_MAP_AREAPORTALS; n++)
			map_areaportals[n] = new qfiles.dareaportal_t();

	}

	public static int numclusters = 1;

	public static mapsurface_t nullsurface = new mapsurface_t();

	public static int floodvalid;

	public static boolean portalopen[] = new boolean[MAX_MAP_AREAPORTALS];

	public static cvar_t map_noareas;

	/*
	===============================================================================
	
						MAP LOADING
	
	===============================================================================
	*/

	public static byte cmod_base[];

	// is that right (rst) ?
	public static int checksum;
	public static int last_checksum;

	/*
	==================
	CM_LoadMap
	
	Loads in the map and all submodels
	==================
	*/
	public static cmodel_t CM_LoadMap(String name, boolean clientload, int checksum[]) {
		Com.DPrintf("CM_LoadMap...\n");
		byte buf[];
		int i;
		qfiles.dheader_t header;
		int length;

		map_noareas = Cvar.Get("map_noareas", "0", 0);

		if (map_name.equals(name) && (clientload || 0 == Cvar.VariableValue("flushmap"))) {

			checksum[0] = last_checksum;

			if (!clientload) {
				Arrays.fill(portalopen, false);
				FloodAreaConnections();
			}
			return map_cmodels[0]; // still have the right version
		}

		// free old stuff
		numnodes = 0;
		numleafs = 0;
		numcmodels = 0;
		numvisibility = 0;
		numentitychars = 0;
		map_entitystring = "";
		map_name = "";

		if (name == null || name.length() == 0) {
			numleafs = 1;
			numclusters = 1;
			numareas = 1;
			checksum[0] = 0;
			return map_cmodels[0];
			// cinematic servers won't have anything at all
		}

		//
		// load the file
		//
		buf = FS.LoadFile(name);

		if (buf == null)
			Com.Error(ERR_DROP, "Couldn't load " + name);

		length = buf.length;

		ByteBuffer bbuf = ByteBuffer.wrap(buf);

		last_checksum = MD4.Com_BlockChecksum(buf, length);
		checksum[0] = last_checksum;

		header = new qfiles.dheader_t(bbuf.slice());

		if (header.version != BSPVERSION)
			Com.Error(
				ERR_DROP,
				"CMod_LoadBrushModel: " + name + " has wrong version number (" + header.version + " should be " + BSPVERSION + ")");

		cmod_base = buf;

		// load into heap
		CMod_LoadSurfaces(header.lumps[LUMP_TEXINFO]); // ok.
		CMod_LoadLeafs(header.lumps[LUMP_LEAFS]);
		CMod_LoadLeafBrushes(header.lumps[LUMP_LEAFBRUSHES]);
		CMod_LoadPlanes(header.lumps[LUMP_PLANES]);
		CMod_LoadBrushes(header.lumps[LUMP_BRUSHES]);
		CMod_LoadBrushSides(header.lumps[LUMP_BRUSHSIDES]);
		CMod_LoadSubmodels(header.lumps[LUMP_MODELS]);

		CMod_LoadNodes(header.lumps[LUMP_NODES]);
		CMod_LoadAreas(header.lumps[LUMP_AREAS]);
		CMod_LoadAreaPortals(header.lumps[LUMP_AREAPORTALS]);
		CMod_LoadVisibility(header.lumps[LUMP_VISIBILITY]);
		CMod_LoadEntityString(header.lumps[LUMP_ENTITIES]);

		FS.FreeFile(buf);

		CM_InitBoxHull();

		Arrays.fill(portalopen, false);

		FloodAreaConnections();

		map_name = name;

		// debug (rst)
		/*		
		Com.p("Testing pointleafes:");
		for (int n = 0; n < 20; n++) {
			float pos[] = new float[] {(float) (Math.random() * 1000), (float) (Math.random() * 1000), 0 };
			int x = CM_PointLeafnum(pos);
			Com.p(Lib.vtofsbeaty(pos) + " ---> leaf=" + x + " area = " +map_leafs[x].area);
		}
		*/
		return map_cmodels[0];
	}

	/*
	=================
	CMod_LoadSubmodels
	=================
	*/
	public static void CMod_LoadSubmodels(lump_t l) {
		Com.DPrintf("CMod_LoadSubmodels...\n");
		qfiles.dmodel_t in;
		cmodel_t out;
		int i, j, count;

		if ((l.filelen % qfiles.dmodel_t.SIZE) != 0)
			Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size");

		count = l.filelen / qfiles.dmodel_t.SIZE;

		if (count < 1)
			Com.Error(ERR_DROP, "Map with no models");
		if (count > MAX_MAP_MODELS)
			Com.Error(ERR_DROP, "Map has too many models");

		Com.DPrintf("   numcmodels=" + count + "\n");
		numcmodels = count;

		if (debugloadmap) {
			Com.DPrintf("submodles(headnode, <origin>, <mins>, <maxs>)\n");
		}
		for (i = 0; i < count; i++) {
			in = new qfiles.dmodel_t(ByteBuffer.wrap(cmod_base, i * qfiles.dmodel_t.SIZE + l.fileofs, qfiles.dmodel_t.SIZE));
			out = map_cmodels[i];

			for (j = 0; j < 3; j++) { // spread the mins / maxs by a pixel
				out.mins[j] = in.mins[j] - 1;
				out.maxs[j] = in.maxs[j] + 1;
				out.origin[j] = in.origin[j];
			}
			out.headnode = in.headnode;
			if (debugloadmap) {
				Com.DPrintf(
					"|%6i|%8.2f|%8.2f|%8.2f|  %8.2f|%8.2f|%8.2f|   %8.2f|%8.2f|%8.2f|\n",
					new Vargs()
						.add(out.headnode)
						.add(out.origin[0])
						.add(out.origin[1])
						.add(out.origin[2])
						.add(out.mins[0])
						.add(out.mins[1])
						.add(out.mins[2])
						.add(out.maxs[0])
						.add(out.maxs[1])
						.add(out.maxs[2]));
			}
		}
	}
	static boolean debugloadmap = false;

	/*
	=================
	CMod_LoadSurfaces
	=================
	*/
	public static void CMod_LoadSurfaces(lump_t l) {
		Com.DPrintf("CMod_LoadSurfaces...\n");
		texinfo_t in;
		mapsurface_t out;
		int i, count;

		if ((l.filelen % texinfo_t.SIZE) != 0)
			Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size");

		count = l.filelen / texinfo_t.SIZE;
		if (count < 1)
			Com.Error(ERR_DROP, "Map with no surfaces");
		if (count > MAX_MAP_TEXINFO)
			Com.Error(ERR_DROP, "Map has too many surfaces");

		numtexinfo = count;
		Com.DPrintf("numtexinfo=" + count + "\n");
		if (debugloadmap)
			Com.DPrintf("surfaces:\n");

		for (i = 0; i < count; i++) {
			out = map_surfaces[i] = new mapsurface_t();
			in = new texinfo_t(cmod_base, l.fileofs + i * texinfo_t.SIZE, texinfo_t.SIZE);

			out.c.name = in.texture;
			out.rname = in.texture;
			out.c.flags = in.flags;
			out.c.value = in.value;

			if (debugloadmap) {
				Com.DPrintf("|%20s|%20s|%6i|%6i|\n", new Vargs().add(out.c.name).add(out.rname).add(out.c.value).add(out.c.flags));
			}

		}
	}

	/*
	=================
	CMod_LoadNodes
	
	=================
	*/
	public static void CMod_LoadNodes(lump_t l) {
		Com.DPrintf("CMod_LoadNodes...\n");
		qfiles.dnode_t in;
		int child;
		cnode_t out;
		int i, j, count;

		if ((l.filelen % qfiles.dnode_t.SIZE) != 0)
			Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size:" + l.fileofs + "," + qfiles.dnode_t.SIZE);
		count = l.filelen / qfiles.dnode_t.SIZE;

		if (count < 1)
			Com.Error(ERR_DROP, "Map has no nodes");
		if (count > MAX_MAP_NODES)
			Com.Error(ERR_DROP, "Map has too many nodes");

		numnodes = count;
		Com.DPrintf("   numnodes=" + count + "\n");

		if (debugloadmap) {
			Com.DPrintf("nodes(planenum, child[0], child[1])\n");
		}

		for (i = 0; i < count; i++) {
			in = new qfiles.dnode_t(ByteBuffer.wrap(cmod_base, qfiles.dnode_t.SIZE * i + l.fileofs, qfiles.dnode_t.SIZE));
			out = map_nodes[i];

			out.plane = map_planes[in.planenum];
			for (j = 0; j < 2; j++) {
				child = in.children[j];
				out.children[j] = child;
			}
			if (debugloadmap) {
				Com.DPrintf("|%6i| %6i| %6i|\n", new Vargs().add(in.planenum).add(out.children[0]).add(out.children[1]));
			}
		}
	}

	/*
	=================
	CMod_LoadBrushes
	
	=================
	*/
	public static void CMod_LoadBrushes(lump_t l) {
		Com.DPrintf("CMod_LoadBrushes...\n");
		qfiles.dbrush_t in;
		cbrush_t out;
		int i, count;

		if ((l.filelen % qfiles.dbrush_t.SIZE) != 0)
			Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size");

		count = l.filelen / qfiles.dbrush_t.SIZE;

		if (count > MAX_MAP_BRUSHES)
			Com.Error(ERR_DROP, "Map has too many brushes");

		numbrushes = count;
		Com.DPrintf("   numbrushes=" + count + "\n");
		if (debugloadmap) {
			Com.DPrintf("brushes:(firstbrushside, numsides, contents)\n");
		}
		for (i = 0; i < count; i++) {
			in = new qfiles.dbrush_t(ByteBuffer.wrap(cmod_base, i * qfiles.dbrush_t.SIZE + l.fileofs, qfiles.dbrush_t.SIZE));
			out = map_brushes[i];
			out.firstbrushside = in.firstside;
			out.numsides = in.numsides;
			out.contents = in.contents;

			if (debugloadmap) {
				Com.DPrintf("| %6i| %6i| %8X|\n", new Vargs().add(out.firstbrushside).add(out.numsides).add(out.contents));
			}
		}
	}

	/*
	=================
	CMod_LoadLeafs
	=================
	*/
	public static void CMod_LoadLeafs(lump_t l) {
		Com.DPrintf("CMod_LoadLeafs...\n");
		int i;
		cleaf_t out;
		qfiles.dleaf_t in;
		int count;

		if ((l.filelen % qfiles.dleaf_t.SIZE) != 0)
			Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size");

		count = l.filelen / qfiles.dleaf_t.SIZE;

		if (count < 1)
			Com.Error(ERR_DROP, "Map with no leafs");

		// need to save space for box planes
		if (count > MAX_MAP_PLANES)
			Com.Error(ERR_DROP, "Map has too many planes");

		Com.DPrintf("   numleafes=" + count + "\n");

		numleafs = count;
		numclusters = 0;
		if (debugloadmap)
			Com.DPrintf("cleaf-list:(contents, cluster, area, firstleafbrush, numleafbrushes)\n");
		for (i = 0; i < count; i++) {
			in = new qfiles.dleaf_t(cmod_base, i * qfiles.dleaf_t.SIZE + l.fileofs, qfiles.dleaf_t.SIZE);

			out = map_leafs[i];

			out.contents = in.contents;
			out.cluster = in.cluster;
			out.area = in.area;
			out.firstleafbrush = (short) in.firstleafbrush;
			out.numleafbrushes = (short) in.numleafbrushes;

			if (out.cluster >= numclusters)
				numclusters = out.cluster + 1;

			if (debugloadmap) {
				Com.DPrintf(
					"|%8x|%6i|%6i|%6i|\n",
					new Vargs().add(out.contents).add(out.cluster).add(out.area).add(out.firstleafbrush).add(out.numleafbrushes));
			}

		}

		Com.DPrintf("   numclusters=" + numclusters + "\n");

		if (map_leafs[0].contents != CONTENTS_SOLID)
			Com.Error(ERR_DROP, "Map leaf 0 is not CONTENTS_SOLID");

		solidleaf = 0;
		emptyleaf = -1;

		for (i = 1; i < numleafs; i++) {
			if (map_leafs[i].contents == 0) {
				emptyleaf = i;
				break;
			}
		}

		if (emptyleaf == -1)
			Com.Error(ERR_DROP, "Map does not have an empty leaf");
	}

	/*
	=================
	CMod_LoadPlanes
	=================
	*/
	public static void CMod_LoadPlanes(lump_t l) {
		Com.DPrintf("CMod_LoadPlanes...\n");
		int i, j;
		cplane_t out;
		qfiles.dplane_t in;
		int count;
		int bits;

		if ((l.filelen % qfiles.dplane_t.SIZE) != 0)
			Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size");

		count = l.filelen / qfiles.dplane_t.SIZE;

		if (count < 1)
			Com.Error(ERR_DROP, "Map with no planes");

		// need to save space for box planes
		if (count > MAX_MAP_PLANES)
			Com.Error(ERR_DROP, "Map has too many planes");

		Com.DPrintf("   numplanes=" + count + "\n");

		numplanes = count;
		if (debugloadmap) {
			Com.DPrintf("cplanes(normal[0],normal[1],normal[2], dist, type, signbits)\n");
		}

		for (i = 0; i < count; i++) {
			in = new qfiles.dplane_t(ByteBuffer.wrap(cmod_base, i * qfiles.dplane_t.SIZE + l.fileofs, qfiles.dplane_t.SIZE));

			out = map_planes[i];

			bits = 0;
			for (j = 0; j < 3; j++) {
				out.normal[j] = in.normal[j];

				if (out.normal[j] < 0)
					bits |= 1 << j;
			}

			out.dist = in.dist;
			out.type = (byte) in.type;
			out.signbits = (byte) bits;

			if (debugloadmap) {
				Com.DPrintf(
					"|%6.2f|%6.2f|%6.2f| %10.2f|%3i| %1i|\n",
					new Vargs().add(out.normal[0]).add(out.normal[1]).add(out.normal[2]).add(out.dist).add(out.type).add(
						out.signbits));
			}
		}
	}

	/*
	=================
	CMod_LoadLeafBrushes
	=================
	*/
	public static void CMod_LoadLeafBrushes(lump_t l) {
		Com.DPrintf("CMod_LoadLeafBrushes...\n");
		int i;
		int out[];
		short in[];
		int count;

		if ((l.filelen % 2) != 0)
			Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size");

		count = l.filelen / 2;

		Com.DPrintf("   numbrushes=" + count + "\n");

		if (count < 1)
			Com.Error(ERR_DROP, "Map with no planes");

		// need to save space for box planes
		if (count > MAX_MAP_LEAFBRUSHES)
			Com.Error(ERR_DROP, "Map has too many leafbrushes");

		out = map_leafbrushes;
		numleafbrushes = count;

		ByteBuffer bb = ByteBuffer.wrap(cmod_base, l.fileofs, count * 2).order(ByteOrder.LITTLE_ENDIAN);

		if (debugloadmap) {
			Com.DPrintf("map_brushes:\n");
		}

		for (i = 0; i < count; i++) {
			out[i] = bb.getShort();
			if (debugloadmap) {
				Com.DPrintf("|%6i|%6i|\n", new Vargs().add(i).add(out[i]));
			}
		}
	}

	/*
	=================
	CMod_LoadBrushSides
	=================
	*/
	public static void CMod_LoadBrushSides(lump_t l) {
		Com.DPrintf("CMod_LoadBrushSides...\n");
		int i, j;
		cbrushside_t out;
		qfiles.dbrushside_t in;
		int count;
		int num;

		if ((l.filelen % qfiles.dbrushside_t.SIZE) != 0)
			Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size");
		count = l.filelen / qfiles.dbrushside_t.SIZE;

		// need to save space for box planes
		if (count > MAX_MAP_BRUSHSIDES)
			Com.Error(ERR_DROP, "Map has too many planes");

		numbrushsides = count;

		Com.DPrintf("   numbrushsides=" + count + "\n");

		if (debugloadmap) {
			Com.DPrintf("brushside(planenum, surfacenum):\n");
		}
		for (i = 0; i < count; i++) {

			in =
				new qfiles.dbrushside_t(
					ByteBuffer.wrap(cmod_base, i * qfiles.dbrushside_t.SIZE + l.fileofs, qfiles.dbrushside_t.SIZE));

			out = map_brushsides[i];

			num = in.planenum;

			out.plane = map_planes[num]; // pointer

			j = in.texinfo;

			if (j >= numtexinfo)
				Com.Error(ERR_DROP, "Bad brushside texinfo");

			// rst: some mysterious happens here, even in the original code ???, texinfo is -1!!!
			// hoz: checked against c version: ok.
			if (j == -1)
				out.surface = new mapsurface_t(); // just for safety
			else
				out.surface = map_surfaces[j];

			if (debugloadmap) {
				Com.DPrintf("| %6i| %6i|\n", new Vargs().add(num).add(j));
			}
		}
	}

	/*
	=================
	CMod_LoadAreas
	=================
	*/
	public static void CMod_LoadAreas(lump_t l) {
		Com.DPrintf("CMod_LoadAreas...\n");
		int i;
		carea_t out;
		qfiles.darea_t in;
		int count;

		if ((l.filelen % qfiles.darea_t.SIZE) != 0)
			Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size");

		count = l.filelen / qfiles.darea_t.SIZE;

		if (count > MAX_MAP_AREAS)
			Com.Error(ERR_DROP, "Map has too many areas");

		Com.DPrintf("   numareas=" + count + "\n");
		numareas = count;

		if (debugloadmap) {
			Com.DPrintf("areas(numportals, firstportal)\n");
		}

		for (i = 0; i < count; i++) {

			in = new qfiles.darea_t(ByteBuffer.wrap(cmod_base, i * qfiles.darea_t.SIZE + l.fileofs, qfiles.darea_t.SIZE));
			out = map_areas[i];

			out.numareaportals = in.numareaportals;
			out.firstareaportal = in.firstareaportal;
			out.floodvalid = 0;
			out.floodnum = 0;
			if (debugloadmap) {
				Com.DPrintf("| %6i| %6i|\n", new Vargs().add(out.numareaportals).add(out.firstareaportal));
			}
		}
	}

	/*
	=================
	CMod_LoadAreaPortals
	=================
	*/
	public static void CMod_LoadAreaPortals(lump_t l) {
		Com.DPrintf("CMod_LoadAreaPortals...\n");
		int i;
		qfiles.dareaportal_t out;
		qfiles.dareaportal_t in;
		int count;

		if ((l.filelen % qfiles.dareaportal_t.SIZE) != 0)
			Com.Error(ERR_DROP, "MOD_LoadBmodel: funny lump size");
		count = l.filelen / qfiles.dareaportal_t.SIZE;

		if (count > MAX_MAP_AREAS)
			Com.Error(ERR_DROP, "Map has too many areas");

		numareaportals = count;
		Com.DPrintf("   numareaportals=" + count + "\n");
		if (debugloadmap) {
			Com.DPrintf("areaportals(portalnum, otherarea)\n");
		}
		for (i = 0; i < count; i++) {
			in =
				new qfiles.dareaportal_t(
					ByteBuffer.wrap(cmod_base, i * qfiles.dareaportal_t.SIZE + l.fileofs, qfiles.dareaportal_t.SIZE));

			out = map_areaportals[i];

			out.portalnum = in.portalnum;
			out.otherarea = in.otherarea;

			if (debugloadmap) {
				Com.DPrintf("|%6i|%6i|\n", new Vargs().add(out.portalnum).add(out.otherarea));
			}
		}
	}


	/*
	=================
	CMod_LoadVisibility
	=================
	*/
	public static void CMod_LoadVisibility(lump_t l) {
		Com.DPrintf("CMod_LoadVisibility...\n");
		int i;

		numvisibility = l.filelen;

		Com.DPrintf("   numvisibility=" + numvisibility + "\n");

		if (l.filelen > MAX_MAP_VISIBILITY)
			Com.Error(ERR_DROP, "Map has too large visibility lump");

		System.arraycopy(cmod_base, l.fileofs, map_visibility, 0, l.filelen);

		ByteBuffer bb = ByteBuffer.wrap(map_visibility, 0, l.filelen);
		bb.order(ByteOrder.LITTLE_ENDIAN);

		map_vis = new qfiles.dvis_t(bb);

	}

	/*
	=================
	CMod_LoadEntityString
	=================
	*/
	public static void CMod_LoadEntityString(lump_t l) {
		Com.DPrintf("CMod_LoadEntityString...\n");

		numentitychars = l.filelen;

		if (l.filelen > MAX_MAP_ENTSTRING)
			Com.Error(ERR_DROP, "Map has too large entity lump");

		int x = 0;
		for (; x < l.filelen && cmod_base[x + l.fileofs] != 0; x++);

		map_entitystring = new String(cmod_base, l.fileofs, x).trim();
	}

	/*
	==================
	CM_InlineModel
	==================
	*/

	// works fine
	public static cmodel_t InlineModel(String name) {
		int num;

		if (name == null || name.charAt(0) != '*')
			Com.Error(ERR_DROP, "CM_InlineModel: bad name");

		num = atoi(name.substring(1));

		if (num < 1 || num >= numcmodels)
			Com.Error(ERR_DROP, "CM_InlineModel: bad number");

		return map_cmodels[num];
	}

	public static int CM_NumClusters() {
		return numclusters;
	}

	public static int CM_NumInlineModels() {
		return numcmodels;
	}

	public static String CM_EntityString() {
		return map_entitystring;
	}

	public static int CM_LeafContents(int leafnum) {
		if (leafnum < 0 || leafnum >= numleafs)
			Com.Error(ERR_DROP, "CM_LeafContents: bad number");
		return map_leafs[leafnum].contents;
	}

	public static int CM_LeafCluster(int leafnum) {
		if (leafnum < 0 || leafnum >= numleafs)
			Com.Error(ERR_DROP, "CM_LeafCluster: bad number");
		return map_leafs[leafnum].cluster;
	}

	public static int CM_LeafArea(int leafnum) {
		if (leafnum < 0 || leafnum >= numleafs)
			Com.Error(ERR_DROP, "CM_LeafArea: bad number");
		return map_leafs[leafnum].area;
	}

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

	static cplane_t box_planes[];
	static int box_headnode;
	static cbrush_t box_brush;
	static cleaf_t box_leaf;

	/*
	===================
	CM_InitBoxHull
	
	Set up the planes and nodes so that the six floats of a bounding box
	can just be stored out and get a proper clipping hull structure.
	===================
	*/
	public static void CM_InitBoxHull() {
		int i;
		int side;
		cnode_t c;
		cplane_t p;
		cbrushside_t s;

		box_headnode = numnodes; // noch platz f?r 6 brushes

		box_planes =
			new cplane_t[] {
				map_planes[numplanes],
				map_planes[numplanes + 1],
				map_planes[numplanes + 2],
				map_planes[numplanes + 3],
				map_planes[numplanes + 4],
				map_planes[numplanes + 5],
				map_planes[numplanes + 6],
				map_planes[numplanes + 7],
				map_planes[numplanes + 8],
				map_planes[numplanes + 9],
				map_planes[numplanes + 10],
				map_planes[numplanes + 11],
				map_planes[numplanes + 12] };

		if (numnodes + 6 > MAX_MAP_NODES
			|| numbrushes + 1 > MAX_MAP_BRUSHES
			|| numleafbrushes + 1 > MAX_MAP_LEAFBRUSHES
			|| numbrushsides + 6 > MAX_MAP_BRUSHSIDES
			|| numplanes + 12 > MAX_MAP_PLANES)
			Com.Error(ERR_DROP, "Not enough room for box tree");

		box_brush = map_brushes[numbrushes];
		box_brush.numsides = 6;
		box_brush.firstbrushside = numbrushsides;
		box_brush.contents = CONTENTS_MONSTER;

		box_leaf = map_leafs[numleafs];
		box_leaf.contents = CONTENTS_MONSTER;
		box_leaf.firstleafbrush = (short) numleafbrushes;
		box_leaf.numleafbrushes = 1;

		map_leafbrushes[numleafbrushes] = numbrushes;

		for (i = 0; i < 6; i++) {
			side = i & 1;

			// brush sides
			s = map_brushsides[numbrushsides + i];
			s.plane = map_planes[(numplanes + i * 2 + side)];
			s.surface = nullsurface;

			// nodes
			c = map_nodes[box_headnode + i];
			c.plane = map_planes[(numplanes + i * 2)];
			c.children[side] = -1 - emptyleaf;
			if (i != 5)
				c.children[side ^ 1] = box_headnode + i + 1;
			else
				c.children[side ^ 1] = -1 - numleafs;

			// planes
			p = box_planes[i * 2];
			p.type = (byte) (i >> 1);
			p.signbits = 0;
			VectorClear(p.normal);
			p.normal[i >> 1] = 1;

			p = box_planes[i * 2 + 1];
			p.type = (byte) (3 + (i >> 1));
			p.signbits = 0;
			VectorClear(p.normal);
			p.normal[i >> 1] = -1;
		}
	}

	/*
	===================
	CM_HeadnodeForBox
	
	To keep everything totally uniform, bounding boxes are turned into small
	BSP trees instead of being compared directly.
	===================
	*/
	public static int HeadnodeForBox(float[] mins, float[] maxs) {
		box_planes[0].dist = maxs[0];
		box_planes[1].dist = -maxs[0];
		box_planes[2].dist = mins[0];
		box_planes[3].dist = -mins[0];
		box_planes[4].dist = maxs[1];
		box_planes[5].dist = -maxs[1];
		box_planes[6].dist = mins[1];
		box_planes[7].dist = -mins[1];
		box_planes[8].dist = maxs[2];
		box_planes[9].dist = -maxs[2];
		box_planes[10].dist = mins[2];
		box_planes[11].dist = -mins[2];

		return box_headnode;
	}

	/*
	==================
	CM_PointLeafnum_r
	==================
	*/
	public static int CM_PointLeafnum_r(float[] p, int num) {
		float d;
		cnode_t node;
		cplane_t plane;

		while (num >= 0) {
			node = map_nodes[num];
			plane = node.plane;

			if (plane.type < 3)
				d = p[plane.type] - plane.dist;
			else
				d = DotProduct(plane.normal, p) - plane.dist;
			if (d < 0)
				num = node.children[1];
			else
				num = node.children[0];
		}

		c_pointcontents++; // optimize counter

		return -1 - num;
	}

	public static int CM_PointLeafnum(float[] p) {
		if (numplanes == 0)
			return 0; // sound may call this without map loaded
		return CM_PointLeafnum_r(p, 0);
	}

	/*
	=============
	CM_BoxLeafnums
	
	Fills in a list of all the leafs touched
	=============
	*/
	static int leaf_count, leaf_maxcount;
	static int leaf_list[];
	static float leaf_mins[], leaf_maxs[];
	static int leaf_topnode;

	public static void CM_BoxLeafnums_r(int nodenum) {
		cplane_t plane;
		cnode_t node;
		int s;

		while (true) {
			if (nodenum < 0) {
				if (leaf_count >= leaf_maxcount) {
					//TODO: here is still an error.
					//Com.DPrintf("CM_BoxLeafnums_r: overflow\n");
					return;
				}
				leaf_list[leaf_count++] = -1 - nodenum;
				return;
			}

			node = map_nodes[nodenum];
			plane = node.plane;

			s = Math3D.BoxOnPlaneSide(leaf_mins, leaf_maxs, plane);

			if (s == 1)
				nodenum = node.children[0];
			else if (s == 2)
				nodenum = node.children[1];
			else {
				// go down both
				if (leaf_topnode == -1)
					leaf_topnode = nodenum;
				CM_BoxLeafnums_r(node.children[0]);
				nodenum = node.children[1];
			}
		}
	}

	public static int CM_BoxLeafnums_headnode(float[] mins, float[] maxs, int list[], int listsize, int headnode, int topnode[]) {
		leaf_list = list;
		leaf_count = 0;
		leaf_maxcount = listsize;
		leaf_mins = mins;
		leaf_maxs = maxs;

		leaf_topnode = -1;

		CM_BoxLeafnums_r(headnode);

		if (topnode != null)
			topnode[0] = leaf_topnode;

		return leaf_count;
	}

	public static int CM_BoxLeafnums(float[] mins, float[] maxs, int list[], int listsize, int topnode[]) {
		return CM_BoxLeafnums_headnode(mins, maxs, list, listsize, map_cmodels[0].headnode, topnode);
	}

	/*
	public static class intwrap1 {
		public intwrap(int i) {
			this.i = i;
		}
		public int i;
	}
	*/
	/*
	==================
	CM_PointContents
	==================
	*/
	public static int PointContents(float[] p, int headnode) {
		int l;

		if (numnodes == 0) // map not loaded
			return 0;

		l = CM_PointLeafnum_r(p, headnode);

		return map_leafs[l].contents;
	}

	/*
	==================
	CM_TransformedPointContents
	
	Handles offseting and rotation of the end points for moving and
	rotating entities
	==================
	*/
	public static int TransformedPointContents(float[] p, int headnode, float[] origin, float[] angles) {
		float[] p_l = { 0, 0, 0 };
		float[] temp = { 0, 0, 0 };
		float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 }, up = { 0, 0, 0 };
		int l;

		// subtract origin offset
		VectorSubtract(p, origin, p_l);

		// rotate start and end into the models frame of reference
		if (headnode != box_headnode && (angles[0] != 0 || angles[1] != 0 || angles[2] != 0)) {
			AngleVectors(angles, forward, right, up);

			VectorCopy(p_l, temp);
			p_l[0] = DotProduct(temp, forward);
			p_l[1] = -DotProduct(temp, right);
			p_l[2] = DotProduct(temp, up);
		}

		l = CM_PointLeafnum_r(p_l, headnode);

		return map_leafs[l].contents;
	}

	/*
	===============================================================================
	
	BOX TRACING
	
	===============================================================================
	*/

	// 1/32 epsilon to keep floating point happy
	private static final float DIST_EPSILON = 0.03125f;

	private static float[] trace_start = { 0, 0, 0 }, trace_end = { 0, 0, 0 };
	private static float[] trace_mins = { 0, 0, 0 }, trace_maxs = { 0, 0, 0 };
	private static float[] trace_extents = { 0, 0, 0 };

	private static trace_t trace_trace = new trace_t();
	private static int trace_contents;
	private static boolean trace_ispoint; // optimized case

	/*
	================
	CM_ClipBoxToBrush
	================
	*/
	public static void CM_ClipBoxToBrush(float[] mins, float[] maxs, float[] p1, float[] p2, trace_t trace, cbrush_t brush) {
		int i, j;
		cplane_t plane, clipplane;
		float dist;
		float enterfrac, leavefrac;
		float[] ofs = { 0, 0, 0 };
		float d1, d2;
		boolean getout, startout;
		float f;
		cbrushside_t side, leadside;

		enterfrac = -1;
		leavefrac = 1;
		clipplane = null;

		if (brush.numsides == 0)
			return;

		c_brush_traces++;

		getout = false;
		startout = false;
		leadside = null;

		for (i = 0; i < brush.numsides; i++) {
			side = map_brushsides[brush.firstbrushside + i];
			plane = side.plane;

			// FIXME: special case for axial

			if (!trace_ispoint) { // general box case

				// push the plane out apropriately for mins/maxs

				// FIXME: use signbits into 8 way lookup for each mins/maxs
				for (j = 0; j < 3; j++) {
					if (plane.normal[j] < 0)
						ofs[j] = maxs[j];
					else
						ofs[j] = mins[j];
				}
				dist = DotProduct(ofs, plane.normal);
				dist = plane.dist - dist;
			}
			else { // special point case
				dist = plane.dist;
			}

			d1 = DotProduct(p1, plane.normal) - dist;
			d2 = DotProduct(p2, plane.normal) - dist;

			if (d2 > 0)
				getout = true; // endpoint is not in solid
			if (d1 > 0)
				startout = true;

			// if completely in front of face, no intersection
			if (d1 > 0 && d2 >= d1)
				return;

			if (d1 <= 0 && d2 <= 0)
				continue;

			// crosses face
			if (d1 > d2) { // enter
				f = (d1 - DIST_EPSILON) / (d1 - d2);
				if (f > enterfrac) {
					enterfrac = f;
					clipplane = plane;
					leadside = side;
				}
			}
			else { // leave
				f = (d1 + DIST_EPSILON) / (d1 - d2);
				if (f < leavefrac)
					leavefrac = f;
			}
		}

		if (!startout) { // original point was inside brush
			trace.startsolid = true;
			if (!getout)
				trace.allsolid = true;
			return;
		}
		if (enterfrac < leavefrac) {
			if (enterfrac > -1 && enterfrac < trace.fraction) {
				if (enterfrac < 0)
					enterfrac = 0;
				trace.fraction = enterfrac;
				// copy
				trace.plane.set(clipplane);
				trace.surface = leadside.surface.c;
				trace.contents = brush.contents;
			}
		}
	}

	/*
	================
	CM_TestBoxInBrush
	================
	*/
	public static void CM_TestBoxInBrush(float[] mins, float[] maxs, float[] p1, trace_t trace, cbrush_t brush) {
		int i, j;
		cplane_t plane;
		float dist;
		float[] ofs = { 0, 0, 0 };
		float d1;
		cbrushside_t side;

		if (brush.numsides == 0)
			return;

		for (i = 0; i < brush.numsides; i++) {
			side = map_brushsides[brush.firstbrushside + i];
			plane = side.plane;

			// FIXME: special case for axial
			// general box case
			// push the plane out apropriately for mins/maxs
			// FIXME: use signbits into 8 way lookup for each mins/maxs

			for (j = 0; j < 3; j++) {
				if (plane.normal[j] < 0)
					ofs[j] = maxs[j];
				else
					ofs[j] = mins[j];
			}
			dist = DotProduct(ofs, plane.normal);
			dist = plane.dist - dist;

			d1 = DotProduct(p1, plane.normal) - dist;

			// if completely in front of face, no intersection
			if (d1 > 0)
				return;

		}

		// inside this brush
		trace.startsolid = trace.allsolid = true;
		trace.fraction = 0;
		trace.contents = brush.contents;
	}

	/*
	================
	CM_TraceToLeaf
	================
	*/
	public static void CM_TraceToLeaf(int leafnum) {
		int k;
		int brushnum;
		cleaf_t leaf;
		cbrush_t b;

		leaf = map_leafs[leafnum];
		if (0 == (leaf.contents & trace_contents))
			return;

		// trace line against all brushes in the leaf
		for (k = 0; k < leaf.numleafbrushes; k++) {

			brushnum = map_leafbrushes[leaf.firstleafbrush + k];
			b = map_brushes[brushnum];
			if (b.checkcount == checkcount)
				continue; // already checked this brush in another leaf
			b.checkcount = checkcount;

			if (0 == (b.contents & trace_contents))
				continue;
			CM_ClipBoxToBrush(trace_mins, trace_maxs, trace_start, trace_end, trace_trace, b);
			if (0 == trace_trace.fraction)
				return;
		}

	}

	/*
	================
	CM_TestInLeaf
	================
	*/
	public static void CM_TestInLeaf(int leafnum) {
		int k;
		int brushnum;
		cleaf_t leaf;
		cbrush_t b;

		leaf = map_leafs[leafnum];
		if (0 == (leaf.contents & trace_contents))
			return;
		// trace line against all brushes in the leaf
		for (k = 0; k < leaf.numleafbrushes; k++) {
			brushnum = map_leafbrushes[leaf.firstleafbrush + k];
			b = map_brushes[brushnum];
			if (b.checkcount == checkcount)
				continue; // already checked this brush in another leaf
			b.checkcount = checkcount;

			if (0 == (b.contents & trace_contents))
				continue;
			CM_TestBoxInBrush(trace_mins, trace_maxs, trace_start, trace_trace, b);
			if (0 == trace_trace.fraction)
				return;
		}

	}

	/*
	==================
	CM_RecursiveHullCheck
	==================
	*/
	public static void CM_RecursiveHullCheck(int num, float p1f, float p2f, float[] p1, float[] p2) {
		cnode_t node;
		cplane_t plane;
		float t1, t2, offset;
		float frac, frac2;
		float idist;
		int i;
		float[] mid = { 0, 0, 0 };
		int side;
		float midf;

		if (trace_trace.fraction <= p1f)
			return; // already hit something nearer

		// if < 0, we are in a leaf node
		if (num < 0) {
			CM_TraceToLeaf(-1 - num);
			return;
		}

		//
		// find the point distances to the seperating plane
		// and the offset for the size of the box
		//
		node = map_nodes[num];
		plane = node.plane;

		if (plane.type < 3) {
			t1 = p1[plane.type] - plane.dist;
			t2 = p2[plane.type] - plane.dist;
			offset = trace_extents[plane.type];
		}
		else {
			t1 = DotProduct(plane.normal, p1) - plane.dist;
			t2 = DotProduct(plane.normal, p2) - plane.dist;
			if (trace_ispoint)
				offset = 0;
			else
				offset =
					Math.abs(trace_extents[0] * plane.normal[0])
						+ Math.abs(trace_extents[1] * plane.normal[1])
						+ Math.abs(trace_extents[2] * plane.normal[2]);
		}

		// see which sides we need to consider
		if (t1 >= offset && t2 >= offset) {
			CM_RecursiveHullCheck(node.children[0], p1f, p2f, p1, p2);
			return;
		}
		if (t1 < -offset && t2 < -offset) {
			CM_RecursiveHullCheck(node.children[1], p1f, p2f, p1, p2);
			return;
		}

		// put the crosspoint DIST_EPSILON pixels on the near side
		if (t1 < t2) {
			idist = 1.0f / (t1 - t2);
			side = 1;
			frac2 = (t1 + offset + DIST_EPSILON) * idist;
			frac = (t1 - offset + DIST_EPSILON) * idist;
		}
		else if (t1 > t2) {
			idist = 1.0f / (t1 - t2);
			side = 0;
			frac2 = (t1 - offset - DIST_EPSILON) * idist;
			frac = (t1 + offset + DIST_EPSILON) * idist;
		}
		else {
			side = 0;
			frac = 1;
			frac2 = 0;
		}

		// move up to the node
		if (frac < 0)
			frac = 0;
		if (frac > 1)
			frac = 1;

		midf = p1f + (p2f - p1f) * frac;
		for (i = 0; i < 3; i++)
			mid[i] = p1[i] + frac * (p2[i] - p1[i]);

		CM_RecursiveHullCheck(node.children[side], p1f, midf, p1, mid);

		// go past the node
		if (frac2 < 0)
			frac2 = 0;
		if (frac2 > 1)
			frac2 = 1;

		midf = p1f + (p2f - p1f) * frac2;
		for (i = 0; i < 3; i++)
			mid[i] = p1[i] + frac2 * (p2[i] - p1[i]);

		CM_RecursiveHullCheck(node.children[side ^ 1], midf, p2f, mid, p2);
	}

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

	/*
	==================
	CM_BoxTrace
	==================
	*/
	public static trace_t BoxTrace(float[] start, float[] end, float[] mins, float[] maxs, int headnode, int brushmask) {

		// for multi-check avoidance
		checkcount++;

		// for statistics, may be zeroed
		c_traces++;

		// fill in a default trace
		//was: memset(& trace_trace, 0, sizeof(trace_trace));
		trace_trace = new trace_t();

		trace_trace.fraction = 1;
		trace_trace.surface = nullsurface.c;

		if (numnodes == 0) // map not loaded
			{
			Com.DPrintf("dummy trace zurueck, da map not loaded!\n");
			return trace_trace;
		}

		trace_contents = brushmask;
		VectorCopy(start, trace_start);
		VectorCopy(end, trace_end);
		VectorCopy(mins, trace_mins);
		VectorCopy(maxs, trace_maxs);

		//
		// check for position test special case
		//
		if (start[0] == end[0] && start[1] == end[1] && start[2] == end[2]) {

			int leafs[] = new int[1024];
			int i, numleafs;
			float[] c1 = { 0, 0, 0 }, c2 = { 0, 0, 0 };
			int topnode = 0;

			VectorAdd(start, mins, c1);
			VectorAdd(start, maxs, c2);

			for (i = 0; i < 3; i++) {
				c1[i] -= 1;
				c2[i] += 1;
			}

			int tn[] = {topnode};

			numleafs = CM_BoxLeafnums_headnode(c1, c2, leafs, 1024, headnode, tn);
			topnode = tn[0];
			for (i = 0; i < numleafs; i++) {
				CM_TestInLeaf(leafs[i]);
				if (trace_trace.allsolid)
					break;
			}
			VectorCopy(start, trace_trace.endpos);
			return trace_trace;
		}

		//
		// check for point special case
		//
		if (mins[0] == 0 && mins[1] == 0 && mins[2] == 0 && maxs[0] == 0 && maxs[1] == 0 && maxs[2] == 0) {
			trace_ispoint = true;
			VectorClear(trace_extents);
		}
		else {
			trace_ispoint = false;
			trace_extents[0] = -mins[0] > maxs[0] ? -mins[0] : maxs[0];
			trace_extents[1] = -mins[1] > maxs[1] ? -mins[1] : maxs[1];
			trace_extents[2] = -mins[2] > maxs[2] ? -mins[2] : maxs[2];
		}

		//
		// general sweeping through world
		//
		CM_RecursiveHullCheck(headnode, 0, 1, start, end);

		if (trace_trace.fraction == 1) {
			VectorCopy(end, trace_trace.endpos);
		}
		else {
			for (int i = 0; i < 3; i++)
				trace_trace.endpos[i] = start[i] + trace_trace.fraction * (end[i] - start[i]);
		}
		return trace_trace;
	}

	/*
	==================
	CM_TransformedBoxTrace
	
	Handles offseting and rotation of the end points for moving and
	rotating entities
	==================
	*/
	public static trace_t TransformedBoxTrace(
		float[] start,
		float[] end,
		float[] mins,
		float[] maxs,
		int headnode,
		int brushmask,
		float[] origin,
		float[] angles) {
		trace_t trace;
		float[] start_l = { 0, 0, 0 }, end_l = { 0, 0, 0 };
		float[] a = { 0, 0, 0 };
		float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 }, up = { 0, 0, 0 };
		float[] temp = { 0, 0, 0 };
		boolean rotated;

		// subtract origin offset
		VectorSubtract(start, origin, start_l);
		VectorSubtract(end, origin, end_l);

		// rotate start and end into the models frame of reference
		if (headnode != box_headnode && (angles[0] != 0 || angles[1] != 0 || angles[2] != 0))
			rotated = true;
		else
			rotated = false;

		if (rotated) {
			AngleVectors(angles, forward, right, up);

			VectorCopy(start_l, temp);
			start_l[0] = DotProduct(temp, forward);
			start_l[1] = -DotProduct(temp, right);
			start_l[2] = DotProduct(temp, up);

			VectorCopy(end_l, temp);
			end_l[0] = DotProduct(temp, forward);
			end_l[1] = -DotProduct(temp, right);
			end_l[2] = DotProduct(temp, up);
		}

		// sweep the box through the model
		trace = BoxTrace(start_l, end_l, mins, maxs, headnode, brushmask);

		if (rotated && trace.fraction != 1.0) {
			// FIXME: figure out how to do this with existing angles
			VectorNegate(angles, a);
			AngleVectors(a, forward, right, up);

			VectorCopy(trace.plane.normal, temp);
			trace.plane.normal[0] = DotProduct(temp, forward);
			trace.plane.normal[1] = -DotProduct(temp, right);
			trace.plane.normal[2] = DotProduct(temp, up);
		}

		trace.endpos[0] = start[0] + trace.fraction * (end[0] - start[0]);
		trace.endpos[1] = start[1] + trace.fraction * (end[1] - start[1]);
		trace.endpos[2] = start[2] + trace.fraction * (end[2] - start[2]);

		return trace;
	}

	/*
	===============================================================================	
	PVS / PHS
	===============================================================================
	*/

	/*
	===================
	CM_DecompressVis
	===================
	*/
	public static void CM_DecompressVis(byte in[], int offset, byte out[]) {
		int c;

		int row;

		row = (numclusters + 7) >> 3;
		int outp = 0;
		int inp = offset;

		if (in == null || numvisibility == 0) { // no vis info, so make all visible
			while (row != 0) {
				out[outp++] = (byte) 0xFF;
				row--;
			}
			return;
		}

		do {
			if (in[inp] != 0) {
				out[outp++] = in[inp++];
				continue;
			}

			c = in[inp + 1] & 0xFF;
			inp += 2;
			if (outp + c > row) {
				c = row - (outp);
				Com.DPrintf("warning: Vis decompression overrun\n");
			}
				while (c != 0) {
					out[outp++] = 0;
					c--;
				}
		}
		while (outp < row);
	}

	public static byte pvsrow[] = new byte[MAX_MAP_LEAFS / 8];
	public static byte phsrow[] = new byte[MAX_MAP_LEAFS / 8];

	public static byte[] CM_ClusterPVS(int cluster) {
		if (cluster == -1)
			Arrays.fill(pvsrow, 0, (numclusters + 7) >> 3, (byte)0);
		else
			CM_DecompressVis(map_visibility, map_vis.bitofs[cluster][DVIS_PVS], pvsrow);
		return pvsrow;
	}

	public static byte[] CM_ClusterPHS(int cluster) {
		if (cluster == -1)
			Arrays.fill(phsrow, 0, (numclusters + 7) >> 3, (byte)0);
		else
			CM_DecompressVis(map_visibility, map_vis.bitofs[cluster][Defines.DVIS_PHS], phsrow);
		return phsrow;
	}

	/*
	===============================================================================
	AREAPORTALS
	===============================================================================
	*/

	public static void FloodArea_r(carea_t area, int floodnum) {
		//Com.Printf("FloodArea_r(" + floodnum + ")...\n");
		int i;
		qfiles.dareaportal_t p;

		if (area.floodvalid == floodvalid) {
			if (area.floodnum == floodnum)
				return;
			Com.Error(ERR_DROP, "FloodArea_r: reflooded");
		}

		area.floodnum = floodnum;
		area.floodvalid = floodvalid;

		for (i = 0; i < area.numareaportals; i++) {
			p = map_areaportals[area.firstareaportal + i];
			if (portalopen[p.portalnum])
				FloodArea_r(map_areas[p.otherarea], floodnum);
		}
	}

	/*
	====================
	FloodAreaConnections
	====================
	*/
	public static void FloodAreaConnections() {
		Com.DPrintf("FloodAreaConnections...\n");

		int i;
		carea_t area;
		int floodnum;

		// all current floods are now invalid
		floodvalid++;
		floodnum = 0;

		// area 0 is not used
		for (i = 1; i < numareas; i++) {

			area = map_areas[i];

			if (area.floodvalid == floodvalid)
				continue; // already flooded into
			floodnum++;
			FloodArea_r(area, floodnum);
		}
	}

	/*
	=================
	CM_SetAreaPortalState 
	=================
	*/
	public static void CM_SetAreaPortalState(int portalnum, boolean open) {
		if (portalnum > numareaportals)
			Com.Error(ERR_DROP, "areaportal > numareaportals");

		portalopen[portalnum] = open;
		FloodAreaConnections();
	}

	/*
	=================
	CM_AreasConnected 
	=================
	*/

	public static boolean CM_AreasConnected(int area1, int area2) {
		if (map_noareas.value != 0)
			return true;

		if (area1 > numareas || area2 > numareas)
			Com.Error(ERR_DROP, "area > numareas");

		if (map_areas[area1].floodnum == map_areas[area2].floodnum)
			return true;

		return false;
	}

	/*
	=================
	CM_WriteAreaBits
	
	Writes a length byte followed by a bit vector of all the areas
	that area in the same flood as the area parameter
	
	This is used by the client refreshes to cull visibility
	=================
	*/
	public static int CM_WriteAreaBits(byte buffer[], int area) {
		int i;
		int floodnum;
		int bytes;

		bytes = (numareas + 7) >> 3;

		if (map_noareas.value != 0) { // for debugging, send everything
			Arrays.fill(buffer, 0, bytes, (byte)255);
		}
		else {
			Arrays.fill(buffer, 0, bytes, (byte)0);
			floodnum = map_areas[area].floodnum;
			for (i = 0; i < numareas; i++) {
				if (map_areas[i].floodnum == floodnum || area == 0)
					buffer[i >> 3] |= 1 << (i & 7);
			}
		}

		return bytes;
	}

	/*
	===================
	CM_WritePortalState
	
	Writes the portal state to a savegame file
	===================
	*/

	public static void CM_WritePortalState(RandomAccessFile os) {

		//was: fwrite(portalopen, sizeof(portalopen), 1, f);
		try {

			for (int n = 0; n < portalopen.length; n++)
				if (portalopen[n])
					os.writeInt(1);
				else
					os.writeInt(0);
		}
		catch (Exception e) {
			Com.Printf("ERROR:" + e);
			e.printStackTrace();
		}
	}

	/*
	===================
	CM_ReadPortalState
	
	Reads the portal state from a savegame file
	and recalculates the area connections
	===================
	*/
	public static void CM_ReadPortalState(RandomAccessFile f) {

		//was: FS_Read(portalopen, sizeof(portalopen), f);
		int len = portalopen.length * 4;

		byte buf[] = new byte[len];


		FS.Read(buf, len, f);

		ByteBuffer bb = ByteBuffer.wrap(buf);
		IntBuffer ib = bb.asIntBuffer();

		for (int n = 0; n < portalopen.length; n++)
			portalopen[n] = ib.get() != 0;

		FloodAreaConnections();
	}

	/*
	=============
	CM_HeadnodeVisible
	
	Returns true if any leaf under headnode has a cluster that
	is potentially visible
	=============
	*/
	public static boolean CM_HeadnodeVisible(int nodenum, byte visbits[]) {
		int leafnum;
		int cluster;
		cnode_t node;

		if (nodenum < 0) {
			leafnum = -1 - nodenum;
			cluster = map_leafs[leafnum].cluster;
			if (cluster == -1)
				return false;
			if (0 != (visbits[cluster >>> 3] & (1 << (cluster & 7))))
				return true;
			return false;
		}

		node = map_nodes[nodenum];
		if (CM_HeadnodeVisible(node.children[0], visbits))
			return true;
		return CM_HeadnodeVisible(node.children[1], visbits);
	}
}