[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
  o' _4 z+ p9 i/ o- f% G( U/ [/ {9 Y<>package ant;
/*
% i5 j/ `5 F1 H& c4 `( \) { * @(#)Antcolony.java 1.0 03/05/22
9 z  _; X1 L# Z. |& R2 F *
( B- `+ [( q2 q4 B# c3 q: b" d * You can modify the template of this file in the
* directory ..\JCreator\Templates\Template_2\Project_Name.java
*
* You can also create your own project template by making a new
6 E7 m3 A4 K: W4 O * folder in the directory ..\JCreator\Template\. Use the other
3 w1 e' N5 e7 i2 S. ^9 c% m( c * templates as examples.
*
" s5 f0 X- w% T/ `  { */</P>
<>import java.awt.*;
import java.applet.*;
( A. ^! F( y# L  g% Gimport java.awt.event.*;
1 M* k$ u+ S" k+ C7 N" {$ W$ e- Fimport java.util.Vector;</P>
5 o7 C3 o0 N; W! c- K" q2 o<>class AntCanvas extends Canvas
. H( r: j* e6 R9 r" B9 I{
    //画布，一切画图操作均由该类完成
//Image image;
Color obs_color;//障碍物颜色
/ i/ H3 W- p3 I* W Color origin_color;//我的颜色
7 K' N* T! ]5 X3 O) X, |& J Color back_color;//背景色
% r6 O* h2 ]' k: X% Q$ w        Color end_color;//食物点的颜色
5 V! {0 B3 ]& L. \ //boolean first;
0 j  e/ o0 i( |, E' l; s. {) g boolean reset;</P>
<>/* public AntCanvas(Image img) {</P>
<>  super();
   image = img;
  obs_color = Color.white;
  setBackground(Color.black);
0 K# J7 ]' k, z3 U7 T1 r  setForeground(Color.white);
9 h: C5 b8 f9 Y" t' ~  first = true;
  reset = false;</P>
5 p9 Z* k6 N- i- G! N- R<> }*/</P>
3 o& }3 N: E" w<> public AntCanvas() {</P>
<>  super();
   //image = null;
   back_color=Antcolony.BACK_COLOR;
  setBackground(back_color);
  setForeground(Color.white);
) X' u4 i/ m( @  obs_color = Antcolony.OBS_COLOR;
0 P3 {2 v" T. x0 _) H) C  origin_color=Antcolony.ORIGIN_COLOR;
                end_color=Antcolony.End_COLOR;
  //first = true;
  reset = true;</P>
4 c* U0 f1 c9 r) m/ {<> }</P>
$ I9 f3 k( B* n2 U' d5 T<> public void Clear() {
        //清空画布
' f) K# a/ E! a. ?3 t" N' F) V  reset = true;
$ M! {& I! q, `0 p) a- o* p" ^! z4 a  repaint();
}</P>
<>
public void paint(Graphics g) {
  int i;
& h. W, g" A! }; d                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
  g.setColor(obs_color);
  A4 ]0 ]  X# z! p; C  for(i=0;i&lt;Antcolony.obsCount;i++){
! u9 P( B- p3 d   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
% d4 F5 L8 _5 F" ^& h<> }
" d/ k+ N: N$ I+ M public void process(){
        //处理动画的过程
  Graphics g=this.getGraphics();
- v7 x1 E4 d8 z, ?                g.setColor(end_color);
   for(int j=0;j&lt;Antcolony.EndPts;j++){
                  //画所有的食物点
                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
                }
- P+ o& w, N; p: q8 `8 O4 d                for(int i=0;i&lt;Antcolony.antCount;i++){
                  //每只蚂蚁开始决策，并画蚂蚁
" Y: x0 T& d3 ?% E( o  k4 p   Antcolony.ants.Process();
& g1 U! A7 q  Z8 R6 x0 i   Antcolony.ants.Draw(g);
  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
: v5 P4 m  o& n, x6 o                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
6 O7 t. h4 }' z$ q! u4 }# k                        case (1):
- ]1 I' T# v1 M6 j/ M                            v.Draw(g);
6 a; C/ Z5 K- W5 y( J0 O. h; s                            break;
                        case (2):
                            if(v.kind==1)v.Draw(g);
                            break;
                        case (3):
                            if(v.kind==0)v.Draw(g);
                            break;
                        }
                        v.delimit(g);
* U' i$ B# ?* X5 B! y! Y7 @& q                }
           g.setColor(origin_color);
                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
# x) S* o: y& {5 l( I" M                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
                }</P>
" ^) k$ Y, j" r<> }
Graphics GetGra() {</P>
<>  return this.getGraphics();
}
$ K3 h  D9 d% C; r}
public class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
static Color OBS_COLOR=Color.red;//障碍物的颜色
/ d5 s" |/ s2 w1 d, v2 @# k static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
2 [: w4 L2 B5 ~3 p. s9 K  t static Color BACK_COLOR=Color.black;//背景色
static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
1 ^$ l( F8 j* q/ i  T+ R AntCanvas canvas=new AntCanvas();//画图用的画布
9 z( j. G, u" o# M; v int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
# {& y2 V7 q, C) V* e/ j        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
. x8 e# o- [% j! G        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;//环境的长和宽
static int antCount;//蚂蚁的数量
: @9 f3 ]% S, t3 F- p5 O* x        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
& `& M/ O/ H1 v- m        static int FoodR=10;//食物和窝产生梯度的信息素的半径
; u7 a# f5 @1 Y5 }! S$ ? static ant ants[];//蚂蚁数组
        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
% J0 b: z) r. l& |0 m* y. _        Button btnStart=new Button("开始");
        Button btnReset=new Button("重来");
        Button btnMap=new Button("编辑地图");
& i4 H4 Q  j6 i. n5 P$ l& x        Button btnConfig=new Button("设置");
  g% s- }2 O, E3 n7 g        Choice choPDraw=new Choice();
public void init() {
: W% f+ v* D) d) z  ?0 w& Q8 G                //初始化函数，先画各种控件
  setLayout(new BorderLayout());
                Panel pan=new Panel();
& K( \$ C. r4 ~! u                add("South",pan);
                this.add("Center",canvas);
                pan.add(btnStart);
                pan.add(btnReset);
                pan.add(btnConfig);
1 C0 a8 X% c( |/ Q; r& y0 t5 B                pan.add(btnMap);
                pan.add(choPDraw);
2 z- D# w0 D0 S' d                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
                choPDraw.addItem("画窝的信息素");
! g: q! g0 u: E" e' q                choPDraw.select(2);</P>
<>                //初始化各个数组
  obs_grid=new int [width][height];
                phe=new Vector();
: }6 Y1 f$ n: p. S0 M2 Z* `                Pheromone_grid=new int [2][width][height];
" _/ g: C* U2 x( Q                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
7 L  Q) ?' W8 h' w    obs_grid[j]=-1;
& y5 ^' b' W; \% \3 i* ?                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
" q) X- o/ r$ w* n) v$ `, o) q9 p   }
  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
  ants=new ant[antCount];
: v4 P; `  y! k1 K1 L        for(int i=0;i&lt;antCount;i++){
          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
# Y; B* u; U* k. u0 H8 ], E7 r                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
% t. a' x: ?2 j  Y' @% M! w  w8 Z                Maps maps=new Maps();
                maps.LoadMap(grid,0);
+ x6 P8 [3 u% k. n; m                //初始化地图
& b9 s+ N$ Y! a; q$ z$ O                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
5 N2 z$ f$ L, Q& K  reinit();
}
  [- C9 }6 F+ k; v) X" _& I4 U        public void reinit_map(int grid[][]){
) Z$ x5 p" p! h$ M6 ~6 I                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
5 ]5 ^+ I9 z: s3 H  ?<>
                obsCount=0;
, \* H$ `% s: A9 l3 J" B                EndPts=0;
                OriginPts=0;
" |* b! A/ @8 R( K! H                obsP=new Point[width*height];
; }% r$ V1 Z' ]& ]                OriginPt=new Point[100];
                EndPt=new Point[100];</P>
3 M5 s9 F( ]' V+ F) d' `<>                //清空obs_grid和Pheromone两个数组中的值
- D6 J2 g$ Z, m                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
/ r% s" c5 O9 u6 J+ U# Y    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
6 S- D) {) b. F   }
) n: [6 u+ |1 ]  F  A  }</P>
+ P# q. _0 g: {. M! T' [& `% J<>                //从grid数组中读取信息
" g  J- Q+ i; y3 M# `                for(int i=0;i&lt;width;i++){
                  for(int j=0;j&lt;height;j++){
! e: i  E& o( k# `: L$ I% S* j                    switch (grid[j]){
! \* Q$ G+ o8 t: S% w4 H" k! B                    case 1:
                      //如果grid[][]存的是障碍物
                      obs_grid[j]=obsCount;
                      obsP[obsCount]=new Point(i,j);
# |9 x3 I  A7 b8 c/ g+ \5 }                      obsCount++;
                      break;
                    case 2:
* L9 D8 X4 C1 l, f' Y" @; }                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
% y2 J$ ^- d& U! t; `+ j1 ]& a                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
                      }
  Z4 a- u& N2 V. [! [                      break;
                    case 3:
  G: x& L$ ^2 @9 w& e                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
. L/ f+ }6 _  ]# V* F" X                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
2 I6 w  ~1 g8 L                          EndPts++;
. e- N; K, Y+ s, o                      }
                      break;
                    }
                  }
. H4 _8 l; `7 i# l; ^3 m                }
6 e( W  h- N  T. d% C3 v            //如果没有指定窝，则随机的选择一点
            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
* c7 q' v3 @$ C' a: h! w* o                int  j;
. R0 z  H" ]! j% }1 _3 P/ [                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
! l$ g! H: t- t3 o                    OriginPts++;
. K+ f: H. z; h) u" X) U3 S2 l. E9 t                    break;
                  }
  o- q* k% B2 U; _                }
                if(j&lt;height-1){
                  break;
                }
              }
            }
# Q5 z0 T# V1 P9 v- B& L1 T        }
public void reinit(){
                //重新初始化整个环境</P>
<>                //先停止程序的运行
                running=false;
3 f& z6 Z& u8 Y. z* B! F5 k, b                btnStart.setLabel("开始");</P>
% s& D+ }0 X$ k9 c5 _5 o7 V+ Z<>
  //清空所有信息素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;
                                }
   }
  }</P>
0 S- G, j: p9 {<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
* Q; [1 \  Y( c. s5 O: R                        int index=(int)(OriginPts*Math.random());
" G  T) z& z. C6 a9 B          ants.OriginPt=new Point(OriginPt[index]);
0 Z' S8 c) J! C# ^/ P$ s! L# Q                        ants.init();
  }</P>
; A* N; i) ^" e, j<>                //清空信息素向量
9 L+ t4 Z& c0 Y. |$ X                phe.removeAllElements();</P>
6 a7 ^& o, i- U3 _<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
' x2 B4 K1 I6 Z8 y5 H: p  for(int i=0;i&lt;EndPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
! e) U8 |  a( Y! r                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        for(int yy=-y;yy&lt;=y;yy++){
                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
" T4 C+ V7 E2 M3 k( @                    }
7 w( I5 v+ |- G# @                }
- j) {  r! j  }2 K  H# i. j                for(int i=0;i&lt;OriginPts;i++){
% i1 _( Z! G5 A9 \, e                   for(int x=-FoodR;x&lt;=FoodR;x++){
! j& C3 o. b  N" a1 O  w* \, B0 w                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
  x; l8 o! ]" g) k& s                        for(int yy=-y;yy&lt;=y;yy++){
& @: u5 B9 f8 F5 s6 ]                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
# M/ \8 L9 U# N& p- x                        }
                    }
, V$ z7 L2 Y( j0 O$ n% E4 ?                }</P>
+ f7 l, W, n8 I: l; g& t<P>                //重画
  canvas.repaint();</P>
/ X* n% i2 W4 P* \* B<P>                //让程序开始运行
                //running=true;
}
" C& q! U5 D9 G  i public void paint(Graphics g) {
0 ]/ h" y; ?( v1 N" ]! B- u  canvas.repaint();
( ^; O2 f* E8 p- U; y }</P>
- M$ T( T8 }9 C+ [) T& i" u% ]1 Q; m<P>
public static void main(String[] args) {
2 \; ], P( V8 m1 \    Antcolony applet = new Antcolony();
( F4 Y3 i* _8 z7 j    applet.isStandalone = true;
    Frame frame;
+ ?: L) x' r3 z' _    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
$ X  H5 J: d4 f2 A0 j/ l9 O        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
          System.exit(0);
; P! g7 ~# C. T3 `2 G( C        }
      }
      public synchronized void setTitle(String title) {
        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
4 t5 y" H; O3 k1 }$ K. b3 I0 C      }
    };
" ?; F! {6 `* A9 M    frame.setTitle("Applet Frame");
& k' S- X0 F  B1 l3 N4 h! `. y- F    frame.add(applet, BorderLayout.CENTER);
    applet.init();
    applet.start();
    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);
$ p, \1 d4 c3 F, s: x  }
  public void start()
  //下面三个函数是控制线程的
{
1 W* r, y% |8 H5 n  if (runner == null)
# \+ N& Y7 y% C# r5 P  {
   runner= new Thread(this);
+ n! W, o; F. U9 a9 K# h* }! N   runner.start();
   //running = true;
  }
}</P>
: o- Y3 }& |0 }- |: ]<P> public void stop()
{
: H: n0 B% j2 s! V+ t% U$ n6 u  if (runner!=null)
  {
8 n, u# A& d3 v) W; x( }! ?8 Q   runner.stop();
   runner=null;
   running = false;
% ]$ R; @# f% Q; M5 {2 _5 p  }
& X  E- w% f; }4 p. ? }</P>
9 ~: a/ O: w0 N<P> public void run() {</P>
<P>  int i;
& ~. @9 S5 u5 L" w& q                //线程一直运行下去
  while (true) {
          if(running){
       //如果开始动画，就进行canvas的处理
" z) }9 ]$ O9 h0 N- O2 C                          canvas.process();
                        }
    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
4 K$ b$ O" _- j$ m/ I   }
! o; c0 B9 L7 A, e( V  }</P>
<P> }
        public boolean action(Event evt, Object o) {
5 _, c& n5 b5 |2 p* G8 Y+ z" |      if (evt.target == btnMap) {
$ w  J3 X) V7 _1 I) U3 s                //开始编辑地图面板
3 s2 L+ m5 `7 z9 _   running=false;
' N: ~5 l; x& L                        btnStart.setLabel("开始");
- {- a$ n. o0 l% W6 q: n1 K   MapPad ctl = new MapPad(this);
, p( |& W6 B% r# _                 ctl.setSize(308,380);
( ]8 o2 ?: a6 g/ Q3 E5 y                        ctl.show();
                        return true;
  }else if(evt.target == btnStart){
. M' }& s7 r5 O! j                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
                    btnStart.setLabel("停止");
' h2 S. [9 j6 J% u" z& \: E                    reset=false;
                    running=true;
                  }else{
) k3 o! Z8 ]$ {6 W                    btnStart.setLabel("开始");
1 \# a8 u+ {9 j                    running=false;
                  }
                  return true;
6 O4 C( n9 c1 x% P& V. {% u                }else if(evt.target == btnReset){
                  running=false;
/ D9 P' _- B# X8 M                  int j=0;
2 r. u- a* [# V2 q3 _/ t                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
  ^+ H# y( B$ F                  repaint();
( f6 x/ F! P2 c& f7 e  b                  btnStart.setLabel("开始");
                  return true;
                }else if(evt.target == btnConfig){
# o) J0 G  a% B                        running=false;
                        btnStart.setLabel("开始");
     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
                        ctl.show();
                        return true;
                }else if(evt.target == choPDraw){
2 S: v- o+ f9 }: x/ o                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
                  return true;
/ t) ?4 C: l/ R- ~; @+ Q' Y. w                }
& A# o- N7 z  j( ~) W+ h& f, Q                return false;</P>
3 g; f6 p+ Q7 B7 R) @* C4 i<P>        }
# V: H+ ?1 J2 j! m4 p3 ~ /**Destroy the applet*/
& e' R3 l( A5 g  public void destroy() {
  //当结束程序的时候，把线程也结束
    if (runner!=null)
) H3 r& S# N0 [    {
       running = false;
       runner.stop();
       runner=null;
/ T5 e+ f! a/ |5 w  c, T5 ?) X% E    }
  }</P>
<P>}
# X0 N; [, ^  o& y+ z</P>

, T( q) f4 U: j

" A/ O2 c$ f# l<P>package ant;
import java.awt.*;
& H3 r9 [2 p  N% }, h/ oimport java.applet.*;
7 E2 H9 }: I8 m2 Nimport java.util.Vector;</P>
<P>public class ant{
, Z8 }. T( B% S: [( J: J1 }* @$ O Point nowPt;//当前点坐标
int VR;//速度，每次蚂蚁能走动的最大长度
4 Z5 |8 t, M. ^4 _) R+ W+ j: z  int id;//标识
2 c5 e5 p8 ~% V- r( i  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
# \$ F5 h$ R% H( X  S Color back_color;//背景的严肃
int height,width;//世界的尺寸
        int Phe;//每次释放信息素的数值
/ [2 o6 d: O+ O2 t- G$ ]$ J+ s Antcolony local_colony;//主程序的指针
! s! O( l0 d5 r& ]8 O: ]: @        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
        double Main_direct;//主方向
5 \5 H1 H) F! g        Point FoodPt;//记录的食物点，是否找到时候判断用
        Point OriginPt;//窝的坐标
  _/ ~: S, W6 S4 {0 l* \* Y. {        Point AimPt;//目标点，是窝或者食物
9 L. D4 {  n) B1 s+ L9 O# N$ u        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
# a8 b5 A9 [9 F8 r  C3 ^        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
0 v& u7 i2 T# ]* N        double mistake;//犯错误的概率
, x6 J# Z1 \( V' a; g        int memory;//记忆走过点的数目
        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
& Q+ X2 H' t; j4 P/ { 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);
4 |* o7 |9 h3 C6 b. U                StartPt=new Point(nowpt);
4 k! C2 x! y/ h  v- F. W- q1 t                AimPt=new Point(nowpt);
6 e+ e% F. U2 P, {) U3 E                lastPt=nowPt;
  VR=vr;
$ J6 x' a% D8 h, w7 s$ V  id=idd;
  color=c;
! `4 O. |  C3 E. |$ b: w$ A$ g  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
  width=Antcolony.width;
' f+ V1 |9 L9 S( h' @  N1 [: q/ t' R( x  local_colony=colony;
+ C4 T- g1 N) y6 \! B2 Q                Phe=200;
! p5 B6 f3 `$ m: q                mistake=mist;
$ u7 L8 ?# W# v                HistoryPoint=new Vector();
                Main_direct=-1;
                FoundTimes=0;
% _6 K0 r  S4 x                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
1 G. b' ?7 V% `/ g                memory=mem;
                Count_distance=0;
                Min_distance=-1;
  P% c% y, ^' {) W! b) Q }
        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
          AimPt=new Point(OriginPt);
9 k; E, k. O/ u2 J6 P8 \8 s          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
* I# p- N& t9 Z4 b& U- {          Main_direct=-1;
          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
          Count_distance=0;
          Min_distance=-1;
: j* A9 f  ~5 x: v5 F3 m        }
8 p7 o. P# B( w( L% C1 \) W, L2 p# l public void Draw(Graphics g) {
          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
# t  z6 L# x( k( i8 t( Z) U/ }  g.setColor(back_color);
  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
$ i/ R- W; x, P) F* D  g.setColor(color);
! u) M2 g2 Q  e2 a" z0 w- Q* C  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
% n- Z- q- S1 [2 C }
2 m% O& T1 d- \; [ public void Process(){
        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
7 T% G9 i, r' G6 _, d, I        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
& i0 l0 u2 Y5 p- e* o; G        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>
; P8 ^2 r8 P) w) U" h- S
4 D3 V' U0 Y! t7 v; [7 o. n<P>        if(Judged==false){
( }4 o( y8 N4 [* W          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
! E8 ~% _: V4 c          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
1 o' [' {- e' I: n: X& m          if(JudgeEnd()){
: q! I% S5 u# ?( Q              //判断，如果找到了目标点那么就退出该程序
3 x9 P  R  U; L" T; r              Judged=true;
              return;
' z  f. i0 c1 z  g) s! b+ F* ?          }
: N8 h  a! K, N& i        }
        Judged=false;
  ^  h, G! @! q( a* k% l" R        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
' V2 B/ g9 j2 L6 }- {<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
        deltx=(int)(VR*Math.cos(direct));
        delty=(int)(VR*Math.sin(direct));</P>
<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
3 [2 G  q: T$ |$ P' V3 K        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
1 d$ X: ~  [3 N<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
" z; K$ L, B3 L2 {<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
! H- l. M. l: L          for(int x=-VR;x&lt;=VR;x++){
# ~7 r) a8 r" Z- L             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
7 V: T7 {5 w/ M( Y5 V7 |                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
8 y( w! e. V. x) D3 R, `                int yy=(nowPt.y+y+height)%height;</P>
<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
' ?$ Q+ x1 T, `3 g" s                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
5 k- I: S0 T/ w+ h<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
0 Z2 F* f7 ~1 h: {, ?% i  V6 \<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
3 @2 U; V/ i) M1 Q, J, c8 k                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
/ K  T- i2 L. H+ }5 N, ?( s5 _  J                      double ra=Math.random();
7 K) b2 [% L( t; F, o: N                      if(here==0||ra&gt;mistake){
                          boolean found=false;
2 B9 d$ Z/ z; K9 l, M  @                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
2 e+ P8 [4 B  ^6 j) L& g                          int minsize=memory;
0 [' B' [6 Z1 V                          if(size&lt;memory)minsize=size;
6 T% D' [. D  t4 i, x0 B! K% x                          for(int i=size-1;i&gt;=size-minsize;i--){
9 B; l. W. q$ e                             Point pt=(Point)(HistoryPoint.elementAt(i));
6 Z% e% d- S7 R4 u/ \! U$ b                             if(pt.x==xx&amp;&amp;pt.y==yy){
% o& X0 g. ^. P& Q, ^                                found=true;
                                break;
* s) q7 ~) |& q# x8 a( S9 b                             }
                          }
                          if(!found){
                            //如果没有原地转圈，那么记录信息素。
- x; q  W- `9 G+ w; u                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
, l& J6 s0 P+ c# X3 _) ^0 k                            deltx=x;
* \4 S. ^+ B+ p2 a+ U                            delty=y;
! }0 T5 v- U! \' Q                          }
                      }//end here==0||ra&gt;0.001
/ m" U( K) Z  X% y                    }//end maxphe&lt;here
                }//end if x!=0
            }//end for y
  X" ?4 K2 |$ v6 w        }//end for x
        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
        pt=Evade_obs(deltx,delty);</P>
4 w/ Q$ _* n$ i3 b7 O# Z# t: q<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
& X* Q" ]7 d4 p5 a5 J) X) [$ D          pt=Evade_obs(deltx1,delty1);
' K' ^  D8 V3 ~/ ~        }</P>
<P>        //播撒信息素
1 C  A+ i, t. w/ o9 P        Scatter();</P>
<P>        //记录走过的距离
        Count_distance+=Distance(lastPt,nowPt);</P>
) P! B, ^' y. t! N7 `7 E<P>        //改变当前点位置
( Q2 A. g6 f" N# f, \        lastPt=new Point(nowPt.x,nowPt.y);</P>
' V. L6 J; U6 G( o' w<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
% p/ Q8 n* `& V- r+ u, v        if(HistoryPoint.size()&gt;memory){
          HistoryPoint.removeElementAt(0);
        }
$ M' ~8 a# W+ |: Y        nowPt=new Point(pt.x,pt.y);
  s4 A! M# @: h5 `( n1 T     }</P>
5 S8 d# z9 v2 [3 P<P>
        private void Scatter(){
: b0 C6 D; }/ l4 G; L0 l6 U9 M        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
            if(Pheromone_count&lt;=0)return;
) y0 F9 ?( A% Q" n            //决定释放信息素的种类
            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
            boolean ofound=false;
            if(Phec!=0){
, R% j' w/ K4 ^- j: a+ Z5 G                //如果当前点已经有信息素了
- v. r2 e; D: U9 s, a                for(int i=0;i&lt;local_colony.phe.size();i++){
' Z- b$ e( n& l+ m! v- ~                    //在信息素向量中查找该点的信息
1 n9 c& a+ g- l                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
                        int size=HistoryPoint.size();</P>
2 _. ?3 s# t3 Z! t/ L<P>                        //如果在表中找到信息素，则用ofound记录。
                        ofound=true;
5 o  o/ t* S$ {) p% T' n0 g4 I                        boolean found=false;
                        if(size&gt;4){
                           for(int j=size-4;j&lt;size-1;j++){
                              Point pt=(Point)(HistoryPoint.elementAt(j));
: A+ J' x* Q) T5 B, F, w8 u                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
- }8 M6 t# b& |                                //如果当前点重复了以前走过的路，就不释放
                                found=true;
( ~. T% ]4 k* B* b) a! v5 s. q                                break;
3 P; j+ n% \$ V) B8 Z9 R* C! i7 s                              }
                            }
. T. w1 U7 m$ k9 A* o                        }
7 @1 D$ s  }9 q+ v3 ^                        if(!found){
" J* E9 j1 }( ^0 A1 s9 c% u                        //如果当前点不重复，则开始撒
. g. I% M; @" l0 T+ ~5 E( ?: J5 a. [! q                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
, f4 A& q+ M! O3 P) @6 n  f& Z+ x<P>                             //让还剩下的信息素总量减少
                             Pheromone_count-=Phe;
                        }
: p+ D$ h8 ~5 j, |, ~' g                        break;
                    }
3 F) K3 B( o9 p9 E. b, q                }
' C# n3 [  e# l5 Y/ I+ T  w/ V  g              }
- H, A; k1 S% o+ D, P          if(Phec==0||!ofound){
            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
                ph.Add(Phe);
# O! f8 x# u" j& D                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
                local_colony.phe.addElement(ph);
                //让还剩下的信息素总量减少
                 Pheromone_count-=Phe;
           }</P>
) j5 H+ \' I5 V& V  I( q+ @  t<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
/ ~/ z, S; i' y( I3 {' p( g* l, w           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
; v% t. O. c! @; ^( i2 S1 q! C           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
# {- U! S$ e6 n  M6 y<P>           //如果剩余信息素已经太小了，则按照等差数列递减
" `8 a' ]5 C- C9 t           if(Phe&lt;=10)Phe=10;
9 z& ?0 l5 X. |1 W! c2 e5 p& l; W        }
, b1 G: M' v+ [. d8 y" eprivate boolean JudgeEnd(){
    //这个函数判断是否已经找到了目标点
    //首先获得当前蚂蚁是正在找窝还是在找食物。
5 v" ~; Y/ e+ R& K1 `  D  G5 `    int kind=FoundTimes%2;
    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
        int i;
        for(i=0;i&lt;local_colony.EndPts;i++){
# D% e) P% S; K: x$ C% \            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
              //如果找到了食物，就直接移动到食物点
/ W. T, y9 f+ D6 ~5 H) ~( R, ~              lastPt=new Point(nowPt.x,nowPt.y);
4 z" I8 r1 ?8 k8 y4 @& F              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
' Y3 s. N) j/ P# S% V+ G4 S# l) k<P>              //计算最后的总距离
" W% C0 U8 y& k, D5 X5 Q. n              Count_distance+=Distance(lastPt,nowPt);
- D5 V) ?) q. {: }/ x! Z, \5 j              //比较大小，记录较小的距离
! `/ e- I1 r( T% M. z. q  Z7 x              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
" G) L: W; `6 [9 O                 Min_distance=Count_distance;
' P( w' K* c/ R              }
# |* u0 j% A- ?3 \0 m. g% Q3 d              //清除总距离记录
              Count_distance=0;</P>
<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
              AimPt=new Point(OriginPt);
( l3 p0 F2 W+ P* {7 w" h              StartPt=new Point(nowPt);
# h1 h2 L. F* Z' s# m# J9 M              //并把当前点标为自己找到的食物点
+ \# L' a" s6 U  u/ O              FoodPt=new Point(nowPt.x,nowPt.y);</P>
<P>              //找到了食物就把找到次数+1
              FoundTimes++;</P>
$ m/ ?9 `3 v& f: L<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
6 X' I' {6 {; s1 j7 b% ^2 w& ^<P>              //重新把自己能撒的信息素置为最大值
              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
<P>              //返回找到为真
, ]# c6 x+ c7 O. O3 M* A              return true;
, [/ \# F5 r# |8 O) I! b: q8 R/ M            }
        }
      //否则没找到
$ t0 [- ]1 h3 D( t+ R      return false;
    }
    if(kind==1){
9 `% Z1 k0 Z2 g( d: T" p2 m5 I. W        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
, V: M1 {( N% W5 ?5 t. o            lastPt=new Point(nowPt.x,nowPt.y);
' O7 `, U7 i. n5 n4 i6 p) N            //如果找到了目标，就直接移动到目标点
$ u7 B4 f+ L3 E. ?' p8 c            nowPt.x=AimPt.x;
/ o, _: r' d- Q/ p# x/ ?' D            nowPt.y=AimPt.y;</P>
! ], [0 j- j. ^: c# \8 ~<P>              //计算最后的总距离
, ]3 L3 H7 Y8 Q6 M              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
: c1 ~: U! `  \( v& S7 g              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
              }
              //清除总距离记录
              Count_distance=0;
; M; [2 ~. n) c$ E) t            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
6 U" I1 R! s1 N) X$ y            StartPt=new Point(OriginPt);</P>
1 f; ]* A/ x/ W# r2 y<P>            //重新置信息素
% G' }, V: l. Z            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
<P>            //主方向反向
            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
            FoundTimes++;
( f9 h! k2 i' ^            return true;
        }
; |2 j3 S& T% I/ N9 t: b        return false;
    }
' Y& A9 s0 V: i+ d% @    return false;
}
. r' e5 @0 Z& e: Y& g' n/ V        private double SelectDirect(){
                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
1 U# g; u) t" E% p! `                if(Main_direct&lt;0){
( w! y0 y$ k2 i, D" S$ u                      //如果目前还没有主方向角，就随机的选择一个
1 M- R' B& Y, \, U$ y7 a        e=2*Math.PI*Math.random();
5 n+ q, H; Z2 n9 k                      Main_direct=e;
, B! U5 c  v! w, V4 Q& p# n! V                }
3 H& \' K- H+ K4 d% b                //选择主方向角
) U7 G/ R3 O( A' j3 R- _; W. @  V9 L                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
& @+ q2 k! d5 R1 s                double re=Math.random();
5 ]- J! x7 S' `7 S# F                double re1=Math.random();
                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
8 L" o2 C. ^- m                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
9 `) Y, V. B7 u  e! q                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
5 o" ^! x7 N$ ]- H5 w# D' d                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
$ ]1 ?. b$ D9 N4 Q5 f, W; x' }                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
                       Main_direct=GetDirection(pt,nowPt);
7 k" u7 q5 Y( u8 u6 u* t2 C0 o; }                    }
                  }
                }
               return direct;</P>
: y$ N+ B- P# {' n' L# x5 q" H; ~<P>        }
        private Point Evade_obs(int deltx,int delty){
              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
- l; b; a5 M. w% z& q. V) t              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
( I! G7 Z5 N! d4 L              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
, N2 q8 W1 ]9 Y8 g              Point pt=new Point(0,0);
              int x,y;
" x- b# U' v( K% i9 ^              int delt=deltx;
2 V! T3 J. k2 l) O3 y( S6 O2 h5 _              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
              if(delt==0)return nowPt;
              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
' f& k6 k7 k- C* B4 J, \                  x=(int)(deltx*t+nowPt.x);
1 d6 L4 a1 S" e# e2 N. R9 K5 @                  y=(int)(delty*t+nowPt.y);
: i' ?7 G, R& f/ x7 t# {                  x=(x+width)%width;
                  y=(y+height)%height;
6 w5 }0 b$ g" x+ [                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
" a6 T6 }6 e3 P* \' ^                     //新目标点为障碍物前方的点，主方向随机取值
. C5 A9 n; }) l3 Z; M                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
                     double disturb=4*Math.PI*(Math.random()-0.5);
6 _) C2 o, C# j                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
/ ]5 N( ?/ l+ E. R& [. Z9 \( |                     break;
; e$ R$ g) F2 X/ `  u- d( w                  }
                  pt=new Point(x,y);
; I6 a8 o# Q/ `5 f8 F- v% T                }</P>
<P>                //计算得出实际能够到达的目标点
  y) h# H2 a% p  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
& J+ J4 R1 x! o/ k         return new Point(x,y);
        }
        private double GetDirection(Point pt1,Point pt2){
' m1 e5 ~* c8 [! Z. U+ G        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
$ U2 Q- u8 }  K$ b        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
        //其中方向角是所有可能的角中使得两点连线距离最短的角。
. D1 y( s! a, K( }               double e;
! v/ [4 c" l: W% |, B( g6 ~7 {( G. H, `               int deltx1=pt2.x-pt1.x;
               int deltx2;
, z- e  c7 H1 n7 e. c$ |6 D) s               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
& Q! s1 v: N7 t& y9 P# k9 j' W               else deltx2=pt2.x+width-pt1.x;
6 I0 ?4 J  f2 W% i8 J; t7 \  B3 A! y               int delty1=pt2.y-pt1.y;
* E/ h0 |# e  c! [               int delty2;
/ k! C! q( Q6 ?5 \* K9 s               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
# M  N0 T9 D# e  m, \' r               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)){
$ [, m$ _4 n8 `% M# d% e, [" h    deltx=deltx2;
               }
        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
4 I5 |# E, ]7 J0 V3 ~2 v               }
               if(deltx!=0){
* s3 ]; z& C4 p' T# m3 b# ^                    e=Math.atan((double)(delty)/(double)(deltx));
" L3 t/ Q) m9 N0 ^5 ^                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
( D7 n2 q, V* P+ h8 J                       else e=e+Math.PI;
                    }
# L- C% U7 |# m' H/ m( ]2 c/ C' \+ x                }else{
7 L( j) g' G' U- r& u                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
                }
                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
+ ]( p' Z! @3 e. j% Z        }
# e( O, R0 ~  _1 T) o; q* I        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
; j  v+ A, w$ n9 l. c# k) I. B        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
! m5 N; f0 S1 F* M            int dx2;
$ d* k1 d* f) c- A4 t/ E) E            int dx,dy;
            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
( Z* V5 s7 O  h' k: i" Z            else dx2=pt2.x+width-pt1.x;
+ f7 i, v! \" `; w. p& L            int dy1=pt1.y-pt2.y;
1 a% H: F( Z2 q5 S# H; y            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;
1 d8 p/ J( \4 X, V            else dx=dx2;
$ M7 l* y4 e4 U7 f* J& T            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
            else dy=dy2;
! e1 n# T9 ^8 B, Z" ^2 _            return Math.sqrt(dx*dx+dy*dy);
! e: a( Y! }8 Q, F- X& A+ ]/ T% t        }
    public void clone(ant ant1){
        //把蚂蚁ant1的属性拷贝到本蚂蚁
  I- q4 ?, L0 E$ {     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);
& y& \5 v6 a. o, U/ H        lastPt=new Point(ant1.lastPt);
$ E& Q% Z6 \3 h3 Y  x        VR=ant1.VR;
! g) r$ r4 r  ]& r( Y* Q$ b        id=ant1.id;
        color=ant1.color;
        back_color=ant1.back_color;
        height=ant1.height;
        width=ant1.width;
        local_colony=ant1.local_colony;
' n( C, z' ?3 _4 w- M) l        Phe=ant1.Phe;
        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
9 B7 C! ]. ~: ]8 n3 t" K        FoundTimes=ant1.FoundTimes;
0 v) l) ~1 A/ [+ W! ]6 f        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
  |! m# `+ L, z% Q. X7 a, I        memory=ant1.memory;
2 m4 C( z. v8 O3 }6 m# G" k0 T$ q        Count_distance=ant1.Count_distance;
4 x) P* R& T* k4 [# v1 ]  i        Min_distance=ant1.Min_distance;
    }
}</P>