[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
8 r1 T- p8 m; b2 ?$ S. E+ |<>package ant;
/*
* @(#)Antcolony.java 1.0 03/05/22
! T# F* @& D  W5 E( \- \ *
# J& M- ~. G8 [2 R- k( X * You can modify the template of this file in the
* directory ..\JCreator\Templates\Template_2\Project_Name.java
7 }6 ~& r, u) L- i! I- p& | *
/ E+ P" i' ?, s- u1 }6 l+ A: q * You can also create your own project template by making a new
. N3 X5 y; s9 G' b( _ * folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
*
- k2 O; r5 y) x" q */</P>
<>import java.awt.*;
  H5 o: N% g; l; t4 x. gimport java.applet.*;
import java.awt.event.*;
import java.util.Vector;</P>
<>class AntCanvas extends Canvas
* C) i3 F% ]1 K. ^{
! ^1 g- D" I3 e, l6 j) D* L    //画布，一切画图操作均由该类完成
//Image image;
+ p/ w$ {6 g5 a Color obs_color;//障碍物颜色
1 E$ W! _. U. }  c Color origin_color;//我的颜色
% c: N: o5 }4 v, { Color back_color;//背景色
        Color end_color;//食物点的颜色
$ k/ s& ^; o( D& V7 g% q //boolean first;
( e+ ^, R, }7 P, \  h0 V boolean reset;</P>
<>/* public AntCanvas(Image img) {</P>
- N! v2 g; x( I! Z3 Z0 V% Q) r0 b<>  super();
   image = img;
  obs_color = Color.white;
  setBackground(Color.black);
$ @& i- I/ A6 I4 o  setForeground(Color.white);
5 O4 v+ I+ W9 c% [$ q  first = true;
  reset = false;</P>
<> }*/</P>
<> public AntCanvas() {</P>
3 a+ d  q- d4 b4 L& c( ?$ l<>  super();
4 G3 g0 B& E7 ?2 T& n; X$ \2 c9 j   //image = null;
   back_color=Antcolony.BACK_COLOR;
3 a+ K7 j. {! ?; t" r/ [' u; q  setBackground(back_color);
  setForeground(Color.white);
5 m$ a2 |' }' _& n7 W6 e. h# }  obs_color = Antcolony.OBS_COLOR;
. q1 y* A# A* P; M/ x9 z  origin_color=Antcolony.ORIGIN_COLOR;
' i! f8 D* [% ?, x                end_color=Antcolony.End_COLOR;
  //first = true;
+ b) A" h5 V9 F4 z# y  reset = true;</P>
<> }</P>
<> public void Clear() {
        //清空画布
2 e) G. {. D- `: ^  reset = true;
7 C: w0 M4 T8 n$ O  Z! E$ W  R' `4 c  repaint();
}</P>
5 S" l8 e  Y' R8 e7 a0 T<>
: b8 Q) L; R  |# o% |$ a  o public void paint(Graphics g) {
1 h. l$ ]2 B+ H" U9 {: O  int i;
                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
1 _! s! |* K2 I" I  g.setColor(obs_color);
) u6 f  y" Q3 t8 s0 o7 Q4 _6 D  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
<> }
. m" @3 ^' [8 I public void process(){
        //处理动画的过程
  Graphics g=this.getGraphics();
& _; V& R$ @& ?. k& y1 v+ e                g.setColor(end_color);
2 R. c% P9 t! U3 j3 q7 |   for(int j=0;j&lt;Antcolony.EndPts;j++){
                  //画所有的食物点
                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
% G- }4 p7 [7 u6 @  a/ h( H1 {                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
% h% Y* }! o/ |1 V' t                  //每只蚂蚁开始决策，并画蚂蚁
   Antcolony.ants.Process();
# g* B* W( A9 p3 ?, L5 a   Antcolony.ants.Draw(g);
  }
$ u  _2 V! z! f9 y7 V                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
' `7 `  K+ s4 F                        //Antcolony的drawPhe变量标志是否画信息素
7 K) }9 i! f- T7 h# g                        switch(Antcolony.drawPhe){
                        case (1):
                            v.Draw(g);
                            break;
! T" S0 w- z6 y+ U. [                        case (2):
1 C" C2 ~! H" p* [0 z                            if(v.kind==1)v.Draw(g);
                            break;
8 t" x( y2 i  Z8 m                        case (3):
                            if(v.kind==0)v.Draw(g);
* G0 f% ?* u* ~/ Y9 g                            break;
1 x1 i# V7 `9 x4 G# @                        }
                        v.delimit(g);
5 @. e$ ]) H) _# l9 K+ [8 X3 z                }
           g.setColor(origin_color);
5 K- q/ f  x" }5 V5 `                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
7 ]% Y% [8 j* f. g1 K                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
                }</P>
<> }
, w% \) }  K, B# f$ h Graphics GetGra() {</P>
- _0 x  [' Z. L( m<>  return this.getGraphics();
7 V% z" h5 ^, A/ i/ i8 Z; u3 } }
; ?1 J4 ~! Q" M& A- L) h}
public class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
% q3 i! o0 x- a) Y6 T) m: L! u boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
3 K, i2 Z  O7 @6 g  C static Color OBS_COLOR=Color.red;//障碍物的颜色
6 b3 a( c, x/ A, n static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
- o4 @* ?0 |- L8 ?: h static Color ANT_COLOR=Color.white;//蚂蚁的颜色
& ^- r# z( ?4 A( r5 N8 N        static Color End_COLOR=Color.cyan;//食物点的颜色
  f+ w0 i" l- }+ G AntCanvas canvas=new AntCanvas();//画图用的画布
$ {2 k! L! u* i" M) x int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
, w* j( K4 t' }4 z6 l* j# ?4 e- k static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
" V/ G) ?4 W  {" n2 w' k! W        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
1 u" P% f. `) Z; V        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
2 [( h- P1 T2 |$ E1 z static Point OriginPt[];//窝点信息
        static int OriginPts=1;//窝的个数，最大为100
5 P# z: W9 o5 E5 B; Y static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
$ w. L0 T$ r/ o/ i) n        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
: i. @1 P$ _6 C6 z2 Q( @) t$ k9 R        static int FoodR=10;//食物和窝产生梯度的信息素的半径
, S4 c* Q8 P/ c4 H# A( J8 ^, X1 k static ant ants[];//蚂蚁数组
5 A. P+ v' S" L2 _9 ?        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
  D- [* u* [; f0 w$ f5 c int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
9 n% {, s8 J& F        Button btnReset=new Button("重来");
        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
2 m4 f2 w" H& t2 r) s1 @ public void init() {
* ]& e' U5 t" J  K* V/ ?3 ~                //初始化函数，先画各种控件
: Z% E' r) H- [, ~0 t! N0 C  setLayout(new BorderLayout());
7 l+ R# U, m$ p" z2 o3 [  m  ?: a                Panel pan=new Panel();
                add("South",pan);
                this.add("Center",canvas);
' m5 K/ V( T. h# }8 b) K! v4 Z0 {                pan.add(btnStart);
                pan.add(btnReset);
                pan.add(btnConfig);
( c" K$ Y/ C- ~2 w, k6 t  _                pan.add(btnMap);
                pan.add(choPDraw);
* S6 X3 G; ^: |4 p                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
                choPDraw.addItem("画窝的信息素");
$ P. t1 x1 h6 w# ^                choPDraw.select(2);</P>
<>                //初始化各个数组
  obs_grid=new int [width][height];
                phe=new Vector();
                Pheromone_grid=new int [2][width][height];
0 @9 q. p4 [( K* M, w                for(int i=0;i&lt;width;i++){
  I- R% h9 w- M, o   for(int j=0;j&lt;height;j++){
+ p$ t7 ~) W* X. m; s    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
! E% N& b2 K. z                                  Pheromone_grid[k][j]=0;
                                }
   }
: Z- c. s$ N6 ?  }</P>
) A, z) d/ y3 c  U. k<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
  ants=new ant[antCount];
# b- ]3 I. E4 Y3 S/ R6 b" N        for(int i=0;i&lt;antCount;i++){
          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
  }</P>
) `* L+ G4 Z% b2 l- t$ ~<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
+ G5 b( x, z9 j: J                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
, a4 Z' K, s7 r; @9 F: T& C0 Y9 i                Maps maps=new Maps();
                maps.LoadMap(grid,0);
0 H4 }) i6 z2 e+ ^/ e                //初始化地图
9 ~7 _( U  ~" M# M, ^# @! d                reinit_map(grid);</P>
8 {2 Z) ^2 }% {<>                //初始化所有的蚂蚁
  r1 Y. {. Z7 Q7 D6 e+ \. o  reinit();
6 ~1 P* ]* ]) T6 n9 ~ }
        public void reinit_map(int grid[][]){
                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
2 z3 x+ j, q' u) S( ]* B& d                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
8 j7 e2 {* L" e) L<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
2 z. d6 E9 R" G! l) d5 H) j<>
                obsCount=0;
1 s! M5 _" ~- L/ }! s                EndPts=0;
+ J% l  f6 o0 J9 Y, V                OriginPts=0;
: |* q7 ^( _9 r* I0 Y( ^' R5 O                obsP=new Point[width*height];
5 ?  H' z: }; D$ S4 i                OriginPt=new Point[100];
+ h6 e. Z+ l; ?' a                EndPt=new Point[100];</P>
0 Q, d( a  \$ e" g) e<>                //清空obs_grid和Pheromone两个数组中的值
+ ^& z8 s, B  q* V                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
5 \) o$ K: b; V0 M0 ^4 B    obs_grid[j]=-1;
# Y" P' j; o% L, Y0 F. s                                for(int k=0;k&lt;2;k++){
& U1 N! {2 {" ~, I                                  Pheromone_grid[k][j]=0;
                                }
' q9 G. R$ a! [# F0 u   }
  }</P>
<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
3 N& n- T* V: {5 v                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
, `: b9 t" ~5 z: M' f) L( d                    case 1:
                      //如果grid[][]存的是障碍物
' c$ D# G& R) d) t) F                      obs_grid[j]=obsCount;
                      obsP[obsCount]=new Point(i,j);
# a1 J# g5 E& b9 B; J                      obsCount++;
5 e1 ^8 m! f4 W, f$ Y  k8 F                      break;
                    case 2:
: d1 }  B% a: C+ P% j8 `                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
+ w$ k4 d' t; @6 J: }3 \                      if(OriginPts&lt;100){
9 z, D4 E/ V- I6 {! C) M% U                          OriginPt[OriginPts]=new Point(i,j);
& Z/ |% _3 N& x7 a                          OriginPts++;
                      }
                      break;
                    case 3:
# }7 Z/ S( G7 x( A1 ~                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
                      if(EndPts&lt;100){
) Q* S9 l+ K' f  D( l                          EndPt[EndPts]=new Point(i,j);
: L) z$ q. }$ U6 O0 V                          EndPts++;
: S# N- D5 N* u  I" F                      }
, n7 Y+ A) A* E" }! Y                      break;
                    }
1 h2 M4 i& K+ b+ k' a2 j; l! [. N                  }
: P3 |8 t( ~& L6 E' m# S1 j                }
3 a' _  [# a' A9 c2 z' L            //如果没有指定窝，则随机的选择一点
, l4 B) o+ k1 u! r            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
                int  j;
. z& G& r( Z8 g& }$ Y                for(j=0;j&lt;height;j++){
. D& z( R" t- h                  if(obs_grid[j]&lt;0){
9 ]7 E4 |% l9 r" T# v# ^2 c" u                    OriginPt[OriginPts]=new Point(i,j);
                    OriginPts++;
: W' I, }, ^- X  g3 y, E                    break;
                  }
" D% T- B' f+ i                }
                if(j&lt;height-1){
                  break;
& S8 A4 J$ {  m' X2 s2 r                }
+ r& b7 j/ C! ^* p. a8 _8 o              }
            }
3 j! X) J3 D) |$ P! J/ V1 T+ L        }
6 n7 K/ \' S( J6 v6 r7 ~% A5 k public void reinit(){
& U  [( q: q1 B- A; Q                //重新初始化整个环境</P>
4 e% _! e) n$ x. R" _: ]+ l<>                //先停止程序的运行
1 f! ^2 G$ C1 W% i/ ~/ ^! Q                running=false;
) ?) w3 J# i% F                btnStart.setLabel("开始");</P>
<>
  //清空所有信息素Pheromone数组中的值
                for(int i=0;i&lt;width;i++){
4 V: p# ?6 N! r! H   for(int j=0;j&lt;height;j++){
5 a( E1 t7 `* h0 K9 `                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
   }
  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
( A8 ~2 _6 z1 `. x6 ~                        int index=(int)(OriginPts*Math.random());
9 F8 m$ B2 i% j9 |8 I+ F          ants.OriginPt=new Point(OriginPt[index]);
" j! [6 i- w6 |& _) t9 n                        ants.init();
  }</P>
9 r# j9 {6 d! D<>                //清空信息素向量
- ~) v& _7 e' _                phe.removeAllElements();</P>
<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
  for(int i=0;i&lt;EndPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
# D9 W' f  H1 k1 @  Y# C                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
2 a' X8 i7 W) f# v6 f                        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));
                        }
, V- p9 p* Q3 g2 n$ v! [                    }
                }
  q1 H5 D/ d" o* a- _                for(int i=0;i&lt;OriginPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
8 r3 ~5 X0 J8 c8 t# g+ a" o                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        for(int yy=-y;yy&lt;=y;yy++){
                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
7 ]. z- G9 G; I2 ]                    }
                }</P>
<P>                //重画
  canvas.repaint();</P>
<P>                //让程序开始运行
                //running=true;
}
0 R1 l' P% b( ?2 q; D public void paint(Graphics g) {
  canvas.repaint();
' z) b% ~8 D, {8 p0 @6 I }</P>
<P>
8 Y0 d( Z# y2 s5 Q7 N* hpublic static void main(String[] args) {
    Antcolony applet = new Antcolony();
- k- X0 o! r! H, V    applet.isStandalone = true;
+ M2 R- U1 j; z1 k1 a6 a9 i' [. I% n    Frame frame;
$ `3 T5 a' N; Q) h: Z/ A    frame = new Frame() {
2 d" ]7 ^0 L( S: S6 E8 S      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
% P( {$ V7 p) A& J  A: B  u        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
/ L4 Y7 Z" w+ {4 V9 \+ j          System.exit(0);
! u- \2 d! w$ f! v4 W( e- w, [        }
* o3 R, e) u/ S) R, x; P2 G0 Z& ~; |      }
      public synchronized void setTitle(String title) {
        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
- u  w$ Y( [% X/ }% l0 }# i2 l2 }$ C    };
    frame.setTitle("Applet Frame");
    frame.add(applet, BorderLayout.CENTER);
    applet.init();
    applet.start();
3 ]! R0 W. v# @! I3 C: y9 z    frame.setSize(300,320);
8 t; J) L# T6 }4 P( R    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
+ L; N* f' P: r1 M5 y, M6 K, P4 S  n    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
; a1 Z2 f, P8 B7 u1 y7 g/ [- `    frame.setVisible(true);
% V, w6 K5 s# Z5 |" q% z( J  }
  public void start()
  //下面三个函数是控制线程的
{
3 t% ]3 w( J2 E& v+ e6 {& O  v  if (runner == null)
7 P, ~% E2 p/ z. D/ {  ]  {
5 p0 \+ _' B5 J3 ^( p6 z   runner= new Thread(this);
   runner.start();
9 s  c* ^! Z# \   //running = true;
5 T8 }: S, b$ C' k  }
9 h8 P, y7 D  ^/ e- K! B) [ }</P>
) f. }# C+ ^0 u$ d<P> public void stop()
; }  N! `9 H$ [" \9 W/ f {
  if (runner!=null)
8 l& l6 |( u* T  c+ `  {
   runner.stop();
2 Z- V8 R/ U0 x   runner=null;
   running = false;
8 x$ W- f4 I, ~9 O4 w  }
$ e3 N, \( i  ^9 B# w }</P>
, I' e/ Y4 K/ `* P7 [) e3 [4 T& _; V* T7 c<P> public void run() {</P>
& j; ^) n/ ~1 W0 x, V* \<P>  int i;
                //线程一直运行下去
8 z. b4 e8 `- T- I4 r% ]  while (true) {
/ c! y. Y& N2 V/ O9 _8 `          if(running){
       //如果开始动画，就进行canvas的处理
                          canvas.process();
                        }
    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
   }
! P4 B- j7 H9 _! U! V9 x  }</P>
4 O) d/ n( t  I2 `* V  K<P> }
        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
                //开始编辑地图面板
1 y, s2 Q$ U3 u: C5 {' ]   running=false;
                        btnStart.setLabel("开始");
   MapPad ctl = new MapPad(this);
; l* z, y6 e. n- y- o% x                 ctl.setSize(308,380);
' ^& \7 }; X  x                        ctl.show();
% D; j4 b( w: c# n9 Y- z5 P; ^3 \                        return true;
( v* ^, P4 F2 J8 X( r+ c$ @  }else if(evt.target == btnStart){
$ }5 O! d' q3 c0 e! I; D) \                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
6 C4 @6 d; B0 f1 S                    btnStart.setLabel("停止");
                    reset=false;
2 Q, K/ S) k5 ^8 F$ Q# R  s                    running=true;
                  }else{
- y# R) Y+ t' D4 n$ V                    btnStart.setLabel("开始");
% P0 G2 S" P! C0 B                    running=false;
# c: `. x/ n3 i6 o                  }
                  return true;
2 I; w& Y# z0 B! J1 E8 x                }else if(evt.target == btnReset){
' l' w- i* ~) O% a                  running=false;
                  int j=0;
                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
$ p4 f& q5 T9 `6 Y                  reset=true;
                  repaint();
, `2 h- c/ d$ v5 o6 L7 _/ d2 [" Y3 {                  btnStart.setLabel("开始");
                  return true;
* F9 c6 G) Y! I: k4 _2 Y1 B5 R                }else if(evt.target == btnConfig){
1 ~0 `( O9 ?: @* G                        running=false;
1 `, x! [6 ^" ]4 _: Q& {2 @$ c& G. a                        btnStart.setLabel("开始");
; t/ S" _) t3 r7 }0 h     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
                        ctl.show();
8 n% W- s5 |" n, p& b7 ^4 X4 n                        return true;
$ }8 T7 y% {# I3 h$ V8 l                }else if(evt.target == choPDraw){
7 K- L% G; W' ?/ v8 V9 C& Z7 ?                  //选择画信息素的模式
3 C# N; ~- }9 I  k8 _! H' D0 G                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
+ ^3 y% ]8 j( V0 s5 m1 S7 V9 ]                  return true;
7 w; ~9 i% ]( i" e* ^0 y                }
                return false;</P>
<P>        }
" `# _0 }2 w5 g3 I /**Destroy the applet*/
$ ]9 T# w9 A3 I  public void destroy() {
  //当结束程序的时候，把线程也结束
( z- G$ X# o6 b( H4 k% D    if (runner!=null)
    {
2 D0 U# w- T  D5 S       running = false;
       runner.stop();
       runner=null;
    }
$ r* \/ ~9 w! n5 y  }</P>
<P>}
& w. o( {/ x& t# p" R0 l/ x$ y9 s</P>

5 K& i' ]' ]: B$ e8 Y& ^. f

9 B4 U" }% a9 g; [5 ?  L3 y<P>package ant;
. @, P" M) g1 C0 j5 N! d* Qimport java.awt.*;
) S% y7 b4 [7 `import java.applet.*;
import java.util.Vector;</P>
<P>public class ant{
& c7 K- g3 a4 ^' ] Point nowPt;//当前点坐标
int VR;//速度，每次蚂蚁能走动的最大长度
5 `( f) r5 `+ _* w1 B& _, V  int id;//标识
# j, S) K9 [9 w0 ]! D  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
9 t( c: o& }/ g" _4 i& a# d: K! w Color back_color;//背景的严肃
int height,width;//世界的尺寸
# k' R. b" @" K4 W: Y        int Phe;//每次释放信息素的数值
0 N) T/ J" D# Z9 r/ [ Antcolony local_colony;//主程序的指针
9 N. R, W+ S0 j7 R5 r1 w+ C        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
% Y# C) c$ M/ h# B        double Main_direct;//主方向
) B; H& j4 @2 y; o" q- N5 N7 k        Point FoodPt;//记录的食物点，是否找到时候判断用
        Point OriginPt;//窝的坐标
" s5 J" ]. O! Z$ v  B        Point AimPt;//目标点，是窝或者食物
        Point StartPt;//起始点，是窝或者食物
3 a7 s/ c" k$ X9 G5 g) I9 v        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
4 \8 Y" ~, B. @0 e) v) G+ r        int memory;//记忆走过点的数目
        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
3 u& B. p0 f: L, ]! ?: W9 _ public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
  nowPt=new Point(nowpt.x,nowpt.y);
; p3 R0 W4 \: d3 z                OriginPt=new Point(nowpt.x,nowpt.y);
# Z+ w- p( _# T: O- R, _% C( [: N                FoodPt=new Point(nowpt.x,nowpt.y);
3 _8 i( \% |7 s$ t; ]                StartPt=new Point(nowpt);
& j! H: L: \; G# ~  v' C                AimPt=new Point(nowpt);
3 S+ _' w2 D" V1 R                lastPt=nowPt;
  VR=vr;
7 z9 c8 ?2 f; z* Y  id=idd;
7 ~! }: F# v7 X3 h  V# u4 |2 ]  color=c;
' g* A+ A8 d) ^8 O  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
  X7 E  R+ q1 q4 a% K  width=Antcolony.width;
! _* H9 O4 ?/ M* B2 `9 n9 X5 Y  local_colony=colony;
  F1 p% W5 S* e& S                Phe=200;
2 C( X) F3 M. V2 U                mistake=mist;
                HistoryPoint=new Vector();
7 P/ [' I% B( ]* [0 g& ^2 W                Main_direct=-1;
# z0 h5 M0 @2 ^                FoundTimes=0;
6 m* B+ R% h8 j3 H+ n7 E+ Y! Z! t+ L/ I' T                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
                memory=mem;
9 Q+ v+ G$ ?  @6 X% s/ u; V                Count_distance=0;
                Min_distance=-1;
: R" D3 M" Q* Z1 f: `9 I }
        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
          AimPt=new Point(OriginPt);
' N. \1 I* N( x5 r, U1 {# @          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
          Main_direct=-1;
, m. E8 s) \0 s- ^          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
- t' i# C  W% J# V/ _4 Q1 c* L          Count_distance=0;
) o% p0 r4 y5 O9 o! k5 ]) q( g          Min_distance=-1;
        }
public void Draw(Graphics g) {
( h3 j5 ]) t/ A. \  I& ]8 x5 N          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
  g.setColor(back_color);
5 }. q3 K% d8 A- D  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
' @5 i' X! L" ?) U: Z% r  g.setColor(color);
; s% v; B; a' R+ m8 O1 [" @  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
}
public void Process(){
, J; h5 x5 Z2 O7 d$ l  Z* v# o        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
6 ~3 `" C  I5 w        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
' h0 M4 E$ k) I4 Y4 D3 J        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
. B+ n# N* F' j9 f        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
3 @" m6 h+ Y5 b- e. F        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

' [2 ?& I; I, Y3 w5 y. I  e<P>        if(Judged==false){
0 _' m. m3 [# g+ K          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
. [" @3 l/ ^+ I6 w: a* i          if(JudgeEnd()){
' B7 d: }- J' I! I4 M! `- |; H              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
0 V& Y3 L  ]2 }, D0 v, Y5 q& c2 @              return;
; H% v! u0 M) Y: y" s2 q0 l3 b          }
        }
        Judged=false;
        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
  x: [! K  f1 U/ M' B        double direct=SelectDirect();</P>
3 S! I& X( N  s2 o0 g) E<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
* K/ o! Y8 t5 Z+ x8 }        //direct是方向角，根据方向计算位移
1 o0 @( n: y, J0 J# T& h% w& ^        deltx=(int)(VR*Math.cos(direct));
6 s# R6 s$ d) g( C. G; @3 a$ o        delty=(int)(VR*Math.sin(direct));</P>
' a/ \3 W! n/ m% e% v+ m<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
9 i+ |8 [0 p" q0 B0 d* P& T3 s% h        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
+ O+ [9 y6 [; G2 ]        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
3 U- i* x  \0 o" [        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
: E5 F# H5 B6 j8 }8 l5 m: W          int deltx1,delty1;
! y5 K1 Q* j0 U% ?          deltx1=deltx;delty1=delty;</P>
<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
& \8 `8 x' F- x) {          for(int x=-VR;x&lt;=VR;x++){
             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
8 n8 C' `. g+ G& ?/ u# A8 _                //在这个程序中，坐标是循环的，也就是在一个球面上
# v7 z5 @- v& R                int xx=(nowPt.x+x+width)%width;
                int yy=(nowPt.y+y+height)%height;</P>
<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
& K: i1 D. W! V( ^! F0 v* e: q                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
, W4 I3 o  d' u8 m" R' Q<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
3 c  i- |6 @7 ?                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
! _. L& i: ^7 j7 K2 D7 L                      double ra=Math.random();
' h+ h3 u; I7 l- {- V                      if(here==0||ra&gt;mistake){
                          boolean found=false;
8 ]% Z- A3 B( E( @! @                          //查一下内存最近走过的memory的点数，从而避免当地转圈
0 @, f0 a0 m$ t5 t9 z/ \                          int size=HistoryPoint.size();
! A# |) s0 a7 ?! u4 F( @* d; _# S0 W+ d                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
" e! l& e3 l9 X* M( o8 `+ x                          for(int i=size-1;i&gt;=size-minsize;i--){
                             Point pt=(Point)(HistoryPoint.elementAt(i));
# d: k4 l  _" u; @( V) y" K: k                             if(pt.x==xx&amp;&amp;pt.y==yy){
- i" x- j, Y9 ~                                found=true;
/ R" b3 Z! V3 H8 l: |                                break;
; f+ P8 J6 J& V* c3 T                             }
6 G$ H+ D- c/ E& `# m$ Q4 L6 n                          }
) v3 J* j9 v6 J# I; E- e/ [( l                          if(!found){
                            //如果没有原地转圈，那么记录信息素。
& d3 O* F3 ?' M: J                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
7 e9 v5 E; x! K7 H1 e                            deltx=x;
                            delty=y;
                          }
                      }//end here==0||ra&gt;0.001
2 }: X+ m7 A4 \0 \                    }//end maxphe&lt;here
                }//end if x!=0
            }//end for y
        }//end for x
5 n" h! J: d' ?        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
8 [$ o& E7 l  w% t        pt=Evade_obs(deltx,delty);</P>
9 A) Y* \: I4 I<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
2 \, _9 H2 L  Q          pt=Evade_obs(deltx1,delty1);
9 _9 j! K5 _; Q; [        }</P>
<P>        //播撒信息素
+ q* m  p2 g" C5 ~  M7 e+ b8 Q        Scatter();</P>
9 `  v0 M% |( q# j7 q: `<P>        //记录走过的距离
; v) W* }6 q4 E  M* V2 W        Count_distance+=Distance(lastPt,nowPt);</P>
& @, ]7 u8 w& u' [+ k) j/ G3 Z<P>        //改变当前点位置
# V) a3 r& G" t6 V, _4 l        lastPt=new Point(nowPt.x,nowPt.y);</P>
<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
9 {& x5 [4 b$ n6 q! m0 S2 T        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
        if(HistoryPoint.size()&gt;memory){
          HistoryPoint.removeElementAt(0);
) h- r# r+ r8 O* E5 `2 I; w        }
% \! C3 e4 b3 j! K% d, P/ q0 X        nowPt=new Point(pt.x,pt.y);
     }</P>
; `9 J0 G* q0 ~8 c6 a; O<P>
! ]# A# ^+ q' L8 P6 L        private void Scatter(){
        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
: J" k4 }' k9 W! w        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
            if(Pheromone_count&lt;=0)return;
; i. H+ S7 p4 `            //决定释放信息素的种类
            int kind=FoundTimes%2;</P>
, F9 o3 a1 {8 \: f<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
            boolean ofound=false;
7 ?& g5 M8 t) ~$ `+ p- t: C            if(Phec!=0){
% |* R# z* A" r, Q                //如果当前点已经有信息素了
* W  u% ?- X& ~4 e/ Y' g                for(int i=0;i&lt;local_colony.phe.size();i++){
. z3 f' V7 E$ w+ g3 U: e' n4 c4 D0 B                    //在信息素向量中查找该点的信息
; @9 V/ H3 u3 \$ [$ L$ Z$ b# t/ T% k                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
8 f4 m/ C4 m2 g7 l3 }                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
2 u7 j7 i: Z$ _0 J% G                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
/ K$ y: i! y  E6 W$ e                        ofound=true;
- z- T6 w, Y+ P9 A. b4 T                        boolean found=false;
                        if(size&gt;4){
  Y& _, a7 v) Q" G# z! B" z& E                           for(int j=size-4;j&lt;size-1;j++){
                              Point pt=(Point)(HistoryPoint.elementAt(j));
                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
0 r6 d1 @+ R* A0 r0 b                                //如果当前点重复了以前走过的路，就不释放
                                found=true;
4 ^& h# _* P1 X3 m3 h0 H5 d                                break;
                              }
! F2 {6 `$ U1 I/ l2 \- B                            }
                        }
/ c7 l9 M' B) _6 i4 @+ E. O                        if(!found){
                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
/ ~; a7 S3 f* w; A                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
5 N  i) O1 V0 ^% b9 `; {<P>                             //让还剩下的信息素总量减少
                             Pheromone_count-=Phe;
                        }
1 @- g. r3 T$ Y) w4 U" L+ f0 j                        break;
2 m, I) c' b1 M& p2 I                    }
( a* J  A1 s  v                }
              }
          if(Phec==0||!ofound){
, W0 _& H$ T1 d: a4 r            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
/ w* h9 \. X8 G$ R+ }  A: h                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);
                //让还剩下的信息素总量减少
                 Pheromone_count-=Phe;
* V" F) y( d- o% W5 \! r4 ?           }</P>
<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
, @) C% V+ j! T- i& B           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
" E  ]  r# }) s! b/ u. ^- u           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
        }
private boolean JudgeEnd(){
    //这个函数判断是否已经找到了目标点
7 Z# e( `' \- q0 W7 N    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
" A8 g% a8 C/ O' s    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
        int i;
        for(i=0;i&lt;local_colony.EndPts;i++){
            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
              //如果找到了食物，就直接移动到食物点
. j! o+ ]' L4 d) Y# \              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
<P>              //计算最后的总距离
4 s, a. e$ {! j/ `6 N( `              Count_distance+=Distance(lastPt,nowPt);
/ q4 F3 x2 V3 v1 N1 U              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
( O) K" W. p& g( t& c* [              }
, H( J9 }9 V5 L; u/ H- k6 Q1 l              //清除总距离记录
# w8 E+ H1 @6 S3 C7 ?1 r+ i+ t              Count_distance=0;</P>
<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
% A; S: F9 e9 K              AimPt=new Point(OriginPt);
. L0 f  k+ `% D) X              StartPt=new Point(nowPt);
              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
* f  ~8 {% ~5 f<P>              //找到了食物就把找到次数+1
4 L8 w: b5 K1 t. F              FoundTimes++;</P>
<P>              //改变主方向为原来方向的镜面反方向
7 Y& D8 l7 b! w$ o- w              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
4 x, p: }- v* D" X<P>              //重新把自己能撒的信息素置为最大值
( l) {. y  X; l              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
<P>              //返回找到为真
- Q- B. \( I5 d8 a1 @, O/ u! N% W+ F0 j              return true;
            }
        }
      //否则没找到
. @7 @" j. U% q; F" J- S7 |      return false;
    }
9 u/ [7 }9 R6 V2 d# `    if(kind==1){
+ i* B/ x- F7 r; Y! v/ r        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
            lastPt=new Point(nowPt.x,nowPt.y);
            //如果找到了目标，就直接移动到目标点
, S* D5 ]- ]" j0 W" k# `# S            nowPt.x=AimPt.x;
5 p& f# S8 K- l6 k, h  L            nowPt.y=AimPt.y;</P>
* }$ u0 d$ \  Y, I, s+ R# @<P>              //计算最后的总距离
9 f5 @5 M4 y4 |+ x" X# ]' U              Count_distance+=Distance(lastPt,nowPt);
9 b1 M; G* q% z8 s              //比较大小，记录较小的距离
1 E3 g& ?; k3 R: b  E- F              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
2 ~1 v( i: o/ c: T: k. N, M                  Min_distance=Count_distance;
* y: b4 P( ~7 `! w2 a' A8 ~              }
              //清除总距离记录
              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
            StartPt=new Point(OriginPt);</P>
% R- z+ |7 W3 t8 ?, i8 Q<P>            //重新置信息素
            Pheromone_count=Max_Pheromone;</P>
1 K# ]8 H# \2 r- n7 s4 M<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
2 m! b2 w  w  ^0 \, H% w5 H<P>            //主方向反向
            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
8 h6 U3 P+ j6 \, h            FoundTimes++;
            return true;
2 v3 z9 F1 z! m        }
' ]  }/ q4 q: Y! W5 _        return false;
    }
1 ~0 |6 _' \: Q2 |' l    return false;
}
! ]+ l9 n# L! {        private double SelectDirect(){
. J8 y- u/ ~/ m; Y1 L5 r. j6 q                //选择方向，最后选择的方向为主方向加一个随机扰动
6 k1 F# g" [: A" u1 q                double direct,e=0;
8 [* g$ D4 j; v  E3 e                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
        e=2*Math.PI*Math.random();
                      Main_direct=e;
+ C- {5 \; o: C5 a                }
' v! m0 g. g0 T' W! E                //选择主方向角
  @4 v' M: \7 d0 _2 T5 N3 E/ `4 T9 _                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
; w7 K. C4 Q. ~6 O                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
9 |9 b3 u7 s) H3 I  r; E/ j) f                double re1=Math.random();
: j( y8 `2 K. l. _9 A                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
8 T; ~: L0 j+ ^" K( h                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
3 a" c1 i$ C. D                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
                       Main_direct=GetDirection(pt,nowPt);
                    }
, U& @0 B( `% U                  }
9 M, I$ Z3 J2 [8 A8 }- E                }
" ]$ O  ?% I+ A( o# D& k5 K               return direct;</P>
<P>        }
        private Point Evade_obs(int deltx,int delty){
+ E4 G* g( k* Q: K8 }8 F" P5 o              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
8 e7 K% E/ n7 t8 W              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
: n/ z8 p6 g& z6 P) ]. o2 V3 X( z              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //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);
4 Q  f+ A7 F( K              int x,y;
7 J% D$ k( `- G) S! ~              int delt=deltx;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
5 Y$ @' N2 o6 _' c$ s8 `6 b              if(delt==0)return nowPt;
              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
; }) w2 K" X9 i8 x7 l$ X- `& A2 [                  x=(x+width)%width;
                  y=(y+height)%height;
                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
) ^8 P3 V! Y5 ^9 n/ P6 R  R<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
                     double disturb=4*Math.PI*(Math.random()-0.5);
                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
, j) |$ S. d. h, z/ ]# Y4 l7 ]                     break;
                  }
4 m; j) H1 ~$ g. g: d5 o. _                  pt=new Point(x,y);
                }</P>
<P>                //计算得出实际能够到达的目标点
2 |; T5 y! b' D0 e) R0 k  x=(nowPt.x+deltx+width)%width;
6 K4 y) u) S: v0 f3 b  y=(nowPt.y+delty+height)%height;
         return new Point(x,y);
        }
        private double GetDirection(Point pt1,Point pt2){
- N/ Q" H- Z# E8 {6 F        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
        //其中方向角是所有可能的角中使得两点连线距离最短的角。
               double e;
               int deltx1=pt2.x-pt1.x;
* R( i/ ^6 O7 g6 V& O$ v( u0 I/ |               int deltx2;
6 N& e; B0 z9 [0 O. i% n               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
               else deltx2=pt2.x+width-pt1.x;
( q8 G4 r! E( Y) _$ w, K               int delty1=pt2.y-pt1.y;
, P' U( S7 x3 u8 W8 `6 C               int delty2;
8 l/ f, H( t8 Z3 [( ^               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
               else delty2=pt2.y+height-pt1.y;
( A" u* g9 Q; {+ [; w. f               int deltx=deltx1,delty=delty1;
               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
6 p* E. \" [8 {% w' d    deltx=deltx2;
) p$ Z% P) U# q2 ?8 Q9 [0 O4 F: B, z               }
        if(Math.abs(delty2)&lt;Math.abs(delty1)){
) h, W7 p7 Q; k7 h                  delty=delty2;
               }
9 o( m. A+ l& k( `               if(deltx!=0){
! Z/ Z1 ]2 f# q' v0 e                    e=Math.atan((double)(delty)/(double)(deltx));
/ C7 C+ Y0 A% O2 o) k                    if(deltx&lt;0){
- O* j! s: a  w. N* L                       if(e&lt;0) e=e-Math.PI;
0 P1 x$ k- T* Z& t                       else e=e+Math.PI;
                    }
* @* v' ~( c, o8 f7 S; u7 u& F5 Y                }else{
                    if(delty&gt;0)e=Math.PI/2;
# e6 D4 K( y/ U8 U: a# o                    else e=-Math.PI/2;
                }
                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
1 U% T. {5 [2 I/ i/ R. w! ^0 q2 F3 H        }
1 }' b* n; f, }' r        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
            int dx2;
5 w/ w9 A/ v5 w            int dx,dy;
+ [' I9 v( A$ ^9 ~% m4 ~$ v            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
+ F/ K6 S# K$ \# I+ K9 `3 b            else dx2=pt2.x+width-pt1.x;
' t4 v+ o1 p9 d0 @            int dy1=pt1.y-pt2.y;
, G) b$ T3 ?# o+ ]5 Q' |% X' o            int dy2;
            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;
            else dx=dx2;
: S8 X. W2 T: H7 X5 m5 a            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
            else dy=dy2;
            return Math.sqrt(dx*dx+dy*dy);
- v$ ?9 `0 J, o2 K& b) X8 ~        }
    public void clone(ant ant1){
: R9 o4 J/ x8 u0 O8 J" G        //把蚂蚁ant1的属性拷贝到本蚂蚁
     nowPt=new Point(ant1.nowPt);
+ l& h; `* P6 P3 i4 ~4 t* ?* |5 q$ L3 }' c        OriginPt=new Point(ant1.OriginPt);
        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
4 g3 N8 {  V- |# U5 `        lastPt=new Point(ant1.lastPt);
        VR=ant1.VR;
        id=ant1.id;
        color=ant1.color;
        back_color=ant1.back_color;
* h1 L+ e/ J  U- E5 ?, l0 q        height=ant1.height;
) f/ Q* _( A5 V( x4 |: Y        width=ant1.width;
        local_colony=ant1.local_colony;
        Phe=ant1.Phe;
        mistake=ant1.mistake;
3 h+ M! _. x! L" L. I+ c6 u        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
' y; C1 H- R, c4 A/ R, [1 j        FoundTimes=ant1.FoundTimes;
9 Y3 `& ?' c& v0 b# g        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
        memory=ant1.memory;
        Count_distance=ant1.Count_distance;
' s# Y& n, w  I1 f# e        Min_distance=ant1.Min_distance;
( a( x0 V4 k' i8 t    }
. d, k# X1 t. G( h) d}</P>