firlogic.java

非常好的JAVA编程的例子

        int ed[] = expandedIn8D(player, row, col);
        for(int d = 0; d < 4; d++)
        {
            if(d == exceptDirection)
                continue;
            if(table[row][col] == player)
            {
                int nConnect = cd[d] + cd[d + 4] + 1;
                int nFree1 = ed[d] - cd[d];
                int nFree2 = ed[d + 4] - cd[d + 4];
                boolean b4S = nConnect >= 4 && (nFree1 >= 1 || nFree2 >= 1);
                boolean b3B = nConnect >= 3 && nFree1 >= 1 && nFree2 >= 1;
                if(b4S || b3B)
                {
                    dFond = d;
                    break;
                }
            }
            if(table[row][col] != 0)
                continue;
            int nFree1 = ed[d] - cd[d];
            int nFree2 = ed[d + 4] - cd[d + 4];
            boolean b2N1 = cd[d] >= 2 && cd[d + 4] >= 1 || cd[d] >= 1 && cd[d + 4] >= 2;
            boolean bSFree = nFree1 >= 1 && nFree2 >= 1;
            if(!b2N1 || !bSFree)
                continue;
            dFond = d;
            break;
        }

        return dFond;
    }

    private int find4S_3B_2N1B(int player, int exceptDirection, int rTest, int cTest, boolean only4S)
    {
        int dFond = -1;
        int rMin = rTest - 3;
        if(rMin < 0)
            rMin = 0;
        int rMax = rTest + 3;
        if(rMax > boardSize)
            rMax = boardSize;
        int cMin = cTest - 3;
        if(cMin < 0)
            cMin = 0;
        int cMax = cTest + 3;
        if(cMax > boardSize)
            cMax = boardSize;
        for(int r = rMin; r < rMax; r++)
        {
            for(int c = cMin; c < cMax; c++)
            {
                if(table[r][c] != player && table[r][c] != 0)
                    continue;
                if(only4S)
                    dFond = find4SAt(r, c, player, exceptDirection);
                else
                    dFond = find4S_3B_2N1BAt(r, c, player, exceptDirection);
                if(dFond != -1)
                    break;
            }

            if(dFond != -1)
               break;
        }

        return dFond;
    }

    private Dot to5L(int player)
    {
        if(playerCounter[player] < 4)
            return null;
        int maxGain = 0;
        Dot dot = null;
        for(int r = 0; r < boardSize; r++)
        {
            for(int c = 0; c < boardSize; c++)
            {
                int gain = to5LAt(player, r, c);
                if(gain > maxGain || gain > 0 && gain == maxGain && randomTrue())
                {
                    maxGain = gain;
                    dot = new Dot(r, c);
                }
            }

        }

        return dot;
    }

    private int to5LAt(int player, int row, int col)
    {
        int lines = 0;
        int otherGain = 0;
        if(table[row][col] == 0)
        {
            int cd[] = connectedIn8D(player, row, col);
            int ed[] = expandedIn8D(player, row, col);
            for(int i = 0; i < 4; i++)
                if(ed[i] + ed[i + 4] + 1 >= 5)
                {
                    int l = cd[i] + cd[i + 4] + 1;
                    if(l >= 5)
                        lines++;
                    else
                        otherGain += 2 ^ l;
                }

        }
        return lines > 0 ? lines * 32 + otherGain : 0;
    }

    private int[] expandedIn8D(int player, int row, int col)
    {
        int ed[] = new int[8];
        for(int d = 0; d < 8; d++)
            ed[d] = expandedIn1D(player, row, col, d);

        return ed;
    }

    private int expandedIn1D(int player, int row, int col, int direction)
    {
        int n = 0;
        int cn = 0;
        Dot d = new Dot(row, col);
        while(cn < 4) 
        {
            d.copyFrom(moveOneStep(d, direction));
            if(!d.isInBoard(boardSize))
                break;
            int p = table[d.row][d.col];
            if(p == 0)
                cn++;
            if(p != player && p != 0)
                break;
            n++;
        }
        return n;
    }

    private Dot maxGainedDot()
    {
        Dot dotWithMaxGain = null;
        int maxGain = 0;
        for(int r = 0; r < boardSize; r++)
        {
            for(int c = 0; c < boardSize; c++)
            {
                int gain = gainAt(r, c);
                if(gain > maxGain || gain > 0 && gain == maxGain && randomTrue())
                {
                    maxGain = gain;
                    dotWithMaxGain = new Dot(r, c);
                }
            }

        }

        return dotWithMaxGain;
    }

    private int gainAt(int row, int col)
    {
        if(table[row][col] == 0)
        {
            int gain = 0;
            for(int d = 0; d < 8; d++)
            {
                int gd = gainAtDirection(row, col, d);
                if(gd == 0)
                    gain >>= 2;
                else
                    gain += gd;
            }

            if(gain < 1)
                gain = 1;
            return gain;
        } else
        {
            return 0;
        }
    }

    private int gainAtDirection(int row, int col, int direction)
    {
        int gain = 0;
        Dot d = new Dot(row, col);
        int step = 0;
        do
        {
            d.copyFrom(moveOneStep(d, direction));
            step++;
            if(!d.isInBoard(boardSize))
                break;
            int player = table[d.row][d.col];
            if(player == 2)
                break;
            int gainByStone = player == 1 ? 5 : 1;
            gain += gainByStep(step) * gainByStone;
        } while(true);
        return gain;
    }

    private int gainByStep(int step)
    {
        int gain = (boardSize - step) / 2;
        if(gain < 1)
            gain = 1;
        return gain;
    }

    private int exist2N1(int row, int col, int player, int exceptDirection)
    {
        int cd[] = connectedIn8D(player, row, col);
        int ed[] = expandedIn8D(player, row, col);
        int existDirection = -1;
        for(int i = 0; i < 4; i++)
        {
            if(i == exceptDirection || (cd[i] < 2 || cd[i + 4] < 1) && (cd[i] < 1 || cd[i + 4] < 2) || (ed[i] - cd[i]) + (ed[i + 4] - cd[i + 4]) <= 0)
                continue;
            existDirection = i;
            break;
        }

        return existDirection;
    }

    private int checkFiveInRow(int row, int col, int n, int exceptDirection)
    {
        int player = table[row][col];
        int cd[] = connectedIn8D(player, row, col);
        int ed[] = expandedIn8D(player, row, col);
        int existDirection = -1;
        for(int i = 0; i < 4;  i++)
        {                
            if(i == exceptDirection || cd[i] + cd[i + 4] + 1 < n || (ed[i] - cd[i]) + (ed[i + 4] - cd[i + 4]) < 0)
                continue;
               

            existDirection = i;
            break;
        }

        return existDirection;
    }

    private int[] connectedIn8D(int player, int row, int col)
    {
        int cd[] = new int[8];
        for(int d = 0; d < 8; d++)
            cd[d] = connectedIn1D(player, row, col, d);

        return cd;
    }

    private int connectedIn1D(int player, int row, int col, int direction)
    {
        int n = 0;
        Dot d = new Dot(row, col);
        do
        {
            d.copyFrom(moveOneStep(d, direction));
            if(d.isInBoard(boardSize) && table[d.row][d.col] == player)
                n++;
            else
                return n;
        } while(true);
    }

    private Dot moveOneStep(Dot d, int direction)
    {
        int r = d.row;
        int c = d.col;
        switch(direction)
        {
        case 0: 
            c++;
            break;

        case 1: 
            r--;
            c++;
            break;

        case 2: 
            r--;
            break;

        case 3: 
            r--;
            c--;
            break;

        case 4: 
            c--;
            break;

        case 5: 
            r++;
            c--;
            break;

        case 6: 
            r++;
            break;

        case 7: 
            r++;
            c++;
            break;
        }
        return new Dot(r, c);
    }

    private boolean randomTrue()
    {
        return rndNum.nextInt() % 2 == 0;
    }


}