[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
. U  }5 p9 f/ X7 n! w& a. F<>package ant;
" t9 q6 `# }: P( [# G) o/ K( {/ f/*
& y* k6 d9 [; J" b- O * @(#)Antcolony.java 1.0 03/05/22
- \# z, A& ^0 K$ k4 ?7 [  P *
% h' ]) A4 R* m4 R' F * You can modify the template of this file in the
/ h6 f2 _+ F; I  [ * directory ..\JCreator\Templates\Template_2\Project_Name.java
*
! I( F# U/ v9 A2 }* z * You can also create your own project template by making a new
* folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
2 J$ r7 @( W' o% g2 g1 O2 ~1 a) p *
*/</P>
! o  Z7 p% x) b5 ~# m<>import java.awt.*;
import java.applet.*;
5 ^, p" {/ \4 F% b6 l- Vimport java.awt.event.*;
  p% D$ }1 \# g4 N0 Pimport java.util.Vector;</P>
<>class AntCanvas extends Canvas
{
5 k' F$ H) T4 `8 s: i, L1 [    //画布，一切画图操作均由该类完成
- Y" `0 K) ^( V, m8 m/ u7 X" w //Image image;
Color obs_color;//障碍物颜色
  f  [) e) ^7 Z Color origin_color;//我的颜色
Color back_color;//背景色
  \( }; y" B) A1 f1 X: d% g        Color end_color;//食物点的颜色
& s* y4 [, P% k) \ //boolean first;
! ?& a) ]1 [; _/ I' g" O boolean reset;</P>
. m" W# f2 k7 M9 ]. f4 s  q<>/* public AntCanvas(Image img) {</P>
<>  super();
   image = img;
  obs_color = Color.white;
! \: b" U  [  c8 y, e! ^  setBackground(Color.black);
% K+ d' S9 y0 w  setForeground(Color.white);
3 M4 J% w/ `- p3 C- X$ C  first = true;
  reset = false;</P>
<> }*/</P>
<> public AntCanvas() {</P>
( e2 F: D- B& J; k<>  super();
   //image = null;
, A! v' g9 _% Z* V- @0 q3 n) S" Y   back_color=Antcolony.BACK_COLOR;
  setBackground(back_color);
  setForeground(Color.white);
  obs_color = Antcolony.OBS_COLOR;
  origin_color=Antcolony.ORIGIN_COLOR;
/ t9 _1 H1 \( g( b                end_color=Antcolony.End_COLOR;
0 x* h- G5 l1 Z2 y6 B  //first = true;
  reset = true;</P>
2 p# L' I. L: b<> }</P>
5 A. N( j& F" _, e- w<> public void Clear() {
5 M# t! a- a. U6 s5 B7 i        //清空画布
  reset = true;
  repaint();
7 R% e: i2 p8 g" |- U; Z% ~ }</P>
<>
public void paint(Graphics g) {
! u; ?; w0 d! S0 I+ N  int i;
% |" g; ^/ h* Y) I0 b2 N                //重画的时候仅仅画障碍物
1 F2 c# j8 C4 |$ d- p  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
( O4 W, ?% g) l1 u8 q! `6 ]  g.setColor(obs_color);
# J- z- [- |% {; j0 R8 |7 ]- x- {  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
<> }
public void process(){
" j% w0 J: U/ n        //处理动画的过程
, A% A2 ?2 K. j( F  }  Graphics g=this.getGraphics();
                g.setColor(end_color);
) Y! F! O0 {' l- F9 h  o   for(int j=0;j&lt;Antcolony.EndPts;j++){
                  //画所有的食物点
                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
/ m9 F/ k% ~' F8 q6 ]9 J                }
/ g7 z0 ]1 h, h* s                for(int i=0;i&lt;Antcolony.antCount;i++){
& ~- C' d5 p) N/ O9 T8 t                  //每只蚂蚁开始决策，并画蚂蚁
   Antcolony.ants.Process();
+ }2 @8 B$ G9 H' D   Antcolony.ants.Draw(g);
" i' W" P) h7 V  z4 {. T8 E5 A$ W  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
& b2 D2 y) w% w                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
2 p& l7 f: M6 J  T8 k                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
                        case (1):
                            v.Draw(g);
                            break;
8 G% u# F9 E. R  A( w6 N0 K                        case (2):
- j8 D" {& u4 o" H                            if(v.kind==1)v.Draw(g);
. f0 X/ D' P4 }* `                            break;
                        case (3):
                            if(v.kind==0)v.Draw(g);
                            break;
                        }
( m2 F7 g2 y- L4 b5 `3 C                        v.delimit(g);
" l% v5 @3 p! l/ K1 E' K5 E                }
3 }- X) ?; k$ {! G; f           g.setColor(origin_color);
$ B4 A( D- F/ T, v; g: y                for(int i=0;i&lt;Antcolony.OriginPts;i++){
5 @5 M" {* r5 @9 I                  //画所有的窝
' y1 d+ D6 [/ Y9 y                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
- q) ^/ s! X0 e/ g! o6 `                }</P>
/ a  r0 u4 I5 I3 J. _, n# U<> }
Graphics GetGra() {</P>
<>  return this.getGraphics();
}
2 ]( r/ B$ g# q. F( C4 e9 k}
% p0 Y9 {6 ^% s( e2 h/ Jpublic class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
( L& v" t, X: W Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
6 v/ N4 ?8 A6 q2 N/ K        boolean reset=false;//是否按下了重置按钮
static Color OBS_COLOR=Color.red;//障碍物的颜色
9 ^7 ?- q# n; X& k! s static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
5 M. m! Q  q6 Z7 ?9 T: g, S3 A static Color BACK_COLOR=Color.black;//背景色
static Color ANT_COLOR=Color.white;//蚂蚁的颜色
7 h4 ~8 I) o9 Y4 L2 O        static Color End_COLOR=Color.cyan;//食物点的颜色
AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
( s9 t* `% K, M# p4 W static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
, _' d/ k& _& ?0 c$ I+ O        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
- @  b6 b. T  y2 J        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
7 y/ X/ d6 K# p3 a$ i% E  L2 i. A( J        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
7 J# D% D! [( K static Point OriginPt[];//窝点信息
        static int OriginPts=1;//窝的个数，最大为100
5 |" O. R1 P0 S static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
8 ?$ s5 h5 o! n) ]) N6 c        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
        static int FoodR=10;//食物和窝产生梯度的信息素的半径
static ant ants[];//蚂蚁数组
+ H+ S# c4 \' U5 w$ N% H/ L        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
+ y5 P$ V7 l& ^; o        Button btnStart=new Button("开始");
3 U$ Y/ c9 |: E& I" @        Button btnReset=new Button("重来");
        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
public void init() {
                //初始化函数，先画各种控件
' Y5 H& N3 }: _$ F1 F1 E  setLayout(new BorderLayout());
                Panel pan=new Panel();
3 ~+ S9 ]( y/ W* W% q                add("South",pan);
7 D' E: \4 ~$ {. g9 u                this.add("Center",canvas);
                pan.add(btnStart);
                pan.add(btnReset);
; U/ Z3 ^1 d$ ]; L  q1 i8 C                pan.add(btnConfig);
* ~* ?2 J5 j" `6 O' g                pan.add(btnMap);
                pan.add(choPDraw);
8 R$ r  l- P2 x1 K$ i2 V0 E( T                choPDraw.addItem("不画信息素");
, \9 X- D% W' b  |                choPDraw.addItem("画所有信息素");
+ v! o: y: B: s6 l                choPDraw.addItem("画食物信息素");
$ Q0 O& r1 r9 I9 q+ ~0 F  U* q                choPDraw.addItem("画窝的信息素");
" j: \' B) Q  q. _, @+ E                choPDraw.select(2);</P>
<>                //初始化各个数组
0 V* [7 @$ S- }  V$ N" f  obs_grid=new int [width][height];
* d2 y7 `( O# I  e- c                phe=new Vector();
. K% [. z. t0 |                Pheromone_grid=new int [2][width][height];
  H" t% H# L1 a& m' f9 d                for(int i=0;i&lt;width;i++){
4 i+ c2 B6 f% K   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;
                                }
1 M6 v5 ^! h) W6 G3 Y   }
4 s# \3 L- j% t+ o7 c2 `  }</P>
- }! M) T# o1 P<>   antCount=50;//蚂蚁个数缺省为50
( m1 a0 x8 e3 R- R5 f                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
# T* b9 K' d8 k7 G8 C2 c  }</P>
, f; H" k) ^; O5 Q& s) M  u<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
3 l. N% R$ g7 [' Y; K* }3 E! g                Maps maps=new Maps();
                maps.LoadMap(grid,0);
$ }3 H( S0 w) m4 R0 {, e1 P, j! I                //初始化地图
" {$ W  j; Z  z7 R* ]% y                reinit_map(grid);</P>
% D, B# D( e: u# O  r<>                //初始化所有的蚂蚁
  reinit();
9 k+ v% n- T% ]' p }
        public void reinit_map(int grid[][]){
                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
<>                //先停止程序的运行
  F; f; D6 C7 S- P% R3 K$ @. ]                running=false;
                btnStart.setLabel("开始");</P>
<>
                obsCount=0;
                EndPts=0;
                OriginPts=0;
                obsP=new Point[width*height];
6 _8 g8 X8 H& m- B' m                OriginPt=new Point[100];
" ?9 e, p/ g* W3 `- h3 k                EndPt=new Point[100];</P>
<>                //清空obs_grid和Pheromone两个数组中的值
                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
; z& r! O9 }. Z2 x2 E                                for(int k=0;k&lt;2;k++){
, _2 }, ^; C! o; b, |" |0 z                                  Pheromone_grid[k][j]=0;
5 o: i8 z. f, a' _# W& n) r                                }
   }
  \8 e2 d3 z) F2 \  }</P>
<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
* _  Y" u+ m1 f7 a7 W* q                  for(int j=0;j&lt;height;j++){
5 I) m( z/ J. _' V0 R4 a2 I3 a                    switch (grid[j]){
                    case 1:
                      //如果grid[][]存的是障碍物
9 ~" `8 n0 W+ D1 H$ H                      obs_grid[j]=obsCount;
, D. b. w' ~; z* x% `                      obsP[obsCount]=new Point(i,j);
                      obsCount++;
) r4 T% }& ~" N0 }                      break;
                    case 2:
; U8 C) E& ?6 ?) @: C# i, e                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
, L& j4 l& X/ w6 @* N                      if(OriginPts&lt;100){
; X$ l- R8 N$ ^. ~                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
                      }
                      break;
) K, a& t; Z2 e/ ?5 |+ g                    case 3:
& c+ Z, J( y+ G9 y                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
0 ^6 X& ^/ H9 W; w" N: @# r                      if(EndPts&lt;100){
4 q. X5 X  [6 g8 ~                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
                      }
                      break;
8 v- p" v/ X* o. [) @% b) _$ q                    }
                  }
1 z5 V- g6 x$ p                }
( `( a8 F! Z6 l! P. o- L            //如果没有指定窝，则随机的选择一点
            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
                int  j;
                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
  Y$ o& z5 H  @                    OriginPts++;
+ d  j8 _3 g9 s  x                    break;
3 V- V4 i  Z9 i1 e                  }
3 ^9 L2 u; H$ e( e                }
                if(j&lt;height-1){
4 a% O+ r2 ~/ b3 W6 [                  break;
                }
              }
% A  [" U8 Y3 P+ F6 ]2 ]            }
        }
$ r4 }: X' C( ], R" B" ^ public void reinit(){
                //重新初始化整个环境</P>
<>                //先停止程序的运行
                running=false;
* y+ p, \5 k" V1 |/ z) i                btnStart.setLabel("开始");</P>
% e0 [* c' C9 z; o<>
  //清空所有信息素Pheromone数组中的值
                for(int i=0;i&lt;width;i++){
" `7 Z" I. N2 o/ u8 T0 _7 v9 Z' J   for(int j=0;j&lt;height;j++){
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
% g* K- j! a7 ~7 ~) T   }
  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
) q/ Y' G: o$ h7 n          ants.OriginPt=new Point(OriginPt[index]);
" J+ o9 b! x: H- x. l8 y                        ants.init();
  }</P>
<>                //清空信息素向量
) X. {, J# _& ~) i3 j                phe.removeAllElements();</P>
<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
- ~7 X8 s: G; c5 i  for(int i=0;i&lt;EndPts;i++){
) `+ u8 [2 L& D* y: t) P7 x4 x                   for(int x=-FoodR;x&lt;=FoodR;x++){
/ O  q) K6 w' z1 K% I                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
/ Z5 N; A3 z/ B, I3 p4 }                        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));
                        }
                    }
  X% ]% L6 R1 V& t) U. e6 t8 u6 e                }
                for(int i=0;i&lt;OriginPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
8 k# A8 a: ~6 S& B( i7 F/ C8 a* ?                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
0 ]0 l, t* c  L  S; d+ M: }$ O                        for(int yy=-y;yy&lt;=y;yy++){
9 b+ e, e& ]+ ]0 o                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
& B" f: ^" u5 E! \                        }
, w; F3 C1 B/ r4 w( l/ k                    }
# l* C& U, g$ o- E4 l8 G. F                }</P>
: m; Z$ n9 ^. z& D<P>                //重画
& Q9 k! ]9 r$ j$ ?+ Y  y2 }: D  canvas.repaint();</P>
# Y6 ]" ]% Z/ x, @( {# u<P>                //让程序开始运行
( i! O* T# b  u                //running=true;
+ s5 K( Y! K  F }
* @  l" p3 \6 Y$ _2 @) K public void paint(Graphics g) {
  canvas.repaint();
. S9 {/ x. C. I) W5 ~: J/ j3 G }</P>
6 `' ~( I4 P$ B6 }4 d<P>
public static void main(String[] args) {
    Antcolony applet = new Antcolony();
& a9 a  W$ k; ?$ z    applet.isStandalone = true;
    Frame frame;
    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
# F9 f5 w: {+ f) J4 Y        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
" y% ~; g9 X% d8 V8 J) }, h' o          System.exit(0);
0 ^3 c% W8 P9 K" W5 o        }
5 e- M" Y4 C, A+ A5 E      }
' _" g: I  \7 s5 Q: H0 h$ C8 c% o      public synchronized void setTitle(String title) {
        super.setTitle(title);
$ N! y* Y5 K/ ~; [9 V6 Z        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
    };
/ t: I: }2 y! t2 s" s" f& A    frame.setTitle("Applet Frame");
    frame.add(applet, BorderLayout.CENTER);
    applet.init();
5 n) F7 |0 q" `% n) c: f) {6 i    applet.start();
) e" ]0 }" g7 u# J+ Y7 s& I+ H2 H    frame.setSize(300,320);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
1 D; e& T; r) p/ R2 Z8 e    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
    frame.setVisible(true);
  }
  public void start()
3 P% J, [! i/ g' t  //下面三个函数是控制线程的
$ |/ ?5 b6 b' q3 ~) b- w7 ` {
$ t6 A* ~$ d: j* s8 `9 X7 A5 @  if (runner == null)
  {
   runner= new Thread(this);
   runner.start();
0 z5 i9 N& X) h$ {- f   //running = true;
  }
0 F2 q( m2 X  Q% X! V& }+ O }</P>
<P> public void stop()
{
4 v$ f. \. K' t  if (runner!=null)
  {
   runner.stop();
   runner=null;
   running = false;
) Q5 Y/ n: u$ f% K! I& R  }
}</P>
<P> public void run() {</P>
<P>  int i;
                //线程一直运行下去
  while (true) {
          if(running){
$ T5 y$ Q- G. g  u- s1 g       //如果开始动画，就进行canvas的处理
2 ^. m* B6 ]" R, p4 s                          canvas.process();
                        }
1 Y! w0 b2 \* j4 S    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
; [+ Y! @! ^9 w. w1 D/ I$ U   }
  }</P>
<P> }
        public boolean action(Event evt, Object o) {
" M/ l  Q5 V* {8 C" A      if (evt.target == btnMap) {
                //开始编辑地图面板
6 z& I& G( Z5 f. l1 c1 k1 A& Y   running=false;
0 x1 x+ N: [4 O  }  W# Z                        btnStart.setLabel("开始");
   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
0 U: r% @! w7 Q; Y0 B                        ctl.show();
                        return true;
9 c/ K. U* z' U, ?  }else if(evt.target == btnStart){
1 t& I+ S+ ^) T( m6 F                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
1 D  e/ W& |; g                    btnStart.setLabel("停止");
                    reset=false;
3 k0 ^/ O% l( `3 x. z0 z/ P$ D0 Q                    running=true;
  r& H) S' q( t) w( D                  }else{
% G4 q! _1 h+ Z5 r& X                    btnStart.setLabel("开始");
                    running=false;
                  }
4 ~5 H! D5 Y8 j                  return true;
                }else if(evt.target == btnReset){
                  running=false;
+ ^4 c/ A0 b" N  j* b1 O' H" ^                  int j=0;
                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
7 z  d$ k1 \2 y7 c/ j                  reset=true;
                  repaint();
                  btnStart.setLabel("开始");
' s# `3 f% a8 f1 h! g                  return true;
- |" T# f! o+ g& F2 X  t7 e6 d                }else if(evt.target == btnConfig){
                        running=false;
                        btnStart.setLabel("开始");
     Configer ctl = new Configer(this);
& p# U. G$ D  H* z$ D5 A                 ctl.setSize(300,300);
2 N- H5 S- a: n0 p                        ctl.show();
) e0 ^; C- ^9 K/ ~' v9 `& d                        return true;
                }else if(evt.target == choPDraw){
                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
4 E' Y1 K2 W3 R$ T                  return true;
" v; R! e- J7 V6 d7 H- }1 U                }
: K! _4 u! A& g( ~, U' _; z5 ^- W                return false;</P>
<P>        }
% O4 P9 \/ u0 Z2 e) G /**Destroy the applet*/
  public void destroy() {
  //当结束程序的时候，把线程也结束
0 _' E8 o1 J& P5 ?7 _4 O    if (runner!=null)
    {
3 G5 L# a* _5 K$ L! I' q+ t" X/ ]       running = false;
       runner.stop();
( H9 R, f) M( t; f' V       runner=null;
! ?4 i. k: F' P) s. B' \    }
8 Q8 V: R9 p% X0 k- R' \. b0 Z  b  }</P>
<P>}
</P>

( B& x2 F# J! [- x# Y: f, o
5 L! i& m- X5 |1 G4 q
- ^8 Q0 k( m7 A- z8 s* r3 F  H: o<P>package ant;
import java.awt.*;
import java.applet.*;
import java.util.Vector;</P>
8 J% y, _+ t* y7 H; f6 b- \<P>public class ant{
Point nowPt;//当前点坐标
0 F+ L6 H1 r) X# Y/ Y; ^ int VR;//速度，每次蚂蚁能走动的最大长度
6 S; {1 k. j0 a4 S: @  int id;//标识
  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
) N: W. Y4 e3 Y4 @4 M2 `& I6 G  S Color back_color;//背景的严肃
5 L/ ~$ f) J4 Q* R int height,width;//世界的尺寸
) |. @4 p- b# E% h        int Phe;//每次释放信息素的数值
Antcolony local_colony;//主程序的指针
0 s, g- D7 i% c# [        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
        double Main_direct;//主方向
  Q$ g+ j7 Z; ?& s' i8 A0 m        Point FoodPt;//记录的食物点，是否找到时候判断用
        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
4 s8 ]$ e8 `" W, _! p        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
" _  [  s" _9 g        double mistake;//犯错误的概率
6 b& j$ r  Y5 R! |; J- B        int memory;//记忆走过点的数目
        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
$ u0 W, ~* |# A$ C& C' o6 j  nowPt=new Point(nowpt.x,nowpt.y);
                OriginPt=new Point(nowpt.x,nowpt.y);
                FoodPt=new Point(nowpt.x,nowpt.y);
                StartPt=new Point(nowpt);
* [/ G0 {! w( V) X# T                AimPt=new Point(nowpt);
5 s+ J- c; T3 @# T. s  w                lastPt=nowPt;
8 t9 l- g0 y) b) x6 z2 |# x  VR=vr;
  id=idd;
6 c9 h* o9 a+ k) N% M( e  color=c;
  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
  width=Antcolony.width;
7 z7 M9 B+ O% w4 \9 ~9 _  local_colony=colony;
                Phe=200;
                mistake=mist;
/ c3 M9 p3 x7 U# U! e/ T                HistoryPoint=new Vector();
                Main_direct=-1;
8 \6 J+ T7 X6 }' g. W                FoundTimes=0;
7 X# ?0 Q& a! E                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
                memory=mem;
- ?% w% @" z: k3 w5 q                Count_distance=0;
& K) |8 l, v) B. P# n! S* n! Y                Min_distance=-1;
}
        public void init(){
          nowPt=new Point(OriginPt);
" E! P' i% M: `- `          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
          Main_direct=-1;
          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
8 z! H8 A3 F3 ~, r          Count_distance=0;
          Min_distance=-1;
        }
  [: |2 u; P  Z public void Draw(Graphics g) {
- [5 Y# T+ I) w! h          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
  g.setColor(back_color);
6 Y! _3 m/ t/ |) x' K. x  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
2 y$ C# T% K5 C0 H1 h0 J6 n1 s  g.setColor(color);
  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
}
public void Process(){
        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
: I( N7 P8 D; r% X* {" J# w        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

<P>        if(Judged==false){
3 N' F7 \+ h% ~. q5 p* n          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
              return;
          }
        }
7 q& S, \0 U' W$ L( t; J; s        Judged=false;
9 q% p  `5 w+ ^0 Q) l4 x0 w        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
! V, }) e- d& K        int deltx=0,delty=0;
4 k! H9 G5 P5 e# H( M- h! q        //direct是方向角，根据方向计算位移
/ O! g" f8 f- U' G$ n) s$ |+ V, U9 R        deltx=(int)(VR*Math.cos(direct));
+ J4 m6 H5 O  _. U2 N$ Z' {        delty=(int)(VR*Math.sin(direct));</P>
9 H% [- B2 A$ j& n: G* q& U<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
$ q4 c9 c9 p: E8 k; H( o<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
* A! ~) ~$ q' f8 Z' J9 v        int maxphe=here;</P>
, W3 e1 c9 q6 c4 |<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
          int deltx1,delty1;
% D+ s2 S6 p, E2 T# z          deltx1=deltx;delty1=delty;</P>
8 W% s0 ^1 i$ H, i<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
% x  c7 D! ~- t8 i# B          for(int x=-VR;x&lt;=VR;x++){
* K1 H& S' `8 m0 _             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
' L8 x& c0 U9 |& ?, Y; b                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
                int yy=(nowPt.y+y+height)%height;</P>
2 C, A  f( u, k<P>                //循环的时候要除去当前点。
% p5 n! z: V2 a: U. M                if(x!=0||y!=0){
                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
- V  o  i0 J" a3 D# i+ c/ O<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
9 \; \$ ^# G3 o$ `7 ?' u                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
& w/ P8 F" R4 M, l8 Y                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
                          boolean found=false;
7 f( o4 v' a7 l2 K                          //查一下内存最近走过的memory的点数，从而避免当地转圈
. Q) @; A" F. ^- b( X! @/ S! T; L                          int size=HistoryPoint.size();
                          int minsize=memory;
6 ]2 z1 A( l$ Q1 J- ]. `0 v8 l/ p; P                          if(size&lt;memory)minsize=size;
7 g: K  e% n7 m0 s+ f                          for(int i=size-1;i&gt;=size-minsize;i--){
) ~# \0 C4 t4 S- ~/ j                             Point pt=(Point)(HistoryPoint.elementAt(i));
( n) K5 a8 X9 _. J                             if(pt.x==xx&amp;&amp;pt.y==yy){
. a" @+ \- k* E: \/ y                                found=true;
                                break;
, E' g, e* G# z" H; r, j                             }
                          }
                          if(!found){
                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
                            delty=y;
                          }
                      }//end here==0||ra&gt;0.001
% d1 F* x% w$ i, L4 M                    }//end maxphe&lt;here
                }//end if x!=0
            }//end for y
; I- j1 W; Z. @5 ?" Z9 e0 M        }//end for x
( E- o+ ]) k% o: m$ [! |% S        Point pt;</P>
- D$ x0 y: O5 j0 V, \<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
% [; k. @& g# c( Y  ?0 n! Z- t2 G        pt=Evade_obs(deltx,delty);</P>
7 H7 c# Q! [1 Z. u3 r* Y<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
8 f4 p* \' A& T: ^        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
; j9 X5 O+ y- A          pt=Evade_obs(deltx1,delty1);
( m& F/ g9 n' W9 H7 J. h        }</P>
3 V7 L2 K9 R) }" L4 C! L% Z+ ?  o: U<P>        //播撒信息素
        Scatter();</P>
: X$ d9 Z$ D- j+ o4 D% E<P>        //记录走过的距离
6 u! J  S/ A- ]( Z3 i1 }        Count_distance+=Distance(lastPt,nowPt);</P>
<P>        //改变当前点位置
7 I6 ]7 c) ~4 F5 x        lastPt=new Point(nowPt.x,nowPt.y);</P>
<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
7 N: A0 J" b0 Y5 s1 J        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
        if(HistoryPoint.size()&gt;memory){
. X, |/ p7 J$ [. I! g          HistoryPoint.removeElementAt(0);
        }
" H, k; p" S- [3 W. c        nowPt=new Point(pt.x,pt.y);
     }</P>
<P>
: d" {) a/ @2 n3 }) U+ d1 K) @        private void Scatter(){
        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
  R3 |5 t8 S' i8 o9 ~( u6 Y        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
4 U- H2 o! ~1 @. b7 p            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
. m/ V" |  q0 v            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
  G) D3 }2 S+ l9 [' I            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
7 Y7 I! T, y: x1 h( d) [            boolean ofound=false;
. x7 N7 n3 O) r; D% y4 \7 U            if(Phec!=0){
                //如果当前点已经有信息素了
                for(int i=0;i&lt;local_colony.phe.size();i++){
                    //在信息素向量中查找该点的信息
6 M( Y% i+ d* S! t6 @$ y0 ~/ |) V                    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>
. {) ^, E( }8 d  ^% u<P>                        //如果在表中找到信息素，则用ofound记录。
$ o+ U2 j7 }0 j% m- C$ b                        ofound=true;
- z* V1 N5 R3 P9 F1 `) p                        boolean found=false;
                        if(size&gt;4){
                           for(int j=size-4;j&lt;size-1;j++){
                              Point pt=(Point)(HistoryPoint.elementAt(j));
% `9 U- d: _) w+ \                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
                                //如果当前点重复了以前走过的路，就不释放
' h, L' D  I! c0 s7 a4 ^3 C                                found=true;
9 L; p' I' }0 J" R' Z- D  a                                break;
                              }
9 N7 P/ q# O" E/ L                            }
* D' d  T9 h* K0 s1 m5 _                        }
                        if(!found){
6 S. w3 {% Q* a# z) v& P, m3 U                        //如果当前点不重复，则开始撒
& l9 K; R3 {3 n( v' O                             ph.Add(Phe);
4 ]8 n5 L. c  G* t6 g                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
<P>                             //让还剩下的信息素总量减少
8 t3 v" R2 M# u- b9 {! H8 ?% j) O                             Pheromone_count-=Phe;
                        }
                        break;
4 m3 y! }# B- e$ I! W+ r5 l                    }
) o2 U5 S, R4 H* M' k2 \+ x9 S& O                }
- }5 I2 U/ Q8 m( n8 ^              }
          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);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
/ q* c3 E  C8 b2 V" m( v                local_colony.phe.addElement(ph);
/ d6 q; D' t  V                //让还剩下的信息素总量减少
# C  |& }% n. s$ Y- K2 E  m" v                 Pheromone_count-=Phe;
, y9 G2 R8 c; `8 f, h5 r           }</P>
<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
( n6 W$ F; s/ x& S/ h1 l2 S           //这个模型是否科学？有待研究
, k1 m/ _; P% C+ w: x           Phe=(int)(0.005*Pheromone_count);</P>
0 |3 C( V# B( T8 K" w/ p<P>           //如果剩余信息素已经太小了，则按照等差数列递减
; G: k3 B9 F- v0 n, }$ Y2 W. W; t( U           if(Phe&lt;=10)Phe=10;
        }
private boolean JudgeEnd(){
0 E( q* E$ y# N& V7 D( ~- S1 [; x    //这个函数判断是否已经找到了目标点
5 o$ c. X7 Z4 M7 ^8 l    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
/ Z& @0 j* M& e" g2 C2 q    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
        int i;
) S8 X  g  n7 J! o( X" |3 w        for(i=0;i&lt;local_colony.EndPts;i++){
% S6 K9 B$ g) [7 f2 C" V$ p) o            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
' K9 G: T9 Y" E$ h: E3 ^( q( v              //如果找到了食物，就直接移动到食物点
              lastPt=new Point(nowPt.x,nowPt.y);
' }9 `& X" P0 G  O, E( F0 j              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
<P>              //计算最后的总距离
9 C' }: I; j* [6 m; P  N& A9 `' m, k              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
' j+ d4 x4 S& b              }
/ Y5 t. {  L2 |4 F              //清除总距离记录
              Count_distance=0;</P>
5 o1 t8 ]2 o/ N" ~5 V% a<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
: C) y9 S& B2 Z4 m, U              AimPt=new Point(OriginPt);
5 G6 S' S7 R, i8 Y- W' S              StartPt=new Point(nowPt);
4 a& Z; C+ S3 d7 D5 q6 N7 }8 M              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
$ T% e: V7 S7 C, M<P>              //找到了食物就把找到次数+1
              FoundTimes++;</P>
8 S8 w0 \" D; N& X1 _<P>              //改变主方向为原来方向的镜面反方向
7 C6 Z$ [/ l0 h3 m              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>              //重新把自己能撒的信息素置为最大值
* ]* m# R8 K' v, X/ ]2 \$ k1 [& d              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
<P>              //返回找到为真
              return true;
            }
        }
      //否则没找到
      return false;
( K4 f4 u4 ~+ W; i: K, C. P0 n/ x: X- l    }
8 I( L2 V' V1 t  f( E3 c% ?3 }5 L    if(kind==1){
0 r$ m6 J* I" ^# J4 L        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
9 U; `1 c! m6 |( K7 u3 s" ~        if(Distance(nowPt,AimPt)&lt;=VR){
            lastPt=new Point(nowPt.x,nowPt.y);
            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
<P>              //计算最后的总距离
! |0 s: D% i% ^; h. f* L              Count_distance+=Distance(lastPt,nowPt);
, x$ u2 q- F) B% j              //比较大小，记录较小的距离
; v, S; T$ U  a; G              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
8 i9 K0 P4 v  t- P) b" N, E/ I                  Min_distance=Count_distance;
              }
; V: ]4 R& R$ l1 y# |0 u  r              //清除总距离记录
              Count_distance=0;
, m2 V7 c* h2 y) d2 Z5 j$ r            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
- p' F" d8 W) `8 c+ n: O# b            StartPt=new Point(OriginPt);</P>
<P>            //重新置信息素
            Pheromone_count=Max_Pheromone;</P>
$ z) e( G9 D6 E; |+ w- J<P>            //清空历史纪录
% J: J, q# s! |' J! A9 A# u) t5 p            HistoryPoint.removeAllElements();</P>
( \: o3 a; ?# K" G1 N& u<P>            //主方向反向
- @: V3 q, a, D            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
9 S. }  A3 d$ P% N3 g. R<P>            //找到次数+1
1 \$ b9 s8 R) v; G            FoundTimes++;
# P" u6 _, f: m. M/ Y8 G* y            return true;
8 d4 j9 c% f* U        }
        return false;
! o7 j8 b- l: P/ U) e5 t( V4 _    }
6 U1 w/ u* N0 A# D, _    return false;
}
        private double SelectDirect(){
3 t9 _# V- x1 I4 U4 ?. R7 \                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
) A8 l1 o4 _9 q* p. V+ o, ~' g# {                if(Main_direct&lt;0){
5 [5 v6 ^; f  M# W* j                      //如果目前还没有主方向角，就随机的选择一个
+ F4 |' b7 c4 A0 l3 |5 d' D        e=2*Math.PI*Math.random();
                      Main_direct=e;
: t1 T, b6 F  ]                }
; X3 [6 \" g+ v$ h/ g                //选择主方向角
5 f: [: Q1 y+ b                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
: D- R( d4 D; A8 n$ p                double re=Math.random();
                double re1=Math.random();
3 A' F; @; ?1 @- H: }                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
' F; r7 R( j" v$ H( c                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
+ k" ]2 X3 n; J2 T                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
2 h0 I  R9 s! _6 Y9 U                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
  c2 q+ l& r/ ^# C0 i1 d                       Main_direct=GetDirection(pt,nowPt);
                    }
! q2 r$ g9 Y$ O7 C' n. z; h                  }
: H) @# x0 O2 X' D: Q) }* C                }
7 q- x9 K) t& g0 m               return direct;</P>
2 f% D* I+ z  b& b  ^& _$ C<P>        }
6 @2 q/ c  S$ h& Z        private Point Evade_obs(int deltx,int delty){
              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
6 b$ o; j7 m  L* I* ~: D9 i              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
, H, ]6 v/ d* v& ^# [              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
! w+ n8 _& j! o' P9 [# b, e/ x: R7 b) h( v              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
+ B4 Z) P! Y' L2 W% D" \% o              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
              Point pt=new Point(0,0);
              int x,y;
  U2 _/ e8 q; |3 L              int delt=deltx;
5 X* U8 H: {6 z$ M/ _              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
( L! G+ Q  @) X- V# D" _              if(delt==0)return nowPt;
              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
+ s+ m% b% [1 s7 L# o- p) [1 E+ O! q                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
% H! M3 k. V4 P% b" y7 `0 m( S) n9 a                  x=(x+width)%width;
/ [( o  D7 ~' i- V# w                  y=(y+height)%height;
                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
                     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);
+ Z1 {2 ?% f" L; ^" @" d5 F$ A                     break;
) U  @6 O0 L9 n: _3 L& i  |                  }
                  pt=new Point(x,y);
                }</P>
8 a& V" ^7 A% |9 `8 R<P>                //计算得出实际能够到达的目标点
  x=(nowPt.x+deltx+width)%width;
4 ^4 M1 _1 T3 }9 M$ h  y=(nowPt.y+delty+height)%height;
, g3 ~: j& v0 @$ V: q7 @         return new Point(x,y);
        }
        private double GetDirection(Point pt1,Point pt2){
- [" L( t0 B' F% b. ^) b        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
        //其中方向角是所有可能的角中使得两点连线距离最短的角。
& K9 L( V5 e6 g0 U5 Z2 T3 c               double e;
               int deltx1=pt2.x-pt1.x;
               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
% f$ W- J# b4 w' K0 O5 `( ^6 x               else deltx2=pt2.x+width-pt1.x;
/ l# _0 ?& O/ F- o, k. Y7 s               int delty1=pt2.y-pt1.y;
               int delty2;
6 }2 `. A" v$ y# w               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
( ?7 E4 g5 z6 }: g               else delty2=pt2.y+height-pt1.y;
' E0 i% `9 U* W4 G$ p1 h  Q; D               int deltx=deltx1,delty=delty1;
               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
               }
- S+ Z* r! @$ [1 X% p7 m        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
4 `8 W% L# f1 X) ~2 D               }
               if(deltx!=0){
% v5 K; [/ y3 c- N) v: q3 n- f. ^                    e=Math.atan((double)(delty)/(double)(deltx));
                    if(deltx&lt;0){
, G/ b6 K0 M7 ]# b; v                       if(e&lt;0) e=e-Math.PI;
                       else e=e+Math.PI;
' i0 G9 h6 ?$ P6 Q                    }
                }else{
                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
                }
                e=(e+Math.PI*2)%(2*Math.PI);
  C7 o/ I, m: n* D; O                return e;
        }
        private double Distance(Point pt1,Point pt2){
" Z8 T/ A8 |' N        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
            int dx2;
            int dx,dy;
) t! D( u9 @$ P; ]) I            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
            else dx2=pt2.x+width-pt1.x;
2 [3 q3 C- g0 D5 v& {2 G            int dy1=pt1.y-pt2.y;
            int dy2;
7 y  R5 {; Z5 R2 R            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
1 Z( g8 B6 X9 P            dy2=pt2.y+height-pt1.y;
$ P. t; E( l* F0 s& j* |            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
            else dx=dx2;
2 s; F! h; X" w  h. _$ D            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
" L6 X1 H( @* C! ]            else dy=dy2;
9 ]% E: ~/ x0 M* l' s            return Math.sqrt(dx*dx+dy*dy);
        }
9 F# C/ U) r) y% Z  a& [/ b    public void clone(ant ant1){
        //把蚂蚁ant1的属性拷贝到本蚂蚁
8 r3 N: u# Z  r- R: l9 w     nowPt=new Point(ant1.nowPt);
+ y& m% |6 c! @+ D        OriginPt=new Point(ant1.OriginPt);
        FoodPt=new Point(ant1.FoodPt);
6 a* [7 a6 m! P0 }. \7 b& R        StartPt=new Point(ant1.StartPt);
- P9 T) L7 g7 u" B- S* A        AimPt=new Point(ant1.AimPt);
5 W& f& j+ v# i7 S1 x4 L        lastPt=new Point(ant1.lastPt);
/ H; @8 H# V# T8 V3 m9 K3 F        VR=ant1.VR;
        id=ant1.id;
        color=ant1.color;
        back_color=ant1.back_color;
        height=ant1.height;
7 C2 N1 N4 y+ z3 ~( [        width=ant1.width;
2 n- R+ H  n1 F  L% h& h        local_colony=ant1.local_colony;
3 G! {+ Y3 g; X  e        Phe=ant1.Phe;
        mistake=ant1.mistake;
; f& [1 U( ?+ ?9 p        HistoryPoint=ant1.HistoryPoint;
7 u0 L% Z' K( G- _8 v: S        Main_direct=ant1.Main_direct;
' o' i1 h- J+ ?2 r( P- S, [6 G. A, Z        FoundTimes=ant1.FoundTimes;
0 J: v3 r- J& t8 C- T. L# w        Max_Pheromone=ant1.Max_Pheromone;
9 F0 }) |( ^, ?2 F" d9 m) }) @        Pheromone_count=ant1.Pheromone_count;
        memory=ant1.memory;
3 u) ^6 o! D+ s' K$ c        Count_distance=ant1.Count_distance;
        Min_distance=ant1.Min_distance;
0 V5 I: d3 g. c- i" ~& L    }
}</P>