[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
# k+ y2 d) V; @<>package ant;
/*
* @(#)Antcolony.java 1.0 03/05/22
*
( y# e+ J0 l# ]% e% c" g; { * You can modify the template of this file in the
* directory ..\JCreator\Templates\Template_2\Project_Name.java
*
. N$ O  J; [: p8 \/ w5 C/ D5 G' ] * 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.*;
import java.applet.*;
import java.awt.event.*;
- p$ T* S9 k+ Timport java.util.Vector;</P>
<>class AntCanvas extends Canvas
. I; K- P; i$ u( T/ c' H/ ^5 A{
    //画布，一切画图操作均由该类完成
5 Y* |' t9 |) x) v+ y- V- b //Image image;
0 L' q+ x/ q7 j5 e Color obs_color;//障碍物颜色
1 z7 p3 [* W# s# i  q- {  a Color origin_color;//我的颜色
Color back_color;//背景色
        Color end_color;//食物点的颜色
" o4 k- _) }. |$ V( F* N1 e8 W, l //boolean first;
& v! D. L; O- ]- f/ c9 Y+ a boolean reset;</P>
<>/* public AntCanvas(Image img) {</P>
<>  super();
- p3 _/ U0 e" D  q$ M+ |4 y   image = img;
  obs_color = Color.white;
$ Y2 m: L, ]$ h) E9 u; e  setBackground(Color.black);
" ^% ?$ c- t! F, ^: E! b+ d+ B4 D  setForeground(Color.white);
  first = true;
, G& V0 T! `/ d0 \8 A, a' M# x% `  reset = false;</P>
<> }*/</P>
<> public AntCanvas() {</P>
( R( W+ p% b+ I1 v<>  super();
   //image = null;
# q8 M* n2 S3 ?/ a, J( [   back_color=Antcolony.BACK_COLOR;
# ?% m1 ~. [: A4 {/ n: A/ a! A  setBackground(back_color);
  setForeground(Color.white);
! t9 E% |1 y9 z& V- f3 c  obs_color = Antcolony.OBS_COLOR;
  S* G  N* V$ |6 \( t* C# G  origin_color=Antcolony.ORIGIN_COLOR;
                end_color=Antcolony.End_COLOR;
  //first = true;
  reset = true;</P>
+ F" ^: q9 W# a, ?) T5 Q5 F% E<> }</P>
<> public void Clear() {
        //清空画布
  reset = true;
  repaint();
}</P>
) L- j, A* v1 M$ D1 E) E<>
0 L/ c- {1 D0 a( P4 @ public void paint(Graphics g) {
5 `: {' F) I* z5 R  int i;
                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
" t0 Y+ s& K) G; v9 l5 y   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
7 q/ J9 h; M" H+ {  }</P>
<> }
  W) N: \5 s# A& w6 \; j public void process(){
        //处理动画的过程
1 p* M- O( e/ F! d( J  Graphics g=this.getGraphics();
                g.setColor(end_color);
   for(int j=0;j&lt;Antcolony.EndPts;j++){
6 e5 S5 Z" v! ^, F3 n0 D  R+ z                  //画所有的食物点
                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
" t5 S" H4 d5 V  d* I5 A3 F6 `% G3 U                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
+ v+ h* C0 z* i                  //每只蚂蚁开始决策，并画蚂蚁
   Antcolony.ants.Process();
; W' N* b( I; d; Z# o" J   Antcolony.ants.Draw(g);
0 ^9 \/ @/ r" x5 h5 j  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
- H( F  q# t" A+ Q" c$ d+ w$ W                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
                        //Antcolony的drawPhe变量标志是否画信息素
& `! P: i$ P% e3 ]( p) t3 s. q                        switch(Antcolony.drawPhe){
                        case (1):
                            v.Draw(g);
7 Y  C% M3 `! e) u; y# j                            break;
0 Q# e; a" v  J                        case (2):
                            if(v.kind==1)v.Draw(g);
                            break;
                        case (3):
                            if(v.kind==0)v.Draw(g);
                            break;
' O* D% Q9 Z7 j# L  w                        }
                        v.delimit(g);
8 t) G, ~* h2 o                }
. o9 U, _6 n+ o! v           g.setColor(origin_color);
: m9 `) Y- H, d/ V" S# i                for(int i=0;i&lt;Antcolony.OriginPts;i++){
. `" W, r/ G! }9 K. A0 ^* X' I8 {                  //画所有的窝
. l" Q- j6 P. b9 G! R6 G; V1 u                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
* b' G- X  V/ ]* E$ b* P& O+ w                }</P>
<> }
% P4 k, a. ^+ E6 g7 k; N, j  m Graphics GetGra() {</P>
<>  return this.getGraphics();
}
}
/ o8 l. R! @7 O& O7 C- @public class Antcolony extends Applet  implements Runnable  {
3 H0 G5 }7 s! w' U8 \# j boolean isStandalone = false;//系统的参数，是否独立运行，不用管
2 J$ Z9 {7 R  {1 j$ h/ n5 ^+ A. b Thread runner;//创建一个线程，让动画平滑的运行
8 |$ {# `9 J  Q  M1 E" d boolean running;//是否让动画运行
( l& @5 \1 h5 x  |        boolean reset=false;//是否按下了重置按钮
static Color OBS_COLOR=Color.red;//障碍物的颜色
static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
3 l3 \0 D. V8 o  @. f% Y  R# }) Z static Color BACK_COLOR=Color.black;//背景色
static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
" c) v, d* O3 J, Q/ L" U3 k        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），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
% s! o6 Y! l# T9 J2 Z4 X; y        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
- x( l' S+ {/ ^! L, X* g4 [: D        static int OriginPts=1;//窝的个数，最大为100
static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
$ r" [. G" R4 O; k+ [        static int FoodR=10;//食物和窝产生梯度的信息素的半径
$ J$ c! I( B  N# H! \4 N# k static ant ants[];//蚂蚁数组
# O$ D* @* r8 ^/ h4 b8 ?        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
4 N8 [0 ~1 U- x int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
- |# Q; R! Q+ r. j7 ^! ^<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
4 \4 _1 z7 @! O+ z- ]6 D: g        Button btnReset=new Button("重来");
6 b" `# d# M4 I6 Q. g9 `( P- u        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
  d1 F- J; Q! R7 m public void init() {
7 o4 P' Z) m0 ~1 R0 A% Q, Z1 W                //初始化函数，先画各种控件
/ M* F. q7 N! B2 J# q  setLayout(new BorderLayout());
                Panel pan=new Panel();
                add("South",pan);
                this.add("Center",canvas);
                pan.add(btnStart);
9 K! k* d/ b; M) [, A0 i5 g. R                pan.add(btnReset);
1 x' g+ r5 X$ l1 e& h                pan.add(btnConfig);
                pan.add(btnMap);
+ |# V$ M* a) R  P, K                pan.add(choPDraw);
% A& e% Q, B, j5 e" o; B" T                choPDraw.addItem("不画信息素");
/ ]0 K0 E5 |( U) |                choPDraw.addItem("画所有信息素");
2 F' _; D( v# X/ c" G( \1 |4 p  H                choPDraw.addItem("画食物信息素");
7 Q3 \8 X' \% a3 m6 H# a" s8 B                choPDraw.addItem("画窝的信息素");
                choPDraw.select(2);</P>
<>                //初始化各个数组
  obs_grid=new int [width][height];
+ C2 M" O, D: ^! d% J/ e/ X$ _& ^9 m! ^                phe=new Vector();
                Pheromone_grid=new int [2][width][height];
( ]# U: W3 \7 @% R3 u                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
' Q7 r/ d3 H- G0 H( h. H: T    obs_grid[j]=-1;
0 @) v) c' r/ o7 D# G/ T9 T                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
2 k9 f# g# M: ]$ ]1 X                                }
8 N2 R4 v$ c& C- q   }
  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
& y$ O, U8 ]' Z( @, M+ j          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
" f  N* G4 u# V7 X  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
# T+ d, F$ d& q- V" U* z) @                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
                Maps maps=new Maps();
                maps.LoadMap(grid,0);
6 y9 Y& l) y% L- s+ |                //初始化地图
8 S; ?/ a9 i) }% Q0 N1 \% i# M$ i                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
  reinit();
  b* }# Z" ?. K/ F# i( W3 j7 Q }
        public void reinit_map(int grid[][]){
( Z$ `; H+ g' N: O2 U, U% K& a                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
' c6 Z! N* V5 ?: ^& `% l% \* d9 S                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
  R" f8 p- i: S6 {<>                //先停止程序的运行
                running=false;
3 C( E( D: U6 Z: Z7 b                btnStart.setLabel("开始");</P>
6 s; Y) q6 N6 ~9 X3 }( W+ P<>
                obsCount=0;
                EndPts=0;
                OriginPts=0;
                obsP=new Point[width*height];
3 G" G2 s6 T3 `% W                OriginPt=new Point[100];
                EndPt=new Point[100];</P>
: F" K9 s9 g0 A& r<>                //清空obs_grid和Pheromone两个数组中的值
7 P) k8 E) d: {7 [4 F                for(int i=0;i&lt;width;i++){
2 N8 ?' x  N/ a! {8 @/ F   for(int j=0;j&lt;height;j++){
" d9 f* `( T. h9 k% p- |7 T% g    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
) i: V4 |" F$ l2 M: Z                                  Pheromone_grid[k][j]=0;
" r0 }6 g% Z0 d$ q( i                                }
' J! e1 P" f9 X; v, }   }
! g3 ~8 z5 `9 Y$ `0 h  }</P>
<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
                    case 1:
                      //如果grid[][]存的是障碍物
. V4 D5 B+ _  j) Q1 S9 R7 \8 |                      obs_grid[j]=obsCount;
; G2 q. [3 W' o                      obsP[obsCount]=new Point(i,j);
                      obsCount++;
3 l. o" }2 t% o" `' h2 r                      break;
                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
& P% C3 Q8 p/ z8 N' m& g7 }                          OriginPt[OriginPts]=new Point(i,j);
6 d; ^* K6 j, W2 b                          OriginPts++;
                      }
9 N5 c7 b: Q; I8 j. o0 W                      break;
                    case 3:
0 X3 \: r3 F+ o3 j! L$ D6 O                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
) v) G" _# g) |( R0 v                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
9 ?4 g7 \# D6 ~' ?                      }
7 W5 M+ b" f- z9 [  G( R+ Z6 X                      break;
2 T. b& }. \+ A& b8 U                    }
2 B( \. y, ~& g9 r. |                  }
% n" j# q0 H& ~' S                }
            //如果没有指定窝，则随机的选择一点
; u5 w6 ]2 n* ^            if(OriginPts==0){
/ e3 p  o; I. ?# B" e5 \              for(int i=0;i&lt;width;i++){
; V) R! ^- U- T' z- _                int  j;
" _; }3 N' h) P. b3 B0 b7 T2 H                for(j=0;j&lt;height;j++){
8 @% }7 w/ p+ ]# y) S$ x                  if(obs_grid[j]&lt;0){
1 Q4 Y6 }/ v, `                    OriginPt[OriginPts]=new Point(i,j);
                    OriginPts++;
3 c1 v- d) ]9 U/ d                    break;
                  }
                }
                if(j&lt;height-1){
/ R+ M1 Z- m6 U$ A2 F9 e# c( v                  break;
2 s5 T2 ^( X, F2 z& w4 g' i                }
              }
, [5 _- {- \/ M% y( V! w% _            }
$ v* {- p( |9 R( X: H/ J# U: i/ C4 k        }
2 [5 ]# ~$ ~  U$ x$ ~* D public void reinit(){
                //重新初始化整个环境</P>
<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
+ g6 `! J5 d8 I<>
  w" q% E3 x6 N+ E# F$ y. l  //清空所有信息素Pheromone数组中的值
! A! s' w3 ?5 R# K! C" s                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
: `) G3 u8 S: q                                for(int k=0;k&lt;2;k++){
6 H  n  m" `; T; r$ j  l                                  Pheromone_grid[k][j]=0;
                                }
   }
2 W3 `: O$ x" @+ H: l% H  }</P>
& T9 d8 ~7 b# D4 d4 h1 e& L<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
          ants.OriginPt=new Point(OriginPt[index]);
4 n3 Q  ^! F" {4 C" y. j' B                        ants.init();
  }</P>
<>                //清空信息素向量
                phe.removeAllElements();</P>
/ H" C$ _9 ^. m4 f! u; I1 ~1 o6 D<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
  for(int i=0;i&lt;EndPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
$ |+ s& F0 ]/ @( Q1 f                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
: e( o$ j' ~* k                        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));
! P- ]% L2 z' q8 c6 J                        }
, F/ R2 r1 ]4 G  Z3 l: a( @7 t8 t" i                    }
! G! c  }: f  A% O  q2 o                }
6 K2 x- C4 ~, Y                for(int i=0;i&lt;OriginPts;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++){
0 Y1 K2 Q4 c3 {, F8 [, L1 h8 u                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
                    }
* i8 S. U* a7 ~                }</P>
. E% ^8 `/ I. V8 }1 I- |  [7 \<P>                //重画
  canvas.repaint();</P>
$ |! o5 d4 J. D  ^- S: f<P>                //让程序开始运行
3 b& m; {$ I% A) J2 `4 J9 Z. x& D1 }9 _- a                //running=true;
}
public void paint(Graphics g) {
  canvas.repaint();
}</P>
+ G+ F) J0 R# i3 X- f% W<P>
9 X7 u/ ~1 S! Y# \3 _public static void main(String[] args) {
    Antcolony applet = new Antcolony();
: _' \0 j) p1 b: e    applet.isStandalone = true;
+ l) q: Y" w, {, G2 \    Frame frame;
    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
& [- v! x. f% g3 D- o/ b# j        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
4 M2 n& K5 c$ g          System.exit(0);
        }
9 X5 R- L1 t8 g3 S6 |9 g8 I- ~" w& J      }
) o5 z5 M0 p6 A/ \      public synchronized void setTitle(String title) {
* P* q& D/ `0 R        super.setTitle(title);
3 q) V" J0 Q7 j# \: h- a        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
# h! ~% J' @6 ?. w6 x5 l      }
    };
    frame.setTitle("Applet Frame");
    frame.add(applet, BorderLayout.CENTER);
4 k: |5 f# f+ |4 Y    applet.init();
: M5 X% b: N3 W# Z% j' ]' Q* Q  w    applet.start();
    frame.setSize(300,320);
5 J' w# q  S% w: ^! B+ ]4 q    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
! D" g$ ~# N$ d2 l% L0 C  j' @    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
* E  K! t( @* M, M    frame.setVisible(true);
# r5 t( U$ {& S4 y2 Q; z  }
! l9 x( Q' H5 ~5 `! {  public void start()
  //下面三个函数是控制线程的
+ A7 Q3 d) d: T* |0 U! b {
  if (runner == null)
' J$ Z" O) [* g- ~" b  {
   runner= new Thread(this);
4 }9 E  {2 N  R/ _   runner.start();
# T/ r! W' i, Z& D" a3 `   //running = true;
  }
}</P>
) _7 w7 f) H- }6 h8 H. L4 K<P> public void stop()
" B8 q  c7 T" A5 N$ E {
$ c' ]# O6 c) x0 V  y  if (runner!=null)
  {
# [5 s5 }. V! y( u( A* q   runner.stop();
# P8 G0 f6 G5 u9 D4 A/ |   runner=null;
   running = false;
  }
}</P>
  `/ Q  N. R5 P6 h" J+ o<P> public void run() {</P>
/ Y8 k4 @' ~! O; G' b$ u<P>  int i;
                //线程一直运行下去
  while (true) {
  h' a: m* f5 [( A9 h* ~1 u7 c          if(running){
. e2 K. w$ N" ?( a! G       //如果开始动画，就进行canvas的处理
2 |" ]  T7 L/ K. Q- `$ w9 Z                          canvas.process();
                        }
    try { Thread.sleep(delay);}
7 A, v. I7 @* U    catch (InterruptedException e) {
& v" ~( k) Z; a* M2 U6 D   }
* I0 s( s3 q5 S8 E6 E8 D! M% B  }</P>
! z% \# K& \- g( L% B8 \<P> }
        public boolean action(Event evt, Object o) {
7 l$ `; W- `' r$ H9 `" z4 H      if (evt.target == btnMap) {
                //开始编辑地图面板
   running=false;
                        btnStart.setLabel("开始");
   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
                        ctl.show();
7 F5 ]. Q7 o2 H( F& L  L                        return true;
7 l* U0 m- m1 t  }else if(evt.target == btnStart){
                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
) T  Z: V" J- a! v6 a% ~                    btnStart.setLabel("停止");
* s1 G: M* l( j/ S                    reset=false;
                    running=true;
                  }else{
7 M1 q$ v! v0 X# p                    btnStart.setLabel("开始");
                    running=false;
3 o; P1 D! q2 w; ]  z* F' y                  }
                  return true;
                }else if(evt.target == btnReset){
                  running=false;
$ ~. \, b% n7 @) w1 U4 ~6 j) Z                  int j=0;
                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
; m* Q) V& m9 w! T: Q- p                  repaint();
- ~7 A! s8 A/ g8 S% o                  btnStart.setLabel("开始");
* k; {  P8 C' v7 C0 p1 `                  return true;
7 i- ^6 p. h0 G1 V# }$ |                }else if(evt.target == btnConfig){
, e( U: a1 F+ k& k- d3 H                        running=false;
  G6 P- r4 j! Y5 b! R( ~% R2 |                        btnStart.setLabel("开始");
- h1 L" R4 f5 Y8 c9 v( P     Configer ctl = new Configer(this);
- Z. u9 S  K" d# m+ i$ ?7 Z                 ctl.setSize(300,300);
                        ctl.show();
3 ]+ i; m. P) D5 _, E9 e2 J- T4 E* E                        return true;
, I2 a: ~/ j; B$ L! k: p                }else if(evt.target == choPDraw){
0 C  g: ?' z( v! c, J$ S# S7 Y                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
( F: w5 ?; V7 M6 q5 W# z4 C                  return true;
                }
, {5 l7 b2 M. g/ k( V                return false;</P>
<P>        }
  J# G% Y; I  c9 L* E$ b1 ?: ` /**Destroy the applet*/
, b7 I/ i+ w1 M; X  O  public void destroy() {
. Q, s/ C9 M1 ^, @. L' f  //当结束程序的时候，把线程也结束
    if (runner!=null)
( b9 t7 L$ K% l    {
       running = false;
       runner.stop();
       runner=null;
    }
  }</P>
<P>}
</P>
) l& i- T9 ?0 e3 F
+ Q' W5 @" Y0 _  a
; ?- r5 B. |! b$ B$ O. D6 L
<P>package ant;
import java.awt.*;
import java.applet.*;
$ f+ h% v5 F* ~4 [import java.util.Vector;</P>
* ~1 }0 O+ I( W- p4 h<P>public class ant{
Point nowPt;//当前点坐标
/ B4 u% w, H9 z3 |0 ]+ C& X( K% n int VR;//速度，每次蚂蚁能走动的最大长度
2 [8 x) X& d4 V1 P1 x9 Y  int id;//标识
" D, {5 Q+ w5 G. J. r. j  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
: X' O6 @4 d4 a0 e$ f+ v$ {9 M$ ^ Color back_color;//背景的严肃
" f3 L3 k7 ~$ q( @: L, z int height,width;//世界的尺寸
: U; d0 w8 {1 g* v& ?        int Phe;//每次释放信息素的数值
8 D: \- R$ ?# O+ }! T Antcolony local_colony;//主程序的指针
        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
. t6 I% g! W3 s9 {( I( J# D, t        double Main_direct;//主方向
        Point FoodPt;//记录的食物点，是否找到时候判断用
: F  b% l6 u- q7 C        Point OriginPt;//窝的坐标
$ _" w4 M. c; y! Z        Point AimPt;//目标点，是窝或者食物
        Point StartPt;//起始点，是窝或者食物
" o) ^9 j6 a- x8 L1 d* h: V        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
" V1 m1 E( g! p: [4 J. @) P        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
7 ~, n5 Z* q# S  \# C* m" \        double mistake;//犯错误的概率
) W# d  d& K, S0 U& z1 a3 |        int memory;//记忆走过点的数目
: \* w2 _3 \/ j) ~) X& D' B        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
  nowPt=new Point(nowpt.x,nowpt.y);
                OriginPt=new Point(nowpt.x,nowpt.y);
                FoodPt=new Point(nowpt.x,nowpt.y);
                StartPt=new Point(nowpt);
; ~  @7 ]: ^- n6 U                AimPt=new Point(nowpt);
                lastPt=nowPt;
  VR=vr;
. C6 K# {6 M+ b% c  id=idd;
  E; k& l: X2 o0 j. T  color=c;
4 L, y' u6 C3 V! D; ^/ K7 c  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
4 a; z, n/ T% G3 b& ]  width=Antcolony.width;
  local_colony=colony;
0 g2 @( B8 W1 q( W1 v; n4 d                Phe=200;
                mistake=mist;
; Y$ `# G4 y: c, C8 S                HistoryPoint=new Vector();
                Main_direct=-1;
                FoundTimes=0;
9 W; }4 G) K9 D+ J6 B" Z6 U+ j                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
                memory=mem;
" J  k! r' s6 }" k3 F; K                Count_distance=0;
$ c% M! {; N' n# u% m9 u; v/ J4 A                Min_distance=-1;
7 F2 w3 W; x% d9 u! {% I6 a8 v }
6 F! K2 F7 A" z) m5 L3 k+ s        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
1 }5 M# s! k7 u0 G* }          AimPt=new Point(OriginPt);
7 [* _9 d8 G0 l) ~6 ?          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
, K9 u! B  m* C" ~          Main_direct=-1;
. @* W+ Y; ?- S/ [" j# n          FoundTimes=0;
& g" q4 s) G6 f          Pheromone_count=Max_Pheromone;
          Count_distance=0;
          Min_distance=-1;
        }
9 o6 G8 N$ ~5 n  z public void Draw(Graphics g) {
          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
( Q/ J% t% F, ?/ Q0 [; h3 \1 c4 [  g.setColor(back_color);
  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
  g.setColor(color);
  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
}
5 @. F( n/ ?& c$ {! y public void Process(){
; ~* ?5 i; g: F) l        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
5 w/ W( }: a% _. |& u2 P3 P& S        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

' U. Q1 j7 x, n- X. z0 K, L  j<P>        if(Judged==false){
          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
  f3 @2 K, p8 s, Z          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
/ X, I" f4 @3 |# C+ q          if(JudgeEnd()){
& _5 t4 ]* u3 q- Y- F              //判断，如果找到了目标点那么就退出该程序
# q; S8 ]2 ?  t) r5 f% V              Judged=true;
+ v% K. q! P6 [1 ]( T# F              return;
          }
2 T5 \' h0 v, M; v- P9 v: J, B        }
        Judged=false;
4 n6 H6 b- l9 d4 D2 I9 L        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
7 B; L! P. N$ E8 `( ?+ N4 i        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
* L1 z/ N: ]" B8 r        deltx=(int)(VR*Math.cos(direct));
) A4 ^, r8 ?0 }# q        delty=(int)(VR*Math.sin(direct));</P>
<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
4 X5 `6 v4 k$ y<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
8 c+ H9 E2 Y$ n1 ]          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
; ~1 I: `) V+ R<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
          for(int x=-VR;x&lt;=VR;x++){
/ y( [: p6 L4 q7 |8 _             for(int y=-VR;y&lt;=VR;y++){
7 k/ m8 n6 C2 \2 @" _8 S                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
" d' {2 {. e& }0 E# G                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
                int yy=(nowPt.y+y+height)%height;</P>
8 Q7 \0 c4 r3 P$ v<P>                //循环的时候要除去当前点。
  K/ X* l. A8 ~) n" ^; \                if(x!=0||y!=0){
                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
  e6 T4 f9 s) R<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
7 o& ^# H+ h4 F4 m9 S<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
3 w& G; ^/ ~( f/ W                      double ra=Math.random();
0 {0 ]$ d6 R1 K: K( l( {* Y                      if(here==0||ra&gt;mistake){
  j3 m+ Q, \, N$ G0 u5 l6 x                          boolean found=false;
                          //查一下内存最近走过的memory的点数，从而避免当地转圈
  x( z% |! \: f: s( y9 H                          int size=HistoryPoint.size();
                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
                          for(int i=size-1;i&gt;=size-minsize;i--){
* W1 y6 c. d8 N* \( R* P                             Point pt=(Point)(HistoryPoint.elementAt(i));
                             if(pt.x==xx&amp;&amp;pt.y==yy){
                                found=true;
                                break;
& c1 {2 q- W# |  z                             }
                          }
' J0 U- r5 O/ z+ s! R! `" w                          if(!found){
# l& d2 P0 K5 S0 J                            //如果没有原地转圈，那么记录信息素。
3 z' N$ T1 F3 b4 ]9 \                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
                            delty=y;
                          }
8 d2 Z- {8 i: _& |3 u; A9 f4 e                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
                }//end if x!=0
            }//end for y
        }//end for x
7 m% J& N# c- \' ~9 g. {        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
% Y! {& c5 D( K- i) @, k        pt=Evade_obs(deltx,delty);</P>
<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
          pt=Evade_obs(deltx1,delty1);
        }</P>
+ M, M: M% Q" V3 I<P>        //播撒信息素
5 g/ g8 W7 u: c+ V2 k3 Y) w) O        Scatter();</P>
# `( X, a: w) n+ `) {<P>        //记录走过的距离
        Count_distance+=Distance(lastPt,nowPt);</P>
! M  W0 C6 `- c0 p7 W' V# u<P>        //改变当前点位置
9 p( S% m8 s2 I! X% M/ Y, @        lastPt=new Point(nowPt.x,nowPt.y);</P>
<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
2 a( o6 n4 w7 W) V9 u4 J        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
9 d. M/ e% U" C2 I  R1 C6 n        if(HistoryPoint.size()&gt;memory){
          HistoryPoint.removeElementAt(0);
7 o# e/ q3 c& |+ W& P( F6 ^        }
+ a& {7 c7 U0 |1 ^        nowPt=new Point(pt.x,pt.y);
     }</P>
* X5 S5 P0 p1 {<P>
* F% \4 ?% C# ^( W; x9 F        private void Scatter(){
  n+ k' E# G* |8 q$ ^        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
& J5 I, N! s# d  I            if(Pheromone_count&lt;=0)return;
2 l8 b7 a. L. r7 O$ e. b; D6 N, o            //决定释放信息素的种类
            int kind=FoundTimes%2;</P>
1 s% t' L+ a) S+ H! g: A<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
+ }6 E) ]7 N$ B4 y# j4 Y0 t8 `            boolean ofound=false;
            if(Phec!=0){
$ @: Z* c9 d8 E5 \! z                //如果当前点已经有信息素了
                for(int i=0;i&lt;local_colony.phe.size();i++){
5 I2 k/ B6 D* P& |7 a; i- t                    //在信息素向量中查找该点的信息
                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
1 Z! c. {! d. i" P: ~) U: l( _" Q                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
. m5 y. O. k/ B2 A$ E  S                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
* [9 b. X4 i1 g3 O( g2 q                        ofound=true;
                        boolean found=false;
. N6 @: W7 S$ ^                        if(size&gt;4){
                           for(int j=size-4;j&lt;size-1;j++){
+ e# A' i3 m6 ~5 Z3 w$ j9 y! f                              Point pt=(Point)(HistoryPoint.elementAt(j));
                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
                                //如果当前点重复了以前走过的路，就不释放
- Z/ u+ d' q0 }( ~' A% }6 p                                found=true;
                                break;
                              }
                            }
* U4 Z) M3 l, E                        }
, f( r& Z) j6 o  q; V                        if(!found){
. M9 O* t6 q' L8 b& [1 d! R                        //如果当前点不重复，则开始撒
: _' q+ F5 \9 X% F+ @& C                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
<P>                             //让还剩下的信息素总量减少
                             Pheromone_count-=Phe;
/ U. ~, n5 Y! K$ d2 ?5 B! c                        }
                        break;
' h8 P6 p( ]3 C% M% k6 s$ F5 |                    }
                }
              }
, {9 {% n+ Q# v' k6 s+ \! B          if(Phec==0||!ofound){
            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
6 D" p% v, T& L" a( F- O                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
! C6 J$ D/ {. ^/ g2 N" B$ {                ph.Add(Phe);
  ]8 l& g9 x( q: \                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
# D! z& U* }0 f9 |! |) D8 v3 w                local_colony.phe.addElement(ph);
                //让还剩下的信息素总量减少
  Z" b; I- S3 `; q0 u6 a" {                 Pheromone_count-=Phe;
           }</P>
" f, k* n6 F3 Z<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
# @" j0 R- t7 J, T           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
5 s, B$ _, ^  m/ f0 _; T           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
# ~+ S; q0 x8 C0 f& }( y           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
2 \0 P% p+ m3 T- M% ^           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
/ c$ o& }- |8 H# H0 H- d<P>           //如果剩余信息素已经太小了，则按照等差数列递减
' j! ^+ H! W4 G1 U+ T8 O           if(Phe&lt;=10)Phe=10;
        }
% @) m3 t( e8 c8 n. `/ Eprivate boolean JudgeEnd(){
# I, F+ Z* Z7 k    //这个函数判断是否已经找到了目标点
% C3 {) `" a& b2 y; _    //首先获得当前蚂蚁是正在找窝还是在找食物。
/ |, m$ C- J" X* i/ N) D    int kind=FoundTimes%2;
$ |, y# {: G* T' a, D    if(kind==0){
5 V; o; ~+ M4 `3 Q* z$ l; K( x% [        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
8 z; S$ G. x! k- v% O0 J  m        int i;
7 A0 O! V6 o9 Y/ \, @! }        for(i=0;i&lt;local_colony.EndPts;i++){
/ j. B9 Z9 Q* \  \3 i: `7 h            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
6 P2 i7 |+ f8 X& c' h9 B              //如果找到了食物，就直接移动到食物点
              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
<P>              //计算最后的总距离
( f" c% y! {- J* N* g! U, [              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
  N( x/ c3 h2 G# k              }
              //清除总距离记录
              Count_distance=0;</P>
& b% C4 O& E& A& b, S0 v) @+ T<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
" n  P6 k' N6 q0 O9 t: N3 S              AimPt=new Point(OriginPt);
              StartPt=new Point(nowPt);
7 \* N# I$ Q8 r- i              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
$ k4 l+ L* {$ y; w' ^: [: Q<P>              //找到了食物就把找到次数+1
              FoundTimes++;</P>
<P>              //改变主方向为原来方向的镜面反方向
' r- b8 ]0 A8 A$ L( P0 _6 r. i              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
9 C8 c- k+ h1 X; t- Z7 k<P>              //重新把自己能撒的信息素置为最大值
6 f- _( r- E  m( ^9 G              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
9 z% A/ {$ z8 t* S# L/ W  c: T# k<P>              //返回找到为真
: g$ u9 o! B$ K% [) {7 u$ _              return true;
6 G; K) c: s; K& }            }
        }
' g# E! [  o/ w% r7 }( e; `      //否则没找到
& w. }5 C/ r' n) q: p7 S! h2 J      return false;
    }
    if(kind==1){
        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
            lastPt=new Point(nowPt.x,nowPt.y);
5 v9 I/ ?: `& j2 E* R            //如果找到了目标，就直接移动到目标点
) Y: d  a; e- M# C' ?5 n% m9 W8 w            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
<P>              //计算最后的总距离
, |# z$ U9 u- H- t              Count_distance+=Distance(lastPt,nowPt);
5 G3 @2 a  G0 M4 z; z6 T              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
% G+ a% _" {4 W- z3 b2 y5 v+ R) X              }
) `& L1 U" |- J              //清除总距离记录
              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
& `' b' c. A$ |            AimPt=new Point(FoodPt);
            StartPt=new Point(OriginPt);</P>
, A9 s& }) D7 [) [. r1 p5 v<P>            //重新置信息素
/ D. k" P1 _1 W. `0 V" v1 r            Pheromone_count=Max_Pheromone;</P>
5 B/ H: K) T( p<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
! B$ K+ _+ o/ X( p<P>            //主方向反向
            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
: K2 c  ^# n5 j( _2 o' P# o<P>            //找到次数+1
: {3 I, K5 W* v4 Y            FoundTimes++;
- {0 u0 T- t) ^; ^' Q+ {            return true;
1 f5 t, j5 a  r        }
/ g! F( f; z- E) L3 @* g: z        return false;
    }
" F$ ]$ N4 M& V% L' q1 o6 Z8 L- R! w" y    return false;
/ Q; T9 O& D) N0 K# c}
6 R  f& d( a; Z4 C; X  x        private double SelectDirect(){
+ ?2 a! c* [% g+ s, ?                //选择方向，最后选择的方向为主方向加一个随机扰动
  |+ f8 W6 ?! k' x0 j- p- V5 d+ w                double direct,e=0;
                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
        e=2*Math.PI*Math.random();
  `, X) ]$ {. U6 D                      Main_direct=e;
                }
  ^. d- Y+ M0 Q( Y! c                //选择主方向角
. Q0 D! I/ i5 Y! v( u- k! l( J3 `                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
9 z8 Q' ?; j* k7 J8 i* \                double re1=Math.random();
0 Q3 D* ]/ X/ ?/ I! G                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
                  int size=(int)(re1*memory)+1;
7 T) B6 H7 R6 ~                  if(HistoryPoint.size()&gt;size){
7 G( R8 b( q: d/ h" v9 w) {                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
) F- S& _4 G  A0 q& e: {5 g0 H                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
                       Main_direct=GetDirection(pt,nowPt);
                    }
                  }
* h4 ]1 w( \* T, b( u4 u                }
               return direct;</P>
6 f  ?% G( D2 L( a- f<P>        }
        private Point Evade_obs(int deltx,int delty){
+ b% r4 q( h4 j, n4 w& e; R0 x              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
1 s' ]: d. c' N' p              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //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;
9 n; q8 [  N+ l3 l) R) Q              int delt=deltx;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
              if(delt==0)return nowPt;
. O+ T; h& [& x* w; W              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
) J: M) @3 c5 W" ~: V& q! G                  x=(int)(deltx*t+nowPt.x);
! ~) X: f3 X( W* ]8 P( E                  y=(int)(delty*t+nowPt.y);
- s) w. y$ n+ Q, s                  x=(x+width)%width;
9 p; x& s* O; W5 a: Q& x                  y=(y+height)%height;
: U( P6 q, E& j: l. W) P0 q                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
9 h' d- a9 k, e" ^+ P# @' h<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
  ^  D/ T" y9 B% @: I! m                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
- z. u- i6 y  F9 m, g; L                     double disturb=4*Math.PI*(Math.random()-0.5);
                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
                     break;
; B+ d% T7 O# |/ y9 I                  }
                  pt=new Point(x,y);
                }</P>
' G2 n: P4 X& S( t1 H. g3 r/ r<P>                //计算得出实际能够到达的目标点
  x=(nowPt.x+deltx+width)%width;
! }9 a% ?% U6 k  y=(nowPt.y+delty+height)%height;
         return new Point(x,y);
5 P& U( r1 m; w        }
# }  D5 f  K4 G" U# s2 K        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
- {8 e- o. ]; @" N2 e        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
; z9 b8 \2 E! L! c" N        //其中方向角是所有可能的角中使得两点连线距离最短的角。
               double e;
# z5 Z7 {  @. I% @               int deltx1=pt2.x-pt1.x;
               int deltx2;
               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;
- V% y% R4 ]$ ^8 {$ Z: }9 a$ w               int delty2;
! }$ }' b0 S) I, S) g5 w  ?- D9 W               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
               else delty2=pt2.y+height-pt1.y;
               int deltx=deltx1,delty=delty1;
* K& q1 s0 e) [  B1 c( Q               if(deltx==0&amp;&amp;delty==0)return -1;
' }9 [. N* {' B6 i  R6 `               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
# _: V; B; `% T% w1 c2 f/ K* V7 s    deltx=deltx2;
               }
        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
6 t$ ?: P; B8 V5 _* ~3 _; @9 t               }
( t: f; [" W% i' Q* O; ]               if(deltx!=0){
& H- a4 k3 z# p) `- M" P                    e=Math.atan((double)(delty)/(double)(deltx));
4 U+ b( |( ]* F1 Z& |/ E0 z                    if(deltx&lt;0){
5 |* A) B; {: @% x. [! n                       if(e&lt;0) e=e-Math.PI;
% j; F0 G1 b5 f9 `. @8 g                       else e=e+Math.PI;
                    }
                }else{
% C& O$ W" l% Q7 [" N7 Z                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
- L% @! e- h6 Q% @' \' K$ d6 _: k                }
                e=(e+Math.PI*2)%(2*Math.PI);
: Z) m' Z5 N% H/ H+ ^                return e;
        }
        private double Distance(Point pt1,Point pt2){
/ {& c' l8 k5 u) }) T# k        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
            int dx2;
) h( f% d* Y) b( t; ^2 n3 ^            int dx,dy;
            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
! Y5 q# s+ j$ K7 b* c! M2 I3 `            else dx2=pt2.x+width-pt1.x;
5 l3 ~, j0 l; \+ T& x7 U3 \; n; L            int dy1=pt1.y-pt2.y;
$ g( d# r0 W- s9 j6 A8 @            int dy2;
- b. B3 r! O8 P' J# x% D, c            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
0 d2 N+ v2 O( p1 z4 x* x1 p            dy2=pt2.y+height-pt1.y;
            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
            else dx=dx2;
            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
8 f! y) i7 e; B8 \5 W- w            else dy=dy2;
            return Math.sqrt(dx*dx+dy*dy);
5 z/ k" c+ ^7 _6 E        }
    public void clone(ant ant1){
# g* x6 w& a9 P# {+ a) ?2 c" u: k        //把蚂蚁ant1的属性拷贝到本蚂蚁
7 S# J6 S7 Z+ v! {     nowPt=new Point(ant1.nowPt);
        OriginPt=new Point(ant1.OriginPt);
" @: g" }! o2 {, R        FoodPt=new Point(ant1.FoodPt);
& |" E' R! q# r: T) a        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
- B2 d) A7 m) N, z3 o( W* ?        lastPt=new Point(ant1.lastPt);
1 Y+ Z4 Y1 u! m/ A% |; W. }        VR=ant1.VR;
        id=ant1.id;
6 U. x7 c* i% L4 k2 |: M# K        color=ant1.color;
2 U2 G; S7 T  P) @0 ?5 k9 d8 \. R5 v        back_color=ant1.back_color;
        height=ant1.height;
        width=ant1.width;
        local_colony=ant1.local_colony;
: J- y) d9 d0 @3 q' J! Y  f9 Q- n; j- G        Phe=ant1.Phe;
        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
) G# Y! w, M  O: j6 O4 X% [        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
2 I1 S$ ~' `" g9 Z        memory=ant1.memory;
, v, t/ j/ E, ^( u8 N/ g4 E        Count_distance=ant1.Count_distance;
5 f* A8 }& s) \$ {+ \        Min_distance=ant1.Min_distance;
' }6 `7 S' V; T8 e3 L  V" |' j    }
}</P>