[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
<>package ant;
6 d- }8 f6 i3 V8 b3 g$ O8 `/*
* @(#)Antcolony.java 1.0 03/05/22
*
$ X+ r% @- A  h; p8 X4 u * You can modify the template of this file in the
; [# n8 L- k( _* ]* |3 ] * directory ..\JCreator\Templates\Template_2\Project_Name.java
7 V6 ?% u$ t5 @1 U *
* You can also create your own project template by making a new
6 c7 E9 J8 n  Q) z& k: d$ R * folder in the directory ..\JCreator\Template\. Use the other
5 d; B/ |7 l/ M9 W: l6 ] * templates as examples.
! e& k3 X% w7 y1 T9 E) G *
*/</P>
; [) E" z8 p! m<>import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.util.Vector;</P>
0 j# c% J9 D" R: L- z0 p. `6 n<>class AntCanvas extends Canvas
{
    //画布，一切画图操作均由该类完成
8 [. a' H! A9 b2 j) j //Image image;
Color obs_color;//障碍物颜色
Color origin_color;//我的颜色
0 ~; [2 W! F- q8 g Color back_color;//背景色
        Color end_color;//食物点的颜色
% c- c/ M& {3 O/ e( R //boolean first;
1 z& Z" {1 P0 ^2 h  A  A* ` boolean reset;</P>
+ O. x) c' m& ^0 a<>/* public AntCanvas(Image img) {</P>
<>  super();
   image = img;
+ l9 N( k& R1 X" ~0 e  obs_color = Color.white;
  setBackground(Color.black);
  setForeground(Color.white);
6 {9 U. r6 V0 f0 I3 H: v4 I: H& ]  first = true;
  ^5 P5 S( ^2 h& d  reset = false;</P>
<> }*/</P>
8 ^4 ~! x' y# B7 Q. s<> public AntCanvas() {</P>
<>  super();
2 C) O1 G9 h/ O! n; T1 g& u1 n   //image = null;
1 `3 W5 k, R" M, `8 Z$ ]   back_color=Antcolony.BACK_COLOR;
  setBackground(back_color);
  setForeground(Color.white);
! X' S1 f3 E& Q/ x! F  obs_color = Antcolony.OBS_COLOR;
( I) @# n3 ~2 Y- L  origin_color=Antcolony.ORIGIN_COLOR;
8 j* S7 @9 a2 T                end_color=Antcolony.End_COLOR;
" }) t+ D# d) p" o( n1 H  B& ]7 b  //first = true;
' z& w$ A; O+ d! b8 S  reset = true;</P>
2 b5 r- d+ B% q1 `3 i. Q! L  b<> }</P>
<> public void Clear() {
        //清空画布
' p, ^3 y3 Q4 p! `+ R% }0 U3 I# |/ ?  reset = true;
# F( \0 S; l, p" O  a  repaint();
}</P>
<>
public void paint(Graphics g) {
  int i;
4 @! a; |  [% H                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
<> }
2 r6 }/ e/ g5 F: `3 E public void process(){
        //处理动画的过程
  Graphics g=this.getGraphics();
( `# [. Z. G/ F' |                g.setColor(end_color);
   for(int j=0;j&lt;Antcolony.EndPts;j++){
# K- H, P0 R- G: a) A                  //画所有的食物点
                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
3 x* }, R' q1 K6 N! Q                  //每只蚂蚁开始决策，并画蚂蚁
   Antcolony.ants.Process();
   Antcolony.ants.Draw(g);
& X" S9 S7 C0 R$ I  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
! A: v! {; s$ |. i. T5 f' _; z! V4 \                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
                        case (1):
. D2 r+ g4 `5 n( X% N                            v.Draw(g);
                            break;
                        case (2):
                            if(v.kind==1)v.Draw(g);
+ L7 a6 \8 D/ c; j2 \$ Y. Q                            break;
; g) @2 Y  C; Z. T; b( t1 ~* }0 J' T                        case (3):
                            if(v.kind==0)v.Draw(g);
                            break;
                        }
+ q# n9 ]5 G* s: z( Z7 g& P3 C2 P                        v.delimit(g);
                }
, j1 d5 y& m9 r! g1 g  c           g.setColor(origin_color);
) j+ @2 H  O0 g5 a' d  L                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
( Z2 |+ {, g2 ~                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
                }</P>
( J1 b1 G3 [/ y<> }
( @/ @9 b. f, u/ ^# D3 `2 ` Graphics GetGra() {</P>
<>  return this.getGraphics();
" i0 {( {& @9 H/ d& v3 ~3 `/ ?+ W }
}
3 x  M6 o& z% k% Q: h9 ~  Dpublic class Antcolony extends Applet  implements Runnable  {
" [+ ]0 h+ S3 {' [ boolean isStandalone = false;//系统的参数，是否独立运行，不用管
! d9 w4 a8 L& f1 b9 T, d Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
. A1 Z( H, R4 O* U static Color OBS_COLOR=Color.red;//障碍物的颜色
; r7 `9 Y: F" p! s static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
( C4 ^% E' z. i0 c+ L9 N* ` static Color BACK_COLOR=Color.black;//背景色
; R7 z0 b' d# h4 T) w' [9 C9 C static Color ANT_COLOR=Color.white;//蚂蚁的颜色
- y% r+ C# O. n/ t, L2 D8 E        static Color End_COLOR=Color.cyan;//食物点的颜色
" c* C; u! m5 U9 `6 ?1 u/ w! [4 m( ^  G AntCanvas canvas=new AntCanvas();//画图用的画布
+ v# n9 R8 E* E, N int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
% y3 w' b" b0 u( r' G/ I        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
% }( j: v% {' {5 F7 M static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
- N$ u9 K# g, ]- o5 Z1 l        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
" c; A7 ~& p+ p% W! l3 f( z/ S        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
0 F  g; d9 i* _) W& U- k        static int OriginPts=1;//窝的个数，最大为100
static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
3 Z* l' t5 Q) q9 E1 L0 O: U0 o7 h4 T        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
        static int FoodR=10;//食物和窝产生梯度的信息素的半径
static ant ants[];//蚂蚁数组
; Y) {# r: j1 b+ R$ y( s        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
$ g/ U3 X0 l. V2 k8 L2 h8 O8 r int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
5 b/ R; ]6 p( G/ R0 d6 ?! U        Button btnStart=new Button("开始");
; n1 V( }8 T, C: Y# \3 L        Button btnReset=new Button("重来");
5 H0 X, J. s9 ^3 Y        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
public void init() {
                //初始化函数，先画各种控件
  setLayout(new BorderLayout());
                Panel pan=new Panel();
& h; T1 k3 l% n. K5 {8 N0 G                add("South",pan);
: L5 r+ V. T, z: ^( `) k                this.add("Center",canvas);
                pan.add(btnStart);
- e( j' Z/ h( b% V5 `( b/ S                pan.add(btnReset);
# x7 l+ p. C# u6 |- V3 T8 A                pan.add(btnConfig);
; q( r" D8 N( n- w                pan.add(btnMap);
                pan.add(choPDraw);
                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
7 ]; w  N* l1 d$ P                choPDraw.addItem("画食物信息素");
4 Z; }  ]! h4 [8 P. R                choPDraw.addItem("画窝的信息素");
) g4 S' g8 w0 b. h) D) k                choPDraw.select(2);</P>
<>                //初始化各个数组
  obs_grid=new int [width][height];
                phe=new Vector();
0 k1 u5 I# q* U# J" ~                Pheromone_grid=new int [2][width][height];
                for(int i=0;i&lt;width;i++){
' H- t& b# @8 E: d   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;
, B# {0 i; v3 ~1 M1 J                                }
   }
  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
0 U" w# a; J0 H5 i                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
+ @% H2 h+ J  u: G# q, |( O* O          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
2 ?, T% _# I; B9 j1 Y4 u' j- O: x  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
0 p8 x" m  ^+ j* x3 a                int grid[][]=new int[width][height];</P>
- u8 I, [* P7 j( s) b# T8 f' W<>                //下面从地图库中加在地图
                Maps maps=new Maps();
                maps.LoadMap(grid,0);
                //初始化地图
0 E! g6 ~. `% X. R                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
  reinit();
& M/ n0 v6 D; m }
        public void reinit_map(int grid[][]){
* g4 f$ z  Z! {2 u  R9 U/ G1 H6 [; E                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
  `( ], {4 A6 M& c2 i/ g% m<>                //先停止程序的运行
0 B4 {: O5 n8 j: k                running=false;
                btnStart.setLabel("开始");</P>
' `. J6 \& q9 m( |: o<>
9 a1 x( F$ D( H- w5 a; D' ?+ c                obsCount=0;
                EndPts=0;
) M# X& P/ D5 c2 n2 e1 T! V- U                OriginPts=0;
+ P3 D+ r9 O0 H( P3 o3 C7 i                obsP=new Point[width*height];
                OriginPt=new Point[100];
                EndPt=new Point[100];</P>
<>                //清空obs_grid和Pheromone两个数组中的值
                for(int i=0;i&lt;width;i++){
& F/ @) u( @/ m, \1 {; c  Y   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
1 R) M  {6 F% J                                for(int k=0;k&lt;2;k++){
6 G# P+ \1 X7 E6 T+ e- Y                                  Pheromone_grid[k][j]=0;
3 ?* N, }# f" l7 @: y- z5 j# G                                }
/ r4 k5 |9 D' @$ R. r! E4 s; U5 ~. P% |( ?   }
, K& u# Z0 `# g% h* d  q  }</P>
$ W# p: q6 ~' N$ Z' H0 R<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
) ?' s3 h+ t; A' D3 P                    case 1:
  S, m+ c3 G) n" ]2 H, E  g( w                      //如果grid[][]存的是障碍物
( v( c- A7 C. w( J6 z                      obs_grid[j]=obsCount;
                      obsP[obsCount]=new Point(i,j);
/ {  r0 g1 {9 X+ h/ S; H! y7 E+ n                      obsCount++;
                      break;
* Y8 u9 H+ K. x6 Y# Q5 M2 k                    case 2:
# D, E/ V1 [- Z. F9 f, A1 h                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
1 Y4 d& [: R+ `9 S3 v                      if(OriginPts&lt;100){
                          OriginPt[OriginPts]=new Point(i,j);
6 e. m1 i9 s% T# H$ \4 K                          OriginPts++;
, Q/ J4 {+ ~; i5 v4 p, U# E* ^                      }
2 j0 Q  A) C* U                      break;
                    case 3:
) i  _5 }# K: x                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
                      if(EndPts&lt;100){
# O3 g% y  a$ Q  Y& N                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
/ K, M: W2 f" @                      }
                      break;
                    }
9 n5 \! \4 ~1 _9 I3 }' N                  }
                }
) u4 o5 f# l! H            //如果没有指定窝，则随机的选择一点
: Y4 ?+ f. \& C+ T* F! B            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
! s& s5 ]! S. m- ]3 `                int  j;
                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
                    OriginPts++;
7 I9 ]9 n3 h- N                    break;
                  }
                }
% R/ o. S% r2 t9 T! p& `                if(j&lt;height-1){
                  break;
                }
              }
            }
) n9 J2 Q5 A7 ]$ C: k        }
public void reinit(){
8 z7 L+ M6 W) L0 \( ^6 b                //重新初始化整个环境</P>
2 P# i) _1 I/ N<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
<>
' [7 p7 P  D' J6 N1 G  //清空所有信息素Pheromone数组中的值
                for(int i=0;i&lt;width;i++){
8 d( W6 W/ [" E( \& y   for(int j=0;j&lt;height;j++){
; ^# R1 X, x7 x. k                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
' J0 N  v$ X, M8 h& q) `                                }
   }
* O, S0 v2 [1 w* I) x  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
7 C% ?# a+ S* [+ O        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
          ants.OriginPt=new Point(OriginPt[index]);
% o8 O3 ]: N) ^0 R( o6 C2 i                        ants.init();
% I( }) }' ?. A* r% d" ]0 I  }</P>
<>                //清空信息素向量
- N- Y- A  W* J3 x                phe.removeAllElements();</P>
<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
  for(int i=0;i&lt;EndPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
/ `5 X1 M" y1 r4 d2 t* S1 U5 H- _5 o+ y                        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: g/ \# H  p: G+ `1 k                    }
2 A* V3 A/ V. G. z' b                }
                for(int i=0;i&lt;OriginPts;i++){
                   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[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
! z  B% D" d, E- L6 L# {4 `                        }
                    }
% ]- c0 v! a# C                }</P>
# r( f8 {# I9 k$ o<P>                //重画
  canvas.repaint();</P>
<P>                //让程序开始运行
  ^! ^; l3 E. Z2 B5 I. _                //running=true;
6 i, G( l& F' W: [0 o. I- w }
public void paint(Graphics g) {
  canvas.repaint();
}</P>
* K# f0 T/ q$ u7 {9 T) g% ?, p6 ~<P>
public static void main(String[] args) {
1 A' z* U1 W0 v; j9 ^. y    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
, s  S" M  E$ d    Frame frame;
    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
7 N2 G: v) U5 O* W, Z          System.exit(0);
% T( _) E" E3 g5 w+ U* V        }
7 `5 Q, t7 a+ V1 G! K      }
( @8 I. L& V: X3 o      public synchronized void setTitle(String title) {
        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
+ o0 P* @7 I% g+ E* l7 E! p5 Q, ^    };
    frame.setTitle("Applet Frame");
0 `8 S' q' |* u. t$ y) \: l$ x    frame.add(applet, BorderLayout.CENTER);
    applet.init();
    applet.start();
    frame.setSize(300,320);
, i& ~' H$ t- ~# s9 m" {    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
8 h$ e; a" w, j( a3 v* M    frame.setVisible(true);
  }
  public void start()
4 |4 _- @! H1 B* H8 G$ i  //下面三个函数是控制线程的
{
  if (runner == null)
; M8 W) X  Q9 h% {8 w7 A  {
3 [, _% s, t; m6 u+ n3 B   runner= new Thread(this);
9 x4 u! h2 ~6 ?8 z0 o1 L3 t   runner.start();
8 G0 W0 e8 J4 w" e; V5 m7 n/ g) F   //running = true;
  }
; X; b4 L4 Y( l9 s% {. H3 P7 } }</P>
  m# r. L+ b9 N+ B: Z<P> public void stop()
{
  if (runner!=null)
  {
" `" k- X/ l. x8 l+ ~   runner.stop();
   runner=null;
   running = false;
  }
- d- L+ ]2 [/ w/ H6 B0 s& f: k* D% g }</P>
<P> public void run() {</P>
<P>  int i;
                //线程一直运行下去
: i; U! H4 I1 w9 M- V2 {  while (true) {
          if(running){
, u: ^$ M& K* g" V6 R; f       //如果开始动画，就进行canvas的处理
" @" s4 c3 @" W0 C# M                          canvas.process();
                        }
    try { Thread.sleep(delay);}
6 F- j; y/ Y$ Y    catch (InterruptedException e) {
  s1 [6 `- Q" [( K- R/ I$ k  j   }
  }</P>
<P> }
        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
                //开始编辑地图面板
   running=false;
                        btnStart.setLabel("开始");
! `5 i- p4 c& L2 h   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
# r$ n' U( H- z/ {  p                        ctl.show();
. B9 V  a2 A+ P( l1 C' }                        return true;
  }else if(evt.target == btnStart){
                  if(!running){
+ l: [% H! |- N1 x+ k5 u$ w                    //如果刚刚按下了重置按钮就重新初始化一下
. `6 `" h' ]2 ]" d, t. G  o                    if(reset)reinit();
. M, v6 S$ n# j# e. P                    btnStart.setLabel("停止");
                    reset=false;
                    running=true;
                  }else{
                    btnStart.setLabel("开始");
                    running=false;
                  }
( v( r9 K4 Q7 `' }& ?9 x                  return true;
                }else if(evt.target == btnReset){
$ T: Z1 o; V/ l. r) [) ~$ `                  running=false;
1 g2 s% N# b  v# B                  int j=0;
                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
                  repaint();
                  btnStart.setLabel("开始");
                  return true;
                }else if(evt.target == btnConfig){
  R4 d+ _2 J4 b. w                        running=false;
! E' E5 i* `1 r. ~9 T                        btnStart.setLabel("开始");
     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
8 K0 E, N4 x% P# k                        ctl.show();
# S3 t) v$ M& ~* T( @                        return true;
                }else if(evt.target == choPDraw){
, ~6 v9 j" U, D! w" }# }                  //选择画信息素的模式
# G- ^: W4 m) n                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
                  return true;
                }
/ r5 r" o" P5 l6 k: M                return false;</P>
<P>        }
0 i& ~* b5 ~3 | /**Destroy the applet*/
  public void destroy() {
  //当结束程序的时候，把线程也结束
' z  W  }, A% a5 Q5 a& M. i: C% m    if (runner!=null)
+ i: H- e0 N8 Z0 {    {
# p) T) }) E9 A; _) K       running = false;
+ u/ T# o$ z$ X# F- C) f       runner.stop();
- b+ {+ G9 S; Q" k4 h6 q3 ~2 F       runner=null;
; N( e' b$ x; E: M7 P$ e2 r    }
; y* U* y+ V3 v3 C; [1 N& C, T5 Z; x  }</P>
# m" n% x  f' m, F( ]. D<P>}
* Y& R) L% `9 I</P>

  \. A% Q' ]3 Q1 B! r5 ?* d% n
) F7 |7 y! D9 Y& M% ]9 ~5 p1 W+ A
<P>package ant;
import java.awt.*;
import java.applet.*;
import java.util.Vector;</P>
<P>public class ant{
Point nowPt;//当前点坐标
int VR;//速度，每次蚂蚁能走动的最大长度
4 C# @3 R3 w2 u% C( j! `( g  int id;//标识
6 L- Z* u$ n* t  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
int height,width;//世界的尺寸
        int Phe;//每次释放信息素的数值
9 R: F! j, j% P& P Antcolony local_colony;//主程序的指针
3 _6 m& c1 z/ V1 Z" W6 E        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
# e+ ]0 S) r/ n        double Main_direct;//主方向
8 J/ M3 n, x% m        Point FoodPt;//记录的食物点，是否找到时候判断用
8 b; i0 T$ m; H        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
8 A7 y: V" W$ z5 u2 J0 `2 p        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
6 n) s  T* n& K- t" l        int Max_Pheromone;//最大能够释放的信息素
        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
! w: a/ w; a( d  N: e/ a& @2 k        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
7 P; L( g# q8 i7 n, X) v8 I        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
$ r+ ?# b+ J% ~7 ^  nowPt=new Point(nowpt.x,nowpt.y);
1 h: Q6 `. b! ?9 r% t1 x                OriginPt=new Point(nowpt.x,nowpt.y);
                FoodPt=new Point(nowpt.x,nowpt.y);
                StartPt=new Point(nowpt);
4 A" k  T" _7 R+ n( b. U6 U, f                AimPt=new Point(nowpt);
# I  y2 S9 v; t  m) Y+ ^; k                lastPt=nowPt;
  VR=vr;
  id=idd;
  color=c;
  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
9 n5 U6 G7 n) Q3 c7 `6 I/ D! p  width=Antcolony.width;
4 i1 F4 N) N2 G  H: X  local_colony=colony;
                Phe=200;
+ ?5 G: j% ]- r4 E2 w                mistake=mist;
  w) R& ^' l4 _" J; u) \3 j& R                HistoryPoint=new Vector();
, |4 J# Y' Y7 x                Main_direct=-1;
                FoundTimes=0;
                Max_Pheromone=local_colony.Max_Pheromone;
* R+ c6 w2 p7 J2 J! E                Pheromone_count=Max_Pheromone;
4 i: W2 l! A% ?3 x* ]- S2 _                memory=mem;
' a( x! k7 w! p0 X+ n                Count_distance=0;
                Min_distance=-1;
1 Y+ A7 @4 f, Q8 u8 [% r/ H6 |  |/ O }
        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
! w$ Q, `7 e, r7 \! Y' _          Main_direct=-1;
          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
: ^% |' q1 k$ k2 h          Count_distance=0;
          Min_distance=-1;
        }
public void Draw(Graphics g) {
7 D0 m1 d1 W0 b3 ^/ \% A+ c) O          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
- }% M! S/ V: F  g.setColor(back_color);
$ V( ]9 T; L6 E- ]& j  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
  g.setColor(color);
( t' c0 Y1 i, v% N9 A  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
3 s  U( d( ?; A% t9 L: I }
public void Process(){
2 d7 K* O* j+ D9 m, X6 x        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
0 N3 }4 d) g- N( S: M4 t        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
4 V5 g/ V4 O+ ]; _" R0 _! ]) ~! ?" u        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>
1 `/ N( A$ c1 f2 z. G/ k
<P>        if(Judged==false){
- r* C( d0 B: L$ F0 Q; Z5 f          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
; m6 N$ m( q9 i2 b5 ]5 A3 b  e          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
              return;
          }
; @1 {* y4 {0 b* b+ k- Q# S9 D! f7 L        }
        Judged=false;
        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
6 [0 }4 R1 v7 T( c8 n<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
7 n5 \6 f/ a% d        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
; Y) g! l* x6 U. F  L+ \) a        deltx=(int)(VR*Math.cos(direct));
& M% M( _$ C! h7 i        delty=(int)(VR*Math.sin(direct));</P>
. C. G- J+ V/ E4 Z+ l<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
8 l/ R, }, n; w3 t! W* x        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
: E% d. U- b* E        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
) s$ w1 s6 r! G# Y% U2 o6 i% V+ N<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
          int deltx1,delty1;
5 R- Y) l2 O$ |6 z1 [          deltx1=deltx;delty1=delty;</P>
9 h+ Q# N' v& ]& v0 i+ F3 `8 v<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
1 `, Y- x8 t* `+ i          for(int x=-VR;x&lt;=VR;x++){
             for(int y=-VR;y&lt;=VR;y++){
3 T4 d. k( r* j3 v$ z                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
4 V# N1 C0 k/ Q% G2 w                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
: x5 {4 J- E3 _* c; _( d6 K7 L                int yy=(nowPt.y+y+height)%height;</P>
( L" F; N" K5 z<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
+ f4 y# G/ |' G* X/ m# R                  //的到要搜寻的点的信息素
4 {. Q. ~* P) R& j2 W. Q                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
( C- l9 I% c+ V0 ^( B2 h<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
3 H: C: }5 h( O$ E<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
) d+ `% Y% h3 E: A* B                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
                      double ra=Math.random();
" {' _) `7 m# ^  d  R6 {0 ]% \! }                      if(here==0||ra&gt;mistake){
                          boolean found=false;
  z- {, g6 V% p% M& I/ y/ y/ ^! e                          //查一下内存最近走过的memory的点数，从而避免当地转圈
3 O$ q% m( L/ _% @) x5 ^                          int size=HistoryPoint.size();
                          int minsize=memory;
+ @4 L% w4 a* |  L                          if(size&lt;memory)minsize=size;
                          for(int i=size-1;i&gt;=size-minsize;i--){
! o/ u! I$ U; [# ?) M9 V7 D2 N                             Point pt=(Point)(HistoryPoint.elementAt(i));
0 i% g" U" D; N) W/ C                             if(pt.x==xx&amp;&amp;pt.y==yy){
& k# z6 _- z, Q% [! z& ]% V1 @                                found=true;
* G3 ~+ y% g. }! _9 @: e                                break;
. [! I/ [1 S  i. L4 ?, o& F& ?% {                             }
                          }
                          if(!found){
                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
                            delty=y;
2 x' R, ]4 E. e2 g6 c' Z5 M                          }
4 a0 G6 w! s) o                      }//end here==0||ra&gt;0.001
5 f$ V6 @8 S. d" X1 U* v# I( y* @                    }//end maxphe&lt;here
0 k2 C3 T; Y, ~) {                }//end if x!=0
            }//end for y
        }//end for x
- ^! T$ B6 P) P        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
/ x; z, u; ~2 C- N  e+ P- r        pt=Evade_obs(deltx,delty);</P>
<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
! ^. Q! L7 _5 ]  |# R! f          pt=Evade_obs(deltx1,delty1);
% U. h0 H3 G/ \2 r( E        }</P>
' G; ~: n1 X2 ?2 I<P>        //播撒信息素
, D* K- e  d7 Z: x+ G" ^7 I' i$ |        Scatter();</P>
<P>        //记录走过的距离
        Count_distance+=Distance(lastPt,nowPt);</P>
<P>        //改变当前点位置
0 D$ W1 h' E0 O1 K3 c, U8 d) M        lastPt=new Point(nowPt.x,nowPt.y);</P>
' h' x: S6 u- a% A) |; }* ?! g<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
* o* H) `# r( i! @6 k        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
7 ^' P: H1 W. |, l+ S1 }0 n        if(HistoryPoint.size()&gt;memory){
4 f7 v1 o: E* a/ Y: q) S  X7 Y          HistoryPoint.removeElementAt(0);
        }
' R! o' {8 \) s# `        nowPt=new Point(pt.x,pt.y);
# P0 F! ]4 w( `. d' t: n     }</P>
' \3 U2 x% K  m* C4 V6 `9 W<P>
        private void Scatter(){
        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
0 ~4 l- I4 z9 e: F( `% a        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
            if(Pheromone_count&lt;=0)return;
( u  O3 @: _4 p) N            //决定释放信息素的种类
            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
( _4 }. b* A+ H# Q            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
3 ~) ]8 n* e/ o9 ]            boolean ofound=false;
: i7 ^5 N. t$ t/ _6 ]( s            if(Phec!=0){
                //如果当前点已经有信息素了
                for(int i=0;i&lt;local_colony.phe.size();i++){
                    //在信息素向量中查找该点的信息
, y+ [# z* b! N                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
5 _) `( ^. G' @1 H* y$ h                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
/ a" R$ \, E# E2 q/ S9 r0 n) a+ g                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
                        int size=HistoryPoint.size();</P>
& L7 Q% k0 i7 {<P>                        //如果在表中找到信息素，则用ofound记录。
9 m& B) x- }1 `/ l0 o8 _                        ofound=true;
                        boolean found=false;
                        if(size&gt;4){
$ @0 _: i. W7 Y# h$ K2 \% ]" a                           for(int j=size-4;j&lt;size-1;j++){
                              Point pt=(Point)(HistoryPoint.elementAt(j));
9 }- B1 b! K7 X! G& z5 k                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
                                //如果当前点重复了以前走过的路，就不释放
                                found=true;
8 d/ e- {4 m5 h7 H* i- M$ W" s6 K                                break;
                              }
7 a. \" M# `6 s2 x                            }
* |5 t8 Z3 m8 B* q3 ?( c) T+ d+ L                        }
                        if(!found){
                        //如果当前点不重复，则开始撒
& A7 N) \$ H; \6 x- j4 o                             ph.Add(Phe);
. l$ ^/ M1 Z( l/ @9 O  c                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
<P>                             //让还剩下的信息素总量减少
                             Pheromone_count-=Phe;
                        }
                        break;
* V" F( t2 L9 r                    }
                }
3 u8 j. ]1 m: d( J, y              }
* \! `6 J, A5 y* b; D1 J* n          if(Phec==0||!ofound){
% \' t1 @; B# X( Z) U: j4 N( ?            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
9 @7 G, F; k+ o3 y                ph.Add(Phe);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
: ]) l# j$ o/ ]                local_colony.phe.addElement(ph);
                //让还剩下的信息素总量减少
* R' H+ [& l) A3 T                 Pheromone_count-=Phe;
           }</P>
8 S4 d* t$ o& f/ h% |" g# k- \<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
. i9 V! I9 w5 e0 O) [- q( K( @           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
7 w/ n4 i9 u5 m1 u6 ~$ {           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
  o( C/ ]4 l; o/ ?           Phe=(int)(0.005*Pheromone_count);</P>
<P>           //如果剩余信息素已经太小了，则按照等差数列递减
- ^5 _7 `! v$ {1 M           if(Phe&lt;=10)Phe=10;
+ R0 X" v1 o( g/ \& a        }
4 l8 u4 b) \0 s9 Gprivate boolean JudgeEnd(){
$ l8 @* P- @4 \7 @    //这个函数判断是否已经找到了目标点
# R2 d( l0 B% N& a) z$ g3 O" t2 `5 f    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
    if(kind==0){
2 X& R9 k; M) J        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
7 A! e) Q& j( L& t! p        int i;
2 M' j5 j7 ^; c! p$ D$ T        for(i=0;i&lt;local_colony.EndPts;i++){
            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
0 {7 U( z8 C) a1 w/ n              //如果找到了食物，就直接移动到食物点
              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
! y3 \5 E5 j2 m3 u& }. E/ ]              nowPt.y=local_colony.EndPt.y;</P>
# m3 W" E9 k9 z  n4 c: g<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
2 M( k: z2 \. Z# n$ N              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
              }
              //清除总距离记录
# t3 D* k2 X* `9 \  G" l              Count_distance=0;</P>
) H, W; L% V  I! J: V2 ]<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
              AimPt=new Point(OriginPt);
              StartPt=new Point(nowPt);
              //并把当前点标为自己找到的食物点
7 B- u6 U3 K' u, o" v              FoodPt=new Point(nowPt.x,nowPt.y);</P>
<P>              //找到了食物就把找到次数+1
              FoundTimes++;</P>
& J8 k3 F$ u( R* t+ g7 [1 N) B<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
6 _" a; ~, Y$ m2 N- u0 l& T' J1 L<P>              //重新把自己能撒的信息素置为最大值
  g2 C- J6 e# _, j' m; T+ D" ?              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
! U0 c' C4 ^: ]0 Y1 D: G, w              HistoryPoint.removeAllElements();</P>
. [4 {4 g7 k* \  f; @& c<P>              //返回找到为真
3 E9 n6 m! j( ?4 t              return true;
            }
! B2 _6 M' I4 l# m2 K1 m        }
3 n0 r* U2 t1 D      //否则没找到
      return false;
0 _  t) n. v" C+ A- }* ~    }
    if(kind==1){
        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
. C$ F/ u: }. ~% `" Q        if(Distance(nowPt,AimPt)&lt;=VR){
3 x& Z# h* ~( @3 f            lastPt=new Point(nowPt.x,nowPt.y);
            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
8 K! E: E$ N* |2 f: |( F! ^<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
( v$ c4 D8 ~9 {* w0 u* v( h" M6 x5 f              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
. p7 H( w) g7 f0 V% \5 b  D              }
, x+ }  n3 l- A) t; g+ C              //清除总距离记录
: u; d+ m; ]1 h; i              Count_distance=0;
2 v$ R  f  v! i& M& |5 C            //把目标点定为食物点，起始点定为窝
  j- d" Q7 @5 i            AimPt=new Point(FoodPt);
            StartPt=new Point(OriginPt);</P>
+ A! C6 V( x9 X<P>            //重新置信息素
( e  z- Q8 Y* w& H% _7 R+ D. N3 t0 [            Pheromone_count=Max_Pheromone;</P>
7 M( w; G6 n( ]7 g7 c( y" ^/ w<P>            //清空历史纪录
6 U& o2 _7 i+ r            HistoryPoint.removeAllElements();</P>
" \* t9 G, N) M<P>            //主方向反向
+ x2 P( [4 A, _3 V0 h3 z# d            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
            FoundTimes++;
4 R% O' P1 {6 s$ j* u4 S5 V- T            return true;
% A" Z" z9 h# ^' K        }
. R* K  f, \4 b1 R+ v, l' g        return false;
6 B, q# B% R$ z- `* V/ X    }
9 m, E  p" w: f+ |; e* v, K2 ~  k9 p' y    return false;
}
        private double SelectDirect(){
                //选择方向，最后选择的方向为主方向加一个随机扰动
5 c) u/ Z' q5 u' P                double direct,e=0;
, f! V  ~4 P1 ]: @                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
        e=2*Math.PI*Math.random();
                      Main_direct=e;
* ~$ B6 c4 ~' @  g5 z                }
( G" b% l9 Z. R1 E                //选择主方向角
- ]6 R  j! g! y( f/ E, @5 v                direct=Main_direct;</P>
1 P1 v9 n+ d. K* U" ~( d<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
! X' O: Z4 h' o1 v1 X9 o- a                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
                double re1=Math.random();
                direct+=Math.PI*(re*re-re1*re1)/2;
- m2 p1 z2 r# C/ U" N! G! K' e                if(re&lt;0.02){
; k* ?5 c: G0 O3 w( r9 B                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
                  int size=(int)(re1*memory)+1;
. _3 [4 M& K  D) j                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
/ @  J0 w5 G! S$ a! z9 t                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
9 E0 C: z0 p7 d" x$ V                       Main_direct=GetDirection(pt,nowPt);
                    }
" g$ L. m/ o, ^$ p; i* g2 Q4 G                  }
/ O" @% s5 {0 ], y/ E" L; Q                }
, @  {) r4 I; D9 Z1 _( G, V) u5 `               return direct;</P>
- u$ m+ `+ N: P/ X8 g0 v' Z8 O<P>        }
        private Point Evade_obs(int deltx,int delty){
              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
( o' f4 M. m% s9 C; q              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
% [' C) K  u/ ?- D! y0 y& P              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
& G$ I! r. P- V# D7 z              Point pt=new Point(0,0);
3 x6 r. M, I5 t8 Z              int x,y;
              int delt=deltx;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
              if(delt==0)return nowPt;
- }6 n% a- a% Y2 l2 X              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
8 t; x% H: C2 L7 [6 v( u4 z2 h                  x=(int)(deltx*t+nowPt.x);
/ T; N) L) X9 ~                  y=(int)(delty*t+nowPt.y);
                  x=(x+width)%width;
* u: {+ z# g) ?! i& M4 m' m                  y=(y+height)%height;
                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
) k8 o! e% r3 T; A! |) j) {                     //新目标点为障碍物前方的点，主方向随机取值
& z/ k% |% `: d                     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);
$ S" |4 G3 p+ s9 v2 L                     break;
0 q* L9 p+ {* w( j7 I                  }
                  pt=new Point(x,y);
                }</P>
<P>                //计算得出实际能够到达的目标点
" Q8 x* ?3 z3 U  q' o* g8 ~4 a  x=(nowPt.x+deltx+width)%width;
: I5 E1 R. C8 m# L* }! s* u  y=(nowPt.y+delty+height)%height;
3 ]6 L* u2 T4 k/ w1 F         return new Point(x,y);
3 o* D4 e: n" r1 S& U; S/ a# A7 @) _5 _        }
        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
+ k& V5 j! U+ c" q. ?. j        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
6 v$ }: ]2 U& b        //其中方向角是所有可能的角中使得两点连线距离最短的角。
5 W1 B$ f2 S# X1 o1 C/ G               double e;
               int deltx1=pt2.x-pt1.x;
               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
               else deltx2=pt2.x+width-pt1.x;
* Z5 |1 g, t- f: V( i               int delty1=pt2.y-pt1.y;
               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
9 [0 [% i$ L& p8 {5 g, m/ ~" J               else delty2=pt2.y+height-pt1.y;
               int deltx=deltx1,delty=delty1;
               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
0 I/ B. M0 X. P5 u               }
        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
7 B- i* S+ `" O3 A, w' q               }
               if(deltx!=0){
/ v1 L3 ~; K# c/ g% D, b                    e=Math.atan((double)(delty)/(double)(deltx));
                    if(deltx&lt;0){
4 E) k- M4 z% W* I  J- M                       if(e&lt;0) e=e-Math.PI;
# U' I$ j0 J: n& [' q3 {* J                       else e=e+Math.PI;
: t. o6 c% A+ F  K; p( _                    }
                }else{
) b. H& |# ?1 V* C1 A                    if(delty&gt;0)e=Math.PI/2;
7 H8 t! ?, a) K5 k3 n: O- `2 e                    else e=-Math.PI/2;
                }
                e=(e+Math.PI*2)%(2*Math.PI);
# q& O2 g" U3 A0 @3 o* R* m                return e;
        }
, N, {  L3 U1 V* D% y6 h1 G! Y) N        private double Distance(Point pt1,Point pt2){
% |- k4 r' M& o! x; B        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
$ m0 Q. ^% R# N1 E, A. v4 \        //这里计算的是所有可能距离中最小的
7 x; {! r7 O6 |1 U! j# `, q: H) n            int dx1=pt1.x-pt2.x;
            int dx2;
            int dx,dy;
+ l: i2 }3 N: z            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
            else dx2=pt2.x+width-pt1.x;
" `& {9 F+ i( ]" b4 B            int dy1=pt1.y-pt2.y;
            int dy2;
/ q! p. I  v1 \$ C; z            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
& p* j7 g, n5 D! j3 K3 o% k% w) ~  c            dy2=pt2.y+height-pt1.y;
            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
            else dx=dx2;
            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
0 `* x9 @0 s" c7 S1 r            else dy=dy2;
0 f. t, c. A* `# T. a1 L            return Math.sqrt(dx*dx+dy*dy);
        }
    public void clone(ant ant1){
        //把蚂蚁ant1的属性拷贝到本蚂蚁
     nowPt=new Point(ant1.nowPt);
- h/ L" }" @& p% W& E        OriginPt=new Point(ant1.OriginPt);
6 x/ i2 |4 `/ z- q5 q* Z        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
2 B! N. F$ I5 Y) P  m        AimPt=new Point(ant1.AimPt);
2 {! X2 C' m  T* x! s        lastPt=new Point(ant1.lastPt);
        VR=ant1.VR;
        id=ant1.id;
/ ]4 D3 d+ p; @2 s        color=ant1.color;
+ a% J6 H- x/ ]& B$ d! D        back_color=ant1.back_color;
9 A; h. H' W# k" j3 D/ Z        height=ant1.height;
7 D" X. F5 e  `  g6 l        width=ant1.width;
3 {8 E7 x0 q" {) L- _        local_colony=ant1.local_colony;
" z: T/ ^7 O* @7 X/ T        Phe=ant1.Phe;
        mistake=ant1.mistake;
( C- \& M; e: M( |8 h& Z        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
        memory=ant1.memory;
; j( K& R8 I9 w: P        Count_distance=ant1.Count_distance;
        Min_distance=ant1.Min_distance;
    }
/ ^. x3 [6 c0 n0 L% h6 q}</P>