[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
* G* r7 O1 ~" G/ G+ A7 G4 I: @<>package ant;
/*
* @(#)Antcolony.java 1.0 03/05/22
1 b! T& \# m+ x: b& b( g4 |4 ? *
* You can modify the template of this file in the
* directory ..\JCreator\Templates\Template_2\Project_Name.java
*
; n8 g! F8 D4 d4 { * You can also create your own project template by making a new
* folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
# f2 G6 s; O! u, H4 q' L5 D- q+ N *
*/</P>
<>import java.awt.*;
- n% \1 R& p" B, L1 u9 P( B' N* Oimport java.applet.*;
3 R. A" z; s! t1 Wimport java.awt.event.*;
( r; I1 _0 F- t1 E4 m4 Yimport java.util.Vector;</P>
1 ]! N1 B9 q8 a) U% c; ^<>class AntCanvas extends Canvas
& O7 O* C% f9 c- t; k7 E! A' j{
' }5 J! D6 d  w. r1 \# V+ d    //画布，一切画图操作均由该类完成
//Image image;
1 x2 Z& S: x% }3 G, d Color obs_color;//障碍物颜色
& l. a* ?3 ~$ R0 K2 ]0 f Color origin_color;//我的颜色
Color back_color;//背景色
1 P- q3 M% X1 ?9 W( [, t. i8 g' M        Color end_color;//食物点的颜色
2 U  a4 d+ h, a3 R //boolean first;
boolean reset;</P>
- R! E- [; T* B- F$ A<>/* public AntCanvas(Image img) {</P>
<>  super();
% p3 L% H/ [) M3 n$ Y   image = img;
  obs_color = Color.white;
  setBackground(Color.black);
  setForeground(Color.white);
  first = true;
  reset = false;</P>
<> }*/</P>
" Y! F6 e+ c/ y7 e% Q2 J<> public AntCanvas() {</P>
1 P, B4 G' `$ F6 L# B; i! m4 r<>  super();
% N( A1 ^! j% f# u   //image = null;
3 B) p  w) m. }   back_color=Antcolony.BACK_COLOR;
% }. R6 P' s5 {4 J& j% V$ R+ C2 V  setBackground(back_color);
+ i" v0 w3 Q$ C5 L( M( _  setForeground(Color.white);
/ M9 k! `1 {  R3 u! T3 j) }+ l  obs_color = Antcolony.OBS_COLOR;
" c+ j2 z) M. I& j6 s: x1 b  origin_color=Antcolony.ORIGIN_COLOR;
4 X4 Y/ }/ b1 m! l& M                end_color=Antcolony.End_COLOR;
8 T/ E6 @0 ]1 N0 y( E6 f  //first = true;
  reset = true;</P>
$ U, _1 U1 V0 T0 F0 i<> }</P>
<> public void Clear() {
5 @7 O* {4 u1 N% [" |% i        //清空画布
  reset = true;
  repaint();
}</P>
<>
( n) f+ P' V2 M, F public void paint(Graphics g) {
; `; p) i3 ^0 Q  int i;
9 F6 w+ _; i9 W2 M1 p. Y                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
- N% \5 I0 r6 g4 [0 I* m2 A0 Z  g.fillRect(0,0,size().width,size().height);
  g.setColor(obs_color);
8 J5 d9 |9 @% x  v- N  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
2 X0 c" T& @& r  }</P>
! b/ A( Q9 y7 @& C<> }
public void process(){
        //处理动画的过程
& d0 r9 _9 }1 s  Graphics g=this.getGraphics();
, b* [* `" W0 i$ U9 m                g.setColor(end_color);
. i9 e+ G& {4 b1 p7 Q# D$ H6 {  M, w   for(int j=0;j&lt;Antcolony.EndPts;j++){
0 `$ u  Z& U; v2 f9 E                  //画所有的食物点
7 T1 n2 j" A- S4 K" ^6 h5 c                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
- y: \# z8 l5 Y# U4 T" k                }
, X4 ?$ b0 l5 E: g; X                for(int i=0;i&lt;Antcolony.antCount;i++){
                  //每只蚂蚁开始决策，并画蚂蚁
3 U1 W3 D9 _  J+ t1 }; ]( D" ]   Antcolony.ants.Process();
3 \- d# P; d4 P* ^8 A) X- j( R) x   Antcolony.ants.Draw(g);
  }
! y( X# v+ m1 J5 P8 p                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
/ Y+ y! c* R& \7 u: J' z                        //Antcolony的drawPhe变量标志是否画信息素
- p- W" ~* k# A. Q  I  }/ q                        switch(Antcolony.drawPhe){
                        case (1):
- J( z: A* ]/ d0 Q, M                            v.Draw(g);
/ T8 P9 B+ b7 `; z7 ~                            break;
                        case (2):
                            if(v.kind==1)v.Draw(g);
                            break;
                        case (3):
8 s, z* E  j' \                            if(v.kind==0)v.Draw(g);
                            break;
6 M$ ~5 i* t0 E1 P- Q8 [                        }
0 |; H& }! P5 l9 N2 j& [3 n0 @                        v.delimit(g);
- Z; B# z8 Z* T& ]: ?$ I4 l! H                }
           g.setColor(origin_color);
9 C) ~  k7 ?& ]  M9 h& H                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
6 e9 S6 f& ~$ E% S' e                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
. Q7 X' Q, t7 M6 E5 y                }</P>
6 i7 t5 M, _: A3 B' V<> }
Graphics GetGra() {</P>
<>  return this.getGraphics();
- H& c/ F: K8 T; _ }
: H+ M2 n/ Q+ Q3 e& i+ w) l) I7 e}
public class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
1 a6 }; o3 B1 l boolean running;//是否让动画运行
7 n# U0 p+ `5 I  K        boolean reset=false;//是否按下了重置按钮
static Color OBS_COLOR=Color.red;//障碍物的颜色
static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
% r% q6 J4 h0 G( Y; `) H, J* y) f static Color BACK_COLOR=Color.black;//背景色
+ w$ S" @' y4 }1 ? static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
5 {  K2 d+ N6 [) w AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
4 j2 X$ Z$ w  K- ^) e  _ static int obsCount;//障碍物的数量，最大为width*height
0 n7 s7 E2 T. v& o2 F static Point EndPt[];//食物点数组，值为食物点坐标。
# D, V% b$ K2 E! O. S3 J* u( @/ n* Q        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
8 t" K6 Z* _* A: m( B        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
8 `8 x# Q# m* ]: \, i        static int OriginPts=1;//窝的个数，最大为100
8 [, u% g+ Z6 o; c8 n static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
8 g/ E0 {( U7 m* `        static int FoodR=10;//食物和窝产生梯度的信息素的半径
static ant ants[];//蚂蚁数组
        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
4 k* ~  Y. O4 D1 P9 G; S  H) b3 z        Button btnReset=new Button("重来");
( X2 \' F; L9 o9 z0 w' z9 X        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
public void init() {
                //初始化函数，先画各种控件
  setLayout(new BorderLayout());
                Panel pan=new Panel();
0 Z1 j. b* \* L8 g: e                add("South",pan);
                this.add("Center",canvas);
9 D4 J3 i" n  e* K3 t. t% w7 k                pan.add(btnStart);
                pan.add(btnReset);
; u3 k1 d$ l& |2 q: E; g                pan.add(btnConfig);
  x3 _/ F( l6 p# W8 b                pan.add(btnMap);
9 J4 Z0 ?" m& r. [, X6 H                pan.add(choPDraw);
                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
                choPDraw.addItem("画窝的信息素");
0 S+ Q6 S+ t  e+ z* E' H                choPDraw.select(2);</P>
<>                //初始化各个数组
, J3 x3 |/ x% c0 b6 ]  obs_grid=new int [width][height];
                phe=new Vector();
                Pheromone_grid=new int [2][width][height];
! O- B4 |/ e+ f4 C7 `# E% ]                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;
- y, d! l) f" U                                }
* r! x6 o, Y4 ^* b; p   }
  }</P>
! L; C3 x2 B8 U9 t<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
/ h! H1 D/ s# m) u+ m+ M$ P  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
! Y4 A$ w. t- D3 f; l- j          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
  }</P>
1 G" Z3 k6 v5 T# ]3 V3 ^<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
                Maps maps=new Maps();
                maps.LoadMap(grid,0);
                //初始化地图
8 ?! I" f/ J# {                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
: F: Q1 [0 |6 U5 W6 t) m0 A. s4 V# e  reinit();
. X# p$ m0 u0 n7 K% H5 [7 G }
        public void reinit_map(int grid[][]){
( i; n. g8 R% U' R: c                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
2 k( e/ {7 Z* A<>                //先停止程序的运行
/ v" P# @% }7 Z. J" \& X( ]                running=false;
9 U& J5 l) X- s0 o& Z6 \                btnStart.setLabel("开始");</P>
<>
+ b  I! d( n, Z. m0 x) @                obsCount=0;
6 A) {3 }1 E8 `, s* s                EndPts=0;
! y% u) ^. `" ^. w2 V, Q                OriginPts=0;
                obsP=new Point[width*height];
                OriginPt=new Point[100];
& k' {4 Y, p. [$ I6 J6 c7 R$ G                EndPt=new Point[100];</P>
; |0 \% L6 w. J3 G<>                //清空obs_grid和Pheromone两个数组中的值
                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
$ E! I' G' ^; i$ q9 f                                for(int k=0;k&lt;2;k++){
. X: h+ C& F& Y! p* C/ ]. {& J                                  Pheromone_grid[k][j]=0;
8 A7 K+ S9 F" T2 |' P                                }
# t# K( U, y+ Q2 s, S   }
) T- u  C+ T$ G  c& t  N+ r  }</P>
<>                //从grid数组中读取信息
- l  V2 \! o) e5 |                for(int i=0;i&lt;width;i++){
/ @& I: p7 e4 v- N; s; g  p2 h! J                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
                    case 1:
; `0 t. J8 l2 ?( v) c                      //如果grid[][]存的是障碍物
) b5 h/ n& P7 k/ Q6 N                      obs_grid[j]=obsCount;
                      obsP[obsCount]=new Point(i,j);
                      obsCount++;
                      break;
  D! o+ Q1 N# k7 t; ^2 W                    case 2:
4 R9 c. F$ K6 ~1 Q0 l+ I2 t                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
" [0 m; [/ g8 y# Y! D1 C4 u& h& o6 e                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
# |5 {( X; F1 r" T                      }
, m, d( A  S  K                      break;
2 V* Y, U! B# u9 n7 a1 g                    case 3:
, t: p8 r6 B) q/ O3 c, a. {                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
5 q' Y7 k& I) v( K1 h5 {8 N, e                      if(EndPts&lt;100){
4 P+ x( F3 W8 U3 T1 I  t                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
" w0 ~) \7 `4 r5 `                      }
                      break;
                    }
                  }
                }
            //如果没有指定窝，则随机的选择一点
' f$ f9 d7 j. J$ }            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
' u  O  M4 l+ d) h                int  j;
6 t! n5 x6 [+ m7 ]9 j  g5 I; B' G                for(j=0;j&lt;height;j++){
" }! d6 P6 r! ?7 k                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
- ?. F; L& x4 ~" x" E                    OriginPts++;
                    break;
& G- o/ |/ w2 e+ A                  }
" n3 N2 a% V# q                }
                if(j&lt;height-1){
5 P: \. S  j" m& G# T( \2 g! B                  break;
                }
              }
- ]  \* p  F  I, {7 ]' M            }
        }
1 L$ k( J  s. A8 Z# } public void reinit(){
( G+ f5 g  ^8 h                //重新初始化整个环境</P>
<>                //先停止程序的运行
6 t8 p& R: D! w/ J' M2 P                running=false;
  l3 B. O2 o. B% D/ D7 e                btnStart.setLabel("开始");</P>
0 Y1 y# w6 \  S4 ?<>
  //清空所有信息素Pheromone数组中的值
# ]$ h) d& }% E4 p/ o3 w                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
                                for(int k=0;k&lt;2;k++){
/ H/ L. I5 h) J" y" {; d* H                                  Pheromone_grid[k][j]=0;
                                }
   }
  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
$ F" d$ w- M( c( r          ants.OriginPt=new Point(OriginPt[index]);
                        ants.init();
2 g( f9 z) q9 P- p4 d  }</P>
<>                //清空信息素向量
) M, B5 d; d7 y+ S3 U7 N# |# K                phe.removeAllElements();</P>
<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
  k9 b5 d' l& y  for(int i=0;i&lt;EndPts;i++){
' L0 J; n) d5 C- E; ]5 I) C                   for(int x=-FoodR;x&lt;=FoodR;x++){
3 T0 z8 w, W2 s+ i. a4 I                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
5 K0 t; P! |6 D" |2 `                        for(int yy=-y;yy&lt;=y;yy++){
+ P% K4 z* |  C                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
; x( H4 T( h! B( o                        }
                    }
                }
                for(int i=0;i&lt;OriginPts;i++){
" t$ e, i! h- R1 A$ P                   for(int x=-FoodR;x&lt;=FoodR;x++){
8 e) E2 ~4 D0 R                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        for(int yy=-y;yy&lt;=y;yy++){
/ E9 r5 d+ Y- `5 W  z8 U                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
! m% w# Z  |$ }9 W                        }
+ @1 m! T3 T  E3 W& k                    }
                }</P>
<P>                //重画
  canvas.repaint();</P>
<P>                //让程序开始运行
                //running=true;
}
3 \( D& E  n) O, }! a( x0 @ public void paint(Graphics g) {
3 H  L2 u3 d8 N. a( y/ x  canvas.repaint();
}</P>
# L: w( W# j* F$ d# W: \0 K<P>
public static void main(String[] args) {
    Antcolony applet = new Antcolony();
! G. N$ T. J8 @# v/ w1 E    applet.isStandalone = true;
4 p# \( {, W0 J    Frame frame;
. X2 u0 t3 e# M, H    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
! @$ b& j4 I( ~, |3 R/ U2 i  c0 d        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
5 ~6 `0 ^. k# K' ~1 T6 Z/ }8 ^          System.exit(0);
        }
      }
      public synchronized void setTitle(String title) {
1 J* C. y* k6 w/ C        super.setTitle(title);
2 T% ]3 d- A$ d9 _        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
8 Q. v) A& t1 a/ m1 [' B    };
    frame.setTitle("Applet Frame");
    frame.add(applet, BorderLayout.CENTER);
3 T3 I( Q) O3 U    applet.init();
; i) Q5 Q, o2 v; h( H7 K7 }    applet.start();
    frame.setSize(300,320);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
    frame.setVisible(true);
  }
7 v# H* d! \0 d/ e8 i1 l! N  public void start()
  //下面三个函数是控制线程的
) C4 q$ {8 |- t$ P. Q {
  if (runner == null)
  {
/ ~( x' D3 b) |5 }   runner= new Thread(this);
   runner.start();
   //running = true;
# O% q, N0 P. z) \- s5 Q" j  }
! `; z; C- x' j3 G: @) ~; L* t }</P>
3 r2 A' [/ V1 T5 z5 C9 ^" ~& `<P> public void stop()
, X- ^0 [: F: |8 ?# f7 M7 {5 D8 H/ P! Z {
. g! Z' s. Y* z1 K0 T  if (runner!=null)
  {
8 Y% j% [5 W$ L1 d   runner.stop();
7 m# Q8 d9 Q  m* x   runner=null;
   running = false;
  }
# P/ U+ H6 z& S* j4 _ }</P>
- {0 T" @1 {. k1 k/ B  }( P" p& }<P> public void run() {</P>
9 L3 Z0 `- M" ?/ V0 D! [<P>  int i;
2 G* I" d- Z4 {7 [9 s                //线程一直运行下去
7 k5 [& @- \. Y6 Y" p' V. i; Q  while (true) {
          if(running){
       //如果开始动画，就进行canvas的处理
                          canvas.process();
# L' V/ o. L$ q% G; Q: c* m. a" @                        }
4 F: ?* u+ d1 {    try { Thread.sleep(delay);}
& o; W6 g, H, F" @    catch (InterruptedException e) {
   }
  }</P>
; C' i" |: G' R, |; }<P> }
' k1 P* A0 k$ T2 |        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
                //开始编辑地图面板
   running=false;
" W& b9 P& j) r" j' d                        btnStart.setLabel("开始");
$ A; _% ]3 m4 o7 \1 M  z   MapPad ctl = new MapPad(this);
" y5 i# R" w; x! j                 ctl.setSize(308,380);
                        ctl.show();
- R3 L* ^9 T3 d5 f% H- T. c                        return true;
  }else if(evt.target == btnStart){
                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
: j9 a1 E; z/ ^                    if(reset)reinit();
                    btnStart.setLabel("停止");
& _4 T6 z  ~/ i9 c% ?- Y5 _5 o5 N; v                    reset=false;
$ o1 Y8 }+ X  V- {                    running=true;
0 w, I* m, d) b: }$ d                  }else{
                    btnStart.setLabel("开始");
                    running=false;
1 [. i& M4 S# o                  }
                  return true;
( A9 J9 r( L2 |2 r7 V& W* N' m                }else if(evt.target == btnReset){
% ]6 \& X. u6 }, b6 P                  running=false;
                  int j=0;
! C3 T' C8 U% M                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
4 x3 S  F* E, G( e/ i& G5 ]; ^$ R* ?% Y                  reset=true;
                  repaint();
, y- c5 f8 z0 U- D                  btnStart.setLabel("开始");
5 c8 Q9 A+ {5 o4 ]                  return true;
1 k) N$ F- H# p) M/ m$ Y* y                }else if(evt.target == btnConfig){
                        running=false;
! Z! j4 @, W4 i! N                        btnStart.setLabel("开始");
7 j# m) e/ v/ f9 u     Configer ctl = new Configer(this);
; g- z. b0 n) r8 L/ q+ @                 ctl.setSize(300,300);
                        ctl.show();
) v0 Y! I2 u8 i" P                        return true;
                }else if(evt.target == choPDraw){
% c: S& r4 s! P1 }4 K% e                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
                  return true;
                }
) u8 w2 k; i9 `1 Y/ z5 F                return false;</P>
4 f  Y+ n+ I/ N4 ^<P>        }
/**Destroy the applet*/
  public void destroy() {
  //当结束程序的时候，把线程也结束
    if (runner!=null)
0 e" g5 @: M% e% C6 D    {
       running = false;
7 @1 E- k! c7 Z2 {& L; ^  o5 g) |5 p       runner.stop();
1 f* j7 |% ^/ g) n" q% t       runner=null;
- \# C4 Q  U% q+ c9 G    }
2 l3 X! {: |$ q2 I9 J6 M  }</P>
<P>}
</P>

' f& x# @# F( M2 L6 @0 I( ~# B

<P>package ant;
import java.awt.*;
' u6 x' D% M# Mimport java.applet.*;
import java.util.Vector;</P>
3 x: D) Q' L% l- K; ]<P>public class ant{
. W3 |2 O" A$ m3 {+ d  G0 Z Point nowPt;//当前点坐标
int VR;//速度，每次蚂蚁能走动的最大长度
2 E1 _  q5 r( v, B8 {% m6 I& c8 ~  int id;//标识
  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
2 j& S  ^! |6 ^+ q8 j int height,width;//世界的尺寸
6 n( ?3 u$ U8 g  V        int Phe;//每次释放信息素的数值
0 E9 @6 g2 V7 f/ h5 ^( s$ @ Antcolony local_colony;//主程序的指针
        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
7 x, g5 x7 f4 }/ o$ L/ g        double Main_direct;//主方向
        Point FoodPt;//记录的食物点，是否找到时候判断用
% P0 v- j4 q: S  o! L' ?8 @        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
: }$ t, H# l/ w  C4 ^9 Q        Point StartPt;//起始点，是窝或者食物
) Y$ m( u# ~+ {1 e        int FoundTimes;//找到食物或者窝的次数
# r  C; ^. R" |* u. N- O% d        int Max_Pheromone;//最大能够释放的信息素
+ Q/ C7 R+ d8 p1 S: T4 S        int Pheromone_count;//当前还拥有的信息素的总量
5 J4 N8 W) l. J) v  f. z" o% Q        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
0 N. D8 U, W- E+ E9 K6 U2 d9 J4 a$ h        int memory;//记忆走过点的数目
        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
7 Q7 ]' X/ r- L. f        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
) T7 F( m1 b! _  x+ L) W, t public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
  U/ x. D6 ~  z, j1 Z: s4 s" A$ s  nowPt=new Point(nowpt.x,nowpt.y);
                OriginPt=new Point(nowpt.x,nowpt.y);
0 }- r$ k% S% S- Z* s2 i7 D, X0 w; T                FoodPt=new Point(nowpt.x,nowpt.y);
                StartPt=new Point(nowpt);
7 y6 I/ ^8 q2 ?+ A8 K  u. a; ?5 i                AimPt=new Point(nowpt);
8 Q$ G2 {- q1 R8 ?4 X9 K$ s                lastPt=nowPt;
' \: {, a3 D/ _+ c9 G5 G  VR=vr;
  id=idd;
  color=c;
  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
  width=Antcolony.width;
! Q$ g/ S' Z7 J2 Y6 u$ R  local_colony=colony;
. y& z7 m+ @5 ]/ L$ j( g" A7 z                Phe=200;
                mistake=mist;
/ ~1 Y" ?. x" Z# f                HistoryPoint=new Vector();
9 Q" k/ k, X- n& _8 N/ d                Main_direct=-1;
' R8 l; V/ E$ V" v7 y# A* n! [0 Z                FoundTimes=0;
* c# z. ^" I2 b. o6 v/ T  |                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
3 g. D  A: J0 h# Y2 c                memory=mem;
                Count_distance=0;
6 R1 k) b. c9 y! t$ _# J3 u' E                Min_distance=-1;
% w+ x) o& Z  p  N9 e4 C* w }
  |& i. W* L. R0 a        public void init(){
# a: B4 n4 O6 o; j          nowPt=new Point(OriginPt);
/ x2 o; s5 w5 m9 a1 e          lastPt=new Point(OriginPt);
" D+ I2 }( ~. u$ h$ y8 H1 }5 ^/ S          FoodPt=new Point(OriginPt);
! d$ J3 d' ]4 H          AimPt=new Point(OriginPt);
, w% u0 U! w# z* a+ {          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
          Main_direct=-1;
          FoundTimes=0;
  U  K0 Y" Q+ u8 N+ z          Pheromone_count=Max_Pheromone;
7 r- o- r8 k& E( p9 n5 K6 l          Count_distance=0;
          Min_distance=-1;
        }
public void Draw(Graphics g) {
          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
  g.setColor(back_color);
& F) Q& K( Y  d# l) P  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
  g.setColor(color);
  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
}
public void Process(){
        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>
/ U' o3 N: @, V: b' t, C3 B# k$ V  J
<P>        if(Judged==false){
          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
6 R6 {- E1 i) ]; D. I# @0 l: G          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
3 {9 p- _# H9 Q( C; M4 g              //判断，如果找到了目标点那么就退出该程序
, ]" V/ l  P: |% a) _/ t: i& v- S              Judged=true;
              return;
" K: v3 Z( l! q, k5 o          }
/ w4 n0 ?6 J  h' b1 ?7 d6 R5 g0 L8 Y$ k        }
$ B4 M3 t2 u. T- u        Judged=false;
        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
3 K8 _3 y5 {# k' _( T2 Q1 B5 U<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
% g1 ?+ F% h; ], W( f        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
/ k0 m  v0 {) I6 n$ p6 n        deltx=(int)(VR*Math.cos(direct));
# L3 f3 e" L5 `. c        delty=(int)(VR*Math.sin(direct));</P>
<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
9 E* J. ~. k) d! @$ Y        int kind=FoundTimes%2;</P>
6 g/ f" |+ [" o% {0 ^  R<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
1 V8 j& h3 A5 L! C        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
. `4 N! Y9 F/ ]9 d1 S: ]6 h( y) n        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
* {0 r9 Z7 P3 ?          int deltx1,delty1;
3 f. c2 q' C/ X* K) f, k7 y& B          deltx1=deltx;delty1=delty;</P>
6 w) D8 T7 ^' O+ [- q& b$ [<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
" ^9 c9 o8 F+ {8 z8 d; `. p) O          for(int x=-VR;x&lt;=VR;x++){
- T2 T! d- ^7 @" F             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
( W/ H1 q6 l/ L3 W' U; e                //在这个程序中，坐标是循环的，也就是在一个球面上
! J" Q: V. r) i                int xx=(nowPt.x+x+width)%width;
                int yy=(nowPt.y+y+height)%height;</P>
- D+ r% c+ g, a& x9 J8 k1 n" I8 r<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
' C# k  W! v  g                  //的到要搜寻的点的信息素
& I  g* Q3 L' G                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
! F/ P& H3 t* ?  U! \" i<P>                  //如果搜索点的信息素比已经找到过的信息素多
) p$ l; r$ {! r                  if(maxphe&lt;phe){</P>
<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
7 |7 r3 ]- y  L- w! P                      double ra=Math.random();
& V6 d/ k- G* p                      if(here==0||ra&gt;mistake){
                          boolean found=false;
( K: v. b. T/ Q: k9 E0 W1 \7 I1 `                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
6 S! }4 m' \5 l# Q% t9 Q                          for(int i=size-1;i&gt;=size-minsize;i--){
1 r  ?. ?  M5 g& P0 M                             Point pt=(Point)(HistoryPoint.elementAt(i));
                             if(pt.x==xx&amp;&amp;pt.y==yy){
& e% B* o# Q8 m/ y# R                                found=true;
9 i+ R" \0 Z3 |5 y2 i. N                                break;
1 r* V( b$ o6 o6 M$ ^0 k4 D                             }
3 N  T9 f: ]3 w                          }
                          if(!found){
( g8 r4 a* {, ?9 V8 z  f  }) h$ J1 Q                            //如果没有原地转圈，那么记录信息素。
. i. {  t6 ~, {5 J  e8 X                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
                            delty=y;
+ z; ]7 j5 F. K9 v: ?                          }
                      }//end here==0||ra&gt;0.001
6 d! P- K! n+ c8 d                    }//end maxphe&lt;here
' Z' [* `) o# j4 Q) ]5 \                }//end if x!=0
            }//end for y
$ d' S& _0 g: i$ U9 A        }//end for x
        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
: X6 z5 a) ^/ ]5 o        pt=Evade_obs(deltx,delty);</P>
+ @* G  G) X$ `; W7 W<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
" Q( Q0 W3 [" S7 c# A% Z2 p. R          pt=Evade_obs(deltx1,delty1);
5 c7 \; p1 j# S) {7 g; S4 l/ {# E        }</P>
<P>        //播撒信息素
7 D0 @" A4 B" G8 O+ p& `& ~6 h        Scatter();</P>
<P>        //记录走过的距离
        Count_distance+=Distance(lastPt,nowPt);</P>
<P>        //改变当前点位置
3 O4 D" e  |9 b+ C# ]7 }        lastPt=new Point(nowPt.x,nowPt.y);</P>
<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
* E- F: [& N9 K) p9 O4 S* w        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
5 ~- L" l( @$ _/ A+ h5 f2 t9 Y3 M        if(HistoryPoint.size()&gt;memory){
! f! ~- C/ J, K1 ]' B8 C4 U          HistoryPoint.removeElementAt(0);
3 U4 g( {1 y& L. R' ]        }
        nowPt=new Point(pt.x,pt.y);
6 p! o% l" ~% o* Q  s' @- m9 [' J     }</P>
$ ]) v- R" f6 u0 y' D/ j) k7 T. p<P>
        private void Scatter(){
  r4 J2 [" T6 @& C! B* c        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
            int kind=FoundTimes%2;</P>
! v$ Z% }$ @* `4 ~. z7 m* N<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
% }" x# o- g1 D+ v( O0 [$ n( Y' r            boolean ofound=false;
$ G6 h  M: Y# }/ I& ~            if(Phec!=0){
                //如果当前点已经有信息素了
                for(int i=0;i&lt;local_colony.phe.size();i++){
                    //在信息素向量中查找该点的信息
                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
+ r3 h& Q' L& Z$ m' N/ C: z$ I# n                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
0 j; u9 r7 G3 k4 L. l" n+ M4 ^                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
# X& ]4 L0 b& G. |                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
2 M  Y0 r  n" O. X. j; N( u+ P0 [8 |+ p                        ofound=true;
                        boolean found=false;
" G) I1 \: @. E0 h+ R                        if(size&gt;4){
8 N; e! z- r/ t                           for(int j=size-4;j&lt;size-1;j++){
  I- U6 e3 N( b- ]' D9 p                              Point pt=(Point)(HistoryPoint.elementAt(j));
! f& U9 Q. g  z. U" B+ A                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
                                //如果当前点重复了以前走过的路，就不释放
0 ?% s3 k/ c4 n9 T8 v4 l$ d                                found=true;
                                break;
, a5 E( o/ y0 ?) a                              }
+ ?8 [) S" b8 K( B% f# D                            }
                        }
                        if(!found){
                        //如果当前点不重复，则开始撒
$ Q4 A+ U" ?$ \                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
<P>                             //让还剩下的信息素总量减少
                             Pheromone_count-=Phe;
. A# C' w$ k" [+ w( ^                        }
                        break;
                    }
                }
              }
8 m  ?0 d1 s& h5 F          if(Phec==0||!ofound){
            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
                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;
                local_colony.phe.addElement(ph);
% C8 g! _4 L9 Q2 h: b                //让还剩下的信息素总量减少
                 Pheromone_count-=Phe;
           }</P>
; d6 [* C% a. V$ N  b. `  K3 }" p5 O<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
8 O* q2 }- x9 g9 H6 [$ V- i           Phe=(int)(0.005*Pheromone_count);</P>
8 {8 O) F# p, ?0 J% M+ x<P>           //如果剩余信息素已经太小了，则按照等差数列递减
' X' B9 J. l& a8 o+ T2 ]# d6 m, ^           if(Phe&lt;=10)Phe=10;
9 A/ p$ O. K1 I, q9 Z6 @        }
7 i" Z! t9 r) M1 y, ?1 ]$ jprivate boolean JudgeEnd(){
- \+ l; w  ]3 }- G  d7 v    //这个函数判断是否已经找到了目标点
    //首先获得当前蚂蚁是正在找窝还是在找食物。
* h- z6 b) U3 G0 Z    int kind=FoundTimes%2;
9 m' d- u/ @! B' {' l4 h    if(kind==0){
1 j1 }3 s9 w( a, r2 I7 ]        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
        int i;
6 K. j6 h2 G$ y7 i) ]- j. [        for(i=0;i&lt;local_colony.EndPts;i++){
            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
              //如果找到了食物，就直接移动到食物点
* i! W; _0 `; z$ N" B2 z# n; S* v              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
. L# H4 V1 f( s% e              nowPt.y=local_colony.EndPt.y;</P>
; R1 E/ c) |$ M% O$ s  G$ `$ d<P>              //计算最后的总距离
9 }* w& O$ F/ c& H              Count_distance+=Distance(lastPt,nowPt);
, c) ~  _+ y7 q& E& h              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
              }
              //清除总距离记录
              Count_distance=0;</P>
9 v6 o8 B" X9 l) i3 x, b<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
# i% L& y+ z5 e9 I3 V              AimPt=new Point(OriginPt);
              StartPt=new Point(nowPt);
1 \4 F( R, f: {              //并把当前点标为自己找到的食物点
* x  g% s9 V- A              FoodPt=new Point(nowPt.x,nowPt.y);</P>
<P>              //找到了食物就把找到次数+1
9 J( ]4 ~7 s( U( h  c# A& Q: j  X              FoundTimes++;</P>
* \  b! u. E$ J+ L9 B6 C<P>              //改变主方向为原来方向的镜面反方向
1 W& x0 K( _# G              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>              //重新把自己能撒的信息素置为最大值
              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
/ q: R' v! z; i              HistoryPoint.removeAllElements();</P>
4 Y4 W  C0 s& [, ~; u<P>              //返回找到为真
2 h& l7 i! F$ ^! o* B              return true;
3 h5 [0 W4 H3 u8 Q; K+ v            }
        }
! f' z6 G! d; n! _& `8 u3 O1 f+ [      //否则没找到
      return false;
    }
9 N+ p3 Z% M2 y( l    if(kind==1){
3 f5 |( t/ E9 X/ @$ `5 s' N        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
+ I& D" q5 X$ ^% |; B( |            lastPt=new Point(nowPt.x,nowPt.y);
+ k* }- V  Y. Z3 n0 B! s, [" s            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
- K7 a! J+ f7 T' i( Z! f% N' {5 U  u            nowPt.y=AimPt.y;</P>
<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
: e& ^6 r: z+ u' J) T2 [              //比较大小，记录较小的距离
" X8 J& }- G8 c9 l+ f% P8 N              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
! s# s6 i- ^+ l) `; y' {& g6 Q. p                  Min_distance=Count_distance;
0 K' {5 L" v/ W0 X              }
! W. F; F* h, X! F& y& T8 C% [. G6 P              //清除总距离记录
0 T- |3 S* E1 p0 [$ Q' C              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
% ~5 N# @8 h; n# A* e5 d& o            AimPt=new Point(FoodPt);
3 p& X2 \+ e/ i. }7 Y            StartPt=new Point(OriginPt);</P>
7 ^4 P" q! r0 y. I% [% `<P>            //重新置信息素
9 D5 w/ l$ T4 I3 w* F            Pheromone_count=Max_Pheromone;</P>
3 P# O. H8 R% D% w' x( |3 Q' S, \# ]' }<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
- N, E9 m6 z; h- `# T  }<P>            //主方向反向
            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
) _% ~  J" X4 a7 s/ a<P>            //找到次数+1
            FoundTimes++;
$ ~" J/ C& r& Y5 g6 J, i5 k            return true;
3 v( \, e) x( _: }        }
        return false;
, N9 ?) z8 y" J# f( r  `; n    }
    return false;
}
8 V7 P. n, h- t/ L2 s5 h  h3 r* d        private double SelectDirect(){
# b9 T6 r- P$ Q                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
, G$ C9 m$ o6 v4 r, H3 U  L9 @                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
) k: C  f! ?5 E! c        e=2*Math.PI*Math.random();
                      Main_direct=e;
                }
                //选择主方向角
                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
+ `+ A2 F. {$ I                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
/ m2 I! q8 W" @* j                double re1=Math.random();
; z' h4 K& l5 ?+ O5 [                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
9 K& [4 E7 n' k' O8 M+ N                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
9 u7 y# F( T# B7 q0 g% n: L4 m. P                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
                       Main_direct=GetDirection(pt,nowPt);
                    }
, m# F5 e" T1 D& H# ?                  }
                }
1 i: n& P$ Z: t7 X' N               return direct;</P>
+ k7 d1 }+ f* z* G, i1 s<P>        }
  g  G* W$ X; N2 c4 r        private Point Evade_obs(int deltx,int delty){
( c6 I- L2 b( [              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
              //其中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;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
( h# T+ m6 O; x. A6 s              if(delt==0)return nowPt;
2 p9 l) ^, z3 N% c              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);
/ O5 q2 r6 {! d9 m2 C2 A                  x=(x+width)%width;
                  y=(y+height)%height;
. P* g: d' l* @% u" e; Y9 n1 R                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
/ _/ P; Q2 m7 t4 u& x* j% j                     //新目标点为障碍物前方的点，主方向随机取值
                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
! P# q9 U0 t) D4 a# j                     double disturb=4*Math.PI*(Math.random()-0.5);
2 Y. s$ B' Q6 ]' t6 g' w                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
; w, t+ s. U0 m7 @" V                     break;
% U8 d) X! f. @* B1 L! ?5 ?                  }
                  pt=new Point(x,y);
                }</P>
6 J; W: u0 u. h# Y' c: z- W<P>                //计算得出实际能够到达的目标点
  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
         return new Point(x,y);
  V7 F, _/ S6 t" p; w$ C        }
" e, \8 B1 k4 U# h. N1 K1 D        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
; h. D  O* k5 K. J) ]# v8 t, ?        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
1 R: h0 G+ H2 R/ Q5 X        //其中方向角是所有可能的角中使得两点连线距离最短的角。
               double e;
               int deltx1=pt2.x-pt1.x;
, y6 s$ r" h4 e6 M               int deltx2;
$ z* Q& M' I  U" Z* E& ]$ V" u               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
               else deltx2=pt2.x+width-pt1.x;
2 g" r* B% L+ `: |+ ~$ X5 x" n+ b4 S( N               int delty1=pt2.y-pt1.y;
; [4 R: d% l' {: l               int delty2;
7 S, G' P9 {! H3 q- x0 n               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
               else delty2=pt2.y+height-pt1.y;
6 l1 P3 k% r- {2 U6 W               int deltx=deltx1,delty=delty1;
               if(deltx==0&amp;&amp;delty==0)return -1;
2 |* P& h; g1 k4 @6 P% J* [               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
1 f1 P9 C% `( v               }
# v5 b1 U1 D7 K( t( _' b) I        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
& U7 {4 A4 P" T               }
               if(deltx!=0){
9 a4 h" x; G$ c( B" H0 Q3 q$ Y5 S& |                    e=Math.atan((double)(delty)/(double)(deltx));
$ [* t" F6 e5 m3 @                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
                       else e=e+Math.PI;
                    }
1 I( R$ K! N1 M. P1 F- c  z                }else{
                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
7 m; I1 t& d/ q) L; I                }
                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
        }
$ h. m% h$ W; D        private double Distance(Point pt1,Point pt2){
& [1 F) ~& `: y6 U        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
, z1 i1 R  A8 z! G+ o9 \$ S# Z        //这里计算的是所有可能距离中最小的
+ t4 w& A# i  J2 [, @; y            int dx1=pt1.x-pt2.x;
            int dx2;
            int dx,dy;
  D/ j$ R7 ?: L5 P0 b            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
+ q6 w. @' [3 D- n+ S& Y4 s            else dx2=pt2.x+width-pt1.x;
            int dy1=pt1.y-pt2.y;
: Z8 \5 d+ l% k" J& c( o            int dy2;
            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
: [% S) [1 ]2 }7 ^% Y            dy2=pt2.y+height-pt1.y;
  y  _/ M  H- q! F+ f8 z            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
2 E" U/ {" K  u; Y( k, ?            else dx=dx2;
0 H& |+ p, D. v0 x& e  ]            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
9 c$ `1 }7 Y- B% W/ ?  r" a; K            else dy=dy2;
            return Math.sqrt(dx*dx+dy*dy);
8 P3 P0 w  B+ p        }
/ j& _0 Q" j  F. ]    public void clone(ant ant1){
        //把蚂蚁ant1的属性拷贝到本蚂蚁
  U8 y, F2 _+ d- v9 O0 ^     nowPt=new Point(ant1.nowPt);
        OriginPt=new Point(ant1.OriginPt);
. _7 f1 g  _* o# p" Y$ x        FoodPt=new Point(ant1.FoodPt);
8 n* I# O# N9 {) [; s5 X; `  n        StartPt=new Point(ant1.StartPt);
% m& a; y1 v3 V: V        AimPt=new Point(ant1.AimPt);
5 @9 B# D2 b# o9 i4 j- Y/ O* n        lastPt=new Point(ant1.lastPt);
        VR=ant1.VR;
- S# m! P7 a" w5 H0 x* K        id=ant1.id;
        color=ant1.color;
        back_color=ant1.back_color;
* U  [6 @0 y: ]" n& n# v* B        height=ant1.height;
        width=ant1.width;
- H5 }4 R' ]  ]8 t' z9 l        local_colony=ant1.local_colony;
' @3 A+ K7 }( D; O6 m8 c. d        Phe=ant1.Phe;
        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
, W- K$ J, Q7 \6 T( E+ J3 n        FoundTimes=ant1.FoundTimes;
$ N4 U2 }5 D$ l; l8 v  f/ ~        Max_Pheromone=ant1.Max_Pheromone;
# a7 ~5 l. Z* `* V9 j        Pheromone_count=ant1.Pheromone_count;
        memory=ant1.memory;
' T$ V3 J/ `9 ~4 c        Count_distance=ant1.Count_distance;
' }) W& a2 x" n& t2 D) X: ~4 k        Min_distance=ant1.Min_distance;
/ F; O: p7 e7 \- |  y5 y1 F    }
0 k4 k0 ]( R9 F7 o8 q3 x% t. R. X}</P>