[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
/ x4 H. g5 H( \, O9 H0 |: i<>package ant;
/*
* l- W/ K6 f+ U5 L8 l! w8 a* V% ~2 _ * @(#)Antcolony.java 1.0 03/05/22
& S  W& W; `3 V5 d% Y7 S; G *
* You can modify the template of this file in the
9 m/ ?/ g5 j0 s0 b * directory ..\JCreator\Templates\Template_2\Project_Name.java
*
/ j  k( c% `  W' c: n. c * You can also create your own project template by making a new
* folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
) e5 m0 j8 ?& C: A' e) k# A6 N6 R *
2 M6 ^8 [5 r% n" x# `0 i7 k */</P>
<>import java.awt.*;
import java.applet.*;
' Z2 q5 W4 {9 \0 E2 {4 S- {import java.awt.event.*;
4 b  `; d. v/ V5 G: K3 u4 Nimport java.util.Vector;</P>
<>class AntCanvas extends Canvas
{
    //画布，一切画图操作均由该类完成
//Image image;
Color obs_color;//障碍物颜色
Color origin_color;//我的颜色
Color back_color;//背景色
        Color end_color;//食物点的颜色
//boolean first;
- {& d# r! k7 [9 c boolean reset;</P>
9 p! j% ]! }/ W; {& ^: s2 ^6 m<>/* public AntCanvas(Image img) {</P>
<>  super();
( |) o9 x4 g1 |& ~3 K% v, ~   image = img;
  obs_color = Color.white;
5 Z: \( h; u' N; e! C& R( Y2 |  setBackground(Color.black);
  setForeground(Color.white);
" N4 w( k  R* O2 n  N  V4 J  first = true;
: J# ~( K- @' c6 P# U  f  reset = false;</P>
% a1 T3 U$ H: e) T; D1 P<> }*/</P>
/ m% R7 K% Z; B- @4 s/ L9 \6 q1 a: j7 [- ~<> public AntCanvas() {</P>
<>  super();
& c- f# H' k- n( F9 n4 ?- \8 [$ {8 Q% a   //image = null;
   back_color=Antcolony.BACK_COLOR;
, q* D+ k  P# i$ C& n6 @6 X  setBackground(back_color);
% u/ c# u" ^7 D3 K8 N: ~1 r1 W/ g# x  setForeground(Color.white);
, V2 Z3 H, A2 y  obs_color = Antcolony.OBS_COLOR;
  origin_color=Antcolony.ORIGIN_COLOR;
( d/ c$ n/ W+ f! d                end_color=Antcolony.End_COLOR;
: O# q, s) I0 r6 l  //first = true;
  reset = true;</P>
<> }</P>
<> public void Clear() {
9 l; X7 H# r- W3 d& v# s* z) @        //清空画布
  reset = true;
  repaint();
}</P>
% W- N# |# a, c7 c! e<>
public void paint(Graphics g) {
; b8 J1 W. o. A) o8 D  int i;
# v5 C0 \6 t+ q- z& Y                //重画的时候仅仅画障碍物
: [: y$ Q$ }! `3 p  g.setColor(Color.black);
2 E- E7 }2 `# ^5 g2 ~- S  g.fillRect(0,0,size().width,size().height);
  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
4 t! k* Q9 y5 F  `  S   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
' W; ^% t& G( \0 q% j  }</P>
<> }
public void process(){
2 X! C! ?5 p  d8 Q. t, a) g        //处理动画的过程
& T4 r" p$ O& |% ]  Graphics g=this.getGraphics();
! e7 @/ C+ O' ~- a' U                g.setColor(end_color);
   for(int j=0;j&lt;Antcolony.EndPts;j++){
                  //画所有的食物点
6 D& ~3 o6 h2 s' U8 O                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
                  //每只蚂蚁开始决策，并画蚂蚁
& c2 h8 r0 f# Z+ g   Antcolony.ants.Process();
" B% [7 v' F0 P. A' b- h8 z  L   Antcolony.ants.Draw(g);
7 E; ?, }1 q5 r7 p  }
' U! z* _/ t: h3 ^                for(int i=0;i&lt;Antcolony.phe.size();i++){
$ K0 G7 F9 X: t/ G8 Z6 U# s                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
$ p/ Z- @* M( S2 R/ W! K                        //Antcolony的drawPhe变量标志是否画信息素
: y! i, V* y/ A0 k0 Y0 j) O                        switch(Antcolony.drawPhe){
                        case (1):
4 i& c$ T* }/ O7 b3 J* L                            v.Draw(g);
                            break;
! U' u; R+ G9 m) A. r$ a                        case (2):
" }5 L6 s/ Q! A; A& A' _) k                            if(v.kind==1)v.Draw(g);
  X8 N! V% K& j& l4 ~/ J+ Z8 X                            break;
                        case (3):
6 a; i+ O7 m( u8 t3 e  m                            if(v.kind==0)v.Draw(g);
                            break;
, k. k+ L+ Z" H; y                        }
5 S1 o  K1 Y: r  }( ~, N1 `                        v.delimit(g);
6 e6 R" X+ D: p; \) V  b                }
4 v5 y3 ~( H6 s* x- i           g.setColor(origin_color);
% u5 y' H7 [9 Z8 n: e3 Z                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
                }</P>
<> }
Graphics GetGra() {</P>
+ e+ G; c. g# _- j5 O<>  return this.getGraphics();
}
}
public class Antcolony extends Applet  implements Runnable  {
' }6 n8 A0 L! B9 k! q/ {5 e boolean isStandalone = false;//系统的参数，是否独立运行，不用管
" n1 X! q0 Y# k. X Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
1 l( \/ O5 G# h" O( @3 Y, V: Y static Color OBS_COLOR=Color.red;//障碍物的颜色
$ @/ g' e5 W3 A' L static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
0 y7 c) l! d9 B8 S/ E static Color ANT_COLOR=Color.white;//蚂蚁的颜色
, s. Z$ ]; v$ G; H! G. x+ y" e; L        static Color End_COLOR=Color.cyan;//食物点的颜色
AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
( b2 T# c6 T  w- o: A3 W8 E        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
7 j& Y9 r8 _9 M6 A        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
        static int OriginPts=1;//窝的个数，最大为100
static int width=300,height=300;//环境的长和宽
$ A% l% R/ l+ S, J static int antCount;//蚂蚁的数量
! p5 q; `3 ^) I7 q        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
8 f+ B/ y3 @1 f9 _4 G        static int FoodR=10;//食物和窝产生梯度的信息素的半径
static ant ants[];//蚂蚁数组
  @! ^$ w* z7 p* N! |- G+ z+ g        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
4 c! M3 b# {3 Z1 y int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
' ]1 W8 J' \" n1 N& r<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
        Button btnReset=new Button("重来");
        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
8 m3 [* O' y# E: U5 N+ o1 ^* {+ ] public void init() {
3 T4 v7 P# e9 t3 V' C2 c                //初始化函数，先画各种控件
& t& x) g# M+ ~/ Q" @/ l8 ?  setLayout(new BorderLayout());
' S) t# ~) ]. U+ j! A& p                Panel pan=new Panel();
8 _6 ?1 r* j! H' y9 U- j% v" l                add("South",pan);
- K9 x" X; M5 H: O                this.add("Center",canvas);
( o& G% f7 e) \( k+ H( y                pan.add(btnStart);
                pan.add(btnReset);
                pan.add(btnConfig);
3 y9 \/ q- T- n4 ^2 l0 q                pan.add(btnMap);
                pan.add(choPDraw);
                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
6 g7 r$ f5 {* t# S3 T                choPDraw.addItem("画窝的信息素");
% ]. h7 ]% ]) [                choPDraw.select(2);</P>
$ [+ H  t7 Q4 y<>                //初始化各个数组
$ v8 ~! h; ^6 m3 ^7 l0 }  obs_grid=new int [width][height];
                phe=new Vector();
) m6 I/ `1 O1 G1 R+ p                Pheromone_grid=new int [2][width][height];
                for(int i=0;i&lt;width;i++){
5 G% q8 q& E* K  [/ _! v   for(int j=0;j&lt;height;j++){
  Y" c" C% F. k# r6 B- V7 _  w    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
4 V' K2 }, x' a/ Q3 P, `$ [                                  Pheromone_grid[k][j]=0;
7 _  ~/ b& Q+ ]! S+ E4 F/ T  {                                }
   }
  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
& w0 z5 {$ X/ ]9 n+ |; x! p                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
4 n+ g( L, Y- H6 J  j6 [1 G3 E  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
+ ~: E; ^7 V, K! P. M! a          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
% }3 b* R* y* b  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
                int grid[][]=new int[width][height];</P>
! {& O: x. [$ w# b6 P<>                //下面从地图库中加在地图
% Y" I- \9 S6 A$ l                Maps maps=new Maps();
                maps.LoadMap(grid,0);
                //初始化地图
                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
  reinit();
}
        public void reinit_map(int grid[][]){
7 F8 f+ Z- z, q" h* l. y! \                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
' V: l) ], b) M3 v  }: {2 g; L: v<>
" d/ X: g( j* W% ?% g9 i7 \                obsCount=0;
                EndPts=0;
( k( n8 `# x% P/ ~                OriginPts=0;
0 j# u$ V2 g8 H- m6 I9 l5 z& _$ W                obsP=new Point[width*height];
- W% p" o/ F. h& U                OriginPt=new Point[100];
$ R4 N3 Z2 J; ^7 z9 Z0 w$ x/ y4 j                EndPt=new Point[100];</P>
<>                //清空obs_grid和Pheromone两个数组中的值
- d8 Z; R5 {1 ^: M3 b# c  f! C                for(int i=0;i&lt;width;i++){
4 N5 y5 X% v9 t1 E" ^   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;
                                }
   }
  }</P>
" J" z# _8 z4 S4 X. c" m( ^3 a1 r<>                //从grid数组中读取信息
8 k& ~1 m, C) l9 O, X                for(int i=0;i&lt;width;i++){
7 F, o+ F* o* D3 g; Z( J                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
% ?" s" W1 L; D8 P# K& {0 S                    case 1:
; z- \% w! ~7 x* S                      //如果grid[][]存的是障碍物
                      obs_grid[j]=obsCount;
                      obsP[obsCount]=new Point(i,j);
0 G" L  w- _8 w4 n* A& x                      obsCount++;
- V5 ]& T3 ~; X/ b                      break;
                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
9 E7 u, ~" K) s3 ^4 B% s  r3 A                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
$ S. [0 G) j& C. x. L                      }
- s8 t) G% @: r; y3 w: k                      break;
                    case 3:
                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
0 Q6 M6 U* N9 a. d. `                      if(EndPts&lt;100){
( J; H3 ^; _& F/ Y                          EndPt[EndPts]=new Point(i,j);
* n% J$ T/ j( O+ b                          EndPts++;
                      }
                      break;
                    }
                  }
6 [8 N0 L/ |! F6 J) K                }
! n+ j$ x& a, T' O! [+ p            //如果没有指定窝，则随机的选择一点
            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
6 k3 H5 O. Y9 H8 S# x                int  j;
                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
0 q$ A  R  n$ O  l4 I+ j& ^                    OriginPt[OriginPts]=new Point(i,j);
- o; ?  ~# n, ^( _% x+ r" z                    OriginPts++;
                    break;
5 {6 M3 _% \5 j3 p7 p! G/ Q' K                  }
  N8 G5 A2 _( d( o; B                }
                if(j&lt;height-1){
- T1 l) I2 ]  V  P' }+ _& K# [* |                  break;
% G6 X. M. H' z: e                }
              }
            }
        }
public void reinit(){
' ]( b$ g- j" |2 {; P# j. z5 n                //重新初始化整个环境</P>
<>                //先停止程序的运行
9 [, B( P- V6 s: U5 v                running=false;
                btnStart.setLabel("开始");</P>
( M: Y* b, m' q: M" L<>
  //清空所有信息素Pheromone数组中的值
                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
' @/ m8 a  Q/ q% ]6 ^$ _9 b   }
  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
/ J3 e- \/ M" w# R1 e. K8 l- K$ i- K        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
          ants.OriginPt=new Point(OriginPt[index]);
                        ants.init();
1 C1 W2 H" P0 v  }</P>
<>                //清空信息素向量
# v( t/ H$ S- Z                phe.removeAllElements();</P>
<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
  for(int i=0;i&lt;EndPts;i++){
2 ^1 c0 L6 w7 P                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
4 \/ N# a* C' k                        for(int yy=-y;yy&lt;=y;yy++){
( o! R( e# B3 G' ?8 b( A1 g* V                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
! }* {, f! b& U; j                        }
4 j& L! |: z2 v8 @2 i                    }
5 T. o, b& H; O                }
                for(int i=0;i&lt;OriginPts;i++){
" A/ F& V- f' O$ ^                   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++){
( y. u2 o, B( V1 s- a: g2 i/ a5 ^                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
                    }
' M# a: t+ i0 Z1 |; S4 {                }</P>
3 X, d! c/ G5 R4 q; s<P>                //重画
  canvas.repaint();</P>
<P>                //让程序开始运行
& b, q( o) f; N1 w4 Y2 l                //running=true;
/ R9 M% i  @  J4 s$ ~% G7 t1 n# F; A }
: e% y. z# w$ E9 c8 z% d8 [0 ^& I+ U public void paint(Graphics g) {
  canvas.repaint();
- M+ [) \  @/ H7 k: k- x }</P>
9 @/ v, L' w" p' {0 l: _<P>
public static void main(String[] args) {
    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
& ~8 `9 ~) S5 c    Frame frame;
    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
/ j0 L& A- Y  D        super.processWindowEvent(e);
        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
- b' L, m, o, z: F, ^, x) O, X8 N          System.exit(0);
$ o, A' C, o: z: i* ?7 D        }
      }
7 T0 b! h9 R+ x, }! U, Y- r% \/ [$ A      public synchronized void setTitle(String title) {
        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
    };
    frame.setTitle("Applet Frame");
    frame.add(applet, BorderLayout.CENTER);
    applet.init();
! m' s7 |0 m6 |7 U    applet.start();
2 _0 v! a+ m6 t% v  |    frame.setSize(300,320);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
    frame.setVisible(true);
2 |  j, F8 ^, q, O! \  }
  public void start()
+ p5 v: o1 |5 k% r, p  //下面三个函数是控制线程的
{
8 U4 `9 A+ P) e+ z) W  if (runner == null)
# w7 R8 ^! s/ y: ^0 X) ~; `  {
5 C2 y7 k2 A8 U- }" c, P   runner= new Thread(this);
   runner.start();
   //running = true;
" @( y: w7 h# E  }
}</P>
3 P3 K) C7 p! p8 O<P> public void stop()
{
  if (runner!=null)
  {
   runner.stop();
" X1 d8 F( p0 [7 `3 n9 X   runner=null;
- m0 v0 x, ^, k3 r3 q+ ~   running = false;
  }
- L' _! P' ]! T; g; ?3 j }</P>
* c* s$ {5 W  q$ [7 l0 d1 U/ }<P> public void run() {</P>
+ V3 Q5 t) k9 y1 d2 T! c* z<P>  int i;
                //线程一直运行下去
$ S% s+ n0 Q' u! u! _: ]) @' h( l  while (true) {
          if(running){
4 M3 {2 s6 K9 a) t; A+ D       //如果开始动画，就进行canvas的处理
                          canvas.process();
                        }
( w9 F7 Q) ~0 S! @6 H' `    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
   }
' |2 M8 |9 H% ^; s. @  }</P>
# C) f; b1 ?( d8 M& r' o; ?<P> }
        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
4 t) Z1 r5 z# X3 O, a  ]" x, Z                //开始编辑地图面板
   running=false;
' |: Y+ l7 x6 o6 _! }4 J  K% ^                        btnStart.setLabel("开始");
   MapPad ctl = new MapPad(this);
' M- Q% x- x1 K* v: F' B% i1 k5 P7 V7 J                 ctl.setSize(308,380);
                        ctl.show();
, G5 _4 P, _) E! i6 P                        return true;
  }else if(evt.target == btnStart){
8 m$ j8 U0 K) B# I                  if(!running){
- v* q0 p/ U: m0 {/ _. p. m0 L                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
                    btnStart.setLabel("停止");
                    reset=false;
                    running=true;
- B: P8 k6 h8 D( Q3 j& t                  }else{
3 f" f. r% ^' n9 v% Z1 l                    btnStart.setLabel("开始");
                    running=false;
                  }
. @) O7 B. o: P( _  v# O                  return true;
2 J  y+ ]8 t  C5 c& g. n" |                }else if(evt.target == btnReset){
& O5 O4 N9 N7 @$ k3 j4 K" r: R                  running=false;
" B1 w$ f6 f+ |/ l( x' b                  int j=0;
+ N$ M# P9 Z& T7 o                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
. A- y6 |, M2 A& N& K1 k, i                  reset=true;
                  repaint();
                  btnStart.setLabel("开始");
6 h, q; M* C8 {% R8 D$ `                  return true;
                }else if(evt.target == btnConfig){
4 V- N8 ^4 A$ M2 J                        running=false;
/ [0 w2 u) y; p# ^3 I% U                        btnStart.setLabel("开始");
* ?% \. Y6 O4 }5 w0 g6 z     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
                        ctl.show();
                        return true;
                }else if(evt.target == choPDraw){
0 Y9 p, |( B8 d7 [3 ]% T                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
                  return true;
                }
0 }2 }5 Q; K* h, c) S7 j                return false;</P>
/ A9 _  U5 R. L8 u; V<P>        }
; x" V4 q5 R, c7 ~ /**Destroy the applet*/
& u% l% b  X9 H. M' d7 ?  Z6 k  public void destroy() {
  //当结束程序的时候，把线程也结束
# a$ J# B% g2 o' c/ i    if (runner!=null)
- _* i; d2 x  M1 V8 j1 ^    {
       running = false;
       runner.stop();
       runner=null;
    }
( ^% t% \/ @% j2 b  }</P>
<P>}
$ [; g+ s2 t0 T* c7 \</P>
" V; r% b( J+ H1 R


$ Q& e" w8 p: {) V<P>package ant;
. n( A$ m0 e; W$ L; z5 ^: Q3 Z: Himport java.awt.*;
/ [- @4 g# F/ Y  u+ Ximport java.applet.*;
import java.util.Vector;</P>
<P>public class ant{
Point nowPt;//当前点坐标
9 {9 f5 i5 @" [! f) S) v int VR;//速度，每次蚂蚁能走动的最大长度
  int id;//标识
  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
int height,width;//世界的尺寸
        int Phe;//每次释放信息素的数值
. Q" G. Z$ \) A2 h. R3 E Antcolony local_colony;//主程序的指针
        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
" w6 g9 K+ Q4 I% }; s        double Main_direct;//主方向
        Point FoodPt;//记录的食物点，是否找到时候判断用
6 v# i# }% `8 c# R9 f# b! N7 M* n& w) K        Point OriginPt;//窝的坐标
2 Y, q" e4 y2 z# j* e1 P/ v/ V* T        Point AimPt;//目标点，是窝或者食物
$ f& H" T0 x4 S, d        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
, \2 \. E4 l/ _        int Max_Pheromone;//最大能够释放的信息素
        int Pheromone_count;//当前还拥有的信息素的总量
2 k- `' W( p  V) ~2 \        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
2 b- R/ k# d  p9 w8 |# \3 W. _        int memory;//记忆走过点的数目
- Q4 ?' Z2 z, V3 H: |# c1 ~) N        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);
% H: a2 }) p! `$ L* R                OriginPt=new Point(nowpt.x,nowpt.y);
                FoodPt=new Point(nowpt.x,nowpt.y);
' i& g  e% o: o" `                StartPt=new Point(nowpt);
( a- l* r2 G6 g8 E8 O$ z( _7 K                AimPt=new Point(nowpt);
                lastPt=nowPt;
  VR=vr;
1 H: y  _5 @' F0 f" B! f  id=idd;
  color=c;
  back_color=Antcolony.BACK_COLOR;
: p) ]+ m4 {0 ~7 k/ C' N4 O2 Q0 z  height=Antcolony.height;
  width=Antcolony.width;
  local_colony=colony;
1 ?0 _  e* l* n* v3 @; }                Phe=200;
8 L6 w- {6 q  o7 y% ?7 R                mistake=mist;
( p- N4 l7 h, v& P2 @4 f                HistoryPoint=new Vector();
0 a: R; E, ]7 U+ J! s0 N& v! z& p                Main_direct=-1;
+ J  b% j! g4 ]- M& N4 v                FoundTimes=0;
                Max_Pheromone=local_colony.Max_Pheromone;
" l9 P  K6 ~( L+ T, D+ ]9 e* [9 ^                Pheromone_count=Max_Pheromone;
                memory=mem;
                Count_distance=0;
! S! q8 `  L" I. Z# t" {2 _                Min_distance=-1;
& I- t8 U2 X, D }
        public void init(){
& \; h* e4 P- `% Q( {7 R4 q6 r          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
) X' F; I5 O$ y# j. J          FoodPt=new Point(OriginPt);
# `! }4 e" a4 X& L3 b          AimPt=new Point(OriginPt);
  y& O, P6 u  H7 S          StartPt=new Point(OriginPt);
# h0 |( t9 u( f( H4 q/ g6 M) `+ s          HistoryPoint.removeAllElements();
% j5 T% }5 i" H% B% p+ ^          Main_direct=-1;
          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
          Count_distance=0;
          Min_distance=-1;
' V7 P# q: [0 a( B2 R        }
" p! m" t5 C5 K" }9 P. T' y- ~% @ public void Draw(Graphics g) {
; E2 V- Z7 h: R0 o  a6 a2 P          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
  g.setColor(back_color);
  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
  g.setColor(color);
" Q! }# r* p6 i, ?  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
5 O1 A7 [# Z; R  n }
public void Process(){
        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
# R. g$ O. z$ [        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
9 \( |. N, }- d3 {1 R6 [% E9 o        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
8 t/ T9 x) f: t* b& W+ N; M        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

<P>        if(Judged==false){
          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
0 Q: ~" I2 C2 y. b              return;
+ o* W; M7 \* }) |          }
        }
/ z" I  }; f( r" A2 Z# _" [        Judged=false;
1 A# L8 E4 V' n4 f: f9 I1 x% ?        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
" `0 v. F  e& K4 Q4 ]1 h8 ?6 i        int deltx=0,delty=0;
8 b8 n0 P1 l6 w. P- Y3 x6 g4 ~% `        //direct是方向角，根据方向计算位移
' ?/ e% G) [6 ^' o        deltx=(int)(VR*Math.cos(direct));
        delty=(int)(VR*Math.sin(direct));</P>
<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
/ @7 a; i) _% \. I+ N        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
8 h5 j( [0 S1 n. ~        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
" Y% v1 p7 \) d1 Z& _<P>        //记录搜索的环境中找到的最大的信息素
+ ]- L+ F  m3 G3 K% [        int maxphe=here;</P>
% f7 c9 A4 ^+ _' Q) H* B+ W' B) b$ ?<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
          for(int x=-VR;x&lt;=VR;x++){
* ^7 C8 T5 N; k& G' y0 v+ P             for(int y=-VR;y&lt;=VR;y++){
+ |( y. E: ^0 i2 ]/ l# ?* J                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
1 y$ I/ h# z$ R                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
                int yy=(nowPt.y+y+height)%height;</P>
<P>                //循环的时候要除去当前点。
; x4 {6 I; G6 \6 N) e& W                if(x!=0||y!=0){
                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
<P>                  //如果搜索点的信息素比已经找到过的信息素多
  I% P1 d) Z. R8 @4 E/ W# L                  if(maxphe&lt;phe){</P>
+ o5 Y- `7 o+ q<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
- {  H, {, I4 w# o: R" [                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
                      double ra=Math.random();
) ^( A: C  v$ m; Z                      if(here==0||ra&gt;mistake){
" E- M/ J# z# \  x                          boolean found=false;
& h$ y4 `  V) r* W                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
( J6 V( j' X  U3 Z! S6 d& t  F                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
6 @/ |3 x. x2 `: c9 k: r, Q                          for(int i=size-1;i&gt;=size-minsize;i--){
3 A3 M2 }' M, R* G                             Point pt=(Point)(HistoryPoint.elementAt(i));
  V6 M+ h! D1 o1 F9 Y+ v$ c                             if(pt.x==xx&amp;&amp;pt.y==yy){
                                found=true;
                                break;
% \0 `7 g- ?7 h+ ]2 k# v5 g+ W                             }
                          }
                          if(!found){
9 z" r+ T3 }; C! _4 ?# g( T                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
) x4 v: \$ w5 n; o7 T: e% l5 ^                            deltx=x;
                            delty=y;
                          }
  w  p. q/ B7 I' V0 D6 b" _                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
0 C, s  y2 F$ h                }//end if x!=0
. p9 n# f( Z  [* |" N6 O            }//end for y
        }//end for x
        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
) y# ^" h: N& X: i% F        pt=Evade_obs(deltx,delty);</P>
<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
7 F: i- P" j% `# I. A        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
) C5 g" F# g! d. L          pt=Evade_obs(deltx1,delty1);
  I$ h9 j$ I; _; Z) W% \3 u6 |        }</P>
<P>        //播撒信息素
! m2 C: O6 H* ?* X6 \        Scatter();</P>
<P>        //记录走过的距离
        Count_distance+=Distance(lastPt,nowPt);</P>
8 o/ A$ d. S2 b% r( M<P>        //改变当前点位置
        lastPt=new Point(nowPt.x,nowPt.y);</P>
/ M" d0 z0 S$ S8 J0 G  t6 g<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
/ z  x- i" W- s( l6 }$ R        if(HistoryPoint.size()&gt;memory){
; ]* Y( G% E2 v# r8 a% r          HistoryPoint.removeElementAt(0);
        }
        nowPt=new Point(pt.x,pt.y);
6 C) F& \5 s/ |' F8 t$ f     }</P>
# E2 |  |% o* k<P>
        private void Scatter(){
4 D) |/ r, X- P  U$ r        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
1 t8 B* X8 z) g+ y# ?) `        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
            boolean ofound=false;
% m. w1 i" z/ i" ~; g            if(Phec!=0){
) x- W* h+ w# d4 l7 L7 F; s                //如果当前点已经有信息素了
4 d6 S5 z! l( s2 I6 u                for(int i=0;i&lt;local_colony.phe.size();i++){
6 H5 u0 T, }7 O$ q                    //在信息素向量中查找该点的信息
7 w# `) t7 t. P( E% F4 o5 f0 c                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
! \* u2 T, t; n- }% m                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
+ d, K- |7 e" j  M9 N7 q                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
                        int size=HistoryPoint.size();</P>
/ i3 K) T/ i3 W) v; \# h4 p<P>                        //如果在表中找到信息素，则用ofound记录。
                        ofound=true;
                        boolean found=false;
- S3 M  i+ `) x! Y$ U4 ]                        if(size&gt;4){
                           for(int j=size-4;j&lt;size-1;j++){
* v! M; ?3 g1 C0 J3 s                              Point pt=(Point)(HistoryPoint.elementAt(j));
                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
" b5 g' U( M+ |% x                                //如果当前点重复了以前走过的路，就不释放
                                found=true;
                                break;
                              }
3 C% e3 n/ e- `7 k& U' v+ R                            }
                        }
                        if(!found){
; P: W6 I- m& o. H! @                        //如果当前点不重复，则开始撒
/ t; i) W; p0 W( v4 s                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
<P>                             //让还剩下的信息素总量减少
+ k& w$ b: f# f4 E* h/ x0 X6 W                             Pheromone_count-=Phe;
6 v( T5 l* b) S# H* z                        }
9 v, p; W1 p* b2 K6 ~                        break;
5 ~  t/ K' V2 H! Q" E9 L7 }( c                    }
7 T0 e' k" Z2 B0 L$ ^                }
              }
          if(Phec==0||!ofound){
            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
3 N- y, j& p4 O$ Y                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
                ph.Add(Phe);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
1 Q6 l, y5 S$ u- L, N& N' B. X                local_colony.phe.addElement(ph);
/ t$ D1 x  K; i7 b7 }                //让还剩下的信息素总量减少
                 Pheromone_count-=Phe;
           }</P>
" ^' ~% m8 l: T<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
3 g6 y) i' K/ t: K+ h           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
        }
private boolean JudgeEnd(){
+ C& y. q0 {3 l! J0 h! I    //这个函数判断是否已经找到了目标点
2 H" ^  t$ \% a$ k& y    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
    if(kind==0){
( t/ R, A7 H% r5 q+ q        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
! L: V/ W' t# H; Q2 _8 ~        int i;
        for(i=0;i&lt;local_colony.EndPts;i++){
  |: m# y, ~& L+ g3 J0 W            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
- {' W% h6 m% s  U( {6 n3 y              //如果找到了食物，就直接移动到食物点
) p' _2 C4 U4 ?              lastPt=new Point(nowPt.x,nowPt.y);
4 n, g4 S% w8 I) L1 R0 u6 g" c              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
! b* M' d; m! `4 o              }
              //清除总距离记录
# U2 T/ a2 {: }5 P: W              Count_distance=0;</P>
<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
              AimPt=new Point(OriginPt);
7 v9 W1 J6 s0 _) {              StartPt=new Point(nowPt);
              //并把当前点标为自己找到的食物点
* T9 P, S9 |7 n4 \8 h              FoodPt=new Point(nowPt.x,nowPt.y);</P>
<P>              //找到了食物就把找到次数+1
3 m# H7 x. k. m- O/ V              FoundTimes++;</P>
<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>              //重新把自己能撒的信息素置为最大值
              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
1 }/ }: O3 n/ H. l. y; {3 X- u" V<P>              //返回找到为真
              return true;
1 U  j& c; Q" U3 p5 ^& a/ I' e            }
        }
      //否则没找到
* v8 i" n$ [  C- m) {      return false;
    }
5 _$ L; C+ k$ H9 I" X    if(kind==1){
        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
6 [- y3 \. O6 ]; O" L+ F        if(Distance(nowPt,AimPt)&lt;=VR){
            lastPt=new Point(nowPt.x,nowPt.y);
            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
<P>              //计算最后的总距离
7 a" n* s" z) c              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
" o! T2 C4 G/ C6 [              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
" V% g8 \- P9 z              }
: ~7 P8 L, \) P- N$ d6 s              //清除总距离记录
              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
9 s" o! r7 F+ Z            AimPt=new Point(FoodPt);
' |! L% r$ d; q- |+ ^  F& L% X) r            StartPt=new Point(OriginPt);</P>
3 d  v4 j, }5 L% D0 h& c! b<P>            //重新置信息素
( V: U5 K" b! W2 f2 }- a. G            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
0 q' A# G: a  }4 n5 p) q4 l            HistoryPoint.removeAllElements();</P>
8 k9 a7 s4 ~9 c' X<P>            //主方向反向
7 P  C! _: h$ A+ V% J, i            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
            FoundTimes++;
            return true;
3 L' m$ P: Y* T, x% W        }
        return false;
    }
0 }3 ]2 }. _" ~7 Y2 ~' V0 W    return false;
) C% `  S0 f8 E}
        private double SelectDirect(){
) P3 z) a+ d* m                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
! n$ v2 j3 u* A/ f8 j1 }                if(Main_direct&lt;0){
& n4 ^4 _$ m% U( S                      //如果目前还没有主方向角，就随机的选择一个
        e=2*Math.PI*Math.random();
9 z0 D' l" X+ I! G6 g) c& K                      Main_direct=e;
" S6 k8 k8 U( j) G3 q/ q2 ]* q4 ?                }
& M. D9 j$ O" `8 q                //选择主方向角
                direct=Main_direct;</P>
  ^- G* \) d' ^9 a5 K8 F<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
# S+ N1 E, ]& [2 R  ^2 W+ \5 k; e                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
                double re1=Math.random();
3 W- G7 [" j+ h3 A% v                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
: _" n& S# O8 G0 F                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
                       Main_direct=GetDirection(pt,nowPt);
. I' V, K% D; F3 n' O                    }
% n6 B+ B4 C+ J1 O6 O0 H& e( z+ }                  }
; h( {1 v3 Y# }                }
               return direct;</P>
<P>        }
        private Point Evade_obs(int deltx,int delty){
1 B) X9 O& `3 E9 _              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
8 i# j6 U" ^  H/ `# ~              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
) h% q' A: j4 t' X8 F# y              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
6 s" v: o3 }: d2 c3 ]* R+ R              Point pt=new Point(0,0);
' }5 O3 v8 E. a2 A( _) `7 e4 W( Y              int x,y;
) U% S! W4 A9 P) W* y              int delt=deltx;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
              if(delt==0)return nowPt;
+ B0 x8 J0 [5 y0 A) y+ N# H3 j! l              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
4 V9 r4 u$ H3 c7 u' }9 t                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
- W, y$ \4 Y0 J" ^                  x=(x+width)%width;
                  y=(y+height)%height;
                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
6 Y/ ^- J. x4 z' p% T4 I- C                     //新目标点为障碍物前方的点，主方向随机取值
9 B7 G) c2 C2 w5 F) }# ~3 a                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
; a% ^, R" x$ N! n9 D                     double disturb=4*Math.PI*(Math.random()-0.5);
                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
3 d9 E* S% ?/ y2 j4 a' X  D6 J& f                     break;
7 d1 ]# N- {6 Z: a4 B                  }
                  pt=new Point(x,y);
                }</P>
<P>                //计算得出实际能够到达的目标点
  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
5 u* u" D& e) m7 h         return new Point(x,y);
        }
! y7 O3 y8 @5 Y6 n" ?/ t        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
" w2 u2 s2 P7 [- M# ]9 f4 r" J/ f2 n        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
; J; @  j% ]8 f        //其中方向角是所有可能的角中使得两点连线距离最短的角。
               double e;
               int deltx1=pt2.x-pt1.x;
; i) G7 `% N8 d. g/ z7 j4 [               int deltx2;
; w6 Y/ [5 U+ t6 N3 O0 y               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
               else deltx2=pt2.x+width-pt1.x;
               int delty1=pt2.y-pt1.y;
: T! }% ^6 c: C; B               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
               else delty2=pt2.y+height-pt1.y;
' Q/ G" `0 G2 l               int deltx=deltx1,delty=delty1;
               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
( ^7 v5 \& A$ `! s5 w               }
$ K! R/ o, o6 }% }2 ?; Q        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
               }
               if(deltx!=0){
& k4 {7 [7 H4 q/ V                    e=Math.atan((double)(delty)/(double)(deltx));
1 G; T/ e" G* Z1 J/ i, W1 n+ ^                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
                       else e=e+Math.PI;
                    }
                }else{
                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
+ i3 G$ O0 A; K* A: k) K                }
$ F! b. p7 L/ P/ \$ |, M/ d+ S                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
" u  R) R, X( A+ H. H! ?        }
        private double Distance(Point pt1,Point pt2){
& {2 N! n# W$ [5 l        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
% g- ?2 u* E6 F8 P        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
            int dx2;
            int dx,dy;
            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
. R# k# `; p9 U            else dx2=pt2.x+width-pt1.x;
& o" T  e  n- H5 n            int dy1=pt1.y-pt2.y;
            int dy2;
! L" i& F# @+ u% [  q& ~            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
% ?, ]8 }: J4 |3 o; g" P            dy2=pt2.y+height-pt1.y;
& M3 U: g9 [5 t9 [            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
# }& I( Y+ Y. V  {            else dx=dx2;
" ^7 |* E2 V0 G8 D( O. L            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
4 O4 P" N1 U' C; _& p4 P+ I            else dy=dy2;
; W! X6 r& k/ B; J  [8 T: H  r: d            return Math.sqrt(dx*dx+dy*dy);
        }
    public void clone(ant ant1){
        //把蚂蚁ant1的属性拷贝到本蚂蚁
6 O. \9 ~0 E! j     nowPt=new Point(ant1.nowPt);
  j4 t6 m. a5 @0 [5 Q5 r* m        OriginPt=new Point(ant1.OriginPt);
2 ^6 L: T+ \5 H6 t  I        FoodPt=new Point(ant1.FoodPt);
3 h0 L, e  j' h* z4 {8 I9 `: d        StartPt=new Point(ant1.StartPt);
9 s+ U9 i# }6 E- j        AimPt=new Point(ant1.AimPt);
# k, c9 m: ?$ a  t1 ~. d        lastPt=new Point(ant1.lastPt);
        VR=ant1.VR;
        id=ant1.id;
        color=ant1.color;
        back_color=ant1.back_color;
        height=ant1.height;
        width=ant1.width;
        local_colony=ant1.local_colony;
        Phe=ant1.Phe;
        mistake=ant1.mistake;
8 q4 Y1 ~7 `( i6 H        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
& ]5 |3 M8 c( K  I. @+ y" F        Max_Pheromone=ant1.Max_Pheromone;
' J, d. g+ I, K        Pheromone_count=ant1.Pheromone_count;
8 V( q* D6 D- l# D% l. Z        memory=ant1.memory;
5 Z  y0 a7 F' q) {        Count_distance=ant1.Count_distance;
        Min_distance=ant1.Min_distance;
    }
}</P>