othello.jad

手机黑白棋

// Decompiled by DJ v2.9.9.60 Copyright 2000 Atanas Neshkov  Date: 2003-6-3 11:54:16
// Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
// Decompiler options: packimports(3) 
// Source File Name:   Othello.java

import java.applet.Applet;
import java.awt.*;
import java.io.PrintStream;

public class Othello extends Applet
    implements Runnable
{

    synchronized void newGame()
    {
        for(int i = 0; i < DIM; i++)
        {
            for(int j = 0; j < DIM; j++)
                grid[i * DIM + j] = 0;

        }

        int k = DIM / 2;
        grid[(k - 1) * DIM + (k - 1)] = 2;
        grid[(k - 1) * DIM + k] = 3;
        grid[k * DIM + (k - 1)] = 3;
        grid[k * DIM + k] = 2;
        offScrGraphics.setColor(Color.white);
        offScrGraphics.fillRect(0, 0, boardSize, boardSize);
        whiteScore = blackScore = 0;
        illegalMove = blackNotMoving = animating = false;
        boardSize = -1;
        repaint();
        if(!whiteMoveFirst)
        {
            blackMove();
            checkScore();
            repaint();
        }
    }

    public synchronized void init()
    {
        aThread = null;
        imageTracker = new MediaTracker(this);
        offScrImage = createImage(400, 400);
        offScrGraphics = offScrImage.getGraphics();
        f = new Font("TimesRoman", 0, 12);
        offScrGraphics.setFont(f);
        fontHeight = getFontMetrics(f).getHeight();
        fontAscent = getFontMetrics(f).getAscent();
        loadImages();
        if(button == null)
        {
            button = new Button("New Game");
            setLayout(new FlowLayout(0));
            add(button);
            choice = new Choice();
            choice.addItem("6");
            choice.addItem("8");
            choice.addItem("10");
            choice.addItem("12");
            choice.addItem("14");
            choice.addItem("16");
            choice.addItem("20");
            add(choice);
            choice.select("10");
        }
        if(moveFirst == null)
        {
            moveFirst = new Choice();
            moveFirst.addItem("Player Move First");
            moveFirst.addItem("Computer Move First");
            add(moveFirst);
            moveFirst.select(0);
            whiteMoveFirst = true;
        }
        newGame();
    }

    public synchronized void loadImages()
    {
        try
        {
            whiteImage = getImage(getDocumentBase(), "p2.gif");
            blackImage = getImage(getDocumentBase(), "p1.gif");
            offScrGraphics.drawImage(whiteImage, 0, 0, this);
            offScrGraphics.drawImage(blackImage, 0, 0, this);
        }
        catch(Exception exception)
        {
            System.out.println(exception);
        }
        imageTracker.addImage(whiteImage, 0);
        imageTracker.addImage(blackImage, 1);
        for(int i = 0; i < 2; i++)
            try
            {
                imageTracker.checkID(i, true);
                imageTracker.waitForID(i);
                showStatus("Loading image P" + i + ".gif");
            }
            catch(Exception exception1)
            {
                System.out.println(exception1);
            }

    }

    public boolean action(Event event, Object obj)
    {
        if(event.target == button)
        {
            newGame();
            return true;
        }
        if(event.target == choice)
        {
            Integer integer = new Integer((String)obj);
            DIM = integer.intValue();
            newGame();
            return true;
        }
        if(event.target == moveFirst)
        {
            if((String)obj == "Computer Move First")
                whiteMoveFirst = false;
            else
                whiteMoveFirst = true;
            return true;
        } else
        {
            return super.action(event, obj);
        }
    }

    public void start()
    {
        aThread = new Thread(this);
        aThread.start();
        imageTracker.statusID(0, true);
        imageTracker.statusID(1, true);
    }

    public void run()
    {
        do
            try
            {
                Thread.sleep(50L);
            }
            catch(Exception _ex) { }
        while(true);
    }

    public void stop()
    {
        if(aThread != null && aThread.isAlive())
            aThread.stop();
    }

    public void destroy()
    {
    }

    public synchronized void blackMove()
    {
        int i = -1;
        byte byte0 = -1;
        int k = -1;
        int l = -1;
        for(int i1 = 0; i1 < DIM; i1++)
        {
            for(int j1 = 0; j1 < DIM; j1++)
                if(grid[i1 * DIM + j1] == 0)
                {
                    int j = howGood(i1, j1, 3, 2);
                    if(i < j && j > 0)
                    {
                        i = j;
                        k = i1;
                        l = j1;
                    }
                }

        }

        blackNotMoving = false;
        if(i > 0)
        {
            grid[k * DIM + l] = 3;
            turnPlys(k, l, 3, 2, 4);
            return;
        } else
        {
            blackNotMoving = true;
            return;
        }
    }

    public synchronized int howGood(int i, int j, int k, int l)
    {
        int j1 = 0;
        int i1 = 0;
        int l1;
        for(l1 = j + 1; l1 < DIM; l1++)
        {
            if(grid[i * DIM + l1] == l)
            {
                i1++;
                continue;
            }
            if(grid[i * DIM + l1] == k)
                break;
            if(grid[i * DIM + l1] != 0)
                continue;
            i1 = 0;
            break;
        }

        if(l1 >= DIM)
            i1 = 0;
        j1 += i1;
        i1 = 0;
        for(l1 = j - 1; l1 >= 0; l1--)
        {
            if(grid[i * DIM + l1] == l)
            {
                i1++;
                continue;
            }
            if(grid[i * DIM + l1] == k)
                break;
            if(grid[i * DIM + l1] != 0)
                continue;
            i1 = 0;
            break;
        }

        if(l1 <= -1)
            i1 = 0;
        j1 += i1;
        i1 = 0;
        int k1;
        for(k1 = i + 1; k1 < DIM; k1++)
        {
            if(grid[k1 * DIM + j] == l)
            {
                i1++;
                continue;
            }
            if(grid[k1 * DIM + j] == k)
                break;
            if(grid[k1 * DIM + j] != 0)
                continue;
            i1 = 0;
            break;
        }

        if(k1 >= DIM)
            i1 = 0;
        j1 += i1;
        i1 = 0;
        for(k1 = i - 1; k1 >= 0; k1--)
        {
            if(grid[k1 * DIM + j] == l)
                i1++;
            if(grid[k1 * DIM + j] == k)
                break;
            if(grid[k1 * DIM + j] != 0)
                continue;
            i1 = 0;
            break;
        }

        if(k1 <= -1)
            i1 = 0;
        j1 += i1;
        i1 = 0;
        int i2 = j + 1;
        int j2;
        for(j2 = i - 1; i2 >= 0 && j2 >= 0; j2--)
        {
            if(grid[j2 * DIM + i2] == l)
                i1++;
            if(grid[j2 * DIM + i2] == k)
                break;
            if(grid[j2 * DIM + i2] == 0)
            {
                i1 = 0;
                break;
            }
            i2++;
        }

        if(i2 >= DIM || j2 <= -1)
            i1 = 0;
        j1 += i1;
        i1 = 0;
        i2 = j + 1;
        for(j2 = i + 1; i2 < DIM && j2 < DIM; j2++)
        {
            if(grid[j2 * DIM + i2] == l)
            {
                i1++;
            } else
            {
                if(grid[j2 * DIM + i2] == k)
                    break;
                if(grid[j2 * DIM + i2] == 0)
                {
                    i1 = 0;
                    break;
                }
            }
            i2++;
        }

        if(i2 >= DIM || j2 >= DIM)
            i1 = 0;
        j1 += i1;
        i1 = 0;
        i2 = j - 1;
        for(j2 = i - 1; i2 >= 0 && j2 >= 0; j2--)
        {
            if(grid[j2 * DIM + i2] == l)
            {
                i1++;
            } else
            {
                if(grid[j2 * DIM + i2] == k)
                    break;
                if(grid[j2 * DIM + i2] == 0)
                {
                    i1 = 0;
                    break;
                }
            }
            i2--;
        }

        if(i2 <= -1 || j2 <= -1)
            i1 = 0;
        j1 += i1;
        i1 = 0;
        i2 = j - 1;
        for(j2 = i + 1; i2 < DIM && j2 < DIM; j2++)
        {
            if(grid[j2 * DIM + i2] == l)
            {
                i1++;
            } else
            {
                if(grid[j2 * DIM + i2] == k)
                    break;
                if(grid[j2 * DIM + i2] == 0)
                {
                    i1 = 0;
                    break;
                }
            }
            i2--;
        }

        if(i2 <= -1 || j2 >= DIM)
            i1 = 0;
        j1 += i1;
        return j1;
    }

    public synchronized void turnPlys(int i, int j, int k, int l, int i1)
    {
        boolean flag = false;
        for(int j5 = j + 1; j5 < DIM; j5++)
        {
            int j1 = i * DIM + j5;
            if(grid[j1] == l)
                continue;
            if(grid[j1] == k)
                flag = true;
            break;
        }

        if(flag)
        {
            for(int k5 = j + 1; k5 < DIM; k5++)
            {
                int k1 = i * DIM + k5;
                if(grid[k1] == l)
                {
                    grid[k1] = i1;
                    continue;