[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
<>package ant;
2 ^1 J+ n: o: p; E" Z/*
5 t, s1 N3 a/ T! ?6 q! k% a: |  O * @(#)Antcolony.java 1.0 03/05/22
# Z9 N2 V' ~3 }' s7 l *
+ T$ ]# o0 B4 s8 d * You can modify the template of this file in the
8 j8 i8 O" O( J8 | * directory ..\JCreator\Templates\Template_2\Project_Name.java
, z9 p' ?+ F2 }3 ^% j *
* V) K. I( H$ D: e * You can also create your own project template by making a new
3 a0 n0 C) a  g* B * folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
*
( U2 x% F  R' a/ [ */</P>
<>import java.awt.*;
" b0 x! X+ B8 d- @3 e( s: [8 d* [2 simport java.applet.*;
import java.awt.event.*;
import java.util.Vector;</P>
1 _5 q2 f/ l+ |' O5 V<>class AntCanvas extends Canvas
: w  Y+ v  I* g5 h$ }* \) U: G7 \{
0 @! X9 N8 R1 k2 F( R    //画布，一切画图操作均由该类完成
//Image image;
$ r- u  b4 a7 E/ i8 c% a/ ^$ ? Color obs_color;//障碍物颜色
Color origin_color;//我的颜色
/ P2 Q9 y. V1 y+ s2 o7 J2 N Color back_color;//背景色
        Color end_color;//食物点的颜色
' C' z2 y- p3 N, o //boolean first;
) ~  \. E6 Q) A9 C! ~5 p" b boolean reset;</P>
<>/* public AntCanvas(Image img) {</P>
/ H6 ~( V, L: w! D<>  super();
' {( Y+ v" S% a( ]7 @0 [+ i* s- h$ f   image = img;
! q$ d0 S% V7 E+ d- \  obs_color = Color.white;
$ K" z3 ?4 h/ }0 T, W  setBackground(Color.black);
  setForeground(Color.white);
  first = true;
( F7 N$ d0 E8 g. {& c& r& m' E  reset = false;</P>
& P1 N! x) h+ p4 s2 c8 K- }; H<> }*/</P>
<> public AntCanvas() {</P>
4 d# c: Z$ U, H) L/ u, U! @$ v<>  super();
7 l& J" m3 s. s) ^% i! o   //image = null;
   back_color=Antcolony.BACK_COLOR;
  E9 O. y' q6 Q& y! L/ p9 F) l  setBackground(back_color);
  setForeground(Color.white);
  obs_color = Antcolony.OBS_COLOR;
  origin_color=Antcolony.ORIGIN_COLOR;
- l) g. R6 F2 H                end_color=Antcolony.End_COLOR;
  //first = true;
  reset = true;</P>
6 V  x1 w+ V# H2 u<> }</P>
<> public void Clear() {
8 }% z( S" h6 N% F9 @$ T        //清空画布
# M4 N8 ^5 H5 u/ B) y  reset = true;
$ D3 Q8 S9 g; d5 O8 Q  repaint();
; t9 w6 |. Y, |: m }</P>
; X# x9 A; u% ?2 A* B0 R! G<>
9 c; r0 R( T  q) u public void paint(Graphics g) {
  T- W' {. `! a, q  int i;
                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
: g  r3 j5 ]. w3 W  g.setColor(obs_color);
1 i. ?5 V; @& o& c  for(i=0;i&lt;Antcolony.obsCount;i++){
0 G2 S8 O. t' m6 r   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
% N, }% L: X% t. m  A# P3 e  }</P>
6 I# R2 }$ }. e6 Q0 {<> }
9 l: Y5 r4 h3 b* b( R public void process(){
  `. F9 h3 N4 X4 X% r' z        //处理动画的过程
  Graphics g=this.getGraphics();
                g.setColor(end_color);
% Q- u! O, b. D   for(int j=0;j&lt;Antcolony.EndPts;j++){
                  //画所有的食物点
8 ]  s: a- g6 q) K0 ^7 H; l* y                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
; }* ?) u6 Q0 `/ S                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
7 w! I6 h$ l1 o( U                  //每只蚂蚁开始决策，并画蚂蚁
  b' O6 A5 E8 o4 S   Antcolony.ants.Process();
! S2 s3 P! G9 O- w1 b% Z, k- K2 }   Antcolony.ants.Draw(g);
  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
9 n+ I/ O; D: F                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
  v) S2 B# X' R. b# s5 Y                        //Antcolony的drawPhe变量标志是否画信息素
! n) x' o- {& Y- Z. a5 F3 h5 q                        switch(Antcolony.drawPhe){
                        case (1):
                            v.Draw(g);
                            break;
$ n3 E% }. P" D! T) }9 Z$ ?8 r2 P                        case (2):
                            if(v.kind==1)v.Draw(g);
1 Y# t% Y9 E2 b( u. e/ y# f0 R! H                            break;
" |4 o2 X+ L. C& l7 \- S% L                        case (3):
                            if(v.kind==0)v.Draw(g);
# [2 q& d6 R, U1 X5 E$ K                            break;
. x% d$ G7 m& G                        }
                        v.delimit(g);
. ~1 |6 s8 Q8 f7 |                }
           g.setColor(origin_color);
                for(int i=0;i&lt;Antcolony.OriginPts;i++){
- M& j5 A' W$ ]1 l6 r- r                  //画所有的窝
8 |- m, M  K$ `9 x                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
                }</P>
<> }
Graphics GetGra() {</P>
1 X: @; A/ A- Y% w% G4 D<>  return this.getGraphics();
* @" w2 ^: s! U0 H }
}
public class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
' {6 @/ W4 q, o Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
8 _% D; [/ {8 p$ {: G$ Q" V        boolean reset=false;//是否按下了重置按钮
) m$ h2 x; f& N8 ?0 T7 r. z* A( L# R static Color OBS_COLOR=Color.red;//障碍物的颜色
) |& k1 w9 U7 Y( D static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
0 ^9 @) s( G9 n2 j% U* F" j static Color BACK_COLOR=Color.black;//背景色
static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
( E# ^; ^( g3 J AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
6 I+ e0 T- g% {0 d2 K3 P# F static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
. C3 v* i4 }' i8 W& t9 u        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
' R7 n1 ?0 ^: v9 i, e: ~        static int OriginPts=1;//窝的个数，最大为100
! M* |/ ]/ T0 t8 A+ ~4 m* Z8 Q# \$ e static int width=300,height=300;//环境的长和宽
: R) V- y9 ~% \- N( r$ o- U) D% ~ static int antCount;//蚂蚁的数量
8 l# j( e! D' o2 ]9 n+ F9 p. ^' r        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
; B2 A! X. p" u/ z6 a        static int FoodR=10;//食物和窝产生梯度的信息素的半径
! u1 O4 w0 _$ y3 m' P5 b' ] static ant ants[];//蚂蚁数组
% k9 u0 @" k" m. X+ I: J" h        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
2 F* k, T: E% D. e2 g8 ~ int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
+ Q8 h: U) o2 f$ T6 r4 b<>        //下面是一些控件信息
+ D# `( e6 h  Q) V0 a        Button btnStart=new Button("开始");
- C. b2 y+ g3 `6 u. h        Button btnReset=new Button("重来");
- P) u# V4 ]7 G2 ^3 D& t( R        Button btnMap=new Button("编辑地图");
$ w1 `( P$ `$ d- k        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
public void init() {
$ j' N* _0 g; G  L& w                //初始化函数，先画各种控件
  setLayout(new BorderLayout());
                Panel pan=new Panel();
                add("South",pan);
) K4 v; q. Z& e. u" b                this.add("Center",canvas);
# i, l. j$ y: \3 i, ~                pan.add(btnStart);
                pan.add(btnReset);
0 u" T& m/ |$ M, g* M  u; s$ k6 b1 ]8 r                pan.add(btnConfig);
                pan.add(btnMap);
: G1 ^2 N3 F/ b                pan.add(choPDraw);
                choPDraw.addItem("不画信息素");
1 T1 a+ F, e$ A% q4 F3 _. w                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
. L+ z! G3 j  Y8 R; n                choPDraw.addItem("画窝的信息素");
- p: X, ^, r0 ^1 m5 t                choPDraw.select(2);</P>
<>                //初始化各个数组
  obs_grid=new int [width][height];
) |) P! F* B/ I                phe=new Vector();
! g# Y' |' T0 D- y! ~$ u5 ~                Pheromone_grid=new int [2][width][height];
                for(int i=0;i&lt;width;i++){
- B2 }- s( O  f* G   for(int j=0;j&lt;height;j++){
5 Z. H. ]+ L# w1 Z. B& a    obs_grid[j]=-1;
. d& N5 ?1 }6 Y' M) q) _" b1 Y+ |% y                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
% h* ]- e5 E! @! R' Z- ?. A   }
  u( H$ o4 y3 V1 ~0 |1 G4 f  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
9 I9 ?; f2 l3 J# g7 s$ k2 f  ants=new ant[antCount];
! w- M' j1 B# i2 J# I. H% v5 R        for(int i=0;i&lt;antCount;i++){
          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
/ I* V( `7 ]' E* j- l' h# z  J  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
& X( q; E' x) v8 {2 @                int grid[][]=new int[width][height];</P>
" n9 @# f3 G$ k% |<>                //下面从地图库中加在地图
; ]$ B8 N: H! h  F6 F9 h1 o                Maps maps=new Maps();
                maps.LoadMap(grid,0);
                //初始化地图
6 P1 B3 S5 X( W  ]& a: H& q                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
  reinit();
}
        public void reinit_map(int grid[][]){
                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
<>                //先停止程序的运行
+ F  p! w' G" E  m9 X3 H4 t                running=false;
8 ^+ h4 z5 V9 \/ W9 B7 n                btnStart.setLabel("开始");</P>
: E* y  Z$ ?4 W* x5 J9 K; l<>
- N8 v( O7 e3 m+ `* `# A                obsCount=0;
                EndPts=0;
                OriginPts=0;
                obsP=new Point[width*height];
" t5 [5 s5 \$ Y- `( Q7 S. N; v                OriginPt=new Point[100];
$ W) U1 L0 E* ^1 l4 q! `                EndPt=new Point[100];</P>
# G( b! i7 _2 @% C<>                //清空obs_grid和Pheromone两个数组中的值
# g8 W8 H* R4 k3 n2 g                for(int i=0;i&lt;width;i++){
; ^8 `8 R1 Y' t. J3 g1 G* w   for(int j=0;j&lt;height;j++){
1 {- y  T! l; p9 d$ X6 T4 t    obs_grid[j]=-1;
4 X* |1 d6 A; q9 p8 @                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
  G: p1 X& I& G3 J/ I   }
  }</P>
9 Q- M9 m& `+ B! `<>                //从grid数组中读取信息
% B- P3 l; }6 q! R8 K0 }6 p& I: `& {                for(int i=0;i&lt;width;i++){
                  for(int j=0;j&lt;height;j++){
0 ]9 F; t$ \* `5 J7 t6 e                    switch (grid[j]){
                    case 1:
                      //如果grid[][]存的是障碍物
                      obs_grid[j]=obsCount;
# Y. e# I$ M2 B5 {6 t, {                      obsP[obsCount]=new Point(i,j);
3 p: H5 }# g( H6 W                      obsCount++;
" G5 {, d% f7 q0 a# {                      break;
. A7 R  @2 N& p                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
0 h) F8 c, @# W8 r                      if(OriginPts&lt;100){
7 ^+ A: S/ R/ U9 t- f: W# u+ G/ f                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
                      }
+ x8 H! l2 k3 ?* s& j                      break;
, Q& M0 _6 ]4 \; n% B" I. D                    case 3:
                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
( _  Q* |* |  a% c2 N# P                      if(EndPts&lt;100){
6 S- b+ Y0 P) I* `* ~8 ~                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
) N- b3 ?$ O  U& b; a* M7 ?                      }
                      break;
2 w- i  e7 ^) ^, i5 K" v  I1 T: X9 W7 g                    }
                  }
                }
- R" R6 h8 [. K$ f+ v. a, k* O            //如果没有指定窝，则随机的选择一点
0 |& y! n  D" k6 T% o& b/ S            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
                int  j;
# u9 B! P0 n% A8 R. ~# a  T                for(j=0;j&lt;height;j++){
7 L, o% F- Y2 X* {/ e7 l; t% ~9 F                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
/ c+ W1 [& }: H) g9 o* j                    OriginPts++;
                    break;
9 d# s0 H3 B3 v4 S* A- V  x# m7 r                  }
                }
                if(j&lt;height-1){
6 @2 L* U5 l: [6 Y0 p. R( f8 E                  break;
                }
/ ?1 v; p+ D9 I. \. Y( p              }
            }
        }
! {) I& X$ j% {$ N% x public void reinit(){
3 p" N7 h6 j' K                //重新初始化整个环境</P>
& p! B/ s/ s' L" V& j<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
<>
3 y/ n2 C/ O5 ^, l$ r# a& k  M  //清空所有信息素Pheromone数组中的值
) p  z/ U" U- W( K( {! F9 Z                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
                                for(int k=0;k&lt;2;k++){
$ m2 f  B- T3 [1 q) }( q* |$ \                                  Pheromone_grid[k][j]=0;
9 X2 T6 d* d$ M! h2 W                                }
   }
  }</P>
' z* o8 n* e/ c- R0 p# O) {, u8 W# {<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
3 S' ?' ?4 c& Z7 X) W# r* b/ y7 v        for(int i=0;i&lt;antCount;i++){
/ z5 \- z; g* s: {4 X! ^% y                        int index=(int)(OriginPts*Math.random());
* P, W; h2 D% R$ H! z: K          ants.OriginPt=new Point(OriginPt[index]);
                        ants.init();
  }</P>
<>                //清空信息素向量
  h6 L1 s) ^" k3 t6 O                phe.removeAllElements();</P>
<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
  for(int i=0;i&lt;EndPts;i++){
1 ]+ J# p/ Y: |* F0 g. I                   for(int x=-FoodR;x&lt;=FoodR;x++){
4 y8 y$ ^6 x% d! t                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
+ C! L' s7 b! A  e. U" z                        for(int yy=-y;yy&lt;=y;yy++){
                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
3 B2 P0 _- ?+ u                    }
! v# A( T7 u! x$ {- @0 d* Q                }
" n% P' z3 z% I% N$ w5 p6 Q) n                for(int i=0;i&lt;OriginPts;i++){
; k( v* a" {" B' a$ O% A' g                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
+ L+ I$ y! [/ N3 Q1 e/ I3 Q6 e                        for(int yy=-y;yy&lt;=y;yy++){
                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
                    }
' V: d# p( r! w9 E                }</P>
<P>                //重画
  canvas.repaint();</P>
9 F0 A" ?! L, N5 }0 {: r# ~<P>                //让程序开始运行
                //running=true;
}
' @3 }+ ]( e8 d8 n3 J9 | public void paint(Graphics g) {
  canvas.repaint();
}</P>
9 Q# Z% j5 {8 X! x4 Z<P>
public static void main(String[] args) {
/ n: o: J! h( ~+ Z- R/ r- G1 N- W4 g    Antcolony applet = new Antcolony();
& M- f' _+ E' j7 p& p$ K  n6 x    applet.isStandalone = true;
    Frame frame;
    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
/ w4 T7 w2 I  T; C5 T; {  }        super.processWindowEvent(e);
; z( C% H. ^% D2 M- W. ?8 S7 ]        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
          System.exit(0);
8 Q1 B( {7 O( a9 r- e$ X        }
9 Z1 j; @3 k1 L6 I$ u      }
5 Q' \2 E4 B; s6 A      public synchronized void setTitle(String title) {
' ]3 P; v) D4 T        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
    };
% R8 h! N$ Y$ V: Q7 K+ X    frame.setTitle("Applet Frame");
) p  N3 r3 _& x% ^4 Y2 P+ B    frame.add(applet, BorderLayout.CENTER);
    applet.init();
    applet.start();
1 ]4 G% w- \0 l2 e1 p! D    frame.setSize(300,320);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
$ h; U5 l+ ]3 n    frame.setVisible(true);
  }
  public void start()
  //下面三个函数是控制线程的
{
6 p& u* U; X& o+ I7 t' A2 y  if (runner == null)
% }# l% g0 |8 ~  {
   runner= new Thread(this);
2 G7 ?/ s( {, m$ h9 E+ F   runner.start();
% g: D& ?; P" o7 w) y' `) g   //running = true;
" m5 Q! r& i* W4 @$ U7 M  O  }
}</P>
+ Q' N" p# ]( c- i<P> public void stop()
, D4 W" x1 e  I9 y% B) s8 z {
" j0 Y5 \4 S3 i0 n3 w  if (runner!=null)
  {
   runner.stop();
( J  r  D4 b- [7 `- \   runner=null;
   running = false;
& i+ Q! P$ c9 _* ]' Q  }
* ?4 B( F7 w# W }</P>
<P> public void run() {</P>
<P>  int i;
                //线程一直运行下去
% |6 _4 ^1 ?& M% U( W5 D/ q* k/ f  while (true) {
          if(running){
  B) ]4 r* O0 p1 \% V       //如果开始动画，就进行canvas的处理
                          canvas.process();
                        }
9 p% [. e( V: k    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
   }
  }</P>
! ?9 w7 r, ?0 h* L' K( u& ^% V<P> }
        public boolean action(Event evt, Object o) {
$ m) v, N* C0 U  x- ~: X8 Z      if (evt.target == btnMap) {
9 @4 d$ @9 q" r1 o2 Z6 D$ n. j1 J                //开始编辑地图面板
   running=false;
: b. q0 o; u2 y4 L7 H4 m7 E* i                        btnStart.setLabel("开始");
% y4 |; \- |# E( `$ |, e   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
                        ctl.show();
                        return true;
3 g' Z  i7 I& K0 n% U  }else if(evt.target == btnStart){
                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
                    btnStart.setLabel("停止");
                    reset=false;
" r, W) D$ ^& j                    running=true;
                  }else{
  Q& P/ @% E8 o  P% {( B3 w/ v                    btnStart.setLabel("开始");
                    running=false;
                  }
& w1 n4 `! w9 e2 D- j8 W& M                  return true;
6 u$ W1 r8 \+ c9 w3 z' e$ D# U                }else if(evt.target == btnReset){
                  running=false;
8 h1 d1 V) K% Z* A; i" C                  int j=0;
) J; s: ^) @+ b4 F. ]" U/ i                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
                  repaint();
" L$ |3 J2 ~6 B8 {9 w( ]                  btnStart.setLabel("开始");
: V7 V5 Y9 J; w% C7 S                  return true;
6 A& F- M5 W  V- g                }else if(evt.target == btnConfig){
                        running=false;
                        btnStart.setLabel("开始");
8 T% z; b8 @; D1 h7 c' J! ^     Configer ctl = new Configer(this);
4 `% Z7 B0 K9 b                 ctl.setSize(300,300);
1 K: U5 X" |; p3 `& o                        ctl.show();
* B- J7 |( c' D) Z) F+ y                        return true;
                }else if(evt.target == choPDraw){
                  //选择画信息素的模式
% h2 z8 `- _, h9 }2 @                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
                  return true;
. s* P9 q, {0 Y' T  @, ^                }
( ]1 |/ I- `, `; V1 L                return false;</P>
<P>        }
) ?) h- t* e* ?0 C /**Destroy the applet*/
  public void destroy() {
/ h! D7 L, ]7 ^  //当结束程序的时候，把线程也结束
    if (runner!=null)
    {
( S  z; t5 x  k7 x1 W       running = false;
1 _( c1 H/ k2 o) p4 f) f: K       runner.stop();
& {. R+ l& G5 C( \8 W4 N- W       runner=null;
    }
3 E, S5 I3 c; s( v  }</P>
, C* I. i3 b1 F4 u/ z# v<P>}
</P>
2 e' ?: `& |( Z# t. Q  c

) h# m* |3 d  V  c2 s! N; H
/ A: q$ P# E6 n& u3 h+ B<P>package ant;
1 c  ?2 ^3 n9 _1 U' Y+ i' {import java.awt.*;
  W6 z+ ?; ^/ G; R: Ximport java.applet.*;
import java.util.Vector;</P>
+ y6 P+ M& B) C0 q<P>public class ant{
; U2 U" ~* f( j" y Point nowPt;//当前点坐标
6 z1 i3 P, F( S% y4 i int VR;//速度，每次蚂蚁能走动的最大长度
  int id;//标识
( Z, E) Q  u, p) S# p  Y' t  c  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
2 ^! R! F' L' B( ~, v; n int height,width;//世界的尺寸
- V  C6 z1 H* X) B# D8 }8 v% n1 d        int Phe;//每次释放信息素的数值
$ u% D3 V1 M! j Antcolony local_colony;//主程序的指针
* a0 `/ v1 _/ [$ E6 ]        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
        double Main_direct;//主方向
! `6 @5 Y+ W6 N+ M( b( h        Point FoodPt;//记录的食物点，是否找到时候判断用
! n- K, j4 T# l* D        Point OriginPt;//窝的坐标
: Q5 t; q0 ^5 T        Point AimPt;//目标点，是窝或者食物
# ]* X$ c+ L) o) J: Z        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
5 M7 \7 Y/ \( v& J( y* d/ s        int Max_Pheromone;//最大能够释放的信息素
        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
5 u. x" H3 l7 i: w" D; q        int memory;//记忆走过点的数目
        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
  P  A1 j  ~# F8 m9 ^        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
  nowPt=new Point(nowpt.x,nowpt.y);
                OriginPt=new Point(nowpt.x,nowpt.y);
                FoodPt=new Point(nowpt.x,nowpt.y);
                StartPt=new Point(nowpt);
                AimPt=new Point(nowpt);
                lastPt=nowPt;
0 x$ U. Q3 L3 S* [  VR=vr;
  id=idd;
( F3 a6 ^. |! I2 U' w: _8 I) H  color=c;
  I: s4 K7 h; v4 m  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
  width=Antcolony.width;
0 E) `& ]# Z5 z) }  local_colony=colony;
! N, G5 ]% @% I5 u& Y6 U  {6 i                Phe=200;
% M$ d) ~5 {2 m* H1 F  `                mistake=mist;
                HistoryPoint=new Vector();
6 n8 |& r6 v+ b& @; _                Main_direct=-1;
5 z6 }* k- l$ A! \6 E/ l                FoundTimes=0;
                Max_Pheromone=local_colony.Max_Pheromone;
9 x- h8 ~. Y& u3 h. [                Pheromone_count=Max_Pheromone;
* y8 d8 {; w" l; ~                memory=mem;
6 I* T9 X, Z" @( U5 D1 t/ V0 a& u0 p                Count_distance=0;
                Min_distance=-1;
}
        public void init(){
6 [  a" [9 S1 ^/ B7 t+ U          nowPt=new Point(OriginPt);
8 l# K  |$ W: Y, H7 j- J  X/ p- I          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
          Main_direct=-1;
% T9 C$ N& o' @, F" }8 O) N          FoundTimes=0;
' I4 k8 r. W/ j  x( L; [          Pheromone_count=Max_Pheromone;
; }, u: v  K$ P. C7 J, s, ?( }2 B          Count_distance=0;
          Min_distance=-1;
        }
3 y+ p' f" v  _1 m- E- C9 r" Z public void Draw(Graphics g) {
: v8 w8 ~' K8 p$ d          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
3 f; t4 C6 _% N) Y" P  g.setColor(back_color);
$ M3 a. f0 I' D% q, o, J  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
4 Z! J: J2 }. m5 ]/ A  [) l$ P! ~5 M  g.setColor(color);
3 B  _; A7 `8 u4 h' Q, O* V  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
}
3 A3 I; p2 M; n5 ^' s# H- m8 W; V public void Process(){
0 i: Q% F2 l' _  t        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>
) L) z; B1 s- G
: `+ r. ?, Y; ~4 m8 z6 ]( R<P>        if(Judged==false){
! j5 E2 I# |; y- E+ U/ S: e7 ]          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
: Y8 u1 K  E7 L4 W& P- \9 s1 ]          if(JudgeEnd()){
              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
8 `( C& U0 B. d& _% ^, C& o! ]; X5 q              return;
# S, \, o( M  U% N3 [' }          }
        }
1 e5 ]$ D- v" S" h3 {        Judged=false;
9 Q; M# C. V$ J% {! y        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
1 l2 p( y5 Q' r7 v( h) x/ f<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
# A" O! O8 L, R  @+ P, U        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
* C5 }; q+ P+ Z# H        deltx=(int)(VR*Math.cos(direct));
- [9 w9 R0 c4 [. O        delty=(int)(VR*Math.sin(direct));</P>
<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
/ N- q$ s0 ?: n& e: j- J! o        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
5 M5 Q" z) {1 @$ @' k<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
2 B+ l) p! W# p9 W0 S0 v          int deltx1,delty1;
, s' O5 Q8 t" ?5 G. x1 b  ^          deltx1=deltx;delty1=delty;</P>
* u( L: A  j& ~' G<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
          for(int x=-VR;x&lt;=VR;x++){
             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
8 A  c9 y' `8 U/ l                int yy=(nowPt.y+y+height)%height;</P>
" x8 x# ^: K1 t1 R  I, l<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
/ r8 q- k$ y# H. d+ L1 c                  //的到要搜寻的点的信息素
( x+ ]- h6 h, ~/ @" x5 b                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
$ q( Q" U- j9 n2 m& P' n* b6 q<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
$ `9 u- y' h9 L$ ]<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
* Z  K( s+ ^) R3 P$ H9 i/ V                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
                          boolean found=false;
                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
                          for(int i=size-1;i&gt;=size-minsize;i--){
  E+ r. d3 [0 y                             Point pt=(Point)(HistoryPoint.elementAt(i));
. O  F3 }0 e) G* q5 b                             if(pt.x==xx&amp;&amp;pt.y==yy){
                                found=true;
                                break;
1 D' ~2 N' J; F/ [                             }
- A/ j8 c9 ]% F: z& w7 n- Z; ^                          }
; k) g% e4 O) V& h5 j/ d3 s                          if(!found){
, i& N$ n2 x4 O3 W1 b                            //如果没有原地转圈，那么记录信息素。
& \4 S7 j6 }% `  H4 g                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
                            delty=y;
  k- g' E* [: {7 B; Z5 H+ L) i$ q( I" k                          }
                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
                }//end if x!=0
            }//end for y
: V* U4 F0 x, u  r! m. I. K7 e        }//end for x
; {; }4 d5 ^; x( r6 e        Point pt;</P>
9 c  X  h) M0 O/ m) ^4 A<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
# B* w5 T) f0 c- }1 S$ u# s        pt=Evade_obs(deltx,delty);</P>
6 m6 ?0 \* ]+ X<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
3 z5 T5 m) T+ G8 p# l# \3 e          pt=Evade_obs(deltx1,delty1);
        }</P>
<P>        //播撒信息素
        Scatter();</P>
2 U: Q1 B5 Q6 H" |<P>        //记录走过的距离
        Count_distance+=Distance(lastPt,nowPt);</P>
* y. [! I8 J- ]6 J- b<P>        //改变当前点位置
) B$ Z5 h& I& q; F8 a        lastPt=new Point(nowPt.x,nowPt.y);</P>
! H, `2 }6 }3 }* h5 P, {<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
$ M5 i! m/ S/ |$ l6 a        if(HistoryPoint.size()&gt;memory){
: J, w! N+ i% U/ `5 k2 l          HistoryPoint.removeElementAt(0);
7 x; G; P. n$ x; q/ v4 q        }
        nowPt=new Point(pt.x,pt.y);
- o9 t' n( h6 x     }</P>
1 l5 w6 g4 n( d( D<P>
        private void Scatter(){
/ ]- R: Z8 u# h* `1 I$ i. N        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
- o2 h' D" C( o, y/ Q            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
' K  ~9 ~. u2 |" ?+ D5 O            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
5 _  {- G$ V# D3 e3 x            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
; s1 \9 w3 w  j5 V- p7 ?            boolean ofound=false;
, T% Q; r& m( I, V, U, T: {6 n            if(Phec!=0){
. W- w  z7 e6 N* d4 J                //如果当前点已经有信息素了
: {, i. P( ?9 q6 o& z3 f                for(int i=0;i&lt;local_colony.phe.size();i++){
                    //在信息素向量中查找该点的信息
  P" W1 t. |9 M                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
+ v) d+ d& y2 Y' v: F                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
  Y5 t% `' I- X, b9 y4 \                        ofound=true;
                        boolean found=false;
                        if(size&gt;4){
                           for(int j=size-4;j&lt;size-1;j++){
                              Point pt=(Point)(HistoryPoint.elementAt(j));
                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
: d: {% D/ s$ _* O3 P; j" x                                //如果当前点重复了以前走过的路，就不释放
- H& S2 N* K: {& K# b                                found=true;
' e: ?' y$ \& S' g( m                                break;
                              }
                            }
) F) {( ^4 i5 F" z5 `# F                        }
                        if(!found){
                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
) ]& G+ }, I0 g  k) \4 \% v<P>                             //让还剩下的信息素总量减少
                             Pheromone_count-=Phe;
                        }
                        break;
                    }
                }
              }
          if(Phec==0||!ofound){
% o1 u) ?# j3 C7 ]' L            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
* }2 c' j1 C! M# k! _0 I8 c3 B                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
3 ]$ o: \1 @# s1 o8 M+ c                ph.Add(Phe);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
                local_colony.phe.addElement(ph);
                //让还剩下的信息素总量减少
* a; X( O$ U5 c  @                 Pheromone_count-=Phe;
           }</P>
8 I' U- g) I9 J<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
  a4 w1 S. l, {. w) I           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
. F5 t4 h( q2 H% }" n; K& j5 G           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
& ~8 l* u, d7 H' Z$ G: l<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
        }
+ d2 N, I3 \1 ?5 H& mprivate boolean JudgeEnd(){
    //这个函数判断是否已经找到了目标点
0 V( c9 C: K; o+ _0 N! R    //首先获得当前蚂蚁是正在找窝还是在找食物。
  v$ w( y! z& F8 ~    int kind=FoundTimes%2;
    if(kind==0){
, X" j& F: S" a4 G        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
! A1 K) E% y) G# C! T        int i;
        for(i=0;i&lt;local_colony.EndPts;i++){
            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
              //如果找到了食物，就直接移动到食物点
              lastPt=new Point(nowPt.x,nowPt.y);
1 g" v$ L  X2 c% p' o  P4 g9 L              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
; Z- h% F' p. r2 O1 O<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
; q+ P4 a" e, I$ f# x; h( y3 ^              //比较大小，记录较小的距离
7 g* }- a/ u: _! D4 m. _4 c3 D              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
" p1 c# K9 b. J4 N* }              }
              //清除总距离记录
              Count_distance=0;</P>
<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
              AimPt=new Point(OriginPt);
7 d+ Q9 _. `7 }              StartPt=new Point(nowPt);
& A+ K6 G) K! q) ^8 a/ G- f. I              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
4 O( c/ p' R* m5 @' I. ^<P>              //找到了食物就把找到次数+1
7 h6 ]+ i7 ^# F              FoundTimes++;</P>
  h4 Z+ f8 N8 s, {0 b5 c<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
8 ~4 J: Z, p" p  O/ A<P>              //重新把自己能撒的信息素置为最大值
              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
3 s: y: ?- M+ t' R4 o' y! D2 F+ U5 y              HistoryPoint.removeAllElements();</P>
( _8 ?3 f# m0 s: D# x<P>              //返回找到为真
              return true;
            }
( K( r! D7 Z' l' d* G. |  x        }
" F3 Y/ g/ Q! n: L; p) A" f      //否则没找到
) ^9 ]5 t7 T/ A2 H% [$ J! M! h3 U  n      return false;
1 ^, @' B2 U  o/ N- J6 i& a    }
4 `/ T/ P& }, n% m2 j+ x6 K    if(kind==1){
        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
4 R+ D) a( Y1 l3 ~5 M9 B            lastPt=new Point(nowPt.x,nowPt.y);
            //如果找到了目标，就直接移动到目标点
$ b8 \2 U/ t' q8 t( Q  ]            nowPt.x=AimPt.x;
+ H8 v7 [" T9 C5 b, `* G$ e            nowPt.y=AimPt.y;</P>
1 u0 o7 J+ ]0 ]1 C& m# c<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
; T2 H' y- m3 `# @& {6 K8 g              //比较大小，记录较小的距离
' F2 ]! b0 w: D8 q  p: D              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
& f& @& `* I% M$ A9 a* W) ]                  Min_distance=Count_distance;
; l  U  Q5 q; A. k" ~! L9 N, g0 \  }              }
- j" T9 F- Q; Q              //清除总距离记录
              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
1 K3 _! ?+ |( C: O, F' m+ A8 S            AimPt=new Point(FoodPt);
6 v/ ]# ~' I5 }" ^4 [            StartPt=new Point(OriginPt);</P>
0 O; \  @0 K1 U<P>            //重新置信息素
            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
<P>            //主方向反向
! b" l( R' a: G; S- X            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
' N6 F+ s1 U& r+ D: {<P>            //找到次数+1
            FoundTimes++;
            return true;
        }
! b# ?0 k) m% j        return false;
- N; ~4 U: {- U/ |  ~    }
    return false;
}
        private double SelectDirect(){
                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
                if(Main_direct&lt;0){
$ \4 {% @: u9 h% J+ |* }                      //如果目前还没有主方向角，就随机的选择一个
# F+ e6 ]: z. d        e=2*Math.PI*Math.random();
" @0 F+ q. B% \3 n2 g                      Main_direct=e;
                }
                //选择主方向角
; H. N9 q9 l4 ]" I* C" `                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
6 B: z+ y* ?/ y* o                //[-1，1]的随机数，并且在0点附近的概率大，两边小
0 X6 [& H. I/ ?! |  t9 @                double re=Math.random();
1 I* G" u0 p! T) |* z; p& L) y. B! A                double re1=Math.random();
* K/ ^- I) r6 v$ H+ k                direct+=Math.PI*(re*re-re1*re1)/2;
& D% X$ ?: P2 ^  O                if(re&lt;0.02){
* j+ ~" N5 }. D6 U& q                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
                  int size=(int)(re1*memory)+1;
; A8 W: P# h) t9 _$ `3 ]/ e% ~                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
0 C7 j7 V7 T* K5 \' l) n                       Main_direct=GetDirection(pt,nowPt);
                    }
5 m# k! o9 ?+ R* A% t7 I5 e* V4 }, g                  }
+ Z9 {1 X1 T. P& q/ o. t$ d+ Q: G                }
: S; y% w! \, o1 c9 C; j               return direct;</P>
<P>        }
        private Point Evade_obs(int deltx,int delty){
              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
/ n' ]1 J+ G' l+ R! D. H! O              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
1 E& ^2 g; p- p& B8 [1 j0 P+ M0 X0 ^6 a              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
5 r7 P6 u$ K+ m9 Z3 _+ q              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
* ^4 c" D3 Z5 ^) f              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
              Point pt=new Point(0,0);
              int x,y;
              int delt=deltx;
( s( d% C+ B6 y) |/ R              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
7 H3 _+ z) w0 s2 n              if(delt==0)return nowPt;
7 L! B0 e% Z* i9 G) z5 n              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
+ w2 O) J4 _6 f; i# c                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
                  x=(x+width)%width;
* {$ k; K! y1 \; p( o0 B( B/ j" ?3 p                  y=(y+height)%height;
4 s4 O$ g1 C- y2 ~  Z                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
6 Y# Y7 I9 M$ ~$ D                     //新目标点为障碍物前方的点，主方向随机取值
9 Q' s! h5 d: |5 o  y$ ~4 M, c! p! ^                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
                     double disturb=4*Math.PI*(Math.random()-0.5);
5 a. W' ?% c$ I* e- f" E                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
                     break;
" b( E+ h: k+ U. O8 Y, c                  }
                  pt=new Point(x,y);
& }4 T2 B) h7 }$ b* G! l: C8 x0 y                }</P>
+ v4 \  \! i, v* L/ S: |<P>                //计算得出实际能够到达的目标点
& \" m9 H+ o- Q& j7 O' ^  x=(nowPt.x+deltx+width)%width;
! X, {" G) d# a% s  y=(nowPt.y+delty+height)%height;
         return new Point(x,y);
0 L/ b1 F" G; }* Y3 j; ?        }
        private double GetDirection(Point pt1,Point pt2){
/ j, w7 K" `* l  _        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
        //其中方向角是所有可能的角中使得两点连线距离最短的角。
8 }" h0 y, d9 z8 w/ ^               double e;
5 U9 U' c7 Y; F' ~8 v               int deltx1=pt2.x-pt1.x;
" a* ]4 L% L) Y! }# x6 E) @- C               int deltx2;
/ a5 d$ J' B8 w1 \( O! g/ V5 A               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
               else deltx2=pt2.x+width-pt1.x;
               int delty1=pt2.y-pt1.y;
               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
6 K0 i) M, ?7 e7 {+ n0 V, [4 P               else delty2=pt2.y+height-pt1.y;
5 ~3 R( {: Y6 p( |               int deltx=deltx1,delty=delty1;
! a! t, Q* O8 }+ v5 J, o               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
5 l9 C1 l: a  Q0 S* z- X. L$ o5 u* j    deltx=deltx2;
( d( ~& V! A5 ?2 U$ G3 x- s  U               }
* U( S$ b# ?/ s: L0 S) G- i0 j        if(Math.abs(delty2)&lt;Math.abs(delty1)){
3 `: [9 O, s8 D; d8 f) G4 V+ s                  delty=delty2;
               }
1 r7 t1 H8 P7 [9 E0 ~               if(deltx!=0){
                    e=Math.atan((double)(delty)/(double)(deltx));
                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
1 d# |& X1 u7 G$ x; @  l0 P" K                       else e=e+Math.PI;
' s, k( H# k  m5 M                    }
                }else{
5 K; I" F& s1 e$ i3 x                    if(delty&gt;0)e=Math.PI/2;
+ C9 k/ w% }& E3 L                    else e=-Math.PI/2;
/ m( m7 o& d8 ?/ W3 G                }
                e=(e+Math.PI*2)%(2*Math.PI);
# G7 A4 B0 Y' ?( Q) Z                return e;
        }
        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
5 a4 e6 F7 p9 c& l) E- X( a            int dx2;
& b! V3 g# Z. P# `, I            int dx,dy;
# l5 E. U- L& U! {+ q! ?            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
. D4 m+ ~" C* A            else dx2=pt2.x+width-pt1.x;
" x1 @; n9 B% r1 k8 |- R! ^0 @            int dy1=pt1.y-pt2.y;
            int dy2;
            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
- B+ U" f8 I- N  @7 v! z( y& z            dy2=pt2.y+height-pt1.y;
            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
            else dx=dx2;
: @8 Q6 b8 A6 d2 z3 \            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
6 t+ X/ B4 h3 ^; k( D4 h% g2 k- f            else dy=dy2;
" W' f* C. b1 f! k            return Math.sqrt(dx*dx+dy*dy);
        }
    public void clone(ant ant1){
  B* f: S: K+ Y9 v- f6 G        //把蚂蚁ant1的属性拷贝到本蚂蚁
  D$ x. p! z, J- j2 I8 g     nowPt=new Point(ant1.nowPt);
* g. z; l8 x' O# F0 u        OriginPt=new Point(ant1.OriginPt);
        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
7 F5 c- ]$ D) q5 N        AimPt=new Point(ant1.AimPt);
# H) N6 q6 G% \$ X        lastPt=new Point(ant1.lastPt);
. E. v: }% P: c2 x4 J% ]& q        VR=ant1.VR;
4 t1 k" k" }( _        id=ant1.id;
        color=ant1.color;
        back_color=ant1.back_color;
: q6 H! F, v. A7 j        height=ant1.height;
        width=ant1.width;
  D% U2 Y9 ^. M8 W* o8 v, W& w0 e        local_colony=ant1.local_colony;
        Phe=ant1.Phe;
) d; r0 M/ p# F, e1 Q        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
/ b: J2 J" Y( U        Main_direct=ant1.Main_direct;
7 _0 g& \8 d& y$ {% o2 x# N5 X        FoundTimes=ant1.FoundTimes;
        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
% v9 [0 ?5 y6 j' }' U3 M- N        memory=ant1.memory;
& O; b5 v8 v: B        Count_distance=ant1.Count_distance;
# s% I5 J- m+ h  s+ b1 D" i        Min_distance=ant1.Min_distance;
7 Z( O/ S. P- D6 F5 ~3 }1 b' g    }
}</P>