public class Scene { public static int sin2048Cache[] = new int[2048]; static int frustumMaxX; static int frustumMinX; static int furstumMaxY; static int furstumMinY; static int furstumFarZ; static int frustumNearZ; private static int sin512Cache[] = new int[512]; private static long textureCountLoaded; private static byte aByteArray434[]; //private static int anIntArray435[] = new int[256]; public int lastVisiblePolygonsCount; public int clipNear; public int clipFar3d; public int clipFar2d; public int fogZFalloff; public int fogZDistance; public boolean wideBand; public double aDouble387; public int anInt388; public int modelCount; public int maxModelCount; public GameModel models[]; public GameModel view; public int raster[]; int rampCount; int gradientBase[]; int gradientRamps[][]; int anIntArray377[]; int textureCount; byte textureColoursUsed[][]; int textureColourList[][]; int textureDimension[]; long textureLoadedNumber[]; int texturePixels[][]; boolean textureBackTransparent[]; int textureColours64[][]; int textureColours128[][]; Surface surface; Scanline scanlines[]; int minY; int maxY; int planeX[]; int planeY[]; int vertexShade[]; int vertexX[]; int vertexY[]; int vertexZ[]; boolean interlace; int newStart; int newEnd; private boolean mousePickingActive; private int mouseX; private int mouseY; private int mousePickedCount; private int mousePickedMax; private GameModel mousePickedModels[]; private int mousePickedFaces[]; private int width; private int clipX; private int clipY; private int baseX; private int baseY; private int viewDistance; private int normalMagnitude; private int cameraX; private int cameraY; private int cameraZ; private int cameraYaw; private int cameraPitch; private int cameraRoll; // private int modelState[]; // only set not used private int visiblePolygonsCount; private Polygon visiblePolygons[]; private int spriteCount; private int spriteId[]; private int spriteX[]; private int spriteZ[]; private int spriteY[]; private int spriteWidth[]; private int spriteHeight[]; private int spriteTranslateX[]; public Scene(Surface surface, int i, int polygons, int k) { rampCount = 50; gradientBase = new int[rampCount]; gradientRamps = new int[rampCount][256]; clipNear = 5; clipFar3d = 1000; clipFar2d = 1000; fogZFalloff = 20; fogZDistance = 10; wideBand = false; aDouble387 = 1.1000000000000001D; anInt388 = 1; mousePickingActive = false; mousePickedMax = 100; mousePickedModels = new GameModel[mousePickedMax]; mousePickedFaces = new int[mousePickedMax]; width = surface.width1; clipX = 256; clipY = 192; baseX = 256; baseY = 256; viewDistance = 8; normalMagnitude = 4; planeX = new int[40]; planeY = new int[40]; vertexShade = new int[40]; vertexX = new int[40]; vertexY = new int[40]; vertexZ = new int[40]; interlace = false; this.surface = surface; clipX = surface.width2 / 2; clipY = surface.height2 / 2; raster = surface.pixels; modelCount = 0; maxModelCount = i; models = new GameModel[maxModelCount]; // modelState = new int[maxModelCount]; // only set not used visiblePolygonsCount = 0; visiblePolygons = new Polygon[polygons]; for (int l = 0; l < polygons; l++) visiblePolygons[l] = new Polygon(); spriteCount = 0; view = new GameModel(k * 2, k); spriteId = new int[k]; spriteWidth = new int[k]; spriteHeight = new int[k]; spriteX = new int[k]; spriteZ = new int[k]; spriteY = new int[k]; spriteTranslateX = new int[k]; if (aByteArray434 == null) aByteArray434 = new byte[17691]; cameraX = 0; cameraY = 0; cameraZ = 0; cameraYaw = 0; cameraPitch = 0; cameraRoll = 0; for (int i1 = 0; i1 < 256; i1++) { sin512Cache[i1] = (int) (Math.sin((double) i1 * 0.02454369D) * 32768D); sin512Cache[i1 + 256] = (int) (Math.cos((double) i1 * 0.02454369D) * 32768D); } for (int j1 = 0; j1 < 1024; j1++) { sin2048Cache[j1] = (int) (Math.sin((double) j1 * 0.00613592315D) * 32768D); sin2048Cache[j1 + 1024] = (int) (Math.cos((double) j1 * 0.00613592315D) * 32768D); } } private static void textureScanline(int ai[], int ai1[], int i, int j, int k, int l, int i1, int j1, int k1, int l1, int i2, int j2, int k2, int l2) { if (i2 <= 0) return; int i3 = 0; int j3 = 0; int i4 = 0; if (i1 != 0) { i = k / i1 << 7; j = l / i1 << 7; } if (i < 0) i = 0; else if (i > 16256) i = 16256; k += j1; l += k1; i1 += l1; if (i1 != 0) { i3 = k / i1 << 7; j3 = l / i1 << 7; } if (i3 < 0) i3 = 0; else if (i3 > 16256) i3 = 16256; int k3 = i3 - i >> 4; int l3 = j3 - j >> 4; for (int j4 = i2 >> 4; j4 > 0; j4--) { i += k2 & 0x600000; i4 = k2 >> 23; k2 += l2; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; i = (i & 0x3fff) + (k2 & 0x600000); i4 = k2 >> 23; k2 += l2; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; i = (i & 0x3fff) + (k2 & 0x600000); i4 = k2 >> 23; k2 += l2; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; i = (i & 0x3fff) + (k2 & 0x600000); i4 = k2 >> 23; k2 += l2; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i = i3; j = j3; k += j1; l += k1; i1 += l1; if (i1 != 0) { i3 = k / i1 << 7; j3 = l / i1 << 7; } if (i3 < 0) i3 = 0; else if (i3 > 16256) i3 = 16256; k3 = i3 - i >> 4; l3 = j3 - j >> 4; } for (int k4 = 0; k4 < (i2 & 0xf); k4++) { if ((k4 & 3) == 0) { i = (i & 0x3fff) + (k2 & 0x600000); i4 = k2 >> 23; k2 += l2; } ai[j2++] = ai1[(j & 0x3f80) + (i >> 7)] >>> i4; i += k3; j += l3; } } private static void textureTranslucentScanline(int ai[], int ai1[], int i, int j, int k, int l, int i1, int j1, int k1, int l1, int i2, int j2, int k2, int l2) { if (i2 <= 0) return; int i3 = 0; int j3 = 0; int i4 = 0; if (i1 != 0) { i = k / i1 << 7; j = l / i1 << 7; } if (i < 0) i = 0; else if (i > 16256) i = 16256; k += j1; l += k1; i1 += l1; if (i1 != 0) { i3 = k / i1 << 7; j3 = l / i1 << 7; } if (i3 < 0) i3 = 0; else if (i3 > 16256) i3 = 16256; int k3 = i3 - i >> 4; int l3 = j3 - j >> 4; for (int j4 = i2 >> 4; j4 > 0; j4--) { i += k2 & 0x600000; i4 = k2 >> 23; k2 += l2; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; i = (i & 0x3fff) + (k2 & 0x600000); i4 = k2 >> 23; k2 += l2; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; i = (i & 0x3fff) + (k2 & 0x600000); i4 = k2 >> 23; k2 += l2; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; i = (i & 0x3fff) + (k2 & 0x600000); i4 = k2 >> 23; k2 += l2; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i = i3; j = j3; k += j1; l += k1; i1 += l1; if (i1 != 0) { i3 = k / i1 << 7; j3 = l / i1 << 7; } if (i3 < 0) i3 = 0; else if (i3 > 16256) i3 = 16256; k3 = i3 - i >> 4; l3 = j3 - j >> 4; } for (int k4 = 0; k4 < (i2 & 0xf); k4++) { if ((k4 & 3) == 0) { i = (i & 0x3fff) + (k2 & 0x600000); i4 = k2 >> 23; k2 += l2; } ai[j2++] = (ai1[(j & 0x3f80) + (i >> 7)] >>> i4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; } } private static void textureBackTranslucentScanline(int ai[], int i, int j, int k, int ai1[], int l, int i1, int j1, int k1, int l1, int i2, int j2, int k2, int l2, int i3) { if (j2 <= 0) return; int j3 = 0; int k3 = 0; i3 <<= 2; if (j1 != 0) { j3 = l / j1 << 7; k3 = i1 / j1 << 7; } if (j3 < 0) j3 = 0; else if (j3 > 16256) j3 = 16256; for (int j4 = j2; j4 > 0; j4 -= 16) { l += k1; i1 += l1; j1 += i2; j = j3; k = k3; if (j1 != 0) { j3 = l / j1 << 7; k3 = i1 / j1 << 7; } if (j3 < 0) j3 = 0; else if (j3 > 16256) j3 = 16256; int l3 = j3 - j >> 4; int i4 = k3 - k >> 4; int k4 = l2 >> 23; j += l2 & 0x600000; l2 += i3; if (j4 < 16) { for (int l4 = 0; l4 < j4; l4++) { if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((l4 & 3) == 3) { j = (j & 0x3fff) + (l2 & 0x600000); k4 = l2 >> 23; l2 += i3; } } } else { if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; j = (j & 0x3fff) + (l2 & 0x600000); k4 = l2 >> 23; l2 += i3; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; j = (j & 0x3fff) + (l2 & 0x600000); k4 = l2 >> 23; l2 += i3; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; j = (j & 0x3fff) + (l2 & 0x600000); k4 = l2 >> 23; l2 += i3; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0x3f80) + (j >> 7)] >>> k4) != 0) ai[k2] = i; k2++; } } } private static void textureScanline2(int ai[], int ai1[], int i, int j, int k, int l, int i1, int j1, int k1, int l1, int i2, int j2, int k2, int l2) { if (i2 <= 0) return; int i3 = 0; int j3 = 0; l2 <<= 2; if (i1 != 0) { i3 = k / i1 << 6; j3 = l / i1 << 6; } if (i3 < 0) i3 = 0; else if (i3 > 4032) i3 = 4032; for (int i4 = i2; i4 > 0; i4 -= 16) { k += j1; l += k1; i1 += l1; i = i3; j = j3; if (i1 != 0) { i3 = k / i1 << 6; j3 = l / i1 << 6; } if (i3 < 0) i3 = 0; else if (i3 > 4032) i3 = 4032; int k3 = i3 - i >> 4; int l3 = j3 - j >> 4; int j4 = k2 >> 20; i += k2 & 0xc0000; k2 += l2; if (i4 < 16) { for (int k4 = 0; k4 < i4; k4++) { ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; if ((k4 & 3) == 3) { i = (i & 0xfff) + (k2 & 0xc0000); j4 = k2 >> 20; k2 += l2; } } } else { ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; i = (i & 0xfff) + (k2 & 0xc0000); j4 = k2 >> 20; k2 += l2; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; i = (i & 0xfff) + (k2 & 0xc0000); j4 = k2 >> 20; k2 += l2; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; i = (i & 0xfff) + (k2 & 0xc0000); j4 = k2 >> 20; k2 += l2; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; i += k3; j += l3; ai[j2++] = ai1[(j & 0xfc0) + (i >> 6)] >>> j4; } } } private static void textureTranslucentScanline2(int ai[], int ai1[], int i, int j, int k, int l, int i1, int j1, int k1, int l1, int i2, int j2, int k2, int l2) { if (i2 <= 0) return; int i3 = 0; int j3 = 0; l2 <<= 2; if (i1 != 0) { i3 = k / i1 << 6; j3 = l / i1 << 6; } if (i3 < 0) i3 = 0; else if (i3 > 4032) i3 = 4032; for (int i4 = i2; i4 > 0; i4 -= 16) { k += j1; l += k1; i1 += l1; i = i3; j = j3; if (i1 != 0) { i3 = k / i1 << 6; j3 = l / i1 << 6; } if (i3 < 0) i3 = 0; else if (i3 > 4032) i3 = 4032; int k3 = i3 - i >> 4; int l3 = j3 - j >> 4; int j4 = k2 >> 20; i += k2 & 0xc0000; k2 += l2; if (i4 < 16) { for (int k4 = 0; k4 < i4; k4++) { ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; if ((k4 & 3) == 3) { i = (i & 0xfff) + (k2 & 0xc0000); j4 = k2 >> 20; k2 += l2; } } } else { ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; i = (i & 0xfff) + (k2 & 0xc0000); j4 = k2 >> 20; k2 += l2; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; i = (i & 0xfff) + (k2 & 0xc0000); j4 = k2 >> 20; k2 += l2; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; i = (i & 0xfff) + (k2 & 0xc0000); j4 = k2 >> 20; k2 += l2; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); i += k3; j += l3; ai[j2++] = (ai1[(j & 0xfc0) + (i >> 6)] >>> j4) + (ai[j2] >> 1 & 0x7f7f7f); } } } private static void textureBackTranslucentScanline2(int ai[], int i, int j, int k, int ai1[], int l, int i1, int j1, int k1, int l1, int i2, int j2, int k2, int l2, int i3) { if (j2 <= 0) return; int j3 = 0; int k3 = 0; i3 <<= 2; if (j1 != 0) { j3 = l / j1 << 6; k3 = i1 / j1 << 6; } if (j3 < 0) j3 = 0; else if (j3 > 4032) j3 = 4032; for (int j4 = j2; j4 > 0; j4 -= 16) { l += k1; i1 += l1; j1 += i2; j = j3; k = k3; if (j1 != 0) { j3 = l / j1 << 6; k3 = i1 / j1 << 6; } if (j3 < 0) j3 = 0; else if (j3 > 4032) j3 = 4032; int l3 = j3 - j >> 4; int i4 = k3 - k >> 4; int k4 = l2 >> 20; j += l2 & 0xc0000; l2 += i3; if (j4 < 16) { for (int l4 = 0; l4 < j4; l4++) { if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((l4 & 3) == 3) { j = (j & 0xfff) + (l2 & 0xc0000); k4 = l2 >> 20; l2 += i3; } } } else { if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; j = (j & 0xfff) + (l2 & 0xc0000); k4 = l2 >> 20; l2 += i3; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; j = (j & 0xfff) + (l2 & 0xc0000); k4 = l2 >> 20; l2 += i3; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; j = (j & 0xfff) + (l2 & 0xc0000); k4 = l2 >> 20; l2 += i3; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; j += l3; k += i4; if ((i = ai1[(k & 0xfc0) + (j >> 6)] >>> k4) != 0) ai[k2] = i; k2++; } } } private static void gradientScanline(int ai[], int i, int j, int k, int ai1[], int l, int i1) { if (i >= 0) return; i1 <<= 1; k = ai1[l >> 8 & 0xff]; l += i1; int j1 = i / 8; for (int k1 = j1; k1 < 0; k1++) { ai[j++] = k; ai[j++] = k; k = ai1[l >> 8 & 0xff]; l += i1; ai[j++] = k; ai[j++] = k; k = ai1[l >> 8 & 0xff]; l += i1; ai[j++] = k; ai[j++] = k; k = ai1[l >> 8 & 0xff]; l += i1; ai[j++] = k; ai[j++] = k; k = ai1[l >> 8 & 0xff]; l += i1; } j1 = -(i % 8); for (int l1 = 0; l1 < j1; l1++) { ai[j++] = k; if ((l1 & 1) == 1) { k = ai1[l >> 8 & 0xff]; l += i1; } } } private static void textureGradientScanline(int ai[], int i, int j, int k, int ai1[], int l, int i1) { if (i >= 0) return; i1 <<= 2; k = ai1[l >> 8 & 0xff]; l += i1; int j1 = i / 16; for (int k1 = j1; k1 < 0; k1++) { ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); k = ai1[l >> 8 & 0xff]; l += i1; ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); k = ai1[l >> 8 & 0xff]; l += i1; ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); k = ai1[l >> 8 & 0xff]; l += i1; ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); k = ai1[l >> 8 & 0xff]; l += i1; } j1 = -(i % 16); for (int l1 = 0; l1 < j1; l1++) { ai[j++] = k + (ai[j] >> 1 & 0x7f7f7f); if ((l1 & 3) == 3) { k = ai1[l >> 8 & 0xff]; l += i1; l += i1; } } } private static void gradientScanline2(int ai[], int i, int j, int k, int ai1[], int l, int i1) { if (i >= 0) return; i1 <<= 2; k = ai1[l >> 8 & 0xff]; l += i1; int j1 = i / 16; for (int k1 = j1; k1 < 0; k1++) { ai[j++] = k; ai[j++] = k; ai[j++] = k; ai[j++] = k; k = ai1[l >> 8 & 0xff]; l += i1; ai[j++] = k; ai[j++] = k; ai[j++] = k; ai[j++] = k; k = ai1[l >> 8 & 0xff]; l += i1; ai[j++] = k; ai[j++] = k; ai[j++] = k; ai[j++] = k; k = ai1[l >> 8 & 0xff]; l += i1; ai[j++] = k; ai[j++] = k; ai[j++] = k; ai[j++] = k; k = ai1[l >> 8 & 0xff]; l += i1; } j1 = -(i % 16); for (int l1 = 0; l1 < j1; l1++) { ai[j++] = k; if ((l1 & 3) == 3) { k = ai1[l >> 8 & 0xff]; l += i1; } } } public static int rgb(int i, int j, int k) { return -1 - (i / 8) * 1024 - (j / 8) * 32 - k / 8; } public void addModel(GameModel model) { if (model == null) System.out.println("Warning tried to add null object!"); if (modelCount < maxModelCount) { //modelState[modelCount] = 0; // only set, not used models[modelCount++] = model; } } public void removeModel(GameModel gameModel) { for (int i = 0; i < modelCount; i++) if (models[i] == gameModel) { modelCount--; for (int j = i; j < modelCount; j++) { models[j] = models[j + 1]; //modelState[j] = modelState[j + 1]; // only set, not used } } } public void dispose() { clear(); for (int i = 0; i < modelCount; i++) models[i] = null; modelCount = 0; } public void clear() { spriteCount = 0; view.clear(); } public void reduceSprites(int i) { spriteCount -= i; view.reduce(i, i * 2); if (spriteCount < 0) spriteCount = 0; } public int addSprite(int n, int x, int z, int y, int w, int h, int tag) { spriteId[spriteCount] = n; spriteX[spriteCount] = x; spriteZ[spriteCount] = z; spriteY[spriteCount] = y; spriteWidth[spriteCount] = w; spriteHeight[spriteCount] = h; spriteTranslateX[spriteCount] = 0; int l1 = view.createVertex(x, z, y); int i2 = view.createVertex(x, z - h, y); int vs[] = { l1, i2 }; view.createFace(2, vs, 0, 0); view.faceTag[spriteCount] = tag; view.isLocalPlayer[spriteCount++] = 0; return spriteCount - 1; } public void setLocalPlayer(int i) { view.isLocalPlayer[i] = 1; } public void setSpriteTranslateX(int i, int n) { spriteTranslateX[i] = n; } public void setMouseLoc(int x, int y) { mouseX = x - baseX; mouseY = y; mousePickedCount = 0; mousePickingActive = true; } public int getMousePickedCount() { return mousePickedCount; } public int[] getMousePickedFaces() { return mousePickedFaces; } public GameModel[] getMousePickedModels() { return mousePickedModels; } public void setBounds(int baseX, int baseY, int clipX, int clipY, int width, int viewDistance) { this.clipX = clipX; this.clipY = clipY; this.baseX = baseX; this.baseY = baseY; this.width = width; this.viewDistance = viewDistance; scanlines = new Scanline[clipY + baseY]; for (int k1 = 0; k1 < clipY + baseY; k1++) scanlines[k1] = new Scanline(); } private void polygonsQSort(Polygon polygons[], int low, int high) { if (low < high) { int min = low - 1; int max = high + 1; int mid = (low + high) / 2; Polygon polygon = polygons[mid]; polygons[mid] = polygons[low]; polygons[low] = polygon; int j1 = polygon.depth; while (min < max) { do max--; while (polygons[max].depth < j1); do min++; while (polygons[min].depth > j1); if (min < max) { Polygon polygon_1 = polygons[min]; polygons[min] = polygons[max]; polygons[max] = polygon_1; } } polygonsQSort(polygons, low, max); polygonsQSort(polygons, max + 1, high); } } public void polygonsIntersectSort(int step, Polygon polygons[], int count) { for (int i = 0; i <= count; i++) { polygons[i].skipSomething = false; polygons[i].index = i; polygons[i].index2 = -1; } int l = 0; do { while (polygons[l].skipSomething) l++; if (l == count) return; Polygon polygon = polygons[l]; polygon.skipSomething = true; int i1 = l; int j1 = l + step; if (j1 >= count) j1 = count - 1; for (int k1 = j1; k1 >= i1 + 1; k1--) { Polygon other = polygons[k1]; if (polygon.minPlaneX < other.maxPlaneX && other.minPlaneX < polygon.maxPlaneX && polygon.minPlaneY < other.maxPlaneY && other.minPlaneY < polygon.maxPlaneY && polygon.index != other.index2 && !separatePolygon(polygon, other) && heuristicPolygon(other, polygon)) { polygonsOrder(polygons, i1, k1); if (polygons[k1] != other) k1++; i1 = newStart; other.index2 = polygon.index; } } } while (true); } public boolean polygonsOrder(Polygon polygons[], int start, int end) { do { Polygon polygon = polygons[start]; for (int k = start + 1; k <= end; k++) { Polygon polygon_1 = polygons[k]; if (!separatePolygon(polygon_1, polygon)) break; polygons[start] = polygon_1; polygons[k] = polygon; start = k; if (start == end) { newStart = start; newEnd = start - 1; return true; } } Polygon polygon_2 = polygons[end]; for (int l = end - 1; l >= start; l--) { Polygon polygon_3 = polygons[l]; if (!separatePolygon(polygon_2, polygon_3)) break; polygons[end] = polygon_3; polygons[l] = polygon_2; end = l; if (start == end) { newStart = end + 1; newEnd = end; return true; } } if (start + 1 >= end) { newStart = start; newEnd = end; return false; } if (!polygonsOrder(polygons, start + 1, end)) { newStart = start; return false; } end = newEnd; } while (true); } public void setFrustum(int i, int j, int k) { int l = -cameraYaw + 1024 & 0x3ff; int i1 = -cameraPitch + 1024 & 0x3ff; int j1 = -cameraRoll + 1024 & 0x3ff; if (j1 != 0) { int k1 = sin2048Cache[j1]; int j2 = sin2048Cache[j1 + 1024]; int i3 = j * k1 + i * j2 >> 15; j = j * j2 - i * k1 >> 15; i = i3; } if (l != 0) { int l1 = sin2048Cache[l]; int k2 = sin2048Cache[l + 1024]; int j3 = j * k2 - k * l1 >> 15; k = j * l1 + k * k2 >> 15; j = j3; } if (i1 != 0) { int i2 = sin2048Cache[i1]; int l2 = sin2048Cache[i1 + 1024]; int k3 = k * i2 + i * l2 >> 15; k = k * l2 - i * i2 >> 15; i = k3; } if (i < frustumMaxX) frustumMaxX = i; if (i > frustumMinX) frustumMinX = i; if (j < furstumMaxY) furstumMaxY = j; if (j > furstumMinY) furstumMinY = j; if (k < furstumFarZ) furstumFarZ = k; if (k > frustumNearZ) frustumNearZ = k; } public void render() { interlace = surface.interlace; int i3 = clipX * clipFar3d >> viewDistance; int j3 = clipY * clipFar3d >> viewDistance; frustumMaxX = 0; frustumMinX = 0; furstumMaxY = 0; furstumMinY = 0; furstumFarZ = 0; frustumNearZ = 0; setFrustum(-i3, -j3, clipFar3d); setFrustum(-i3, j3, clipFar3d); setFrustum(i3, -j3, clipFar3d); setFrustum(i3, j3, clipFar3d); setFrustum(-clipX, -clipY, 0); setFrustum(-clipX, clipY, 0); setFrustum(clipX, -clipY, 0); setFrustum(clipX, clipY, 0); frustumMaxX += cameraX; frustumMinX += cameraX; furstumMaxY += cameraY; furstumMinY += cameraY; furstumFarZ += cameraZ; frustumNearZ += cameraZ; models[modelCount] = view; view.transformState = 2; for (int i = 0; i < modelCount; i++) models[i].project(cameraX, cameraY, cameraZ, cameraYaw, cameraPitch, cameraRoll, viewDistance, clipNear); models[modelCount].project(cameraX, cameraY, cameraZ, cameraYaw, cameraPitch, cameraRoll, viewDistance, clipNear); visiblePolygonsCount = 0; for (int count = 0; count < modelCount; count++) { GameModel gameModel = models[count]; if (gameModel.visible) { for (int face = 0; face < gameModel.numFaces; face++) { int num_vertices = gameModel.faceNumVertices[face]; int vertices[] = gameModel.faceVertices[face]; boolean visible = false; for (int vertex = 0; vertex < num_vertices; vertex++) { int z = gameModel.projectVertexZ[vertices[vertex]]; if (z <= clipNear || z >= clipFar3d) continue; visible = true; break; } if (visible) { int viewxcount = 0; for (int vertex = 0; vertex < num_vertices; vertex++) { int x = gameModel.vertexViewX[vertices[vertex]]; if (x > -clipX) viewxcount |= 1; if (x < clipX) viewxcount |= 2; if (viewxcount == 3) break; } if (viewxcount == 3) { int viewycount = 0; for (int vertex = 0; vertex < num_vertices; vertex++) { int k1 = gameModel.vertexViewY[vertices[vertex]]; if (k1 > -clipY) viewycount |= 1; if (k1 < clipY) viewycount |= 2; if (viewycount == 3) break; } if (viewycount == 3) { Polygon polygon_1 = visiblePolygons[visiblePolygonsCount]; polygon_1.model = gameModel; polygon_1.face = face; initialisePolygon3d(visiblePolygonsCount); int facefill; if (polygon_1.visibility < 0) facefill = gameModel.faceFillFront[face]; else facefill = gameModel.faceFillBack[face]; if (facefill != World.colourTransparent) { // 12345678 = invisible ? int h = 0; for (int vertex = 0; vertex < num_vertices; vertex++) h += gameModel.projectVertexZ[vertices[vertex]]; polygon_1.depth = h / num_vertices + gameModel.depth; polygon_1.facefill = facefill; visiblePolygonsCount++; } } } } } } } GameModel model_2d = view; if (model_2d.visible) { for (int face = 0; face < model_2d.numFaces; face++) { int faceVertices[] = model_2d.faceVertices[face]; int vertex0 = faceVertices[0]; int vx = model_2d.vertexViewX[vertex0]; int vy = model_2d.vertexViewY[vertex0]; int vz = model_2d.projectVertexZ[vertex0]; if (vz > clipNear && vz < clipFar2d) { int vw = (spriteWidth[face] << viewDistance) / vz; int vh = (spriteHeight[face] << viewDistance) / vz; if (vx - vw / 2 <= clipX && vx + vw / 2 >= -clipX && vy - vh <= clipY && vy >= -clipY) { Polygon polygon_2 = visiblePolygons[visiblePolygonsCount]; polygon_2.model = model_2d; polygon_2.face = face; initialisePolygon2d(visiblePolygonsCount); polygon_2.depth = (vz + model_2d.projectVertexZ[faceVertices[1]]) / 2; visiblePolygonsCount++; } } } } if (visiblePolygonsCount == 0) return; lastVisiblePolygonsCount = visiblePolygonsCount; polygonsQSort(visiblePolygons, 0, visiblePolygonsCount - 1); polygonsIntersectSort(100, visiblePolygons, visiblePolygonsCount); for (int model = 0; model < visiblePolygonsCount; model++) { Polygon polygon = visiblePolygons[model]; GameModel gameModel_2 = polygon.model; int l = polygon.face; if (gameModel_2 == view) { int faceverts[] = gameModel_2.faceVertices[l]; int face_0 = faceverts[0]; int vx = gameModel_2.vertexViewX[face_0]; int vy = gameModel_2.vertexViewY[face_0]; int vz = gameModel_2.projectVertexZ[face_0]; int w = (spriteWidth[l] << viewDistance) / vz; int h = (spriteHeight[l] << viewDistance) / vz; //int i11 = vy - gameModel_2.vertexViewY[faceverts[1]]; // not used //int tx = ((gameModel_2.vertexViewX[faceverts[1]] - vx) * i11) / h; // redundant int tx = gameModel_2.vertexViewX[faceverts[1]] - vx; int x = vx - w / 2; int y = (baseY + vy) - h; surface.spriteClipping(x + baseX, y, w, h, spriteId[l], tx, (256 << viewDistance) / vz); if (mousePickingActive && mousePickedCount < mousePickedMax) { x += (spriteTranslateX[l] << viewDistance) / vz; if (mouseY >= y && mouseY <= y + h && mouseX >= x && mouseX <= x + w && !gameModel_2.unpickable && gameModel_2.isLocalPlayer[l] == 0) { mousePickedModels[mousePickedCount] = gameModel_2; mousePickedFaces[mousePickedCount] = l; mousePickedCount++; } } } else { int k8 = 0; int j10 = 0; int l10 = gameModel_2.faceNumVertices[l]; int ai3[] = gameModel_2.faceVertices[l]; if (gameModel_2.faceIntensity[l] != World.colourTransparent) if (polygon.visibility < 0) j10 = gameModel_2.lightAmbience - gameModel_2.faceIntensity[l]; else j10 = gameModel_2.lightAmbience + gameModel_2.faceIntensity[l]; for (int k11 = 0; k11 < l10; k11++) { int k2 = ai3[k11]; vertexX[k11] = gameModel_2.projectVertexX[k2]; vertexY[k11] = gameModel_2.projectVertexY[k2]; vertexZ[k11] = gameModel_2.projectVertexZ[k2]; if (gameModel_2.faceIntensity[l] == World.colourTransparent) if (polygon.visibility < 0) j10 = (gameModel_2.lightAmbience - gameModel_2.vertexIntensity[k2]) + gameModel_2.vertexAmbience[k2]; else j10 = gameModel_2.lightAmbience + gameModel_2.vertexIntensity[k2] + gameModel_2.vertexAmbience[k2]; if (gameModel_2.projectVertexZ[k2] >= clipNear) { planeX[k8] = gameModel_2.vertexViewX[k2]; planeY[k8] = gameModel_2.vertexViewY[k2]; vertexShade[k8] = j10; if (gameModel_2.projectVertexZ[k2] > fogZDistance) vertexShade[k8] += (gameModel_2.projectVertexZ[k2] - fogZDistance) / fogZFalloff; k8++; } else { int k9; if (k11 == 0) k9 = ai3[l10 - 1]; else k9 = ai3[k11 - 1]; if (gameModel_2.projectVertexZ[k9] >= clipNear) { int k7 = gameModel_2.projectVertexZ[k2] - gameModel_2.projectVertexZ[k9]; int i5 = gameModel_2.projectVertexX[k2] - ((gameModel_2.projectVertexX[k2] - gameModel_2.projectVertexX[k9]) * (gameModel_2.projectVertexZ[k2] - clipNear)) / k7; int j6 = gameModel_2.projectVertexY[k2] - ((gameModel_2.projectVertexY[k2] - gameModel_2.projectVertexY[k9]) * (gameModel_2.projectVertexZ[k2] - clipNear)) / k7; planeX[k8] = (i5 << viewDistance) / clipNear; planeY[k8] = (j6 << viewDistance) / clipNear; vertexShade[k8] = j10; k8++; } if (k11 == l10 - 1) k9 = ai3[0]; else k9 = ai3[k11 + 1]; if (gameModel_2.projectVertexZ[k9] >= clipNear) { int l7 = gameModel_2.projectVertexZ[k2] - gameModel_2.projectVertexZ[k9]; int j5 = gameModel_2.projectVertexX[k2] - ((gameModel_2.projectVertexX[k2] - gameModel_2.projectVertexX[k9]) * (gameModel_2.projectVertexZ[k2] - clipNear)) / l7; int k6 = gameModel_2.projectVertexY[k2] - ((gameModel_2.projectVertexY[k2] - gameModel_2.projectVertexY[k9]) * (gameModel_2.projectVertexZ[k2] - clipNear)) / l7; planeX[k8] = (j5 << viewDistance) / clipNear; planeY[k8] = (k6 << viewDistance) / clipNear; vertexShade[k8] = j10; k8++; } } } for (int i12 = 0; i12 < l10; i12++) { if (vertexShade[i12] < 0) vertexShade[i12] = 0; else if (vertexShade[i12] > 255) vertexShade[i12] = 255; if (polygon.facefill >= 0) if (textureDimension[polygon.facefill] == 1) vertexShade[i12] <<= 9; else vertexShade[i12] <<= 6; } generateScanlines(0, 0, 0, 0, k8, planeX, planeY, vertexShade, gameModel_2, l); if (maxY > minY) rasterize(0, 0, l10, vertexX, vertexY, vertexZ, polygon.facefill, gameModel_2); } } mousePickingActive = false; } private void generateScanlines(int i, int j, int k, int l, int i1, int ai[], int ai1[], int ai2[], GameModel gameModel, int pid) { if (i1 == 3) { int k1 = ai1[0] + baseY; int k2 = ai1[1] + baseY; int k3 = ai1[2] + baseY; int k4 = ai[0]; int l5 = ai[1]; int j7 = ai[2]; int l8 = ai2[0]; int j10 = ai2[1]; int j11 = ai2[2]; int j12 = (baseY + clipY) - 1; int l12 = 0; int j13 = 0; int l13 = 0; int j14 = 0; int l14 = World.colourTransparent; int j15 = 0xff439eb2; if (k3 != k1) { j13 = (j7 - k4 << 8) / (k3 - k1); j14 = (j11 - l8 << 8) / (k3 - k1); if (k1 < k3) { l12 = k4 << 8; l13 = l8 << 8; l14 = k1; j15 = k3; } else { l12 = j7 << 8; l13 = j11 << 8; l14 = k3; j15 = k1; } if (l14 < 0) { l12 -= j13 * l14; l13 -= j14 * l14; l14 = 0; } if (j15 > j12) j15 = j12; } int l15 = 0; int j16 = 0; int l16 = 0; int j17 = 0; int l17 = World.colourTransparent; int j18 = 0xff439eb2; if (k2 != k1) { j16 = (l5 - k4 << 8) / (k2 - k1); j17 = (j10 - l8 << 8) / (k2 - k1); if (k1 < k2) { l15 = k4 << 8; l16 = l8 << 8; l17 = k1; j18 = k2; } else { l15 = l5 << 8; l16 = j10 << 8; l17 = k2; j18 = k1; } if (l17 < 0) { l15 -= j16 * l17; l16 -= j17 * l17; l17 = 0; } if (j18 > j12) j18 = j12; } int l18 = 0; int j19 = 0; int l19 = 0; int j20 = 0; int l20 = World.colourTransparent; int j21 = 0xff439eb2; if (k3 != k2) { j19 = (j7 - l5 << 8) / (k3 - k2); j20 = (j11 - j10 << 8) / (k3 - k2); if (k2 < k3) { l18 = l5 << 8; l19 = j10 << 8; l20 = k2; j21 = k3; } else { l18 = j7 << 8; l19 = j11 << 8; l20 = k3; j21 = k2; } if (l20 < 0) { l18 -= j19 * l20; l19 -= j20 * l20; l20 = 0; } if (j21 > j12) j21 = j12; } minY = l14; if (l17 < minY) minY = l17; if (l20 < minY) minY = l20; maxY = j15; if (j18 > maxY) maxY = j18; if (j21 > maxY) maxY = j21; int l21 = 0; for (k = minY; k < maxY; k++) { if (k >= l14 && k < j15) { i = j = l12; l = l21 = l13; l12 += j13; l13 += j14; } else { i = 0xa0000; j = 0xfff60000; } if (k >= l17 && k < j18) { if (l15 < i) { i = l15; l = l16; } if (l15 > j) { j = l15; l21 = l16; } l15 += j16; l16 += j17; } if (k >= l20 && k < j21) { if (l18 < i) { i = l18; l = l19; } if (l18 > j) { j = l18; l21 = l19; } l18 += j19; l19 += j20; } Scanline scanline_6 = scanlines[k]; scanline_6.startX = i; scanline_6.endX = j; scanline_6.startS = l; scanline_6.endS = l21; } if (minY < baseY - clipY) minY = baseY - clipY; } else if (i1 == 4) { int l1 = ai1[0] + baseY; int l2 = ai1[1] + baseY; int l3 = ai1[2] + baseY; int l4 = ai1[3] + baseY; int i6 = ai[0]; int k7 = ai[1]; int i9 = ai[2]; int k10 = ai[3]; int k11 = ai2[0]; int k12 = ai2[1]; int i13 = ai2[2]; int k13 = ai2[3]; int i14 = (baseY + clipY) - 1; int k14 = 0; int i15 = 0; int k15 = 0; int i16 = 0; int k16 = World.colourTransparent; int i17 = 0xff439eb2; if (l4 != l1) { i15 = (k10 - i6 << 8) / (l4 - l1); i16 = (k13 - k11 << 8) / (l4 - l1); if (l1 < l4) { k14 = i6 << 8; k15 = k11 << 8; k16 = l1; i17 = l4; } else { k14 = k10 << 8; k15 = k13 << 8; k16 = l4; i17 = l1; } if (k16 < 0) { k14 -= i15 * k16; k15 -= i16 * k16; k16 = 0; } if (i17 > i14) i17 = i14; } int k17 = 0; int i18 = 0; int k18 = 0; int i19 = 0; int k19 = World.colourTransparent; int i20 = 0xff439eb2; if (l2 != l1) { i18 = (k7 - i6 << 8) / (l2 - l1); i19 = (k12 - k11 << 8) / (l2 - l1); if (l1 < l2) { k17 = i6 << 8; k18 = k11 << 8; k19 = l1; i20 = l2; } else { k17 = k7 << 8; k18 = k12 << 8; k19 = l2; i20 = l1; } if (k19 < 0) { k17 -= i18 * k19; k18 -= i19 * k19; k19 = 0; } if (i20 > i14) i20 = i14; } int k20 = 0; int i21 = 0; int k21 = 0; int i22 = 0; int j22 = World.colourTransparent; int k22 = 0xff439eb2; if (l3 != l2) { i21 = (i9 - k7 << 8) / (l3 - l2); i22 = (i13 - k12 << 8) / (l3 - l2); if (l2 < l3) { k20 = k7 << 8; k21 = k12 << 8; j22 = l2; k22 = l3; } else { k20 = i9 << 8; k21 = i13 << 8; j22 = l3; k22 = l2; } if (j22 < 0) { k20 -= i21 * j22; k21 -= i22 * j22; j22 = 0; } if (k22 > i14) k22 = i14; } int l22 = 0; int i23 = 0; int j23 = 0; int k23 = 0; int l23 = World.colourTransparent; int i24 = 0xff439eb2; if (l4 != l3) { i23 = (k10 - i9 << 8) / (l4 - l3); k23 = (k13 - i13 << 8) / (l4 - l3); if (l3 < l4) { l22 = i9 << 8; j23 = i13 << 8; l23 = l3; i24 = l4; } else { l22 = k10 << 8; j23 = k13 << 8; l23 = l4; i24 = l3; } if (l23 < 0) { l22 -= i23 * l23; j23 -= k23 * l23; l23 = 0; } if (i24 > i14) i24 = i14; } minY = k16; if (k19 < minY) minY = k19; if (j22 < minY) minY = j22; if (l23 < minY) minY = l23; maxY = i17; if (i20 > maxY) maxY = i20; if (k22 > maxY) maxY = k22; if (i24 > maxY) maxY = i24; int j24 = 0; for (k = minY; k < maxY; k++) { if (k >= k16 && k < i17) { i = j = k14; l = j24 = k15; k14 += i15; k15 += i16; } else { i = 0xa0000; j = 0xfff60000; } if (k >= k19 && k < i20) { if (k17 < i) { i = k17; l = k18; } if (k17 > j) { j = k17; j24 = k18; } k17 += i18; k18 += i19; } if (k >= j22 && k < k22) { if (k20 < i) { i = k20; l = k21; } if (k20 > j) { j = k20; j24 = k21; } k20 += i21; k21 += i22; } if (k >= l23 && k < i24) { if (l22 < i) { i = l22; l = j23; } if (l22 > j) { j = l22; j24 = j23; } l22 += i23; j23 += k23; } Scanline scanline_7 = scanlines[k]; scanline_7.startX = i; scanline_7.endX = j; scanline_7.startS = l; scanline_7.endS = j24; } if (minY < baseY - clipY) minY = baseY - clipY; } else { maxY = minY = ai1[0] += baseY; for (k = 1; k < i1; k++) { int i2; if ((i2 = ai1[k] += baseY) < minY) minY = i2; else if (i2 > maxY) maxY = i2; } if (minY < baseY - clipY) minY = baseY - clipY; if (maxY >= baseY + clipY) maxY = (baseY + clipY) - 1; if (minY >= maxY) return; for (k = minY; k < maxY; k++) { Scanline scanline = scanlines[k]; scanline.startX = 0xa0000; scanline.endX = 0xfff60000; } int j2 = i1 - 1; int i3 = ai1[0]; int i4 = ai1[j2]; if (i3 < i4) { int i5 = ai[0] << 8; int j6 = (ai[j2] - ai[0] << 8) / (i4 - i3); int l7 = ai2[0] << 8; int j9 = (ai2[j2] - ai2[0] << 8) / (i4 - i3); if (i3 < 0) { i5 -= j6 * i3; l7 -= j9 * i3; i3 = 0; } if (i4 > maxY) i4 = maxY; for (k = i3; k <= i4; k++) { Scanline scanline_2 = scanlines[k]; scanline_2.startX = scanline_2.endX = i5; scanline_2.startS = scanline_2.endS = l7; i5 += j6; l7 += j9; } } else if (i3 > i4) { int j5 = ai[j2] << 8; int k6 = (ai[0] - ai[j2] << 8) / (i3 - i4); int i8 = ai2[j2] << 8; int k9 = (ai2[0] - ai2[j2] << 8) / (i3 - i4); if (i4 < 0) { j5 -= k6 * i4; i8 -= k9 * i4; i4 = 0; } if (i3 > maxY) i3 = maxY; for (k = i4; k <= i3; k++) { Scanline scanline_3 = scanlines[k]; scanline_3.startX = scanline_3.endX = j5; scanline_3.startS = scanline_3.endS = i8; j5 += k6; i8 += k9; } } for (k = 0; k < j2; k++) { int k5 = k + 1; int j3 = ai1[k]; int j4 = ai1[k5]; if (j3 < j4) { int l6 = ai[k] << 8; int j8 = (ai[k5] - ai[k] << 8) / (j4 - j3); int l9 = ai2[k] << 8; int l10 = (ai2[k5] - ai2[k] << 8) / (j4 - j3); if (j3 < 0) { l6 -= j8 * j3; l9 -= l10 * j3; j3 = 0; } if (j4 > maxY) j4 = maxY; for (int l11 = j3; l11 <= j4; l11++) { Scanline scanline_4 = scanlines[l11]; if (l6 < scanline_4.startX) { scanline_4.startX = l6; scanline_4.startS = l9; } if (l6 > scanline_4.endX) { scanline_4.endX = l6; scanline_4.endS = l9; } l6 += j8; l9 += l10; } } else if (j3 > j4) { int i7 = ai[k5] << 8; int k8 = (ai[k] - ai[k5] << 8) / (j3 - j4); int i10 = ai2[k5] << 8; int i11 = (ai2[k] - ai2[k5] << 8) / (j3 - j4); if (j4 < 0) { i7 -= k8 * j4; i10 -= i11 * j4; j4 = 0; } if (j3 > maxY) j3 = maxY; for (int i12 = j4; i12 <= j3; i12++) { Scanline scanline_5 = scanlines[i12]; if (i7 < scanline_5.startX) { scanline_5.startX = i7; scanline_5.startS = i10; } if (i7 > scanline_5.endX) { scanline_5.endX = i7; scanline_5.endS = i10; } i7 += k8; i10 += i11; } } } if (minY < baseY - clipY) minY = baseY - clipY; } if (mousePickingActive && mousePickedCount < mousePickedMax && mouseY >= minY && mouseY < maxY) { Scanline scanline_1 = scanlines[mouseY]; if (mouseX >= scanline_1.startX >> 8 && mouseX <= scanline_1.endX >> 8 && scanline_1.startX <= scanline_1.endX && !gameModel.unpickable && gameModel.isLocalPlayer[pid] == 0) { mousePickedModels[mousePickedCount] = gameModel; mousePickedFaces[mousePickedCount] = pid; mousePickedCount++; } } } private void rasterize(int i, int j, int k, int ai[], int ai1[], int ai2[], int l, GameModel gameModel) { if (l == -2) return; if (l >= 0) { if (l >= textureCount) l = 0; prepareTexture(l); int i1 = ai[0]; int k1 = ai1[0]; int j2 = ai2[0]; int i3 = i1 - ai[1]; int k3 = k1 - ai1[1]; int i4 = j2 - ai2[1]; k--; int i6 = ai[k] - i1; int j7 = ai1[k] - k1; int k8 = ai2[k] - j2; if (textureDimension[l] == 1) { int l9 = i6 * k1 - j7 * i1 << 12; int k10 = j7 * j2 - k8 * k1 << (5 - viewDistance) + 7 + 4; int i11 = k8 * i1 - i6 * j2 << (5 - viewDistance) + 7; int k11 = i3 * k1 - k3 * i1 << 12; int i12 = k3 * j2 - i4 * k1 << (5 - viewDistance) + 7 + 4; int k12 = i4 * i1 - i3 * j2 << (5 - viewDistance) + 7; int i13 = k3 * i6 - i3 * j7 << 5; int k13 = i4 * j7 - k3 * k8 << (5 - viewDistance) + 4; int i14 = i3 * k8 - i4 * i6 >> viewDistance - 5; int k14 = k10 >> 4; int i15 = i12 >> 4; int k15 = k13 >> 4; int i16 = minY - baseY; int k16 = width; int i17 = baseX + minY * k16; byte byte1 = 1; l9 += i11 * i16; k11 += k12 * i16; i13 += i14 * i16; if (interlace) { if ((minY & 1) == 1) { minY++; l9 += i11; k11 += k12; i13 += i14; i17 += k16; } i11 <<= 1; k12 <<= 1; i14 <<= 1; k16 <<= 1; byte1 = 2; } if (gameModel.textureTranslucent) { for (i = minY; i < maxY; i += byte1) { Scanline scanline_3 = scanlines[i]; j = scanline_3.startX >> 8; int k17 = scanline_3.endX >> 8; int k20 = k17 - j; if (k20 <= 0) { l9 += i11; k11 += k12; i13 += i14; i17 += k16; } else { int i22 = scanline_3.startS; int k23 = (scanline_3.endS - i22) / k20; if (j < -clipX) { i22 += (-clipX - j) * k23; j = -clipX; k20 = k17 - j; } if (k17 > clipX) { int l17 = clipX; k20 = l17 - j; } textureTranslucentScanline(raster, texturePixels[l], 0, 0, l9 + k14 * j, k11 + i15 * j, i13 + k15 * j, k10, i12, k13, k20, i17 + j, i22, k23 << 2); l9 += i11; k11 += k12; i13 += i14; i17 += k16; } } return; } if (!textureBackTransparent[l]) { for (i = minY; i < maxY; i += byte1) { Scanline scanline_4 = scanlines[i]; j = scanline_4.startX >> 8; int i18 = scanline_4.endX >> 8; int l20 = i18 - j; if (l20 <= 0) { l9 += i11; k11 += k12; i13 += i14; i17 += k16; } else { int j22 = scanline_4.startS; int l23 = (scanline_4.endS - j22) / l20; if (j < -clipX) { j22 += (-clipX - j) * l23; j = -clipX; l20 = i18 - j; } if (i18 > clipX) { int j18 = clipX; l20 = j18 - j; } textureScanline(raster, texturePixels[l], 0, 0, l9 + k14 * j, k11 + i15 * j, i13 + k15 * j, k10, i12, k13, l20, i17 + j, j22, l23 << 2); l9 += i11; k11 += k12; i13 += i14; i17 += k16; } } return; } for (i = minY; i < maxY; i += byte1) { Scanline scanline_5 = scanlines[i]; j = scanline_5.startX >> 8; int k18 = scanline_5.endX >> 8; int i21 = k18 - j; if (i21 <= 0) { l9 += i11; k11 += k12; i13 += i14; i17 += k16; } else { int k22 = scanline_5.startS; int i24 = (scanline_5.endS - k22) / i21; if (j < -clipX) { k22 += (-clipX - j) * i24; j = -clipX; i21 = k18 - j; } if (k18 > clipX) { int l18 = clipX; i21 = l18 - j; } textureBackTranslucentScanline(raster, 0, 0, 0, texturePixels[l], l9 + k14 * j, k11 + i15 * j, i13 + k15 * j, k10, i12, k13, i21, i17 + j, k22, i24); l9 += i11; k11 += k12; i13 += i14; i17 += k16; } } return; } int i10 = i6 * k1 - j7 * i1 << 11; int l10 = j7 * j2 - k8 * k1 << (5 - viewDistance) + 6 + 4; int j11 = k8 * i1 - i6 * j2 << (5 - viewDistance) + 6; int l11 = i3 * k1 - k3 * i1 << 11; int j12 = k3 * j2 - i4 * k1 << (5 - viewDistance) + 6 + 4; int l12 = i4 * i1 - i3 * j2 << (5 - viewDistance) + 6; int j13 = k3 * i6 - i3 * j7 << 5; int l13 = i4 * j7 - k3 * k8 << (5 - viewDistance) + 4; int j14 = i3 * k8 - i4 * i6 >> viewDistance - 5; int l14 = l10 >> 4; int j15 = j12 >> 4; int l15 = l13 >> 4; int j16 = minY - baseY; int l16 = width; int j17 = baseX + minY * l16; byte byte2 = 1; i10 += j11 * j16; l11 += l12 * j16; j13 += j14 * j16; if (interlace) { if ((minY & 1) == 1) { minY++; i10 += j11; l11 += l12; j13 += j14; j17 += l16; } j11 <<= 1; l12 <<= 1; j14 <<= 1; l16 <<= 1; byte2 = 2; } if (gameModel.textureTranslucent) { for (i = minY; i < maxY; i += byte2) { Scanline scanline_6 = scanlines[i]; j = scanline_6.startX >> 8; int i19 = scanline_6.endX >> 8; int j21 = i19 - j; if (j21 <= 0) { i10 += j11; l11 += l12; j13 += j14; j17 += l16; } else { int l22 = scanline_6.startS; int j24 = (scanline_6.endS - l22) / j21; if (j < -clipX) { l22 += (-clipX - j) * j24; j = -clipX; j21 = i19 - j; } if (i19 > clipX) { int j19 = clipX; j21 = j19 - j; } textureTranslucentScanline2(raster, texturePixels[l], 0, 0, i10 + l14 * j, l11 + j15 * j, j13 + l15 * j, l10, j12, l13, j21, j17 + j, l22, j24); i10 += j11; l11 += l12; j13 += j14; j17 += l16; } } return; } if (!textureBackTransparent[l]) { for (i = minY; i < maxY; i += byte2) { Scanline scanline_7 = scanlines[i]; j = scanline_7.startX >> 8; int k19 = scanline_7.endX >> 8; int k21 = k19 - j; if (k21 <= 0) { i10 += j11; l11 += l12; j13 += j14; j17 += l16; } else { int i23 = scanline_7.startS; int k24 = (scanline_7.endS - i23) / k21; if (j < -clipX) { i23 += (-clipX - j) * k24; j = -clipX; k21 = k19 - j; } if (k19 > clipX) { int l19 = clipX; k21 = l19 - j; } textureScanline2(raster, texturePixels[l], 0, 0, i10 + l14 * j, l11 + j15 * j, j13 + l15 * j, l10, j12, l13, k21, j17 + j, i23, k24); i10 += j11; l11 += l12; j13 += j14; j17 += l16; } } return; } for (i = minY; i < maxY; i += byte2) { Scanline scanline = scanlines[i]; j = scanline.startX >> 8; int i20 = scanline.endX >> 8; int l21 = i20 - j; if (l21 <= 0) { i10 += j11; l11 += l12; j13 += j14; j17 += l16; } else { int j23 = scanline.startS; int l24 = (scanline.endS - j23) / l21; if (j < -clipX) { j23 += (-clipX - j) * l24; j = -clipX; l21 = i20 - j; } if (i20 > clipX) { int j20 = clipX; l21 = j20 - j; } textureBackTranslucentScanline2(raster, 0, 0, 0, texturePixels[l], i10 + l14 * j, l11 + j15 * j, j13 + l15 * j, l10, j12, l13, l21, j17 + j, j23, l24); i10 += j11; l11 += l12; j13 += j14; j17 += l16; } } return; } for (int j1 = 0; j1 < rampCount; j1++) { if (gradientBase[j1] == l) { anIntArray377 = gradientRamps[j1]; break; } if (j1 == rampCount - 1) { int l1 = (int) (Math.random() * (double) rampCount); gradientBase[l1] = l; l = -1 - l; int k2 = (l >> 10 & 0x1f) * 8; int j3 = (l >> 5 & 0x1f) * 8; int l3 = (l & 0x1f) * 8; for (int j4 = 0; j4 < 256; j4++) { int j6 = j4 * j4; int k7 = (k2 * j6) / 0x10000; int l8 = (j3 * j6) / 0x10000; int j10 = (l3 * j6) / 0x10000; gradientRamps[l1][255 - j4] = (k7 << 16) + (l8 << 8) + j10; } anIntArray377 = gradientRamps[l1]; } } int i2 = width; int l2 = baseX + minY * i2; byte byte0 = 1; if (interlace) { if ((minY & 1) == 1) { minY++; l2 += i2; } i2 <<= 1; byte0 = 2; } if (gameModel.transparent) { for (i = minY; i < maxY; i += byte0) { Scanline scanline = scanlines[i]; j = scanline.startX >> 8; int k4 = scanline.endX >> 8; int k6 = k4 - j; if (k6 <= 0) { l2 += i2; } else { int l7 = scanline.startS; int i9 = (scanline.endS - l7) / k6; if (j < -clipX) { l7 += (-clipX - j) * i9; j = -clipX; k6 = k4 - j; } if (k4 > clipX) { int l4 = clipX; k6 = l4 - j; } textureGradientScanline(raster, -k6, l2 + j, 0, anIntArray377, l7, i9); l2 += i2; } } return; } if (wideBand) { for (i = minY; i < maxY; i += byte0) { Scanline scanline_1 = scanlines[i]; j = scanline_1.startX >> 8; int i5 = scanline_1.endX >> 8; int l6 = i5 - j; if (l6 <= 0) { l2 += i2; } else { int i8 = scanline_1.startS; int j9 = (scanline_1.endS - i8) / l6; if (j < -clipX) { i8 += (-clipX - j) * j9; j = -clipX; l6 = i5 - j; } if (i5 > clipX) { int j5 = clipX; l6 = j5 - j; } gradientScanline(raster, -l6, l2 + j, 0, anIntArray377, i8, j9); l2 += i2; } } return; } for (i = minY; i < maxY; i += byte0) { Scanline scanline_2 = scanlines[i]; j = scanline_2.startX >> 8; int k5 = scanline_2.endX >> 8; int i7 = k5 - j; if (i7 <= 0) { l2 += i2; } else { int j8 = scanline_2.startS; int k9 = (scanline_2.endS - j8) / i7; if (j < -clipX) { j8 += (-clipX - j) * k9; j = -clipX; i7 = k5 - j; } if (k5 > clipX) { int l5 = clipX; i7 = l5 - j; } gradientScanline2(raster, -i7, l2 + j, 0, anIntArray377, j8, k9); l2 += i2; } } } public void setCamera(int x, int z, int y, int pitch, int yaw, int roll, int distance) { pitch &= 0x3ff; yaw &= 0x3ff; roll &= 0x3ff; cameraYaw = 1024 - pitch & 0x3ff; cameraPitch = 1024 - yaw & 0x3ff; cameraRoll = 1024 - roll & 0x3ff; int l1 = 0; int i2 = 0; int j2 = distance; if (pitch != 0) { int k2 = sin2048Cache[pitch]; int j3 = sin2048Cache[pitch + 1024]; int i4 = i2 * j3 - j2 * k2 >> 15; j2 = i2 * k2 + j2 * j3 >> 15; i2 = i4; } if (yaw != 0) { int l2 = sin2048Cache[yaw]; int k3 = sin2048Cache[yaw + 1024]; int j4 = j2 * l2 + l1 * k3 >> 15; j2 = j2 * k3 - l1 * l2 >> 15; l1 = j4; } if (roll != 0) { int i3 = sin2048Cache[roll]; int l3 = sin2048Cache[roll + 1024]; int k4 = i2 * i3 + l1 * l3 >> 15; i2 = i2 * l3 - l1 * i3 >> 15; l1 = k4; } cameraX = x - l1; cameraY = z - i2; cameraZ = y - j2; } private void initialisePolygon3d(int i) { Polygon polygon = visiblePolygons[i]; GameModel gameModel = polygon.model; int face = polygon.face; int faceVertices[] = gameModel.faceVertices[face]; int faceNumVertices = gameModel.faceNumVertices[face]; int faceCameraNormalScale = gameModel.normalScale[face]; int vcx = gameModel.projectVertexX[faceVertices[0]]; int vcy = gameModel.projectVertexY[faceVertices[0]]; int vcz = gameModel.projectVertexZ[faceVertices[0]]; int vcx1 = gameModel.projectVertexX[faceVertices[1]] - vcx; int vcy1 = gameModel.projectVertexY[faceVertices[1]] - vcy; int vcz1 = gameModel.projectVertexZ[faceVertices[1]] - vcz; int vcx2 = gameModel.projectVertexX[faceVertices[2]] - vcx; int vcy2 = gameModel.projectVertexY[faceVertices[2]] - vcy; int vcz2 = gameModel.projectVertexZ[faceVertices[2]] - vcz; int t1 = vcy1 * vcz2 - vcy2 * vcz1; int t2 = vcz1 * vcx2 - vcz2 * vcx1; int t3 = vcx1 * vcy2 - vcx2 * vcy1; if (faceCameraNormalScale == -1) { faceCameraNormalScale = 0; for (; t1 > 25000 || t2 > 25000 || t3 > 25000 || t1 < -25000 || t2 < -25000 || t3 < -25000; t3 >>= 1) { faceCameraNormalScale++; t1 >>= 1; t2 >>= 1; } gameModel.normalScale[face] = faceCameraNormalScale; gameModel.normalMagnitude[face] = (int) ((double) normalMagnitude * Math.sqrt(t1 * t1 + t2 * t2 + t3 * t3)); } else { t1 >>= faceCameraNormalScale; t2 >>= faceCameraNormalScale; t3 >>= faceCameraNormalScale; } polygon.visibility = vcx * t1 + vcy * t2 + vcz * t3; polygon.normalX = t1; polygon.normalY = t2; polygon.normalZ = t3; int j4 = gameModel.projectVertexZ[faceVertices[0]]; int k4 = j4; int l4 = gameModel.vertexViewX[faceVertices[0]]; int i5 = l4; int j5 = gameModel.vertexViewY[faceVertices[0]]; int k5 = j5; for (int l5 = 1; l5 < faceNumVertices; l5++) { int i1 = gameModel.projectVertexZ[faceVertices[l5]]; if (i1 > k4) k4 = i1; else if (i1 < j4) j4 = i1; i1 = gameModel.vertexViewX[faceVertices[l5]]; if (i1 > i5) i5 = i1; else if (i1 < l4) l4 = i1; i1 = gameModel.vertexViewY[faceVertices[l5]]; if (i1 > k5) k5 = i1; else if (i1 < j5) j5 = i1; } polygon.minZ = j4; polygon.maxZ = k4; polygon.minPlaneX = l4; polygon.maxPlaneX = i5; polygon.minPlaneY = j5; polygon.maxPlaneY = k5; } private void initialisePolygon2d(int i) { Polygon polygon = visiblePolygons[i]; GameModel gameModel = polygon.model; int j = polygon.face; int ai[] = gameModel.faceVertices[j]; int l = 0; int i1 = 0; int j1 = 1; int k1 = gameModel.projectVertexX[ai[0]]; int l1 = gameModel.projectVertexY[ai[0]]; int i2 = gameModel.projectVertexZ[ai[0]]; gameModel.normalMagnitude[j] = 1; gameModel.normalScale[j] = 0; polygon.visibility = k1 * l + l1 * i1 + i2 * j1; polygon.normalX = l; polygon.normalY = i1; polygon.normalZ = j1; int j2 = gameModel.projectVertexZ[ai[0]]; int k2 = j2; int l2 = gameModel.vertexViewX[ai[0]]; int i3 = l2; if (gameModel.vertexViewX[ai[1]] < l2) l2 = gameModel.vertexViewX[ai[1]]; else i3 = gameModel.vertexViewX[ai[1]]; int j3 = gameModel.vertexViewY[ai[1]]; int k3 = gameModel.vertexViewY[ai[0]]; int k = gameModel.projectVertexZ[ai[1]]; if (k > k2) k2 = k; else if (k < j2) j2 = k; k = gameModel.vertexViewX[ai[1]]; if (k > i3) i3 = k; else if (k < l2) l2 = k; k = gameModel.vertexViewY[ai[1]]; if (k > k3) k3 = k; else if (k < j3) j3 = k; polygon.minZ = j2; polygon.maxZ = k2; polygon.minPlaneX = l2 - 20; polygon.maxPlaneX = i3 + 20; polygon.minPlaneY = j3; polygon.maxPlaneY = k3; } private boolean separatePolygon(Polygon polygon, Polygon polygon_1) { if (polygon.minPlaneX >= polygon_1.maxPlaneX) return true; if (polygon_1.minPlaneX >= polygon.maxPlaneX) return true; if (polygon.minPlaneY >= polygon_1.maxPlaneY) return true; if (polygon_1.minPlaneY >= polygon.maxPlaneY) return true; if (polygon.minZ >= polygon_1.maxZ) return true; if (polygon_1.minZ > polygon.maxZ) return false; GameModel gameModel = polygon.model; GameModel gameModel_1 = polygon_1.model; int i = polygon.face; int j = polygon_1.face; int ai[] = gameModel.faceVertices[i]; int ai1[] = gameModel_1.faceVertices[j]; int k = gameModel.faceNumVertices[i]; int l = gameModel_1.faceNumVertices[j]; int k2 = gameModel_1.projectVertexX[ai1[0]]; int l2 = gameModel_1.projectVertexY[ai1[0]]; int i3 = gameModel_1.projectVertexZ[ai1[0]]; int j3 = polygon_1.normalX; int k3 = polygon_1.normalY; int l3 = polygon_1.normalZ; int i4 = gameModel_1.normalMagnitude[j]; int j4 = polygon_1.visibility; boolean flag = false; for (int k4 = 0; k4 < k; k4++) { int i1 = ai[k4]; int i2 = (k2 - gameModel.projectVertexX[i1]) * j3 + (l2 - gameModel.projectVertexY[i1]) * k3 + (i3 - gameModel.projectVertexZ[i1]) * l3; if ((i2 >= -i4 || j4 >= 0) && (i2 <= i4 || j4 <= 0)) continue; flag = true; break; } if (!flag) return true; k2 = gameModel.projectVertexX[ai[0]]; l2 = gameModel.projectVertexY[ai[0]]; i3 = gameModel.projectVertexZ[ai[0]]; j3 = polygon.normalX; k3 = polygon.normalY; l3 = polygon.normalZ; i4 = gameModel.normalMagnitude[i]; j4 = polygon.visibility; flag = false; for (int l4 = 0; l4 < l; l4++) { int j1 = ai1[l4]; int j2 = (k2 - gameModel_1.projectVertexX[j1]) * j3 + (l2 - gameModel_1.projectVertexY[j1]) * k3 + (i3 - gameModel_1.projectVertexZ[j1]) * l3; if ((j2 >= -i4 || j4 <= 0) && (j2 <= i4 || j4 >= 0)) continue; flag = true; break; } if (!flag) return true; int ai2[]; int ai3[]; if (k == 2) { ai2 = new int[4]; ai3 = new int[4]; int i5 = ai[0]; int k1 = ai[1]; ai2[0] = gameModel.vertexViewX[i5] - 20; ai2[1] = gameModel.vertexViewX[k1] - 20; ai2[2] = gameModel.vertexViewX[k1] + 20; ai2[3] = gameModel.vertexViewX[i5] + 20; ai3[0] = ai3[3] = gameModel.vertexViewY[i5]; ai3[1] = ai3[2] = gameModel.vertexViewY[k1]; } else { ai2 = new int[k]; ai3 = new int[k]; for (int j5 = 0; j5 < k; j5++) { int i6 = ai[j5]; ai2[j5] = gameModel.vertexViewX[i6]; ai3[j5] = gameModel.vertexViewY[i6]; } } int ai4[]; int ai5[]; if (l == 2) { ai4 = new int[4]; ai5 = new int[4]; int k5 = ai1[0]; int l1 = ai1[1]; ai4[0] = gameModel_1.vertexViewX[k5] - 20; ai4[1] = gameModel_1.vertexViewX[l1] - 20; ai4[2] = gameModel_1.vertexViewX[l1] + 20; ai4[3] = gameModel_1.vertexViewX[k5] + 20; ai5[0] = ai5[3] = gameModel_1.vertexViewY[k5]; ai5[1] = ai5[2] = gameModel_1.vertexViewY[l1]; } else { ai4 = new int[l]; ai5 = new int[l]; for (int l5 = 0; l5 < l; l5++) { int j6 = ai1[l5]; ai4[l5] = gameModel_1.vertexViewX[j6]; ai5[l5] = gameModel_1.vertexViewY[j6]; } } return !intersect(ai2, ai3, ai4, ai5); } private boolean heuristicPolygon(Polygon polygon, Polygon polygon_1) { GameModel gameModel = polygon.model; GameModel gameModel_1 = polygon_1.model; int i = polygon.face; int j = polygon_1.face; int ai[] = gameModel.faceVertices[i]; int ai1[] = gameModel_1.faceVertices[j]; int k = gameModel.faceNumVertices[i]; int l = gameModel_1.faceNumVertices[j]; int i2 = gameModel_1.projectVertexX[ai1[0]]; int j2 = gameModel_1.projectVertexY[ai1[0]]; int k2 = gameModel_1.projectVertexZ[ai1[0]]; int l2 = polygon_1.normalX; int i3 = polygon_1.normalY; int j3 = polygon_1.normalZ; int k3 = gameModel_1.normalMagnitude[j]; int l3 = polygon_1.visibility; boolean flag = false; for (int i4 = 0; i4 < k; i4++) { int i1 = ai[i4]; int k1 = (i2 - gameModel.projectVertexX[i1]) * l2 + (j2 - gameModel.projectVertexY[i1]) * i3 + (k2 - gameModel.projectVertexZ[i1]) * j3; if ((k1 >= -k3 || l3 >= 0) && (k1 <= k3 || l3 <= 0)) continue; flag = true; break; } if (!flag) return true; i2 = gameModel.projectVertexX[ai[0]]; j2 = gameModel.projectVertexY[ai[0]]; k2 = gameModel.projectVertexZ[ai[0]]; l2 = polygon.normalX; i3 = polygon.normalY; j3 = polygon.normalZ; k3 = gameModel.normalMagnitude[i]; l3 = polygon.visibility; flag = false; for (int j4 = 0; j4 < l; j4++) { int j1 = ai1[j4]; int l1 = (i2 - gameModel_1.projectVertexX[j1]) * l2 + (j2 - gameModel_1.projectVertexY[j1]) * i3 + (k2 - gameModel_1.projectVertexZ[j1]) * j3; if ((l1 >= -k3 || l3 <= 0) && (l1 <= k3 || l3 >= 0)) continue; flag = true; break; } return !flag; } public void allocateTextures(int count, int something7, int something11) { textureCount = count; textureColoursUsed = new byte[count][]; textureColourList = new int[count][]; textureDimension = new int[count]; textureLoadedNumber = new long[count]; textureBackTransparent = new boolean[count]; texturePixels = new int[count][]; textureCountLoaded = 0L; textureColours64 = new int[something7][];// 64x64 rgba textureColours128 = new int[something11][];// 128x128 rgba } public void defineTexture(int id, byte usedColours[], int colours[], int wide128) { textureColoursUsed[id] = usedColours; textureColourList[id] = colours; textureDimension[id] = wide128;// is 1 if the texture is 128+ pixels wide, 0 if <128 textureLoadedNumber[id] = 0L;// as in the current loaded texture count when its loaded textureBackTransparent[id] = false; texturePixels[id] = null; prepareTexture(id); } public void prepareTexture(int id) { if (id < 0) return; textureLoadedNumber[id] = textureCountLoaded++; if (texturePixels[id] != null) return; if (textureDimension[id] == 0) {// is 64 pixels wide for (int j = 0; j < textureColours64.length; j++) if (textureColours64[j] == null) { textureColours64[j] = new int[16384]; texturePixels[id] = textureColours64[j]; setTexturePixels(id); return; } long GIGALONG = 1L << 30;// almost as large as exemplar's nas storage int wut = 0; for (int k1 = 0; k1 < textureCount; k1++) if (k1 != id && textureDimension[k1] == 0 && texturePixels[k1] != null && textureLoadedNumber[k1] < GIGALONG) { GIGALONG = textureLoadedNumber[k1]; wut = k1; } texturePixels[id] = texturePixels[wut]; texturePixels[wut] = null; setTexturePixels(id); return; } // is 128 wide for (int k = 0; k < textureColours128.length; k++) if (textureColours128[k] == null) { textureColours128[k] = new int[0x10000]; texturePixels[id] = textureColours128[k]; setTexturePixels(id); return; } long GIGALONG = 1L << 30;// 1G 2G 3G... 4G? int wat = 0; for (int i2 = 0; i2 < textureCount; i2++) if (i2 != id && textureDimension[i2] == 1 && texturePixels[i2] != null && textureLoadedNumber[i2] < GIGALONG) { GIGALONG = textureLoadedNumber[i2]; wat = i2; } texturePixels[id] = texturePixels[wat]; texturePixels[wat] = null; setTexturePixels(id); } private void setTexturePixels(int id) { char textureWidth; if (textureDimension[id] == 0) textureWidth = 64;//'@'; else textureWidth = 128;//'\200'; int colours[] = texturePixels[id]; int colourCount = 0; for (int x = 0; x < textureWidth; x++) { for (int y = 0; y < textureWidth; y++) { int colour = textureColourList[id][textureColoursUsed[id][y + x * textureWidth] & 0xff]; colour &= 0xf8f8ff; if (colour == 0) colour = 1; else if (colour == 0xf800ff) { colour = 0; textureBackTransparent[id] = true; } colours[colourCount++] = colour; } } for (int i1 = 0; i1 < colourCount; i1++) { int colour = colours[i1];// ?? colours[colourCount + i1] = colour - (colour >>> 3) & 0xf8f8ff; colours[colourCount * 2 + i1] = colour - (colour >>> 2) & 0xf8f8ff; colours[colourCount * 3 + i1] = colour - (colour >>> 2) - (colour >>> 3) & 0xf8f8ff; } } public void doSOemthingWithTheFuckinFountainFuck(int id) { if (texturePixels[id] == null) return; int colours[] = texturePixels[id]; for (int i = 0; i < 64; i++) { int k = i + 4032; int l = colours[k]; for (int j1 = 0; j1 < 63; j1++) { colours[k] = colours[k - 64]; k -= 64; } texturePixels[id][k] = l; } char c = 4096; for (int i1 = 0; i1 < c; i1++) { int k1 = colours[i1]; colours[c + i1] = k1 - (k1 >>> 3) & 0xf8f8ff; colours[c * 2 + i1] = k1 - (k1 >>> 2) & 0xf8f8ff; colours[c * 3 + i1] = k1 - (k1 >>> 2) - (k1 >>> 3) & 0xf8f8ff; } } public int method302(int i) { if (i == World.colourTransparent) return 0; prepareTexture(i); if (i >= 0) return texturePixels[i][0]; if (i < 0) { i = -(i + 1); int j = i >> 10 & 0x1f; int k = i >> 5 & 0x1f; int l = i & 0x1f; return (j << 19) + (k << 11) + (l << 3); } else { return 0; } } public void setLight(int i, int j, int k) { if (i == 0 && j == 0 && k == 0) i = 32; for (int l = 0; l < modelCount; l++) models[l].setLight(i, j, k); } public void setLight(int i, int j, int k, int l, int i1) { if (k == 0 && l == 0 && i1 == 0) k = 32; for (int j1 = 0; j1 < modelCount; j1++) models[j1].setLight(i, j, k, l, i1); } public int method306(int i, int j, int k, int l, int i1) { if (l == j) return i; else return i + ((k - i) * (i1 - j)) / (l - j); } public boolean method307(int i, int j, int k, int l, boolean flag) { if (flag && i <= k || i < k) { if (i > l) return true; if (j > k) return true; if (j > l) return true; return !flag; } if (i < l) return true; if (j < k) return true; if (j < l) return true; else return flag; } public boolean method308(int i, int j, int k, boolean flag) { if (flag && i <= k || i < k) { if (j > k) return true; return !flag; } if (j < k) return true; else return flag; } public boolean intersect(int ai[], int ai1[], int ai2[], int ai3[]) { int i = ai.length; int j = ai2.length; byte byte0 = 0; int i20; int k20 = i20 = ai1[0]; int k = 0; int j20; int l20 = j20 = ai3[0]; int i1 = 0; for (int i21 = 1; i21 < i; i21++) if (ai1[i21] < i20) { i20 = ai1[i21]; k = i21; } else if (ai1[i21] > k20) k20 = ai1[i21]; for (int j21 = 1; j21 < j; j21++) if (ai3[j21] < j20) { j20 = ai3[j21]; i1 = j21; } else if (ai3[j21] > l20) l20 = ai3[j21]; if (j20 >= k20) return false; if (i20 >= l20) return false; int l; int j1; boolean flag; if (ai1[k] < ai3[i1]) { for (l = k; ai1[l] < ai3[i1]; l = (l + 1) % i) ; for (; ai1[k] < ai3[i1]; k = ((k - 1) + i) % i) ; int k1 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai3[i1]); int k6 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai3[i1]); int l10 = ai2[i1]; flag = (k1 < l10) | (k6 < l10); if (method308(k1, k6, l10, flag)) return true; j1 = (i1 + 1) % j; i1 = ((i1 - 1) + j) % j; if (k == l) byte0 = 1; } else { for (j1 = i1; ai3[j1] < ai1[k]; j1 = (j1 + 1) % j) ; for (; ai3[i1] < ai1[k]; i1 = ((i1 - 1) + j) % j) ; int l1 = ai[k]; int i11 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai1[k]); int l15 = method306(ai2[((j1 - 1) + j) % j], ai3[((j1 - 1) + j) % j], ai2[j1], ai3[j1], ai1[k]); flag = (l1 < i11) | (l1 < l15); if (method308(i11, l15, l1, !flag)) return true; l = (k + 1) % i; k = ((k - 1) + i) % i; if (i1 == j1) byte0 = 2; } while (byte0 == 0) if (ai1[k] < ai1[l]) { if (ai1[k] < ai3[i1]) { if (ai1[k] < ai3[j1]) { int i2 = ai[k]; int l6 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai1[k]); int j11 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai1[k]); int i16 = method306(ai2[((j1 - 1) + j) % j], ai3[((j1 - 1) + j) % j], ai2[j1], ai3[j1], ai1[k]); if (method307(i2, l6, j11, i16, flag)) return true; k = ((k - 1) + i) % i; if (k == l) byte0 = 1; } else { int j2 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai3[j1]); int i7 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai3[j1]); int k11 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai3[j1]); int j16 = ai2[j1]; if (method307(j2, i7, k11, j16, flag)) return true; j1 = (j1 + 1) % j; if (i1 == j1) byte0 = 2; } } else if (ai3[i1] < ai3[j1]) { int k2 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai3[i1]); int j7 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai3[i1]); int l11 = ai2[i1]; int k16 = method306(ai2[((j1 - 1) + j) % j], ai3[((j1 - 1) + j) % j], ai2[j1], ai3[j1], ai3[i1]); if (method307(k2, j7, l11, k16, flag)) return true; i1 = ((i1 - 1) + j) % j; if (i1 == j1) byte0 = 2; } else { int l2 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai3[j1]); int k7 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai3[j1]); int i12 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai3[j1]); int l16 = ai2[j1]; if (method307(l2, k7, i12, l16, flag)) return true; j1 = (j1 + 1) % j; if (i1 == j1) byte0 = 2; } } else if (ai1[l] < ai3[i1]) { if (ai1[l] < ai3[j1]) { int i3 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai1[l]); int l7 = ai[l]; int j12 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai1[l]); int i17 = method306(ai2[((j1 - 1) + j) % j], ai3[((j1 - 1) + j) % j], ai2[j1], ai3[j1], ai1[l]); if (method307(i3, l7, j12, i17, flag)) return true; l = (l + 1) % i; if (k == l) byte0 = 1; } else { int j3 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai3[j1]); int i8 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai3[j1]); int k12 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai3[j1]); int j17 = ai2[j1]; if (method307(j3, i8, k12, j17, flag)) return true; j1 = (j1 + 1) % j; if (i1 == j1) byte0 = 2; } } else if (ai3[i1] < ai3[j1]) { int k3 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai3[i1]); int j8 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai3[i1]); int l12 = ai2[i1]; int k17 = method306(ai2[((j1 - 1) + j) % j], ai3[((j1 - 1) + j) % j], ai2[j1], ai3[j1], ai3[i1]); if (method307(k3, j8, l12, k17, flag)) return true; i1 = ((i1 - 1) + j) % j; if (i1 == j1) byte0 = 2; } else { int l3 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai3[j1]); int k8 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai3[j1]); int i13 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai3[j1]); int l17 = ai2[j1]; if (method307(l3, k8, i13, l17, flag)) return true; j1 = (j1 + 1) % j; if (i1 == j1) byte0 = 2; } while (byte0 == 1) if (ai1[k] < ai3[i1]) { if (ai1[k] < ai3[j1]) { int i4 = ai[k]; int j13 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai1[k]); int i18 = method306(ai2[((j1 - 1) + j) % j], ai3[((j1 - 1) + j) % j], ai2[j1], ai3[j1], ai1[k]); return method308(j13, i18, i4, !flag); } int j4 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai3[j1]); int l8 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai3[j1]); int k13 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai3[j1]); int j18 = ai2[j1]; if (method307(j4, l8, k13, j18, flag)) return true; j1 = (j1 + 1) % j; if (i1 == j1) byte0 = 0; } else if (ai3[i1] < ai3[j1]) { int k4 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai3[i1]); int i9 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai3[i1]); int l13 = ai2[i1]; int k18 = method306(ai2[((j1 - 1) + j) % j], ai3[((j1 - 1) + j) % j], ai2[j1], ai3[j1], ai3[i1]); if (method307(k4, i9, l13, k18, flag)) return true; i1 = ((i1 - 1) + j) % j; if (i1 == j1) byte0 = 0; } else { int l4 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai3[j1]); int j9 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai3[j1]); int i14 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai3[j1]); int l18 = ai2[j1]; if (method307(l4, j9, i14, l18, flag)) return true; j1 = (j1 + 1) % j; if (i1 == j1) byte0 = 0; } while (byte0 == 2) if (ai3[i1] < ai1[k]) { if (ai3[i1] < ai1[l]) { int i5 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai3[i1]); int k9 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai3[i1]); int j14 = ai2[i1]; return method308(i5, k9, j14, flag); } int j5 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai1[l]); int l9 = ai[l]; int k14 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai1[l]); int i19 = method306(ai2[((j1 - 1) + j) % j], ai3[((j1 - 1) + j) % j], ai2[j1], ai3[j1], ai1[l]); if (method307(j5, l9, k14, i19, flag)) return true; l = (l + 1) % i; if (k == l) byte0 = 0; } else if (ai1[k] < ai1[l]) { int k5 = ai[k]; int i10 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai1[k]); int l14 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai1[k]); int j19 = method306(ai2[((j1 - 1) + j) % j], ai3[((j1 - 1) + j) % j], ai2[j1], ai3[j1], ai1[k]); if (method307(k5, i10, l14, j19, flag)) return true; k = ((k - 1) + i) % i; if (k == l) byte0 = 0; } else { int l5 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai1[l]); int j10 = ai[l]; int i15 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai1[l]); int k19 = method306(ai2[((j1 - 1) + j) % j], ai3[((j1 - 1) + j) % j], ai2[j1], ai3[j1], ai1[l]); if (method307(l5, j10, i15, k19, flag)) return true; l = (l + 1) % i; if (k == l) byte0 = 0; } if (ai1[k] < ai3[i1]) { int i6 = ai[k]; int j15 = method306(ai2[(i1 + 1) % j], ai3[(i1 + 1) % j], ai2[i1], ai3[i1], ai1[k]); int l19 = method306(ai2[((j1 - 1) + j) % j], ai3[((j1 - 1) + j) % j], ai2[j1], ai3[j1], ai1[k]); return method308(j15, l19, i6, !flag); } int j6 = method306(ai[(k + 1) % i], ai1[(k + 1) % i], ai[k], ai1[k], ai3[i1]); int k10 = method306(ai[((l - 1) + i) % i], ai1[((l - 1) + i) % i], ai[l], ai1[l], ai3[i1]); int k15 = ai2[i1]; return method308(j6, k10, k15, flag); } }