h.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 h
{

	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 h 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 p t[];
	private byte u[];
	private byte v[];
	private static byte w;
	private static p x[][];
	private static byte y[][];
	private static byte z[][];
	private byte A;
	private p B[];
	private byte C[];
	private byte D[][];
	private static byte E;
	private static p 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 h()
	{
	}

	public static final void a(int i1)
	{
		h = new h[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 (((y) (obj)).f[4] == 0)
							{
								((y) (obj)).a(g1, ((y) (obj)).f[8] - I, ((y) (obj)).f[9] - J);
								continue;
							}
							if (((y) (obj)).f[4] == 100)
							{
								S[U * 3 + 0] = ((y) (obj)).f[1];
								S[U * 3 + 1] = (short)(((y) (obj)).f[8] - I);
								S[U * 3 + 2] = (short)(((y) (obj)).f[9] - J);
								U++;
								if (U < f);
							} else
							{
								T[V * 3 + 0] = ((y) (obj)).f[1];
								T[V * 3 + 1] = (short)(((y) (obj)).f[8] - I);
								T[V * 3 + 2] = (short)(((y) (obj)).f[9] - J);
								V++;
							}
						}

					}
				if ((k1 = h[e].r[j1]) >= -87)
					continue;
				int l1 = k1 + 127;
				v v1;
				if (((v1 = v.c[l1]).a[2] & 2) == 2)
				{
					v1.a(g1, v.c[l1].a[6] - I, v.c[l1].a[7] - J);
				} else
				{
					W[X++] = l1;
					W[X++] = v.c[l1].a[6] - I;
					W[X++] = v.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;
			((y) (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;
			((y) (obj2)).a(g1, S[k3 * 3 + 1], S[k3 * 3 + 2]);
		}

		for (int l3 = 0; l3 < X;)
			v.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]);
			h h1;
			(h1 = new h()).i = (short)(datainputstream.readByte() & 0xff);
			h1.j = (short)(datainputstream.readByte() & 0xff);
			h1.k = datainputstream.readByte();
			h1.l = datainputstream.readByte();
			h1.m = (short)(h1.i * h1.k);
			h1.n = (short)(h1.j * h1.l);
			h1.s = datainputstream.readByte();
			h1.A = datainputstream.readByte();
			if (!vector.contains(String.valueOf(h1.s)))
			{
				boolean flag = false;
				int i3 = 0;
				do
				{
					if (i3 >= vector.size())
						break;
					int k3 = Integer.parseInt((String)vector.elementAt(i3));
					if (h1.s < k3)
					{
						vector.insertElementAt(String.valueOf(h1.s), i3);
						flag = true;
						break;
					}
					i3++;
				} while (true);
				if (!flag)
					vector.addElement(String.valueOf(h1.s));
			}
			if (!vector1.contains(String.valueOf(h1.A)))
			{
				boolean flag1 = false;
				int j3 = 0;
				do
				{
					if (j3 >= vector1.size())
						break;
					int l3 = Integer.parseInt((String)vector1.elementAt(j3));
					if (h1.A < l3)
					{
						vector1.insertElementAt(String.valueOf(h1.A), j3);
						flag1 = true;
						break;
					}
					j3++;
				} while (true);
				if (!flag1)
					vector1.addElement(String.valueOf(h1.A));
			}
			h1.o = new byte[h1.i * h1.j];
			datainputstream.read(h1.o);
			h1.p = new byte[h1.i * h1.j];
			datainputstream.read(h1.p);
			h1.q = new byte[h1.i * h1.j];
			datainputstream.read(h1.q);
			h1.r = new byte[h1.q.length];
			h[byte3] = h1;
			l1 = byte3;
		}

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

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

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

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

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

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

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

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

			l1 = l4;
		}

		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++;
		Q++;
		R++;
		ag = true;
		i();
	}

	public static final byte a(byte byte0, int i1, int j1)
	{
		int k1 = (j1 / h[e].k) * h[e].i + i1 / h[e].l;
		switch (byte0)
		{
		case 0: // '\0'
			return h[e].o[k1];