[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
! x& W' U! ?$ G) i* ~<>package ant;
/*
* @(#)Antcolony.java 1.0 03/05/22
) j1 \8 p1 H* k8 X) M *
) z: w" K. W- T. l * You can modify the template of this file in the
* directory ..\JCreator\Templates\Template_2\Project_Name.java
+ S  H% G4 b7 ^2 j) R. q0 ~ *
* You can also create your own project template by making a new
* folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
*
*/</P>
<>import java.awt.*;
" L  Z1 d7 t. t6 mimport java.applet.*;
4 }6 [+ X0 ~- L9 F; L. C1 mimport java.awt.event.*;
6 Q4 f  x; M! ^3 R5 s. nimport java.util.Vector;</P>
<>class AntCanvas extends Canvas
{
6 W" Z! }7 I0 _! R9 J, c  T9 o    //画布，一切画图操作均由该类完成
//Image image;
Color obs_color;//障碍物颜色
- N- c1 v' Y" O& Y" V2 b Color origin_color;//我的颜色
Color back_color;//背景色
        Color end_color;//食物点的颜色
//boolean first;
boolean reset;</P>
( s, e3 {+ @( v; o4 q( w; Q- M<>/* public AntCanvas(Image img) {</P>
6 v% S( f% a0 Y  o+ ^! P+ k<>  super();
' G$ ]: t8 q! `: O- Q; z   image = img;
  obs_color = Color.white;
. K# @* a/ L8 ^0 o# o3 q  setBackground(Color.black);
3 d1 y5 t8 w3 M# g" _. X0 F0 }  setForeground(Color.white);
  first = true;
; d+ ]! U5 {8 E8 z0 O- U  reset = false;</P>
<> }*/</P>
<> public AntCanvas() {</P>
<>  super();
   //image = null;
   back_color=Antcolony.BACK_COLOR;
, b3 w: {7 y/ q; s( v; K2 |' `  setBackground(back_color);
  setForeground(Color.white);
; b+ H5 Y8 @; k1 n; e" E2 o2 T# R  obs_color = Antcolony.OBS_COLOR;
* K7 ?# I5 D  `7 ]  origin_color=Antcolony.ORIGIN_COLOR;
6 w) R0 i" P% R6 f7 t' x                end_color=Antcolony.End_COLOR;
5 C( w. Z/ P7 D- m) j  //first = true;
  reset = true;</P>
<> }</P>
; a; V# m2 U( `. I' O% _5 z: V3 }<> public void Clear() {
        //清空画布
8 N* _+ z* \" l4 B2 @3 K  reset = true;
9 y+ J# ]4 K7 S/ x, c% u1 F  repaint();
6 {  K2 i2 r, L" u3 ~$ E }</P>
  H& L- P) E  h' v2 y: H* J<>
0 i' K/ D* j1 [- T: X, { public void paint(Graphics g) {
  int i;
                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
  w/ a' p. d0 T5 _  i: [$ q  g.setColor(obs_color);
9 f. I$ a3 ]: M  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
5 g$ D* ?! v( E) r, y2 \6 x<> }
public void process(){
% x  a9 Q) L, X" B        //处理动画的过程
. H6 k  B. d% B7 k/ `% x  Graphics g=this.getGraphics();
) H3 H5 _8 ]: v                g.setColor(end_color);
   for(int j=0;j&lt;Antcolony.EndPts;j++){
: W, D& R. y* |; `: h+ J                  //画所有的食物点
( L4 _# r! J7 v* ~                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
                  //每只蚂蚁开始决策，并画蚂蚁
8 q5 N8 Y7 l' Q0 G' H   Antcolony.ants.Process();
   Antcolony.ants.Draw(g);
  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
/ |$ Q# V" N7 o. {( A+ A2 n" N, o/ z                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
                        case (1):
' D) |+ T3 H0 A) f                            v.Draw(g);
                            break;
                        case (2):
) F& H  {1 ~; s- t( c+ h& S% u: s                            if(v.kind==1)v.Draw(g);
                            break;
                        case (3):
+ q2 r* Q( G  Z                            if(v.kind==0)v.Draw(g);
  \  w9 t! t' q1 s$ |$ N                            break;
                        }
                        v.delimit(g);
9 O, A3 r# E8 ?                }
           g.setColor(origin_color);
" ?7 }3 J! I! Y) j. l- e                for(int i=0;i&lt;Antcolony.OriginPts;i++){
* f& y; v) W) {8 x( R2 m  x# j" |                  //画所有的窝
% a3 k, g+ \1 @, f4 T" u                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
                }</P>
<> }
Graphics GetGra() {</P>
<>  return this.getGraphics();
+ w$ g+ `6 |& N' o4 P5 R }
4 |& V- T( \$ t: G}
8 S; s# @) ?3 W' L+ Wpublic class Antcolony extends Applet  implements Runnable  {
' t0 O" O- w% I/ D0 m, M2 h/ w9 v) W boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
, f, C" W. j3 _/ R* l' `$ _5 e+ X boolean running;//是否让动画运行
! @# d. s, R/ T9 ?8 ^* b        boolean reset=false;//是否按下了重置按钮
- T1 Z( h- C0 ]8 L0 k2 g3 J* w% q static Color OBS_COLOR=Color.red;//障碍物的颜色
static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
! p+ j5 r  w6 n& P& `7 k5 n static Color ANT_COLOR=Color.white;//蚂蚁的颜色
' h! n% \; F# L' S, g$ L# }% l        static Color End_COLOR=Color.cyan;//食物点的颜色
. N' ]# N5 A+ I9 H3 i AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
& r' Z! B8 H( F: q7 o; \- H static int obsCount;//障碍物的数量，最大为width*height
; Q. O: w4 w9 ~9 U" a6 l static Point EndPt[];//食物点数组，值为食物点坐标。
) K2 r6 H7 }) b( e        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
$ s( _. ~! U- |' D: X        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
        static int OriginPts=1;//窝的个数，最大为100
1 w- z* q7 z, X6 R$ x3 ] static int width=300,height=300;//环境的长和宽
/ X( Y# W% t7 D2 @ static int antCount;//蚂蚁的数量
        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
* Z& J: ^% z9 g. ?: U! a        static int FoodR=10;//食物和窝产生梯度的信息素的半径
9 J& x3 S; x; {& o0 @" ?% I static ant ants[];//蚂蚁数组
9 s0 D  d$ ?0 W" p( t+ P1 b# K+ d- h        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
8 b# q- d2 f1 F- n7 | int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
( Z' E$ d; x9 s, ~# g) M& Y4 J        Button btnStart=new Button("开始");
3 ~( N5 F2 k, I        Button btnReset=new Button("重来");
0 s2 h& R8 E: J# ^) Z        Button btnMap=new Button("编辑地图");
  P* q6 t! y+ M- h: ^  D' A) u        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
- a/ N- I8 {& m# p public void init() {
                //初始化函数，先画各种控件
8 R1 q: q  X6 j# u/ ^7 R4 Z, O  setLayout(new BorderLayout());
5 ~4 ]9 p. |* x. }- K/ o                Panel pan=new Panel();
                add("South",pan);
$ d+ X6 T. i6 n+ x6 ^+ D6 \& p% q+ ^                this.add("Center",canvas);
' L0 A+ o% s, \) I5 r# q                pan.add(btnStart);
5 h9 e1 y4 ^) I) q                pan.add(btnReset);
# e# v" E$ a6 [* S* s) x/ ~) C7 d  `                pan.add(btnConfig);
2 b! j5 r$ S# K6 b                pan.add(btnMap);
                pan.add(choPDraw);
                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
" D7 s/ E' g3 w. w                choPDraw.addItem("画窝的信息素");
8 \" u. |( f: L5 e9 u* k8 r& V0 s                choPDraw.select(2);</P>
0 O9 y+ h/ V1 S& Y<>                //初始化各个数组
1 V' B1 [! d* V# S2 T  obs_grid=new int [width][height];
3 [* O8 c( `, @0 R                phe=new Vector();
5 v5 u& u4 f3 J! R8 b                Pheromone_grid=new int [2][width][height];
                for(int i=0;i&lt;width;i++){
- X9 y5 e, o: W  A   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
6 U( }8 J  v" w                                for(int k=0;k&lt;2;k++){
9 L# c3 W# R3 `7 v0 w; R6 N                                  Pheromone_grid[k][j]=0;
                                }
   }
: W" Y  H6 d3 w  }</P>
5 r- E$ y7 l" I" ^/ K; V<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
' A8 Z1 J( B8 \" r. P8 M  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
/ p7 W: g6 n) C5 L& g5 X          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
2 a: p/ L& \* M. x" [  k                int grid[][]=new int[width][height];</P>
$ }. F9 x- E; e+ {! A3 ^  X<>                //下面从地图库中加在地图
* A/ R; @  i. I/ n, m                Maps maps=new Maps();
                maps.LoadMap(grid,0);
; O+ D' Z9 p7 m0 A# v8 h; Q5 w                //初始化地图
                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
  reinit();
}
$ S* Q) n3 Y* f$ @" x" D8 A        public void reinit_map(int grid[][]){
6 `. c! Q, |) u9 j+ m" c                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
+ n1 _6 f# R3 v' v  Y<>
5 l; x& x7 Q0 S7 B                obsCount=0;
                EndPts=0;
                OriginPts=0;
                obsP=new Point[width*height];
) ^2 a( ~0 x6 e& M& t% Z$ P* P                OriginPt=new Point[100];
! H2 i9 R! w0 |- D. k1 L                EndPt=new Point[100];</P>
<>                //清空obs_grid和Pheromone两个数组中的值
* z; m2 c8 c2 r. i9 i7 Y' z8 @                for(int i=0;i&lt;width;i++){
) q; v4 C# l6 }2 D   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
$ P  S- C; }  {                                for(int k=0;k&lt;2;k++){
: d9 ?+ G- E$ `# o                                  Pheromone_grid[k][j]=0;
                                }
   }
  }</P>
) S2 B$ X2 }& ^$ ~<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
8 V- t; @& C3 @' s+ g5 Q8 ]                    case 1:
                      //如果grid[][]存的是障碍物
                      obs_grid[j]=obsCount;
                      obsP[obsCount]=new Point(i,j);
: ?6 a6 z4 y* ]4 j: r                      obsCount++;
/ m3 P4 D  H% H. r8 h8 w/ E                      break;
                    case 2:
" S' A. Q- i$ q: e. J                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
                          OriginPt[OriginPts]=new Point(i,j);
, ?1 r- M, B' x) x                          OriginPts++;
                      }
& P- b- @) x2 N/ o1 q                      break;
6 [3 ^" {7 j1 @; Z5 J$ Z% G& V                    case 3:
                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
                      if(EndPts&lt;100){
& q) |! v  }) o+ ]/ z                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
; r& ?2 e' U  T# j& g: F                      }
9 [% w% }& u3 d9 N% Y5 [: m/ r7 i* ]                      break;
                    }
; f" g) g& y8 J* h6 J+ @                  }
4 x7 T! q+ j% J8 |( Y$ }                }
  h" Q/ O4 {3 C7 @" d8 l7 `* q            //如果没有指定窝，则随机的选择一点
5 a3 z* s) E8 T            if(OriginPts==0){
5 y3 R/ m4 T7 I( x# e6 l3 G              for(int i=0;i&lt;width;i++){
                int  j;
                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
                    OriginPts++;
                    break;
                  }
                }
$ U' p; A& j( i0 _+ C+ ?; n                if(j&lt;height-1){
+ |; {' z; A; P7 ]( q                  break;
7 ]( n# N1 c3 F9 y5 K( m4 x                }
: Y1 M( ?  _- }9 m! j" _              }
$ a& N; J; f. f            }
, m: ^* g0 \3 G0 D3 k" V: U. ]0 D6 \        }
public void reinit(){
( P6 G- T. P3 o                //重新初始化整个环境</P>
* p! Z( L+ T3 B% f4 a<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
<>
  //清空所有信息素Pheromone数组中的值
                for(int i=0;i&lt;width;i++){
- i/ {' s' b: q/ {* h   for(int j=0;j&lt;height;j++){
8 v# Y- E/ T! D                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
* _# S. t  I( [' _9 k1 R                                }
   }
  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
% X2 i# d  m! `- }; @$ T: X8 q        for(int i=0;i&lt;antCount;i++){
( x3 R* S$ M9 X6 b, M1 ~1 d+ ^                        int index=(int)(OriginPts*Math.random());
          ants.OriginPt=new Point(OriginPt[index]);
6 n# Z+ _1 ]% {0 w8 |0 G                        ants.init();
9 L6 T0 u9 a% a5 h8 E8 n  }</P>
<>                //清空信息素向量
                phe.removeAllElements();</P>
) V& j8 r1 w4 n( R+ ~<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
3 Y' [6 ?& j6 W0 E. P  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));
( g6 @. {6 x6 U& w5 y1 |3 A                        for(int yy=-y;yy&lt;=y;yy++){
/ U* |+ b5 Z+ E+ E* s                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
$ A4 D  i9 C3 s: X" [+ W7 C                        }
1 k! D1 S# Q- q, F" z                    }
                }
) m7 F( x% B. T                for(int i=0;i&lt;OriginPts;i++){
, p2 T  n, d( p- W+ p                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
( P# W7 S8 D) |5 w; `) I1 p, h                        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));
7 `. M* F- I8 Z" d6 \! W                        }
                    }
                }</P>
# H4 _8 _4 B) a6 _4 @) F! ?; p<P>                //重画
" X/ ]0 |: Q/ s6 Y" I  canvas.repaint();</P>
9 b( E, _/ D+ y3 L- @# @( C<P>                //让程序开始运行
1 h" s, ^1 \2 E0 R5 d# N                //running=true;
}
public void paint(Graphics g) {
7 P: w( W" ~6 k5 x# j* o& t5 U: j  canvas.repaint();
}</P>
- d9 r! R4 G4 d<P>
public static void main(String[] args) {
% Z) z2 v( c3 g5 ~/ U5 i! j    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
    Frame frame;
    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
: Y, v6 [2 _7 S- _/ K) ?7 s' u& f. V        super.processWindowEvent(e);
        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
          System.exit(0);
        }
      }
; Y9 D* N  P$ L      public synchronized void setTitle(String title) {
: q2 I+ p9 N" L2 L' S        super.setTitle(title);
' U, D+ ^, U! C" H  m        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
. f4 a! Q, Q. {7 b8 s    };
    frame.setTitle("Applet Frame");
4 X% P0 A- U8 D8 [% d1 t    frame.add(applet, BorderLayout.CENTER);
    applet.init();
$ B# E. F! Q7 I3 [4 t' ?" P( E    applet.start();
    frame.setSize(300,320);
$ J) ^, z/ p& `6 m1 Q7 B' y7 l    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
5 K) w3 s3 ~# g/ }) z    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
* ?, M$ {: X$ S* E# K    frame.setVisible(true);
  g( _5 B* o5 J1 Z" A2 M  }
  public void start()
4 O+ I% i( X% r/ K  //下面三个函数是控制线程的
{
  if (runner == null)
  {
   runner= new Thread(this);
   runner.start();
   //running = true;
  }
8 p! r* B& y3 x4 U/ l }</P>
# x' g4 q% Y; R2 A7 Z, Q<P> public void stop()
) e$ U  E% b! A4 `2 ] {
: K- m8 s) H0 H3 g4 [3 D% n  if (runner!=null)
) l5 l9 y- Z  e  {
3 m8 ^/ j8 j- A9 j  @0 K   runner.stop();
   runner=null;
) Z' Q* s3 k+ n5 Q- U   running = false;
  }
}</P>
<P> public void run() {</P>
; `! _5 S6 n& X# ]<P>  int i;
6 g0 V; H6 A: p. y/ T8 ^7 N. g3 e                //线程一直运行下去
  while (true) {
          if(running){
, I$ N; s1 P7 V, }, G2 Y( n       //如果开始动画，就进行canvas的处理
* O/ B; s6 Y- @                          canvas.process();
3 ?- \! b* [# [# o                        }
    try { Thread.sleep(delay);}
, v( O6 `9 G* k3 w. ?: F$ ?7 D    catch (InterruptedException e) {
) g9 f; o, o/ p% b   }
  }</P>
<P> }
        public boolean action(Event evt, Object o) {
5 K2 u. G' P% Z% A, U: o5 _      if (evt.target == btnMap) {
8 V$ P3 c0 O; r1 k: b, [7 K% ~                //开始编辑地图面板
( J. i( o7 h! Z% }% o# r1 ~5 `6 M' B   running=false;
                        btnStart.setLabel("开始");
   MapPad ctl = new MapPad(this);
' Z- F( c! S& O: c; K                 ctl.setSize(308,380);
                        ctl.show();
6 N" L5 I$ w' T* J, x' u                        return true;
  }else if(evt.target == btnStart){
) T2 h1 @+ X  G- V; y* s                  if(!running){
  i3 K& }& @1 j0 v8 n! J                    //如果刚刚按下了重置按钮就重新初始化一下
& C7 h) B" G7 s* M9 V6 |                    if(reset)reinit();
                    btnStart.setLabel("停止");
                    reset=false;
) B* g2 h* \- h# \; G                    running=true;
                  }else{
                    btnStart.setLabel("开始");
                    running=false;
3 o: F( F: f# H# c+ v8 @                  }
6 H) z8 [+ n" x, ~7 I6 {& H+ p                  return true;
                }else if(evt.target == btnReset){
3 D( I' ?' j& [* i0 `; b                  running=false;
1 ?+ p! s. P) {                  int j=0;
% J7 ]  V  T+ S5 Z6 f                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
$ e+ s/ a% b: u9 P" E                  reset=true;
0 j& v1 G. l7 y# \: \5 X+ a5 K6 z                  repaint();
                  btnStart.setLabel("开始");
                  return true;
                }else if(evt.target == btnConfig){
9 z$ `, _3 \& x: I2 o1 i; }% R                        running=false;
! g6 X( u7 e& S' j                        btnStart.setLabel("开始");
     Configer ctl = new Configer(this);
- G7 D7 B/ h* L                 ctl.setSize(300,300);
                        ctl.show();
                        return true;
                }else if(evt.target == choPDraw){
                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
3 `, f, _- L) r: I( _                  if(drawPhe!=1){canvas.repaint();}
                  return true;
7 Q/ D6 ?1 s  U. S                }
                return false;</P>
<P>        }
; c  f& ?( `8 x" t! @( ?7 o" w /**Destroy the applet*/
  public void destroy() {
  //当结束程序的时候，把线程也结束
* [+ \! y0 t- g7 f  G( w- f$ Z! j6 v$ H. |    if (runner!=null)
    {
       running = false;
       runner.stop();
       runner=null;
    }
  }</P>
* X* s+ G0 M5 g2 E5 O. u+ `* e  c<P>}
* q1 ]: p8 D* O) b</P>
+ C& j' |& p* I8 d$ u5 |8 k


9 y' x" J5 T8 E; j! C- ^<P>package ant;
6 ]" V3 ]8 s5 \+ w0 Vimport java.awt.*;
import java.applet.*;
% d/ T# a, M2 d0 B" j7 d* Dimport java.util.Vector;</P>
<P>public class ant{
' S2 H9 t+ h( P$ j; O) C; t Point nowPt;//当前点坐标
% n  u5 h; }) K2 ~/ y' _ int VR;//速度，每次蚂蚁能走动的最大长度
  int id;//标识
- x- M% ~8 o2 s  Point lastPt;//上一点坐标
$ X& \- ?; I0 b; a: V) b Color color;//蚂蚁的颜色
" }8 G6 n: X2 x6 v2 t! p, | Color back_color;//背景的严肃
2 P- x* T0 J% l, h1 N int height,width;//世界的尺寸
        int Phe;//每次释放信息素的数值
/ v9 Q5 d6 c; {" v  g Antcolony local_colony;//主程序的指针
        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
        double Main_direct;//主方向
3 k- X3 T; q6 _. t* e        Point FoodPt;//记录的食物点，是否找到时候判断用
" q! I. \* D8 x) [5 I! F2 Y        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
) R, w7 h) e/ s4 V0 O" k' H        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
        int Pheromone_count;//当前还拥有的信息素的总量
# [# _0 L  n/ X3 z8 c* w) _        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
( P) k8 L% j3 G; b- r        double mistake;//犯错误的概率
+ X* n- k& e, R/ n1 i% _        int memory;//记忆走过点的数目
6 C; e# k) c3 `: I9 @        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
% Y# ^9 |0 P: B, n/ _! i* H        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
) b- \# [5 H- y# m+ P4 D  nowPt=new Point(nowpt.x,nowpt.y);
                OriginPt=new Point(nowpt.x,nowpt.y);
                FoodPt=new Point(nowpt.x,nowpt.y);
                StartPt=new Point(nowpt);
                AimPt=new Point(nowpt);
; {3 X) ?$ z2 }4 w- I" A7 }                lastPt=nowPt;
8 b6 B9 ^& H( f5 r  VR=vr;
0 x( M8 D% n$ ]) q+ j  G+ \9 u- w  id=idd;
9 ^  \% a, f8 d" S) s  color=c;
! y% O' J7 `( u# Y  back_color=Antcolony.BACK_COLOR;
3 R8 E6 [" j0 N) `, y  height=Antcolony.height;
  width=Antcolony.width;
3 i8 D  K7 D/ W  local_colony=colony;
* `4 J% G% N9 e* {5 R                Phe=200;
/ W" q, F+ y1 H) V$ A: {                mistake=mist;
7 E: ^2 v- X' h0 B8 j                HistoryPoint=new Vector();
                Main_direct=-1;
                FoundTimes=0;
                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
& V" ]3 P$ Y' T: P. ^: @                memory=mem;
                Count_distance=0;
                Min_distance=-1;
7 d3 y! u# w- _. R8 q) N }
        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
          AimPt=new Point(OriginPt);
  }  G' G7 A0 R$ b: U9 i; e          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
  p# |. Z8 n+ S( b! f. k          Main_direct=-1;
& E$ h, ]1 ]2 x5 C$ I/ I! _          FoundTimes=0;
! s3 \1 O4 s* d0 g0 Y# t5 b+ {7 V5 x          Pheromone_count=Max_Pheromone;
          Count_distance=0;
  L$ P# q0 x- G7 t% g          Min_distance=-1;
% q1 E/ P* g* U        }
public void Draw(Graphics g) {
1 Z! }6 G' ^) U- y3 ^) h% H          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
3 }3 r+ |) j/ `9 s  g.setColor(back_color);
0 `9 y) H; Y$ W1 a  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
4 I, t: \0 V0 _, v2 M+ W  g.setColor(color);
, o$ o# }6 J9 r) _  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
" p: \" }# h& W$ o+ `2 p& x$ G }
2 _9 A9 a/ L5 g" g6 m5 @8 i# D public void Process(){
        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
  e6 a9 [( i0 }; z/ K        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
, O7 [+ I' f+ Q; m5 Q5 K        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>
( E% B9 N8 b$ L& ?
<P>        if(Judged==false){
7 h5 N  D, z" N% v  |* U          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
; s# ]1 l) u5 B8 D+ m& g/ z% r          if(JudgeEnd()){
              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
              return;
! t% A" F& i* N9 P7 |9 A          }
        }
        Judged=false;
: E) d) [2 {4 m- q% A" b        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
" W6 P; t$ }$ S, ^3 t" N! z9 i        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
+ h2 t" M8 g7 j6 B        deltx=(int)(VR*Math.cos(direct));
  ?4 S& `$ X" U        delty=(int)(VR*Math.sin(direct));</P>
1 u  \% X# y1 b& U+ F<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
) G  C; M# A( F6 s+ {3 d% Y<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
4 {& v, d% H9 I. _6 Z        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
5 i: l! y$ ]3 Y        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
: k* |9 f  \2 c: }9 K  v<P>        //记录搜索的环境中找到的最大的信息素
! p3 n% ~  t: A        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
" T! T2 j3 o0 ^$ X: M. o          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
          for(int x=-VR;x&lt;=VR;x++){
             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
                int yy=(nowPt.y+y+height)%height;</P>
- p, K/ X  Z5 {4 x<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
                  //的到要搜寻的点的信息素
2 w3 j$ W+ r5 C* ^& s: ]. d$ h4 t                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
) |9 @: ^( ]/ D( d<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
. R7 O) S4 h6 i+ {6 M# a/ s9 D<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
% J: V; i- _2 m( @, m( u                      double ra=Math.random();
4 L9 E2 e! u3 A; L' p2 J+ [                      if(here==0||ra&gt;mistake){
                          boolean found=false;
( t7 R) C3 k0 t( \4 F7 w2 D' Q$ [  I# [                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
4 D2 I9 }2 x! @( ^3 B3 A/ N2 P, S                          for(int i=size-1;i&gt;=size-minsize;i--){
( q8 m* L$ g. s; H5 @! s* D                             Point pt=(Point)(HistoryPoint.elementAt(i));
5 O, p5 P# z2 I5 Z6 K. C. M                             if(pt.x==xx&amp;&amp;pt.y==yy){
                                found=true;
                                break;
) C0 g! ^" f6 b0 R5 f                             }
                          }
' |/ ?0 C' \& ~, ~                          if(!found){
% c! j$ v) ?# o; c& a( J                            //如果没有原地转圈，那么记录信息素。
* n; f% N" ^# X                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
% e6 R' B0 z0 |7 K8 t2 v                            delty=y;
" ^3 P! R- M1 m9 h( _  w                          }
4 H. z4 t! `, Y) T+ _7 o  W6 h8 U                      }//end here==0||ra&gt;0.001
+ Z: i, ]7 f7 i0 p1 t2 t                    }//end maxphe&lt;here
  g2 \- A7 u+ e7 E0 v, x( _& M                }//end if x!=0
. B) X7 @0 V- o$ o' B% C6 v            }//end for y
- W% d/ k" k- s9 u9 x, {+ Q        }//end for x
        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
        pt=Evade_obs(deltx,delty);</P>
( s2 `; A. l4 h, `1 C<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
' z8 u; C* A9 y+ o* u1 _        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
          pt=Evade_obs(deltx1,delty1);
9 n) P$ }6 s& F1 k        }</P>
6 p5 @  V  P% ^& r0 _4 B6 {" {<P>        //播撒信息素
% K: ~! h; n$ l$ j7 }        Scatter();</P>
# M$ T' F  ~& |: z2 w  ?<P>        //记录走过的距离
/ Q+ d: ]0 s! Y2 ~; R/ i0 v        Count_distance+=Distance(lastPt,nowPt);</P>
<P>        //改变当前点位置
) v% z  V1 W  z5 _        lastPt=new Point(nowPt.x,nowPt.y);</P>
<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
  d5 H2 S+ F! d( Q7 a8 S# m: u        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
* g3 V8 h! h4 [' l* o        if(HistoryPoint.size()&gt;memory){
          HistoryPoint.removeElementAt(0);
        }
        nowPt=new Point(pt.x,pt.y);
3 ~2 \5 U; N, x; p     }</P>
$ V; o6 o, u; h<P>
        private void Scatter(){
0 ~1 T* m9 _0 }8 j% @, S        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
  ]9 f. S, R3 t. p& y            int kind=FoundTimes%2;</P>
1 U9 Y8 a/ O( n* Q<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
9 p$ g  M& P/ G) |& t            boolean ofound=false;
& V+ Z/ M7 w0 j, [8 W) Z0 x# ^2 c            if(Phec!=0){
                //如果当前点已经有信息素了
                for(int i=0;i&lt;local_colony.phe.size();i++){
0 B" _) v9 ^* Z; [8 z0 E* q2 D% O7 c                    //在信息素向量中查找该点的信息
                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
8 @' V# w- ?0 \2 j$ ?1 g                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
9 b) n! I% u# j! C6 F  W' j                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
9 S, I- Y2 u% f! _! x; D  B% l                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
                        ofound=true;
                        boolean found=false;
                        if(size&gt;4){
) m  _: K6 s0 V                           for(int j=size-4;j&lt;size-1;j++){
+ _) O. H; h0 J/ b% l1 p: a) @                              Point pt=(Point)(HistoryPoint.elementAt(j));
                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
                                //如果当前点重复了以前走过的路，就不释放
2 @+ f7 |% m) m# K) e                                found=true;
1 `# Q+ k! Y& ?9 V7 r3 h; q                                break;
# ]# N. z! [! B/ W5 h                              }
                            }
                        }
                        if(!found){
! |& m/ q/ c! x. q! [/ ~                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
2 W3 O( b4 @+ @/ {% G8 ~<P>                             //让还剩下的信息素总量减少
, C* d2 v* o+ D1 \/ V' l2 g                             Pheromone_count-=Phe;
8 I9 Q2 n3 Y2 t# D( J* a                        }
7 Q; K  M# j1 a  e                        break;
+ j9 {1 U4 o* s. D1 S, J9 v8 d! Y/ H4 i                    }
6 q% I; P. @" {/ ]; Y) a& h                }
              }
1 W! c5 b9 b- g1 Y( S          if(Phec==0||!ofound){
3 F- [# S$ n4 P            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
0 i6 Q' |& b' ^6 D. U0 u                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
, j% h4 q( @3 B$ d7 k                ph.Add(Phe);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
                local_colony.phe.addElement(ph);
7 [6 j! B4 ?: C: i, D+ ^# a                //让还剩下的信息素总量减少
                 Pheromone_count-=Phe;
! N# k+ h+ R" h           }</P>
2 W( a5 }6 Q6 M% h" i  z7 }$ e<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
( O( |; k+ l3 l& F9 ~. P           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
7 e! ?; X& X/ Y6 a% J% P1 c6 m           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
% R9 E0 ?! p& w8 n* P+ R, [) r<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
  h6 o: Y) [% v' Z' j  ?        }
private boolean JudgeEnd(){
    //这个函数判断是否已经找到了目标点
* B# c4 k. i! x' [2 t    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
9 H4 u# {& b, V$ I: j    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
1 T3 u: u( F& i  C' T7 H4 }        int i;
9 N9 ~8 j& R# U& E        for(i=0;i&lt;local_colony.EndPts;i++){
. e% z" N- @$ m4 c1 f: s            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
              //如果找到了食物，就直接移动到食物点
              lastPt=new Point(nowPt.x,nowPt.y);
$ g2 \" A$ F5 f  s$ g( C' H  @' Z2 t              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
% l: I8 r1 W) ^4 W              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
! S/ g* w" q5 A, z! q' \0 N+ G                 Min_distance=Count_distance;
              }
              //清除总距离记录
              Count_distance=0;</P>
  \+ c# P8 G- y6 y, \, _$ d! T<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
! R9 k; j' z/ @# B" M4 N8 y              AimPt=new Point(OriginPt);
9 M2 S+ C+ L2 E  ?7 F0 G              StartPt=new Point(nowPt);
2 I4 i" N  S9 q  g, ]              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
9 \7 m. ]/ I5 T$ O! H( {<P>              //找到了食物就把找到次数+1
' h7 e: V, I+ p9 ^; r' P" i: I              FoundTimes++;</P>
<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
& x. n9 g5 l6 `) l<P>              //重新把自己能撒的信息素置为最大值
( h9 i  L1 [5 l              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
<P>              //返回找到为真
              return true;
            }
  i- @5 l/ s6 d. E* \) ?        }
      //否则没找到
      return false;
- l. M2 s) m* z" w0 K; |    }
: l& f0 o, U, f: E    if(kind==1){
; \) L: t+ H. c  O6 L5 F- k- S        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
            lastPt=new Point(nowPt.x,nowPt.y);
" g/ Y$ W+ D- J' m8 q+ ^            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
<P>              //计算最后的总距离
0 S  C; V4 R( K% a+ x              Count_distance+=Distance(lastPt,nowPt);
0 w4 E# j" x( n              //比较大小，记录较小的距离
# V$ K: }* U+ l: ~* |8 @              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
              }
              //清除总距离记录
: {# t' V9 |- A/ Y) L              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
            StartPt=new Point(OriginPt);</P>
<P>            //重新置信息素
            Pheromone_count=Max_Pheromone;</P>
& @5 Y$ u5 n1 u% H  i3 K7 y1 A<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
<P>            //主方向反向
4 {! u5 {$ M$ K8 h            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
            FoundTimes++;
            return true;
9 k+ [+ S3 `, L        }
        return false;
1 D- j  M; b9 d. L. A5 z* D5 ?) R    }
! j- ]+ o5 m" _, V. I    return false;
}
        private double SelectDirect(){
/ q, P- B, o+ }/ l: J                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
4 W$ s: }* ]7 Q6 y! {" u                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
0 Z% d0 ~. l8 N3 \- d3 k, g, O        e=2*Math.PI*Math.random();
                      Main_direct=e;
* A  f/ @( A1 \# Z3 b. O  P% x                }
) Y9 Q+ A0 l5 R! L9 f3 n                //选择主方向角
                direct=Main_direct;</P>
5 F; J3 O: ?: |# N; E3 p<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
5 j& B" a" F4 W* b- z                //[-1，1]的随机数，并且在0点附近的概率大，两边小
7 g" @0 p1 u- V) A7 b                double re=Math.random();
                double re1=Math.random();
0 I: e- E) [8 ^0 i) y& o, R7 W. _                direct+=Math.PI*(re*re-re1*re1)/2;
4 e7 M% S& }5 d! f                if(re&lt;0.02){
                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
. Z; M& E7 [. ?, G, f" {- _                  int size=(int)(re1*memory)+1;
/ }1 u$ c; ~  v( ~+ }- @0 m2 Y                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
; ]- \7 ^+ ?/ d4 p/ D                       Main_direct=GetDirection(pt,nowPt);
. x1 {' T2 ^# j) e. T  s                    }
. M; E- b- f+ F; X0 g3 |                  }
                }
               return direct;</P>
; {5 I9 p7 j& Q<P>        }
+ i+ S8 A! t/ t        private Point Evade_obs(int deltx,int delty){
              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
  [$ `6 Q' I& _1 Y4 N% @  N+ V              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
  Q6 M. f8 A; D" W              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
" Z# a% G, V) V, K6 U% x' A              //p1,p2在这里分别是nowPt和nowPt+delt
              Point pt=new Point(0,0);
  O' o8 {1 p  Z& L  ]. `8 T% V  a! n              int x,y;
              int delt=deltx;
. h5 E  Q6 W0 ~4 W" I# b% `: V              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
- a4 l1 S& k! W$ z. A3 w+ k              if(delt==0)return nowPt;
              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
* l# W5 u1 _/ o: T" R! M- I" R                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
' G  _3 q, \% X& j- N$ U                  x=(x+width)%width;
                  y=(y+height)%height;
                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
  c# a) o# S+ M% u' T                     //新目标点为障碍物前方的点，主方向随机取值
4 q3 K; B. U) t5 v! V  S                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
( ?7 K7 G7 L" g* K+ U2 [+ S                     double disturb=4*Math.PI*(Math.random()-0.5);
% S! a3 d( B7 ^& A; u: j! P! L1 g                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
) ]: W, S# E) x+ J8 f2 z, G( M                     break;
                  }
                  pt=new Point(x,y);
- h) G! K8 r. P                }</P>
<P>                //计算得出实际能够到达的目标点
  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
0 m" w& O  X# y! d  r; [         return new Point(x,y);
* i9 ]+ d/ [  W2 f( `        }
. `, q8 u' G% Z7 b; u6 x9 q* N- e/ P        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
' w2 h4 W, e5 A8 L% G, \        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
0 P: i/ s! k; G& f/ B  B        //其中方向角是所有可能的角中使得两点连线距离最短的角。
: c# k# m9 e# C, ~: e               double e;
5 g% Q- X; ~- z+ m; j' g5 u  i               int deltx1=pt2.x-pt1.x;
               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
: n6 ^8 f% q/ }! M/ I               else deltx2=pt2.x+width-pt1.x;
" E$ _# x! m7 G, Q               int delty1=pt2.y-pt1.y;
$ _0 ]9 N" y9 e3 ^2 i6 o               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
8 {) R3 C" V: n% b, P) A) N, u               else delty2=pt2.y+height-pt1.y;
               int deltx=deltx1,delty=delty1;
, F, }/ I/ z$ @               if(deltx==0&amp;&amp;delty==0)return -1;
3 p& d) ]; ]4 t% X- |- P, C+ N- Y4 b6 C               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
               }
" ?$ ?% f* O( F0 K+ N        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
               }
               if(deltx!=0){
                    e=Math.atan((double)(delty)/(double)(deltx));
$ P! v$ W! Q- U                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
                       else e=e+Math.PI;
                    }
1 c  t9 E3 b1 I$ R" r6 e4 a                }else{
3 D4 ?: f2 v- a& f6 H, x, ?                    if(delty&gt;0)e=Math.PI/2;
4 F  E& e- n& S                    else e=-Math.PI/2;
                }
                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
        }
        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
% R' s( a2 a# @$ S            int dx1=pt1.x-pt2.x;
/ U0 `" s6 G! T/ x            int dx2;
            int dx,dy;
% C$ _) M' i7 w% c            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
            else dx2=pt2.x+width-pt1.x;
            int dy1=pt1.y-pt2.y;
$ n) _  c' D3 v+ D* U            int dy2;
            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
            dy2=pt2.y+height-pt1.y;
1 ?! s! h* X& V; q# p            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
            else dx=dx2;
. \( E" T3 _: @1 b$ u            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
6 S% O$ b% W& z( ]/ Y! D! F            else dy=dy2;
1 O- N/ {  S2 _$ b            return Math.sqrt(dx*dx+dy*dy);
0 q1 p- A( X/ @2 a( k% Q0 u        }
4 I6 v' W& D! n# ?    public void clone(ant ant1){
        //把蚂蚁ant1的属性拷贝到本蚂蚁
5 H. G; f$ |5 C) }8 k     nowPt=new Point(ant1.nowPt);
        OriginPt=new Point(ant1.OriginPt);
8 D& |* x. {2 l5 Z+ D% Y$ g        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
' E! `* o9 ~  g# P; L2 P$ L        lastPt=new Point(ant1.lastPt);
        VR=ant1.VR;
        id=ant1.id;
) G0 |5 P/ O/ `+ }$ Y, e        color=ant1.color;
        back_color=ant1.back_color;
* G* e1 U) g2 m, ^        height=ant1.height;
  I: a* z& H9 Z* W7 E2 H        width=ant1.width;
        local_colony=ant1.local_colony;
' z9 s( ]# R, N- ]4 G! W+ k+ b        Phe=ant1.Phe;
        mistake=ant1.mistake;
2 v! W9 q0 T* `! i6 n3 I        HistoryPoint=ant1.HistoryPoint;
7 p6 K% ]7 `/ E2 \! S0 J& b        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
        Max_Pheromone=ant1.Max_Pheromone;
4 K. |7 k; n: B- K4 n        Pheromone_count=ant1.Pheromone_count;
0 h# w5 j/ \5 X4 j# S% n6 P        memory=ant1.memory;
$ v6 x  m2 P( r2 J% |; U        Count_distance=ant1.Count_distance;
3 L; |* m) G. A8 n. Y' f        Min_distance=ant1.Min_distance;
% V9 L. t7 @6 i! K6 [( w1 g0 ~; J0 g    }
}</P>