thinkthread.java

五子棋,J2ME小游戏

// Decompiled by DJ v2.9.9.61 Copyright 2000 Atanas Neshkov  Date: 2004-12-21 16:10:42
// Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
// Decompiler options: packimports(3) 

package igs;

import java.io.PrintStream;
import java.util.Random;
import java.util.Vector;

// Referenced classes of package igs:
//            OneStep, Pattern, BoardCanvas

public class ThinkThread extends Thread
{

    public ThinkThread(byte abyte0[][], BoardCanvas boardcanvas)
    {
        board = abyte0;
        boardCanvas = boardcanvas;
    }

    static boolean nearToExistedStones(int i, int j, byte abyte0[][])
    {
        for(int k = Math.max(0, i - 1); k <= Math.min(14, i + 1); k++)
        {
            for(int l = Math.max(0, j - 1); l <= Math.min(14, j + 1); l++)
                if(abyte0[k][l] != 0)
                    return true;

        }

        return false;
    }

    public void run()
    {
        if(boardCanvas.side != computerSide)
            return;
        boolean flag = false;
        boolean flag1 = false;
        byte abyte0[][] = new byte[15][];
        byte abyte1[][] = new byte[15][];
        byte abyte2[][] = new byte[15][];
        for(int i1 = 0; i1 < 15; i1++)
        {
            abyte0[i1] = new byte[15];
            abyte1[i1] = new byte[15];
            abyte2[i1] = new byte[15];
        }

        for(int i = 0; i < 15; i++)
        {
            for(int k = 0; k < 15; k++)
            {
                abyte0[i][k] = board[i][k];
                abyte1[i][k] = 0;
                abyte2[i][k] = 0;
            }

        }

        Vector vector = new Vector();
        for(int j = 0; j < 15; j++)
        {
            for(int l = 0; l < 15; l++)
                if(nearToExistedStones(j, l, board) && board[j][l] == 0)
                {
                    OneStep onestep = new OneStep();
                    onestep.x = j;
                    onestep.y = l;
                    abyte0[j][l] = computerSide;
                    onestep.value = -dynamicEval(abyte0, userSide, j, l, 0);
                    abyte0[j][l] = 0;
                    vector.addElement(onestep);
                }

        }

        sortFirstGroup(vector);
        int j1 = ((OneStep)vector.elementAt(0)).value;
        int k1 = 0;
        k1 = 0;
        do
        {
            if(k1 >= vector.size())
                break;
            OneStep onestep1 = (OneStep)vector.elementAt(k1);
            if(j1 != onestep1.value)
                break;
            k1++;
        } while(true);
        OneStep onestep2 = (OneStep)vector.elementAt(Math.abs(rand.nextInt()) % k1);
        board[onestep2.x][onestep2.y] = computerSide;
        boardCanvas.cursorX = onestep2.x;
        boardCanvas.cursorY = onestep2.y;
        boardCanvas.repaint();
        boardCanvas.checkWin(board, onestep2.x, onestep2.y);
        boardCanvas.side = userSide;
    }

    void printBoard(byte abyte0[][])
    {
        char ac[] = {
            '.', 'O', '*'
        };
        for(int i = 0; i < 15; i++)
        {
            for(int j = 0; j < 15; j++)
                System.out.print(ac[abyte0[j][i]]);

            System.out.println();
        }

    }

    int dynamicEval(byte abyte0[][], int i, int j, int k, int l)
    {
        byte abyte1[][] = abyte0;
        if(l == 0)
            return staticEval(abyte0, (byte)i, j, k);
        int i2;
        Vector vector = new Vector();
        for(int i1 = 0; i1 < 15; i1++)
        {
            for(int k1 = 0; k1 < 15; k1++)
                if(nearToExistedStones(i1, k1, abyte0) && abyte0[i1][k1] == 0)
                {
                    OneStep onestep = new OneStep();
                    onestep.x = i1;
                    onestep.y = k1;
                    abyte1[i1][k1] = (byte)i;
                    onestep.value = -staticEval(abyte1, (byte)(3 - i), i1, k1);
                    abyte1[i1][k1] = 0;
                    vector.addElement(onestep);
                }

        }

        int j1 = vector.size();
        j1 = Math.min(j1, 2);
        sort(vector, j1);
        boolean flag = false;
        i2 = -65535;
        for(int l1 = 0; l1 < j1; l1++)
        {
            OneStep onestep1 = (OneStep)vector.elementAt(l1);
            int j2 = onestep1.x;
            int k2 = onestep1.y;
            abyte1[j2][k2] = (byte)i;
            int l2 = -dynamicEval(abyte0, 3 - i, j2, k2, l - 1);
            abyte1[j2][k2] = 0;
            onestep1.value = l2;
            if(i2 < l2)
                i2 = l2;
        }

        return i2;
//        Exception exception;
//        exception;
//        exception.printStackTrace();
//        return 0;
    }

    int staticEval(byte abyte0[][], byte byte0, int i, int j)
    {
        return staticEval1(abyte0, byte0, i, j);
    }

    int staticEval0(byte abyte0[][], byte byte0)
    {
        int i;
        i = 0;
        for(int j = 0; j < 15; j++)
        {
            int l1 = 1;
            int j3 = 0;
            for(int l4 = 0; l4 < 15; l4++)
            {
                byte byte1 = abyte0[j][l4];
                if(byte1 != 0 && byte1 == j3)
                    l1++;
                else
                if(byte1 != j3 && j3 != 0)
                {
                    if(l1 > 6)
                        l1 = 6;
                    int j7 = 0;
                    if(l4 - (l1 + 1) >= 0 && abyte0[j][l4 - (l1 + 1)] == 0)
                        j7++;
                    if(abyte0[j][l4] == 0)
                        j7++;
                    if(j3 == byte0)
                        i += dValuesSelf[j7][l1];
                    else
                        i += dValuesEnemy[j7][l1];
                    l1 = 1;
                }
                j3 = byte1;
            }

        }

        for(int k = 0; k < 15; k++)
        {
            int i2 = 1;
            int k3 = 0;
            for(int i5 = 0; i5 < 15; i5++)
            {
                byte byte2 = abyte0[i5][k];
                if(byte2 != 0 && byte2 == k3)
                    i2++;
                else
                if(byte2 != k3 && k3 != 0)
                {
                    if(i2 > 6)
                        i2 = 6;
                    int k7 = 0;
                    if(i5 - (i2 + 1) >= 0 && abyte0[i5 - (i2 + 1)][k] == 0)
                        k7++;
                    if(abyte0[i5][k] == 0)
                        k7++;
                    if(k3 == byte0)
                        i += dValuesSelf[k7][i2];
                    else
                        i += dValuesEnemy[k7][i2];
                    i2 = 1;
                }
                k3 = byte2;
            }

        }

        for(int l = 0; l < 15; l++)
        {
            int j2 = 1;
            int l3 = 0;
            int j5 = 0;
            for(int j6 = l; j5 < 15 && j6 < 15; j6++)
            {
                byte byte3 = abyte0[j6][j5];
                if(byte3 != 0 && byte3 == l3)
                    j2++;
                else
                if(byte3 != l3 && l3 != 0)
                {
                    if(j2 > 6)
                        j2 = 6;
                    int l7 = 0;
                    if(j5 - (j2 + 1) >= 0 && j6 - (j2 + 1) >= 0 && abyte0[j6 - (j2 + 1)][j5 - (j2 + 1)] == 0)
                        l7++;