Java

本类阅读TOP10

·使用MyEclipse开发Struts框架的Hello World!(录像1)
·hibernate配置笔记
·AOP编程入门--Java篇
·linux下Tomcat 5.0.20 与 Apache 2 安装/集成/配置
·在win2003下整合了整合Tomcat5.5+ apache_2.0.53+ mod_jk_2.0.47.dll
·构建Linux下IDE环境--Eclipse篇
·Jsp 连接 mySQL、Oracle 数据库备忘(Windows平台)
·ASP、JSP、PHP 三种技术比较
·Tomcat5.5.9的安装配置
·AWT GUI 设计笔记(二)

分类导航
VC语言Delphi
VB语言ASP
PerlJava
Script数据库
其他语言游戏开发
文件格式网站制作
软件工程.NET开发
拼图的人工智能算法的分析,等待的是思考

作者:未知 来源:月光软件站 加入时间:2005-2-28 月光软件站

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.io.*;

/**************************************************
* 类功能简介:游戏场景的实现 2004-03-05
* @author gowithfox@163.com
* @version 1.01
**************************************************/

public class GamePlat extends Canvas //implements KeyListener
{
  public static final int BOARDNUM = 3;         //可以活动的元素
  public static final int WIDACTION = 201;      //设置拼图游戏活动场景图片的宽度
  public static final int HEIACTION = 201;      //设置拼图游戏活动场景图片的高度
  public static final int WID = 281;            //设置整个GamePlat的宽度
  public static final int HEI = 281;            //设置整个GamePlat的高度

  private int [][] boardArray;                  //游戏里面的可以变换的数组

  private final int [][] WINARRAY = {{0,1,2},   //设定游戏成功的条件
                                     {3,4,5},
                                     {6,7,8}};
  private int stepNum = 0;                      //记录玩家走走过的步骤

  private Random rand = null;
  private Toolkit tk = null;
  private Image spiriteImage = null;
  private int x8 = BOARDNUM-1,y8 = x8;

  /**************************************************
  * 构造方法:构造整个游戏最重要的数据
  ***************************************************/

  public GamePlat()
  {
    tk = getToolkit();
    rand = new Random();
    boardArray = new int[BOARDNUM][BOARDNUM];
    try
    {
      spiriteImage = tk.createImage("photo.jpg");
    }
    catch (Exception ex)
    {
      System.out.println(ex.getMessage());
    }
    init();
  }

  /**************************************************
  * 方法介绍:初始化记录步骤和并随机生成每个数组里面的值
  * 输入参数:无
  * 返回类型:无
  ****************************************************/

  public void init()
  {
    stepNum = 0;
    generateBoardNum();
  }

  /**************************************************
  * 方法介绍:随机生成每个数组里面的值
  * 输入参数:无
  * 返回类型:无
  ****************************************************/

  private void generateBoardNum()
  {
    int k=0;
    for (int i = 0 ; i < 3 ; i++)
      for (int j = 0 ; j < 3 ; j++)
      {
        boardArray[i][j] = k++;
      }
      for (int i = 0 ; i < 100 ; i++)
      {
        int x1,y2,x2,y1,temp;
        x1=Math.abs(rand.nextInt()%3);
        x2=Math.abs(rand.nextInt()%3);
        y1=Math.abs(rand.nextInt()%3);
        y2=Math.abs(rand.nextInt()%3);
        temp = boardArray[x1][y1];
        boardArray[x1][y1]=boardArray[x2][y2];
        boardArray[x2][y2]=temp;
      }
      int x=0,y=0,temp;
      for (int i = 0 ; i < 3 ; i++)
        for(int j = 0 ; j < 3 ; j++)
        {
          if(boardArray[i][j]==8)
          {
            x=i;
            y=j;
            System.out.println("Now the X"+i+" & Y"+j+" & boardArrayVALUE is : X : "+x+" Y : "+y+" BV : "+boardArray[i][j]);
            break;
          }
        }
      System.out.println("Now the X2 & Y2 & boardArrayVALUE is : X : 2 Y : 2 BV : "+boardArray[2][2]);
      if(x == 2 && y == 2)
        return;
      else
      {
        temp = boardArray[2][2];
        boardArray[2][2]=8;
        boardArray[x][y]=temp;
      }
      //cheat();
      testArray(boardArray);
    }

    /**************************************************
     * 方法介绍:作弊,用来测试人工智能
     * 输入参数:无
     * 返回类型:无
     ****************************************************/
    public void cheat()
    {
      System.out.println("CHEAT:)");
      int k = 0;
      for (int i = 0 ; i < BOARDNUM ; i++)
      {
        for (int j = 0; j < BOARDNUM; j++)
        {
          boardArray[i][j] = k++;
        }
      }

      boardArray [0][2]=2;
      boardArray [1][2]=8;
      boardArray [2][2]=5;
      for (int i = 0 ; i < BOARDNUM ; i++)
      {
        for (int j = 0; j < BOARDNUM; j++)
        {
          System.out.print(boardArray[i][j] + " ");
        }
        System.out.println();
      }


    }

    /**************************************************
    * 方法介绍:int [][]引用的数组中的值按一定格式输出
    * 输入参数:int [][]
    * 返回类型:无
    ****************************************************/

   private void testArray(int [][] args)
   {
     System.out.println("TEST THE ARRAY");
     for (int i = 0; i < BOARDNUM; i++)
     {
       for (int j = 0; j < BOARDNUM; j++)
       {
         System.out.print( args[i][j] +" ");
       }
       System.out.println();
     }
   }
   /**************************************************
    * 方法介绍:让存储8的元素和它下面的元素交换,这种方法完
    * 成得方法效率可能稍差,但这是为了能够扩展人工智能而不
    * 得不采取得方法,因为如果不知道8的位置,人工智能就不
    * 能实现
    * 输入参数:int [][]
    * 返回类型:int [][]
    ****************************************************/

   private int [][] updateDown(int [][] args)
   {
     int [][] tempArr = new int [BOARDNUM][BOARDNUM];
     for (int i = 0 ; i < BOARDNUM ; i++)
       for (int j = 0 ; j < BOARDNUM ; j++)
       {
         tempArr [i][j] = args[i][j];
       }
     int x8 =0,y8=0;
     for (int i = 0 ; i < 3 ; i++)
        for(int j = 0 ; j < 3 ; j++)
        {
          if(tempArr[i][j]==8)
          {
            x8=i;
            y8=j;
            //System.out.println("Now the X"+i+" & Y"+j+" & boardArrayVALUE is : X : "+x8+" Y : "+y8+" BV : "+tempArr[i][j]);
            break;
          }
        }

     if (x8 != 2)
     {
       int temp = tempArr[x8+1][y8];
       tempArr[x8+1][y8] = tempArr[x8][y8];
       tempArr[x8][y8] = temp;
     }
     return tempArr;
   }

   /**************************************************
    * 方法介绍:让存储8的元素和它上面的元素交换,这种方法完
    * 成得方法效率可能稍差,但这是为了能够扩展人工智能而不
    * 得不采取得方法,因为如果不知道8的位置,人工智能就不
    * 能实现
    * 输入参数:int [][]
    * 返回类型:int [][]
    ****************************************************/


   private int [][] updateUp(int [][] args)
   {
     int [][] tempArr = new int [BOARDNUM][BOARDNUM];
     for (int i = 0 ; i < BOARDNUM ; i++)
       for (int j = 0 ; j < BOARDNUM ; j++)
       {
         tempArr [i][j] = args[i][j];
       }
     int x8 =0,y8=0;
     for (int i = 0 ; i < 3 ; i++)
        for(int j = 0 ; j < 3 ; j++)
        {
          if(tempArr[i][j]==8)
          {
            x8=i;
            y8=j;
           // System.out.println("Now the X"+i+" & Y"+j+" & boardArrayVALUE is : X : "+x8+" Y : "+y8+" BV : "+tempArr[i][j]);
            break;
          }
        }

      if (x8 != 0)
      {
        int temp = tempArr[x8-1][y8];
        tempArr [x8-1][y8] = tempArr[x8][y8];
        tempArr [x8][y8] = temp;
      }
      return tempArr;

   }

   /**************************************************
    * 方法介绍:让存储8的元素和它右面的元素交换,这种方法完
    * 成得方法效率可能稍差,但这是为了能够扩展人工智能而不
    * 得不采取得方法,因为如果不知道8的位置,人工智能就不
    * 能实现
    * 输入参数:int [][]
    * 返回类型:int [][]
    ****************************************************/

   private int [][] updateRight(int [][] args)
   {
     int [][] tempArr = new int [BOARDNUM][BOARDNUM];
     for (int i = 0 ; i < BOARDNUM ; i++)
       for (int j = 0 ; j < BOARDNUM ; j++)
       {
         tempArr [i][j] = args[i][j];
       }
     int x8 =0,y8=0;
     for (int i = 0 ; i < 3 ; i++)
        for(int j = 0 ; j < 3 ; j++)
        {
          if(tempArr[i][j]==8)
          {
            x8=i;
            y8=j;
           // System.out.println("Now the X"+i+" & Y"+j+" & boardArrayVALUE is : X : "+x8+" Y : "+y8+" BV : "+tempArr[i][j]);
            break;
          }
        }

     if (y8 != 2)
     {
       int temp = tempArr [x8][y8+1];
       tempArr [x8][y8+1] = tempArr [x8][y8];
       tempArr [x8][y8] = temp;
     }
     return tempArr;
   }

   /**************************************************
    * 方法介绍:让存储8的元素和它左面的元素交换,这种方法完
    * 成得方法效率可能稍差,但这是为了能够扩展人工智能而不
    * 得不采取得方法,因为如果不知道8的位置,人工智能就不
    * 能实现
    * 输入参数:int [][]
    * 返回类型:int [][]
    ****************************************************/

 

   private int [][] updateLeft(int [][] args)
   {
     int [][] tempArr = new int [BOARDNUM][BOARDNUM];
     for (int i = 0 ; i < BOARDNUM ; i++)
       for (int j = 0 ; j < BOARDNUM ; j++)
       {
         tempArr [i][j] = args[i][j];
       }
     int x8 =0,y8=0;
     for (int i = 0 ; i < 3 ; i++)
        for(int j = 0 ; j < 3 ; j++)
        {
          if(tempArr[i][j]==8)
          {
            x8=i;
            y8=j;
            //System.out.println("Now the X"+i+" & Y"+j+" & boardArrayVALUE is : X : "+x8+" Y : "+y8+" BV : "+tempArr[i][j]);
            break;
          }
        }

     if (y8 != 0)
     {
       int temp = tempArr [x8][y8-1];
       tempArr [x8][y8-1] = tempArr [x8][y8];
       tempArr [x8][y8] = temp;
     }
     return tempArr;
   }

   /**************************************************
    * 方法介绍:程序调试时使用的接口,实现了数组的变换
    * 输入参数:无
    * 返回类型:无
    **************************************************/

   public void mainCallLeft()
   {
     boardArray = updateLeft(boardArray);
     testArray(boardArray);
   }

   /**************************************************
    * 方法介绍:程序调试时使用的接口,实现了数组的变换
    * 输入参数:无
    * 返回类型:无
    **************************************************/

   public void mainCallRight()
   {
     boardArray = updateRight(boardArray);
     testArray(boardArray);
   }
   /**************************************************
    * 方法介绍:程序调试时使用的接口,实现了数组的变换
    * 输入参数:无
    * 返回类型:无
    **************************************************/

   public void mainCallUp()
   {
     boardArray = updateUp(boardArray);
     testArray(boardArray);
   }

   /**************************************************
    * 方法介绍:程序调试时使用的接口,实现了数组的变换
    * 输入参数:无
    * 返回类型:无
    **************************************************/

   public void mainCallDown()
   {
     boardArray = updateDown(boardArray);
     testArray(boardArray);
   }
   /**************************************************
    * 方法介绍:判断是否已经排列正确
    * 输入参数:int [][]
    * 返回类型:boolean
    **************************************************/

   private boolean isOrder(int [][] args)
   {
     for (int i = 0 ; i < BOARDNUM ; i++)
         for (int j = 0 ; j < BOARDNUM ; j++)
         {
           if (args [i][j] != WINARRAY[i][j])
             return false;
         }
      return true;
   }
   /**************************************************
    * 方法介绍:程序调试时使用的接口,实现了人工智能变换
    * 输入参数:无
    * 返回类型:无
    **************************************************/

   public void aI()
   {
     Vector [] binTree = new Vector [2];              //建立两颗二叉树存储数组状态
     StringBuffer [] strDir = new StringBuffer [2];   //建立两颗二叉树存储搜索方向
     for ( int i = 0 ; i < 2 ; i++)
       for (int j = 0 ; j < 2 ; j++)
       {
         binTree [i] = new Vector(0,1);
         strDir [i] =  new StringBuffer("");
       }
     if (isOrder(boardArray))
     {
       System.out.println("The Tree Not Construct , and the answer is OK");
       return;
     }
     else
     {
       int [][] tempArr;

       strDir [0].append("U");                         //方向树的根结点
       tempArr = updateUp(boardArray);
       //testArray(tempArr);
       if(isOrder(tempArr))
       {
         System.out.println("The answer found at the first time use the direction tree");
         System.out.println(strDir [0].toString());
         return;
       }
       binTree [0].addElement(tempArr);


       strDir[1].append("L");
       tempArr = updateLeft(boardArray);
       //testArray(tempArr);
       if(isOrder(tempArr))
       {
         System.out.println("The answer found at the first time use the direction tree");
         System.out.println(strDir [1].toString());
         return;
       }
       binTree[1] . addElement(tempArr);
       System.out.println("The tree become useful in searching the answer for every successful condidtion");
       int stepRecord = 0;
       for ( stepRecord = 0 ; ; stepRecord++)
       {
         System.out.println(stepRecord);
         for (int i = 0 ; i < 2 ; i++)
         {
           int less = (int)(Math.pow(2,stepRecord)) - 1;
           int large = (int)(Math.pow(2,stepRecord+1)) - 1;
           for (int k = less ; k < large ; k++)
           {
             int [][] theCurrentState = (int [][])binTree [i].elementAt(k);
             if (strDir [i].charAt(k) == 'L' || strDir [i].charAt(k) == 'R')
             {
               strDir[i].append("U");
               tempArr = updateUp(theCurrentState);
               //testArray(tempArr);
               if(isOrder(tempArr))
               {
                 System.out.println("The answer found when constructing tree");
                 System.out.println(strDir [i].toString());
                 return;
               }
               binTree [i].addElement(tempArr);
               strDir[i].append("D");
               tempArr = updateDown(theCurrentState);
               //testArray(tempArr);
               if(isOrder(tempArr))
               {
                 System.out.println("The answer found when constructing tree");
                 System.out.println(strDir [i].toString());
                 return;
               }
               binTree [i].addElement(tempArr);


             }
             else
             {
               strDir[i].append("L");
               tempArr = updateLeft(theCurrentState);
               //testArray(tempArr);
               if(isOrder(tempArr))
               {
                 System.out.println("The answer found when constructing tree");
                 System.out.println(strDir [i].toString());
                 return;
               }
               binTree [i].addElement(tempArr);
               strDir[i].append("R");
               tempArr = updateRight(theCurrentState);
               //testArray(tempArr);
               if(isOrder(tempArr))
               {
                 System.out.println("The answer found when constructing tree");
                 System.out.println(strDir [i].toString());
                 return;
               }
               binTree [i].addElement(tempArr);

             }
           }
         }
       }
     }
     //The AI has work well , but you will can't get the answer except:
     //First you know have to make up a tree & how the use the last leave
     //to find the root . The way like this : the N --->the least leave
     //the step is : (N+1)/2 - 1 -> N
     ///             (N+1)/2 - 1 -> N
     ///               ...............
     ///                        0 ->      and you will found the answer is
     //correct may be not optimisted! copyright : gowithfox@163.com
     //modified for the www.csdn.net         .    regards......
     //The most importand method in this file .  2004-03-06.
   }

 

    /**************************************************
    * 方法介绍:测试数据的正确与否
    * 输入参数:String []
    * 返回类型:无
    ****************************************************/
    public static void  main(String [] args) throws Exception
    {
      GamePlat gp = new GamePlat();
      InputStreamReader reader = new InputStreamReader(System.in);
      BufferedReader input = new BufferedReader(reader);
      System.out.println("Now you can play the Game in console!");
      System.out.println("Following are commands");
      System.out.println("up");
      System.out.println("down");
      System.out.println("left");
      System.out.println("right");
      System.out.println("demoai");
      System.out.println("restart");
      System.out.println("exit");
      while(true){
        System.out.print("->");
        String command = input.readLine();
        if(command.equals("exit"))
        {
          break;
        }
        else if (command.equals("left"))
        {
           gp.mainCallLeft();
        }
        else if (command.equals("right"))
        {
           gp.mainCallRight();
        }
        else if (command.equals("up"))
        {
           gp.mainCallUp();
        }
        else if (command.equals("down"))
        {
          gp.mainCallDown();
        }
        else if (command.equals("demoai"))
        {
          gp.aI();
        }
        else if (command.equals("cheat"))
        {
          gp.cheat();
        }
        else if (command.equals("restart"))
        {
          gp.init();
        }

        else
        {
          System.out.println(command+" is not support ~Z");
        }

      }
    }
}

寒假时候为了给同学演示怎样做个游戏,而做了一个最简单的拼图游戏。规则,如下,生成 0 1 2 3 4 5 6 7 8 个数列,然后随机的放到一个二维数组里面:
比如:
1 3 2
4 6 5
0 7 8
8总是在最右脚,智能用8和他临近的值交换。直到得到如下序列游戏成功?;
0 1 2
3 4 5
6 7 8
。现在我想让游戏具有人工智能,用自己的思考建造一棵搜索树,找到一个路径,自己排列数组:
于是我编了一个简单的控制台程序,建了一些命令和程序交互,当输入demoai的时候,人工智能启动,计算了超过3个小时也没有得到结果!后来,我加入了一条cheat的命令,把初始值定义为:
0 1 8
3 4 2
6 7 5
:其实,人一眼就看出只需走两步:
然后我运行demoai,
可以看到计算机是如此思考的:
G:\PTGAI>java GamePlat
Now the X2 & Y1 & boardArrayVALUE is : X : 2 Y : 1 BV : 8
Now the X2 & Y2 & boardArrayVALUE is : X : 2 Y : 2 BV : 6
Now you can play the Game in console!
Following are commands
up
down
left
right
demoai
restart
exit
->cheat
CHEAT:)
0 1 2
3 4 8
6 7 5
->demoai
The tree become useful in searching the answer for every successful condidtion
0
1
2
3
The answer found when constructing tree
ULRUDUDLRLRLRLRUDUDUDUDUDUDUDUD
->
结果分析:
U L R U D U D L R L R L R L R U D U D U D U D U D U D U D U D
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
0 0U

 


1 1L 2R


2 3U 4D 5U 6D


3 7L 8R 9L 10R 11L 12R 13L 14R


4 15U 16D U17 18D U19 20D U21 22D U23 24D U25 26D U27 28D U29 30D

G:\PTGAI>java GamePlat
Now the X0 & Y1 & boardArrayVALUE is : X : 0 Y : 1 BV : 8
Now the X2 & Y2 & boardArrayVALUE is : X : 2 Y : 2 BV : 2
TEST THE ARRAY
5 2 7
3 1 6
4 0 8
Now you can play the Game in console!
Following are commands
up
down
left
right
demoai
restart
exit
->cheat
CHEAT:)
0 1 2
3 4 8
6 7 5
->up
TEST THE ARRAY
0 1 8
3 4 2
6 7 5
->right
TEST THE ARRAY
0 1 8
3 4 2
6 7 5
->down
TEST THE ARRAY
0 1 2
3 4 8
6 7 5
->right
TEST THE ARRAY
0 1 2
3 4 8
6 7 5
->down
TEST THE ARRAY
0 1 2
3 4 5
6 7 8
->exit

G:\PTGAI>
够恐怖吧?

欢迎批评指正,

希望有人找到更好的智能方法告诉我!




相关文章

相关软件