package com.graardor.client.world;

import com.graardor.Configuration;
import com.graardor.client.Client;
import com.graardor.client.VertexNormal;
import com.graardor.client.accounts.LocalSettings;
import com.graardor.client.cache.node.Deque;
import com.graardor.client.graphics.Raster;
import com.graardor.client.renderable.Animable;

public final class WorldController {

	private static boolean isClicked;

	private static boolean[][] TILE_VISIBILITY_MAP;

	private static byte TILE_DRAW_DISTANCE = 25;

	public void setDrawDistance(int distance) {
		TILE_DRAW_DISTANCE = (byte) distance;
		TILE_VISIBILITY_MAPS = new boolean[8][32][(TILE_DRAW_DISTANCE << 1) | 1][(TILE_DRAW_DISTANCE << 1) | 1];
	}

	private static boolean[][][][] TILE_VISIBILITY_MAPS = new boolean[8][32][(TILE_DRAW_DISTANCE << 1) | 1][(TILE_DRAW_DISTANCE << 1) | 1];

	private static Deque aClass19_477 = new Deque();

	private static InteractiveObject[] interactiveObjects = new InteractiveObject[100];

	private static final CullingCluster[] processed_culling_clusters = new CullingCluster[500];
	private static CullingCluster[][] cullingClusters;
	private static int anInt446;
	private static int plane;
	private static int anInt448;
	private static int anInt449;
	private static int anInt450;
	private static int anInt451;
	private static int anInt452;
	private static int xCameraPositionTile;
	private static int yCameraPositionTile;
	private static int xCameraPosition;
	private static int zCameraPosition;
	private static int yCameraPosition;
	private static int yCurveSine;
	private static int yCurveCosine;
	private static int xCurveSine;
	private static int xCurveCosine;
	private static int anInt468;
	private static int anInt469;
	public static int clickedTileX = -1;
	public static int clickedTileY = -1;
	private static final int anInt472;
	private static int processed_culling_clusters_ptr;
	private static int anInt493;
	private static int anInt494;
	private static int anInt495;
	private static int anInt496;
	private static int anInt497;
	private static int anInt498;
	private static final int[] anIntArray463 = { 53, -53, -53, 53 };
	private static final int[] anIntArray464 = { -53, -53, 53, 53 };
	private static final int[] anIntArray465 = { -45, 45, 45, -45 };
	private static final int[] anIntArray466 = { 45, 45, -45, -45 };
	private static int[] cullingClusterPointer;
	private static final int[] anIntArray478 = { 19, 55, 38, 155, 255, 110,
			137, 205, 76 };
	private static final int[] anIntArray479 = { 160, 192, 80, 96, 0, 144, 80,
			48, 160 };
	private static final int[] anIntArray480 = { 76, 8, 137, 4, 0, 1, 38, 2, 19 };
	private static final int[] anIntArray481 = { 0, 0, 2, 0, 0, 2, 1, 1, 0 };
	private static final int[] anIntArray482 = { 2, 0, 0, 2, 0, 0, 0, 4, 4 };
	private static final int[] anIntArray483 = { 0, 4, 4, 8, 0, 0, 8, 0, 0 };
	private static final int[] anIntArray484 = { 1, 1, 0, 0, 0, 8, 0, 0, 8 };
	private static final int[] textureRGBColour = { 41, 39248, 41, 4643, 41, 41,
			41, 41, 41, 41, 41, 41, 41, 41, 41, 43086, 41, 41, 41, 41, 41, 41,
			41, 8602, 41, 28992, 41, 41, 41, 41, 41, 5056, 41, 41, 41, 7079,
			41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 3131, 41, 41, 41,

			41, 39248, 41, 4643, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 43086,
			41, 41, 41, 41, 41, 41, 41, 8602, 41, 28992, 41, 41, 41, 41, 41, 5056, 41, 41, 41, 7079, 41, 41, 41, 41, 41,
			41, 41, 41, 41, 41, 3131, 41, 41, 41};
	public static boolean lowDetail = true;
	static {
		anInt472 = 4;
		cullingClusterPointer = new int[anInt472];
		cullingClusters = new CullingCluster[anInt472][500];
	}

	static void createCullingCluster(int z, int lowest_x, int lowest_z, int highest_x, int highest_y, int highest_z, int lowest_y, int search_mask) {
		CullingCluster cullingCluster = new CullingCluster();
		cullingCluster.tileStartX = lowest_x / 128;
		cullingCluster.tileEndX = highest_x / 128;
		cullingCluster.tileStartY = lowest_y / 128;
		cullingCluster.tileEndY = highest_y / 128;
		cullingCluster.searchMask = search_mask;
		cullingCluster.worldStartX = lowest_x;
		cullingCluster.worldEndX = highest_x;
		cullingCluster.worldStartY = lowest_y;
		cullingCluster.worldEndY = highest_y;
		cullingCluster.worldStartZ = highest_z;
		cullingCluster.worldEndZ = lowest_z;
		cullingClusters[z][cullingClusterPointer[z]++] = cullingCluster;
	}

	public static void method310(int i, int j, int k, int l, int ai[]) {
		anInt495 = 0;
		anInt496 = 0;
		anInt497 = k;
		anInt498 = l;
		anInt493 = k / 2;
		anInt494 = l / 2;
		boolean aflag[][][][] = new boolean[9][32][(TILE_DRAW_DISTANCE << 1) + 3][(TILE_DRAW_DISTANCE << 1) + 3];
		for (int i1 = 128; i1 <= 384; i1 += 32) {
			for (int j1 = 0; j1 < 2048; j1 += 64) {
				yCurveSine = Model.SINE[i1];
				yCurveCosine = Model.COSINE[i1];
				xCurveSine = Model.SINE[j1];
				xCurveCosine = Model.COSINE[j1];
				int l1 = (i1 - 128) / 32;
				int j2 = j1 / 64;
				for (int l2 = -TILE_DRAW_DISTANCE - 1; l2 <= TILE_DRAW_DISTANCE + 1; l2++) {
					for (int j3 = -TILE_DRAW_DISTANCE - 1; j3 <= TILE_DRAW_DISTANCE + 1; j3++) {
						int k3 = l2 * 128;
						int i4 = j3 * 128;
						boolean flag2 = false;
						for (int k4 = -i; k4 <= j; k4 += 128) {
							if (!tileIsVisible(ai[l1] + k4, i4, k3)) {
								continue;
							}
							flag2 = true;
							break;
						}

						aflag[l1][j2][l2 + TILE_DRAW_DISTANCE + 1][j3 + TILE_DRAW_DISTANCE + 1] = flag2;
					}

				}

			}

		}

		for (int k1 = 0; k1 < 8; k1++) {
			for (int i2 = 0; i2 < 32; i2++) {
				for (int k2 = -TILE_DRAW_DISTANCE; k2 < TILE_DRAW_DISTANCE; k2++) {
					for (int i3 = -TILE_DRAW_DISTANCE; i3 < TILE_DRAW_DISTANCE; i3++) {
						boolean flag1 = false;
						label0: for (int l3 = -1; l3 <= 1; l3++) {
							for (int j4 = -1; j4 <= 1; j4++) {
								if (aflag[k1][i2][k2 + l3 + TILE_DRAW_DISTANCE + 1][i3 + j4 + TILE_DRAW_DISTANCE + 1]) {
									flag1 = true;
								} else if (aflag[k1][(i2 + 1) % 31][k2 + l3 + TILE_DRAW_DISTANCE + 1][i3 + j4 + TILE_DRAW_DISTANCE + 1]) {
									flag1 = true;
								} else if (aflag[k1 + 1][i2][k2 + l3 + TILE_DRAW_DISTANCE + 1][i3 + j4 + TILE_DRAW_DISTANCE + 1]) {
									flag1 = true;
								} else {
									if (!aflag[k1 + 1][(i2 + 1) % 31][k2 + l3 + TILE_DRAW_DISTANCE + 1][i3 + j4 + TILE_DRAW_DISTANCE + 1]) {
										continue;
									}

									flag1 = true;
								}

								break label0;
							}
						}

						TILE_VISIBILITY_MAPS[k1][i2][k2 + TILE_DRAW_DISTANCE][i3 + TILE_DRAW_DISTANCE] = flag1;
					}
				}
			}
		}
	}

	private static boolean tileIsVisible(int i, int j, int k) {
		int l = j * xCurveSine + k * xCurveCosine >> 16;
		int i1 = j * xCurveCosine - k * xCurveSine >> 16;
		int j1 = i * yCurveSine + i1 * yCurveCosine >> 16;
		int k1 = i * yCurveCosine - i1 * yCurveSine >> 16;

		if(j1 < Configuration.CAM_NEAR || j1 > (Configuration.INCREASED_RENDER_DISTANCE ? 7000 : Configuration.CAM_FAR)) {
			return false;
		}

		int l1 = anInt493 + (l << Client.log_view_dist) / j1;
		int i2 = anInt494 + (k1 << Client.log_view_dist) / j1;
		return l1 >= anInt495 && l1 <= anInt497 && i2 >= anInt496 && i2 <= anInt498;
	}

	public static void nullify() {
		interactiveObjects = null;
		cullingClusterPointer = null;
		cullingClusters = null;
		aClass19_477 = null;
		TILE_VISIBILITY_MAPS = null;
		TILE_VISIBILITY_MAP = null;
	}

	private boolean aBoolean434;
	private final int zMapSize;
	private final int xMapSize;
	private final int yMapSize;
	private int currentHL;
	private int anInt488;
	private final int[] anIntArray486;
	private final int[] anIntArray487;
	private final int[][] tileShapePoints = { new int[16],
			{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
			{ 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1 },
			{ 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 },
			{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1 },
			{ 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
			{ 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 },
			{ 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
			{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0 },
			{ 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1 },
			{ 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 },
			{ 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1 },
			{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1 } };
	private final int[][] tileShapeIndices = {
			{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
			{ 12, 8, 4, 0, 13, 9, 5, 1, 14, 10, 6, 2, 15, 11, 7, 3 },
			{ 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 },
			{ 3, 7, 11, 15, 2, 6, 10, 14, 1, 5, 9, 13, 0, 4, 8, 12 } };
	private final int[][][] heightmap;
	private final int[][][] anIntArrayArrayArray445;
	private final Tile[][][] tileArray;
	private final InteractiveObject[] interactiveObjectCache;
	private int interactableObjectCacheCurrPos;

	public WorldController(int heightmap[][][]) {
		int i = 104;// was parameter
		int j = 104;// was parameter
		int k = 4;// was parameter
		aBoolean434 = true;
		interactiveObjectCache = new InteractiveObject[5000];
		anIntArray486 = new int[10000];
		anIntArray487 = new int[10000];
		zMapSize = k;
		xMapSize = j;
		yMapSize = i;
		tileArray = new Tile[k][j][i];
		anIntArrayArrayArray445 = new int[k][j + 1][i + 1];
		this.heightmap = heightmap;
		reset();
	}

	public void clearObj5Cache() {
		for (int i = 0; i < interactableObjectCacheCurrPos; i++) {
			InteractiveObject object5 = interactiveObjectCache[i];
			remove(object5);
			interactiveObjectCache[i] = null;
		}
		interactableObjectCacheCurrPos = 0;
	}

	public void reset() {
		for (int j = 0; j < zMapSize; j++) {
			for (int k = 0; k < xMapSize; k++) {
				for (int i1 = 0; i1 < yMapSize; i1++) {
					tileArray[j][k][i1] = null;
				}

			}

		}
		for (int l = 0; l < anInt472; l++) {
			for (int j1 = 0; j1 < cullingClusterPointer[l]; j1++) {
				cullingClusters[l][j1] = null;
			}

			cullingClusterPointer[l] = 0;
		}

		for (int k1 = 0; k1 < interactableObjectCacheCurrPos; k1++) {
			interactiveObjectCache[k1] = null;
		}

		interactableObjectCacheCurrPos = 0;
		for (int l1 = 0; l1 < interactiveObjects.length; l1++) {
			interactiveObjects[l1] = null;
		}

	}

	public void fill(int i) {
		currentHL = i;
		for (int k = 0; k < xMapSize; k++) {
			for (int l = 0; l < yMapSize; l++) {
				if (tileArray[i][k][l] == null) {
					tileArray[i][k][l] = new Tile(i, k, l);
				}
			}
		}
	}

	void applyBridgeMode(int y, int x) {
		Tile level0_tile = tileArray[0][x][y];
		for (int l = 0; l < 3; l++) {
			Tile tile = tileArray[l][x][y] = tileArray[l + 1][x][y];
			if (tile != null) {
				tile.tileZ--;
				for (int j1 = 0; j1 < tile.entityCount; j1++) {
					InteractiveObject worldEntity = tile.interactiveObjects[j1];
					if ((worldEntity.uid >> 29 & 3) == 2 && worldEntity.tileLeft == x && worldEntity.tileTop == y) {
						worldEntity.zPos--;
					}
				}
			}
		}

		if (tileArray[0][x][y] == null) {
			tileArray[0][x][y] = new Tile(0, x, y);
		}

		tileArray[0][x][y].tileBelow0 = level0_tile;
		tileArray[3][x][y] = null;
	}

	void setTileLogicHeight(int z, int x, int y, int l_z) {
		Tile tile = tileArray[z][x][y];

		if (tile != null) {
			tileArray[z][x][y].logicHeight = l_z;
		}
	}

	void addTile(int zz, int x, int y, int shape, int i1, int overlaytex, int underlaytex, int zA, int zB, int zD, int zC, int colourA, int colourB, int colourD, int colourC, int colourAA, int colourBA, int colourDA, int colourCA, int cRGB2, int RGBA, boolean tex) {
		if (shape == 0) {
			PlainTile plainTile = new PlainTile(colourA, colourB, colourD, colourC, underlaytex > Rasterizer.TEXTURE_COUNT ? -1 : underlaytex, cRGB2, false, tex);

			for (int i5 = zz; i5 >= 0; i5--) {
				if (tileArray[i5][x][y] == null) {
					tileArray[i5][x][y] = new Tile(i5, x, y);
				}
			}

			tileArray[zz][x][y].myPlainTile = plainTile;
			return;
		}

		if (shape == 1) {
			PlainTile plainTile_1 = new PlainTile(colourAA, colourBA, colourDA, colourCA, overlaytex > Rasterizer.TEXTURE_COUNT ? -1 : overlaytex, RGBA, zA == zB && zA == zD && zA == zC, tex);

			for (int z = zz; z >= 0; z--) {
				if (tileArray[z][x][y] == null) {
					tileArray[z][x][y] = new Tile(z, x, y);
				}
			}

			tileArray[zz][x][y].myPlainTile = plainTile_1;
			return;
		}

		ShapedTile shapedTile = new ShapedTile(y, colourAA, colourC, zD, overlaytex, underlaytex, colourDA, i1, colourA, cRGB2, colourD, zC, zB, zA, shape, colourCA, colourBA, colourB, x, RGBA, tex);

		for (int z = zz; z >= 0; z--) {
			if (tileArray[z][x][y] == null) {
				tileArray[z][x][y] = new Tile(z, x, y);
			}
		}

		tileArray[zz][x][y].shapedTile = shapedTile;
	}

	void addGroundDecoration(int Z, int z3d, int Y, Animable jagexNode, byte byte0, int i1, int X, int id) {
		if (jagexNode == null) {
			return;
		}

		GroundDecoration groundDecoration = new GroundDecoration();
		groundDecoration.aClass30_Sub2_Sub4_814 = jagexNode;
		groundDecoration.xPos = (X * 128) + 64;
		groundDecoration.yPos = (Y * 128) + 64;
		groundDecoration.zPos = z3d;
		groundDecoration.uid = i1;
		groundDecoration.id = id;
		groundDecoration.objConf = byte0;
		if (tileArray[Z][X][Y] == null)
			tileArray[Z][X][Y] = new Tile(Z, X, Y);

		tileArray[Z][X][Y].groundDecoration = groundDecoration;
	}

	public void addGroundItemTile(int x, int j, Animable secondGroundItem, int k, Animable thirdGroundItem, Animable firstGroundItem, int z, int y) {
		GroundItemTile itemTile = new GroundItemTile();
		itemTile.firstGroundItem = firstGroundItem;
		itemTile.xPos = x * 128 + 64;
		itemTile.yPos = y * 128 + 64;
		itemTile.zPos = k;
		itemTile.uid = j;
		itemTile.secondGroundItem = secondGroundItem;
		itemTile.thirdGroundItem = thirdGroundItem;
		int j1 = 0;
		Tile class30_sub3 = tileArray[z][x][y];

		if (class30_sub3 != null) {
			for (int k1 = 0; k1 < class30_sub3.entityCount; k1++) {
				if (class30_sub3.interactiveObjects[k1].jagexNode instanceof Model) {
					int l1 = ((Model) class30_sub3.interactiveObjects[k1].jagexNode).anInt1654;
					if (l1 > j1) {
						j1 = l1;
					}
				}
			}
		}

		itemTile.anInt52 = j1;

		if (tileArray[z][x][y] == null) {
			tileArray[z][x][y] = new Tile(z, x, y);
		}

		tileArray[z][x][y].groundItemTile = itemTile;
	}

	void addWallObject(int i, Animable jagexNode, int j, int y, byte byte0, int x, Animable jagexNode2, int i1, int j1, int zz, int var) {
		if (jagexNode == null && jagexNode2 == null) {
			return;
		}

		WallObject wallObject = new WallObject();
		wallObject.uid = j;
		wallObject.setNewUID(var);
		wallObject.objConf = byte0;
		wallObject.xPos = x * 128 + 64;
		wallObject.yPos = y * 128 + 64;
		wallObject.zPos = i1;
		wallObject.node1 = jagexNode;
		wallObject.node2 = jagexNode2;
		wallObject.orientation = i;
		wallObject.orientation1 = j1;
		for (int z = zz; z >= 0; z--) {
			if (tileArray[z][x][y] == null) {
				tileArray[z][x][y] = new Tile(z, x, y);
			}
		}

		tileArray[zz][x][y].wallObject = wallObject;
	}

	void addWallDecoration(int i, int y, int face, int z, int x3dOff, int k1, Animable jagexNode, int x, byte byte0, int y3dOff, int facebits) {
		if (jagexNode == null) {
			return;
		}

		WallDecoration wallDecoration = new WallDecoration();
		wallDecoration.uid = i;
		wallDecoration.objConf = byte0;
		wallDecoration.xPos = x * 128 + 64 + x3dOff;
		wallDecoration.yPos = y * 128 + 64 + y3dOff;
		wallDecoration.zPos = k1;
		wallDecoration.myMob = jagexNode;
		wallDecoration.configBits = facebits;
		wallDecoration.face = face;
		for (int zz = z; zz >= 0; zz--) {
			if (tileArray[zz][x][y] == null) {
				tileArray[zz][x][y] = new Tile(zz, x, y);
			}
		}

		tileArray[z][x][y].wallDecoration = wallDecoration;
	}

	boolean addEntityB(int i, byte byte0, int j, int k, Animable entity, int l, int i1, int j1, int k1, int l1, int var) {
		if (entity == null) {
			return true;
		} else {
			int i2 = l1 * 128 + 64 * l;
			int j2 = k1 * 128 + 64 * k;
			return addEntityC(i1, l1, k1, l, k, i2, j2, j, entity, j1, false, i, byte0, var);
		}
	}

	public boolean addEntityA(int plane, int rotation, int drawHeight, int l, int boundExtentY, int j1, int boundExtentX, Animable npc, boolean flag) {
		if (npc == null) {
			return true;
		}
		int x = boundExtentX - j1;
		int y = boundExtentY - j1;
		int j2 = boundExtentX + j1;
		int k2 = boundExtentY + j1;
		if (flag) {
			if (rotation > 640 && rotation < 1408) {
				k2 += 128;
			}
			if (rotation > 1152 && rotation < 1920) {
				j2 += 128;
			}
			if (rotation > 1664 || rotation < 384) {
				y -= 128;
			}
			if (rotation > 128 && rotation < 896) {
				x -= 128;
			}
		}
		x /= 128;
		y /= 128;
		j2 /= 128;
		k2 /= 128;
		return addEntityC(plane, x, y, j2 - x + 1, k2 - y + 1, boundExtentX, boundExtentY, drawHeight, npc, rotation, true, l, (byte) 0, 0);
	}

	public boolean addEntity(int j, int k, Animable class30_sub2_sub4, int l, int i1, int j1, int k1, int l1, int i2, int j2, int k2) {
		return class30_sub2_sub4 == null || addEntityC(j, l1, k2, i2 - l1 + 1, i1 - k2 + 1, j1, k, k1, class30_sub2_sub4, l, true, j2, (byte) 0, 0);
	}

	private boolean addEntityC(int z, int x, int y, int tileHeight, int tileWidth, int worldX, int worldY, int worldZ, Animable jagexNode, int rotation, boolean flag, int j2, byte byte0, int var) {
		for (int _x = x; _x < x + tileHeight; _x++) {
			for (int _y = y; _y < y + tileWidth; _y++) {
				if (_x < 0 || _y < 0 || _x >= xMapSize || _y >= yMapSize) {
					return false;
				}
				Tile class30_sub3 = tileArray[z][_x][_y];
				if (class30_sub3 != null && class30_sub3.entityCount >= 5) {
					return false;
				}
			}

		}

		InteractiveObject interactiveObject = new InteractiveObject();
		interactiveObject.uid = j2;
		interactiveObject.setNewUID(var);
		interactiveObject.objConf = byte0;
		interactiveObject.zPos = z;
		interactiveObject.worldX = worldX;
		interactiveObject.worldY = worldY;
		interactiveObject.worldZ = worldZ;
		interactiveObject.jagexNode = jagexNode;
		interactiveObject.rotation = rotation;
		interactiveObject.tileLeft = x;
		interactiveObject.tileTop = y;
		interactiveObject.tileRight = x + tileHeight - 1;
		interactiveObject.tileBottom = y + tileWidth - 1;
		for (int _x = x; _x < x + tileHeight; _x++) {
			for (int j3 = y; j3 < y + tileWidth; j3++) {
				int k3 = 0;
				if (_x > x) {
					k3++;
				}
				if (_x < x + tileHeight - 1) {
					k3 += 4;
				}
				if (j3 > y) {
					k3 += 8;
				}
				if (j3 < y + tileWidth - 1) {
					k3 += 2;
				}
				for (int l3 = z; l3 >= 0; l3--) {
					if (tileArray[l3][_x][j3] == null) {
						tileArray[l3][_x][j3] = new Tile(l3, _x, j3);
					}
				}

				Tile class30_sub3_1 = tileArray[z][_x][j3];
				class30_sub3_1.interactiveObjects[class30_sub3_1.entityCount] = interactiveObject;
				class30_sub3_1.anIntArray1319[class30_sub3_1.entityCount] = k3;
				class30_sub3_1.anInt1320 |= k3;
				class30_sub3_1.entityCount++;
			}

		}

		if (flag) {
			interactiveObjectCache[interactableObjectCacheCurrPos++] = interactiveObject;
		}
		return true;
	}

	private void remove(InteractiveObject interactiveObject) {
		for (int j = interactiveObject.tileLeft; j <= interactiveObject.tileRight; j++) {
			for (int k = interactiveObject.tileTop; k <= interactiveObject.tileBottom; k++) {
				Tile class30_sub3 = tileArray[interactiveObject.zPos][j][k];
				if (class30_sub3 != null) {
					for (int l = 0; l < class30_sub3.entityCount; l++) {
						if (class30_sub3.interactiveObjects[l] != interactiveObject) {
							continue;
						}
						class30_sub3.entityCount--;
						for (int i1 = l; i1 < class30_sub3.entityCount; i1++) {
							class30_sub3.interactiveObjects[i1] = class30_sub3.interactiveObjects[i1 + 1];
							class30_sub3.anIntArray1319[i1] = class30_sub3.anIntArray1319[i1 + 1];
						}

						class30_sub3.interactiveObjects[class30_sub3.entityCount] = null;
						break;
					}

					class30_sub3.anInt1320 = 0;
					for (int j1 = 0; j1 < class30_sub3.entityCount; j1++) {
						class30_sub3.anInt1320 |= class30_sub3.anIntArray1319[j1];
					}
				}
			}
		}
	}

	void method290(int i, int k, int l, int i1) {
		Tile tile = tileArray[i1][l][i];

		if (tile == null) {
			return;
		}

		WallDecoration class26 = tile.wallDecoration;

		if (class26 != null) {
			int j1 = l * 128 + 64;
			int k1 = i * 128 + 64;
			class26.xPos = j1 + (class26.xPos - j1) * k / 16;
			class26.yPos = k1 + (class26.yPos - k1) * k / 16;
		}
	}

	public void removeWallObject(int x, int z, int y, byte byte0) {
		Tile tile = tileArray[z][x][y];

		if (byte0 != -119) {
			aBoolean434 = !aBoolean434;
		}

		if (tile != null) {
			tile.wallObject = null;
		}
	}

	public void removeWallDecoration(int y, int z, int x) {
		Tile tile = tileArray[z][x][y];
		if (tile != null) {
			tile.wallDecoration = null;
		}
	}

	public void method293(int i, int k, int l) {
		Tile tile = tileArray[i][k][l];
		if (tile == null) {
			return;
		}

		for (int j1 = 0; j1 < tile.entityCount; j1++) {
			InteractiveObject interactiveObject = tile.interactiveObjects[j1];

			if ((interactiveObject.uid >> 29 & 3) == 2 && interactiveObject.tileLeft == k && interactiveObject.tileTop == l) {
				remove(interactiveObject);
				return;
			}
		}
	}

	public void removeGroundDecoration(int z, int y, int x) {
		Tile tile = tileArray[z][x][y];
		if (tile == null) {
			return;
		}

		tile.groundDecoration = null;
	}

	public void removeGroundItemTile(int z, int x, int y) {
		Tile tile = tileArray[z][x][y];
		if (tile != null) {
			tile.groundItemTile = null;
		}
	}

	public WallObject getWallObject(int z, int x, int y) {
		Tile tile = tileArray[z][x][y];
		if (tile == null) {
			return null;
		} else {
			return tile.wallObject;
		}
	}

	public WallDecoration getWallDecoration(int x, int y, int z) {
		Tile tile = tileArray[z][x][y];
		if (tile == null) {
			return null;
		} else {
			return tile.wallDecoration;
		}
	}

	public InteractiveObject getInteractableObject(int x, int y, int z) {
		Tile tile = tileArray[z][x][y];
		if (tile == null) {
			return null;
		}

		for (int l = 0; l < tile.entityCount; l++) {
			InteractiveObject interactiveObject = tile.interactiveObjects[l];

			if ((interactiveObject.uid >> 29 & 3) == 2 && interactiveObject.tileLeft == x && interactiveObject.tileTop == y) {
				return interactiveObject;
			}
		}

		return null;
	}

	public GroundDecoration getGroundDecoration(int y, int x, int z) {
		Tile tile = tileArray[z][x][y];

		if (tile == null || tile.groundDecoration == null) {
			return null;
		} else {
			return tile.groundDecoration;
		}
	}

	public int getWallObjectUID(int z, int x, int y) {
		Tile tile = tileArray[z][x][y];
		if (tile == null || tile.wallObject == null) {
			return 0;
		} else {
			return tile.wallObject.uid;
		}
	}

	// fetchWallObjectNewUID
	public int fetchWallObjectNewUID(int i, int j, int k) {
		Tile tile = tileArray[i][j][k];
		if (tile == null || tile.wallObject == null) {
			return 0;
		} else {
			return tile.wallObject.getNewUID();
		}
	}

	public int getWallDecorationUID(int z, int x, int y) {
		Tile tile = tileArray[z][x][y];
		if (tile == null || tile.wallDecoration == null) {
			return 0;
		} else {
			return tile.wallDecoration.uid;
		}
	}

	// fetchWallDecorationNewUID
	public int fetchWallDecorationNewUID(int i, int j, int l) {
		Tile tile = tileArray[i][j][l];
		if (tile == null || tile.wallDecoration == null) {
			return 0;
		} else {
			return tile.wallDecoration.getNewUID();
		}
	}

	// fetchObjectMeshUID
	public int getInteractableObjectUID(int z, int x, int y) {
		if (z == 4) {
			z = 0;
		}
		Tile tile = tileArray[z][x][y];
		if (tile == null) {
			return 0;
		}
		for (int l = 0; l < tile.entityCount; l++) {
			InteractiveObject interactableObject = tile.interactiveObjects[l];
			if ((interactableObject.uid >> 29 & 3) == 2 && interactableObject.tileLeft == x && interactableObject.tileTop == y) {
				return interactableObject.uid;
			}
		}
		return 0;
	}

	// fetchObjectMeshNewUID
	public int fetchObjectMeshNewUID(int z, int x, int y) {
		Tile tile = tileArray[z][x][y];
		if (tile == null) {
			return 0;
		}
		for (int l = 0; l < tile.entityCount; l++) {
			InteractiveObject interactableObject = tile.interactiveObjects[l];
			if ((interactableObject.uid >> 29 & 3) == 2 && interactableObject.tileLeft == x && interactableObject.tileTop == y) {
				return interactableObject.getNewUID();
			}
		}
		return 0;
	}

	// fetchGroundDecorationUID
	public int getGroundDecorationUID(int z, int x, int y) {
		Tile tile = tileArray[z][x][y];
		if (tile == null || tile.groundDecoration == null) {
			return 0;
		} else {
			return tile.groundDecoration.uid;
		}
	}

	// fetchGroundDecorationNewUID
	public int fetchGroundDecorationNewUID(int i, int j, int k) {
		Tile tile = tileArray[i][j][k];
		if (tile == null || tile.groundDecoration == null) {
			return 0;
		} else {
			return tile.groundDecoration.id;
		}
	}

	public int fetchObjectIDTagForPosition(int z, int x, int y, int objectMesh) {
		Tile tile = tileArray[z][x][y];
		if (tile == null) {
			return -1;
		}
		if (tile.wallObject != null && tile.wallObject.uid == objectMesh) {
			return tile.wallObject.objConf & 0xff;
		}
		if (tile.wallDecoration != null && tile.wallDecoration.uid == objectMesh) {
			return tile.wallDecoration.objConf & 0xff;
		}
		if (tile.groundDecoration != null && tile.groundDecoration.uid == objectMesh) {
			return tile.groundDecoration.objConf & 0xff;
		}
		for (int i1 = 0; i1 < tile.entityCount; i1++) {
			// entityCount = count?
			if (tile.interactiveObjects[i1].uid == objectMesh) {
				return tile.interactiveObjects[i1].objConf & 0xff;
			}
		}

		return -1;
	}

	void shadeModels(int i, int k, int i1) {
		int j = 75;//check this for draw distance
		int l = 1800;
		int k1 = l >> 4;

		for (int l1 = 0; l1 < zMapSize; l1++) {
			for (int i2 = 0; i2 < xMapSize; i2++) {
				for (int j2 = 0; j2 < yMapSize; j2++) {
					Tile tile = tileArray[l1][i2][j2];

					if (tile != null) {
						WallObject class10 = tile.wallObject;
						if (class10 != null && class10.node1 != null && class10.node1.vertex_normals != null) {
							method307(l1, 1, 1, i2, j2, (Model) class10.node1);
							if (class10.node2 != null && class10.node2.vertex_normals != null) {
								method307(l1, 1, 1, i2, j2, (Model) class10.node2);
								method308((Model) class10.node1, (Model) class10.node2, 0, 0, 0, false);
								((Model) class10.node2).doShading(j, k1, k, i, i1);
							}
							((Model) class10.node1).doShading(j, k1, k, i, i1);
						}
						for (int k2 = 0; k2 < tile.entityCount; k2++) {
							InteractiveObject class28 = tile.interactiveObjects[k2];
							if (class28 != null && class28.jagexNode != null && class28.jagexNode.vertex_normals != null) {
								method307(l1, class28.tileRight - class28.tileLeft + 1, class28.tileBottom - class28.tileTop + 1, i2, j2, (Model) class28.jagexNode);
								((Model) class28.jagexNode).doShading(j, k1, k, i, i1);
							}
						}

						GroundDecoration class49 = tile.groundDecoration;
						if (class49 != null && class49.aClass30_Sub2_Sub4_814.vertex_normals != null) {
							method306(i2, l1, (Model) class49.aClass30_Sub2_Sub4_814, j2);
							((Model) class49.aClass30_Sub2_Sub4_814).doShading(j, k1, k, i, i1);
						}
					}
				}

			}

		}

	}

	private void method306(int x, int z, Model model, int y) {
		if (x < xMapSize) {
			Tile tile = tileArray[z][x + 1][y];
			if (tile != null && tile.groundDecoration != null && tile.groundDecoration.aClass30_Sub2_Sub4_814.vertex_normals != null) {
				method308(model, (Model) tile.groundDecoration.aClass30_Sub2_Sub4_814, 128, 0, 0, true);
			}
		}
		if (y < xMapSize) {
			Tile tile = tileArray[z][x][y + 1];
			if (tile != null && tile.groundDecoration != null && tile.groundDecoration.aClass30_Sub2_Sub4_814.vertex_normals != null) {
				method308(model, (Model) tile.groundDecoration.aClass30_Sub2_Sub4_814, 0, 0, 128, true);
			}
		}
		if (x < xMapSize && y < yMapSize) {
			Tile tile = tileArray[z][x + 1][y + 1];
			if (tile != null && tile.groundDecoration != null && tile.groundDecoration.aClass30_Sub2_Sub4_814.vertex_normals != null) {
				method308(model, (Model) tile.groundDecoration.aClass30_Sub2_Sub4_814, 128, 0, 128, true);
			}
		}
		if (x < xMapSize && y > 0) {
			Tile tile = tileArray[z][x + 1][y - 1];
			if (tile != null && tile.groundDecoration != null && tile.groundDecoration.aClass30_Sub2_Sub4_814.vertex_normals != null) {
				method308(model, (Model) tile.groundDecoration.aClass30_Sub2_Sub4_814, 128, 0, -128, true);
			}
		}
	}

	private void method307(int z, int j, int k, int x, int y, Model model) {
		boolean flag = true;
		int j1 = x;
		int k1 = x + j;
		int l1 = y - 1;
		int i2 = y + k;
		for (int j2 = z; j2 <= z + 1; j2++) {
			if (j2 != zMapSize) {
				for (int k2 = j1; k2 <= k1; k2++) {
					if (k2 >= 0 && k2 < xMapSize) {
						for (int l2 = l1; l2 <= i2; l2++) {
							if (l2 >= 0 && l2 < yMapSize && (!flag || k2 >= k1 || l2 >= i2 || l2 < y && k2 != x)) {
								Tile class30_sub3 = tileArray[j2][k2][l2];
								if (class30_sub3 != null) {
									int i3 = (heightmap[j2][k2][l2] + heightmap[j2][k2 + 1][l2] + heightmap[j2][k2][l2 + 1] + heightmap[j2][k2 + 1][l2 + 1]) / 4 - (heightmap[z][x][y] + heightmap[z][x + 1][y] + heightmap[z][x][y + 1] + heightmap[z][x + 1][y + 1]) / 4;
									WallObject class10 = class30_sub3.wallObject;
									if (class10 != null && class10.node1 != null && class10.node1.vertex_normals != null) {
										method308(model, (Model) class10.node1, (k2 - x) * 128 + (1 - j) * 64, i3, (l2 - y) * 128 + (1 - k) * 64, flag);
									}
									if (class10 != null && class10.node2 != null && class10.node2.vertex_normals != null) {
										method308(model, (Model) class10.node2, (k2 - x) * 128 + (1 - j) * 64, i3, (l2 - y) * 128 + (1 - k) * 64, flag);
									}
									for (int j3 = 0; j3 < class30_sub3.entityCount; j3++) {
										InteractiveObject class28 = class30_sub3.interactiveObjects[j3];
										if (class28 != null && class28.jagexNode != null && class28.jagexNode.vertex_normals != null) {
											int k3 = class28.tileRight - class28.tileLeft + 1;
											int l3 = class28.tileBottom - class28.tileTop + 1;
											method308(model, (Model) class28.jagexNode, (class28.tileLeft - x) * 128 + (k3 - j) * 64, i3, (class28.tileTop - y) * 128 + (l3 - k) * 64, flag);
										}
									}

								}
							}
						}

					}
				}

				j1--;
				flag = false;
			}
		}

	}

	private void method308(Model model, Model model_1, int i, int j, int k, boolean flag) {
		anInt488++;
		int l = 0;
		int ai[] = model_1.verticesXCoordinate;
		int i1 = model_1.numberOfVerticeCoordinates;
		for (int j1 = 0; j1 < model.numberOfVerticeCoordinates; j1++) {
			VertexNormal vertexNormal = model.vertex_normals[j1];
			VertexNormal vertexNormal_1 = model.vertexNormalOffset[j1];
			if (vertexNormal_1.magnitude != 0) {
				int i2 = (model.verticesYCoordinate[j1] >> (model.scaling ? 2 : 0)) - j;
				if (i2 <= model_1.maxY) {
					int j2 = (model.verticesXCoordinate[j1] >> (model.scaling ? 2 : 0)) - i;
					if (j2 >= model_1.minX && j2 <= model_1.maxX) {
						int k2 = (model.verticesZCoordinate[j1] >> (model.scaling ? 2 : 0)) - k;
						if (k2 >= model_1.minZ && k2 <= model_1.maxZ) {
							for (int l2 = 0; l2 < i1; l2++) {
								VertexNormal vertexNormal_2 = model_1.vertex_normals[l2];
								VertexNormal vertexNormal_3 = model_1.vertexNormalOffset[l2];
								if (j2 == ai[l2] >> (model_1.scaling ? 2 : 0) && k2 == model_1.verticesZCoordinate[l2] >> (model_1.scaling ? 2 : 0) && i2 == model_1.verticesYCoordinate[l2] >> (model_1.scaling ? 2 : 0) && vertexNormal_3.magnitude != 0) {
									vertexNormal.x += vertexNormal_3.x;
									vertexNormal.y += vertexNormal_3.y;
									vertexNormal.z += vertexNormal_3.z;
									vertexNormal.magnitude += vertexNormal_3.magnitude;
									vertexNormal_2.x += vertexNormal_1.x;
									vertexNormal_2.y += vertexNormal_1.y;
									vertexNormal_2.z += vertexNormal_1.z;
									vertexNormal_2.magnitude += vertexNormal_1.magnitude;
									l++;
									anIntArray486[j1] = anInt488;
									anIntArray487[l2] = anInt488;
								}
							}

						}
					}
				}
			}
		}

		if (l < 3 || !flag) {
			return;
		}
		for (int k1 = 0; k1 < model.numberOfTriangleFaces; k1++) {
			if (anIntArray486[model.face_a[k1]] == anInt488 && anIntArray486[model.face_b[k1]] == anInt488 && anIntArray486[model.face_c[k1]] == anInt488) {
				model.face_render_type[k1] = -1;
			}
		}

		for (int l1 = 0; l1 < model_1.numberOfTriangleFaces; l1++) {
			if (anIntArray487[model_1.face_a[l1]] == anInt488 && anIntArray487[model_1.face_b[l1]] == anInt488 && anIntArray487[model_1.face_c[l1]] == anInt488) {
				model_1.face_render_type[l1] = -1;
			}
		}

	}

	public void drawMinimapTile(int pixels[], int pixelPointer, int k, int l, int i1) {
		int j = 512;// was parameter
		Tile currentTile = tileArray[k][l][i1];
		if (currentTile == null) {
			return;
		}
		PlainTile plainTile = currentTile.myPlainTile;
		if (plainTile != null) {
			if (LocalSettings.getBoolean("hd_minimap") && plainTile.colourA != 12345678) {
				if (plainTile.colourRGB == 0) {
					return;
				}
				int hs = plainTile.colourA & ~0x7f;
				int l1 = plainTile.anInt719 & 0x7f;
				int l2 = plainTile.colourD & 0x7f;
				int l3 = (plainTile.colourA & 0x7f) - l1;
				int l4 = (plainTile.anInt717 & 0x7f) - l2;
				l1 <<= 2;
				l2 <<= 2;
				for (int k1 = 0; k1 < 4; k1++) {
					if (!plainTile.textured) {
						pixels[pixelPointer] = Rasterizer.hsl2rgb[hs | l1 >> 2];
						pixels[pixelPointer + 1] = Rasterizer.hsl2rgb[hs | l1 * 3 + l2 >> 4];
						pixels[pixelPointer + 2] = Rasterizer.hsl2rgb[hs | l1 + l2 >> 3];
						pixels[pixelPointer + 3] = Rasterizer.hsl2rgb[hs | l1 + l2 * 3 >> 4];
					} else {
						int j1 = plainTile.colourRGB;
						int lig = 0xff - ((l1 >> 1) * (l1 >> 1) >> 8);
						pixels[pixelPointer] = ((j1 & 0xff00ff) * lig & ~0xff00ff) + ((j1 & 0xff00) * lig & 0xff0000) >> 8;
						lig = 0xff - ((l1 * 3 + l2 >> 3) * (l1 * 3 + l2 >> 3) >> 8);
						pixels[pixelPointer + 1] = ((j1 & 0xff00ff) * lig & ~0xff00ff) + ((j1 & 0xff00) * lig & 0xff0000) >> 8;
						lig = 0xff - ((l1 + l2 >> 2) * (l1 + l2 >> 2) >> 8);
						pixels[pixelPointer + 2] = ((j1 & 0xff00ff) * lig & ~0xff00ff) + ((j1 & 0xff00) * lig & 0xff0000) >> 8;
						lig = 0xff - ((l1 + l2 * 3 >> 3) * (l1 + l2 * 3 >> 3) >> 8);
						pixels[pixelPointer + 3] = ((j1 & 0xff00ff) * lig & ~0xff00ff) + ((j1 & 0xff00) * lig & 0xff0000) >> 8;
					}
					l1 += l3;
					l2 += l4;
					pixelPointer += j;
				}
				return;
			}
			int tileRGB = plainTile.colourRGB;
			if (tileRGB == 0) {
				return;
			}
			for (int k1 = 0; k1 < 4; k1++) {
				pixels[pixelPointer] = tileRGB;
				pixels[pixelPointer + 1] = tileRGB;
				pixels[pixelPointer + 2] = tileRGB;
				pixels[pixelPointer + 3] = tileRGB;
				pixelPointer += j;
			}

			return;
		}
		ShapedTile shapedTile = currentTile.shapedTile;
		if (shapedTile == null) {
			return;
		}
		int shapeA = shapedTile.shape;
		int shapeB = shapedTile.rotation;
		int underlayRGB = shapedTile.colourRGB;
		int overlayRGB = shapedTile.colourRGBA;
		int shapePoints[] = tileShapePoints[shapeA];
		int shapeIndices[] = tileShapeIndices[shapeB];
		int shapePtr = 0;
		if (LocalSettings.getBoolean("hd_minimap") && shapedTile.color62 != 12345678) {
			int hs1 = shapedTile.color62 & ~0x7f;
			int l11 = shapedTile.color92 & 0x7f;
			int l21 = shapedTile.color82 & 0x7f;
			int l31 = (shapedTile.color62 & 0x7f) - l11;
			int l41 = (shapedTile.color72 & 0x7f) - l21;
			l11 <<= 2;
			l21 <<= 2;
			for (int k1 = 0; k1 < 4; k1++) {
				if (!shapedTile.textured) {
					if (shapePoints[shapeIndices[shapePtr++]] != 0) {
						pixels[pixelPointer] = Rasterizer.hsl2rgb[hs1 | l11 >> 2];
					}
					if (shapePoints[shapeIndices[shapePtr++]] != 0) {
						pixels[pixelPointer + 1] = Rasterizer.hsl2rgb[hs1 | l11 * 3 + l21 >> 4];
					}
					if (shapePoints[shapeIndices[shapePtr++]] != 0) {
						pixels[pixelPointer + 2] = Rasterizer.hsl2rgb[hs1 | l11 + l21 >> 3];
					}
					if (shapePoints[shapeIndices[shapePtr++]] != 0) {
						pixels[pixelPointer + 3] = Rasterizer.hsl2rgb[hs1 | l11 + l21 * 3 >> 4];
					}
				} else {
					int j1 = overlayRGB;
					if (shapePoints[shapeIndices[shapePtr++]] != 0) {
						int lig = 0xff - ((l11 >> 1) * (l11 >> 1) >> 8);
						pixels[pixelPointer] = ((j1 & 0xff00ff) * lig & ~0xff00ff) + ((j1 & 0xff00) * lig & 0xff0000) >> 8;
					}
					if (shapePoints[shapeIndices[shapePtr++]] != 0) {
						int lig = 0xff - ((l11 * 3 + l21 >> 3) * (l11 * 3 + l21 >> 3) >> 8);
						pixels[pixelPointer + 1] = ((j1 & 0xff00ff) * lig & ~0xff00ff) + ((j1 & 0xff00) * lig & 0xff0000) >> 8;
					}
					if (shapePoints[shapeIndices[shapePtr++]] != 0) {
						int lig = 0xff - ((l11 + l21 >> 2) * (l11 + l21 >> 2) >> 8);
						pixels[pixelPointer + 2] = ((j1 & 0xff00ff) * lig & ~0xff00ff) + ((j1 & 0xff00) * lig & 0xff0000) >> 8;
					}
					if (shapePoints[shapeIndices[shapePtr++]] != 0) {
						int lig = 0xff - ((l11 + l21 * 3 >> 3) * (l11 + l21 * 3 >> 3) >> 8);
						pixels[pixelPointer + 3] = ((j1 & 0xff00ff) * lig & ~0xff00ff) + ((j1 & 0xff00) * lig & 0xff0000) >> 8;
					}
				}
				l11 += l31;
				l21 += l41;
				pixelPointer += j;
			}
			if (underlayRGB != 0 && shapedTile.color61 != 12345678) {
				pixelPointer -= j << 2;
				shapePtr -= 16;
				hs1 = shapedTile.color61 & ~0x7f;
				l11 = shapedTile.color91 & 0x7f;
				l21 = shapedTile.color81 & 0x7f;
				l31 = (shapedTile.color61 & 0x7f) - l11;
				l41 = (shapedTile.color71 & 0x7f) - l21;
				l11 <<= 2;
				l21 <<= 2;
				for (int k1 = 0; k1 < 4; k1++) {
					if (shapePoints[shapeIndices[shapePtr++]] == 0) {
						pixels[pixelPointer] = Rasterizer.hsl2rgb[hs1 | l11 >> 2];
					}
					if (shapePoints[shapeIndices[shapePtr++]] == 0) {
						pixels[pixelPointer + 1] = Rasterizer.hsl2rgb[hs1 | l11 * 3 + l21 >> 4];
					}
					if (shapePoints[shapeIndices[shapePtr++]] == 0) {
						pixels[pixelPointer + 2] = Rasterizer.hsl2rgb[hs1 | l11 + l21 >> 3];
					}
					if (shapePoints[shapeIndices[shapePtr++]] == 0) {
						pixels[pixelPointer + 3] = Rasterizer.hsl2rgb[hs1 | l11 + l21 * 3 >> 4];
					}
					l11 += l31;
					l21 += l41;
					pixelPointer += j;
				}
			}
			return;
		}
		if (underlayRGB != 0) {
			for (int i3 = 0; i3 < 4; i3++) {
				pixels[pixelPointer] = shapePoints[shapeIndices[shapePtr++]] != 0 ? overlayRGB : underlayRGB;
				pixels[pixelPointer + 1] = shapePoints[shapeIndices[shapePtr++]] != 0 ? overlayRGB : underlayRGB;
				pixels[pixelPointer + 2] = shapePoints[shapeIndices[shapePtr++]] != 0 ? overlayRGB : underlayRGB;
				pixels[pixelPointer + 3] = shapePoints[shapeIndices[shapePtr++]] != 0 ? overlayRGB : underlayRGB;
				pixelPointer += j;
			}

			return;
		}
		for (int j3 = 0; j3 < 4; j3++) {
			if (shapePoints[shapeIndices[shapePtr++]] != 0) {
				pixels[pixelPointer] = overlayRGB;
			}
			if (shapePoints[shapeIndices[shapePtr++]] != 0) {
				pixels[pixelPointer + 1] = overlayRGB;
			}
			if (shapePoints[shapeIndices[shapePtr++]] != 0) {
				pixels[pixelPointer + 2] = overlayRGB;
			}
			if (shapePoints[shapeIndices[shapePtr++]] != 0) {
				pixels[pixelPointer + 3] = overlayRGB;
			}
			pixelPointer += j;
		}

	}

	public void method312(int i, int j) {
		isClicked = true;
		anInt468 = j;
		anInt469 = i;
		clickedTileX = -1;
		clickedTileY = -1;
	}

	public void method313(int xCampos, int yCampos, int xCurve, int zCampos, int plane, int yCurve) {

		if (xCampos < 0) {
			xCampos = 0;
		} else if (xCampos >= xMapSize * 128) {
			xCampos = xMapSize * 128 - 1;
		}
		if (yCampos < 0) {
			yCampos = 0;
		} else if (yCampos >= yMapSize * 128) {
			yCampos = yMapSize * 128 - 1;
		}
		anInt448++;
		yCurveSine = Model.SINE[yCurve];
		yCurveCosine = Model.COSINE[yCurve];
		xCurveSine = Model.SINE[xCurve];
		xCurveCosine = Model.COSINE[xCurve];
		TILE_VISIBILITY_MAP = TILE_VISIBILITY_MAPS[(yCurve - 128) / 32][xCurve / 64];
		xCameraPosition = xCampos;
		zCameraPosition = zCampos;
		yCameraPosition = yCampos;
		xCameraPositionTile = xCampos / 128;
		yCameraPositionTile = yCampos / 128;
		WorldController.plane = plane;
		anInt449 = xCameraPositionTile - TILE_DRAW_DISTANCE;
		if (anInt449 < 0) {
			anInt449 = 0;
		}
		anInt451 = yCameraPositionTile - TILE_DRAW_DISTANCE;
		if (anInt451 < 0) {
			anInt451 = 0;
		}
		anInt450 = xCameraPositionTile + TILE_DRAW_DISTANCE;
		if (anInt450 > xMapSize) {
			anInt450 = xMapSize;
		}
		anInt452 = yCameraPositionTile + TILE_DRAW_DISTANCE;
		if (anInt452 > yMapSize) {
			anInt452 = yMapSize;
		}
		process_culling();
		anInt446 = 0;
		for (int k1 = currentHL; k1 < zMapSize; k1++) {
			Tile floorTiles[][] = tileArray[k1];
			for (int i2 = anInt449; i2 < anInt450; i2++) {
				for (int k2 = anInt451; k2 < anInt452; k2++) {
					Tile singleTile = floorTiles[i2][k2];
					if (singleTile != null) {
						if (singleTile.logicHeight > plane || !TILE_VISIBILITY_MAP[i2 - xCameraPositionTile + TILE_DRAW_DISTANCE][k2 - yCameraPositionTile + TILE_DRAW_DISTANCE] && heightmap[k1][i2][k2] - zCampos < (Configuration.INCREASED_RENDER_DISTANCE ? 4000 : 2000)) {
							singleTile.aBoolean1322 = false;
							singleTile.aBoolean1323 = false;
							singleTile.anInt1325 = 0;
						} else {
							singleTile.aBoolean1322 = true;
							singleTile.aBoolean1323 = true;
							singleTile.aBoolean1324 = singleTile.entityCount > 0;
							anInt446++;
						}
					}
				}

			}

		}

		for (int l1 = currentHL; l1 < zMapSize; l1++) {
			Tile tiles[][] = tileArray[l1];
			for (int l2 = -TILE_DRAW_DISTANCE; l2 <= 0; l2++) {
				int i3 = xCameraPositionTile + l2;
				int k3 = xCameraPositionTile - l2;
				if (i3 >= anInt449 || k3 < anInt450) {
					for (int i4 = -TILE_DRAW_DISTANCE; i4 <= 0; i4++) {
						int k4 = yCameraPositionTile + i4;
						int i5 = yCameraPositionTile - i4;
						if (i3 >= anInt449) {
							if (k4 >= anInt451) {
								Tile class30_sub3_1 = tiles[i3][k4];
								if (class30_sub3_1 != null && class30_sub3_1.aBoolean1322) {
									renderTile(class30_sub3_1, true);
								}
							}
							if (i5 < anInt452) {
								Tile class30_sub3_2 = tiles[i3][i5];
								if (class30_sub3_2 != null && class30_sub3_2.aBoolean1322) {
									renderTile(class30_sub3_2, true);
								}
							}
						}
						if (k3 < anInt450) {
							if (k4 >= anInt451) {
								Tile class30_sub3_3 = tiles[k3][k4];
								if (class30_sub3_3 != null && class30_sub3_3.aBoolean1322) {
									renderTile(class30_sub3_3, true);
								}
							}
							if (i5 < anInt452) {
								Tile class30_sub3_4 = tiles[k3][i5];
								if (class30_sub3_4 != null && class30_sub3_4.aBoolean1322) {
									renderTile(class30_sub3_4, true);
								}
							}
						}
						if (anInt446 == 0) {
							isClicked = false;
							return;
						}
					}

				}
			}

		}

		for (int j2 = currentHL; j2 < zMapSize; j2++) {
			Tile aclass30_sub3_2[][] = tileArray[j2];
			for (int j3 = -TILE_DRAW_DISTANCE; j3 <= 0; j3++) {
				int l3 = xCameraPositionTile + j3;
				int j4 = xCameraPositionTile - j3;
				if (l3 >= anInt449 || j4 < anInt450) {
					for (int l4 = -TILE_DRAW_DISTANCE; l4 <= 0; l4++) {
						int j5 = yCameraPositionTile + l4;
						int k5 = yCameraPositionTile - l4;
						if (l3 >= anInt449) {
							if (j5 >= anInt451) {
								Tile class30_sub3_5 = aclass30_sub3_2[l3][j5];
								if (class30_sub3_5 != null && class30_sub3_5.aBoolean1322) {
									renderTile(class30_sub3_5, false);
								}
							}
							if (k5 < anInt452) {
								Tile class30_sub3_6 = aclass30_sub3_2[l3][k5];
								if (class30_sub3_6 != null && class30_sub3_6.aBoolean1322) {
									renderTile(class30_sub3_6, false);
								}
							}
						}
						if (j4 < anInt450) {
							if (j5 >= anInt451) {
								Tile class30_sub3_7 = aclass30_sub3_2[j4][j5];
								if (class30_sub3_7 != null && class30_sub3_7.aBoolean1322) {
									renderTile(class30_sub3_7, false);
								}
							}
							if (k5 < anInt452) {
								Tile class30_sub3_8 = aclass30_sub3_2[j4][k5];
								if (class30_sub3_8 != null && class30_sub3_8.aBoolean1322) {
									renderTile(class30_sub3_8, false);
								}
							}
						}
						if (anInt446 == 0) {
							isClicked = false;
							return;
						}
					}

				}
			}

		}

		isClicked = false;
	}

	private void renderTile(Tile class30_sub3, boolean flag) {
		aClass19_477.insertHead(class30_sub3);
			do {
				Tile tile;
				do {
					tile = (Tile) aClass19_477.popHead();
					if (tile == null) {
						return;
					}
				} while (!tile.aBoolean1323);
				int tileX = tile.tileX;
				int tileY = tile.tileY;
				int tileZ = tile.tileZ;
				int l = tile.anInt1310;
				Tile aclass30_sub3[][] = tileArray[tileZ];
				if (tile.aBoolean1322) {
					if (flag) {
						if (tileZ > 0) {
							Tile class30_sub3_2 = tileArray[tileZ - 1][tileX][tileY];
							if (class30_sub3_2 != null && class30_sub3_2.aBoolean1323) {
								continue;
							}
						}
						if (tileX <= xCameraPositionTile && tileX > anInt449) {
							Tile class30_sub3_3 = aclass30_sub3[tileX - 1][tileY];
							if (class30_sub3_3 != null && class30_sub3_3.aBoolean1323 && (class30_sub3_3.aBoolean1322 || (tile.anInt1320 & 1) == 0)) {
								continue;
							}
						}
						if (tileX >= xCameraPositionTile && tileX < anInt450 - 1) {
							Tile class30_sub3_4 = aclass30_sub3[tileX + 1][tileY];
							if (class30_sub3_4 != null && class30_sub3_4.aBoolean1323 && (class30_sub3_4.aBoolean1322 || (tile.anInt1320 & 4) == 0)) {
								continue;
							}
						}
						if (tileY <= yCameraPositionTile && tileY > anInt451) {
							Tile class30_sub3_5 = aclass30_sub3[tileX][tileY - 1];
							if (class30_sub3_5 != null && class30_sub3_5.aBoolean1323 && (class30_sub3_5.aBoolean1322 || (tile.anInt1320 & 8) == 0)) {
								continue;
							}
						}
						if (tileY >= yCameraPositionTile && tileY < anInt452 - 1) {
							Tile class30_sub3_6 = aclass30_sub3[tileX][tileY + 1];
							if (class30_sub3_6 != null && class30_sub3_6.aBoolean1323 && (class30_sub3_6.aBoolean1322 || (tile.anInt1320 & 2) == 0)) {
								continue;
							}
						}
					} else {
						flag = true;
					}
					tile.aBoolean1322 = false;
					if (tile.tileBelow0 != null) {
						Tile class30_sub3_7 = tile.tileBelow0;
						if (class30_sub3_7.myPlainTile != null) {
							if (!method320(0, tileX, tileY)) {
								renderPlainTile(class30_sub3_7.myPlainTile, 0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, tileX, tileY);
							}
						} else if (class30_sub3_7.shapedTile != null && !method320(0, tileX, tileY)) {
							renderShapedTile(tileX, yCurveSine, xCurveSine, class30_sub3_7.shapedTile, yCurveCosine, tileY, xCurveCosine);
						}
						WallObject wallObject = class30_sub3_7.wallObject;
						if (wallObject != null && wallObject.node1 != null) {
							wallObject.node1.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, wallObject.xPos - xCameraPosition, wallObject.zPos - zCameraPosition, wallObject.yPos - yCameraPosition, wallObject.uid, wallObject.getNewUID());
						}
						for (int i2 = 0; i2 < class30_sub3_7.entityCount; i2++) {
							InteractiveObject interactiveObject = class30_sub3_7.interactiveObjects[i2];
							if (interactiveObject != null) {
								interactiveObject.jagexNode.renderAtPoint(interactiveObject.rotation, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, interactiveObject.worldX - xCameraPosition, interactiveObject.worldZ - zCameraPosition, interactiveObject.worldY - yCameraPosition, interactiveObject.uid, interactiveObject.getNewUID());
							}
						}

					}
					boolean flag1 = false;
					if (tile.myPlainTile != null) {
						if (!method320(l, tileX, tileY)) {
							flag1 = true;
							renderPlainTile(tile.myPlainTile, l, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, tileX, tileY);
						}
					} else if (tile.shapedTile != null && !method320(l, tileX, tileY)) {
						flag1 = true;
						renderShapedTile(tileX, yCurveSine, xCurveSine, tile.shapedTile, yCurveCosine, tileY, xCurveCosine);
					}
					int j1 = 0;
					int j2 = 0;
					WallObject class10_3 = tile.wallObject;
					WallDecoration class26_1 = tile.wallDecoration;
					if (class10_3 != null || class26_1 != null) {
						if (xCameraPositionTile == tileX) {
							j1++;
						} else if (xCameraPositionTile < tileX) {
							j1 += 2;
						}
						if (yCameraPositionTile == tileY) {
							j1 += 3;
						} else if (yCameraPositionTile > tileY) {
							j1 += 6;
						}
						j2 = anIntArray478[j1];
						tile.anInt1328 = anIntArray480[j1];
					}
					if (class10_3 != null) {
						if ((class10_3.orientation & anIntArray479[j1]) != 0) {
							if (class10_3.orientation == 16) {
								tile.anInt1325 = 3;
								tile.anInt1326 = anIntArray481[j1];
								tile.anInt1327 = 3 - tile.anInt1326;
							} else if (class10_3.orientation == 32) {
								tile.anInt1325 = 6;
								tile.anInt1326 = anIntArray482[j1];
								tile.anInt1327 = 6 - tile.anInt1326;
							} else if (class10_3.orientation == 64) {
								tile.anInt1325 = 12;
								tile.anInt1326 = anIntArray483[j1];
								tile.anInt1327 = 12 - tile.anInt1326;
							} else {
								tile.anInt1325 = 9;
								tile.anInt1326 = anIntArray484[j1];
								tile.anInt1327 = 9 - tile.anInt1326;
							}
						} else {
							tile.anInt1325 = 0;
						}
						if ((class10_3.orientation & j2) != 0 && !method321(l, tileX, tileY, class10_3.orientation) && class10_3.node1 != null) {
							class10_3.node1.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, class10_3.xPos - xCameraPosition, class10_3.zPos - zCameraPosition, class10_3.yPos - yCameraPosition, class10_3.uid, class10_3.getNewUID());
						}
						if ((class10_3.orientation1 & j2) != 0 && !method321(l, tileX, tileY, class10_3.orientation1)) {
							class10_3.node2.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, class10_3.xPos - xCameraPosition, class10_3.zPos - zCameraPosition, class10_3.yPos - yCameraPosition, class10_3.uid, class10_3.getNewUID());
						}
					}
					if (class26_1 != null && !method322(l, tileX, tileY, class26_1.myMob.modelHeight)) {
						if ((class26_1.configBits & j2) != 0) {
							class26_1.myMob.renderAtPoint(class26_1.face, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, class26_1.xPos - xCameraPosition, class26_1.zPos - zCameraPosition, class26_1.yPos - yCameraPosition, class26_1.uid, class26_1.getNewUID());
						} else if ((class26_1.configBits & 0x300) != 0) {
							int j4 = class26_1.xPos - xCameraPosition;
							int l5 = class26_1.zPos - zCameraPosition;
							int k6 = class26_1.yPos - yCameraPosition;
							int i8 = class26_1.face;
							int k9;
							if (i8 == 1 || i8 == 2) {
								k9 = -j4;
							} else {
								k9 = j4;
							}
							int k10;
							if (i8 == 2 || i8 == 3) {
								k10 = -k6;
							} else {
								k10 = k6;
							}
							if ((class26_1.configBits & 0x100) != 0 && k10 < k9) {
								int i11 = j4 + anIntArray463[i8];
								int k11 = k6 + anIntArray464[i8];
								class26_1.myMob.renderAtPoint(i8 * 512 + 256, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, i11, l5, k11, class26_1.uid, class26_1.getNewUID());
							}
							if ((class26_1.configBits & 0x200) != 0 && k10 > k9) {
								int j11 = j4 + anIntArray465[i8];
								int l11 = k6 + anIntArray466[i8];
								class26_1.myMob.renderAtPoint(i8 * 512 + 1280 & 0x7ff, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, j11, l5, l11, class26_1.uid, class26_1.getNewUID());
							}
						}
					}
					if (flag1) {
						GroundDecoration class49 = tile.groundDecoration;
						if (class49 != null) {
							class49.aClass30_Sub2_Sub4_814.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, class49.xPos - xCameraPosition, class49.zPos - zCameraPosition, class49.yPos - yCameraPosition, class49.uid, class49.id);
						}
						GroundItemTile groundItemTile_1 = tile.groundItemTile;
						if (groundItemTile_1 != null && groundItemTile_1.anInt52 == 0) {
							if (groundItemTile_1.secondGroundItem != null) {
								groundItemTile_1.secondGroundItem.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, groundItemTile_1.xPos - xCameraPosition, groundItemTile_1.zPos - zCameraPosition, groundItemTile_1.yPos - yCameraPosition, groundItemTile_1.uid, groundItemTile_1.getNewUID());
							}
							if (groundItemTile_1.thirdGroundItem != null) {
								groundItemTile_1.thirdGroundItem.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, groundItemTile_1.xPos - xCameraPosition, groundItemTile_1.zPos - zCameraPosition, groundItemTile_1.yPos - yCameraPosition, groundItemTile_1.uid, groundItemTile_1.getNewUID());
							}
							if (groundItemTile_1.firstGroundItem != null) {
								groundItemTile_1.firstGroundItem.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, groundItemTile_1.xPos - xCameraPosition, groundItemTile_1.zPos - zCameraPosition, groundItemTile_1.yPos - yCameraPosition, groundItemTile_1.uid, groundItemTile_1.getNewUID());
							}
						}
					}
					int k4 = tile.anInt1320;
					if (k4 != 0) {
						if (tileX < xCameraPositionTile && (k4 & 4) != 0) {
							Tile class30_sub3_17 = aclass30_sub3[tileX + 1][tileY];
							if (class30_sub3_17 != null && class30_sub3_17.aBoolean1323) {
								aClass19_477.insertHead(class30_sub3_17);
							}
						}
						if (tileY < yCameraPositionTile && (k4 & 2) != 0) {
							Tile class30_sub3_18 = aclass30_sub3[tileX][tileY + 1];
							if (class30_sub3_18 != null && class30_sub3_18.aBoolean1323) {
								aClass19_477.insertHead(class30_sub3_18);
							}
						}
						if (tileX > xCameraPositionTile && (k4 & 1) != 0) {
							Tile class30_sub3_19 = aclass30_sub3[tileX - 1][tileY];
							if (class30_sub3_19 != null && class30_sub3_19.aBoolean1323) {
								aClass19_477.insertHead(class30_sub3_19);
							}
						}
						if (tileY > yCameraPositionTile && (k4 & 8) != 0) {
							Tile class30_sub3_20 = aclass30_sub3[tileX][tileY - 1];
							if (class30_sub3_20 != null && class30_sub3_20.aBoolean1323) {
								aClass19_477.insertHead(class30_sub3_20);
							}
						}
					}
				}
				if (tile.anInt1325 != 0) {
					boolean flag2 = true;
					for (int k1 = 0; k1 < tile.entityCount; k1++) {
						if (tile.interactiveObjects[k1].anInt528 == anInt448 || (tile.anIntArray1319[k1] & tile.anInt1325) != tile.anInt1326) {
							continue;
						}
						flag2 = false;
						break;
					}

					if (flag2) {
						WallObject class10_1 = tile.wallObject;
						if (!method321(l, tileX, tileY, class10_1.orientation)) {
							class10_1.node1.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, class10_1.xPos - xCameraPosition, class10_1.zPos - zCameraPosition, class10_1.yPos - yCameraPosition, class10_1.uid, class10_1.getNewUID());
						}
						tile.anInt1325 = 0;
					}
				}
				if (tile.aBoolean1324) {
					try {
						int i1 = tile.entityCount;
						tile.aBoolean1324 = false;
						int l1 = 0;
						label0:
						for (int k2 = 0; k2 < i1; k2++) {
							InteractiveObject class28_1 = tile.interactiveObjects[k2];
							if (class28_1.anInt528 == anInt448) {
								continue;
							}
							for (int k3 = class28_1.tileLeft; k3 <= class28_1.tileRight; k3++) {
								for (int l4 = class28_1.tileTop; l4 <= class28_1.tileBottom; l4++) {
									Tile class30_sub3_21 = aclass30_sub3[k3][l4];
									if (class30_sub3_21.aBoolean1322) {
										tile.aBoolean1324 = true;
									} else {
										if (class30_sub3_21.anInt1325 == 0) {
											continue;
										}
										int l6 = 0;
										if (k3 > class28_1.tileLeft) {
											l6++;
										}
										if (k3 < class28_1.tileRight) {
											l6 += 4;
										}
										if (l4 > class28_1.tileTop) {
											l6 += 8;
										}
										if (l4 < class28_1.tileBottom) {
											l6 += 2;
										}
										if ((l6 & class30_sub3_21.anInt1325) != tile.anInt1327) {
											continue;
										}
										tile.aBoolean1324 = true;
									}
									continue label0;
								}

							}

							interactiveObjects[l1++] = class28_1;
							int i5 = xCameraPositionTile - class28_1.tileLeft;
							int i6 = class28_1.tileRight - xCameraPositionTile;
							if (i6 > i5) {
								i5 = i6;
							}
							int i7 = yCameraPositionTile - class28_1.tileTop;
							int j8 = class28_1.tileBottom - yCameraPositionTile;
							if (j8 > i7) {
								class28_1.anInt527 = i5 + j8;
							} else {
								class28_1.anInt527 = i5 + i7;
							}
						}

						while (l1 > 0) {
							int i3 = -50;
							int l3 = -1;
							for (int j5 = 0; j5 < l1; j5++) {
								InteractiveObject class28_2 = interactiveObjects[j5];
								if (class28_2.anInt528 != anInt448) {
									if (class28_2.anInt527 > i3) {
										i3 = class28_2.anInt527;
										l3 = j5;
									} else if (class28_2.anInt527 == i3) {
										int j7 = class28_2.worldX - xCameraPosition;
										int k8 = class28_2.worldY - yCameraPosition;
										int l9 = interactiveObjects[l3].worldX - xCameraPosition;
										int l10 = interactiveObjects[l3].worldY - yCameraPosition;
										if (j7 * j7 + k8 * k8 > l9 * l9 + l10 * l10) {
											l3 = j5;
										}
									}
								}
							}

							if (l3 == -1) {
								break;
							}
							InteractiveObject class28_3 = interactiveObjects[l3];
							class28_3.anInt528 = anInt448;
							if (!method323(l, class28_3.tileLeft, class28_3.tileRight, class28_3.tileTop, class28_3.tileBottom, class28_3.jagexNode.modelHeight)) {
								class28_3.jagexNode.renderAtPoint(class28_3.rotation, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, class28_3.worldX - xCameraPosition, class28_3.worldZ - zCameraPosition, class28_3.worldY - yCameraPosition, class28_3.uid, class28_3.getNewUID());
							}
							for (int k7 = class28_3.tileLeft; k7 <= class28_3.tileRight; k7++) {
								for (int l8 = class28_3.tileTop; l8 <= class28_3.tileBottom; l8++) {
									Tile class30_sub3_22 = aclass30_sub3[k7][l8];
									if (class30_sub3_22.anInt1325 != 0) {
										aClass19_477.insertHead(class30_sub3_22);
									} else if ((k7 != tileX || l8 != tileY) && class30_sub3_22.aBoolean1323) {
										aClass19_477.insertHead(class30_sub3_22);
									}
								}

							}

						}
						if (tile.aBoolean1324) {
							continue;
						}
					} catch (Exception _ex) {
						tile.aBoolean1324 = false;
					}
				}
				if (!tile.aBoolean1323 || tile.anInt1325 != 0) {
					continue;
				}
				if (tileX <= xCameraPositionTile && tileX > anInt449) {
					Tile class30_sub3_8 = aclass30_sub3[tileX - 1][tileY];
					if (class30_sub3_8 != null && class30_sub3_8.aBoolean1323) {
						continue;
					}
				}
				if (tileX >= xCameraPositionTile && tileX < anInt450 - 1) {
					Tile class30_sub3_9 = aclass30_sub3[tileX + 1][tileY];
					if (class30_sub3_9 != null && class30_sub3_9.aBoolean1323) {
						continue;
					}
				}
				if (tileY <= yCameraPositionTile && tileY > anInt451) {
					Tile class30_sub3_10 = aclass30_sub3[tileX][tileY - 1];
					if (class30_sub3_10 != null && class30_sub3_10.aBoolean1323) {
						continue;
					}
				}
				if (tileY >= yCameraPositionTile && tileY < anInt452 - 1) {
					Tile class30_sub3_11 = aclass30_sub3[tileX][tileY + 1];
					if (class30_sub3_11 != null && class30_sub3_11.aBoolean1323) {
						continue;
					}
				}
				tile.aBoolean1323 = false;
				anInt446--;
				GroundItemTile groundItemTile = tile.groundItemTile;
				if (groundItemTile != null && groundItemTile.anInt52 != 0) {
					if (groundItemTile.secondGroundItem != null) {
						groundItemTile.secondGroundItem.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, groundItemTile.xPos - xCameraPosition, groundItemTile.zPos - zCameraPosition - groundItemTile.anInt52, groundItemTile.yPos - yCameraPosition, groundItemTile.uid, groundItemTile.getNewUID());
					}
					if (groundItemTile.thirdGroundItem != null) {
						groundItemTile.thirdGroundItem.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, groundItemTile.xPos - xCameraPosition, groundItemTile.zPos - zCameraPosition - groundItemTile.anInt52, groundItemTile.yPos - yCameraPosition, groundItemTile.uid, groundItemTile.getNewUID());
					}
					if (groundItemTile.firstGroundItem != null) {
						groundItemTile.firstGroundItem.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, groundItemTile.xPos - xCameraPosition, groundItemTile.zPos - zCameraPosition - groundItemTile.anInt52, groundItemTile.yPos - yCameraPosition, groundItemTile.uid, groundItemTile.getNewUID());
					}
				}
				if (tile.anInt1328 != 0) {
					WallDecoration class26 = tile.wallDecoration;
					if (class26 != null && !method322(l, tileX, tileY, class26.myMob.modelHeight)) {
						if ((class26.configBits & tile.anInt1328) != 0) {
							class26.myMob.renderAtPoint(class26.face, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, class26.xPos - xCameraPosition, class26.zPos - zCameraPosition, class26.yPos - yCameraPosition, class26.uid, class26.getNewUID());
						} else if ((class26.configBits & 0x300) != 0) {
							int l2 = class26.xPos - xCameraPosition;
							int j3 = class26.zPos - zCameraPosition;
							int i4 = class26.yPos - yCameraPosition;
							int k5 = class26.face;
							int j6;
							if (k5 == 1 || k5 == 2) {
								j6 = -l2;
							} else {
								j6 = l2;
							}
							int l7;
							if (k5 == 2 || k5 == 3) {
								l7 = -i4;
							} else {
								l7 = i4;
							}
							if ((class26.configBits & 0x100) != 0 && l7 >= j6) {
								int i9 = l2 + anIntArray463[k5];
								int i10 = i4 + anIntArray464[k5];
								class26.myMob.renderAtPoint(k5 * 512 + 256, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, i9, j3, i10, class26.uid, class26.getNewUID());
							}
							if ((class26.configBits & 0x200) != 0 && l7 <= j6) {
								int j9 = l2 + anIntArray465[k5];
								int j10 = i4 + anIntArray466[k5];
								class26.myMob.renderAtPoint(k5 * 512 + 1280 & 0x7ff, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, j9, j3, j10, class26.uid, class26.getNewUID());
							}
						}
					}
					WallObject class10_2 = tile.wallObject;
					if (class10_2 != null) {
						if ((class10_2.orientation1 & tile.anInt1328) != 0 && !method321(l, tileX, tileY, class10_2.orientation1)) {
							class10_2.node2.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, class10_2.xPos - xCameraPosition, class10_2.zPos - zCameraPosition, class10_2.yPos - yCameraPosition, class10_2.uid, class10_2.getNewUID());
						}
						if ((class10_2.orientation & tile.anInt1328) != 0 && !method321(l, tileX, tileY, class10_2.orientation) && class10_2.node1 != null) {
							class10_2.node1.renderAtPoint(0, yCurveSine, yCurveCosine, xCurveSine, xCurveCosine, class10_2.xPos - xCameraPosition, class10_2.zPos - zCameraPosition, class10_2.yPos - yCameraPosition, class10_2.uid, class10_2.getNewUID());
						}
					}
				}
				if (tileZ < zMapSize - 1) {
					Tile class30_sub3_12 = tileArray[tileZ + 1][tileX][tileY];
					if (class30_sub3_12 != null && class30_sub3_12.aBoolean1323) {
						aClass19_477.insertHead(class30_sub3_12);
					}
				}
				if (tileX < xCameraPositionTile) {
					Tile class30_sub3_13 = aclass30_sub3[tileX + 1][tileY];
					if (class30_sub3_13 != null && class30_sub3_13.aBoolean1323) {
						aClass19_477.insertHead(class30_sub3_13);
					}
				}
				if (tileY < yCameraPositionTile) {
					Tile class30_sub3_14 = aclass30_sub3[tileX][tileY + 1];
					if (class30_sub3_14 != null && class30_sub3_14.aBoolean1323) {
						aClass19_477.insertHead(class30_sub3_14);
					}
				}
				if (tileX > xCameraPositionTile) {
					Tile class30_sub3_15 = aclass30_sub3[tileX - 1][tileY];
					if (class30_sub3_15 != null && class30_sub3_15.aBoolean1323) {
						aClass19_477.insertHead(class30_sub3_15);
					}
				}
				if (tileY > yCameraPositionTile) {
					Tile class30_sub3_16 = aclass30_sub3[tileX][tileY - 1];
					if (class30_sub3_16 != null && class30_sub3_16.aBoolean1323) {
						aClass19_477.insertHead(class30_sub3_16);
					}
				}
			} while (true);
	}

	private void renderPlainTile(PlainTile plainTile, int tZ, int ysin, int ycos, int xsin, int xcos, int tX, int tY) {
		int xC;
		int xA = xC = (tX << 7) - xCameraPosition;
		int yB;
		int yA = yB = (tY << 7) - yCameraPosition;
		int xD;
		int xB = xD = xA + 128;
		int yC;
		int yD = yC = yA + 128;
		int zA = heightmap[tZ][tX][tY] - zCameraPosition;
		int zB = heightmap[tZ][tX + 1][tY] - zCameraPosition;
		int zD = heightmap[tZ][tX + 1][tY + 1] - zCameraPosition;
		int zC = heightmap[tZ][tX][tY + 1] - zCameraPosition;
		int l4 = yA * xsin + xA * xcos >> 16;
		yA = yA * xcos - xA * xsin >> 16;
		xA = l4;
		l4 = zA * ycos - yA * ysin >> 16;
		yA = zA * ysin + yA * ycos >> 16;
		zA = l4;
		if (yA < Configuration.CAM_NEAR) {
			return;
		}
		l4 = yB * xsin + xB * xcos >> 16;
		yB = yB * xcos - xB * xsin >> 16;
		xB = l4;
		l4 = zB * ycos - yB * ysin >> 16;
		yB = zB * ysin + yB * ycos >> 16;
		zB = l4;
		if (yB < Configuration.CAM_NEAR) {
			return;
		}
		l4 = yD * xsin + xD * xcos >> 16;
		yD = yD * xcos - xD * xsin >> 16;
		xD = l4;
		l4 = zD * ycos - yD * ysin >> 16;
		yD = zD * ysin + yD * ycos >> 16;
		zD = l4;
		if (yD < Configuration.CAM_NEAR) {
			return;
		}
		l4 = yC * xsin + xC * xcos >> 16;
		yC = yC * xcos - xC * xsin >> 16;
		xC = l4;
		l4 = zC * ycos - yC * ysin >> 16;
		yC = zC * ysin + yC * ycos >> 16;
		zC = l4;
		if (yC < Configuration.CAM_NEAR) {
			return;
		}
		int screenXA = Rasterizer.centerX + (xA << Client.log_view_dist) / yA;
		int screenYA = Rasterizer.centerY + (zA << Client.log_view_dist) / yA;
		int screenXB = Rasterizer.centerX + (xB << Client.log_view_dist) / yB;
		int screenYB = Rasterizer.centerY + (zB << Client.log_view_dist) / yB;
		int screenXD = Rasterizer.centerX + (xD << Client.log_view_dist) / yD;
		int screenYD = Rasterizer.centerY + (zD << Client.log_view_dist) / yD;
		int screenXC = Rasterizer.centerX + (xC << Client.log_view_dist) / yC;
		int screenYC = Rasterizer.centerY + (zC << Client.log_view_dist) / yC;
		Rasterizer.alpha = 0;
		if ((screenXD - screenXC) * (screenYB - screenYC) - (screenYD - screenYC) * (screenXB - screenXC) > 0) {
			Rasterizer.restrict_edges = screenXD < 0 || screenXC < 0 || screenXB < 0 || screenXD > Raster.viewportRx || screenXC > Raster.viewportRx || screenXB > Raster.viewportRx;
			if (isClicked && isMouseWithinTriangle(anInt468, anInt469, screenYD, screenYC, screenYB, screenXD, screenXC, screenXB)) {
				clickedTileX = tX;
				clickedTileY = tY;
			}
			if(plainTile.texture == -1)
			{
				if(plainTile.colourD != 0xbc614e) {
					if(Configuration.DEPTH_BUFFER)
						Rasterizer.drawShadedTriangle(screenYD, screenYC, screenYB, screenXD, screenXC, screenXB, plainTile.colourD, plainTile.anInt719, plainTile.anInt717, yD, yC, yB);
					else
						Rasterizer.method374(screenYD, screenYC, screenYB, screenXD, screenXC, screenXB, plainTile.colourD, plainTile.anInt719, plainTile.anInt717);
				}
			} else if(!lowDetail)
			{
				if (plainTile.flat) {
					if(Configuration.DEPTH_BUFFER)
						Rasterizer.drawTexturedTriangle(screenYD, screenYC, screenYB, screenXD, screenXC, screenXB, plainTile.colourD, plainTile.anInt719, plainTile.anInt717, xA, xB, xC, zA, zB, zC, yA, yB, yC, plainTile.texture, yD, yC, yB);
					else
						Rasterizer.method378(screenYD, screenYC, screenYB, screenXD, screenXC, screenXB, plainTile.colourD, plainTile.anInt719, plainTile.anInt717, xA, xB, xC, zA, zB, zC, yA, yB, yC, plainTile.texture);
				} else {
					if(Configuration.DEPTH_BUFFER)
						Rasterizer.drawTexturedTriangle(screenYD, screenYC, screenYB, screenXD, screenXC, screenXB, plainTile.colourD, plainTile.anInt719, plainTile.anInt717, xD, xC, xB, zD, zC, zB, yD, yC, yB, plainTile.texture, yD, yC, yB);
					else
						Rasterizer.method378(screenYD, screenYC, screenYB, screenXD, screenXC, screenXB, plainTile.colourD, plainTile.anInt719, plainTile.anInt717, xD, xC, xB, zD, zC, zB, yD, yC, yB, plainTile.texture);
				}
			} else
			{
				int i7 = textureRGBColour[plainTile.texture];
				if(Configuration.DEPTH_BUFFER)
					Rasterizer.drawShadedTriangle(screenYD, screenYC, screenYB, screenXD, screenXC, screenXB, mixColour(i7, plainTile.colourD), mixColour(i7, plainTile.anInt719), mixColour(i7, plainTile.anInt717), yD, yC, yB);
				else
					Rasterizer.method374(screenYD, screenYC, screenYB, screenXD, screenXC, screenXB, mixColour(i7, plainTile.colourD), mixColour(i7, plainTile.anInt719), mixColour(i7, plainTile.anInt717));
			}
		}
		if((screenXA - screenXB) * (screenYC - screenYB) - (screenYA - screenYB) * (screenXC - screenXB) > 0)
		{
			Rasterizer.restrict_edges = screenXA < 0 || screenXB < 0 || screenXC < 0 || screenXA > Raster.viewportRx || screenXB > Raster.viewportRx || screenXC > Raster.viewportRx;
			if(isClicked && isMouseWithinTriangle(anInt468, anInt469, screenYA, screenYB, screenYC, screenXA, screenXB, screenXC))
			{
				clickedTileX = tX;
				clickedTileY = tY;
			}
			if (plainTile.texture == -1) {
				if (plainTile.colourA != 0xbc614e) {
					if(Configuration.DEPTH_BUFFER)
						Rasterizer.drawShadedTriangle(screenYA, screenYB, screenYC, screenXA, screenXB, screenXC, plainTile.colourA, plainTile.anInt717, plainTile.anInt719, yA, yB, yC);
					else
						Rasterizer.method374(screenYA, screenYB, screenYC, screenXA, screenXB, screenXC, plainTile.colourA, plainTile.anInt717, plainTile.anInt719);
				}
			} else {
				if (!lowDetail) {
					if(Configuration.DEPTH_BUFFER)
						Rasterizer.drawTexturedTriangle(screenYA, screenYB, screenYC, screenXA, screenXB, screenXC, plainTile.colourA, plainTile.anInt717, plainTile.anInt719, xA, xB, xC, zA, zB, zC, yA, yB, yC, plainTile.texture, yA, yB, yC);
					else
						Rasterizer.method378(screenYA, screenYB, screenYC, screenXA, screenXB, screenXC, plainTile.colourA, plainTile.anInt717, plainTile.anInt719, xA, xB, xC, zA, zB, zC, yA, yB, yC, plainTile.texture);
					return;
				}
				int j7 = textureRGBColour[plainTile.texture];
				if(Configuration.DEPTH_BUFFER)
					Rasterizer.drawShadedTriangle(screenYA, screenYB, screenYC, screenXA, screenXB, screenXC, mixColour(j7, plainTile.colourA), mixColour(j7, plainTile.anInt717), mixColour(j7, plainTile.anInt719), yA, yB, yC);
				else
					Rasterizer.method374(screenYA, screenYB, screenYC, screenXA, screenXB, screenXC, mixColour(j7, plainTile.colourA), mixColour(j7, plainTile.anInt717), mixColour(j7, plainTile.anInt719));
			}
		}
	}

	private void renderShapedTile(int i, int ysin, int xsin, ShapedTile shapedTile, int ycos, int i1, int xcos) {
		int triangleCount = shapedTile.origVertexX.length;
		for (int l1 = 0; l1 < triangleCount; l1++) {
			int viewspaceX = shapedTile.origVertexX[l1] - xCameraPosition;
			int viewspaceY = shapedTile.origVertexY[l1] - zCameraPosition;
			int viewspaceZ = shapedTile.origVertexZ[l1] - yCameraPosition;
			int k3 = viewspaceZ * xsin + viewspaceX * xcos >> 16;
			viewspaceZ = viewspaceZ * xcos - viewspaceX * xsin >> 16;
			viewspaceX = k3;
			k3 = viewspaceY * ycos - viewspaceZ * ysin >> 16;
			viewspaceZ = viewspaceY * ysin + viewspaceZ * ycos >> 16;
			viewspaceY = k3;
			if (viewspaceZ < Configuration.CAM_NEAR) {
				return;
			}
			if (LocalSettings.getBoolean("hd_textures") || shapedTile.triangleTexture != null) {
				ShapedTile.viewSpaceX[l1] = viewspaceX;
				ShapedTile.viewSpaceY[l1] = viewspaceY;
				ShapedTile.viewSpaceZ[l1] = viewspaceZ;
			}
			ShapedTile.screenX[l1] = Rasterizer.centerX + (viewspaceX << Client.log_view_dist) / viewspaceZ;
			ShapedTile.screenY[l1] = Rasterizer.centerY + (viewspaceY << Client.log_view_dist) / viewspaceZ;
			ShapedTile.depthPoint[l1] = viewspaceZ;
		}
		Rasterizer.alpha = 0;
		triangleCount = shapedTile.triangleA.length;
		for (int triIdx = 0; triIdx < triangleCount; triIdx++) {
			int indexA = shapedTile.triangleA[triIdx];
			int indexB = shapedTile.triangleB[triIdx];
			int indexC = shapedTile.triangleC[triIdx];
			int x1 = ShapedTile.screenX[indexA];
			int x2 = ShapedTile.screenX[indexB];
			int x3 = ShapedTile.screenX[indexC];
			int y1 = ShapedTile.screenY[indexA];
			int y2 = ShapedTile.screenY[indexB];
			int y3 = ShapedTile.screenY[indexC];
			if ((x1 - x2) * (y3 - y2) - (y1 - y2) * (x3 - x2) > 0) {
				Rasterizer.restrict_edges = x1 < 0 || x2 < 0 || x3 < 0 || x1 > Raster.viewportRx || x2 > Raster.viewportRx || x3 > Raster.viewportRx;
				if (isClicked && isMouseWithinTriangle(anInt468, anInt469, y1, y2, y3, x1, x2, x3)) {
					clickedTileX = i;
					clickedTileY = i1;
				}
				if (shapedTile.triangleTexture == null || shapedTile.triangleTexture[triIdx] == -1 || shapedTile.triangleTexture[triIdx] > Rasterizer.TEXTURE_COUNT) {
					if (shapedTile.triangleHslA[triIdx] != 0xbc614e) {
						if(Configuration.DEPTH_BUFFER)
							Rasterizer.drawShadedTriangle(y1, y2, y3, x1, x2, x3, shapedTile.triangleHslA[triIdx], shapedTile.anIntArray677[triIdx], shapedTile.anIntArray678[triIdx], ShapedTile.depthPoint[indexA], ShapedTile.depthPoint[indexB], ShapedTile.depthPoint[indexC]);
						else
							Rasterizer.method374(y1, y2, y3, x1, x2, x3, shapedTile.triangleHslA[triIdx], shapedTile.anIntArray677[triIdx], shapedTile.anIntArray678[triIdx]);
					}
				} else if (!lowDetail) {
					if (shapedTile.flat) {
						if(Configuration.DEPTH_BUFFER)
							Rasterizer.drawTexturedTriangle(y1, y2, y3, x1, x2, x3, shapedTile.triangleHslA[triIdx], shapedTile.anIntArray677[triIdx], shapedTile.anIntArray678[triIdx], ShapedTile.viewSpaceX[0], ShapedTile.viewSpaceX[1], ShapedTile.viewSpaceX[3], ShapedTile.viewSpaceY[0], ShapedTile.viewSpaceY[1], ShapedTile.viewSpaceY[3], ShapedTile.viewSpaceZ[0], ShapedTile.viewSpaceZ[1], ShapedTile.viewSpaceZ[3], shapedTile.triangleTexture[triIdx], ShapedTile.depthPoint[indexA], ShapedTile.depthPoint[indexB], ShapedTile.depthPoint[indexC]);
						else
							Rasterizer.method378(y1, y2, y3, x1, x2, x3, shapedTile.triangleHslA[triIdx], shapedTile.anIntArray677[triIdx], shapedTile.anIntArray678[triIdx], ShapedTile.viewSpaceX[0], ShapedTile.viewSpaceX[1], ShapedTile.viewSpaceX[3], ShapedTile.viewSpaceY[0], ShapedTile.viewSpaceY[1], ShapedTile.viewSpaceY[3], ShapedTile.viewSpaceZ[0], ShapedTile.viewSpaceZ[1], ShapedTile.viewSpaceZ[3], shapedTile.triangleTexture[triIdx]);
					} else {
						if(Configuration.DEPTH_BUFFER)
							Rasterizer.drawTexturedTriangle(y1, y2, y3, x1, x2, x3, shapedTile.triangleHslA[triIdx], shapedTile.anIntArray677[triIdx], shapedTile.anIntArray678[triIdx], ShapedTile.viewSpaceX[indexA], ShapedTile.viewSpaceX[indexB], ShapedTile.viewSpaceX[indexC], ShapedTile.viewSpaceY[indexA], ShapedTile.viewSpaceY[indexB], ShapedTile.viewSpaceY[indexC], ShapedTile.viewSpaceZ[indexA], ShapedTile.viewSpaceZ[indexB], ShapedTile.viewSpaceZ[indexC], shapedTile.triangleTexture[triIdx], ShapedTile.depthPoint[indexA], ShapedTile.depthPoint[indexB], ShapedTile.depthPoint[indexC]);
						else
							Rasterizer.method378(y1, y2, y3, x1, x2, x3, shapedTile.triangleHslA[triIdx], shapedTile.anIntArray677[triIdx], shapedTile.anIntArray678[triIdx], ShapedTile.viewSpaceX[indexA], ShapedTile.viewSpaceX[indexB], ShapedTile.viewSpaceX[indexC], ShapedTile.viewSpaceY[indexA], ShapedTile.viewSpaceY[indexB], ShapedTile.viewSpaceY[indexC], ShapedTile.viewSpaceZ[indexA], ShapedTile.viewSpaceZ[indexB], ShapedTile.viewSpaceZ[indexC], shapedTile.triangleTexture[triIdx]);
					}
				} else {
					int k5 = textureRGBColour[shapedTile.triangleTexture[triIdx]];
					if(Configuration.DEPTH_BUFFER)
						Rasterizer.drawShadedTriangle(y1, y2, y3, x1, x2, x3, mixColour(k5, shapedTile.triangleHslA[triIdx]), mixColour(k5, shapedTile.anIntArray677[triIdx]), mixColour(k5, shapedTile.anIntArray678[triIdx]), ShapedTile.depthPoint[indexA], ShapedTile.depthPoint[indexB], ShapedTile.depthPoint[indexC]);
					else
						Rasterizer.method374(y1, y2, y3, x1, x2, x3, mixColour(k5, shapedTile.triangleHslA[triIdx]), mixColour(k5, shapedTile.anIntArray677[triIdx]), mixColour(k5, shapedTile.anIntArray678[triIdx]));
				}
			}
		}
	}

	private int mixColour(int j, int k) {
		k = 127 - k;
		k = k * (j & 0x7f) / 160;
		if (k < 2) {
			k = 2;
		} else if (k > 126) {
			k = 126;
		}
		return (j & 0xff80) + k;
	}

	private boolean isMouseWithinTriangle(int mouseX, int mouseY, int k, int l, int i1, int j1, int k1, int l1) {
		if (mouseY < k && mouseY < l && mouseY < i1) {
			return false;
		}
		if (mouseY > k && mouseY > l && mouseY > i1) {
			return false;
		}
		if (mouseX < j1 && mouseX < k1 && mouseX < l1) {
			return false;
		}
		if (mouseX > j1 && mouseX > k1 && mouseX > l1) {
			return false;
		}
		int i2 = (mouseY - k) * (k1 - j1) - (mouseX - j1) * (l - k);
		int j2 = (mouseY - i1) * (j1 - l1) - (mouseX - l1) * (k - i1);
		int k2 = (mouseY - l) * (l1 - k1) - (mouseX - k1) * (i1 - l);
		return i2 * k2 > 0 && k2 * j2 > 0;
	}

	private void process_culling() {
		int cluster_count = cullingClusterPointer[plane];
		CullingCluster clusters[] = cullingClusters[plane];
		processed_culling_clusters_ptr = 0;
		for (int ptr = 0; ptr < cluster_count; ptr++) {
			CullingCluster cullingCluster = clusters[ptr];
			if (cullingCluster.searchMask == 1) {
				int x_dist_from_camera_start = cullingCluster.tileStartX - xCameraPositionTile + TILE_DRAW_DISTANCE;
				if (x_dist_from_camera_start < 0 || x_dist_from_camera_start > (TILE_DRAW_DISTANCE << 1)) {
					continue;
				}
				int y_dist_from_camera_start = cullingCluster.tileStartY - yCameraPositionTile + TILE_DRAW_DISTANCE;
				if (y_dist_from_camera_start < 0) {
					y_dist_from_camera_start = 0;
				}
				int y_dist_from_camera_end = cullingCluster.tileEndY - yCameraPositionTile + TILE_DRAW_DISTANCE;
				if (y_dist_from_camera_end > (TILE_DRAW_DISTANCE << 1)) {
					y_dist_from_camera_end = (TILE_DRAW_DISTANCE << 1);
				}
				boolean is_visible = false;
				while (y_dist_from_camera_start <= y_dist_from_camera_end) {
					if (TILE_VISIBILITY_MAP[x_dist_from_camera_start][y_dist_from_camera_start++]) {
						is_visible = true;
						break;
					}
				}
				if (!is_visible) {
					continue;
				}
				int x_dist_from_camera_start_real = xCameraPosition - cullingCluster.worldStartX;
				if (x_dist_from_camera_start_real > 32) {
					cullingCluster.tileDistanceEnum = 1;
				} else {
					if (x_dist_from_camera_start_real >= -32) {
						continue;
					}
					cullingCluster.tileDistanceEnum = 2;
					x_dist_from_camera_start_real = -x_dist_from_camera_start_real;
				}
				cullingCluster.worldDistanceFromCameraStartY = (cullingCluster.worldStartY - yCameraPosition << 8) / x_dist_from_camera_start_real;
				cullingCluster.worldDistanceFromCameraEndY = (cullingCluster.worldEndY - yCameraPosition << 8) / x_dist_from_camera_start_real;
				cullingCluster.worldDistanceFromCameraStartZ = (cullingCluster.worldStartZ - zCameraPosition << 8) / x_dist_from_camera_start_real;
				cullingCluster.worldDistanceFromCameraEndZ = (cullingCluster.worldEndZ - zCameraPosition << 8) / x_dist_from_camera_start_real;
				processed_culling_clusters[processed_culling_clusters_ptr++] = cullingCluster;
				continue;
			}
			if (cullingCluster.searchMask == 2) {
				int i1 = cullingCluster.tileStartY - yCameraPositionTile + TILE_DRAW_DISTANCE;
				if (i1 < 0 || i1 > (TILE_DRAW_DISTANCE << 1)) {
					continue;
				}
				int l1 = cullingCluster.tileStartX - xCameraPositionTile + TILE_DRAW_DISTANCE;
				if (l1 < 0) {
					l1 = 0;
				}
				int k2 = cullingCluster.tileEndX - xCameraPositionTile + TILE_DRAW_DISTANCE;
				if (k2 > (TILE_DRAW_DISTANCE << 1)) {
					k2 = (TILE_DRAW_DISTANCE << 1);
				}
				boolean flag1 = false;
				while (l1 <= k2) {
					if (TILE_VISIBILITY_MAP[l1++][i1]) {
						flag1 = true;
						break;
					}
				}
				if (!flag1) {
					continue;
				}
				int y_dist_from_camera_start_real = yCameraPosition - cullingCluster.worldStartY;
				if (y_dist_from_camera_start_real > 32) {
					cullingCluster.tileDistanceEnum = 3;
				} else {
					if (y_dist_from_camera_start_real >= -32) {
						continue;
					}
					cullingCluster.tileDistanceEnum = 4;
					y_dist_from_camera_start_real = -y_dist_from_camera_start_real;
				}
				cullingCluster.worldDistanceFromCameraStartX = (cullingCluster.worldStartX - xCameraPosition << 8) / y_dist_from_camera_start_real;
				cullingCluster.worldDistanceFromCameraEndX = (cullingCluster.worldEndX - xCameraPosition << 8) / y_dist_from_camera_start_real;
				cullingCluster.worldDistanceFromCameraStartZ = (cullingCluster.worldStartZ - zCameraPosition << 8) / y_dist_from_camera_start_real;
				cullingCluster.worldDistanceFromCameraEndZ = (cullingCluster.worldEndZ - zCameraPosition << 8) / y_dist_from_camera_start_real;
				processed_culling_clusters[processed_culling_clusters_ptr++] = cullingCluster;
			} else if (cullingCluster.searchMask == 4) {
				int j1 = cullingCluster.worldStartZ - zCameraPosition;
				if (j1 > 128) {
					int i2 = cullingCluster.tileStartY - yCameraPositionTile + TILE_DRAW_DISTANCE;
					if (i2 < 0) {
						i2 = 0;
					}
					int l2 = cullingCluster.tileEndY - yCameraPositionTile + TILE_DRAW_DISTANCE;
					if (l2 > (TILE_DRAW_DISTANCE << 1)) {
						l2 = (TILE_DRAW_DISTANCE << 1);
					}
					if (i2 <= l2) {
						int i3 = cullingCluster.tileStartX - xCameraPositionTile + TILE_DRAW_DISTANCE;
						if (i3 < 0) {
							i3 = 0;
						}
						int l3 = cullingCluster.tileEndX - xCameraPositionTile + TILE_DRAW_DISTANCE;
						if (l3 > (TILE_DRAW_DISTANCE << 1)) {
							l3 = (TILE_DRAW_DISTANCE << 1);
						}
						boolean flag2 = false;
						label0: for (int i4 = i3; i4 <= l3; i4++) {
							for (int j4 = i2; j4 <= l2; j4++) {
								if (!TILE_VISIBILITY_MAP[i4][j4]) {
									continue;
								}
								flag2 = true;
								break label0;
							}

						}

						if (flag2) {
							cullingCluster.tileDistanceEnum = 5;
							cullingCluster.worldDistanceFromCameraStartX = (cullingCluster.worldStartX - xCameraPosition << 8) / j1;
							cullingCluster.worldDistanceFromCameraEndX = (cullingCluster.worldEndX - xCameraPosition << 8) / j1;
							cullingCluster.worldDistanceFromCameraStartY = (cullingCluster.worldStartY - yCameraPosition << 8) / j1;
							cullingCluster.worldDistanceFromCameraEndY = (cullingCluster.worldEndY - yCameraPosition << 8) / j1;
							processed_culling_clusters[processed_culling_clusters_ptr++] = cullingCluster;
						}
					}
				}
			}
		}

	}

	private boolean method320(int i, int j, int k) {
		int l = anIntArrayArrayArray445[i][j][k];
		if (l == -anInt448) {
			return false;
		}
		if (l == anInt448) {
			return true;
		}
		int i1 = j << 7;
		int j1 = k << 7;
		if (method324(i1 + 1, heightmap[i][j][k], j1 + 1) && method324(i1 + 128 - 1, heightmap[i][j + 1][k], j1 + 1) && method324(i1 + 128 - 1, heightmap[i][j + 1][k + 1], j1 + 128 - 1) && method324(i1 + 1, heightmap[i][j][k + 1], j1 + 128 - 1)) {
			anIntArrayArrayArray445[i][j][k] = anInt448;
			return true;
		} else {
			anIntArrayArrayArray445[i][j][k] = -anInt448;
			return false;
		}
	}

	private boolean method321(int i, int j, int k, int l) {
		if (!method320(i, j, k)) {
			return false;
		}
		int i1 = j << 7;
		int j1 = k << 7;
		int k1 = heightmap[i][j][k] - 1;
		int l1 = k1 - 120;
		int i2 = k1 - 230;
		int j2 = k1 - 238;
		if (l < 16) {
			if (l == 1) {
				if (i1 > xCameraPosition) {
					if (!method324(i1, k1, j1)) {
						return false;
					}
					if (!method324(i1, k1, j1 + 128)) {
						return false;
					}
				}
				if (i > 0) {
					if (!method324(i1, l1, j1)) {
						return false;
					}
					if (!method324(i1, l1, j1 + 128)) {
						return false;
					}
				}
				return method324(i1, i2, j1) && method324(i1, i2, j1 + 128);
			}
			if (l == 2) {
				if (j1 < yCameraPosition) {
					if (!method324(i1, k1, j1 + 128)) {
						return false;
					}
					if (!method324(i1 + 128, k1, j1 + 128)) {
						return false;
					}
				}
				if (i > 0) {
					if (!method324(i1, l1, j1 + 128)) {
						return false;
					}
					if (!method324(i1 + 128, l1, j1 + 128)) {
						return false;
					}
				}
				return method324(i1, i2, j1 + 128) && method324(i1 + 128, i2, j1 + 128);
			}
			if (l == 4) {
				if (i1 < xCameraPosition) {
					if (!method324(i1 + 128, k1, j1)) {
						return false;
					}
					if (!method324(i1 + 128, k1, j1 + 128)) {
						return false;
					}
				}
				if (i > 0) {
					if (!method324(i1 + 128, l1, j1)) {
						return false;
					}
					if (!method324(i1 + 128, l1, j1 + 128)) {
						return false;
					}
				}
				return method324(i1 + 128, i2, j1) && method324(i1 + 128, i2, j1 + 128);
			}
			if (l == 8) {
				if (j1 > yCameraPosition) {
					if (!method324(i1, k1, j1)) {
						return false;
					}
					if (!method324(i1 + 128, k1, j1)) {
						return false;
					}
				}
				if (i > 0) {
					if (!method324(i1, l1, j1)) {
						return false;
					}
					if (!method324(i1 + 128, l1, j1)) {
						return false;
					}
				}
				return method324(i1, i2, j1) && method324(i1 + 128, i2, j1);
			}
		}
		if (!method324(i1 + 64, j2, j1 + 64)) {
			return false;
		}
		if (l == 16) {
			return method324(i1, i2, j1 + 128);
		}
		if (l == 32) {
			return method324(i1 + 128, i2, j1 + 128);
		}
		if (l == 64) {
			return method324(i1 + 128, i2, j1);
		}
		if (l == 128) {
			return method324(i1, i2, j1);
		} else {
			System.out.println("Warning unsupported wall type");
			return true;
		}
	}

	private boolean method322(int i, int j, int k, int l) {
		if (!method320(i, j, k)) {
			return false;
		}
		int i1 = j << 7;
		int j1 = k << 7;
		return method324(i1 + 1, heightmap[i][j][k] - l, j1 + 1) && method324(i1 + 128 - 1, heightmap[i][j + 1][k] - l, j1 + 1) && method324(i1 + 128 - 1, heightmap[i][j + 1][k + 1] - l, j1 + 128 - 1) && method324(i1 + 1, heightmap[i][j][k + 1] - l, j1 + 128 - 1);
	}

	private boolean method323(int i, int j, int k, int l, int i1, int j1) {
		if (j == k && l == i1) {
			if (!method320(i, j, l)) {
				return false;
			}
			int k1 = j << 7;
			int i2 = l << 7;
			return method324(k1 + 1, heightmap[i][j][l] - j1, i2 + 1) && method324(k1 + 128 - 1, heightmap[i][j + 1][l] - j1, i2 + 1) && method324(k1 + 128 - 1, heightmap[i][j + 1][l + 1] - j1, i2 + 128 - 1) && method324(k1 + 1, heightmap[i][j][l + 1] - j1, i2 + 128 - 1);
		}
		for (int l1 = j; l1 <= k; l1++) {
			for (int j2 = l; j2 <= i1; j2++) {
				if (anIntArrayArrayArray445[i][l1][j2] == -anInt448) {
					return false;
				}
			}

		}

		int k2 = (j << 7) + 1;
		int l2 = (l << 7) + 2;
		int i3 = heightmap[i][j][l] - j1;
		if (!method324(k2, i3, l2)) {
			return false;
		}
		int j3 = (k << 7) - 1;
		if (!method324(j3, i3, l2)) {
			return false;
		}
		int k3 = (i1 << 7) - 1;
		return method324(k2, i3, k3) && method324(j3, i3, k3);
	}

	private boolean method324(int i, int j, int k) {
		for (int l = 0; l < processed_culling_clusters_ptr; l++) {
			CullingCluster cullingCluster = processed_culling_clusters[l];
			if (cullingCluster.tileDistanceEnum == 1) {
				int i1 = cullingCluster.worldStartX - i;
				if (i1 > 0) {
					int j2 = cullingCluster.worldStartY + (cullingCluster.worldDistanceFromCameraStartY * i1 >> 8);
					int k3 = cullingCluster.worldEndY + (cullingCluster.worldDistanceFromCameraEndY * i1 >> 8);
					int l4 = cullingCluster.worldStartZ + (cullingCluster.worldDistanceFromCameraStartZ * i1 >> 8);
					int i6 = cullingCluster.worldEndZ + (cullingCluster.worldDistanceFromCameraEndZ * i1 >> 8);
					if (k >= j2 && k <= k3 && j >= l4 && j <= i6) {
						return true;
					}
				}
			} else if (cullingCluster.tileDistanceEnum == 2) {
				int j1 = i - cullingCluster.worldStartX;
				if (j1 > 0) {
					int k2 = cullingCluster.worldStartY + (cullingCluster.worldDistanceFromCameraStartY * j1 >> 8);
					int l3 = cullingCluster.worldEndY + (cullingCluster.worldDistanceFromCameraEndY * j1 >> 8);
					int i5 = cullingCluster.worldStartZ + (cullingCluster.worldDistanceFromCameraStartZ * j1 >> 8);
					int j6 = cullingCluster.worldEndZ + (cullingCluster.worldDistanceFromCameraEndZ * j1 >> 8);
					if (k >= k2 && k <= l3 && j >= i5 && j <= j6) {
						return true;
					}
				}
			} else if (cullingCluster.tileDistanceEnum == 3) {
				int k1 = cullingCluster.worldStartY - k;
				if (k1 > 0) {
					int l2 = cullingCluster.worldStartX + (cullingCluster.worldDistanceFromCameraStartX * k1 >> 8);
					int i4 = cullingCluster.worldEndX + (cullingCluster.worldDistanceFromCameraEndX * k1 >> 8);
					int j5 = cullingCluster.worldStartZ + (cullingCluster.worldDistanceFromCameraStartZ * k1 >> 8);
					int k6 = cullingCluster.worldEndZ + (cullingCluster.worldDistanceFromCameraEndZ * k1 >> 8);
					if (i >= l2 && i <= i4 && j >= j5 && j <= k6) {
						return true;
					}
				}
			} else if (cullingCluster.tileDistanceEnum == 4) {
				int l1 = k - cullingCluster.worldStartY;
				if (l1 > 0) {
					int i3 = cullingCluster.worldStartX + (cullingCluster.worldDistanceFromCameraStartX * l1 >> 8);
					int j4 = cullingCluster.worldEndX + (cullingCluster.worldDistanceFromCameraEndX * l1 >> 8);
					int k5 = cullingCluster.worldStartZ + (cullingCluster.worldDistanceFromCameraStartZ * l1 >> 8);
					int l6 = cullingCluster.worldEndZ + (cullingCluster.worldDistanceFromCameraEndZ * l1 >> 8);
					if (i >= i3 && i <= j4 && j >= k5 && j <= l6) {
						return true;
					}
				}
			} else if (cullingCluster.tileDistanceEnum == 5) {
				int i2 = j - cullingCluster.worldStartZ;
				if (i2 > 0) {
					int j3 = cullingCluster.worldStartX + (cullingCluster.worldDistanceFromCameraStartX * i2 >> 8);
					int k4 = cullingCluster.worldEndX + (cullingCluster.worldDistanceFromCameraEndX * i2 >> 8);
					int l5 = cullingCluster.worldStartY + (cullingCluster.worldDistanceFromCameraStartY * i2 >> 8);
					int i7 = cullingCluster.worldEndY + (cullingCluster.worldDistanceFromCameraEndY * i2 >> 8);
					if (i >= j3 && i <= k4 && k >= l5 && k <= i7) {
						return true;
					}
				}
			}
		}

		return false;
	}
}