[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
<>package ant;
/*
9 W9 \4 T8 e& `( e' H * @(#)Antcolony.java 1.0 03/05/22
*
0 K5 P9 I" B/ P0 L0 {& P$ }: @) c * You can modify the template of this file in the
* directory ..\JCreator\Templates\Template_2\Project_Name.java
*
* You can also create your own project template by making a new
! L  M# S% |% B/ D: \ * folder in the directory ..\JCreator\Template\. Use the other
8 m% x% |- N( A * templates as examples.
: P4 a3 s- C2 \$ m *
*/</P>
& [" |% p6 P" k" ?  V! ~<>import java.awt.*;
+ ?5 W+ P# w# o; C2 vimport java.applet.*;
" \0 n2 K: [# r6 V  H0 V7 r% E( vimport java.awt.event.*;
/ n  P% u9 a$ ?+ V3 l' Fimport java.util.Vector;</P>
<>class AntCanvas extends Canvas
{
3 Y; l& E- `7 b+ s! @+ b    //画布，一切画图操作均由该类完成
//Image image;
Color obs_color;//障碍物颜色
3 W+ A% s  `" | Color origin_color;//我的颜色
3 g/ y5 N1 C2 c) n Color back_color;//背景色
        Color end_color;//食物点的颜色
//boolean first;
boolean reset;</P>
<>/* public AntCanvas(Image img) {</P>
* C# P. v. ~5 B+ ~+ W; _<>  super();
" y$ W; ^, U8 `5 U   image = img;
( S* F1 s: ~0 W6 K: S5 r  obs_color = Color.white;
1 W4 k( {  o. C4 t7 c$ F  setBackground(Color.black);
  setForeground(Color.white);
  first = true;
% ?0 B1 E5 }/ `* Q6 R8 w4 E4 o  q1 @  reset = false;</P>
# t7 h2 @5 U' s6 W$ y; g( ~* }<> }*/</P>
# E( k9 S: a% Y5 c8 i- u<> public AntCanvas() {</P>
; l, b2 X' `9 v) Y2 B6 [# ]- {<>  super();
# F+ z4 A# D0 c3 T2 A1 ]! c4 D   //image = null;
   back_color=Antcolony.BACK_COLOR;
: J  ^8 Y0 r0 Q( v" X+ ?. O  setBackground(back_color);
* @7 k: G, p" s5 _6 ?. Q0 l  setForeground(Color.white);
6 u. K0 z6 D2 X5 j( M( S0 T  obs_color = Antcolony.OBS_COLOR;
) `; S) u' `, C+ F' C  origin_color=Antcolony.ORIGIN_COLOR;
6 Q8 \2 j% o: i8 s7 I& m                end_color=Antcolony.End_COLOR;
7 \: P6 r: C( ]" J  //first = true;
7 t! t% `- z% d; r, |  reset = true;</P>
3 d* r# B2 w# {6 E- u( W/ N<> }</P>
! U, A, p. H: }  a# [4 o% T<> public void Clear() {
! f" g" [$ _* G8 k' B) S        //清空画布
! y/ J+ |, Y) e1 v  reset = true;
! G6 G" A/ ?- f/ L3 b  repaint();
0 ^- x2 n& d: W/ _ }</P>
! r5 @8 T& l/ H% w2 G+ x<>
+ d. l4 G+ ?$ S7 y public void paint(Graphics g) {
1 I% I1 f+ b9 K& }; J. p1 g  int i;
  _0 @# P+ c9 o* @% R                //重画的时候仅仅画障碍物
) [# `+ ^4 F" M! Q  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
2 |; h& ?3 n. G4 ~- V  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
3 `& y) I5 u; S  }</P>
% Q) z# _: G. u2 v  c& J8 a: d<> }
public void process(){
9 H& d1 J* Y) u        //处理动画的过程
  Graphics g=this.getGraphics();
                g.setColor(end_color);
   for(int j=0;j&lt;Antcolony.EndPts;j++){
                  //画所有的食物点
5 v# m" J! O9 F9 [) W" \; m# V                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
                }
8 {3 U2 x. F% U8 F( Z; G                for(int i=0;i&lt;Antcolony.antCount;i++){
2 \( k2 ~! B" S8 L                  //每只蚂蚁开始决策，并画蚂蚁
3 }/ G% S9 E0 V! P   Antcolony.ants.Process();
   Antcolony.ants.Draw(g);
  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
5 L) a, y: ^( f0 e& X- ^                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
                        case (1):
- S! `  ?: Q  p) b                            v.Draw(g);
/ x% B. d" c) `3 i0 ^5 @8 M, E: N7 B                            break;
                        case (2):
                            if(v.kind==1)v.Draw(g);
) V# K7 g0 D$ m                            break;
                        case (3):
8 }, P# }  U: [0 e; C( u- J                            if(v.kind==0)v.Draw(g);
4 p! H; I% m$ `/ A* h( z, H2 G. r                            break;
0 [( T* ]+ ^. A+ O                        }
                        v.delimit(g);
                }
9 S0 X8 f! A1 l6 k# a3 L           g.setColor(origin_color);
7 X, h5 R2 I3 j                for(int i=0;i&lt;Antcolony.OriginPts;i++){
" m0 G: t. B+ Z. j: r1 ^                  //画所有的窝
* `+ f  I9 D6 q$ n) s5 @                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
9 p  `/ k) ^0 n1 {* |  o                }</P>
) Q$ x$ A; o! ^, H( `: u/ E<> }
4 D4 L$ K+ N: C8 W+ ~' Z# S Graphics GetGra() {</P>
1 j6 H& b) s( S  _" Z<>  return this.getGraphics();
}
% g# G& J- }5 L}
- V4 h* g, r. t2 d" u" |public class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
% n1 T2 M1 j7 ^, h Thread runner;//创建一个线程，让动画平滑的运行
! o  _$ P6 W) ^' G1 K) C boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
static Color OBS_COLOR=Color.red;//障碍物的颜色
, c! H/ f$ |9 y static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
5 F! a; L9 L7 ~8 X8 _  o static Color ANT_COLOR=Color.white;//蚂蚁的颜色
" m1 k3 p: G0 m1 x0 l5 ^5 J3 l        static Color End_COLOR=Color.cyan;//食物点的颜色
% ^# d8 l& g( f& u  r- C$ N AntCanvas canvas=new AntCanvas();//画图用的画布
7 n9 z2 w$ X- r- Y3 ~3 n/ y int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
2 `& a2 X. m5 C: d; V" Q# E+ Z        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
( q" i9 e6 q& e8 G2 d+ ]% H8 j static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
  h+ n4 v( o6 e% I5 J9 I8 P        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
' P  z7 s- d% {8 B  L& M; L: Z        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
: }# k' _. D2 V/ g3 u& ~  U' \        static int OriginPts=1;//窝的个数，最大为100
static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
. c2 ~% ^. q0 j4 l        static int FoodR=10;//食物和窝产生梯度的信息素的半径
static ant ants[];//蚂蚁数组
        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
/ X" y3 S" v! K' }+ ~( F<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
; D% \6 |4 x# F( D$ ?5 A& G9 d        Button btnReset=new Button("重来");
8 D( w4 V% A! E( `( g4 U+ S/ d        Button btnMap=new Button("编辑地图");
' y: a+ g: g" Z& i0 b        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
8 W8 h! M, G$ S public void init() {
; {( B; x7 {4 D' Z, n                //初始化函数，先画各种控件
  setLayout(new BorderLayout());
                Panel pan=new Panel();
                add("South",pan);
2 }) [4 X& u. j, w% \7 l                this.add("Center",canvas);
8 T6 N% v; v  @5 D/ H8 z4 e                pan.add(btnStart);
                pan.add(btnReset);
+ N7 ]0 \; [4 w- i                pan.add(btnConfig);
6 u3 w/ t* `! B                pan.add(btnMap);
! d9 k" M* T! ?: c                pan.add(choPDraw);
% c. M( h: ]5 F: i                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
- w+ t' _% x& I0 y                choPDraw.addItem("画窝的信息素");
                choPDraw.select(2);</P>
  X( l# y7 S! |- y<>                //初始化各个数组
  obs_grid=new int [width][height];
                phe=new Vector();
3 _2 H$ l0 |$ j+ [                Pheromone_grid=new int [2][width][height];
/ g* }( }) r1 g4 W, b% B$ E                for(int i=0;i&lt;width;i++){
# a$ i% w: i0 w8 @% J' \   for(int j=0;j&lt;height;j++){
$ G  @* |6 q4 a7 `6 i2 U$ t+ }6 m    obs_grid[j]=-1;
9 V, R! K- z3 K1 P% w1 o                                for(int k=0;k&lt;2;k++){
' P! W+ u! H/ J6 X                                  Pheromone_grid[k][j]=0;
+ M- T  K6 N3 V; O5 K: o                                }
, l4 ~; L; e5 V& H) w+ x   }
  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
9 F' n/ J' u/ \/ _- S  ants=new ant[antCount];
5 V' J; V- w5 _, ]: ^2 X1 `4 W        for(int i=0;i&lt;antCount;i++){
          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
  }</P>
/ A8 M% d6 D% \  y0 n3 g<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
( W! a( C' u! ~+ f( `2 K                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
( o5 f* S) b* h% N9 {( l& Q8 |+ v                Maps maps=new Maps();
                maps.LoadMap(grid,0);
                //初始化地图
& B- Q7 c% ]. c+ X* q                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
4 v$ H; b/ p# K( i; w- r* \3 x  reinit();
}
        public void reinit_map(int grid[][]){
) J5 g) H) F% o  t/ I2 B/ \                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
# k3 ?% x8 d  `* F+ b* K% ?( @1 f) I<>                //先停止程序的运行
+ J( c! y0 c: s4 n                running=false;
                btnStart.setLabel("开始");</P>
8 K- p. y4 y1 f0 ^<>
3 s2 A+ b+ K3 W, w                obsCount=0;
( {; V$ c- b6 Z: U  x                EndPts=0;
# a0 K& H, f6 K/ j: X& W6 [                OriginPts=0;
6 E4 J' M2 o7 x9 j3 B                obsP=new Point[width*height];
                OriginPt=new Point[100];
# O0 N1 J, T2 ~6 X8 k- Z                EndPt=new Point[100];</P>
<>                //清空obs_grid和Pheromone两个数组中的值
! P4 y8 J8 j9 g3 d! Y, @: [                for(int i=0;i&lt;width;i++){
2 I) A- i; x8 b# \2 G6 y   for(int j=0;j&lt;height;j++){
$ Z; }$ N. D: e: \5 U: ^    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
# _8 V# n0 Z0 E- A+ {                                  Pheromone_grid[k][j]=0;
. I+ \8 k5 F( |  L                                }
! E' A1 ^! H/ ]7 h# ]+ q   }
1 j1 |# G2 _; o' L7 u' P: D  }</P>
. }- b3 s/ M5 z' m+ U<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
6 y" F( t3 \7 @( e' S1 @                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
                    case 1:
                      //如果grid[][]存的是障碍物
0 I( h# r0 [5 a1 l; [2 v0 Z                      obs_grid[j]=obsCount;
1 D9 h% ]6 C: e. Q                      obsP[obsCount]=new Point(i,j);
8 R$ G* D' n8 [: m! |) D                      obsCount++;
                      break;
                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
                      }
+ A4 x' B  U% l6 E1 w/ i5 Q7 _0 ?0 W                      break;
8 V: T* b4 N; v: g, P                    case 3:
! C; N7 X' b$ f+ k: H0 a2 A9 C                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
7 |* b8 C, T6 v! ~                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
                      }
                      break;
                    }
                  }
                }
            //如果没有指定窝，则随机的选择一点
            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
4 _0 b5 }1 X, ~. V                int  j;
                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
                    OriginPts++;
* G  O6 Q% w. v                    break;
                  }
& c, h1 ^% M8 F$ o; O                }
                if(j&lt;height-1){
                  break;
                }
. M2 P2 v' r0 }; E              }
/ P0 h7 ?% R! Y            }
        }
public void reinit(){
- A, J0 a6 v8 X% M% H                //重新初始化整个环境</P>
<>                //先停止程序的运行
% A( r8 e' E! a$ n& H                running=false;
                btnStart.setLabel("开始");</P>
<>
  //清空所有信息素Pheromone数组中的值
                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
6 W  }% ~- D6 E, _  t                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
. O7 X* C" R; O4 @+ u) _   }
6 N% U* T, {: k. x9 F  }</P>
3 e* P: G3 k. z<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
- @2 X6 p. x; d" U4 ?& h          ants.OriginPt=new Point(OriginPt[index]);
, L# t' h2 U- p/ K" x/ n) `: h: X" A                        ants.init();
  }</P>
9 O" v4 G6 ?; o8 y<>                //清空信息素向量
                phe.removeAllElements();</P>
<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
6 P  _$ }6 X  a) f% e  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));
5 f* o6 K. g8 q" r' R: Q/ B+ e9 O                        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));
                        }
                    }
                }
/ z3 {0 O8 o' H- H2 C" d                for(int i=0;i&lt;OriginPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
; ?% Q' y1 A2 w0 ~( G& x8 C                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
) s% j+ C  d1 m4 A1 |& ^                        for(int yy=-y;yy&lt;=y;yy++){
/ T- o8 Z- z3 n  v- t& V                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
4 E  a& T2 ]# r. ~" _! S  u                        }
# t/ @% G. G$ M                    }
$ o4 R2 y* v$ F: T                }</P>
  f* C7 d; H% E3 K<P>                //重画
  canvas.repaint();</P>
9 N/ q) h  j% f5 n7 s6 t4 x' B<P>                //让程序开始运行
1 ~! S( i0 I2 P8 I# A( Y/ T                //running=true;
! F' _9 i8 I8 }  M8 s }
; B2 Y& y, R2 V: L" M public void paint(Graphics g) {
/ ?* i9 `+ U* e. l, S: W  canvas.repaint();
}</P>
- u7 O5 |) Z- E; P' v<P>
, h' X: Z* r+ u4 U$ s/ Fpublic static void main(String[] args) {
    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
    Frame frame;
    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
          System.exit(0);
        }
      }
      public synchronized void setTitle(String title) {
        super.setTitle(title);
  T' Z) q: N7 ^+ ^        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
+ q+ w3 Y; z/ |$ S) H( s8 j9 @+ T      }
8 _. u3 z. j$ S, ~    };
    frame.setTitle("Applet Frame");
    frame.add(applet, BorderLayout.CENTER);
- R5 o, M( Y% U1 X    applet.init();
5 a% _# i! k/ S0 y* D    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);
* {2 h2 d0 g$ ^. m* Z+ h3 o( o    frame.setVisible(true);
- N8 s3 i. c7 ]1 s- T; I3 |  }
  public void start()
  //下面三个函数是控制线程的
) G& Z- O9 C2 U; |% G8 Y {
' s" s3 [3 @0 `7 x, a5 J7 v  if (runner == null)
; N# X6 Q7 m! b2 ~- `5 [& m  {
9 q5 g* {9 c& G# h. T+ V   runner= new Thread(this);
   runner.start();
3 B& G+ C# E% f   //running = true;
  }
}</P>
1 Z- _. w) W$ w! n! B<P> public void stop()
{
+ z" b% g; d5 p% w  if (runner!=null)
8 ?3 S' n- N5 ~" l: p$ {  {
' b. O9 f+ V- U- j$ t0 @   runner.stop();
3 L: p( Q1 m2 k. G: @   runner=null;
5 J( M3 Y/ `; K5 d   running = false;
  }
}</P>
- u  O- l1 @, q<P> public void run() {</P>
<P>  int i;
                //线程一直运行下去
  while (true) {
          if(running){
       //如果开始动画，就进行canvas的处理
4 m( S) T( Y% y' K( [3 y                          canvas.process();
+ I2 X  D$ F- U% ]                        }
    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
- r* X" v" U5 l$ O: ^+ U0 B   }
0 I" t0 S! f, r: S! v8 h! M/ t  }</P>
<P> }
1 v% T$ ^! G* H  \- q        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
                //开始编辑地图面板
8 _1 p. ]% F3 n4 T# b5 C" M. c   running=false;
                        btnStart.setLabel("开始");
# l0 r! b  N7 E' ?1 y7 ^   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
# d$ w! y' o0 }/ t2 q                        ctl.show();
" W. Y4 O# {. ^( T& a3 e) Q                        return true;
$ R! x, [, k7 z- \$ {9 n  }else if(evt.target == btnStart){
                  if(!running){
# V$ `0 V' b. F/ C7 L  Q8 {4 }0 ], B9 K                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
; ?2 P7 q( |) F* f, f                    btnStart.setLabel("停止");
* n8 C# ?6 e; r: g$ e7 y8 A- d                    reset=false;
$ S# H; `8 w1 V* U                    running=true;
9 Z6 I. C1 s$ f1 Q* J                  }else{
                    btnStart.setLabel("开始");
& e, H' o' e2 W8 }8 _% k7 ?$ k: E                    running=false;
4 i* X; j8 l( d. Q/ l! ]8 C                  }
                  return true;
8 j2 E3 a1 D/ G$ ]' u2 Q6 S/ I' M                }else if(evt.target == btnReset){
8 j/ |! ^( m& |8 H2 J! s                  running=false;
                  int j=0;
                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
3 L/ V# g) v( F1 Y% L7 A/ N                  repaint();
                  btnStart.setLabel("开始");
                  return true;
7 o& |; d2 P' z3 d; @- Z/ \: T  V                }else if(evt.target == btnConfig){
2 w! S5 x7 _+ k. ^3 @& R0 m                        running=false;
6 X( @- ~2 Q/ i7 A0 v9 y                        btnStart.setLabel("开始");
# v( N4 x# g0 M; F     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
* p( P0 `% L( X1 X0 _2 j                        ctl.show();
                        return true;
                }else if(evt.target == choPDraw){
8 U3 X. b8 L; I3 o* A                  //选择画信息素的模式
( w6 v) W" G6 R                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
                  return true;
& j" [, A" O$ F. h                }
' ~; |- D5 k, {, J, B. R7 [9 o/ _                return false;</P>
2 e0 h* A; E4 b% k<P>        }
/**Destroy the applet*/
5 j7 S* a5 @9 x  public void destroy() {
# L+ j' Y  g! S% G3 t# s  //当结束程序的时候，把线程也结束
    if (runner!=null)
    {
8 {1 v; r: p3 r1 W7 K; ?* c, Z       running = false;
       runner.stop();
9 J% |! t! b. v7 }  s7 J' `       runner=null;
* j: y0 b$ V' G' a# X7 U) c    }
1 S0 c' }2 [. v) @9 K% v( l  }</P>
9 {9 c- d0 z, H& y  A7 W8 p<P>}
</P>


2 P4 M' ]3 Y' {: C- Q# W
8 r! t0 D1 H( W4 V<P>package ant;
0 C  O- T8 S" X  k$ l( r: s  \import java.awt.*;
import java.applet.*;
2 `$ o: |5 z' F/ ?2 @( Bimport java.util.Vector;</P>
6 I8 D% A8 J  m- d0 ^* Z<P>public class ant{
Point nowPt;//当前点坐标
int VR;//速度，每次蚂蚁能走动的最大长度
% N0 X& p/ k- j/ c2 G  int id;//标识
  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
int height,width;//世界的尺寸
        int Phe;//每次释放信息素的数值
Antcolony local_colony;//主程序的指针
) S, @- \7 g/ R3 n" w. q        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
9 l& S! \: b6 u. [7 J! h        double Main_direct;//主方向
        Point FoodPt;//记录的食物点，是否找到时候判断用
        Point OriginPt;//窝的坐标
+ D: L# U8 X3 z4 M0 w3 E        Point AimPt;//目标点，是窝或者食物
8 w) R' j$ D' F        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
        int Pheromone_count;//当前还拥有的信息素的总量
1 y7 j, }6 E6 Y, Z1 k$ h6 m        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
: y/ ?' z5 b7 j- M( J! Z& W        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
+ W/ J" e6 X* W) [- ]        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
2 w7 C7 A1 t7 `  X+ Q% L public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
  nowPt=new Point(nowpt.x,nowpt.y);
6 ]4 w( F" \8 J! R6 r8 m                OriginPt=new Point(nowpt.x,nowpt.y);
                FoodPt=new Point(nowpt.x,nowpt.y);
                StartPt=new Point(nowpt);
                AimPt=new Point(nowpt);
                lastPt=nowPt;
4 I3 p6 }. l* @6 G# o  VR=vr;
+ p, W  h4 e1 A9 f* a: Z  id=idd;
  color=c;
  back_color=Antcolony.BACK_COLOR;
( p/ ~( L7 J1 q  F1 ?  height=Antcolony.height;
4 R. |" n* u4 a6 `0 C4 b  width=Antcolony.width;
% a5 N1 |* f0 c' N7 Y* P3 B- @  local_colony=colony;
8 B# e! S7 f0 b/ Z1 g3 a                Phe=200;
                mistake=mist;
( C( Z. s* ^4 X6 s                HistoryPoint=new Vector();
                Main_direct=-1;
& i! Y6 L& i' q/ `                FoundTimes=0;
                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
* a8 G7 f4 [1 p: U# I- E: k( a                memory=mem;
                Count_distance=0;
6 i- J# [$ h& ?0 y9 |: ?2 g+ I                Min_distance=-1;
}
        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
$ w2 l& N8 ]/ |' l3 x          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
( f6 M! o3 Q& H          HistoryPoint.removeAllElements();
/ o' P$ v: K. M, s          Main_direct=-1;
3 T8 H: R: V* @          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
          Count_distance=0;
          Min_distance=-1;
  ~7 Z" i; T# z* a, p3 _% H! k6 P4 I        }
/ y! Z; c; _8 a  ~. m# T* Z5 n4 D public void Draw(Graphics g) {
9 \) E5 T% D+ g# `% n          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
  g.setColor(back_color);
- X+ D1 m% {7 Z3 n  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
  g.setColor(color);
. H  g, U+ I, }, w  ^. C+ l0 t  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
& H  s6 Z/ R( e2 c# Y }
+ t) r" s  E4 `1 c public void Process(){
0 Y; K. l/ ^* |! ~/ p        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
2 Y) L% p* o6 s4 R        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
4 U, A, a' d2 F6 j7 [' @        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
/ b6 v$ R  k$ a. j8 }% q0 b2 s        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

9 K  Z) A2 l) J# p+ w8 H<P>        if(Judged==false){
0 b2 \  @" S% ~, U2 i% y          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
" R( c' e+ I& {  k$ m) F0 [# d          if(JudgeEnd()){
: ?0 M" B# m; o& }7 w5 Z8 h              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
              return;
- n) l: Z8 T3 [' c          }
' U+ E& r9 I4 R. D% _8 S- q+ u        }
' |* p* [0 {3 H3 v0 V% G        Judged=false;
        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
) |/ g# g. P0 P+ ]<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
" V, T, ^# p) \, o8 d        //direct是方向角，根据方向计算位移
1 K- \# ?' q" `: O7 d! ~        deltx=(int)(VR*Math.cos(direct));
2 F4 l& ~& v+ G" N        delty=(int)(VR*Math.sin(direct));</P>
8 G- O% D) d$ q) x, n% w<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
+ N8 h9 ]; {5 n9 L0 u( ?        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
- q3 _' t- _: J" k* m<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
          int deltx1,delty1;
1 u# g+ R+ U4 h) ^# D4 F          deltx1=deltx;delty1=delty;</P>
- k: a7 a. c+ e) [) s: h) z! g4 ?<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>
5 T2 N, g& c: l% g3 b  f% Y* h, u8 |<P>                //循环的时候要除去当前点。
4 s3 i) ~" |' z  o                if(x!=0||y!=0){
5 Y5 x8 T7 r8 o  X) U                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
5 }* j; m) O% P# B$ x0 Z2 j  w<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
; @5 D% L/ X' `4 V- r                      double ra=Math.random();
- r$ v- K! h/ g0 B( @                      if(here==0||ra&gt;mistake){
                          boolean found=false;
& E. a$ d* ?  U5 N( B- A% ]                          //查一下内存最近走过的memory的点数，从而避免当地转圈
3 _+ i6 r/ E7 `                          int size=HistoryPoint.size();
8 d. q+ t7 C# B; X0 N2 c+ x                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
                          for(int i=size-1;i&gt;=size-minsize;i--){
$ a" B! o0 \: x% a7 D                             Point pt=(Point)(HistoryPoint.elementAt(i));
                             if(pt.x==xx&amp;&amp;pt.y==yy){
7 T/ O6 V; G( s7 ^6 \8 h2 ?                                found=true;
                                break;
                             }
                          }
                          if(!found){
                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
* M' y9 b2 W' p; d/ n                            deltx=x;
                            delty=y;
5 I6 L2 _+ q6 d! Y9 x( u                          }
. u: G2 K, z% H                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
" U% A( Z! S4 F! i* \9 ]( l                }//end if x!=0
" t7 J6 r  p3 O0 r7 n            }//end for y
        }//end for x
5 ]7 v& [* m0 A. o3 m        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
        pt=Evade_obs(deltx,delty);</P>
<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
, N" @# X, ^/ D' N8 l( N0 c  y        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
& {8 E# u- N3 k& I8 @" F          pt=Evade_obs(deltx1,delty1);
        }</P>
3 `' C& U! ^( i8 @<P>        //播撒信息素
        Scatter();</P>
% C  l- P" b& D1 L! o6 Q1 y<P>        //记录走过的距离
        Count_distance+=Distance(lastPt,nowPt);</P>
<P>        //改变当前点位置
. G1 x, D1 ?, a6 H' a* z        lastPt=new Point(nowPt.x,nowPt.y);</P>
# \0 F( Q! M- e$ U7 S7 ]4 K<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
        if(HistoryPoint.size()&gt;memory){
. x: X3 ~7 V# J- u$ X          HistoryPoint.removeElementAt(0);
  }" {' B1 O/ {3 X/ _- G3 |        }
        nowPt=new Point(pt.x,pt.y);
/ C- o/ K( q3 f, J3 t2 t     }</P>
<P>
1 d' T& ~' F$ C  e3 w# b/ |        private void Scatter(){
        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
3 t/ ?3 i, M$ L( ~$ Y, [        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
            if(Pheromone_count&lt;=0)return;
7 \/ L0 |. a8 `/ W% I& ^# ?            //决定释放信息素的种类
, E/ b$ W+ s9 T7 O6 \4 L            int kind=FoundTimes%2;</P>
0 w; z0 D! b( o4 O6 b' D<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
            boolean ofound=false;
  r& w* E3 b, I$ T3 w/ w            if(Phec!=0){
                //如果当前点已经有信息素了
% w. ]! O: b8 d+ R5 Y                for(int i=0;i&lt;local_colony.phe.size();i++){
# G1 C0 L9 J8 b% t' R: ^/ g5 I                    //在信息素向量中查找该点的信息
                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
/ z2 T1 f, |& y  m+ c5 L                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
$ J6 l( Y  C7 P2 B. @& D3 q0 c: t; r/ |' Z                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
% x1 a6 g& r9 ~. z6 ?                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
" H) U0 J( u' L                        ofound=true;
                        boolean found=false;
                        if(size&gt;4){
                           for(int j=size-4;j&lt;size-1;j++){
                              Point pt=(Point)(HistoryPoint.elementAt(j));
* h; m9 M; v8 c6 J' M4 w3 v0 l4 j! O                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
                                //如果当前点重复了以前走过的路，就不释放
' n& E4 l) i0 Y                                found=true;
4 B; g9 W$ Q& R/ O9 b                                break;
                              }
                            }
# G0 w1 p* r  `( V# L8 j                        }
3 U  m9 h- w" B                        if(!found){
& q) n  [" J  S# _                        //如果当前点不重复，则开始撒
, V$ g1 u' o4 E. T- d                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
/ \8 h1 Z6 l$ ^7 q" F<P>                             //让还剩下的信息素总量减少
1 `9 A4 A7 U. r: o3 X. R                             Pheromone_count-=Phe;
                        }
5 v; w0 t. V9 w                        break;
; _9 u. u6 _+ x9 a                    }
                }
              }
% P& s$ f- a+ ^8 ?7 A0 V$ {          if(Phec==0||!ofound){
: W! [* r/ Q! M& }" b            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
3 P+ B& L4 U+ y                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);
, U; Z# i1 t4 g# F9 U6 X5 @( t                //让还剩下的信息素总量减少
, G* y! T( c1 J" s9 X                 Pheromone_count-=Phe;
           }</P>
* b9 l8 x! L$ M. Z<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
; d( R2 J# S- h' b# G# l           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
2 f, `  W' n4 `" q9 d' n& N- M           Phe=(int)(0.005*Pheromone_count);</P>
0 ]" q* ]- r$ X. k<P>           //如果剩余信息素已经太小了，则按照等差数列递减
3 L+ `/ H# K3 }; `! U2 i+ A           if(Phe&lt;=10)Phe=10;
% ?3 s. j+ e5 q2 R  i& y' j        }
private boolean JudgeEnd(){
    //这个函数判断是否已经找到了目标点
& X0 R0 h2 C1 h1 z8 F/ T( |    //首先获得当前蚂蚁是正在找窝还是在找食物。
2 ~/ O/ P+ s& F0 d    int kind=FoundTimes%2;
    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
7 J0 V2 a5 c6 C, `( t5 C0 S        int i;
' S/ ?, q3 x( r/ }( _( o        for(i=0;i&lt;local_colony.EndPts;i++){
            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
) [& N( {! y3 w" }              //如果找到了食物，就直接移动到食物点
              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
5 Z: ?5 L) L0 a( Y; M! O0 |2 z6 c              nowPt.y=local_colony.EndPt.y;</P>
<P>              //计算最后的总距离
, T( G0 e; m* |. c2 L/ z              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
$ N, S4 y( V' Y' V              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
; d% e6 O9 K" N) v! L7 z# P; R  W                 Min_distance=Count_distance;
              }
              //清除总距离记录
$ `8 w# q7 M3 e4 r" J. }              Count_distance=0;</P>
& q. T! B5 r* u& T; H1 w, J' y<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
              AimPt=new Point(OriginPt);
" K' _; Q/ y9 c4 K( |6 `0 }+ U              StartPt=new Point(nowPt);
( F( x# ?8 b( Z              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
<P>              //找到了食物就把找到次数+1
              FoundTimes++;</P>
<P>              //改变主方向为原来方向的镜面反方向
" v/ b6 M4 l% j  q              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
' G" d# S3 ~  A6 g: A" B$ A0 m<P>              //重新把自己能撒的信息素置为最大值
1 f: c9 g. ]8 Z1 K; d              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
8 i6 x! H( Y7 Q8 _9 S8 t0 u! I              HistoryPoint.removeAllElements();</P>
! B  ]& K  @  t<P>              //返回找到为真
) W0 Q2 D  A- u              return true;
% a# g* x$ E2 B' [            }
: p- ~3 p6 A3 o/ ?        }
      //否则没找到
      return false;
' k8 I; S& `3 L- U2 F' T7 c6 i) C    }
    if(kind==1){
        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
            lastPt=new Point(nowPt.x,nowPt.y);
6 P+ q, o2 M" K            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
<P>              //计算最后的总距离
4 v/ }8 S! A0 ~3 J) r) @              Count_distance+=Distance(lastPt,nowPt);
; t+ U% [3 k5 M              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
  G+ U$ V: S* \% e              }
              //清除总距离记录
$ `0 m9 {7 U' o              Count_distance=0;
, b2 p2 M4 }* f2 t1 W            //把目标点定为食物点，起始点定为窝
$ E. H: L, R- p. y, j3 d& O1 e/ A. A            AimPt=new Point(FoodPt);
2 O' b1 l6 y+ h+ j. Z! z5 W( R            StartPt=new Point(OriginPt);</P>
<P>            //重新置信息素
9 Q6 \0 }, ]: R            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
* ~0 f% U3 R. q" q4 U% d" e* [<P>            //主方向反向
3 I; K* \) ~5 H9 m! _# X# K% @9 j0 a            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
5 [3 z1 }- \1 p7 ?; }4 d% ^            FoundTimes++;
            return true;
! ^" s- z# A+ U6 N) E        }
0 f8 ^# _9 n" j6 h1 t0 \7 a        return false;
& @, W4 |! y3 j% k; E% z8 v  ~  S    }
    return false;
}
        private double SelectDirect(){
5 V3 S' F- p. ?$ u3 _/ p                //选择方向，最后选择的方向为主方向加一个随机扰动
. X4 h* Q9 g& q' ~0 }& x                double direct,e=0;
0 N8 `( l1 Y3 n& J' t2 R                if(Main_direct&lt;0){
4 P# x( Y" b' G$ t8 E$ }                      //如果目前还没有主方向角，就随机的选择一个
        e=2*Math.PI*Math.random();
6 z- Z9 S5 @+ _- I1 r2 _! m9 F                      Main_direct=e;
                }
                //选择主方向角
0 x7 }6 N! @! ], n1 O                direct=Main_direct;</P>
6 i/ t4 C: N% T: r3 j  I<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
, M& }; h7 D1 ?                double re=Math.random();
2 c- g4 S2 h% z6 N                double re1=Math.random();
6 s& {6 ?% Q: T' W) y1 Y" e3 Y                direct+=Math.PI*(re*re-re1*re1)/2;
2 x. q0 F- }; v' R                if(re&lt;0.02){
- e8 a& u$ o* N! `. a( W                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
. c( c5 j4 G8 K0 P2 \- V# P6 @0 D                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
3 b: [4 ]& z3 U$ K                       Main_direct=GetDirection(pt,nowPt);
) p7 W  J* K  l+ b) r! \                    }
                  }
                }
               return direct;</P>
<P>        }
  J* i! B: j' \  z7 P/ T8 S" D6 b5 l        private Point Evade_obs(int deltx,int delty){
              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
9 x0 Z6 T) |+ Z4 r              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
! F% j  i9 {( @! S9 w              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
' K3 t8 |6 }: z! r+ I) c              //其中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;
/ B/ Q* x0 e7 g$ ?. ]              if(delt==0)return nowPt;
              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
8 I8 c( H- _+ U, T! A                  x=(int)(deltx*t+nowPt.x);
% @& S. K0 I; P  l; C) r. c  v* p                  y=(int)(delty*t+nowPt.y);
                  x=(x+width)%width;
& T5 M# k. H2 R3 U                  y=(y+height)%height;
$ b  @0 ^( {3 h$ h6 M/ B8 g3 [                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
. Q! D8 \) S' s<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
( [3 T3 F% g1 W2 X/ W                     //新目标点为障碍物前方的点，主方向随机取值
                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
' l9 f9 H# k' a4 D/ y5 v' _                     double disturb=4*Math.PI*(Math.random()-0.5);
) B/ H1 \0 I  Y, p1 F) k6 _, R3 t9 m% s                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
                     break;
                  }
                  pt=new Point(x,y);
- U$ N4 M% o+ u% [0 \) C! v                }</P>
: i) U+ h. z0 s<P>                //计算得出实际能够到达的目标点
# V9 a! P0 H& `6 _. j1 s$ Q  x=(nowPt.x+deltx+width)%width;
) g. g8 l- i5 o$ _: V) i& H  y=(nowPt.y+delty+height)%height;
         return new Point(x,y);
7 ?" u6 @9 P% ^% o8 m9 ^5 L        }
# C- A4 v$ ^7 V. c! N* v: A* F" }        private double GetDirection(Point pt1,Point pt2){
) R; P( v4 S! M        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
0 l/ w9 M3 J; k: v0 W( r5 _" f        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
        //其中方向角是所有可能的角中使得两点连线距离最短的角。
* z. N% h2 e* Z5 ~               double e;
/ Y' m$ O% j1 H1 B               int deltx1=pt2.x-pt1.x;
               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
% x9 V; l) r- h% k               else deltx2=pt2.x+width-pt1.x;
6 T: P/ ?1 m& l4 c               int delty1=pt2.y-pt1.y;
3 y+ @6 W) [  n- [6 w# |" E2 d               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
               else delty2=pt2.y+height-pt1.y;
" v6 @0 [( I5 X4 P               int deltx=deltx1,delty=delty1;
' L5 h+ ^  V5 n1 R0 o& a- {               if(deltx==0&amp;&amp;delty==0)return -1;
5 p  t9 A% o6 G               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
. z. h, ?% P2 u7 k# y1 Z. e    deltx=deltx2;
               }
        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
               }
               if(deltx!=0){
                    e=Math.atan((double)(delty)/(double)(deltx));
                    if(deltx&lt;0){
  `% t6 q5 M! w                       if(e&lt;0) e=e-Math.PI;
                       else e=e+Math.PI;
                    }
3 s0 y: U2 E* t# z1 ?+ E2 A                }else{
                    if(delty&gt;0)e=Math.PI/2;
: V: h0 k: I- C/ E! _" U5 \                    else e=-Math.PI/2;
  r9 `! r  c* v, {1 Z* [) G1 [6 Q4 ]                }
/ X, J: l( F; `5 s5 L' @. Z, c0 E                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
        }
  v  Z: Y1 q* G1 A        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
6 |1 @1 g- b6 I" u3 x/ ]$ ^+ W2 e            int dx1=pt1.x-pt2.x;
            int dx2;
            int dx,dy;
            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;
            int dy2;
: k7 L  `0 P. E! c# ]            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
            dy2=pt2.y+height-pt1.y;
            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
  ?7 _$ h# }' ~2 ]# f8 ~+ b: q- z/ e            else dx=dx2;
  o. [" X' S: e+ G            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
/ h7 A, E# n9 k- C5 [            else dy=dy2;
4 }8 t( W/ g/ G            return Math.sqrt(dx*dx+dy*dy);
& _9 v/ k9 H0 I  s        }
    public void clone(ant ant1){
        //把蚂蚁ant1的属性拷贝到本蚂蚁
* y$ H" }8 s; V# k) a% i( `" x     nowPt=new Point(ant1.nowPt);
% ~% [0 t! s+ ?2 _        OriginPt=new Point(ant1.OriginPt);
, Y2 c5 P( I1 u2 F4 ~        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
        lastPt=new Point(ant1.lastPt);
) P* R7 _4 w) y7 |  e! D        VR=ant1.VR;
        id=ant1.id;
- Q- [, J* v+ a$ O        color=ant1.color;
/ P* a8 ?3 p& ?' f        back_color=ant1.back_color;
: f& Y. J  u6 U1 h! v# K        height=ant1.height;
        width=ant1.width;
        local_colony=ant1.local_colony;
        Phe=ant1.Phe;
        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
  h2 `/ [/ B, S" B- Q        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
        Max_Pheromone=ant1.Max_Pheromone;
" Z4 Q: N# D4 N! @0 j% m        Pheromone_count=ant1.Pheromone_count;
2 q/ u/ C  j3 |( v1 G8 P6 h        memory=ant1.memory;
+ S( p9 c9 U* ?" F" }: E        Count_distance=ant1.Count_distance;
7 D' t/ L1 c& ^        Min_distance=ant1.Min_distance;
    }
}</P>