[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
<>package ant;
5 N2 c  g( x5 z9 |& m- E/*
  P0 }- h1 d" R9 _& H- Y$ }: n * @(#)Antcolony.java 1.0 03/05/22
*
* You can modify the template of this file in the
7 H2 u, M0 L0 w! k0 ~4 n * directory ..\JCreator\Templates\Template_2\Project_Name.java
*
* You can also create your own project template by making a new
* folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
*
0 [8 N2 {2 r, t* O! n9 F3 ^8 m# d */</P>
2 v- Q% [3 b9 q4 z  u: R0 j/ I<>import java.awt.*;
5 Y' z2 }& I: _, O7 f* S' q. I! yimport java.applet.*;
import java.awt.event.*;
import java.util.Vector;</P>
<>class AntCanvas extends Canvas
8 l4 v0 J4 T% I$ q/ ?{
    //画布，一切画图操作均由该类完成
7 }5 _& E! b. E //Image image;
* ]" ]4 Z* ]' W" Y Color obs_color;//障碍物颜色
) T4 U; C" ~$ s+ f Color origin_color;//我的颜色
' U- e# t. h- i" w7 ^$ c Color back_color;//背景色
% `2 f0 u* H& ?  ^1 \7 P! a        Color end_color;//食物点的颜色
2 Y/ K* q9 P. i //boolean first;
boolean reset;</P>
! O# \* x9 O% b; F* \" l0 _<>/* public AntCanvas(Image img) {</P>
<>  super();
   image = img;
  t) ^4 t! H3 k" m0 T  p# y' g  obs_color = Color.white;
  setBackground(Color.black);
: \) l7 \9 a9 |& N1 U/ o8 o  setForeground(Color.white);
  first = true;
9 E2 o7 f9 s9 m  reset = false;</P>
, D( u, P' r" b8 Z<> }*/</P>
<> public AntCanvas() {</P>
; P! w& `) X$ p/ A" Y<>  super();
. z% ^3 Z" `0 K4 M3 C  p   //image = null;
! B) @  x! t0 }! ]   back_color=Antcolony.BACK_COLOR;
8 N3 r7 l# g/ w: e: m' w. m  setBackground(back_color);
) J. P7 V9 a7 }& t- `- N  k8 W  setForeground(Color.white);
8 o: o( j- ^0 c0 K+ M, U2 x  obs_color = Antcolony.OBS_COLOR;
  origin_color=Antcolony.ORIGIN_COLOR;
8 C5 ~* H. n) L& X) z* O8 `# h                end_color=Antcolony.End_COLOR;
' v1 P& Y8 |3 }9 ?# }  //first = true;
  reset = true;</P>
7 p  P' S) f( O+ ?- l<> }</P>
<> public void Clear() {
        //清空画布
* ~/ ^9 a0 c5 Z. y  reset = true;
! V- I* }' R; r* Q  repaint();
}</P>
  z. K: @5 ]' s# K! h% w' \3 A<>
5 I# S( ]3 }1 ]2 m1 Q public void paint(Graphics g) {
# X& E9 Z' u* n  int i;
                //重画的时候仅仅画障碍物
' a  W& e. }/ |, n6 J5 c7 ?( ]  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
# i0 N( C9 @9 Z! Q  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
, U5 H2 n" j2 u. r1 d; J   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
) D' ^; Z8 Y/ W' ]( A  }</P>
) \( [* d9 T8 n9 u! |( ^0 E<> }
public void process(){
/ j- Q0 l0 b/ Q. n        //处理动画的过程
  Graphics g=this.getGraphics();
                g.setColor(end_color);
3 y* s4 W, V' `& U6 i4 k1 O   for(int j=0;j&lt;Antcolony.EndPts;j++){
                  //画所有的食物点
) H0 G2 @+ T2 i( m( |* H+ O                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
2 t" o& N5 Z) f/ o' _/ I5 [                  //每只蚂蚁开始决策，并画蚂蚁
   Antcolony.ants.Process();
  O: c# D. S( x- \0 c* O   Antcolony.ants.Draw(g);
  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
, X* |* \/ v4 A! ]4 D                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
' [+ O/ `+ N4 W! h2 s0 I                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
" y# o, f6 M, k: b3 W6 b7 Q) J                        case (1):
4 s" |" Y* I* f2 _# |7 G: o                            v.Draw(g);
                            break;
. t1 Z, B- r2 j3 K" X( o                        case (2):
( U4 b3 I+ ?( r/ U* G8 V, |                            if(v.kind==1)v.Draw(g);
/ N$ l$ A" ?+ [4 y                            break;
& ^3 J3 P$ k+ D, p                        case (3):
                            if(v.kind==0)v.Draw(g);
                            break;
9 @0 r, \  @! H                        }
                        v.delimit(g);
* F1 U- Q& z0 ^4 @5 x                }
           g.setColor(origin_color);
# s) r: I' h! ^                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
                }</P>
<> }
6 e; L; a# g$ t Graphics GetGra() {</P>
<>  return this.getGraphics();
}
}
public class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
- B# A/ e: E  | boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
# h4 }: ^! h5 P1 |5 \% v4 y static Color OBS_COLOR=Color.red;//障碍物的颜色
: ^: }4 f7 s. |+ b5 d. v. D6 d) } static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
& W  M" j4 q0 G& P7 J static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
( u* }2 v/ C  h9 y AntCanvas canvas=new AntCanvas();//画图用的画布
' L- y5 I/ P  n! s1 S1 v. w int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
5 ^; O" [3 Y2 c: N        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
& f! _  t. G& y/ d; `  F$ s" T        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
- D# O( E' g3 b# X8 }' ?  ?! z static Point OriginPt[];//窝点信息
        static int OriginPts=1;//窝的个数，最大为100
$ P4 A0 O& f: M8 R; k5 X6 K static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
2 E( k" _) k- r/ T; r! H        static int FoodR=10;//食物和窝产生梯度的信息素的半径
6 y4 \4 I# k: |3 z static ant ants[];//蚂蚁数组
% O3 c7 c5 I, w        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
* m. j& ^" e1 ?; F int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
; x9 q9 }+ l$ X" b/ S* x) }' A% |        Button btnStart=new Button("开始");
" A. [0 E3 L5 X* A        Button btnReset=new Button("重来");
8 y# S: V" ?* ~8 S7 ?8 H, o        Button btnMap=new Button("编辑地图");
3 C! q" T8 \5 M: H7 v        Button btnConfig=new Button("设置");
6 R: U$ r$ }/ P7 _& o        Choice choPDraw=new Choice();
public void init() {
                //初始化函数，先画各种控件
9 J2 t- T4 i6 a; x. F6 v) z  setLayout(new BorderLayout());
                Panel pan=new Panel();
4 y7 y8 B5 F0 _3 \& f" V% j5 J# ?                add("South",pan);
  ~# |. e1 g( u1 @0 ?7 m* L                this.add("Center",canvas);
                pan.add(btnStart);
                pan.add(btnReset);
                pan.add(btnConfig);
0 x* l- M. u; ]6 F                pan.add(btnMap);
                pan.add(choPDraw);
* S* P; d- g2 r- g% g- Z$ x                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
# X/ @4 e# L- s  m                choPDraw.addItem("画窝的信息素");
8 @9 s# q3 O" N* G0 g4 j+ v                choPDraw.select(2);</P>
5 c, n) T. V5 ^" i8 z* M<>                //初始化各个数组
* W' v6 i* {( v/ t  obs_grid=new int [width][height];
                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;
; K0 A5 D. K: x+ x! k                                }
$ m; u. N& u7 ^   }
+ D$ }& @  Q0 M) w0 U  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
* ]/ [; [2 I; _0 A8 @* G! `                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
- u/ ~, Y) f8 M9 q- D4 D2 c  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
                int grid[][]=new int[width][height];</P>
; N4 h) {4 W1 Z* j% V$ d7 q- N<>                //下面从地图库中加在地图
" R5 E; `) M, V$ |* V/ _                Maps maps=new Maps();
* K7 A5 b0 B$ ~2 C0 W" P+ }3 B                maps.LoadMap(grid,0);
0 d+ N6 G2 y# c8 M- U                //初始化地图
                reinit_map(grid);</P>
- k  J1 P' n( e* S! Z9 Q  w<>                //初始化所有的蚂蚁
  reinit();
}
        public void reinit_map(int grid[][]){
                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
6 w4 U- [+ ~% l, g9 ~/ D" I( }3 w                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
<>                //先停止程序的运行
                running=false;
; j* P- ]' n0 b! {                btnStart.setLabel("开始");</P>
, ^6 ~# L1 U2 {  l% O<>
                obsCount=0;
                EndPts=0;
% r% v$ }$ [8 I: `                OriginPts=0;
2 F( L0 ~. N. j" p* A* X% |5 S1 S                obsP=new Point[width*height];
1 R5 x+ n; G5 r7 p/ R+ _! {                OriginPt=new Point[100];
  _$ F- z9 O% N                EndPt=new Point[100];</P>
<>                //清空obs_grid和Pheromone两个数组中的值
1 N& H( y+ H0 Z+ K                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++){
0 V: o9 G6 c: ~/ V                                  Pheromone_grid[k][j]=0;
2 g5 b7 d  o8 R* E5 j                                }
   }
  }</P>
8 q! S  }$ \$ q$ L8 ~7 ~; Y" {<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
                    case 1:
                      //如果grid[][]存的是障碍物
/ k( V8 t0 f, p: M8 s                      obs_grid[j]=obsCount;
0 @. V6 U5 T; V4 w9 r                      obsP[obsCount]=new Point(i,j);
                      obsCount++;
                      break;
& T  a# W6 e# B& t                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
& c1 q# B. k5 F  G: G                      if(OriginPts&lt;100){
                          OriginPt[OriginPts]=new Point(i,j);
1 O- o4 f3 Q; C% h8 m! q! x+ N- q                          OriginPts++;
                      }
- [8 t' D1 f! u3 }1 k4 t                      break;
                    case 3:
" U: n0 |0 m6 N* N9 P5 r' c                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
5 B7 @0 r$ y8 H' b, x# q                      if(EndPts&lt;100){
: `6 m% Y9 R9 x                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
                      }
- O4 b' E3 f( m. G7 y2 f                      break;
                    }
                  }
% t- i1 [- |: x  o  g                }
            //如果没有指定窝，则随机的选择一点
            if(OriginPts==0){
8 d" m8 Z# b' R. {! d' C9 P              for(int i=0;i&lt;width;i++){
                int  j;
9 ~# j+ e5 F3 O8 `                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
                    OriginPts++;
                    break;
+ t* j8 f; J; a                  }
                }
                if(j&lt;height-1){
4 ]9 V8 m" ~9 m# r                  break;
                }
              }
            }
        }
public void reinit(){
: P8 I, P) K6 _+ i6 s8 ]                //重新初始化整个环境</P>
7 ^5 @8 C" o4 H3 X+ }# J- _+ F<>                //先停止程序的运行
; H4 x4 L2 V. e( X$ L9 y+ [                running=false;
. `/ h% n. G8 O, {& E                btnStart.setLabel("开始");</P>
<>
$ I7 Z/ b) F+ t  W0 r/ }  //清空所有信息素Pheromone数组中的值
# @/ q+ R9 X- o                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
4 r$ L0 B+ Q: Y2 T; ~  M! U                                for(int k=0;k&lt;2;k++){
9 e4 F1 b  P( n) g' [+ I                                  Pheromone_grid[k][j]=0;
5 \' t- k* ~6 i' P' b                                }
2 `  \0 d* I% H) J4 t/ a7 ~- m   }
) N) |/ X8 l" M" q. |& I' H( s6 G  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
/ V! y6 {* W& C0 U- m; l! L- F        for(int i=0;i&lt;antCount;i++){
1 P/ l% ~3 ~( k+ r8 e                        int index=(int)(OriginPts*Math.random());
          ants.OriginPt=new Point(OriginPt[index]);
                        ants.init();
& z" s, r" s+ p7 V* u( W1 B* u  }</P>
<>                //清空信息素向量
6 R6 _# b: o* i" N# R# g                phe.removeAllElements();</P>
<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
+ i: E" y6 c( P- r4 O8 {. f) a  for(int i=0;i&lt;EndPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        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));
8 V; t/ c+ U8 e+ c: M8 H) Y, f& r* x5 Z                        }
7 E1 B2 \) I2 y1 z4 p  W( J! M                    }
                }
                for(int i=0;i&lt;OriginPts;i++){
3 m) X- J3 h2 b4 J8 V                   for(int x=-FoodR;x&lt;=FoodR;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));
                        }
) x: R) |! s: Y5 L0 Y+ F/ \( t                    }
9 r5 J7 @8 @- K& n& B, W                }</P>
: l; c( w7 O( w# N3 L<P>                //重画
  canvas.repaint();</P>
<P>                //让程序开始运行
' r: o* P" D5 w: z* W                //running=true;
}
; P0 i  C5 \1 g& x8 J public void paint(Graphics g) {
$ E- o5 S/ h+ X" E& w  canvas.repaint();
}</P>
<P>
) ?# A& I3 i) Y( w% V( ?public static void main(String[] args) {
/ u7 ~3 A& A+ }0 G, V    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
    Frame frame;
    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
7 c  D9 ]* I% X  ]        super.processWindowEvent(e);
        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
& c; m4 r. u' }# u          System.exit(0);
) D  y# X+ z# x; d& L( Z; |        }
      }
+ A9 I3 P' p7 v2 Z- \% q. L& w8 N. {9 z      public synchronized void setTitle(String title) {
9 f- i. b6 P6 B% b* }* s        super.setTitle(title);
) T1 |2 z: M$ }$ R+ I( l7 E        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
* c1 E* K) N+ K* t6 j/ C, x      }
+ w. Z/ B1 C8 k% I* C- j$ K    };
    frame.setTitle("Applet Frame");
* a7 I9 w7 D" e4 P+ _" v' }# k    frame.add(applet, BorderLayout.CENTER);
    applet.init();
5 j  Z! R; P! J, _8 b+ B    applet.start();
    frame.setSize(300,320);
$ k2 l! i0 ~* H) W* D    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
  t4 B& V: q7 ?; d0 L, ^/ @" J    frame.setVisible(true);
% y* k' @2 R6 I4 V. q  }
  public void start()
  //下面三个函数是控制线程的
' a5 I$ p9 o; R: c# e$ g6 j1 D% t {
  if (runner == null)
  {
1 E3 E" t' X8 c2 U3 |   runner= new Thread(this);
- O( A% J$ b$ H5 j0 u( d3 l' c   runner.start();
   //running = true;
1 b) `1 E% ~2 ]/ g8 A) e  }
- ~9 o; F( t6 ]; x }</P>
  m# ?1 t! e8 t* I3 x5 N. G- a, [<P> public void stop()
2 z2 x8 A+ o# @! p {
  if (runner!=null)
: [3 w; P! e1 {  {
: J& H+ k4 U, P& }( ^5 c4 N, A   runner.stop();
6 _0 J- d0 Q. r" |4 [* ]% H5 i   runner=null;
4 \& M$ Z. W( [) x2 L   running = false;
/ L" o. x1 Z9 v0 ^$ w$ d  }
: W3 v. j$ T* L: B2 K: X1 l }</P>
: R6 ]- t- J: j$ l; s" `<P> public void run() {</P>
<P>  int i;
                //线程一直运行下去
4 L/ S! C: w8 Y: V/ F! `3 e# K  while (true) {
          if(running){
       //如果开始动画，就进行canvas的处理
                          canvas.process();
" X) G4 ~# j! L                        }
    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
   }
  }</P>
/ v$ v! h" y) `- y9 m<P> }
4 D4 R% f  m; |( u" \- x; {3 ?, r        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
3 O% I% ^0 ?; r# u4 |                //开始编辑地图面板
: m) ?8 W# S1 p" D) N   running=false;
, Y) x9 m; u! s                        btnStart.setLabel("开始");
   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
                        ctl.show();
" u4 B: c7 z2 m0 D, N# L                        return true;
( o0 D4 L2 D& u  }else if(evt.target == btnStart){
* j1 l5 J) E+ s; P9 K' s                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
                    btnStart.setLabel("停止");
                    reset=false;
                    running=true;
                  }else{
                    btnStart.setLabel("开始");
# k6 a" ~& S0 l9 b  U& x( w* g. T1 c                    running=false;
$ \! H4 R; o- h9 M8 \                  }
                  return true;
                }else if(evt.target == btnReset){
* x3 D+ U  M: S  P3 r7 a. |( V                  running=false;
- o0 y- m: ~' y7 d                  int j=0;
                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
' w: ~0 b1 J7 }7 Y( A! Z                  repaint();
                  btnStart.setLabel("开始");
                  return true;
                }else if(evt.target == btnConfig){
0 q9 Y- v$ U) |& W3 q& }& f                        running=false;
                        btnStart.setLabel("开始");
0 c' ]$ y" Z; k     Configer ctl = new Configer(this);
# s: d# |4 ]; F$ O                 ctl.setSize(300,300);
7 o" t7 ^) ^; d. O) Y                        ctl.show();
                        return true;
; x" t* F. m& F; [, u3 F  l1 d- z3 ~                }else if(evt.target == choPDraw){
, J- H5 f/ I$ v; t6 p  T                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
$ k, r& }: e/ r+ @                  if(drawPhe!=1){canvas.repaint();}
                  return true;
                }
8 `( {7 H. A. u" t; U! m! Z" d                return false;</P>
<P>        }
/**Destroy the applet*/
) O8 v( e7 q2 S6 ~; c. ]  public void destroy() {
. K4 x  `! I8 H. C; h& H5 @  //当结束程序的时候，把线程也结束
* a6 O6 `  t/ C0 a. m    if (runner!=null)
    {
$ _6 X% S- o9 t/ I7 o! g       running = false;
% _' ]/ ~, Y$ k! t! T( F3 X       runner.stop();
       runner=null;
$ T& S" \" ^+ @8 t    }
  }</P>
/ t) k, [8 Y1 ]5 _- L& e<P>}
</P>



<P>package ant;
6 A$ Z) U/ }0 Yimport java.awt.*;
import java.applet.*;
4 |3 Q5 k9 K% g% y6 u+ Q% q9 ]import java.util.Vector;</P>
' L9 h/ l+ q- n. q8 W1 _/ x& ^) `<P>public class ant{
* @  s4 d: n: h6 u4 Q7 r) \9 v& e Point nowPt;//当前点坐标
int VR;//速度，每次蚂蚁能走动的最大长度
4 \9 o: a7 v  {  int id;//标识
  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
. ~/ C' p: \' M: e Color back_color;//背景的严肃
! E  I2 I, i. `" W int height,width;//世界的尺寸
, u* I, _4 T& n4 w) A7 T5 |        int Phe;//每次释放信息素的数值
' J0 h# p+ L- v4 o Antcolony local_colony;//主程序的指针
        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
        double Main_direct;//主方向
4 x9 E- [6 D  S; r0 ]        Point FoodPt;//记录的食物点，是否找到时候判断用
# b7 m6 {' ?2 q6 y4 s1 d+ `        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
  P" \5 E( }9 y) [        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
, f8 X! y! U$ A, t& m( K        int Max_Pheromone;//最大能够释放的信息素
/ }6 ^  _$ C! J/ a        int Pheromone_count;//当前还拥有的信息素的总量
) G' J* ?, y# T2 n5 M/ D& s- r        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
* f% _9 X  E$ \& P( n  {' l        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
; |6 \& c$ D0 j! V" r, O        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
0 _4 l1 b9 T6 U5 f9 H& b+ E7 t  nowPt=new Point(nowpt.x,nowpt.y);
                OriginPt=new Point(nowpt.x,nowpt.y);
5 n& h* e2 O+ \2 j8 R8 s7 _0 W                FoodPt=new Point(nowpt.x,nowpt.y);
                StartPt=new Point(nowpt);
1 b5 X) Y7 V8 P                AimPt=new Point(nowpt);
$ u' w- d4 M/ J7 Q  y                lastPt=nowPt;
  VR=vr;
  id=idd;
5 ^1 I0 }: H& O9 @8 }# b$ i8 `. U  color=c;
  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
' ]6 t" w  a3 W6 l4 f  width=Antcolony.width;
/ ~+ J7 V; n# k* B1 Q0 n% K% \' S  local_colony=colony;
4 b: X  Q+ D: z  f% [) m                Phe=200;
" U, u/ V& {: `/ _; r5 p                mistake=mist;
                HistoryPoint=new Vector();
6 z  |- |$ [, r6 U  Z5 _                Main_direct=-1;
9 ?4 q0 ~4 a4 Q7 _7 H                FoundTimes=0;
- K$ ]  C% d& ~/ x+ S( Q2 Z                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
8 T8 k- }9 I* N" Q  f/ P7 N                memory=mem;
                Count_distance=0;
                Min_distance=-1;
) {5 P! P2 E7 `4 h% @ }
3 ?& |! b9 ]7 o; [& b0 x) w        public void init(){
          nowPt=new Point(OriginPt);
; @  l6 O- f. Y6 `# `2 Y8 H- J          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
          Main_direct=-1;
  a# b4 Z: q& m, }  ^. m          FoundTimes=0;
" f6 n8 h9 |" v* f# o          Pheromone_count=Max_Pheromone;
          Count_distance=0;
          Min_distance=-1;
        }
public void Draw(Graphics g) {
: n+ A  u; @- y+ W          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
  g.setColor(back_color);
. V; Q$ _; m2 ~4 _3 e  N, N2 U9 X  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
0 p8 m6 ?' l% V1 n- [8 @% d" M! Z  g.setColor(color);
0 Y% V: c8 R5 q* _  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
" X1 b1 ]" y8 D; y/ J# I; O; ` }
% a0 d" [7 R8 P3 z public void Process(){
3 O) @; f$ D% U6 Z  z. b2 p0 I0 `( y        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
8 B0 P! n; e8 {( U) H, k        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
+ F& g! k, ]) }        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

<P>        if(Judged==false){
: A9 B  S% i! f  K! T          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
& S4 b7 G1 z3 c6 Z          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
+ p' }! F5 `0 r7 D6 h              return;
, @8 J6 H& w$ ~$ u          }
6 Z3 h- K4 j4 {8 `        }
        Judged=false;
) W) `, c3 e5 C        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
* r5 a+ I. o9 C' k4 q* e4 \        deltx=(int)(VR*Math.cos(direct));
        delty=(int)(VR*Math.sin(direct));</P>
( \2 w# R/ m% @7 d. Y<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
8 a7 A$ g' F) _        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
- n0 e2 X1 o5 P; i, u3 {- k4 c: d        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
# r1 b3 O  e# o! Q7 ?        int maxphe=here;</P>
3 I% v0 b- Y4 u1 m! [<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
% M& R. z1 g5 w. _7 h' j8 i          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
& S6 a0 t) [6 _) u) ?          for(int x=-VR;x&lt;=VR;x++){
             for(int y=-VR;y&lt;=VR;y++){
; z( ~+ w* c- x; W2 X                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
" W  P4 o. H, V# j* R7 [" n0 m                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
                int yy=(nowPt.y+y+height)%height;</P>
<P>                //循环的时候要除去当前点。
/ A) v" c1 Q$ t& d                if(x!=0||y!=0){
  o4 X4 l( s! O                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
0 H$ I9 t  P5 Z* [<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
- _" M! E, \; [5 V                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
. K. J$ A( h( v# X' @2 }( v3 @. D                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
, b+ {( e/ ]2 k, O8 y) c                          boolean found=false;
                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
: T3 o3 n( d0 }- q                          for(int i=size-1;i&gt;=size-minsize;i--){
/ ]" h. E) Q2 i& c                             Point pt=(Point)(HistoryPoint.elementAt(i));
0 i% @  w6 H8 `8 z" [                             if(pt.x==xx&amp;&amp;pt.y==yy){
; ~/ G) @% A- g. s9 V+ L                                found=true;
                                break;
% ]& I5 J6 h$ g- d                             }
                          }
/ _7 }2 `8 z* y" c9 }( B5 e                          if(!found){
- X' m* o* G) o& u: C% m/ s" I7 \0 ^, Y                            //如果没有原地转圈，那么记录信息素。
* k0 z; C5 ~7 m                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
0 o/ w& ?0 a$ L2 {                            deltx=x;
                            delty=y;
; }( I& c5 t, I) v                          }
1 _# k: E* {# _# Q" p5 f/ m- P- G                      }//end here==0||ra&gt;0.001
5 y# L  I! L7 Q- _" Y) E                    }//end maxphe&lt;here
0 P% p6 x, v& b& d  t5 ~/ m+ l                }//end if x!=0
            }//end for y
, \% N3 f* |8 X1 J# I1 M: r        }//end for x
        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
8 J, Z, L+ a( H1 q+ i# j5 @4 M        pt=Evade_obs(deltx,delty);</P>
<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
+ M& G, \: T+ O$ l: C        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
          pt=Evade_obs(deltx1,delty1);
        }</P>
<P>        //播撒信息素
2 J+ K; j9 L% u1 I        Scatter();</P>
& d: w, s. g7 F% g<P>        //记录走过的距离
        Count_distance+=Distance(lastPt,nowPt);</P>
<P>        //改变当前点位置
. Z0 E+ {  {% a) M( V4 R" |        lastPt=new Point(nowPt.x,nowPt.y);</P>
<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
        if(HistoryPoint.size()&gt;memory){
  b: S6 k) H$ M  T6 y          HistoryPoint.removeElementAt(0);
        }
        nowPt=new Point(pt.x,pt.y);
) m0 m0 \* `' k     }</P>
<P>
( x; R' a& V8 e/ u: Y        private void Scatter(){
" `) _& Y! H2 x* Z, A+ c( i( t        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
7 M, M. w- d! g8 |2 Q1 A        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
- ^  E4 l! e, {: r2 L            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
& ^/ v8 N- R2 P            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
  I8 a# r/ `% ^6 u$ s. W            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
            boolean ofound=false;
            if(Phec!=0){
                //如果当前点已经有信息素了
                for(int i=0;i&lt;local_colony.phe.size();i++){
/ e0 l6 N9 a! S0 L' j( T6 p                    //在信息素向量中查找该点的信息
                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
# e6 E  C2 W- ^% h- Q8 Y                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
                        ofound=true;
( B% x& O/ Q1 a6 C/ D: o; a                        boolean found=false;
                        if(size&gt;4){
' e6 f# D* r2 P6 q! i8 _                           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){
1 Q7 A* T0 F$ x2 g0 \) h                                //如果当前点重复了以前走过的路，就不释放
                                found=true;
) F" d, a, B- ^# t- h4 f- o9 E) m                                break;
                              }
  p3 M# ?+ t! ?2 F$ U8 e) Q4 W                            }
9 q+ G" ?8 M, h/ B/ e                        }
                        if(!found){
                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
<P>                             //让还剩下的信息素总量减少
+ P" p$ m% U3 r2 ]3 [                             Pheromone_count-=Phe;
8 B0 ~2 y8 s* J8 L5 d9 q* n                        }
                        break;
4 k: x2 `) }+ a: ~                    }
$ A3 P5 A  l, r  ?/ g+ l- r                }
& S/ [1 y2 V$ A% U; {% |/ i" ?* b- p              }
: s$ @1 E' T1 ~  S          if(Phec==0||!ofound){
            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
# J, c& D, d4 _. i0 y! _# |  I                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
5 O! S6 x, D0 l                ph.Add(Phe);
: F6 Z2 J. {1 j3 P2 }                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
  Z% ~1 G  O  w1 N% F                local_colony.phe.addElement(ph);
                //让还剩下的信息素总量减少
                 Pheromone_count-=Phe;
           }</P>
<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
* W; [5 t8 a9 k! g( S. T           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
, t) }2 h( F0 X<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
        }
private boolean JudgeEnd(){
    //这个函数判断是否已经找到了目标点
    //首先获得当前蚂蚁是正在找窝还是在找食物。
* e, }6 X* b$ g: [0 F! {- _& L9 U0 s+ b+ |; p    int kind=FoundTimes%2;
+ u" v: z7 y6 y4 ]" n! V9 Y, j$ Z    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
        int i;
5 r5 V5 a1 N5 T1 p7 `        for(i=0;i&lt;local_colony.EndPts;i++){
) d9 p; B* Z" t0 l! k            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
7 M* Y1 \2 I8 t& i  T              //如果找到了食物，就直接移动到食物点
& M/ t# v9 k7 J7 z' W              lastPt=new Point(nowPt.x,nowPt.y);
  \5 y. i4 [6 Z8 ]) T              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
4 C- i! S+ ~# p$ {0 z<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
2 ]- K  {; {2 y5 e4 p/ F1 `              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
0 M9 ]" p. Z8 k+ v: G- y                 Min_distance=Count_distance;
; z2 Q2 i; K' {6 b8 q              }
7 r6 v1 M' b5 }: D7 m6 L              //清除总距离记录
) z& i6 Q: F- Q( _/ z: o- f              Count_distance=0;</P>
<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
5 p' e8 H, G( ^9 f& c+ y              AimPt=new Point(OriginPt);
+ N" Z! N$ n  m, f4 c# V8 X              StartPt=new Point(nowPt);
              //并把当前点标为自己找到的食物点
# {; [2 `% G+ e2 [. R+ y              FoodPt=new Point(nowPt.x,nowPt.y);</P>
4 T4 x: k) b& j* ^4 j6 Z  Z/ b<P>              //找到了食物就把找到次数+1
8 b6 G7 q/ s) }              FoundTimes++;</P>
3 w. e) U* |, ]0 c<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>              //重新把自己能撒的信息素置为最大值
              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
3 u9 A6 ]& \+ k+ a$ P              HistoryPoint.removeAllElements();</P>
+ B1 Q6 J& M6 s<P>              //返回找到为真
. E5 x3 [, w+ f' s5 i9 }) {3 w+ n* X              return true;
            }
$ A& t' G! C7 ?  K        }
, X, [6 f, t$ b6 [: A) ^      //否则没找到
' S- `# K2 L5 A; E' `  }* a" Y      return false;
    }
' L" J( _/ V. ?/ H' \* u  }( H" ^    if(kind==1){
        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
( Q1 q8 w1 v% S, w        if(Distance(nowPt,AimPt)&lt;=VR){
, N! P5 Y& V) k) `- Y            lastPt=new Point(nowPt.x,nowPt.y);
            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
& ?+ U$ a! ~. R            nowPt.y=AimPt.y;</P>
! G6 }& L  J2 Z1 y5 B0 A8 S<P>              //计算最后的总距离
) k0 _3 z4 a$ C) Q              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
3 C2 ]; Q  p' |8 \% C, g& d              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
9 {9 j6 i# @! U) ^; \+ s7 |              }
+ z% ^5 ?- H& t              //清除总距离记录
* b: k( b4 d: Y# ]              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
: s8 b( K  s4 T  r            AimPt=new Point(FoodPt);
            StartPt=new Point(OriginPt);</P>
<P>            //重新置信息素
            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
" T9 B* i) [/ }4 ~            HistoryPoint.removeAllElements();</P>
+ s9 d. x$ x* L$ {" ]6 `<P>            //主方向反向
7 t5 e# L5 K" z# G            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
: x) }+ X  D7 g# R- H<P>            //找到次数+1
            FoundTimes++;
8 T3 D7 y, O; l" ~# \            return true;
$ U: s9 L8 `) T6 D& @( F+ h. w        }
        return false;
" B3 g7 U3 B. P- T6 W2 x    }
    return false;
$ Z3 o' Y* w; Y3 c}
        private double SelectDirect(){
                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
8 |9 }! t. y/ h8 f4 ]2 ?                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
- Z7 U* K- `2 h* F+ p        e=2*Math.PI*Math.random();
. u2 x. G; Q  p0 r' A, X8 W                      Main_direct=e;
8 j6 Q* s1 Y5 E+ v3 q! B% e2 O                }
) w( c0 c8 a; s3 J' q4 [/ v                //选择主方向角
0 E. y, c0 Q& U; W! ]) [                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
( f5 _7 F' W6 Y1 n! ]5 p& \8 i                double re1=Math.random();
6 j/ y; Q6 T/ z( W, U. k3 C                direct+=Math.PI*(re*re-re1*re1)/2;
3 h! n, o& k! }7 v+ C% F                if(re&lt;0.02){
                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
                  int size=(int)(re1*memory)+1;
5 {- a7 s+ j8 o5 i                  if(HistoryPoint.size()&gt;size){
- x! H9 A; H/ g4 ?                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
5 ^9 A8 N" A( |8 ]4 C5 V" D" y( n9 l                       Main_direct=GetDirection(pt,nowPt);
7 }: c+ \% s% N9 ?* X                    }
                  }
                }
6 k/ N" ]4 U/ B1 J+ b; T               return direct;</P>
. a$ u  m+ [. q: M. G" Y<P>        }
( x* `3 i0 \2 s6 x9 b4 |" d& b# f        private Point Evade_obs(int deltx,int delty){
2 \8 {/ L3 [, b7 s% a, Q              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
1 A7 W- l2 n- h. Z# q/ p" [3 d7 j' i              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
/ r7 X" h7 X5 t  Q              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
8 e7 r5 [5 J% B, k* o6 S              //p1,p2在这里分别是nowPt和nowPt+delt
              Point pt=new Point(0,0);
              int x,y;
              int delt=deltx;
, \* M. U" A' s( o/ N1 |              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
$ e3 c5 _, T6 ?4 C# W5 S              if(delt==0)return nowPt;
. A* d# k7 E  ~" ^# q              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
* j8 ?  H1 g9 N                  x=(int)(deltx*t+nowPt.x);
" k# t2 ]' b, E# n0 e7 z! O9 h! k                  y=(int)(delty*t+nowPt.y);
                  x=(x+width)%width;
                  y=(y+height)%height;
" h$ ~& Q) B" c9 N+ b5 C                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
; ]# w2 S4 n3 T3 V3 ]% u5 @<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
  y. I3 \- y( h7 C                     double disturb=4*Math.PI*(Math.random()-0.5);
                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
                     break;
% X6 P; b" z, S                  }
" C9 I1 {; {4 y( ?  A9 H+ j                  pt=new Point(x,y);
& J3 Y- _9 h1 H3 S% r: `, t                }</P>
4 x: N" e& |! D6 P) D<P>                //计算得出实际能够到达的目标点
$ N8 n# k$ J' k; I/ W3 T  x=(nowPt.x+deltx+width)%width;
9 N; s+ `+ o  j! K  y=(nowPt.y+delty+height)%height;
! U% @; s3 ?' C( u6 @9 I2 H$ Z         return new Point(x,y);
8 W6 ~9 s& V0 G. [( A        }
        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
0 w$ \! ~! b% z        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
        //其中方向角是所有可能的角中使得两点连线距离最短的角。
9 s/ }: t% W2 l) G               double e;
; a- j$ D0 r% d/ @1 ?+ ?2 l               int deltx1=pt2.x-pt1.x;
7 g  ]- h. R' W8 K# V               int deltx2;
3 v& v: `4 y0 Z2 f' r! s               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;
. {8 ~" b5 x- P# [$ ~3 C               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
  C; U7 A6 a) c) p! |0 O( b+ t               else delty2=pt2.y+height-pt1.y;
2 P6 t$ y8 \1 M6 D8 D               int deltx=deltx1,delty=delty1;
               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
               }
        if(Math.abs(delty2)&lt;Math.abs(delty1)){
; ?1 {. {) e! _/ R& A                  delty=delty2;
               }
               if(deltx!=0){
2 M% A" I+ `, R0 J6 b                    e=Math.atan((double)(delty)/(double)(deltx));
5 k( q8 e- t* [  b6 G  @/ Q& b( U+ b2 n) K                    if(deltx&lt;0){
  u) j& R5 ~  z3 m- b                       if(e&lt;0) e=e-Math.PI;
                       else e=e+Math.PI;
                    }
  c; u; u9 Q, x4 L# a                }else{
                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
: |* t; D( o' O# o  w; m5 z6 \                }
                e=(e+Math.PI*2)%(2*Math.PI);
  O; K& U! g* C3 W) I0 @( j                return e;
        }
        private double Distance(Point pt1,Point pt2){
5 B- ]9 [9 X  I9 x5 e! u+ V9 r        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
            int dx2;
& n7 i7 r9 `, E9 k& c" y7 k$ a7 s            int dx,dy;
            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
            else dx2=pt2.x+width-pt1.x;
/ F4 W' e" M1 \: S: w# x8 m7 n            int dy1=pt1.y-pt2.y;
            int dy2;
            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
            dy2=pt2.y+height-pt1.y;
            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
# O+ c# p; \3 P5 I4 y            else dx=dx2;
            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
" x. q& b# ~% @3 u% V            else dy=dy2;
! [# I! M' _2 ?* b            return Math.sqrt(dx*dx+dy*dy);
        }
    public void clone(ant ant1){
        //把蚂蚁ant1的属性拷贝到本蚂蚁
& W( R& {' o7 T! `/ K6 S9 K     nowPt=new Point(ant1.nowPt);
        OriginPt=new Point(ant1.OriginPt);
        FoodPt=new Point(ant1.FoodPt);
# h2 s& z( B$ G        StartPt=new Point(ant1.StartPt);
/ ~: I" y7 M$ t2 [& x        AimPt=new Point(ant1.AimPt);
% q3 z% l$ s; q& ~( B( p/ j/ t- w        lastPt=new Point(ant1.lastPt);
, W$ G) P2 S" w" Z4 U! v- {0 S        VR=ant1.VR;
        id=ant1.id;
" W- ~+ Q2 L+ P/ B  B1 I        color=ant1.color;
' d8 p+ I& m: e; s9 O; T6 K        back_color=ant1.back_color;
        height=ant1.height;
        width=ant1.width;
* H; Q$ e" {! C; P' L        local_colony=ant1.local_colony;
1 {- n( x: U+ ?6 H        Phe=ant1.Phe;
6 i  r( y& D# M9 o3 S7 {( F7 m        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
' l) B" _" _8 Z# r* B. G1 d; Z        FoundTimes=ant1.FoundTimes;
        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
        memory=ant1.memory;
, c4 p% H+ o' t, @0 i        Count_distance=ant1.Count_distance;
        Min_distance=ant1.Min_distance;
    }
}</P>