[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
<>package ant;
/*
* @(#)Antcolony.java 1.0 03/05/22
2 u) m8 J$ s* ~: u *
* 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
* folder in the directory ..\JCreator\Template\. Use the other
8 u) W& j# `9 G% m. j * templates as examples.
* Y" d4 y+ v( w/ T$ c4 l' q *
*/</P>
9 j, R' k5 O! O6 C# i; Q! n1 {<>import java.awt.*;
; d+ @9 _" J4 V" P8 Yimport java.applet.*;
) ]6 J: _; `5 I+ i* a7 aimport java.awt.event.*;
import java.util.Vector;</P>
7 v2 ^  h. F. G3 m+ }6 }) ?<>class AntCanvas extends Canvas
{
    //画布，一切画图操作均由该类完成
  U1 ~  `; _- G8 } //Image image;
Color obs_color;//障碍物颜色
" a! ?! D% [2 o  D Color origin_color;//我的颜色
Color back_color;//背景色
        Color end_color;//食物点的颜色
//boolean first;
" _2 }( w0 d  f2 [( ~3 d$ q boolean reset;</P>
4 ]. T1 J0 x" y# H. j) }% B# W<>/* public AntCanvas(Image img) {</P>
<>  super();
' K+ B7 X) E1 q  c+ }2 ]   image = img;
  obs_color = Color.white;
) l% W% ~. M' u, T" k  setBackground(Color.black);
  setForeground(Color.white);
. C. ?2 b# C+ c$ g4 D* ]- M  first = true;
  reset = false;</P>
+ y3 J# z4 O( B) L<> }*/</P>
) b8 r" i, _* G& Q& O<> public AntCanvas() {</P>
<>  super();
$ P* v5 I( ~: Q# k3 i   //image = null;
8 G. F4 q. {# i, W' Z; w9 z   back_color=Antcolony.BACK_COLOR;
  setBackground(back_color);
2 c# u2 o' r/ ~7 z) r2 o  setForeground(Color.white);
  obs_color = Antcolony.OBS_COLOR;
2 m% x! P9 }) K. t: F$ N4 V  origin_color=Antcolony.ORIGIN_COLOR;
' Z! J0 |3 {- U1 J                end_color=Antcolony.End_COLOR;
3 D3 U7 w7 j, w3 D. e  S3 L4 O  //first = true;
  reset = true;</P>
+ B" M7 N0 S  h<> }</P>
3 E! M3 n0 r/ O: J% r<> public void Clear() {
        //清空画布
1 e0 l& L+ Z# p9 O/ C+ J  reset = true;
  E8 ~7 h' D) K. `7 d  repaint();
}</P>
<>
6 ?) W) _# C2 w% p/ w public void paint(Graphics g) {
# w  s1 F6 _6 G# i2 y4 ~3 u  int i;
                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
( |, S5 K4 G4 K. d6 H  g.fillRect(0,0,size().width,size().height);
  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
! U2 \: A. f8 I1 T   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
6 r% m# V8 f6 O  }</P>
<> }
% G& f# T1 L+ B7 h2 k* m: | public void process(){
        //处理动画的过程
( [5 b: k) I( L$ ^( A  F2 g  Graphics g=this.getGraphics();
1 f) w9 u7 x0 n& b* Y5 ^                g.setColor(end_color);
. o( H+ c! }1 f+ j4 d1 H3 f9 {   for(int j=0;j&lt;Antcolony.EndPts;j++){
3 ?& [4 [+ E8 q! V8 J                  //画所有的食物点
                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
: J% B- ^' I, w+ d( ?3 M                }
# ~9 p; x8 g7 a/ k                for(int i=0;i&lt;Antcolony.antCount;i++){
$ N, @: a! K% n, e, l2 _                  //每只蚂蚁开始决策，并画蚂蚁
9 V% f  W1 n" l+ A; o* d; I   Antcolony.ants.Process();
+ D( D+ C5 p1 q8 A   Antcolony.ants.Draw(g);
  }
% i  S/ v6 f" @% T' p                for(int i=0;i&lt;Antcolony.phe.size();i++){
3 B+ _4 Z# W) t( l, M/ Z% B                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
5 e( e3 X4 O1 a1 G  |4 S                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
( R' d  o& G1 J- ]/ j+ L" M                        case (1):
' p0 f5 r6 h% O* R! `" H# @                            v.Draw(g);
                            break;
# L/ b1 {4 f$ }                        case (2):
                            if(v.kind==1)v.Draw(g);
1 H5 k7 _. X" h0 O6 B8 |9 Y                            break;
+ V3 L8 C0 \8 w, p. u6 g                        case (3):
- @. O, r3 y% F& |                            if(v.kind==0)v.Draw(g);
/ Z+ D2 z5 b# _                            break;
  I. d8 Z$ s: ~% `                        }
, @  _; e- E4 \: X0 K5 d6 H                        v.delimit(g);
  }0 n% \' Y5 O/ ^. d                }
           g.setColor(origin_color);
8 f) ~% X( r& v+ J* ~                for(int i=0;i&lt;Antcolony.OriginPts;i++){
. a7 k& f7 }$ s7 q                  //画所有的窝
                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
                }</P>
<> }
) ]% U7 b' M5 _3 N8 W; Z, P Graphics GetGra() {</P>
4 V. Q& S$ j! g. Z4 P2 @- e8 ^8 h9 C<>  return this.getGraphics();
}
( q2 D6 C7 Y' ]1 {& l}
6 i6 ]- l  V0 K% Bpublic class Antcolony extends Applet  implements Runnable  {
5 |  V( {+ P, W. j boolean isStandalone = false;//系统的参数，是否独立运行，不用管
5 y( b3 m" K0 Q% X- z" ^/ v3 d Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
: i6 {2 w8 `6 z' b        boolean reset=false;//是否按下了重置按钮
* j9 q% D" O* j; K* ? static Color OBS_COLOR=Color.red;//障碍物的颜色
static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
2 ]& n' q/ c; s/ W static Color BACK_COLOR=Color.black;//背景色
' y" K5 M, \/ q; B, [, m& P static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
AntCanvas canvas=new AntCanvas();//画图用的画布
& U: _: {6 A$ @9 x int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
1 W7 b4 \) d3 {: i- k: V* n! J static int obsCount;//障碍物的数量，最大为width*height
6 ]' y* u) i. A6 u( } static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
  J. t: S; T! k+ |' n# l        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
) T. T4 ^0 O8 D5 }        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
: w3 z0 T$ T& c" {4 h# { static Point OriginPt[];//窝点信息
        static int OriginPts=1;//窝的个数，最大为100
static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
! G4 e2 e/ {! v- k2 P" W" A0 f- Q4 x        static int FoodR=10;//食物和窝产生梯度的信息素的半径
" E$ Y9 e$ W, y# P7 _& _; b1 N static ant ants[];//蚂蚁数组
& a  E( c8 O8 P        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
4 z# s/ E6 L; o9 v9 e<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
        Button btnReset=new Button("重来");
# }, p+ b* T+ `0 p2 H7 v$ g        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
! ~3 R& m. O6 Y' j& Z  l. T        Choice choPDraw=new Choice();
public void init() {
$ X% j) Q% |9 m; n2 |3 X                //初始化函数，先画各种控件
$ H" i: R' m/ }/ l9 u, h" y4 k: B  setLayout(new BorderLayout());
                Panel pan=new Panel();
5 d5 I1 y  O4 m7 B) A; ^" w                add("South",pan);
, a) c; W) ~" n) z& W: F! O6 `                this.add("Center",canvas);
+ C; s+ J% N. N! R! W( x( l                pan.add(btnStart);
1 v: w! I' b& i# {  r: U                pan.add(btnReset);
                pan.add(btnConfig);
$ r3 M; q- U6 @( C% S2 @                pan.add(btnMap);
* P+ e8 ?0 ]) b2 i                pan.add(choPDraw);
" }6 B0 {# f' p" L2 n                choPDraw.addItem("不画信息素");
+ R. z  |: z4 ?0 T2 w/ h5 @                choPDraw.addItem("画所有信息素");
: x8 ?" B: U3 W3 e. P, d' N& f                choPDraw.addItem("画食物信息素");
                choPDraw.addItem("画窝的信息素");
6 T& g6 W0 L$ A* }0 q                choPDraw.select(2);</P>
5 R9 M( H! I& Y: \$ x<>                //初始化各个数组
4 v$ Y/ Q8 h) O4 u& {. T0 P, x  obs_grid=new int [width][height];
) p  _% s7 D! b' L9 D% n  U                phe=new Vector();
                Pheromone_grid=new int [2][width][height];
1 e3 Q: y2 g0 \/ D7 k4 W5 Z! `/ i                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
$ E" p* W# M5 i! _& W& Q+ {3 n   }
+ `- g5 d( Z( v+ a  }</P>
( i" h, }1 W$ }- `<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
  ants=new ant[antCount];
+ B3 n/ q1 A" z5 s6 j9 k4 h; h        for(int i=0;i&lt;antCount;i++){
' g$ ^1 u+ z- }$ K+ a          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
% m$ G  x/ _$ F6 s9 I  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
" o. z; J7 M# X' g                int grid[][]=new int[width][height];</P>
2 a( f' b, c" N# `; k2 k<>                //下面从地图库中加在地图
* b  E3 G* P  \                Maps maps=new Maps();
                maps.LoadMap(grid,0);
% v5 {( O  [" H& W                //初始化地图
6 t+ y; Z" q' C                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
# ]3 j  H7 V4 _- W. C. S, w  reinit();
}
9 C# \' U0 b  T- r: F$ Z        public void reinit_map(int grid[][]){
, o* D' G: x1 K- d+ a# x                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
<>                //先停止程序的运行
                running=false;
& f( l* l4 d" Q2 a                btnStart.setLabel("开始");</P>
<>
                obsCount=0;
                EndPts=0;
                OriginPts=0;
/ k& `+ r+ V# R& V                obsP=new Point[width*height];
' b% Z  ~2 Q, R, `- y                OriginPt=new Point[100];
                EndPt=new Point[100];</P>
<>                //清空obs_grid和Pheromone两个数组中的值
2 [  `8 W5 k( d$ Z- i                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
  k  g# J( E9 N3 o& o$ u( L$ P8 \                                for(int k=0;k&lt;2;k++){
$ j  l; \, ^: Z, H( O$ b: W. L                                  Pheromone_grid[k][j]=0;
- `8 F( @9 F! h$ Z- f! K                                }
& U. I/ Q' k5 g5 R; \$ G) m   }
# r% j( p, \( [) z2 L2 o  }</P>
<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
, u2 e8 `  r7 q9 R' H: h# M                  for(int j=0;j&lt;height;j++){
1 Z1 f" S4 ^: f- b$ F                    switch (grid[j]){
# [% i4 ^/ D: H* E6 k; \                    case 1:
                      //如果grid[][]存的是障碍物
3 ?# \- R# f! W                      obs_grid[j]=obsCount;
                      obsP[obsCount]=new Point(i,j);
                      obsCount++;
6 s% L7 i/ s$ i, c; m; K" T# q                      break;
% X# c4 S3 P; r( N                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
                          OriginPt[OriginPts]=new Point(i,j);
- `5 A4 Q  L" |                          OriginPts++;
/ z' a# _' C. u0 R+ N9 P" H                      }
                      break;
                    case 3:
                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
' s6 K) E) l4 R                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
3 c- w* D' Z# S8 h& E: i                          EndPts++;
: }1 e% k9 O+ J; g$ m                      }
1 d5 k$ ~2 N0 }% Q$ n+ B  P                      break;
                    }
: y$ w' h  B$ l# z, O$ G; A                  }
7 A  [& }% Q1 z  U) G$ K                }
            //如果没有指定窝，则随机的选择一点
            if(OriginPts==0){
+ S6 y, K0 z* z1 g              for(int i=0;i&lt;width;i++){
                int  j;
                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
* l3 f  g8 @; @( i  i# n                    OriginPt[OriginPts]=new Point(i,j);
                    OriginPts++;
                    break;
                  }
) B( c" O3 m. x" f                }
+ F+ Q! j: J+ M4 ~9 w2 @- R, F! u, {                if(j&lt;height-1){
                  break;
                }
6 M/ _  d5 e) J  q: u              }
            }
        }
public void reinit(){
& P- @% F) a/ i; F                //重新初始化整个环境</P>
0 _  A, |6 g/ m% C1 |  D) {<>                //先停止程序的运行
* U2 {$ {( W2 \                running=false;
                btnStart.setLabel("开始");</P>
<>
+ ?0 o' u. |- A" |, ~  //清空所有信息素Pheromone数组中的值
, m- B9 X6 w# |; B7 [                for(int i=0;i&lt;width;i++){
9 |' m& D- u$ P2 k6 W* Y+ T* T7 x   for(int j=0;j&lt;height;j++){
                                for(int k=0;k&lt;2;k++){
) Q" A2 e/ [8 n4 y                                  Pheromone_grid[k][j]=0;
9 t4 |, u0 m$ b3 g" P6 O2 Q6 h8 ]                                }
   }
  }</P>
# f6 `6 u2 N/ O; }% r/ q% a<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
' v7 l* O- m- ?/ y          ants.OriginPt=new Point(OriginPt[index]);
                        ants.init();
  }</P>
( O& }& ~: e( `* f4 w" c/ F4 ]( B<>                //清空信息素向量
' d, y5 X0 u7 |; ~6 h                phe.removeAllElements();</P>
<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
  for(int i=0;i&lt;EndPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
; Z0 l  L3 v! p3 f) P' L$ Q                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        for(int yy=-y;yy&lt;=y;yy++){
                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
7 ]1 v' j) o3 }! Y1 T' y. d                        }
                    }
* }( o) \; Q; p. ^! K1 x# X                }
                for(int i=0;i&lt;OriginPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
) \# O3 g2 R% o: Y                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
5 g( N2 W( q. B4 P" Y                        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));
' S9 G0 r. G, e2 C9 `4 r                        }
                    }
                }</P>
<P>                //重画
' @1 ]2 P7 }$ e6 s  R  canvas.repaint();</P>
# t. z. z# O8 f- E- W<P>                //让程序开始运行
" F' ~; c/ r* \/ e+ @6 t+ d                //running=true;
7 C  u- Q6 D3 `/ u3 f9 r4 L" s }
+ s3 L0 z; D' y: H8 s! M public void paint(Graphics g) {
8 J, C; Z7 M( M! e$ ]6 m$ K+ @  canvas.repaint();
}</P>
. K7 L6 Z& R& E8 R5 j8 d<P>
4 ~+ T( N1 f% u. |3 w- S+ J) Gpublic static void main(String[] args) {
    Antcolony applet = new Antcolony();
0 E  ~3 s( x; I6 g    applet.isStandalone = true;
    Frame frame;
# S2 O+ b! x" |6 J& W: i    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
, r: Q' A% z+ @% R: _% S4 }) H        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
          System.exit(0);
        }
# d8 T1 M6 M5 d0 h      }
0 Y6 Y2 A4 {* q      public synchronized void setTitle(String title) {
        super.setTitle(title);
* R# O& t  N, a5 C        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
/ T6 ?1 D; f/ t  o' d% u; F  t) G    };
    frame.setTitle("Applet Frame");
2 C+ r% Z2 Q# H5 {/ i7 J    frame.add(applet, BorderLayout.CENTER);
6 U7 S6 I0 ]6 k3 z( \8 G, X    applet.init();
    applet.start();
# _6 \  J. X  }    frame.setSize(300,320);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
  L& f- l% {! X: p  K+ x    frame.setVisible(true);
3 x8 h6 K! I! {* F) H! o# e) g" N7 j  }
2 p: z) n# W! A3 R& z  public void start()
: B5 s7 P( |. G3 H  //下面三个函数是控制线程的
( M$ }3 H' [6 Y$ m {
1 T- k9 e! u5 G  if (runner == null)
6 @- O8 E" `1 f; G& n  {
0 e" u7 U2 d( T) v5 ^   runner= new Thread(this);
   runner.start();
   //running = true;
4 e# w+ ?# ^3 ~1 T+ e/ H  i  ]; {  }
}</P>
  n* p' t/ w# A  T<P> public void stop()
{
' {, Z& I( @$ y/ u# Z  r& Q# {  if (runner!=null)
  {
   runner.stop();
  d0 X) J+ m% {9 W7 k" {   runner=null;
- j0 \( X9 N" Y- P9 u   running = false;
2 K! l6 a7 T/ a3 P4 y( t  }
}</P>
<P> public void run() {</P>
9 I. C- }9 h. P3 M1 t/ s<P>  int i;
                //线程一直运行下去
2 }8 @, Z  `- H9 s- ]; x  while (true) {
          if(running){
       //如果开始动画，就进行canvas的处理
                          canvas.process();
                        }
3 Q# S/ l, z+ ?2 @$ p- w    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
   }
  }</P>
<P> }
6 s5 t3 _5 t/ ]8 a        public boolean action(Event evt, Object o) {
! c3 U! G/ c( A0 Y1 x/ w# C2 |( J- n      if (evt.target == btnMap) {
                //开始编辑地图面板
9 r: P- l$ z2 ]! m1 ?   running=false;
7 M0 ~$ U) Q0 G( J; v* M+ M" {                        btnStart.setLabel("开始");
# j( E9 L. z) V4 `8 {  L  _1 U" I: F   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
+ d. d3 C2 ]; R7 ^; S1 R                        ctl.show();
9 K$ [6 k; v8 y1 e( ]8 |                        return true;
  }else if(evt.target == btnStart){
5 _, ^5 F4 m" c+ @1 W+ J3 k% L' C                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
7 g+ e) l: t( `- N: h                    if(reset)reinit();
                    btnStart.setLabel("停止");
                    reset=false;
* t1 _. v; ~4 Q) i: n# u( D9 P/ c, f                    running=true;
9 w# }: B" D+ P. L4 c$ R4 f; @                  }else{
                    btnStart.setLabel("开始");
                    running=false;
. H0 p9 C/ k6 B, B                  }
                  return true;
7 H/ c, u* {1 U1 k6 T( Q3 T2 {                }else if(evt.target == btnReset){
                  running=false;
                  int j=0;
2 l0 X4 J0 e. W                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
& v2 R5 H4 g* ^4 m4 \! \                  reset=true;
                  repaint();
                  btnStart.setLabel("开始");
                  return true;
                }else if(evt.target == btnConfig){
' d3 P$ s5 h# o3 ]9 q( \, N+ X                        running=false;
                        btnStart.setLabel("开始");
     Configer ctl = new Configer(this);
- {( a  y7 `" v0 G6 b                 ctl.setSize(300,300);
                        ctl.show();
                        return true;
. S6 Q# i5 N8 d/ b3 u! T) r7 b! Z                }else if(evt.target == choPDraw){
                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
/ J. `& ^: Z6 X" B  [4 P  _. q9 K                  if(drawPhe!=1){canvas.repaint();}
                  return true;
" i! h1 A0 k. g" |" i/ Z                }
% @( z; s5 W  a% t, b' f5 k7 t                return false;</P>
: g. j3 d; j0 l. ]8 K6 u9 `; P<P>        }
3 g4 E' b7 p2 f7 y$ g7 L0 f( i /**Destroy the applet*/
0 h7 W8 d0 A; B& Q8 I  public void destroy() {
  //当结束程序的时候，把线程也结束
    if (runner!=null)
    {
$ m5 `2 {" F6 M3 O/ @1 k& c( Y       running = false;
2 P1 z, I* T) X2 w       runner.stop();
1 U+ }$ H6 L/ |: k# Z1 x( \       runner=null;
1 `0 D# v0 N- O3 z" D; e' q    }
  }</P>
8 O4 P% Q, N* Y" k. V<P>}
</P>

3 N/ Z  l4 B, R' F: a9 _

<P>package ant;
import java.awt.*;
0 t+ r6 w) v5 x0 _: timport java.applet.*;
import java.util.Vector;</P>
  F8 T: t( b5 S/ Z& k; G& Z; p<P>public class ant{
Point nowPt;//当前点坐标
; _& v  w9 \: g4 e5 p% Y( Q$ t, f+ X# e int VR;//速度，每次蚂蚁能走动的最大长度
  int id;//标识
, T- l& G: N1 R9 |5 M  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
6 B" L9 {+ f, G+ [ int height,width;//世界的尺寸
* Y* ?& \0 }+ Q2 _# f        int Phe;//每次释放信息素的数值
; v( U- f: L. q3 a Antcolony local_colony;//主程序的指针
( y8 _/ u8 D) m  z5 y        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
2 L: ~  H/ G2 Q- }- x2 b        double Main_direct;//主方向
        Point FoodPt;//记录的食物点，是否找到时候判断用
4 _9 u) o8 e" B8 I- o& o+ V        Point OriginPt;//窝的坐标
$ \1 v; A* z/ N4 L        Point AimPt;//目标点，是窝或者食物
, q2 Y2 U9 f# J( h* e4 D; d        Point StartPt;//起始点，是窝或者食物
% {" w% C/ z) ?; E; p( d; N        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
        int Pheromone_count;//当前还拥有的信息素的总量
0 W$ N8 U: `# r0 T7 `        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
: w# |! l8 V  t" W6 G. t) b2 A        int memory;//记忆走过点的数目
, f' S4 u- v. t  C6 l: x" u        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
0 J) c* z- r; X8 v  p3 g2 o        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
3 W/ m* i6 p, p; @ 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);
+ k1 W# [9 x( F% z- G4 U2 G. F3 G) p                FoodPt=new Point(nowpt.x,nowpt.y);
                StartPt=new Point(nowpt);
                AimPt=new Point(nowpt);
! D8 @& ~. q. w& i/ ^8 T                lastPt=nowPt;
  VR=vr;
7 \6 I$ J4 w  Z! B  Y" Z9 _  id=idd;
( ~. y' g  |9 d4 f! R  color=c;
9 _1 q3 C2 G7 u8 @1 N  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
6 l- C8 L6 b1 n: I) c5 s: G& S  width=Antcolony.width;
$ q( N/ S  v1 B; [  I) I  local_colony=colony;
                Phe=200;
                mistake=mist;
                HistoryPoint=new Vector();
+ p3 }2 x, Q* W) D, p                Main_direct=-1;
: A5 F, i  K9 F5 l# e- P+ s0 R) Q                FoundTimes=0;
                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
1 h7 j9 S% w  \: f8 z# v. d8 u- l                memory=mem;
                Count_distance=0;
                Min_distance=-1;
}
        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
5 d4 f) D# X' W' p0 U' v" C6 r% C          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
' ^% e# E+ q0 W0 s4 ?          Main_direct=-1;
          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
! c& o! v: t$ h# y2 w          Count_distance=0;
          Min_distance=-1;
) h9 O& {" j* T( {0 r! v/ ~! Z        }
public void Draw(Graphics g) {
          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
  g.setColor(back_color);
  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
9 }" o8 ^+ V* ~7 c3 h% p0 d  g.setColor(color);
  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
% W  g8 ]) @1 P5 ~ }
1 P0 a( M7 Q  q2 x public void Process(){
7 Y. G# Y2 ]' ^2 o4 z        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
# G, e& o- o7 R  x8 Q        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
9 D2 ^" k- U0 ^6 f        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>
+ G2 T. ]9 d0 q
# U4 O& t/ X' O5 C  x2 Z<P>        if(Judged==false){
          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
4 R* `8 }" g' \5 `( q" @              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
2 J/ z9 y0 z1 @8 `- N              return;
          }
  j4 I. ]% s5 C  T. r& K  Z        }
4 [0 }! O+ _/ |0 @) j( q        Judged=false;
4 K: O8 Y% |# @* A4 w        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
" _  S" c+ R6 o2 f3 L        int deltx=0,delty=0;
# \0 U0 M% D) h' f2 b2 s7 p        //direct是方向角，根据方向计算位移
  m1 m* K3 {: W; i        deltx=(int)(VR*Math.cos(direct));
        delty=(int)(VR*Math.sin(direct));</P>
<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
6 l/ {0 W. G) G7 i8 ~# B        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
4 J8 u6 ?* O/ m2 z  j" {6 _        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
8 h! e; b. H5 e          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
" l( b& Z1 j; n7 I% X/ s) n% N- b<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
          for(int x=-VR;x&lt;=VR;x++){
  g% e. R4 O) I+ n! Z4 v* I! J             for(int y=-VR;y&lt;=VR;y++){
4 J& o2 d2 b+ z; ^                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
( ?5 X, H+ b. r# x6 Z! |2 ]                int yy=(nowPt.y+y+height)%height;</P>
$ d+ |1 w9 }5 |' O- o<P>                //循环的时候要除去当前点。
3 g" Z7 u3 _. w+ v7 m                if(x!=0||y!=0){
                  //的到要搜寻的点的信息素
! U( k; P0 n: Z# s                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
9 N- B2 m; u) Q! r! ^<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
$ M; c2 E! G+ F0 c' W<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
+ b+ S( y( i2 n( X                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
+ n4 b+ ^% Z8 d: P* t- L+ y3 _                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
4 ?% c8 D& i$ @! u: M                          boolean found=false;
2 p# y1 G+ D0 K$ a( D; c1 H                          //查一下内存最近走过的memory的点数，从而避免当地转圈
  }2 z$ ~  Z7 F7 U7 Q                          int size=HistoryPoint.size();
5 X6 g9 W, U4 q' r* z# p                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
2 X7 D3 a; g/ \; g& ]. o, K5 o) |                          for(int i=size-1;i&gt;=size-minsize;i--){
  G# |2 Q  s5 A$ k0 E                             Point pt=(Point)(HistoryPoint.elementAt(i));
                             if(pt.x==xx&amp;&amp;pt.y==yy){
5 L0 b  c2 j) @$ k; L                                found=true;
                                break;
                             }
, N# T/ \  x5 e( d4 E$ |  z                          }
" j2 P$ Y7 B4 [8 {0 A                          if(!found){
' n. d* m, B) p" m                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
- x: R: V4 A# F! a3 ]. z' w4 p8 X( |6 I                            delty=y;
% o  G3 @7 A& n5 o/ D/ @9 t                          }
# M  S( R& l* I4 t) o                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
0 z! n3 J" z9 y                }//end if x!=0
            }//end for y
6 |- M2 K! z# j8 N        }//end for x
        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
        pt=Evade_obs(deltx,delty);</P>
<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
7 o( [5 N7 L# i  i1 W& `        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
, U/ s4 q, W6 D& O, M0 M+ m          pt=Evade_obs(deltx1,delty1);
2 c3 t7 J0 A* h/ ~; J        }</P>
<P>        //播撒信息素
5 S: N0 A5 w4 ], f        Scatter();</P>
<P>        //记录走过的距离
& l9 m' X* E, ?" K+ n9 |4 u        Count_distance+=Distance(lastPt,nowPt);</P>
<P>        //改变当前点位置
        lastPt=new Point(nowPt.x,nowPt.y);</P>
<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
3 S+ O9 k0 k' z% e        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
        if(HistoryPoint.size()&gt;memory){
' w; N0 C2 }6 l9 S: M          HistoryPoint.removeElementAt(0);
/ j- b4 Q3 }+ x' u( ^        }
, D; ~6 L; z( @( U        nowPt=new Point(pt.x,pt.y);
# \% a. K, I! V5 x' g* Y* c0 ~% Q     }</P>
' ~+ b% _2 g, H7 G4 j<P>
        private void Scatter(){
/ Z( P# P  L( N9 R7 K: x        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
+ y7 }+ f! D4 E0 ?8 |9 o            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
* m" t% X! s* Y            int kind=FoundTimes%2;</P>
& @7 w) n& Y5 Y, k( Z2 y<P>            //获得当前点环境已有信息素的值
2 P, k, D+ P# d$ A& A: v/ ^            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
8 k" Y3 o# y, B            boolean ofound=false;
            if(Phec!=0){
                //如果当前点已经有信息素了
                for(int i=0;i&lt;local_colony.phe.size();i++){
( ]6 L) }+ k4 S                    //在信息素向量中查找该点的信息
* y2 i8 Q7 G( y8 w5 q                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
- u( O' M$ I; q' f% e! Z                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
                        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));
( Z- H* a4 v+ ^0 ^                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
                                //如果当前点重复了以前走过的路，就不释放
                                found=true;
                                break;
3 _' D/ O8 X  h' N0 y  Z                              }
+ b% V/ |% r& _. ^% Z% \5 l                            }
                        }
( F% g2 i( c- b8 i( S9 b5 R5 n                        if(!found){
  `6 L' v+ p) H6 t& h5 L3 Q3 s                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
<P>                             //让还剩下的信息素总量减少
                             Pheromone_count-=Phe;
                        }
) \4 E% s( E) y0 Q" C, E6 x0 a                        break;
; ]! N( F! A# a8 q4 I                    }
# w5 n$ A/ |  V& d" F- h                }
/ K, ^) v" m3 u; d+ x' R# B: G" v8 c              }
2 |1 U5 b7 a4 ]- h% ]          if(Phec==0||!ofound){
            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
, q; |+ R6 j  b% c* _8 Z& @) J                ph.Add(Phe);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
                local_colony.phe.addElement(ph);
% h  `' ^! c0 q1 ~# e                //让还剩下的信息素总量减少
                 Pheromone_count-=Phe;
) O! N3 ~& X. L# u6 n0 U: e           }</P>
! s( c# Z  t5 N2 p6 S  Q<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
( M5 t! A8 E0 q7 B4 ?           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
; B/ C, h8 w! `0 w4 [; |           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
, E1 }$ m/ L+ m/ k3 s           Phe=(int)(0.005*Pheromone_count);</P>
) V- V* {! a# H' L<P>           //如果剩余信息素已经太小了，则按照等差数列递减
* ~- w  m! J0 |           if(Phe&lt;=10)Phe=10;
        }
' `5 Y& Q; ~, f0 Q) r8 R0 }; x- fprivate boolean JudgeEnd(){
6 B4 C. [& [/ f5 R' I- I' k    //这个函数判断是否已经找到了目标点
    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
2 Q9 t# `7 }  Z& T. h( D7 ^2 c: [    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
        int i;
3 i# D; ?- v  o" A8 S0 P        for(i=0;i&lt;local_colony.EndPts;i++){
9 D7 c3 _4 z8 w/ |            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
              //如果找到了食物，就直接移动到食物点
4 X# {0 S( ?, Q1 i  A              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
/ ]" v0 F  q3 V9 t0 g& [) v2 r1 T# A<P>              //计算最后的总距离
! c$ y+ p# f8 j; g9 @4 X/ k6 P3 t  @              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
( I- V2 k" T' t, v              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
% j+ Y6 t) H9 f              }
* |( I. J8 y3 S( S: q              //清除总距离记录
% {; m% O. D' b! X# t* }  f/ d( r              Count_distance=0;</P>
# o; {5 m0 c  c7 n5 J+ k6 d6 y<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
( `* {& o3 V+ Q7 ]  K; f3 Z' P. g! k              AimPt=new Point(OriginPt);
" g4 t  S0 t; f( n              StartPt=new Point(nowPt);
              //并把当前点标为自己找到的食物点
" f/ k: V. r. u/ L  f              FoodPt=new Point(nowPt.x,nowPt.y);</P>
8 d4 Y2 m' C$ |4 y: x4 v1 j: a( f<P>              //找到了食物就把找到次数+1
+ W( Q8 a. y: S              FoundTimes++;</P>
( O9 K& [0 ~& R. {6 G! A<P>              //改变主方向为原来方向的镜面反方向
% K/ y$ Q6 Y: e8 ?" F7 R1 E# z              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
3 g2 e% j" O2 ^8 J1 z<P>              //重新把自己能撒的信息素置为最大值
8 b, S, S- {" Z+ L) ?5 T              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
  j/ g# s0 Z" a: S2 b              HistoryPoint.removeAllElements();</P>
$ [8 W' p& y: M$ z. ^4 R) ?<P>              //返回找到为真
; a5 Y/ W6 F: u2 C6 R" |              return true;
            }
; O( a9 }8 Y  k% x' O        }
      //否则没找到
      return false;
    }
    if(kind==1){
        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
. N( W/ b2 P$ t& V9 o        if(Distance(nowPt,AimPt)&lt;=VR){
6 a" [2 M8 V4 r. M            lastPt=new Point(nowPt.x,nowPt.y);
, Q1 n- T. K, F7 a2 o0 _4 P            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
              }
6 \# e' V" Y8 Y: l2 a              //清除总距离记录
+ F- [! \7 w) U, x              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
8 J8 K; X' T1 O1 D7 F; G! r            StartPt=new Point(OriginPt);</P>
<P>            //重新置信息素
  O3 Q& Z. K+ J5 X( N) ~            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
  I  [& ^* Q3 H  N+ _  F            HistoryPoint.removeAllElements();</P>
<P>            //主方向反向
            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
# m2 j6 G1 m- e9 a4 U            FoundTimes++;
" M  ^) t1 A9 H& \' ]& W" Y' T6 U            return true;
0 L3 s9 [) @6 o8 J. r        }
# {* j6 r* K0 l3 Z) {        return false;
2 M" g# ^2 d6 T9 k    }
    return false;
}
        private double SelectDirect(){
% c' @5 u0 L/ f5 h                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
  }3 b' ], w9 m3 I$ H, k                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
2 Z  K. B* x' _+ q6 ~        e=2*Math.PI*Math.random();
                      Main_direct=e;
                }
5 ^# z  ]8 O5 K4 [7 G$ k                //选择主方向角
                direct=Main_direct;</P>
2 k7 l3 ?3 Z' j* \, x<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
                double re1=Math.random();
" }3 T9 U, _  R* Q" Y  P                direct+=Math.PI*(re*re-re1*re1)/2;
- d, L9 g4 Z! N/ p7 [+ }" l, G                if(re&lt;0.02){
( s- n' y9 |; {6 i! O                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
! a3 J+ z: H- K                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
5 m( j8 a1 [3 S2 k& a3 ?1 C' w6 I                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
* l# m, Y/ G2 p  \                       Main_direct=GetDirection(pt,nowPt);
- ?* g, S/ z. R, }' q                    }
2 K3 `: a5 \+ \. \# N) K4 h                  }
                }
               return direct;</P>
% }( D- v( n% P  q- J. u4 \8 D/ A<P>        }
        private Point Evade_obs(int deltx,int delty){
              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
2 O. e# a/ n4 L) }! r' O) p$ j7 ^! O              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
4 y$ k/ E# J! b1 `* R9 i7 q/ k              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
2 i$ q& C) W1 Y. J, @              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
              Point pt=new Point(0,0);
9 g. p( Q. O; K8 R              int x,y;
              int delt=deltx;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
              if(delt==0)return nowPt;
              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
                  x=(int)(deltx*t+nowPt.x);
  ]$ `! v, w; g8 M3 t* n                  y=(int)(delty*t+nowPt.y);
% t* v4 J$ m- [. f- u3 G* Z1 i9 h                  x=(x+width)%width;
                  y=(y+height)%height;
& o: c  K# v* a5 @& p' s9 f                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
$ C" b; m7 s: x+ m<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
, ]" ~: s- t1 i9 O! C. w' i                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
& U5 [# ?9 D4 o; k- l9 V7 _                     double disturb=4*Math.PI*(Math.random()-0.5);
" ~0 Z& V1 {5 T) {( M                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
                     break;
                  }
( Z4 d+ o. [8 V1 X  j+ o! R                  pt=new Point(x,y);
+ ]" f5 g9 `0 g# l7 M, p9 |5 c                }</P>
$ X4 a8 H* r; i6 G: L5 Z& a<P>                //计算得出实际能够到达的目标点
1 K0 ~8 c+ J8 b  N. n8 e1 m  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
         return new Point(x,y);
$ w4 I; L/ S, d        }
        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
7 O/ V& _( y+ h% z9 J) G1 z  _: f        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
9 x5 J, c# H5 y& D5 E* x5 l        //其中方向角是所有可能的角中使得两点连线距离最短的角。
( Z! M) Z2 q/ Q, O3 R' B               double e;
               int deltx1=pt2.x-pt1.x;
               int deltx2;
6 j' e' E4 p4 o% i$ t               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
% p. r6 u) Q; A" p6 c6 ]& E7 I6 X. T               else deltx2=pt2.x+width-pt1.x;
               int delty1=pt2.y-pt1.y;
; h( M* W" ?9 H/ C! e4 Z" W               int delty2;
3 x2 r* @( ]7 o               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
               else delty2=pt2.y+height-pt1.y;
4 e" P* T, J5 n. u( Q5 q, _               int deltx=deltx1,delty=delty1;
               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
8 j. m  c; d5 T- l4 y! v! v    deltx=deltx2;
               }
        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
               }
: L3 j3 M' ~2 P: Z7 r               if(deltx!=0){
                    e=Math.atan((double)(delty)/(double)(deltx));
                    if(deltx&lt;0){
% a2 g7 i$ P( v/ G5 @# i' N  T4 I' W/ J8 l                       if(e&lt;0) e=e-Math.PI;
                       else e=e+Math.PI;
                    }
& b2 u0 a, r! o! X1 t                }else{
5 }! X& ^5 g! F5 y1 `  N) D                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
                }
                e=(e+Math.PI*2)%(2*Math.PI);
- d. a4 h" S( @4 O* _% Q' ^                return e;
, ?0 n1 c% l+ `- P, m7 w# b) E        }
        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
. t( A' Z" l4 k% _  [! W* A7 m        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
            int dx2;
1 W) g0 \4 b5 k6 j) s. G* ^) w$ X            int dx,dy;
            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
6 B  ]9 L, }. B; {: g- d$ A            else dx2=pt2.x+width-pt1.x;
            int dy1=pt1.y-pt2.y;
            int dy2;
' q) p2 G7 b3 C7 Q. N+ e6 @            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
            dy2=pt2.y+height-pt1.y;
) P$ e: ^9 r7 J! A/ k: [            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
            else dx=dx2;
# W: G/ @8 z3 A: f! Q            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
            else dy=dy2;
5 J' `9 r1 r0 \0 P            return Math.sqrt(dx*dx+dy*dy);
        }
- z% o- F  Z  Z2 b1 G5 K  ^( I0 u    public void clone(ant ant1){
7 V" i) z* P7 s        //把蚂蚁ant1的属性拷贝到本蚂蚁
     nowPt=new Point(ant1.nowPt);
) w% F/ e. f3 b5 Y4 w        OriginPt=new Point(ant1.OriginPt);
; S0 _) Y5 |; P9 r        FoodPt=new Point(ant1.FoodPt);
' b1 |# v% A3 ?+ O% h* B% w: F: @        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
  _1 O# A! i# m7 t* X! B) \) c        lastPt=new Point(ant1.lastPt);
) p  T: z4 _  o+ _2 \$ Y& e+ t        VR=ant1.VR;
9 x) R* B( Y8 x% a        id=ant1.id;
        color=ant1.color;
        back_color=ant1.back_color;
        height=ant1.height;
        width=ant1.width;
" |. M2 C7 v- a, v( g        local_colony=ant1.local_colony;
! s; S& j, t8 X5 Y        Phe=ant1.Phe;
" j9 [5 q& s! t. G3 e        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
. B  j. P* R. [+ {4 x        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
        Max_Pheromone=ant1.Max_Pheromone;
* z. d2 ]8 u' K: z4 q) A: p' X        Pheromone_count=ant1.Pheromone_count;
        memory=ant1.memory;
        Count_distance=ant1.Count_distance;
3 h- q5 J5 N& O0 f, `* T        Min_distance=ant1.Min_distance;
    }
7 d! ~9 I# S  W6 T9 B}</P>