othello.java

小游戏,,,也挺好的

//filename Othello.java;
//filename Othello.class;

import java.applet.*;
import java.awt.*;
import java.awt.image.*;
import java.awt.event.*;
import java.io.PrintStream;
import java.net.URL;

public class Othello extends Applet implements Runnable,ActionListener,MouseListener
{
  private MediaTracker imageTracker;
  private Image redImage;
  private Image blueImage;
  private Image offScrImage;
  private Graphics offScrGraphics;
  private Font f;
  private int fontHeight;
  private int fontAscent;
  private Button button;
  private int buttonHeight;
  private Choice choice;
  private Choice moveFirst;
  private boolean redMoveFirst;
  private boolean illegalMove;
  private boolean blueNotMoving;
  private boolean animating;
  private int redScore;
  private int blueScore;
  private Thread aThread;
  private static final int EMPTY = 0;
  private static final int RED = 2;
  private static final int BLUE = 3;
  private static final int BLUE_TEMP = 4;
  private static final int RED_TEMP = 5;
  private static final int VERYGOOD = 9999;
  private static int DIM = 10;
  private int boardSize = 400;
  private int[] grid = new int[400];

  private synchronized void newGame()
  {
    DIM = (new Integer((String) choice.getSelectedItem())).intValue();
    int whoMoveFirst=moveFirst.getSelectedIndex();
    if(whoMoveFirst==0)
   	  redMoveFirst = true;
    else
   		redMoveFirst = false;
       		
    int int1;
    int int2;
    for( int1 = 0; int1 < DIM; ++int1 )
    {
      for( int2 = 0; int2 < DIM; ++int2 )
        grid[int1 * DIM + int2] = EMPTY;
    }
    int2 = DIM / 2;
    grid[(int2 - 1) * DIM + (int2 - 1)] = RED;
    grid[(int2 - 1) * DIM + int2] = BLUE;
    grid[int2 * DIM + (int2 - 1)] = BLUE;
    grid[int2 * DIM + int2] = RED;
    offScrGraphics.setColor( Color.white );
    offScrGraphics.fillRect( 0, 0, boardSize, boardSize );
    redScore = blueScore = 0;
    illegalMove = blueNotMoving = animating = false;
    boardSize = -1;
    repaint();
    if( !redMoveFirst )
    {
      blueMove();
      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" );
      button.addActionListener(this);
      setLayout( new FlowLayout( ) );
      add( button );
      choice = new Choice();
      choice.addItem( "6" );
      choice.addItem( "8" );
      choice.addItem( "10" );
      choice.addItem( "12" );
      choice.addItem( "14" );
      add( choice );
      choice.select( "10" );
    }
    if( moveFirst == null )
    {
      moveFirst = new Choice();
      moveFirst.addItem( "You Move First" );
      moveFirst.addItem( "Computer Move First" );
      add( moveFirst );
      moveFirst.select( 0 );
      redMoveFirst = true;
    }
    addMouseListener(this);
    newGame();
  }

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

  public void start()
  {
    aThread = new Thread( this );
    aThread.start();
    imageTracker.statusID( 0, true );
    imageTracker.statusID( 1, true );
  }
    
  public void run()
  {
    for( ;; )
    {
      try
      {
        Thread.sleep( 50L );
        continue;
      }
      catch( Exception unused1 )
      {
        continue;
      }
    }
  }

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

  public void destroy()
  {
  }
    
  public synchronized void blueMove()
  {
    int int1 = -1;
    int int2 = -1;
    int int3 = -1;
    int int4 = -1;
    int int5;

    for( int5 = 0; int5 < DIM; ++int5 )
    {
      int int6;
      for( int6 = 0; int6 < DIM; ++int6 )
      {
        if( grid[int5 * DIM + int6] == 0 )
        {
          int2 = howGood( int5, int6, 3, 2 );
          if( int1 < int2 && int2 > 0 )
          {
            int1 = int2;
            int3 = int5;
            int4 = int6;
          }
        }
      }
    }
    blueNotMoving = false;
    if( int1 > 0 )
    {
      grid[int3 * DIM + int4] = BLUE;
      turnPlys( int3, int4, 3, 2, 4 );
    }
    else
      blueNotMoving = true;
  }
    
  public synchronized int howGood(int int1, int int2, int int3, int int4)
  {
    int int6 = 0;
    int int5 = 0;
    int int7;
    int int8;
    int int9;
    int int10;
    for( int8 = int2 + 1; int8 < DIM; ++int8 )
    {
      if( grid[int1 * DIM + int8] == int4 )
        ++int5;
      else
      {
        if( grid[int1 * DIM + int8] == int3 )
          break;
        if( grid[int1 * DIM + int8] == 0 )
        {
          int5 = 0;
          break;
        }
      }
    }
    if( int8 >= DIM )
      int5 = 0;
    int6 += int5;
    int5 = 0;
    for( int8 = int2 - 1; int8 >= 0; --int8 )
    {
      if( grid[int1 * DIM + int8] == int4 )
        ++int5;
      else
      {
        if( grid[int1 * DIM + int8] == int3 )
    	    break;
        if( grid[int1 * DIM + int8] == 0 )
        {
          int5 = 0;
          break;
        }
      }
    }
    if( int8 <= -1 )
      int5 = 0;
    int6 += int5;
    int5 = 0;
    for( int7 = int1 + 1; int7 < DIM; ++int7 )
    {
      if( grid[int7 * DIM + int2] == int4 )
        ++int5;
      else
      {
        if( grid[int7 * DIM + int2] == int3 )
          break;
        if( grid[int7 * DIM + int2] == 0 )
        {
          int5 = 0;
          break;
        }
      }
    }
    if( int7 >= DIM )
      int5 = 0;
    int6 += int5;
    int5 = 0;
    int7 = int1 - 1;
    while( int7 >= 0 )
    {
      if( grid[int7 * DIM + int2] == int4 )
        ++int5;
      if( grid[int7 * DIM + int2] == int3 )
        break;
      if( grid[int7 * DIM + int2] == 0 )
      {
        int5 = 0;
        break;
      }
      else
        --int7;
    }
    if( int7 <= -1 )
      int5 = 0;
    int6 += int5;
    int5 = 0;
    int9 = int2 + 1;
    int10 = int1 - 1;
    while( int9 >= 0 && int10 >= 0 )
    {
      if( grid[int10 * DIM + int9] == int4 )
        ++int5;
      if( grid[int10 * DIM + int9] == int3 )
        break;
      if( grid[int10 * DIM + int9] == 0 )
      {
        int5 = 0;
        break;
      }
      else
      {
        ++int9;
        --int10;
      }
    }
    if( int9 >= DIM || int10 <= -1 )
      int5 = 0;
    int6 += int5;
    int5 = 0;
    int9 = int2 + 1;
    for( int10 = int1 + 1; int9 < DIM && int10 < DIM; ++int10 )
    {
      if( grid[int10 * DIM + int9] == int4 )
        ++int5;
      else
      {
        if( grid[int10 * DIM + int9] == int3 )
          break;
        if( grid[int10 * DIM + int9] == 0 )
        {
          int5 = 0;
          break;
        }
      }
      ++int9;
    }
    if( int9 >= DIM || int10 >= DIM )
      int5 = 0;
    int6 += int5;
    int5 = 0;
    int9 = int2 - 1;
    for( int10 = int1 - 1; int9 >= 0 && int10 >= 0; --int10 )
    {
      if( grid[int10 * DIM + int9] == int4 )
        ++int5;
      else
      {
        if( grid[int10 * DIM + int9] == int3 )
          break;
        if( grid[int10 * DIM + int9] == 0 )
        {
          int5 = 0;
          break;
        }
      }
      --int9;
    }
    if( int9 <= -1 || int10 <= -1 )
      int5 = 0;
    int6 += int5;
    int5 = 0;
    int9 = int2 - 1;
    for( int10 = int1 + 1; int9 < DIM && int10 < DIM; ++int10 )
    {
      if( grid[int10 * DIM + int9] == int4 )
        ++int5;
      else
      {
        if( grid[int10 * DIM + int9] == int3 )
          break;
        if( grid[int10 * DIM + int9] == 0 )
        {
          int5 = 0;
          break;
        }
      }
      --int9;
    }
    if( int9 <= -1 || int10 >= DIM )
      int5 = 0;
    int6 += int5;
    return int6;
  }

  public synchronized void turnPlys(int int1, int int2, int int3, int int4, int int5)
  {
    int int6 = 0;
    int int8 = int2 + 1;
    int int7;
    int int9;
    int int10;
    int int11;
    int int12;
    int int13;
    int int14;
    int int15;
    int int16;
    int int17;
    int int18;
    int int19;

    while( int8 < DIM )
    {
      int7 = int1 * DIM + int8;
      if( grid[int7] != int4 )
      {
        if( grid[int7] == int3 )
          int6 = 1;