[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
<>package ant;
4 t  T$ o3 u9 `. C  H/*
* @(#)Antcolony.java 1.0 03/05/22
2 s0 x5 R  f7 y+ C0 ]: K( ^ *
* You can modify the template of this file in the
1 w1 O) c) s9 Q5 R * directory ..\JCreator\Templates\Template_2\Project_Name.java
$ F% k7 Z& H8 y: H *
* You can also create your own project template by making a new
5 W- Z7 O4 P0 p: |2 F7 Y * folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
2 v& j. I! U4 w; z0 H* H5 _ *
*/</P>
<>import java.awt.*;
import java.applet.*;
" e& D# y; k& b' K8 [& @import java.awt.event.*;
import java.util.Vector;</P>
- r! Z# }' R: o+ |6 ?<>class AntCanvas extends Canvas
{
/ u* L% q% n: U8 L% F7 b7 ]+ ~' ]    //画布，一切画图操作均由该类完成
! _3 G) b5 l3 H  c //Image image;
& |* U5 X' @$ }7 ?" P8 ~9 z Color obs_color;//障碍物颜色
Color origin_color;//我的颜色
Color back_color;//背景色
        Color end_color;//食物点的颜色
//boolean first;
boolean reset;</P>
<>/* public AntCanvas(Image img) {</P>
" Y7 Y: [( h: q' P0 O<>  super();
! D* g0 [9 k3 m* f4 R% Z4 c   image = img;
0 ~* E7 {8 ~( b4 `, K  obs_color = Color.white;
  setBackground(Color.black);
  setForeground(Color.white);
6 ]4 T* f! f" i4 L4 j6 K& d  first = true;
/ U* Z! [$ l( r( V4 b; |, ~  reset = false;</P>
<> }*/</P>
<> public AntCanvas() {</P>
, L0 N! [9 W5 b1 R0 X. z<>  super();
   //image = null;
   back_color=Antcolony.BACK_COLOR;
# c% ^( I) d' Z- Y; S- c6 ^  setBackground(back_color);
* t7 ~7 \/ @9 c% E  setForeground(Color.white);
  obs_color = Antcolony.OBS_COLOR;
  origin_color=Antcolony.ORIGIN_COLOR;
- |7 L& `- Q6 m" O% Z3 x, v                end_color=Antcolony.End_COLOR;
! v: \& |8 R! }0 Q9 |0 t  //first = true;
  reset = true;</P>
<> }</P>
! F% {' A/ z4 g# r  n<> public void Clear() {
+ B- F# K6 P; B( e- a& N" K+ n        //清空画布
  reset = true;
" y' I0 F( b1 c0 a& n2 l2 G  repaint();
' n# b7 P$ y+ D+ C2 V+ L }</P>
<>
public void paint(Graphics g) {
# d  }/ e/ i$ o8 F3 g% ~+ `  int i;
) \! Y" \3 b5 S+ s( v                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
; P3 E- b: B! x6 A  g; O; ?  g.fillRect(0,0,size().width,size().height);
/ N2 z" E' n  }: D  g.setColor(obs_color);
5 H. Q9 \$ ?9 t$ ~8 V  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
% j( f7 A+ ?% L7 d+ J9 D' R  }</P>
<> }
" E# w8 ?7 P( A# V6 l" h, b3 b public void process(){
# J1 f" Q6 M" x) U; k        //处理动画的过程
  Graphics g=this.getGraphics();
+ I& F5 F, Q/ s! f( q0 K                g.setColor(end_color);
   for(int j=0;j&lt;Antcolony.EndPts;j++){
6 a* A' S" v; t$ c5 f, ~                  //画所有的食物点
                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
$ Z! }) G- {' N* }1 i0 o# U                }
8 ?& Q) }1 o6 F: Q" b                for(int i=0;i&lt;Antcolony.antCount;i++){
                  //每只蚂蚁开始决策，并画蚂蚁
   Antcolony.ants.Process();
   Antcolony.ants.Draw(g);
  }
- M  ]9 B0 P' Y6 D$ Z. M# F                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
$ Z2 O3 s0 E9 n: `1 A                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
8 J; R" E) B  B* }9 `                        case (1):
                            v.Draw(g);
" O# L" Q3 o. J, ]8 T9 Z- J                            break;
' i5 O! ^& w6 L5 p' s                        case (2):
) @5 |4 A4 v5 D) q% z$ H                            if(v.kind==1)v.Draw(g);
                            break;
                        case (3):
" i5 H0 E: j7 ^- j& ?: }" D                            if(v.kind==0)v.Draw(g);
2 L0 L. r5 Y5 a+ a3 i$ Z9 a1 ^                            break;
                        }
$ ]- m( {6 l0 U6 C3 m1 h, O5 Q                        v.delimit(g);
                }
0 x1 g' G; ~  l# U           g.setColor(origin_color);
* b6 m/ u0 e6 l. u$ `( i  J                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
/ s3 B$ C/ Y' k- ^                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
( I# d, _9 f8 p& K8 b$ O                }</P>
6 d/ W, C+ c9 X5 h' N3 T, z6 m. P7 a<> }
+ X9 h$ ~* p7 ]; p  B/ p2 p1 u$ O Graphics GetGra() {</P>
<>  return this.getGraphics();
}
}
* v, i  t# z. H7 p5 `public class Antcolony extends Applet  implements Runnable  {
. b! p. p5 T0 ]& a5 Y boolean isStandalone = false;//系统的参数，是否独立运行，不用管
1 a% h0 W9 d% m Thread runner;//创建一个线程，让动画平滑的运行
! d9 ^' ~2 d& g0 n$ g boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
# p( I! I6 o8 z- k4 [- \9 c static Color OBS_COLOR=Color.red;//障碍物的颜色
static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
static Color ANT_COLOR=Color.white;//蚂蚁的颜色
( M7 ~0 z7 m! Q        static Color End_COLOR=Color.cyan;//食物点的颜色
- Y* ?, g8 @% _' C! N% e8 o AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
& Y/ N0 K; m( F        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
) ?* n0 ?1 C0 b+ }: Y0 L        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
        static int OriginPts=1;//窝的个数，最大为100
$ m5 h" c2 y) y. @ static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
+ t( @( z* r1 o, X8 I        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
        static int FoodR=10;//食物和窝产生梯度的信息素的半径
7 a( P+ D( `' [% F( ^# V6 b8 G static ant ants[];//蚂蚁数组
        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
        Button btnReset=new Button("重来");
        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
) A5 R& J6 O& u4 ^/ p        Choice choPDraw=new Choice();
6 j# G4 q2 w7 S+ Y7 N7 V7 W4 ` public void init() {
                //初始化函数，先画各种控件
  setLayout(new BorderLayout());
                Panel pan=new Panel();
: z1 h2 F0 S6 ~) u                add("South",pan);
                this.add("Center",canvas);
                pan.add(btnStart);
8 W) h# ?* L4 e- L# P4 g                pan.add(btnReset);
' i* z0 k3 B& G6 R( ^                pan.add(btnConfig);
, Q! P* I) V2 c9 N) i5 \1 K                pan.add(btnMap);
. \, Y, `# }; v$ P$ a                pan.add(choPDraw);
                choPDraw.addItem("不画信息素");
8 q6 z+ ^4 F% b5 @! w7 T, y8 Q                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
                choPDraw.addItem("画窝的信息素");
. y/ ]$ v2 B0 X0 I3 G                choPDraw.select(2);</P>
<>                //初始化各个数组
  obs_grid=new int [width][height];
6 D  {% Q  A0 O" f2 i                phe=new Vector();
                Pheromone_grid=new int [2][width][height];
                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
* V# M0 a: n; i( _( U, Q) T+ V3 P   }
  }</P>
8 H* _* B# b2 S0 D: {<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
: L) f. _, v2 J( Z5 @4 V4 }* J4 Q          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
& J0 K8 H7 h* e( I  N* F' j  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
0 n" q. v) ^" L                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
                Maps maps=new Maps();
) H. b4 D8 H' t9 `                maps.LoadMap(grid,0);
% q+ C7 m9 h1 q" t                //初始化地图
3 ^7 e/ s7 C) M6 Y                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
  reinit();
4 a& d9 j3 B" ?) m, d }
% q/ [7 [, f+ M        public void reinit_map(int grid[][]){
1 H' H  f, @! T5 X                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
<>                //先停止程序的运行
                running=false;
9 ]. Y) O" ?' `, ]" ~( s. \( F: F                btnStart.setLabel("开始");</P>
<>
                obsCount=0;
                EndPts=0;
7 D7 D) G% M+ n' c6 V                OriginPts=0;
                obsP=new Point[width*height];
                OriginPt=new Point[100];
                EndPt=new Point[100];</P>
) R& N/ i5 A1 F<>                //清空obs_grid和Pheromone两个数组中的值
                for(int i=0;i&lt;width;i++){
7 w2 p  j! \9 B/ l+ x5 G   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
" }, G! I6 ^; D3 e4 F  ^                                }
   }
, K$ n  m7 U+ |2 r! Z6 @5 m  }</P>
$ F+ j  g% w1 O; q6 [<>                //从grid数组中读取信息
, W' l- x4 ?1 j5 s5 a- ]                for(int i=0;i&lt;width;i++){
                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
+ ^; a7 U6 B" g! d: ~0 V6 B: C: `# I                    case 1:
                      //如果grid[][]存的是障碍物
2 o) K( u! x' a# X6 U                      obs_grid[j]=obsCount;
+ J* i  p9 e" G5 r$ t1 U% r, G                      obsP[obsCount]=new Point(i,j);
                      obsCount++;
                      break;
. L" M& v2 a4 K: K4 T6 g" ?: d                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
                      }
                      break;
( L5 Y& R+ m7 ]) s( V                    case 3:
                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
9 P$ k* S& ]& C4 ^                          EndPts++;
- t9 n( K0 J+ `( s                      }
" S! H+ q' d; e! O  X( `                      break;
                    }
. f1 b8 h+ R8 Y) i9 o                  }
% L  x* t8 l% m9 `( z& H                }
            //如果没有指定窝，则随机的选择一点
            if(OriginPts==0){
0 F3 K2 h: V& R. j; E) F              for(int i=0;i&lt;width;i++){
9 w5 x6 d" L9 a2 O; W                int  j;
                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
# h: _7 Y+ P  x                    OriginPt[OriginPts]=new Point(i,j);
6 f3 S: V& E& s& G) D                    OriginPts++;
  l- b# Y1 S$ q( e* c# y: u                    break;
' e1 n% h1 z& N( V1 n9 V. }/ t                  }
7 f+ z( T/ u7 Y0 |7 n) i- {                }
                if(j&lt;height-1){
( }8 m. h8 p4 |! |' }3 N                  break;
9 ~+ S1 w% E* |! _' d  i5 [                }
% _  ]- Y2 K4 k/ `6 V' f              }
" t' ^( v# l% B9 z            }
; I7 z- X6 P' u/ `' |        }
public void reinit(){
                //重新初始化整个环境</P>
<>                //先停止程序的运行
                running=false;
4 i$ M+ M: ~- ^; h3 X                btnStart.setLabel("开始");</P>
- P/ f+ Z- c$ \4 q* d<>
' ^" F' _- m: I: K. x3 `7 t% M  //清空所有信息素Pheromone数组中的值
                for(int i=0;i&lt;width;i++){
: Z+ i% B3 B0 B( @% |% m+ s7 a   for(int j=0;j&lt;height;j++){
0 u- Y1 Q$ c4 e8 T8 w0 q' R                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
7 O0 R% M) q0 M- D/ Y' b6 k                                }
: ^+ K/ T- L, Y% a! u8 d# `1 d3 i) v; f   }
) \! A& v0 V! n5 s# o% X  }</P>
$ _4 z$ q+ f# {, K' R5 J( Z<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
/ c( {. |' u4 n        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
          ants.OriginPt=new Point(OriginPt[index]);
                        ants.init();
& |" j& j9 B6 N7 I  }</P>
+ S( X' Q$ E4 p" O/ [4 z<>                //清空信息素向量
0 @+ {9 K7 T# J" j                phe.removeAllElements();</P>
4 _5 x8 q; D0 I9 I$ L7 |<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
' Y/ t! ]0 P' `  for(int i=0;i&lt;EndPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
" n/ q& q0 l) Y/ }& `                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        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));
: Z2 j3 j* I: C+ Q* B6 ^8 a* E                        }
                    }
                }
0 ]' q1 V2 f% v/ K  f$ ~, i                for(int i=0;i&lt;OriginPts;i++){
! a! c: w: _8 m5 p4 T% I                   for(int x=-FoodR;x&lt;=FoodR;x++){
# y* g9 [8 _8 P) S! C! X                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        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));
                        }
" N& w* }4 X/ W' T+ L' p9 C8 O                    }
- y! E5 k8 M! o) o' B# R5 ^                }</P>
<P>                //重画
  canvas.repaint();</P>
0 k$ d- x. }; f" _- Z<P>                //让程序开始运行
                //running=true;
}
public void paint(Graphics g) {
  canvas.repaint();
. Y' N6 H8 K9 x$ @% M+ I* C4 N2 M }</P>
<P>
public static void main(String[] args) {
  c. Q+ g" b7 s" [9 S5 H8 z    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
& p* @4 c9 ?8 x, S0 q    Frame frame;
    frame = new Frame() {
) n& f: e# q2 V& N; D3 z5 N      protected void processWindowEvent(WindowEvent e) {
! {  o; N9 \9 u( `9 g        super.processWindowEvent(e);
3 {. d, b* t* p( _        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
          System.exit(0);
6 A  X: h% @8 \- D& i        }
2 u( O: Y+ |5 _0 P+ g# m6 e" p      }
1 J0 G. {, F( {5 u! t0 q' A: O; s      public synchronized void setTitle(String title) {
        super.setTitle(title);
# v9 k1 g, C# B- c        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
    };
    frame.setTitle("Applet Frame");
" t( _9 N$ Z; \: |5 |$ b& r    frame.add(applet, BorderLayout.CENTER);
    applet.init();
& }" X' m8 {5 m( O, Q    applet.start();
    frame.setSize(300,320);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
% T( w0 z- V" g  d, C3 x    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
    frame.setVisible(true);
: k& L9 M% I! ?6 q8 ?0 E/ P  }
3 e" L$ b5 L* n. u  h# l0 s/ i9 Z7 Z  public void start()
  //下面三个函数是控制线程的
. T4 E& `! c+ h+ I; k+ U" V! O2 k {
  if (runner == null)
  {
   runner= new Thread(this);
   runner.start();
8 M4 j5 I$ Y) U1 ?! @  a   //running = true;
/ \* w3 t9 a5 K8 R  ?3 U2 l  }
}</P>
+ r& `) ^! L4 D5 T# L" Q6 p( q<P> public void stop()
{
9 _) `3 @/ ~8 F" \; u  if (runner!=null)
  {
   runner.stop();
3 T) U9 u& H# l" Q$ n) u+ C   runner=null;
   running = false;
) G+ D, o$ G; ?7 I0 F; ^- U  }
}</P>
0 m  a- Y4 d  I1 T" ^0 l<P> public void run() {</P>
. b+ X2 A, O5 Y4 h1 q4 x<P>  int i;
                //线程一直运行下去
  while (true) {
          if(running){
       //如果开始动画，就进行canvas的处理
                          canvas.process();
9 C* S0 Z* ~3 K4 P) S, M) b                        }
    try { Thread.sleep(delay);}
6 I3 ~1 g$ I1 p; A9 z) f    catch (InterruptedException e) {
; P/ d2 r8 M. V0 X4 J   }
$ f1 b& I4 d& c- b  }</P>
6 ~* i" _) o2 \& b3 a' v<P> }
7 K, _8 c6 L4 t4 E( G        public boolean action(Event evt, Object o) {
  b; P( `6 y- ?" @3 t: i! r      if (evt.target == btnMap) {
- D: @1 {: X' ~( J& O+ W                //开始编辑地图面板
+ q7 {$ h1 a: M1 l   running=false;
3 W2 x3 s. I, B9 L" L                        btnStart.setLabel("开始");
) X6 v/ z2 u. P   MapPad ctl = new MapPad(this);
) `3 O! }5 Q) I+ j4 }                 ctl.setSize(308,380);
                        ctl.show();
                        return true;
5 A) Z' n9 ?/ s- e: l) M  y  }else if(evt.target == btnStart){
9 R  h/ T& g4 A                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
9 `: I% ?( k: Q' u8 T) e! J                    btnStart.setLabel("停止");
: S4 z8 Z; t: [6 e6 }5 _+ _                    reset=false;
                    running=true;
                  }else{
( l" ~9 n& O- e! q0 d                    btnStart.setLabel("开始");
                    running=false;
$ h7 p3 h/ R& u. p4 T                  }
                  return true;
" ~7 }5 V. O% P1 M% m0 `                }else if(evt.target == btnReset){
$ y! V/ |5 I) r  Y4 S& U( C1 r4 A                  running=false;
                  int j=0;
& w7 E$ ~: U/ N' k2 q; a  L                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
  J+ r) h6 @% W+ P( V7 x# t( D, c( p0 A                  repaint();
. G. n, d  Z: O; @9 y& g1 K                  btnStart.setLabel("开始");
0 A+ s" s" h8 Q3 r$ V                  return true;
+ A3 W7 m: f$ Z! G  H                }else if(evt.target == btnConfig){
                        running=false;
9 ?- |5 t( M" X1 u! w- v                        btnStart.setLabel("开始");
     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
                        ctl.show();
                        return true;
: k/ b* B5 n* x4 i0 l                }else if(evt.target == choPDraw){
8 i+ J9 H' k9 o) d1 F                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
  z8 S% i5 v5 W! b# y% x8 A                  if(drawPhe!=1){canvas.repaint();}
                  return true;
                }
                return false;</P>
: u, y' k' e& A4 K$ y$ k9 |5 H<P>        }
' Q7 H( F- A- Q0 T0 u3 Y) n7 v /**Destroy the applet*/
  public void destroy() {
  //当结束程序的时候，把线程也结束
    if (runner!=null)
    {
       running = false;
; L: a/ X' ]' g& f8 I       runner.stop();
       runner=null;
    }
; j: _( U% V( M) y2 V1 `; K3 }. _  }</P>
<P>}
</P>
# L5 V+ |0 X; ^7 J# h

/ \. @$ y8 ~1 ?2 x0 X4 ?
<P>package ant;
import java.awt.*;
% _, {; r  C3 B$ d5 N' vimport java.applet.*;
: a3 {) A. p% f9 e- |6 B/ U0 Bimport java.util.Vector;</P>
+ g* ]) B1 _4 G1 V: {2 x8 @: ]! P: {& A<P>public class ant{
. D6 e# ?. _4 N0 m: ] Point nowPt;//当前点坐标
4 J# i& G& G  l9 K int VR;//速度，每次蚂蚁能走动的最大长度
; F2 J8 V  s9 U" u  int id;//标识
  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
  o/ |4 }6 Q- I9 B5 p# J- U% T Color back_color;//背景的严肃
int height,width;//世界的尺寸
% G# D0 I5 ]% |, y9 G# T, Q; u        int Phe;//每次释放信息素的数值
  y" }5 q* A  h$ b3 |& X Antcolony local_colony;//主程序的指针
- H$ Z4 N2 a2 S! a        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
8 Y$ f* H  o+ @        double Main_direct;//主方向
- v6 y0 W" T3 g' ~) ~4 n5 m        Point FoodPt;//记录的食物点，是否找到时候判断用
        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
( m  a) G! D3 X/ a5 H# Q        Point StartPt;//起始点，是窝或者食物
0 s+ M7 W0 x5 I2 M7 r        int FoundTimes;//找到食物或者窝的次数
. L+ q) ~6 E& C- B6 t' x& _: C, D        int Max_Pheromone;//最大能够释放的信息素
& T6 T1 j& S' u+ y        int Pheromone_count;//当前还拥有的信息素的总量
7 O" Q+ }5 G6 c" ~5 M5 U        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
2 E+ ?7 l2 ]* Q0 p* W1 X) N- l        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
9 D* w  ?2 s* E; R0 v6 o        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
* p2 h/ v3 g  Y$ q; h/ }% |, d  nowPt=new Point(nowpt.x,nowpt.y);
                OriginPt=new Point(nowpt.x,nowpt.y);
9 z! K  _- T8 a! W1 s- _                FoodPt=new Point(nowpt.x,nowpt.y);
  k6 s  w6 A+ a  A5 ]) N7 K: ]                StartPt=new Point(nowpt);
6 @0 K) c* t, {$ m3 `  d                AimPt=new Point(nowpt);
5 [! a9 X8 H+ _5 c8 s                lastPt=nowPt;
  VR=vr;
- n8 E# Z1 S" }$ M- M  id=idd;
  color=c;
  back_color=Antcolony.BACK_COLOR;
7 r& X, M) }8 ^  M  height=Antcolony.height;
  width=Antcolony.width;
  local_colony=colony;
" @7 D/ H7 \% s9 L                Phe=200;
                mistake=mist;
: C- r% B4 p8 Y5 H                HistoryPoint=new Vector();
                Main_direct=-1;
                FoundTimes=0;
                Max_Pheromone=local_colony.Max_Pheromone;
8 h+ |  k1 u6 S/ {, g# k                Pheromone_count=Max_Pheromone;
                memory=mem;
! y. F; ]8 y8 K3 Z9 b                Count_distance=0;
, c0 _- {# h; c8 t                Min_distance=-1;
}
. o9 P6 w  }# V! r5 Q2 X        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
' H% K8 B6 ^( {          Main_direct=-1;
          FoundTimes=0;
* L/ d! g" Z+ Q          Pheromone_count=Max_Pheromone;
( k  |+ u4 J( A; t1 m: P. x3 ]          Count_distance=0;
          Min_distance=-1;
5 P: @  n/ @" }        }
public void Draw(Graphics g) {
          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
! @. Q9 }6 p: O9 P  g.setColor(back_color);
- Q/ |3 }8 }4 C. z  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
  g.setColor(color);
2 q% S. l( U6 f  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
/ a$ X% J4 `9 ?. U! w }
4 H1 S' V3 ]. j: G1 ^5 T4 K public void Process(){
        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>
& d4 D* a/ |' E9 I* V  C# q
<P>        if(Judged==false){
+ H: h) q7 h, d" ], |          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
; ?9 ~3 N0 s0 f2 `          if(JudgeEnd()){
4 E) ^! O6 n* y/ ^; o              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
              return;
1 P+ H: c- g6 _9 N0 {          }
' L3 h8 M- K9 f        }
0 ~& x) g$ P- t8 f8 P        Judged=false;
5 M& c/ Z; T$ s        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
5 ?( l& N0 W5 a. E$ H<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
* N* A" o6 ?# K, U* u        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
        deltx=(int)(VR*Math.cos(direct));
        delty=(int)(VR*Math.sin(direct));</P>
$ E0 X& G! g( I) {+ n# q<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
1 R6 Q5 A! o  A' r4 E1 [, n<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
& X8 W1 z- t% B5 a" a          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
! k7 z0 e! X3 t' `2 H3 n8 U1 x8 f) \<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
# A! m$ I, B3 n. y          for(int x=-VR;x&lt;=VR;x++){
             for(int y=-VR;y&lt;=VR;y++){
( y. J4 N$ \. \9 \4 a                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
7 w; k. w9 Y8 N# C                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
                int yy=(nowPt.y+y+height)%height;</P>
<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
' n( P; z& ^9 B                  //的到要搜寻的点的信息素
( p6 C0 k; }/ ~, z4 U5 h                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
2 m) N" V* r, I0 v<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
( e- J! O* F6 n0 _<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
- b! _/ N% p4 H                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
! J& P. U. N" y+ @                      double ra=Math.random();
# s: I1 G4 P8 m0 n                      if(here==0||ra&gt;mistake){
/ w, O8 D2 B9 n7 S* H, V! U0 M                          boolean found=false;
                          //查一下内存最近走过的memory的点数，从而避免当地转圈
; O8 @% O7 O1 {' ]; s1 a                          int size=HistoryPoint.size();
                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
                          for(int i=size-1;i&gt;=size-minsize;i--){
                             Point pt=(Point)(HistoryPoint.elementAt(i));
* p, n) w, N$ Z2 c$ J7 x  w; a                             if(pt.x==xx&amp;&amp;pt.y==yy){
. m; g% S" X# f                                found=true;
                                break;
                             }
                          }
% Y. X- }+ Y9 Q5 l2 ^- h7 e; b                          if(!found){
                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
' x% E8 }0 [7 V                            deltx=x;
                            delty=y;
: m+ n5 I( q" f1 g                          }
                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
                }//end if x!=0
            }//end for y
        }//end for x
  s) ?: \2 ]2 c  P1 S        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
        pt=Evade_obs(deltx,delty);</P>
5 W" h" Z$ S& }; Y8 G8 v2 l<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
          pt=Evade_obs(deltx1,delty1);
: O' q% B( w  X% `: w% j        }</P>
<P>        //播撒信息素
: p0 h2 m* E. p6 ?        Scatter();</P>
; `7 _6 N2 h9 u. q6 M. ~& D<P>        //记录走过的距离
, j4 O% p5 w9 `3 M* L7 ?        Count_distance+=Distance(lastPt,nowPt);</P>
<P>        //改变当前点位置
) f" {% e: h, v0 l* F: A        lastPt=new Point(nowPt.x,nowPt.y);</P>
. g3 E* e8 n: u6 o" ^<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
$ c% Q9 q* D( m/ P& c        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
! G$ Q. S+ q  A. t        if(HistoryPoint.size()&gt;memory){
9 |* w# K7 X& F7 z          HistoryPoint.removeElementAt(0);
% _- d! w6 }6 K9 N5 ^& M        }
6 Q. \( U6 P& A0 w2 _5 s; Q        nowPt=new Point(pt.x,pt.y);
3 @* g3 I+ j+ A/ ^# X8 Z     }</P>
<P>
. _9 A- [: \+ y; R" z' ?$ m        private void Scatter(){
, ?2 C3 e7 E( Z% ]        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
' t1 w0 Q$ ?) m- e7 n; [& c/ F            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
. k& j6 I* p9 D1 J6 N; l' i+ `            int kind=FoundTimes%2;</P>
% v& F0 f: P4 I( G1 ^<P>            //获得当前点环境已有信息素的值
, o& q5 j/ S9 b3 Z9 ]0 d  v            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
. m' u- c; m) D/ W& A/ S            boolean ofound=false;
            if(Phec!=0){
8 m. ]& b! |( J7 _* w                //如果当前点已经有信息素了
                for(int i=0;i&lt;local_colony.phe.size();i++){
( Q. J) S$ p+ c# w! V* C; ]                    //在信息素向量中查找该点的信息
                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
6 j8 y3 j' s6 |4 }* {6 c                        ofound=true;
9 E, w( x$ e$ s7 q) S$ D                        boolean found=false;
                        if(size&gt;4){
1 q8 r: z/ b$ j* [+ U* G                           for(int j=size-4;j&lt;size-1;j++){
0 p. ^8 p$ K# p3 b2 j                              Point pt=(Point)(HistoryPoint.elementAt(j));
                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
$ z! W/ J4 s6 `( T: @" v, U- J                                //如果当前点重复了以前走过的路，就不释放
( V$ X# ~8 ?" j% p% i- Y                                found=true;
4 _& P4 j6 u2 }- Q                                break;
) z. k* Z7 _+ |1 P. v8 o# M                              }
                            }
                        }
                        if(!found){
                        //如果当前点不重复，则开始撒
4 @4 Q7 P2 J. E2 G3 ^. ?5 }( p                             ph.Add(Phe);
8 ^* b- b; l+ h                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
" p. |; G: g0 m( U7 x6 a: W: p" Z<P>                             //让还剩下的信息素总量减少
6 p+ g9 a+ L/ {                             Pheromone_count-=Phe;
                        }
; r& [5 Y# }( D+ y. P                        break;
. b1 {- X' _' L7 c* R/ a6 z, M* O                    }
& [3 f0 _1 H: {                }
              }
1 H) w6 a" s* t0 a" e. D/ t. E- I          if(Phec==0||!ofound){
& |* o- `/ S' B7 ?* @            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
7 C, q$ Q. |; S, h% c                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
                ph.Add(Phe);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
' _7 Y7 I; ^( c8 _, p                local_colony.phe.addElement(ph);
" }. D6 ~7 |( C1 S  N( n6 m                //让还剩下的信息素总量减少
, s+ y9 t- V# p& D6 q                 Pheromone_count-=Phe;
           }</P>
<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
; \) ?# s1 t! e. q# b& p           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
; U2 G2 E* p% [% p8 N3 p6 x* S           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
9 s& s# u( O" [6 u% ?8 A  \& q<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
# c4 d! B" m( K4 W        }
private boolean JudgeEnd(){
    //这个函数判断是否已经找到了目标点
    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
! B$ w4 d3 d7 q+ O! V    if(kind==0){
% S8 M% ]: e( F8 J4 ~        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
        int i;
) f; A5 |* t3 @# m  B- r$ C        for(i=0;i&lt;local_colony.EndPts;i++){
            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
              //如果找到了食物，就直接移动到食物点
1 Q- W* t/ B$ `: n) E              lastPt=new Point(nowPt.x,nowPt.y);
9 q3 m4 d1 J) w3 c0 u              nowPt.x=local_colony.EndPt.x;
6 q( O- M: n9 t              nowPt.y=local_colony.EndPt.y;</P>
<P>              //计算最后的总距离
' J$ j8 ?3 B: G+ Y              Count_distance+=Distance(lastPt,nowPt);
6 y' ~  \2 B: b* T              //比较大小，记录较小的距离
& o/ N9 V; o6 h8 L              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
              }
' |) q/ _, E* `; ]+ P              //清除总距离记录
9 Y0 R. a  B; b- t              Count_distance=0;</P>
<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
% P8 n1 y# J* o" Y% ^  y5 H              AimPt=new Point(OriginPt);
& b! ^/ p0 V/ f) i( F              StartPt=new Point(nowPt);
              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
! |9 [# C% ], i$ z. R2 Q4 t6 {<P>              //找到了食物就把找到次数+1
& s# x) v& I2 d, r' B% t              FoundTimes++;</P>
<P>              //改变主方向为原来方向的镜面反方向
. {: k, }* O  K. u: u              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>              //重新把自己能撒的信息素置为最大值
5 R3 ~1 E$ L- l7 |              Pheromone_count=Max_Pheromone;</P>
" ~7 U+ L( s5 Q, D. k<P>              //清空记录的所有点
" L1 f& p4 ?$ g) [/ X+ p$ ~1 x4 V7 D              HistoryPoint.removeAllElements();</P>
  u$ J) U0 R1 \' Q( O; c% J<P>              //返回找到为真
( q  z! G9 N3 U: ~              return true;
" ~' X. ~) w! r9 W( T  \3 Z            }
        }
* j# e1 P1 }+ W5 H5 P6 \! g      //否则没找到
      return false;
    }
/ I2 w) ^9 W/ d/ J' V( A    if(kind==1){
        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
( L% ^1 f7 ?# V0 P; O; @            lastPt=new Point(nowPt.x,nowPt.y);
            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
# u# Z( A" l7 l! g, w" E, N<P>              //计算最后的总距离
) d& q. `% F9 e: y1 k8 Z              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
- B; y$ G# C# b$ n$ P/ H1 G2 u              }
              //清除总距离记录
1 Q% y& G! @2 T+ [/ j- M# i1 u! D  ^              Count_distance=0;
; ~( [" j9 j6 R+ l- Q5 d0 |6 r& A            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
            StartPt=new Point(OriginPt);</P>
/ t& u; e+ s' B/ A6 Y) O<P>            //重新置信息素
1 m# G1 R( |0 T0 B2 }) ]8 s' z            Pheromone_count=Max_Pheromone;</P>
! [2 l$ q; C! o/ E4 `2 J<P>            //清空历史纪录
, [0 t: W9 ~2 k) P            HistoryPoint.removeAllElements();</P>
, u  t- k' _& u<P>            //主方向反向
; |+ Q' n, P" {. z2 P3 {3 ]            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
. k! m4 [3 k1 i1 Z0 K" e5 H2 h            FoundTimes++;
( B9 D( @1 u  l( {/ t9 D' r            return true;
, c+ O# h' O* K+ U. }8 [, v) i! T        }
4 @: i2 j8 d* P8 t( u        return false;
    }
    return false;
( X9 q# |! J' G+ V& _9 X}
        private double SelectDirect(){
                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
: }: ~- m/ }$ p  ~( C4 B5 B4 S                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
        e=2*Math.PI*Math.random();
% m- _& L2 l$ \& L. D2 @                      Main_direct=e;
                }
$ i" q# T! v. w. U: J                //选择主方向角
                direct=Main_direct;</P>
9 C* e) h: k; A! q9 O1 r<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
; @5 ~" v# o6 l                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
9 l7 Z3 [. [7 y; ?                double re1=Math.random();
                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
, k; q. U0 O# D, d# u0 o                  int size=(int)(re1*memory)+1;
2 w+ u3 k. h; q4 R4 T% e7 f% u                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
                       Main_direct=GetDirection(pt,nowPt);
' z, l! O) L$ _" \                    }
                  }
. m' M0 D" M2 N/ P4 `: H) P                }
( o, S' o) \* I) r: ]0 W' I               return direct;</P>
<P>        }
        private Point Evade_obs(int deltx,int delty){
              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
; r1 Q( v: ]# l9 t. Y              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
9 o9 R: Z0 F# U3 C/ G              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
/ ]5 {& z: }. c; X- S              Point pt=new Point(0,0);
              int x,y;
              int delt=deltx;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
; e$ u) R$ W* R( r7 o: x, |: h4 p              if(delt==0)return nowPt;
% G- [( m; a8 Q# k3 G( K  l9 `. B8 V              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
# G$ z+ `; f+ o                  x=(x+width)%width;
                  y=(y+height)%height;
                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
                     double disturb=4*Math.PI*(Math.random()-0.5);
                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
                     break;
( G# I! V: o* A! G: o8 U                  }
6 P) B- v: B" v; ~* a  y( W                  pt=new Point(x,y);
# J' v6 D1 A, o9 D, v9 c4 C0 U                }</P>
' |% c: }. j6 G0 n/ V# l<P>                //计算得出实际能够到达的目标点
$ J, w5 ?: v* p* V2 Q1 }5 g  x=(nowPt.x+deltx+width)%width;
" u1 C3 M1 U, M5 C6 x8 n$ |  y=(nowPt.y+delty+height)%height;
         return new Point(x,y);
9 U& r$ Y# e$ D        }
        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
) Y  s' M0 w' e( e        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
        //其中方向角是所有可能的角中使得两点连线距离最短的角。
: I- C, I6 K: V6 v: u3 t               double e;
               int deltx1=pt2.x-pt1.x;
; g; z& H% a% }9 S               int deltx2;
( N' j% J1 j% m& k9 N2 n               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;
1 n0 @0 H3 J$ h               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
* S, O# t+ d! x, O               else delty2=pt2.y+height-pt1.y;
* G% l" j5 |  ]" {$ {$ e  `               int deltx=deltx1,delty=delty1;
  n$ @5 k% t* W               if(deltx==0&amp;&amp;delty==0)return -1;
" ]' J) A. C! l8 D9 g               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
& d3 ^( @$ ^/ ]+ M, _& t7 o6 o               }
        if(Math.abs(delty2)&lt;Math.abs(delty1)){
4 C# e, ~+ s+ V( i' z                  delty=delty2;
               }
, G1 f7 T% T4 F4 T6 M' V               if(deltx!=0){
# {# M0 Y2 ~; _3 D3 W9 f                    e=Math.atan((double)(delty)/(double)(deltx));
                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
                       else e=e+Math.PI;
                    }
                }else{
. l( s/ D" ]' \4 S5 g                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
' b3 O" ^9 w% F$ i* j! o                }
                e=(e+Math.PI*2)%(2*Math.PI);
6 m0 Z* s9 D/ b. U; j# {+ B& @                return e;
  a" F: t6 `7 p7 C! Y        }
' O+ T8 J2 t4 f- V6 J7 d        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
8 I/ j) n5 D* f6 T8 y& t            int dx2;
            int dx,dy;
- @: [) Z4 s& f% G! z" ^            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
# V7 u/ |9 ]( v, n, s            else dx2=pt2.x+width-pt1.x;
            int dy1=pt1.y-pt2.y;
            int dy2;
1 O$ d* C2 R3 v: y. K+ o            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
            dy2=pt2.y+height-pt1.y;
9 `% g5 e' u7 o+ {            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
            else dx=dx2;
" R, o, F7 C: N7 U            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
            else dy=dy2;
            return Math.sqrt(dx*dx+dy*dy);
5 q; X' m7 B! m8 g: f        }
8 S5 e" ?/ D+ N; H" z, T- i    public void clone(ant ant1){
) d# J( C& i! y' H7 z        //把蚂蚁ant1的属性拷贝到本蚂蚁
! D4 y  U# q  [     nowPt=new Point(ant1.nowPt);
, @0 h. y8 b  V( p# T2 u) L        OriginPt=new Point(ant1.OriginPt);
" _, _- C2 J) Z8 j" _* |        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
        lastPt=new Point(ant1.lastPt);
* h5 |, l. D4 b; @7 d) J3 s. k4 \6 E        VR=ant1.VR;
/ G# o0 C1 O+ J' R- j1 R        id=ant1.id;
        color=ant1.color;
! `" C: Z6 c& m1 h& T+ q        back_color=ant1.back_color;
  F2 Z+ }9 r9 G6 N( C: J        height=ant1.height;
        width=ant1.width;
) j9 Z, R" J! Z; E7 C. d4 b* e- B        local_colony=ant1.local_colony;
8 t' \/ u" d: B# r        Phe=ant1.Phe;
        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
( O7 h' L3 M4 X        Main_direct=ant1.Main_direct;
# d5 a# b# Z8 J# h        FoundTimes=ant1.FoundTimes;
! r( V  a! O6 B+ h        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
; y+ h& R) I, ~- h6 R* x. R. Z        memory=ant1.memory;
        Count_distance=ant1.Count_distance;
  P+ J* t5 D, M' R. d' `        Min_distance=ant1.Min_distance;
3 C' a0 L- `/ ]9 A4 r    }
! ~  y  C0 m* k# Y}</P>