mirror/deep-c-rsc
1
0
Fork 0
mirror of https://github.com/2003scape/deep-c-rsc.git synced 2024-03-22 05:49:51 -04:00
Code Issues Projects Releases Wiki Activity
5583ddff51
deep-c-rsc/mudclient204-threadless/Scene.java

3128 lines
112 KiB
Java
Raw Normal View History

threadless client (for web)
2021-07-18 22:51:38 -04:00
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);
}
}
Reference in New Issue Copy Permalink