i.java

j2me武林传之刀剑江湖录[中篇]反编译的源代码

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 

import java.io.DataInputStream;
import java.io.PrintStream;
import java.util.Vector;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;

public final class i
{

	public static byte a[] = new byte[121];
	public static short b[] = new short[605];
	public static byte c;
	public static short d[] = new short[121];
	private static i h[];
	public static int e;
	private short i;
	private short j;
	private byte k;
	private byte l;
	private short m;
	private short n;
	private byte o[];
	private byte p[];
	private byte q[];
	private byte r[];
	private byte s;
	private q t[];
	private byte u[];
	private byte v[];
	private static byte w;
	private static q x[][];
	private static byte y[][];
	private static byte z[][];
	private byte A;
	private q B[];
	private byte C[];
	private byte D[][];
	private static byte E;
	private static q F[][];
	private static byte G[][];
	private static byte H[][][];
	private static int I;
	private static int J;
	private static int K;
	private static int L;
	private static int M;
	private static int N;
	private static int O;
	private static int P;
	private static byte Q;
	private static byte R;
	public static final int f;
	public static final int g;
	private static short S[];
	private static short T[];
	private static int U;
	private static int V;
	private static int W[] = new int[45];
	private static short X;
	private static int Y;
	private static int Z;
	private static Image aa;
	private static Graphics ab;
	private static int ac;
	private static int ad;
	private static int ae;
	private static int af;
	private static boolean ag;

	public i()
	{
	}

	public static final void a(int i1)
	{
		h = new i[i1];
	}

	private static void a(Graphics g1)
	{
		X = 0;
		int k2 = L;
		int l2 = K;
		V = 0;
		U = 0;
		L -= 4;
		P += 4;
		K -= 4;
		O += 4;
		for (int i3 = L; i3 < P; i3++)
		{
			if (i3 < 0)
				continue;
			if (i3 >= h[e].j)
				break;
			int i1 = i3 * h[e].i;
			for (int i4 = K; i4 < O; i4++)
			{
				if (i4 < 0)
					continue;
				if (i4 >= h[e].i)
					break;
				int j1 = i1 + i4;
				int k1;
				if ((k1 = h[e].p[j1]) != -1)
					if (k1 > -1)
					{
						int i2 = (i4 - l2) * h[e].k + M;
						int j2 = (i3 - k2) * h[e].l + N;
						T[V * 3 + 0] = (short)(-(k1 + 1));
						T[V * 3 + 1] = (short)i2;
						T[V * 3 + 2] = (short)j2;
						V++;
						if (V < g);
					} else
					if (k1 > -128)
					{
						k1 = -k1 + -2;
						for (int j4 = 0; j4 < a[k1]; j4++)
						{
							Object obj;
							short word0;
							if ((word0 = b[k1 * 5 + j4]) < 120)
								obj = k.u[k.w[word0]];
							else
								obj = k.q[word0 - 120];
							if (((z) (obj)).e[4] == 0)
							{
								((z) (obj)).a(g1, ((z) (obj)).e[8] - I, ((z) (obj)).e[9] - J);
								continue;
							}
							if (((z) (obj)).e[4] == 100)
							{
								S[U * 3 + 0] = ((z) (obj)).e[1];
								S[U * 3 + 1] = (short)(((z) (obj)).e[8] - I);
								S[U * 3 + 2] = (short)(((z) (obj)).e[9] - J);
								U++;
								if (U < f);
							} else
							{
								T[V * 3 + 0] = ((z) (obj)).e[1];
								T[V * 3 + 1] = (short)(((z) (obj)).e[8] - I);
								T[V * 3 + 2] = (short)(((z) (obj)).e[9] - J);
								V++;
							}
						}

					}
				if ((k1 = h[e].r[j1]) >= -87)
					continue;
				int l1 = k1 + 127;
				w w1;
				if (((w1 = w.c[l1]).a[2] & 2) == 2)
				{
					w1.a(g1, w.c[l1].a[6] - I, w.c[l1].a[7] - J);
				} else
				{
					W[X++] = l1;
					W[X++] = w.c[l1].a[6] - I;
					W[X++] = w.c[l1].a[7] - J;
				}
			}

		}

		for (int j3 = 0; j3 < V; j3++)
		{
			short word1;
			if ((word1 = T[j3 * 3 + 0]) < 0)
			{
				a(g1, T[j3 * 3 + 1], T[j3 * 3 + 2], -(word1 + 1));
				continue;
			}
			Object obj1;
			if (word1 >= 2)
				obj1 = k.u[word1];
			else
				obj1 = k.s;
			((z) (obj1)).a(g1, T[j3 * 3 + 1], T[j3 * 3 + 2]);
		}

		for (int k3 = 0; k3 < U; k3++)
		{
			Object obj2;
			short word2;
			if ((word2 = S[k3 * 3 + 0]) >= 2)
				obj2 = k.u[word2];
			else
				obj2 = k.s;
			((z) (obj2)).a(g1, S[k3 * 3 + 1], S[k3 * 3 + 2]);
		}

		for (int l3 = 0; l3 < X;)
			w.c[W[l3++]].a(g1, W[l3++], W[l3++]);

	}

	private static void a(Graphics g1, int i1, int j1, int k1)
	{
		int i2 = h[e].D[k1].length >> 2;
		for (int j2 = 0; j2 < i2; j2++)
		{
			int l1 = j2 << 2;
			byte byte0 = h[e].D[k1][l1++];
			byte byte1 = h[e].D[k1][l1++];
			byte byte2 = h[e].D[k1][l1++];
			byte byte3 = h[e].D[k1][l1];
			l1 = byte0 << 1;
			byte byte4 = h[e].C[l1++];
			byte byte5 = h[e].C[l1];
			h[e].B[byte4].a(g1, byte5, i1 + byte2, j1 + byte3, 20, byte1);
		}

	}

	public static final void b(int i1)
	{
		Object obj = null;
		DataInputStream datainputstream;
		byte byte0;
		int ai[] = new int[(byte0 = (datainputstream = k.a("map.bin")).readByte()) + 1];
		for (int j1 = 0; j1 < ai.length; j1++)
			ai[j1] = datainputstream.readInt();

		byte byte1;
		int ai1[] = new int[(byte1 = datainputstream.readByte()) + 1];
		for (int k1 = 0; k1 < ai1.length; k1++)
			ai1[k1] = datainputstream.readInt();

		int l1 = -1;
		Vector vector = new Vector();
		Vector vector1 = new Vector();
		for (int i2 = 0; i2 < k.ae[i1].length; i2++)
		{
			byte byte3 = k.ae[i1][i2];
			if (h[byte3] != null)
				continue;
			if (i2 == 0)
				datainputstream.skip(ai1[byte3]);
			else
				datainputstream.skip(ai1[byte3] - ai1[l1 + 1]);
			i j2;
			(j2 = new i()).i = (short)(datainputstream.readByte() & 0xff);
			j2.j = (short)(datainputstream.readByte() & 0xff);
			j2.k = datainputstream.readByte();
			j2.l = datainputstream.readByte();
			j2.m = (short)(j2.i * j2.k);
			j2.n = (short)(j2.j * j2.l);
			j2.s = datainputstream.readByte();
			j2.A = datainputstream.readByte();
			if (!vector.contains(String.valueOf(j2.s)))
			{
				boolean flag = false;
				int j3 = 0;
				do
				{
					if (j3 >= vector.size())
						break;
					int l3 = Integer.parseInt((String)vector.elementAt(j3));
					if (j2.s < l3)
					{
						vector.insertElementAt(String.valueOf(j2.s), j3);
						flag = true;
						break;
					}
					j3++;
				} while (true);
				if (!flag)
					vector.addElement(String.valueOf(j2.s));
			}
			if (!vector1.contains(String.valueOf(j2.A)))
			{
				boolean flag1 = false;
				int k3 = 0;
				do
				{
					if (k3 >= vector1.size())
						break;
					int i4 = Integer.parseInt((String)vector1.elementAt(k3));
					if (j2.A < i4)
					{
						vector1.insertElementAt(String.valueOf(j2.A), k3);
						flag1 = true;
						break;
					}
					k3++;
				} while (true);
				if (!flag1)
					vector1.addElement(String.valueOf(j2.A));
			}
			j2.o = new byte[j2.i * j2.j];
			datainputstream.read(j2.o);
			j2.p = new byte[j2.i * j2.j];
			datainputstream.read(j2.p);
			j2.q = new byte[j2.i * j2.j];
			datainputstream.read(j2.q);
			j2.r = new byte[j2.q.length];
			h[byte3] = j2;
			l1 = byte3;
		}

		datainputstream.skip(ai1[byte1] - ai1[l1 + 1]);
		byte byte2 = datainputstream.readByte();
		if (x == null)
			x = new q[byte2][];
		if (y == null)
			y = new byte[byte2][];
		if (z == null)
			z = new byte[byte2][];
		int ai2[] = new int[byte2 + 1];
		for (int k2 = 0; k2 < ai2.length; k2++)
			ai2[k2] = datainputstream.readInt();

		int ai3[] = new int[vector.size()];
		for (int l2 = 0; l2 < ai3.length; l2++)
			ai3[l2] = Integer.parseInt((String)vector.elementAt(l2));

		l1 = -1;
		for (int i3 = 0; i3 < byte2; i3++)
		{
			boolean flag2 = false;
			int j4 = 0;
			do
			{
				if (j4 >= ai3.length)
					break;
				if (ai3[j4] == i3)
				{
					flag2 = true;
					break;
				}
				j4++;
			} while (true);
			if (!flag2 || x[i3] != null)
				continue;
			if (i3 == 0)
				datainputstream.skip(ai2[i3]);
			else
				datainputstream.skip(ai2[i3] - ai2[l1 + 1]);
			w = datainputstream.readByte();
			x[i3] = new q[w];
			for (j4 = 0; j4 < w; j4++)
				x[i3][j4] = q.a(datainputstream);

			j4 = datainputstream.readByte();
			y[i3] = new byte[j4 << 1];
			datainputstream.read(y[i3]);
			byte byte5 = datainputstream.readByte();
			z[i3] = new byte[byte5 << 1];
			datainputstream.read(z[i3]);
			l1 = i3;
		}

		datainputstream.skip(ai2[byte2] - ai2[l1 + 1]);
		byte byte4 = datainputstream.readByte();
		if (F == null)
			F = new q[byte2][];
		if (G == null)
			G = new byte[byte2][];
		if (H == null)
			H = new byte[byte2][][];
		int ai4[] = new int[byte4 + 1];
		for (int k4 = 0; k4 < ai4.length; k4++)
			ai4[k4] = datainputstream.readInt();

		int ai5[] = new int[vector1.size()];
		for (int l4 = 0; l4 < ai5.length; l4++)
			ai5[l4] = Integer.parseInt((String)vector1.elementAt(l4));

		l1 = -1;
		for (int i5 = 0; i5 < byte2; i5++)
		{
			boolean flag3 = false;
			int j5 = 0;
			do
			{
				if (j5 >= ai5.length)
					break;
				if (ai5[j5] == i5)
				{
					flag3 = true;
					break;
				}
				j5++;
			} while (true);
			if (!flag3 || F[i5] != null)
				continue;
			if (i5 == 0)
				datainputstream.skip(ai4[i5]);
			else
				datainputstream.skip(ai4[i5] - ai4[l1 + 1]);
			E = datainputstream.readByte();
			F[i5] = new q[E];
			for (j5 = 0; j5 < E; j5++)
				F[i5][j5] = q.a(datainputstream);

			j5 = datainputstream.readByte();
			G[i5] = new byte[j5 << 1];
			datainputstream.read(G[i5]);
			byte byte6 = datainputstream.readByte();
			H[i5] = new byte[byte6][];
			for (int k5 = 0; k5 < byte6; k5++)
			{
				byte byte7 = datainputstream.readByte();
				H[i5][k5] = new byte[byte7 << 2];
				datainputstream.read(H[i5][k5]);
			}

			l1 = i5;
		}

		datainputstream.skip(ai4[byte4] - ai4[l1 + 1]);
		datainputstream.close();
		break MISSING_BLOCK_LABEL_1412;
		JVM INSTR dup ;
		Exception exception;
		exception;
		printStackTrace();
		break MISSING_BLOCK_LABEL_1412;
		Exception exception1;
		exception1;
		throw exception1;
		e = i1;
		g();
		return;
	}

	private static void g()
	{
		Q = (byte)(240 / h[e].k);
		R = (byte)(320 / h[e].l);
		if (240 % h[e].k != 0)
			Q++;
		if (320 % h[e].l != 0)
			R++;