[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
<>package ant;
0 }2 d& b# }, M- w/*
& I% G! G3 c9 x! x/ H( v' c * @(#)Antcolony.java 1.0 03/05/22
9 l$ N) m. C+ l) m4 b$ b- y *
% K, ]. }8 D7 E9 E/ ]$ q- u * You can modify the template of this file in the
' I. v$ U6 n4 p8 _* {7 E. h% J * directory ..\JCreator\Templates\Template_2\Project_Name.java
1 y( g9 v( h  W! I *
* You can also create your own project template by making a new
$ j# z$ H0 d+ ?0 w1 V * folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
8 j& `9 e" F  \ *
*/</P>
2 y8 m2 t& _4 `+ R<>import java.awt.*;
1 i. g( D! {) M" ^/ J$ gimport java.applet.*;
( w# e/ `* w" k1 {import java.awt.event.*;
import java.util.Vector;</P>
( ^8 O6 O# f: g2 ~" }+ F<>class AntCanvas extends Canvas
8 f6 ^$ {& T! ~: ?% B- @  |' E6 A8 X{
3 O. u% v( {' h: F+ `) Z& z    //画布，一切画图操作均由该类完成
# ?& h8 G; e/ ^5 c+ b/ w3 V //Image image;
, O: a/ q& X4 I, y Color obs_color;//障碍物颜色
% u  L# h3 l6 `' U8 D Color origin_color;//我的颜色
# s* V3 S7 k0 S, E# I$ }% P# U9 l' H Color back_color;//背景色
) G5 A. E, R, S. n$ S) J        Color end_color;//食物点的颜色
//boolean first;
boolean reset;</P>
<>/* public AntCanvas(Image img) {</P>
<>  super();
1 `8 ]0 f- U4 a  P. w9 X3 h   image = img;
  obs_color = Color.white;
  setBackground(Color.black);
8 n( T5 m& g1 u; t& \6 e. @  setForeground(Color.white);
  first = true;
/ h( S7 g0 M7 W! j% h  reset = false;</P>
$ S3 i6 Q& d/ ], [' r& q* Z  J<> }*/</P>
<> public AntCanvas() {</P>
8 X; }" t* D4 G  N: |2 w$ F1 ~9 w<>  super();
" L- j1 [( ]- d$ k   //image = null;
   back_color=Antcolony.BACK_COLOR;
  setBackground(back_color);
4 M8 e2 w- c3 E* i& C' |% v  setForeground(Color.white);
% T1 ^# _, M8 @$ Y; P/ p. A5 z  obs_color = Antcolony.OBS_COLOR;
! F& o  C7 {/ \: o4 b  origin_color=Antcolony.ORIGIN_COLOR;
                end_color=Antcolony.End_COLOR;
  //first = true;
- R$ m9 Z4 L% I: r  reset = true;</P>
<> }</P>
<> public void Clear() {
        //清空画布
  reset = true;
" O8 s9 ^4 I* d+ b7 P$ ^  repaint();
1 A! `( U' d' U( T/ y8 ]* | }</P>
( J, {  O+ I9 I- @<>
2 b9 |* i: C# h7 P) E  a public void paint(Graphics g) {
2 Z0 I) v7 i) m1 A( Z  int i;
2 p8 D" m" M& P1 g* w* _7 i  m                //重画的时候仅仅画障碍物
5 }0 [9 O8 i5 g* y, V: J1 J  g.setColor(Color.black);
- X  g) I9 B1 p0 @% d  g.fillRect(0,0,size().width,size().height);
  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
3 ~, M' N; ~# d& h8 ]+ U   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
" {! O2 [6 b" `! ^+ o2 A& k# I  }</P>
<> }
3 x8 j( @4 I0 `1 s# j+ c/ o public void process(){
1 L/ V+ j) G7 O8 f* u        //处理动画的过程
  Graphics g=this.getGraphics();
                g.setColor(end_color);
) N' j1 L2 I2 X9 L! m) h   for(int j=0;j&lt;Antcolony.EndPts;j++){
8 `; K4 |& }5 u3 H) S                  //画所有的食物点
# A! _; Y& Y) y: @$ @& E                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
                }
8 z  W0 V* v( t& @# Z                for(int i=0;i&lt;Antcolony.antCount;i++){
8 R7 B$ `6 |- T- c                  //每只蚂蚁开始决策，并画蚂蚁
" e) G) [( n0 g4 C7 r0 @) [& G   Antcolony.ants.Process();
   Antcolony.ants.Draw(g);
/ h+ {9 [8 M' I! O  }
( i9 Q1 y! h% t% N4 u+ g4 [                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
                        //Antcolony的drawPhe变量标志是否画信息素
2 n) \+ h& s* r& G7 M' q8 p4 Y                        switch(Antcolony.drawPhe){
                        case (1):
                            v.Draw(g);
. Z# a' ?& C( {% o' Z& t$ H) @7 H                            break;
3 f2 A" _7 H  o3 m                        case (2):
                            if(v.kind==1)v.Draw(g);
1 \2 M) Q0 N# T5 h7 s                            break;
                        case (3):
+ U4 K8 f2 }; D                            if(v.kind==0)v.Draw(g);
                            break;
. G3 h& Q( R9 H: F- N                        }
/ J/ g  q4 g5 y. ]% @# H* V                        v.delimit(g);
7 l1 C2 ?- k7 F/ [) F, }                }
           g.setColor(origin_color);
                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
! O- Q0 d) z6 q) q: l                }</P>
) Y7 h' D4 `" h4 G8 d# R( @# v# f<> }
# H9 F# ?% f. ^% e# y Graphics GetGra() {</P>
1 ^0 r* p4 X+ w3 \" I' N8 o+ F<>  return this.getGraphics();
% ~+ q4 w, S, c+ Z }
}
$ {9 c9 }- X) O2 _6 H! Epublic class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
( z" ]- V" b% ?) b; q, N+ U8 q# x static Color OBS_COLOR=Color.red;//障碍物的颜色
$ l* N" t9 P$ |. S( e* d static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
5 Q0 Z) p% g. X" u static Color ANT_COLOR=Color.white;//蚂蚁的颜色
% j, n0 x1 [' U( l5 x% P0 k0 h        static Color End_COLOR=Color.cyan;//食物点的颜色
. G* |2 u! a! o7 w) h# R4 K AntCanvas canvas=new AntCanvas();//画图用的画布
' k, U: B$ q" g int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
$ {. _4 B& ~- d* e, O) J        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
! K" |8 y2 c. X static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
* M0 \) I8 p* ?- U" n        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
2 N7 R$ E6 W0 L static Point OriginPt[];//窝点信息
7 H$ U1 H# ]  A  F9 _/ h' z        static int OriginPts=1;//窝的个数，最大为100
static int width=300,height=300;//环境的长和宽
: M. K6 L1 ~: Z: s; k6 q static int antCount;//蚂蚁的数量
* z8 p: L* k6 G4 A! N9 O        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
" Y$ T. l# L" S$ [- A8 U        static int FoodR=10;//食物和窝产生梯度的信息素的半径
0 x* g! E6 m3 f: b2 Q$ O7 p static ant ants[];//蚂蚁数组
+ p! P, y6 \# s; l0 D        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
5 _: H6 _5 c/ u  k" G- i int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
( P- ]% c' w1 Q. C/ W& K9 c        Button btnStart=new Button("开始");
        Button btnReset=new Button("重来");
        Button btnMap=new Button("编辑地图");
- |! v" W6 \$ h# X: q4 p; x        Button btnConfig=new Button("设置");
1 d; p; L" k: T2 @/ t5 x        Choice choPDraw=new Choice();
public void init() {
% {8 U4 U( W/ B- C  D* Q                //初始化函数，先画各种控件
  setLayout(new BorderLayout());
                Panel pan=new Panel();
7 y/ O' e& x7 }/ L; b: x) l* p                add("South",pan);
                this.add("Center",canvas);
                pan.add(btnStart);
                pan.add(btnReset);
                pan.add(btnConfig);
( e3 v* |; }" K& k9 \: J# m4 K                pan.add(btnMap);
                pan.add(choPDraw);
  `! T. X- E2 C5 N' P$ W2 @                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
4 ~. E7 z9 K8 v( F9 |8 C, d                choPDraw.addItem("画窝的信息素");
3 ^  [8 t# Y9 R. ~                choPDraw.select(2);</P>
<>                //初始化各个数组
  obs_grid=new int [width][height];
                phe=new Vector();
$ S+ L; P5 q; x/ {  O                Pheromone_grid=new int [2][width][height];
                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;
0 h, A* D9 P5 s8 z: m6 @! K3 ?& y                                }
0 M1 \/ Y4 D. d: L. v   }
/ s6 W7 g+ }( B/ A3 C" B* ]  }</P>
* X# `. Y# w" u5 o2 h! A' Z5 ~3 e<>   antCount=50;//蚂蚁个数缺省为50
; z' L' K) I7 ^0 s! N9 W$ ^                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
# g4 @9 m, e9 S0 W  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
9 f) P) A0 M  V( c  S+ V3 @' |) |          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
& }3 x% |) ?0 b& g1 D' @  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
9 O2 [% f0 \% c9 O                Maps maps=new Maps();
3 h, z& ~( ], T. H                maps.LoadMap(grid,0);
                //初始化地图
# Z% i5 n! Q; g- H( [# l                reinit_map(grid);</P>
) A2 D* U& _8 ]: p' u* O. W: V7 W* u<>                //初始化所有的蚂蚁
2 K! A" s8 p; U: N8 ]! U" W  reinit();
& h  O4 A0 `9 w% [  g( P8 b; k }
        public void reinit_map(int grid[][]){
! h9 Z9 M) ^# E5 W                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
8 I" t+ S8 [+ W. \0 u$ L; l7 {; [                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
<>                //先停止程序的运行
; z: e3 \. K+ U. V" N; |                running=false;
' P& c$ i' h% a( X, M                btnStart.setLabel("开始");</P>
; [& W5 j; M5 C0 |9 [$ B. @<>
                obsCount=0;
                EndPts=0;
2 ?7 g& Q9 X5 t: ]2 d6 b                OriginPts=0;
                obsP=new Point[width*height];
                OriginPt=new Point[100];
                EndPt=new Point[100];</P>
  I0 q! P/ \. p  J<>                //清空obs_grid和Pheromone两个数组中的值
5 Y" i5 j: Q! M. p8 c                for(int i=0;i&lt;width;i++){
8 ?4 f; b) Y" ?0 Z1 D: x5 c   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;
% L; r% ~3 U# p8 a0 f' i7 H                                }
   }
3 M0 t2 M; m; W; w  }</P>
  u& q1 L$ E0 m& @! W" w<>                //从grid数组中读取信息
" n8 ~3 h/ M( o: P9 C# Q1 N5 i                for(int i=0;i&lt;width;i++){
                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
6 Z$ g9 u( w& l- U) p7 N                    case 1:
                      //如果grid[][]存的是障碍物
                      obs_grid[j]=obsCount;
3 R/ P5 ^$ [/ u/ t/ p: f: z                      obsP[obsCount]=new Point(i,j);
5 C8 |7 C, n- E8 [1 G- u. x                      obsCount++;
6 A- ], y8 O6 A8 u% C                      break;
                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
                      }
: i; k3 G* B; T0 q$ x) }                      break;
                    case 3:
+ e; U- @9 x$ i3 U& u9 R                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
+ w' c5 W! y; \) I  C" r                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
9 V! m/ x7 b7 c1 O/ r                      }
                      break;
$ z% K- g5 Y4 C8 M* r( a& e% G0 ^  H                    }
                  }
                }
7 @3 r1 p/ u; {, |- B* _6 d/ X            //如果没有指定窝，则随机的选择一点
# x* M5 R& [% }+ Z2 S+ n8 y            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
; I! s: ]. v7 @" i; o6 l                int  j;
7 M; w; D* ?# o  p( J% t                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
1 J. g" y$ Z( D( l                    OriginPt[OriginPts]=new Point(i,j);
, e; i. J$ K0 t) H' a                    OriginPts++;
                    break;
+ a* L/ x: S% F, E+ b                  }
, a4 Q/ i. t0 x9 _6 V  J1 {. J; h2 m                }
                if(j&lt;height-1){
                  break;
& M/ d4 j  {0 X                }
$ P( u- j4 A2 ?( g              }
            }
        }
/ i! y5 [# j- E1 Q+ z$ D' D- d public void reinit(){
) w$ x6 a, `+ N                //重新初始化整个环境</P>
<>                //先停止程序的运行
3 e& @: G# s& g, }, c! h                running=false;
% ^# H0 b* Q3 t* g% n                btnStart.setLabel("开始");</P>
<>
  //清空所有信息素Pheromone数组中的值
5 j) X, d- u* Z, `8 v" E8 z+ ]                for(int i=0;i&lt;width;i++){
  ~( G: g: I3 j$ J   for(int j=0;j&lt;height;j++){
4 |& P0 q7 X5 o# b                                for(int k=0;k&lt;2;k++){
% n& b+ h, i9 t( E                                  Pheromone_grid[k][j]=0;
                                }
! K, k. L4 d. _   }
9 d+ i6 @9 q- R* _" A  }</P>
% D4 W* n# w& s( J9 R: U1 O<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
: c' `* I3 `$ M! e2 U" M                        int index=(int)(OriginPts*Math.random());
% i, |- T2 @1 L: A$ z- E! Y3 Y* i          ants.OriginPt=new Point(OriginPt[index]);
                        ants.init();
3 S7 E: y$ x1 F7 }7 r2 I6 O  }</P>
<>                //清空信息素向量
                phe.removeAllElements();</P>
. ]5 W) H) k5 K# V0 |<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
8 J$ ?* }( [# Y" \  for(int i=0;i&lt;EndPts;i++){
9 C/ q; T" _* P# ~$ k                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        for(int yy=-y;yy&lt;=y;yy++){
                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
                    }
                }
                for(int i=0;i&lt;OriginPts;i++){
* q! ?4 |: P0 ?8 f: @8 F9 y' a- y7 T                   for(int x=-FoodR;x&lt;=FoodR;x++){
* @3 k7 Z. D; J  |                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        for(int yy=-y;yy&lt;=y;yy++){
" r0 d3 R0 x: u( I& {                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
  V3 ^" g1 d( O8 _                    }
) c4 `* y% F5 O* ~                }</P>
<P>                //重画
  canvas.repaint();</P>
& T- `- R2 p) a& d0 G# E<P>                //让程序开始运行
                //running=true;
3 B! P, e& }/ J- N+ Y0 M }
/ q0 k1 n4 W; E4 f, I public void paint(Graphics g) {
8 Z: X: |' d) M0 d) f  canvas.repaint();
}</P>
<P>
# r3 [4 T7 F7 ]- Rpublic static void main(String[] args) {
  a7 ]7 K8 s4 ?0 p7 {* N2 H    Antcolony applet = new Antcolony();
. n- B/ k9 }4 A, h& N3 ^    applet.isStandalone = true;
! E9 T; q5 }2 s- G4 d# v, l    Frame frame;
0 j* U; r, z* c4 A8 c4 o; }2 O    frame = new Frame() {
/ d. O/ o1 B9 |6 G7 o" O. r; P3 l6 t      protected void processWindowEvent(WindowEvent e) {
4 d/ P; k5 F5 P4 ]        super.processWindowEvent(e);
( M# L% x$ i; x        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
8 }3 P" l! N0 i3 i7 D* |* m          System.exit(0);
6 ]; k0 t8 X9 c+ N        }
. u* V: n$ u# ]* V2 ?9 Z  V6 S      }
      public synchronized void setTitle(String title) {
        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
6 t! f5 C8 ]( H) a: W      }
    };
9 w' d0 J9 z* y( p    frame.setTitle("Applet Frame");
* e; m: A- o: n* o    frame.add(applet, BorderLayout.CENTER);
% i3 n& V( U7 h3 n$ P& \    applet.init();
  o( ?) l  N3 F; u  |: u& h    applet.start();
' z# K% R. o/ @& K9 q    frame.setSize(300,320);
- @/ k/ G3 K& b3 n0 _    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
) w% e- p& f; u3 @    frame.setVisible(true);
* l5 A" [; c6 @5 G  M) z6 ]! r; W  N  }
  public void start()
  //下面三个函数是控制线程的
{
7 U! r, N4 `7 d; {, B  if (runner == null)
3 B, G; \& L4 }! `! ?. j  {
   runner= new Thread(this);
   runner.start();
   //running = true;
  }
}</P>
<P> public void stop()
{
& z4 e: G9 L& l& S" m  if (runner!=null)
) n( ]+ P9 m; b1 V8 n7 P  {
   runner.stop();
2 d& L, ~/ r& X9 x0 `   runner=null;
   running = false;
' {9 e: M5 }+ S7 K  }
}</P>
<P> public void run() {</P>
! ]% A8 }* J0 I6 W. p9 }<P>  int i;
                //线程一直运行下去
. v- b: A$ |3 h1 B/ p/ U: `  while (true) {
          if(running){
       //如果开始动画，就进行canvas的处理
- m% D9 m* \1 g4 f  s# u+ Q9 Q                          canvas.process();
. e+ W" \* q0 N9 H                        }
. M7 B# N8 o4 ~* W% D8 g' W    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
2 L5 I+ U- Q  Q   }
1 O4 `) s5 G" B  W- t  }</P>
% J0 g1 x+ _; }9 T<P> }
        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
                //开始编辑地图面板
   running=false;
                        btnStart.setLabel("开始");
   MapPad ctl = new MapPad(this);
& e( ?6 e) Q" Q/ j! a                 ctl.setSize(308,380);
  N0 Z) F8 A' R% {; C# s                        ctl.show();
                        return true;
  }else if(evt.target == btnStart){
( z; R% ^$ t' C4 }# \0 ?                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
, K. f1 f" _3 T: l2 Z/ U                    btnStart.setLabel("停止");
; d/ w9 w) q' ~2 c. ]5 J                    reset=false;
+ e/ k* u, T% R! F3 K                    running=true;
                  }else{
                    btnStart.setLabel("开始");
                    running=false;
                  }
8 I7 R' Y6 `( U0 P; ]  e) ~                  return true;
# w; {! z& O! T: |: O                }else if(evt.target == btnReset){
                  running=false;
                  int j=0;
                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
' x& ~7 w$ i: B% ?2 k: D2 U  S/ b( d                  repaint();
                  btnStart.setLabel("开始");
                  return true;
                }else if(evt.target == btnConfig){
                        running=false;
                        btnStart.setLabel("开始");
; c7 z6 O% `* Z7 M     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
                        ctl.show();
                        return true;
                }else if(evt.target == choPDraw){
- _6 P6 `$ l* p. Y# d                  //选择画信息素的模式
7 y9 n/ v1 @& N; A                  drawPhe=choPDraw.getSelectedIndex();
$ q4 M  X# O: H4 n! F) |" @                  if(drawPhe!=1){canvas.repaint();}
* ^% ?* u; v- o% e) `( k8 s                  return true;
                }
                return false;</P>
<P>        }
7 ]* v3 g7 C4 ^7 B7 Z! r  O /**Destroy the applet*/
& {" W  C( a$ N  b  public void destroy() {
$ z8 }) R; K+ |7 C: y* c: ?* j  //当结束程序的时候，把线程也结束
( t, [: N% J8 V    if (runner!=null)
* g, ~! y4 H5 F6 u- @    {
       running = false;
       runner.stop();
       runner=null;
    }
; t1 i4 _7 G/ ?+ h  }</P>
) y- z6 M( \9 ]9 p% t4 a<P>}
1 x: s3 s" ?: E1 G% ~</P>
9 x$ r- r- s+ D- G! m6 s

/ z5 M, F2 m" z# B# B8 I
<P>package ant;
import java.awt.*;
& z" @' l0 O. P6 B" ximport java.applet.*;
. J+ C  Z! p6 S  {$ Q& Z6 Pimport java.util.Vector;</P>
* ^2 f! j/ R4 X& z<P>public class ant{
  |' [: e( y3 c" t1 _; r: f: K Point nowPt;//当前点坐标
int VR;//速度，每次蚂蚁能走动的最大长度
( i+ W' p( O  ~1 ]- t  int id;//标识
6 M1 I, k6 C% i5 u, E4 R# P  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
; @) |. }$ s6 Y9 b/ m' n6 X int height,width;//世界的尺寸
* n& ]" F& \! V; X0 h        int Phe;//每次释放信息素的数值
9 z4 `  e; R5 c9 a4 J1 n Antcolony local_colony;//主程序的指针
* B. n0 l9 U& m2 M        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
6 C4 S9 o2 @1 D3 O) ~2 u        double Main_direct;//主方向
: C2 L0 o% A3 v& g$ z! L: _4 Q6 E        Point FoodPt;//记录的食物点，是否找到时候判断用
5 d& T5 E1 _0 m% v+ P$ q' A        Point OriginPt;//窝的坐标
0 G9 _! N' h8 C  ~  Z; p: {. @, A        Point AimPt;//目标点，是窝或者食物
: i4 o( z, E$ C0 z        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
! J6 h$ ]( \8 D- [/ e5 g4 ~        int Pheromone_count;//当前还拥有的信息素的总量
# e; m; w/ D9 q, i        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
8 G6 I2 E" f9 V$ N- a: L* J        int memory;//记忆走过点的数目
+ C& J( x5 @9 |        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
  nowPt=new Point(nowpt.x,nowpt.y);
                OriginPt=new Point(nowpt.x,nowpt.y);
, a0 d0 M8 h4 ?9 k  d2 m                FoodPt=new Point(nowpt.x,nowpt.y);
- o' T' z0 f9 h3 A5 d$ Y                StartPt=new Point(nowpt);
                AimPt=new Point(nowpt);
8 I# o& ^  T) U9 R+ A( d' a                lastPt=nowPt;
5 r4 d* W7 e7 v) i; C6 {' l  VR=vr;
  id=idd;
% V) G) V, e5 C1 P  }7 ]  color=c;
  back_color=Antcolony.BACK_COLOR;
9 e/ K8 P* U  E+ B9 V* F, p& b  height=Antcolony.height;
4 s9 G, }- Y- N4 G. D4 o. b& `7 q  width=Antcolony.width;
  local_colony=colony;
                Phe=200;
                mistake=mist;
                HistoryPoint=new Vector();
, D( Q  B2 a1 C( ]' N                Main_direct=-1;
: d; U/ \2 c) k8 @2 g6 m1 s6 h                FoundTimes=0;
1 ?3 R4 n! k0 g: a& \6 K7 f, Q4 C$ \/ z                Max_Pheromone=local_colony.Max_Pheromone;
! u" {: H2 L) E# {) X: I& `                Pheromone_count=Max_Pheromone;
# l& a7 S) e' u6 `4 L7 r" U                memory=mem;
                Count_distance=0;
                Min_distance=-1;
9 ~: [7 Z: a! D7 d }
0 C# _7 {8 l# K& {* [! q3 F        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
* m0 O. J- U6 A. C; u4 |* p  R$ g          FoodPt=new Point(OriginPt);
          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
  ]/ X5 t2 h3 d) M          HistoryPoint.removeAllElements();
          Main_direct=-1;
0 w1 d7 Q7 b# X. `2 x( N          FoundTimes=0;
/ y- j5 A* E* F, T$ C          Pheromone_count=Max_Pheromone;
; K- }; `# Q6 }0 h          Count_distance=0;
          Min_distance=-1;
        }
( [  p) I7 Q/ e4 b- o% @ public void Draw(Graphics g) {
          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
  g.setColor(back_color);
  Q# v6 O2 q, P  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
$ T7 q' ]5 n+ ~1 G; f. h  g.setColor(color);
  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
}
4 W2 A6 |6 X5 O public void Process(){
1 a. D$ u( l; D5 n5 l) d' U        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
; G0 g3 ^5 \' E7 S& B        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
$ j& q* V6 M! v5 ]        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
  t; L4 T1 n/ L& W% p2 N) G        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

<P>        if(Judged==false){
          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
( _1 H8 f) U1 R, ^0 S# u: E              return;
0 |6 {$ V6 b4 ]3 V3 M$ D" n4 f3 V& l          }
2 E2 J5 g8 [5 ~) V+ y        }
        Judged=false;
; K5 b9 |  m# t; l2 b& K        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
/ d1 B9 V" ^' ?6 Y& E9 B% N        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
        deltx=(int)(VR*Math.cos(direct));
3 L3 ], ^' }' F: |" i, I0 ~        delty=(int)(VR*Math.sin(direct));</P>
<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
" B* y2 \0 I$ D* K6 K6 l' L( P<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
) Q/ m6 |8 J% G' {2 r- v        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
! V5 v7 ?9 J! ?8 S<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
9 [* k$ C6 z, `, q1 O! R; B" b          int deltx1,delty1;
* C0 v- [. n# U5 A, _          deltx1=deltx;delty1=delty;</P>
7 O" W! O. ~  L- Z. T<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
8 r: c# K) a/ e! O2 V          for(int x=-VR;x&lt;=VR;x++){
             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
- J! ~* K# O1 ~. p                //在这个程序中，坐标是循环的，也就是在一个球面上
  j4 L' f) r. {' H8 `* r9 H                int xx=(nowPt.x+x+width)%width;
. a# u0 w9 |5 P                int yy=(nowPt.y+y+height)%height;</P>
! X1 K0 x* u2 f+ [4 B. \! U, Q<P>                //循环的时候要除去当前点。
0 ~% A- X& u* Z& F                if(x!=0||y!=0){
. J8 A( o8 ]: U: q* U5 c! F                  //的到要搜寻的点的信息素
  S+ J+ x$ w2 E, _- I                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
<P>                  //如果搜索点的信息素比已经找到过的信息素多
* k1 U4 o6 H' H) {+ M                  if(maxphe&lt;phe){</P>
9 O3 |) ?4 t3 t) w5 v<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
; p7 x; n9 n+ Z4 K                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
8 D8 e0 |" b# O! e: v! V/ O  `% @                          boolean found=false;
6 C+ y" S+ O/ t/ T: a                          //查一下内存最近走过的memory的点数，从而避免当地转圈
* J) \/ w6 i0 U: X) A% C8 G                          int size=HistoryPoint.size();
8 l% Z5 k2 t8 P                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
7 H! X/ H/ L! |8 U8 V                          for(int i=size-1;i&gt;=size-minsize;i--){
  K& d( Y/ i2 @( j                             Point pt=(Point)(HistoryPoint.elementAt(i));
$ g) z* ^% D( i  q                             if(pt.x==xx&amp;&amp;pt.y==yy){
                                found=true;
                                break;
9 Z' D- t2 z! v# B1 T6 S                             }
                          }
. }3 R4 p6 @$ [) X                          if(!found){
3 v$ g1 B- J1 {% |9 G; B- Q# H: G                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
8 `( R! d/ H0 f! P                            deltx=x;
: X/ n0 V" R) y3 m' A* E9 U2 ]                            delty=y;
, \* ~; Z$ _7 Y! g' j5 u                          }
                      }//end here==0||ra&gt;0.001
: M! f. E4 [: `' W+ a7 g                    }//end maxphe&lt;here
0 @' ]$ t  t5 ~4 D                }//end if x!=0
            }//end for y
        }//end for x
        Point pt;</P>
& Z( F; e) O; s2 Z: W; Y! c<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
0 k/ H& m, T) n# c3 s8 i4 ^8 Z) O* G        pt=Evade_obs(deltx,delty);</P>
' B/ z* T! @$ X) w- P<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
$ o9 X! U. o+ T" x! @, `/ V        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
          pt=Evade_obs(deltx1,delty1);
. w5 }7 f# Q+ l/ n' u        }</P>
& \) S& X! l+ S6 d" V; n<P>        //播撒信息素
        Scatter();</P>
# l& M0 {+ }1 r1 e% N<P>        //记录走过的距离
' E  P) R* B* ?8 z% h& N) p        Count_distance+=Distance(lastPt,nowPt);</P>
7 e0 D! c6 }3 n' l5 ~  H<P>        //改变当前点位置
        lastPt=new Point(nowPt.x,nowPt.y);</P>
<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
) }: W) a$ R1 J) A5 F1 }        if(HistoryPoint.size()&gt;memory){
5 z" h& d! m, y' d1 n          HistoryPoint.removeElementAt(0);
        }
) M; s. C2 v2 H6 i. M! c        nowPt=new Point(pt.x,pt.y);
     }</P>
6 @  S  t% x- k, b3 ]- a9 h<P>
        private void Scatter(){
( Y: \5 c: E6 P2 T4 k        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
3 m( |, k( ~- h1 v* w& q        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
1 n- i  x* S  M6 A1 ^8 F            if(Pheromone_count&lt;=0)return;
6 c% ^! A+ [4 [' G% E; c  k: i6 `            //决定释放信息素的种类
9 q" t% J2 n) C3 O, i7 y            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
/ n- y- s7 h1 y& Z4 C$ q            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
5 U5 e# k( H+ h1 I6 `- c. G% |            boolean ofound=false;
+ v7 m: [- E& ]  a) H4 n5 O" P9 C            if(Phec!=0){
' l/ c0 K2 q7 w1 B: S7 X7 ^                //如果当前点已经有信息素了
                for(int i=0;i&lt;local_colony.phe.size();i++){
# ^0 q! S3 I0 C                    //在信息素向量中查找该点的信息
                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
. ]5 J) R  a: f$ |                    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;
8 D% G8 N; u7 Z# \" L; n" z                        boolean found=false;
4 @! ?7 o! U5 l9 p" ]                        if(size&gt;4){
+ {% f6 K- F0 y8 A                           for(int j=size-4;j&lt;size-1;j++){
/ v2 l# a4 n: R0 c: `& ^                              Point pt=(Point)(HistoryPoint.elementAt(j));
7 }; R) x/ S6 {( K2 e* a& g                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
4 }$ W3 Z  G( K8 P  z. P) ^8 ]                                //如果当前点重复了以前走过的路，就不释放
( O& w# I4 ~3 q- O- a% i0 r                                found=true;
                                break;
                              }
                            }
                        }
                        if(!found){
# V# e& C: z! O- o8 p# y                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
1 q" Z7 e0 [' o$ a( g- p2 |                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
( a7 Y% _9 t9 Q, ]1 [8 z0 ]<P>                             //让还剩下的信息素总量减少
                             Pheromone_count-=Phe;
                        }
                        break;
+ J: Q7 h# p. Y6 B3 ?8 o6 F                    }
( [4 d! ^7 c' w/ R0 g                }
3 r% |; O  o9 Z( @              }
5 p8 \; p) A' T; B& D7 e% }' a          if(Phec==0||!ofound){
            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
% x% k0 @' P6 z7 w                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
                ph.Add(Phe);
' u% S8 j9 z( G. j2 ]                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
                local_colony.phe.addElement(ph);
$ r8 M3 j- |6 I& I) H                //让还剩下的信息素总量减少
8 y( f. f2 T3 k% C                 Pheromone_count-=Phe;
           }</P>
- Z( E* t, \' v" s<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
) Z/ Y$ w* J& F# Z$ e- w# u, d           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
/ I; f. Z$ c1 {  u$ F: r5 t, @        }
; X2 ^  F) D8 W; v' v9 yprivate boolean JudgeEnd(){
    //这个函数判断是否已经找到了目标点
    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
2 n  a! ]/ M, H0 ]2 n) w' S        int i;
" n( g: X0 c  }* P7 }3 y9 u        for(i=0;i&lt;local_colony.EndPts;i++){
; Y$ E. [: q; q% r& U2 ~  {9 X            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
8 K0 x' t! Z" ]/ V. R              //如果找到了食物，就直接移动到食物点
7 |6 H+ _, g) o# O2 f9 G+ h              lastPt=new Point(nowPt.x,nowPt.y);
* d3 w+ R! g! P& E9 [* L2 Z8 ^              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
, y9 y& r! N' k8 `2 R2 [              //比较大小，记录较小的距离
  `6 {9 u" \9 L! a9 @# V4 g              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
              }
6 b6 n1 n6 f0 _# r; ]$ H$ ~( m              //清除总距离记录
              Count_distance=0;</P>
<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
6 q3 U( V3 _- x5 \              AimPt=new Point(OriginPt);
              StartPt=new Point(nowPt);
              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
' Y( w% z+ h- M( S1 f( @<P>              //找到了食物就把找到次数+1
: A: |' M* N5 B2 S8 b% P1 _              FoundTimes++;</P>
" @8 V7 a+ k' I- |<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>              //重新把自己能撒的信息素置为最大值
8 W8 @) E4 b0 q' L0 g              Pheromone_count=Max_Pheromone;</P>
0 d- P/ p$ G1 O<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
<P>              //返回找到为真
7 T* o) U9 G7 J  y              return true;
7 e- Y$ k% o% k1 y4 Z' N            }
        }
      //否则没找到
      return false;
+ P- R; D6 D! F% U    }
    if(kind==1){
; H+ O) |2 [  N; m: k/ x5 e' Q        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
1 e9 X3 P. ]8 L2 Y) K            lastPt=new Point(nowPt.x,nowPt.y);
            //如果找到了目标，就直接移动到目标点
9 g  v1 U# f. t) D4 H            nowPt.x=AimPt.x;
) @# |; M4 p% L6 T            nowPt.y=AimPt.y;</P>
<P>              //计算最后的总距离
8 a" n+ s) ?0 I5 k0 ^! R              Count_distance+=Distance(lastPt,nowPt);
6 Y0 l' G4 @- N2 R) c0 V              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
! y+ D/ [  v" B2 H; q                  Min_distance=Count_distance;
              }
5 ?+ v8 c0 s! x  q: c1 j              //清除总距离记录
) X3 K* U# {; I6 C+ x              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
) V9 H3 O9 s: }. Z6 T9 W7 o' w/ I            StartPt=new Point(OriginPt);</P>
<P>            //重新置信息素
+ N9 D$ F) n0 u* i1 H% s            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
' l, G- P* B  O+ R            HistoryPoint.removeAllElements();</P>
<P>            //主方向反向
            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
            FoundTimes++;
! O( b/ X5 N" q8 S7 P' h" @            return true;
        }
! L9 C& {( R1 O        return false;
    }
! l( i: U$ R0 V' I& L- s    return false;
  ]% S$ y& B; G}
        private double SelectDirect(){
1 O! {' ?0 ~  P: Q                //选择方向，最后选择的方向为主方向加一个随机扰动
! M" q8 _1 i" q; Z3 i( u* g+ P  l                double direct,e=0;
  O4 [7 B7 Q" A! T3 ^                if(Main_direct&lt;0){
0 s  W( J& t" S& x9 ~- T                      //如果目前还没有主方向角，就随机的选择一个
) y' \1 M# A5 r! u        e=2*Math.PI*Math.random();
8 G$ t% K4 @" A! @2 k7 }                      Main_direct=e;
                }
/ B$ Y' u- _, u+ [+ e1 U                //选择主方向角
8 O7 D( X0 p( N# \; p; N                direct=Main_direct;</P>
' N( H4 T' u; A; k9 v<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
                double re1=Math.random();
                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
2 |/ M9 q* m9 L! ^+ D                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
* t& I* q; o6 h$ w# l" p* F! D                  int size=(int)(re1*memory)+1;
, x2 A. ^6 b7 `5 A2 k" P/ F                  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);
3 N( `6 t2 O3 `& i& z9 a                    }
                  }
5 f' I- t$ N- s. V" {0 _& F                }
               return direct;</P>
<P>        }
        private Point Evade_obs(int deltx,int delty){
# q1 i& i( S2 P0 i9 f7 p              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
  Y& u: ~) `$ z, n8 _7 u              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
/ k. l! _1 L* e6 z1 I              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
" ]3 q" X1 o6 N) s/ \& B              //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;
              if(delt==0)return nowPt;
              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
; Y: o% v8 k0 Z5 S- y6 @  w                  x=(int)(deltx*t+nowPt.x);
# F0 j2 |9 X# O9 @  K                  y=(int)(delty*t+nowPt.y);
                  x=(x+width)%width;
                  y=(y+height)%height;
                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
6 r$ W/ l. L/ N8 n" z" S5 `' U                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
7 t) y) ]; z" B. d" r/ y                     double disturb=4*Math.PI*(Math.random()-0.5);
                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
                     break;
                  }
                  pt=new Point(x,y);
! C7 D) V- @& n9 o7 s! ^2 g                }</P>
<P>                //计算得出实际能够到达的目标点
- o, L" l" l+ E  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
         return new Point(x,y);
; F) d5 f& w8 D% c+ G" W7 U        }
6 r* `( j% h8 K( K, h' N        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
2 o8 G; h, F7 c0 T6 E; b# ~8 A3 l' e        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
        //其中方向角是所有可能的角中使得两点连线距离最短的角。
               double e;
               int deltx1=pt2.x-pt1.x;
               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
" h" @" h3 R# T% F               else deltx2=pt2.x+width-pt1.x;
+ F' @; Y# b& E! |               int delty1=pt2.y-pt1.y;
1 f7 ]0 b- g7 g9 Y/ _; q               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
8 _: n6 T2 z- A3 V4 I. x               else delty2=pt2.y+height-pt1.y;
               int deltx=deltx1,delty=delty1;
               if(deltx==0&amp;&amp;delty==0)return -1;
( Q. ~  B1 |8 p% V! K& r* o               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
+ F3 Z  z8 z* ]& l5 ]/ z    deltx=deltx2;
# d) j' {4 i2 X7 o1 ^, y               }
! X5 H& k4 Z6 u# c, l" z        if(Math.abs(delty2)&lt;Math.abs(delty1)){
* k* M0 f9 z6 G9 |                  delty=delty2;
               }
* g  U- _  F2 [- q0 y6 j7 l0 T               if(deltx!=0){
+ ?  O) @( W0 `3 i" d/ ~                    e=Math.atan((double)(delty)/(double)(deltx));
                    if(deltx&lt;0){
' M1 W) r- N# i/ y                       if(e&lt;0) e=e-Math.PI;
                       else e=e+Math.PI;
& v; y# Z+ r& z* U" r  i1 A6 B                    }
                }else{
                    if(delty&gt;0)e=Math.PI/2;
2 Q- M& o, g9 n/ \                    else e=-Math.PI/2;
1 [& F3 s2 l6 T6 J- x# w2 N                }
                e=(e+Math.PI*2)%(2*Math.PI);
7 T& J' |4 E& H                return e;
0 q% o8 t: y3 L- `  p        }
/ C0 [1 P8 ^1 f* l        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
& G' k- P7 E" z/ z, M* A        //这里计算的是所有可能距离中最小的
  P! Q0 p2 ?6 W) ?# M            int dx1=pt1.x-pt2.x;
            int dx2;
' Z9 b' Z. c. J$ k: h& r0 Q- H            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;
# x+ D6 {$ C% _' I, u            int dy2;
' `/ F3 E1 J/ t' i4 ~            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;
2 r- D. K& M0 |* F  w            else dx=dx2;
            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
            else dy=dy2;
! W" R$ V5 B& u. \            return Math.sqrt(dx*dx+dy*dy);
        }
2 K+ l# z8 a7 B2 x  \" E. e6 N    public void clone(ant ant1){
        //把蚂蚁ant1的属性拷贝到本蚂蚁
7 r- L6 ~' L4 Z4 {# D7 H! x1 ~2 {     nowPt=new Point(ant1.nowPt);
/ z' l4 u: w( w) d        OriginPt=new Point(ant1.OriginPt);
% m- c# \% c6 {! m        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
: b6 T( l5 n( R/ T8 h1 @  m        AimPt=new Point(ant1.AimPt);
2 ?' @1 u8 X( m+ d' M        lastPt=new Point(ant1.lastPt);
* ^2 O# s1 I/ ?5 Z. g4 ~0 q        VR=ant1.VR;
        id=ant1.id;
" {4 P! f7 ]* V( x0 s( H. l        color=ant1.color;
, f& R5 G% S' p  h. z2 t( E        back_color=ant1.back_color;
! a) S- Y7 F+ f: R& e+ {6 R6 S        height=ant1.height;
        width=ant1.width;
4 L1 f# X& j2 f: z* U        local_colony=ant1.local_colony;
        Phe=ant1.Phe;
        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
$ B  g$ R, T, U4 E& B; R$ O        FoundTimes=ant1.FoundTimes;
        Max_Pheromone=ant1.Max_Pheromone;
! U2 H1 {$ B! R3 R* U        Pheromone_count=ant1.Pheromone_count;
! r  y) K& w$ n# P        memory=ant1.memory;
2 j4 c6 v5 p: F2 v& x" R3 \: G        Count_distance=ant1.Count_distance;
6 m9 u. h, _2 D9 w, R% e        Min_distance=ant1.Min_distance;
% j, k; ^" ~( B8 {# u) o    }
# ^  k5 @" p0 s. c( Y# }}</P>