[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
5 x8 [+ Y$ p% u4 q3 X8 a, h<>package ant;
/*
* @(#)Antcolony.java 1.0 03/05/22
*
* You can modify the template of this file in the
5 g, h& e5 Q8 E) O3 r& D9 p5 z& b" Y * directory ..\JCreator\Templates\Template_2\Project_Name.java
, ^, G1 x, s5 G  Y% ]* b4 ]7 Y$ m' z *
* You can also create your own project template by making a new
* folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
! T& ?9 g- z* i9 D* f2 q! y+ ]% U *
*/</P>
<>import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.util.Vector;</P>
<>class AntCanvas extends Canvas
# _. |/ w5 o5 B# Q) W! _0 B: a{
7 d; ]# {" a+ P* h3 p: c& s    //画布，一切画图操作均由该类完成
//Image image;
Color obs_color;//障碍物颜色
Color origin_color;//我的颜色
  `3 F! Q0 D) A: z) u; X- l Color back_color;//背景色
        Color end_color;//食物点的颜色
& f7 A# D: Q# O" K //boolean first;
! P- d) O$ l1 `( Z+ N) L7 J boolean reset;</P>
<>/* public AntCanvas(Image img) {</P>
+ D. i7 W8 N( d. k" c) o( e, H& b<>  super();
0 C8 L/ B, C9 C, }9 d* O% s0 p0 d9 e   image = img;
  obs_color = Color.white;
0 O6 M( W8 U& k7 X) A$ U  setBackground(Color.black);
: l! n7 u: M# l5 X  setForeground(Color.white);
  }( ]  }0 r4 |3 d# y) |1 M  first = true;
6 Q" O  J. j4 q& g' w- H  reset = false;</P>
<> }*/</P>
, b' v. l* `' Q+ C& ~/ _<> public AntCanvas() {</P>
<>  super();
* s; _" t7 D9 w1 R/ t! H' O( z/ ]9 A' b   //image = null;
- @  G4 ~5 q  c: L   back_color=Antcolony.BACK_COLOR;
. B* a+ j: o% |) u& q2 U  setBackground(back_color);
  setForeground(Color.white);
  obs_color = Antcolony.OBS_COLOR;
  origin_color=Antcolony.ORIGIN_COLOR;
- r; \% T% a9 k7 r                end_color=Antcolony.End_COLOR;
  //first = true;
  reset = true;</P>
<> }</P>
1 t) l/ @# P. |1 N, C  C<> public void Clear() {
4 ?3 e7 g. J( P" R0 i3 \        //清空画布
  reset = true;
  repaint();
7 u  o" X6 _$ Q0 E; r! y }</P>
- D2 s5 S; @/ L( ?5 `$ J<>
public void paint(Graphics g) {
0 H1 L# ?; ~, o) S: Y, ?. G  int i;
' p% ~( o+ b  P7 d                //重画的时候仅仅画障碍物
2 M# k9 _, G9 H2 I/ [0 t2 u  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
* i6 v6 r& [7 B" n" K, `* M3 D  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
% B  \- ?2 _( p$ W) n   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
<> }
; J" o' v7 r* @5 c9 Z public void process(){
+ ?; V9 T# {- W, c8 ~" D        //处理动画的过程
7 E# a& m3 W& B# J  c9 k  Graphics g=this.getGraphics();
                g.setColor(end_color);
   for(int j=0;j&lt;Antcolony.EndPts;j++){
# t# C5 z0 O+ r1 H                  //画所有的食物点
* M5 t: \  V9 H0 U2 d! c( C8 T, q                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
                  //每只蚂蚁开始决策，并画蚂蚁
; a: G  s3 b) N0 ~0 I   Antcolony.ants.Process();
& p0 r6 \" w  p! Z' ?   Antcolony.ants.Draw(g);
  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
* C5 P' u2 {) U  u2 z0 Z                        //Antcolony的drawPhe变量标志是否画信息素
/ ]* @- w. ]9 q/ K, z' Y9 R" k                        switch(Antcolony.drawPhe){
                        case (1):
                            v.Draw(g);
% A) S+ ~  A% A, d/ V                            break;
                        case (2):
                            if(v.kind==1)v.Draw(g);
, j; D2 a  Y0 r+ x& S( S% _                            break;
                        case (3):
                            if(v.kind==0)v.Draw(g);
+ N4 t( z: |" ?( v; u+ b! k: k                            break;
3 d3 H  u. B; D                        }
                        v.delimit(g);
; N- i+ }4 a4 }* X/ c                }
           g.setColor(origin_color);
                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
& [0 ?& Y: S( I' I1 P2 W- P                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
& P$ x) ?' U% v7 p6 F; ~( n6 e                }</P>
, Q+ N" x2 u+ a* p3 P. V<> }
Graphics GetGra() {</P>
<>  return this.getGraphics();
) o1 g  h( `5 d) D, t3 V1 u }
}
public class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
static Color OBS_COLOR=Color.red;//障碍物的颜色
static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
% a) W+ F* x. B" c static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
5 p# e! B( N' V, \9 u; K4 C        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
1 N  j3 N$ a( ]' t) ?        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
& V4 `; _8 b4 U2 c" h) a6 D  B static Point OriginPt[];//窝点信息
# S( x* @- L! U0 K. S2 ?        static int OriginPts=1;//窝的个数，最大为100
static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
, u! ?# ]2 r0 q' i        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
% k" E  I' f. `6 A8 P, U% j7 M        static int FoodR=10;//食物和窝产生梯度的信息素的半径
static ant ants[];//蚂蚁数组
        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
) @% F' v7 v, {- ?% D. u int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
/ G3 Q* E& d- F4 s        Button btnStart=new Button("开始");
* u5 U& c; ?1 ]; g+ B( p4 ]        Button btnReset=new Button("重来");
        Button btnMap=new Button("编辑地图");
# z) {+ c; n7 d6 I" R        Button btnConfig=new Button("设置");
- v3 a- v& \! D        Choice choPDraw=new Choice();
public void init() {
                //初始化函数，先画各种控件
; X7 r2 {+ @  v8 c  q; t7 w" |  setLayout(new BorderLayout());
                Panel pan=new Panel();
                add("South",pan);
                this.add("Center",canvas);
                pan.add(btnStart);
$ u6 D! P6 _! G5 T$ D                pan.add(btnReset);
                pan.add(btnConfig);
                pan.add(btnMap);
, W& K  i! k' d8 C                pan.add(choPDraw);
                choPDraw.addItem("不画信息素");
2 n& l: ~4 W. K% G8 k4 v3 x                choPDraw.addItem("画所有信息素");
# d- _1 O( B# Y9 q                choPDraw.addItem("画食物信息素");
                choPDraw.addItem("画窝的信息素");
1 }4 P9 `' F: i; d+ ]8 r  L% C2 L% v                choPDraw.select(2);</P>
<>                //初始化各个数组
  obs_grid=new int [width][height];
+ y3 ?. Z+ |7 J. n9 Z                phe=new Vector();
                Pheromone_grid=new int [2][width][height];
- B7 L! x+ r* E0 K. B( q5 ?                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
) k& P. v# M, s5 i3 U    obs_grid[j]=-1;
1 n! `  K# x3 |) e                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
   }
  }</P>
0 b6 w9 v7 q5 X; T, q7 Q, [<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
) b! f0 T( N" e# J& W: n  ants=new ant[antCount];
6 ~7 q# s4 S) O/ [& l        for(int i=0;i&lt;antCount;i++){
. h/ F/ m5 {, X9 @$ p2 D          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
( h! J2 l, ?' z! c$ w, E$ P  }</P>
! x/ {  P- e  @<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
                int grid[][]=new int[width][height];</P>
6 w+ \4 j  V+ [<>                //下面从地图库中加在地图
                Maps maps=new Maps();
                maps.LoadMap(grid,0);
* u) E; _* g+ b5 C                //初始化地图
5 m" @/ E# g2 X1 Y) b                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
  reinit();
}
        public void reinit_map(int grid[][]){
                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
; I1 q3 y( R5 j* l# f- z$ @" C# r$ \                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
( w8 j$ }, _5 }5 l+ h2 m+ z# ^<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
6 Z2 v5 I) s( {9 e7 j0 ~6 n<>
# ^) i9 }1 w4 w                obsCount=0;
                EndPts=0;
! j; [3 J/ q; X$ }                OriginPts=0;
2 w9 w" u3 @+ U                obsP=new Point[width*height];
6 D; }8 T7 ]& V4 Q* G, N. F# h                OriginPt=new Point[100];
" v$ }, \/ `5 `3 }  _                EndPt=new Point[100];</P>
: F) c* Q. n0 A! z<>                //清空obs_grid和Pheromone两个数组中的值
                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
- D6 P0 o. Q- @1 e! c    obs_grid[j]=-1;
0 J' T4 f- y$ v0 J3 Q1 d1 l0 ?                                for(int k=0;k&lt;2;k++){
3 n) r- U7 z4 w9 i$ [4 G* i9 S                                  Pheromone_grid[k][j]=0;
3 J- K% `7 d; ]6 ?9 W+ ?4 d6 \; `                                }
% D9 t3 f) n7 ]$ K" T6 Q   }
  }</P>
' c! c3 B! E4 j) n<>                //从grid数组中读取信息
1 E, V1 }, v  |: _                for(int i=0;i&lt;width;i++){
                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
" T( j8 v" b2 T: [* h; ~; ]                    case 1:
0 X  C+ W/ W2 t$ U                      //如果grid[][]存的是障碍物
: i! B) E& h4 V0 u                      obs_grid[j]=obsCount;
                      obsP[obsCount]=new Point(i,j);
                      obsCount++;
                      break;
                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
4 J- X+ C/ A' j                          OriginPt[OriginPts]=new Point(i,j);
+ F( |1 a  `9 T( K+ @                          OriginPts++;
5 B7 O" k" ?! a4 _! R% Z+ ^  H                      }
                      break;
                    case 3:
. R- ]0 o! o0 g                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
- M! q9 O" o6 n( }$ V9 t) q                      if(EndPts&lt;100){
" S2 u  V5 Y2 T( m3 s6 }                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
' |* P6 U4 L9 ]+ U! ~                      }
                      break;
                    }
                  }
                }
8 V, z8 L! ?. H            //如果没有指定窝，则随机的选择一点
2 q8 H5 _; \) u0 k4 b+ @            if(OriginPts==0){
  C  C; e$ I# t" n2 w  p# e. Z) [              for(int i=0;i&lt;width;i++){
7 ^6 @! y0 z0 V6 G                int  j;
2 l# z3 p: p/ B: d& y                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
4 E- K( E4 \2 C7 c5 a                    OriginPt[OriginPts]=new Point(i,j);
$ v) y/ m- s! v+ d                    OriginPts++;
1 v/ B  }* i" I- A                    break;
( J% z; R: |& l9 T" Q                  }
                }
3 c1 V# f6 w8 w                if(j&lt;height-1){
                  break;
                }
  P8 e2 Z+ f. X, v! b8 W, k' X8 ?              }
  K) P, {+ V: E0 C0 M- b            }
        }
. x4 q" A8 `5 ]4 k. b public void reinit(){
                //重新初始化整个环境</P>
<>                //先停止程序的运行
                running=false;
: N0 E/ v/ W2 {; }) d$ o0 g1 p7 p                btnStart.setLabel("开始");</P>
<>
  //清空所有信息素Pheromone数组中的值
) S  C+ r" }+ B' J# e                for(int i=0;i&lt;width;i++){
2 _1 l: R& @6 k5 p0 P, \' u   for(int j=0;j&lt;height;j++){
, j% D- G6 d' g* s4 _, S                                for(int k=0;k&lt;2;k++){
: a* h! A  H9 H% J7 j6 O* v& Q( ^                                  Pheromone_grid[k][j]=0;
' G' E1 q' t8 I3 @) a3 N, A4 M                                }
   }
/ J- e' y2 i5 L8 C6 V  }</P>
$ i, V9 l& ]+ T( Y' H( c<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
4 N" K6 D/ D! s                        int index=(int)(OriginPts*Math.random());
          ants.OriginPt=new Point(OriginPt[index]);
( p& k, G( c+ S                        ants.init();
/ ]' s! K$ y5 S1 P2 b; G* _  }</P>
4 F+ q3 @8 u" q<>                //清空信息素向量
3 A& V4 h: |0 G( ~7 g, Y                phe.removeAllElements();</P>
<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
  for(int i=0;i&lt;EndPts;i++){
+ y! L* K4 ?4 n, h+ k                   for(int x=-FoodR;x&lt;=FoodR;x++){
% a2 o+ S; s0 z3 }8 U' b" s4 m. [4 i                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        for(int yy=-y;yy&lt;=y;yy++){
0 L* o1 H" ?/ p8 _! s8 e                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
( d0 k( S" O  p7 y5 }3 o% d; [/ v                    }
0 S4 t$ k7 G6 v8 `' F" P& F                }
/ ~3 A$ O) q* Y9 Y6 Z                for(int i=0;i&lt;OriginPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
: T( @1 Y# f, k$ K/ x                        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));
+ D; t. ?, t3 F1 \- ~# j$ r                        }
                    }
                }</P>
<P>                //重画
  canvas.repaint();</P>
, _5 K- w. I3 b( f; ^+ X8 H<P>                //让程序开始运行
5 v3 \/ k& V$ B- n                //running=true;
2 G9 k4 ^3 h  ?$ X3 x: D }
+ R, `9 z! K) ?5 l public void paint(Graphics g) {
, A# x( b4 |: \3 D2 ^( ^  canvas.repaint();
  T& f: i. L# ^+ D7 j; r: [# s& g }</P>
/ Y2 Y4 S( n$ ?; Y0 _6 ~8 q<P>
public static void main(String[] args) {
( }' ^. |& k" ^" K! D    Antcolony applet = new Antcolony();
3 @- L+ E5 ]* k; |    applet.isStandalone = true;
    Frame frame;
    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
7 v3 q# J/ e, p5 A$ e        super.processWindowEvent(e);
$ o9 m, l3 s. ?% P9 W8 M        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
: X, P  V' ?6 M4 G4 F) F$ A8 ]          System.exit(0);
        }
      }
      public synchronized void setTitle(String title) {
% z7 \  c. N% s' _6 x        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
7 @1 H* I7 h) o. z6 x    };
, y& I: ?( u% m3 `    frame.setTitle("Applet Frame");
0 I$ b/ X/ E& G2 ~; Q! `8 F    frame.add(applet, BorderLayout.CENTER);
    applet.init();
    applet.start();
2 c4 Q3 @2 O% ~& f3 J0 o    frame.setSize(300,320);
2 Q# b  }# C" b5 t# ~: t    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
0 ?! Z! E, @+ M1 H, i$ }4 k    frame.setVisible(true);
  }
  public void start()
$ U! ?) W$ h' i  //下面三个函数是控制线程的
{
7 T* p( j$ O, [5 n9 I6 u$ n  if (runner == null)
  {
   runner= new Thread(this);
3 A% r% }$ J  H7 P" \* o   runner.start();
   //running = true;
% f+ k, @/ v: b  }
}</P>
<P> public void stop()
# `, X9 n: k( V! v9 [# l! I3 }0 J  z {
  if (runner!=null)
5 x# `* G2 Y4 m4 X; ?, I  {
   runner.stop();
6 ?' f$ B9 o# P   runner=null;
) B; B5 W* e0 g2 C1 e3 L; V   running = false;
  }
5 D$ I7 N: z8 G! X1 t$ Z( H% g }</P>
<P> public void run() {</P>
! o" A7 M  x3 E<P>  int i;
                //线程一直运行下去
  while (true) {
          if(running){
       //如果开始动画，就进行canvas的处理
: L( t# C3 \* v6 v                          canvas.process();
6 W( P2 V2 G6 W                        }
    try { Thread.sleep(delay);}
  D6 v* H1 U' i; c; b    catch (InterruptedException e) {
   }
  }</P>
4 P3 t3 ?$ h, u$ X1 A& ?<P> }
  F/ Q0 v* g8 T3 S        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
1 J" _$ O: x/ H1 q/ y* B' \                //开始编辑地图面板
   running=false;
                        btnStart.setLabel("开始");
# V( X. R" {" Q. C; r5 u. N3 T   MapPad ctl = new MapPad(this);
) F7 @* l" M2 o  z% G+ }2 v                 ctl.setSize(308,380);
7 R8 H) i# I) C, d0 J                        ctl.show();
5 O$ A2 g. {. f, U' L                        return true;
( o# L; x! Y0 A/ I' E3 E. m7 [  }else if(evt.target == btnStart){
  S4 a  `  K9 z                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
                    btnStart.setLabel("停止");
" u, S: E' l+ e2 b* L9 l7 W                    reset=false;
                    running=true;
                  }else{
                    btnStart.setLabel("开始");
                    running=false;
                  }
                  return true;
                }else if(evt.target == btnReset){
                  running=false;
                  int j=0;
" l/ R# z+ ~- p" }2 c                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
9 m; K% u5 G3 L. o3 G' ]: s8 C                  repaint();
                  btnStart.setLabel("开始");
) i6 c# j4 g5 {0 v# B; q                  return true;
                }else if(evt.target == btnConfig){
                        running=false;
- c" N2 @$ r7 U& P& Y                        btnStart.setLabel("开始");
  P8 ?! {, o+ c" {% ]7 W& x& w     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
                        ctl.show();
                        return true;
                }else if(evt.target == choPDraw){
! T2 L4 c4 W1 f, G5 S' K4 ^                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
                  return true;
                }
$ ~5 B& G8 C; V) C5 l7 G                return false;</P>
+ w9 H& h1 |" x. M( F<P>        }
/**Destroy the applet*/
  public void destroy() {
  //当结束程序的时候，把线程也结束
    if (runner!=null)
# k) ^2 J3 }6 ~. `# Y# E/ J* G( o, i    {
9 y* F# t! f4 k* i" D$ h- ^; p       running = false;
% @8 P8 g2 E* y5 P& c; `- C       runner.stop();
6 T/ p9 y6 O) W       runner=null;
    }
* q2 c$ S# K/ y1 {$ ^& j  }</P>
8 L  J' D! w6 Q% C4 C$ u0 z<P>}
, _5 ^7 J' k2 K0 I2 P</P>
# ?8 D1 e) a0 `5 s; k# ?- l


<P>package ant;
import java.awt.*;
import java.applet.*;
import java.util.Vector;</P>
<P>public class ant{
% h7 c$ c5 e: P) Z/ C& u Point nowPt;//当前点坐标
( `+ a1 J1 g% C int VR;//速度，每次蚂蚁能走动的最大长度
8 m8 H# p3 G# d7 J1 @0 Y0 l) c  int id;//标识
  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
, N; Z  |& t0 y  A Color back_color;//背景的严肃
int height,width;//世界的尺寸
        int Phe;//每次释放信息素的数值
Antcolony local_colony;//主程序的指针
        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
! b5 `. }! f- \) Y) s3 v! U/ ^        double Main_direct;//主方向
0 {& g1 ]* F9 M1 Q1 E/ T5 Q        Point FoodPt;//记录的食物点，是否找到时候判断用
. T( g2 \2 @9 k* c, F3 U* _        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
0 V( y0 s9 ]. `        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
# b* V, y2 b2 P; S        int Pheromone_count;//当前还拥有的信息素的总量
5 M/ {! d5 \% ]7 d5 o        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
8 J; o2 q# ?7 l# y: h        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
2 b  ^7 G1 {- c- b        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
( i3 ~" b# H  V  B6 S( j        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
  nowPt=new Point(nowpt.x,nowpt.y);
                OriginPt=new Point(nowpt.x,nowpt.y);
                FoodPt=new Point(nowpt.x,nowpt.y);
+ d6 K5 x1 j, N                StartPt=new Point(nowpt);
                AimPt=new Point(nowpt);
                lastPt=nowPt;
3 j' m3 q) q+ a! p; l" y  VR=vr;
% c# @$ p+ K" {2 ^  id=idd;
6 U8 `' \3 Z0 K, S3 U0 u! w  color=c;
7 t7 [/ W( d/ i$ U4 H( p' x  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
3 `5 l+ n2 w0 n9 b! x  width=Antcolony.width;
0 i1 _* e: L( }/ D3 ^$ V  local_colony=colony;
- t: y3 [3 x* y                Phe=200;
                mistake=mist;
$ C: w  G& c8 \! L# `6 j  @% |# z                HistoryPoint=new Vector();
                Main_direct=-1;
                FoundTimes=0;
                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
                memory=mem;
                Count_distance=0;
' ^) z: [0 Y) \2 ^; M# H                Min_distance=-1;
}
( p( m0 h7 C1 P) @, x        public void init(){
8 X/ i) t5 g0 d8 n3 l          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
. w1 X9 w4 B9 n4 O7 D. [+ R0 o          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
          Main_direct=-1;
          FoundTimes=0;
; l0 g" r# M$ b: K0 v; F. ]          Pheromone_count=Max_Pheromone;
          Count_distance=0;
          Min_distance=-1;
        }
0 \- S3 u6 R0 O8 x: j( L' o public void Draw(Graphics g) {
# t3 \7 |. y7 z3 _5 B- l          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
/ g/ D# S* T! G  g.setColor(back_color);
5 _4 V, w: l3 z9 |  h! J  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
4 F0 {& A' u7 f  g.setColor(color);
  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
}
( q! |) b! g6 w( u public void Process(){
7 ?! F6 ]5 ], }7 W4 \! m* n        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
- \' Q% L. f. g2 \2 S1 P" \  _        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
' d* S4 X' j8 q/ K4 j& {        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>
- ?; Z  Y9 k. T* e
% N6 I5 y+ }; `<P>        if(Judged==false){
* B3 m8 Z, O. X1 F          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
+ W5 m* G, Z+ r( m: t- K          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
% Y  h& L8 i0 M3 [: V              //判断，如果找到了目标点那么就退出该程序
! K) v6 q: S; q+ q! N; _( k              Judged=true;
# n+ Q0 T6 _8 f              return;
          }
        }
5 Q  ]: W. t( a* }  c$ i9 c7 ?6 @        Judged=false;
; P! g6 W/ s) l        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
7 C3 Q" a- i/ _# ]5 Q        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
7 a5 S! y9 F3 A3 A! \        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
. n/ u4 w0 I3 X  o' z        deltx=(int)(VR*Math.cos(direct));
+ c& T5 k' u: }6 T+ B9 j* v        delty=(int)(VR*Math.sin(direct));</P>
8 H7 a: s7 @1 e3 }* E<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
( |+ i3 Y0 ^7 F: C        int kind=FoundTimes%2;</P>
' {% I' M% w$ p" x2 d<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
# ?* g9 D0 q1 c) b7 l7 \4 v        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
! s4 ~( R4 B5 w, b        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
1 j: J: h3 t2 D5 T5 m9 [<P>        //记录搜索的环境中找到的最大的信息素
: R) |& Z2 Q; [! d* t; X* W        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
+ N2 @: }( h" m5 B$ K4 u5 F          int deltx1,delty1;
* o0 V, R9 n' F' h          deltx1=deltx;delty1=delty;</P>
<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
* F: O# w: y" z2 j0 C          for(int x=-VR;x&lt;=VR;x++){
             for(int y=-VR;y&lt;=VR;y++){
, t6 K/ D) [2 P# q                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
) S' i( I2 s1 g                //在这个程序中，坐标是循环的，也就是在一个球面上
1 \4 V1 _; N1 L6 C! _                int xx=(nowPt.x+x+width)%width;
5 v% l+ `1 _) B5 A0 Y                int yy=(nowPt.y+y+height)%height;</P>
) M# v" R( s) K/ L- X9 K; ]8 |) y<P>                //循环的时候要除去当前点。
9 l! B4 F( u' D- s1 `7 ]4 f0 S                if(x!=0||y!=0){
# z3 }+ L4 o4 P) M                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
9 g  Y* L6 p/ t. w9 y8 f( O$ u<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
4 o1 w, p! }" w1 [                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
                      double ra=Math.random();
4 d5 y" f  w6 r1 y: W; V5 f                      if(here==0||ra&gt;mistake){
                          boolean found=false;
# ~& @+ m, A. T6 S4 W: v$ M                          //查一下内存最近走过的memory的点数，从而避免当地转圈
9 E. }; P2 w. H( u( Q$ P, j* C                          int size=HistoryPoint.size();
                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
' V& \# z% I/ `4 o! S! H0 T! ]0 Z                          for(int i=size-1;i&gt;=size-minsize;i--){
( U% N6 e, Q8 b3 f! `                             Point pt=(Point)(HistoryPoint.elementAt(i));
                             if(pt.x==xx&amp;&amp;pt.y==yy){
                                found=true;
                                break;
7 D# R! G% P  B4 A                             }
                          }
% q, J2 ]# O. o' n6 A# m1 R                          if(!found){
                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
5 a. r" }* B: k- \4 Z                            deltx=x;
                            delty=y;
                          }
  T" \, U: K6 Y( O, \5 k# g                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
$ X/ J, }0 ]& @) ]0 Z; @                }//end if x!=0
            }//end for y
0 F" y- ]! X) r9 J4 h        }//end for x
        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
' Q  c4 c, R7 i4 {" M  v        pt=Evade_obs(deltx,delty);</P>
, b  X8 [& A3 p* _* K<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
7 i* t9 |" ^! m          pt=Evade_obs(deltx1,delty1);
        }</P>
( M" O$ q% }+ u6 |<P>        //播撒信息素
        Scatter();</P>
<P>        //记录走过的距离
+ Y5 L' t, I8 W) }  C        Count_distance+=Distance(lastPt,nowPt);</P>
1 k* E1 x+ {6 J$ }( d. y; v<P>        //改变当前点位置
        lastPt=new Point(nowPt.x,nowPt.y);</P>
9 c+ v4 b8 I* i+ \<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
        if(HistoryPoint.size()&gt;memory){
9 ^+ n' T7 ?* I2 e% S4 e0 o          HistoryPoint.removeElementAt(0);
        }
/ \! {/ f8 J/ Z1 O, T6 F' C        nowPt=new Point(pt.x,pt.y);
     }</P>
<P>
        private void Scatter(){
7 @# D& S; t6 b9 @9 x        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
, E2 B, S+ C, {: N! W* @        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
( f$ {# s; S2 a5 X# r2 h            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
) G8 N- a% @* D' g            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
            boolean ofound=false;
% @$ b/ M1 V: B            if(Phec!=0){
                //如果当前点已经有信息素了
8 F& c. F$ M( k/ I7 B: }                for(int i=0;i&lt;local_colony.phe.size();i++){
                    //在信息素向量中查找该点的信息
                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
# b" _1 G+ U+ ]1 ~9 P$ A                    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;
2 u3 v: \  }8 d' r3 F6 ?                        boolean found=false;
                        if(size&gt;4){
9 [4 f, }1 m" v                           for(int j=size-4;j&lt;size-1;j++){
                              Point pt=(Point)(HistoryPoint.elementAt(j));
( T5 C- c4 o2 G$ {1 Z& X  I                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
# e$ }' [: C9 x' Q  R! n! C$ [                                //如果当前点重复了以前走过的路，就不释放
) \: L4 V7 Q$ D  r# Z; c1 N                                found=true;
                                break;
0 U3 ]- B) E3 a7 C5 e$ \7 d- v* w. b                              }
% A1 \& U! u4 X2 W! H                            }
9 u7 A/ X2 J0 V0 e0 O1 B$ s2 r: ~                        }
                        if(!found){
                        //如果当前点不重复，则开始撒
9 p9 Y% s7 T$ X. m/ N                             ph.Add(Phe);
3 w. }1 ?) |7 o+ w3 K6 H                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
<P>                             //让还剩下的信息素总量减少
3 c" c; A) O3 I) a" g  s                             Pheromone_count-=Phe;
                        }
                        break;
+ ~+ i! |$ N4 L0 _* c                    }
                }
, k5 i6 D' G' w0 S1 V( s+ r              }
8 F! g& V6 _0 z7 I( m          if(Phec==0||!ofound){
: ?' d) h7 }$ s2 h            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
                ph.Add(Phe);
- T+ `/ d, h$ c( M3 j& h                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
8 E2 o9 o% x$ b( B                local_colony.phe.addElement(ph);
, a" y8 X9 s+ {' S' V                //让还剩下的信息素总量减少
                 Pheromone_count-=Phe;
2 P' F7 l0 [% w2 }$ X& q5 B           }</P>
<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
0 d0 G, W! ~; C# b" T" S  `7 D           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
, y& q$ a7 i# R+ e0 z! o- e           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
# e, t7 L" l8 S6 Q7 E: r) [           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
        }
6 [# f" X0 V- pprivate boolean JudgeEnd(){
    //这个函数判断是否已经找到了目标点
    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
$ o7 e' V  t( L9 |        int i;
        for(i=0;i&lt;local_colony.EndPts;i++){
; N& v1 o& S3 }$ s            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
              //如果找到了食物，就直接移动到食物点
              lastPt=new Point(nowPt.x,nowPt.y);
# {( Z" z5 q- s' y1 P9 C7 L  `% N              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
<P>              //计算最后的总距离
! G! ~3 `" A0 [+ l' }" w- f              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
* x2 p4 N" d  L' W4 h$ @              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
# ^/ h0 ^( e. b9 s% Z                 Min_distance=Count_distance;
/ ^6 z0 a8 U% l: x, l) g              }
              //清除总距离记录
- M: I) ]+ z0 B( U- r  [              Count_distance=0;</P>
<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
              AimPt=new Point(OriginPt);
0 ?  ^% X: z9 ?0 Z9 ?# F              StartPt=new Point(nowPt);
, Z7 M. Q5 c2 l, e; q, D              //并把当前点标为自己找到的食物点
. _# l. n0 ?1 F! a& U2 b: t              FoodPt=new Point(nowPt.x,nowPt.y);</P>
<P>              //找到了食物就把找到次数+1
& |8 m' U5 {. l3 ?, J, P              FoundTimes++;</P>
' x2 o! f+ |6 q  P$ G; [& Y<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>              //重新把自己能撒的信息素置为最大值
              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
$ G2 a9 l/ @# [' _<P>              //返回找到为真
              return true;
            }
6 F5 T, @3 ]( D% @% V( b3 ~        }
# _! a# d+ u% j1 a: {# G. S      //否则没找到
0 }: a* h7 K( [3 q, `      return false;
6 e  u7 K+ k! d2 ~    }
/ K6 N2 A/ z1 V3 t# n    if(kind==1){
        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
            lastPt=new Point(nowPt.x,nowPt.y);
$ i% M/ z1 s* |  c1 g) ^, s' B2 s            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
" C2 D8 g! R  ~8 |( w2 v            nowPt.y=AimPt.y;</P>
& D8 _. i# c, Y4 A6 R<P>              //计算最后的总距离
- ~7 q$ v& A0 N5 S              Count_distance+=Distance(lastPt,nowPt);
% G3 J. {8 }1 y3 z5 ~- Z              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
( m. _( U& p  v( ]                  Min_distance=Count_distance;
              }
& Y/ r4 L& |  r3 V* J. ?) ]) _. H$ m( a7 d              //清除总距离记录
              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
            StartPt=new Point(OriginPt);</P>
<P>            //重新置信息素
            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
' ^( t2 w+ J3 y6 O; H<P>            //主方向反向
; S. s9 h- I# E9 b- G            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
            FoundTimes++;
3 E; |  P7 X8 F! a4 }0 J9 W            return true;
        }
        return false;
    }
    return false;
( k7 X5 P1 t6 j+ `# Y( H; {}
        private double SelectDirect(){
/ \4 K2 o: s* l. f1 j, j8 a                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
7 o! O; }6 g* y+ l4 E+ ?" W1 @                if(Main_direct&lt;0){
' N1 h4 B4 f/ m' b# {                      //如果目前还没有主方向角，就随机的选择一个
; r6 M/ y+ |) x0 \, R" q& H  J1 J        e=2*Math.PI*Math.random();
4 |! H# Q7 U' \: c1 e) ]                      Main_direct=e;
                }
                //选择主方向角
: X& `. h: o, H' d                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
+ N& V4 w4 K' j; L# j$ c                double re1=Math.random();
                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
; r. J4 V* w) G  K                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
( z% W9 `6 E& H# H% Z2 Q                  int size=(int)(re1*memory)+1;
9 P! e) z4 j0 J; @( s1 c                  if(HistoryPoint.size()&gt;size){
& V) X( f3 ?$ L4 z0 W' {                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
& x8 c+ N3 Y2 U0 b% q; M                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
                       Main_direct=GetDirection(pt,nowPt);
3 w8 u+ V" L1 B+ b* L5 I, T                    }
2 ~! W  K4 J: j                  }
                }
               return direct;</P>
<P>        }
- L4 Z9 S& ?; g' k        private Point Evade_obs(int deltx,int delty){
3 A1 V" i* e- T5 R5 ~              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
* x2 M8 T. q' v5 Y* W$ |; M9 E              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
" D' ~* {/ J  I. t1 i  K              Point pt=new Point(0,0);
              int x,y;
              int delt=deltx;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
2 s5 O1 c* r6 K' b: S0 d4 P0 e" h              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);
, k' ~5 Y+ u# H                  x=(x+width)%width;
                  y=(y+height)%height;
                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
# k8 R6 q' b. G<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
; K: @5 H) c+ D, ~" n1 N                     //新目标点为障碍物前方的点，主方向随机取值
: Z. K- K+ f4 B% G                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
1 A' B5 H& S3 N4 x, ?6 |                     double disturb=4*Math.PI*(Math.random()-0.5);
) f5 ?, N9 n0 x. F/ ^& X                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
& q9 t0 g& ?* W# Q                     break;
                  }
                  pt=new Point(x,y);
3 U0 d/ U, M5 t, R. @. p$ N9 @3 X) B                }</P>
<P>                //计算得出实际能够到达的目标点
  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
5 N0 L% ]& }- W, I( A         return new Point(x,y);
2 m# C9 K. d$ @' J5 D7 e0 u+ V        }
5 M$ a( M% z" V- u# Q8 X- k9 Y2 q9 u        private double GetDirection(Point pt1,Point pt2){
/ W# N  ?* M* j. ^, E        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
) E' G6 N9 U  f9 M" E; ]7 B1 }1 B        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
        //其中方向角是所有可能的角中使得两点连线距离最短的角。
, u) `/ }' _" j0 w8 e% x& g# i               double e;
               int deltx1=pt2.x-pt1.x;
# b  l( r$ U4 x7 o3 U  y/ }               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
9 ^5 a: l& G+ O" e4 l8 C$ A               else deltx2=pt2.x+width-pt1.x;
5 f5 k/ C) O- S               int delty1=pt2.y-pt1.y;
               int delty2;
8 U" N6 U7 B+ m5 _& ?3 Y& L               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
               else delty2=pt2.y+height-pt1.y;
6 f+ b* m3 q) C& p: _  A9 b1 P               int deltx=deltx1,delty=delty1;
               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
$ w# I5 {& o  b( ~9 ~    deltx=deltx2;
; _8 h' m; s+ U9 ]6 v               }
        if(Math.abs(delty2)&lt;Math.abs(delty1)){
. c8 m' h: V% I, [- b                  delty=delty2;
               }
               if(deltx!=0){
                    e=Math.atan((double)(delty)/(double)(deltx));
                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
                       else e=e+Math.PI;
& X6 \6 Z( b# f3 z! x2 y                    }
                }else{
                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
2 }7 g& n6 R6 ]! a7 y/ u                }
                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
! e1 H  Q$ \- I        }
        private double Distance(Point pt1,Point pt2){
  {4 s' E2 b/ q) W7 b0 @6 d        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
* V$ ?- y) Y( }& i. w  j            int dx1=pt1.x-pt2.x;
            int dx2;
            int dx,dy;
            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
            else dx2=pt2.x+width-pt1.x;
            int dy1=pt1.y-pt2.y;
0 k/ E! t' \" x7 F  t% Z8 G  S            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;
/ d- I5 C2 y$ c7 E. g7 p& t1 q) e            else dx=dx2;
* E/ I: _/ {# \# C$ g7 p            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
' ?% ~6 b- E* ?0 A: e8 R" w, t& U            else dy=dy2;
            return Math.sqrt(dx*dx+dy*dy);
, t# Z/ u4 u9 g* H3 l' b4 |/ ^        }
3 d( j0 R4 Y. s/ B    public void clone(ant ant1){
+ h1 H4 E; Y1 p0 O, p/ k        //把蚂蚁ant1的属性拷贝到本蚂蚁
     nowPt=new Point(ant1.nowPt);
        OriginPt=new Point(ant1.OriginPt);
        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
6 ~9 P/ u0 Z: x/ r        lastPt=new Point(ant1.lastPt);
# `: c9 A7 r# e- W- l  J% K        VR=ant1.VR;
9 U  t: u0 Z+ h( S% ?0 ^5 v        id=ant1.id;
        color=ant1.color;
, [- t7 S  f0 l8 z0 Y+ u8 @% N+ `: P        back_color=ant1.back_color;
        height=ant1.height;
$ v+ `8 v" X# n) s( H  N        width=ant1.width;
$ L( l7 f5 L& m5 |4 E# S; n+ F; E! Q        local_colony=ant1.local_colony;
        Phe=ant1.Phe;
$ u8 N! A9 D0 m4 A. T  @( o        mistake=ant1.mistake;
4 Z$ C) n, E9 a  R9 \8 ]& D        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
! e. M$ p. P1 C& q% u% d( @        FoundTimes=ant1.FoundTimes;
        Max_Pheromone=ant1.Max_Pheromone;
) t+ g, i( Q, `# S+ g( z8 H        Pheromone_count=ant1.Pheromone_count;
( W4 b/ h! Y. e" J, c2 X9 I        memory=ant1.memory;
: n# N& g& J! V/ ^  n4 r% Z        Count_distance=ant1.Count_distance;
, j7 g7 y- D" q* `, [# ^        Min_distance=ant1.Min_distance;
    }
# q; M+ J8 j8 b! J' H  k6 a}</P>