[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
) r- C7 }5 {# c" g6 b. F<>package ant;
7 J3 n  S" Y) H( ^! D% N$ [/*
+ w) s7 F  A& L3 _ * @(#)Antcolony.java 1.0 03/05/22
*
* You can modify the template of this file in the
* directory ..\JCreator\Templates\Template_2\Project_Name.java
*
% ^% i* ?2 B$ w) n8 ] * You can also create your own project template by making a new
* folder in the directory ..\JCreator\Template\. Use the other
; ?5 _: Y. _) C$ R * templates as examples.
, p3 `$ p7 \7 q8 F1 c0 O9 C *
# B& ^, \! z5 I2 B& Z3 Z */</P>
<>import java.awt.*;
import java.applet.*;
' \9 E6 {# s3 w. U& a* ]import java.awt.event.*;
import java.util.Vector;</P>
<>class AntCanvas extends Canvas
! K& @" S; m" R% c{
' V  ^& o. f: u+ `1 \0 v    //画布，一切画图操作均由该类完成
//Image image;
3 h5 o5 z  q' w6 ~' z Color obs_color;//障碍物颜色
Color origin_color;//我的颜色
Color back_color;//背景色
+ T' p) _+ M/ q, M/ N        Color end_color;//食物点的颜色
//boolean first;
2 _) a1 i) L6 `  m8 d3 T+ e boolean reset;</P>
6 Y0 r$ f0 b) d<>/* public AntCanvas(Image img) {</P>
<>  super();
   image = img;
  obs_color = Color.white;
  setBackground(Color.black);
3 v: F2 l8 r* U" q  x  setForeground(Color.white);
  first = true;
, I8 j8 J+ I" ~: h4 d7 u; Z  reset = false;</P>
<> }*/</P>
<> public AntCanvas() {</P>
5 P7 e5 X2 u4 m; U* P<>  super();
5 Y# G: ]# N: |6 O- S; H3 h   //image = null;
# T1 @8 Z9 z, y8 u1 o   back_color=Antcolony.BACK_COLOR;
  setBackground(back_color);
( `+ G; w# M4 ~3 S/ A  setForeground(Color.white);
" w1 t( q. [2 x% h4 K9 n' v  obs_color = Antcolony.OBS_COLOR;
  origin_color=Antcolony.ORIGIN_COLOR;
3 z! d7 l/ l4 K* P! o                end_color=Antcolony.End_COLOR;
* M& ^; X% O0 Y9 ?  R! U9 V# j- Z  //first = true;
8 `& R) \- @4 V: I# g+ t9 M  reset = true;</P>
; m0 o2 Q9 r2 i2 u<> }</P>
' y+ `) ]! s4 j, h* [4 ~$ u2 @9 x" [- [<> public void Clear() {
        //清空画布
  reset = true;
  repaint();
+ N8 r9 q- w1 @" O8 h }</P>
<>
public void paint(Graphics g) {
' O+ e2 {/ O: s  int i;
                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
  g.setColor(obs_color);
# V! s  K% i8 z  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
<> }
' W+ g8 ^6 O7 C2 w* }6 \ public void process(){
        //处理动画的过程
  Graphics g=this.getGraphics();
                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);
                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
                  //每只蚂蚁开始决策，并画蚂蚁
   Antcolony.ants.Process();
) U  l% {- {5 B1 A( E   Antcolony.ants.Draw(g);
  }
0 v. G0 ~/ Z. T- h1 J0 ^$ A3 @                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
* _+ a) ?4 _2 W# Q5 c5 c, N                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
                        case (1):
                            v.Draw(g);
8 x+ R" j5 d5 K6 o5 A: ?                            break;
5 ^" W& n. y* g" P5 K: w$ ^                        case (2):
                            if(v.kind==1)v.Draw(g);
                            break;
                        case (3):
. @6 o, S9 @2 a/ s/ v                            if(v.kind==0)v.Draw(g);
! X) T( R. l- p) v6 A* C: E/ L% g                            break;
# g/ o9 b. L- F5 G4 w9 o, u" g                        }
# J" \: P2 Q! E( X2 N                        v.delimit(g);
) g! F& {1 v: a9 ^/ B( J$ S. {  J                }
2 S7 s) X% N1 J5 e, f           g.setColor(origin_color);
% ~* w  p/ X6 R7 g- j; Z                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
0 z' t7 G0 I5 s                }</P>
+ q$ Z. M2 {$ q$ Z1 K<> }
Graphics GetGra() {</P>
5 A" h: j+ ]: d, D+ q<>  return this.getGraphics();
}
- S* o+ ]7 R- d- ]. N( t) P0 k}
& U" N( Y" r( w7 Dpublic class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
9 Q/ G* ^" n9 D% B5 \/ t/ H Thread runner;//创建一个线程，让动画平滑的运行
0 }5 X# R. c$ h& }* ~0 F boolean running;//是否让动画运行
4 r1 R# B" `0 I, x4 s        boolean reset=false;//是否按下了重置按钮
static Color OBS_COLOR=Color.red;//障碍物的颜色
static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
  x, z" @. ?8 D9 H. N7 e5 b static Color BACK_COLOR=Color.black;//背景色
static Color ANT_COLOR=Color.white;//蚂蚁的颜色
7 T/ W4 j9 q2 r% u; ?+ ^        static Color End_COLOR=Color.cyan;//食物点的颜色
0 e! p" w1 h9 q4 ]* D) y AntCanvas canvas=new AntCanvas();//画图用的画布
% ~% C4 ]: i0 U2 e; ^3 j7 X int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
: Y6 w; x+ u* Y) @$ P1 ^& x static Point EndPt[];//食物点数组，值为食物点坐标。
4 q0 n3 c6 R9 m+ B* j3 c        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
8 p. W! N# D0 Z' U$ H& s: ^        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
! a) y) T- ?$ I& X7 y$ B6 `' `        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
! Q3 D- w4 I) _" I- b        static int OriginPts=1;//窝的个数，最大为100
static int width=300,height=300;//环境的长和宽
# ?' N9 L( l$ D& |- N1 \0 q static int antCount;//蚂蚁的数量
        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
# J+ I, M( q" O! D- D/ ^+ H        static int FoodR=10;//食物和窝产生梯度的信息素的半径
static ant ants[];//蚂蚁数组
        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
% V" y7 O: ?6 B" ?$ D: x int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
( u" C7 U  x+ d4 \% M0 W4 y  B        Button btnStart=new Button("开始");
        Button btnReset=new Button("重来");
        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
public void init() {
                //初始化函数，先画各种控件
  setLayout(new BorderLayout());
                Panel pan=new Panel();
                add("South",pan);
                this.add("Center",canvas);
/ Z; R# Z) c' ]  `                pan.add(btnStart);
; O4 Y: m1 D& t: V                pan.add(btnReset);
# Y6 x# Q( y! @, U2 N2 i                pan.add(btnConfig);
" N, Y0 {. F! O6 k; H                pan.add(btnMap);
4 Y3 |# `& ?5 k4 D+ B6 H2 m. T                pan.add(choPDraw);
) H3 ?7 f( T9 H; o/ ?                choPDraw.addItem("不画信息素");
. {7 b6 Q: {4 ~; A4 Z4 y                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
                choPDraw.addItem("画窝的信息素");
$ _! E+ M* \( S- j1 @5 R) L5 E: M                choPDraw.select(2);</P>
9 r( J: v: x  C<>                //初始化各个数组
  obs_grid=new int [width][height];
                phe=new Vector();
                Pheromone_grid=new int [2][width][height];
$ K0 N1 v0 {* I0 ]* `# I% F                for(int i=0;i&lt;width;i++){
4 f- j0 K6 Q9 y8 \, |8 y$ V- ?   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
, ^0 K! ^4 U, n4 O5 I0 m) B                                  Pheromone_grid[k][j]=0;
8 d! `8 W2 J" r                                }
   }
+ u. F3 ?  p# c  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
! m9 c4 l4 Y9 S* e" y+ N                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
  ants=new ant[antCount];
( u& M0 O2 M1 F* o        for(int i=0;i&lt;antCount;i++){
4 L, c: R0 g6 R* J/ [          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
                Maps maps=new Maps();
+ }! N) R" a+ f4 T# a: J' c                maps.LoadMap(grid,0);
- b4 _1 O+ T; B" R) j9 D                //初始化地图
1 y9 {) f$ q9 w4 R  l  y" M                reinit_map(grid);</P>
5 Q7 v2 s6 D4 n6 }4 i6 {- \2 g<>                //初始化所有的蚂蚁
' x9 G0 o* N, N: L  z  reinit();
}
3 d- L5 P8 W8 {! Y) p3 [        public void reinit_map(int grid[][]){
3 X0 d& E' N# Y8 D: v" C' m                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
" {* i- K( ~9 o2 q/ @; u<>                //先停止程序的运行
                running=false;
6 B+ h+ \+ M) {                btnStart.setLabel("开始");</P>
<>
                obsCount=0;
                EndPts=0;
                OriginPts=0;
                obsP=new Point[width*height];
- }  U9 ~/ B* k  G  J                OriginPt=new Point[100];
                EndPt=new Point[100];</P>
<>                //清空obs_grid和Pheromone两个数组中的值
                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
8 s4 _; v; l% }: h% R  Y) `    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
% M; Q/ `/ `4 D8 S. z   }
! B' x3 x! A4 M/ R# L# _* K  }</P>
9 ]. X3 l5 v6 m3 T' A; m<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
9 Z+ O0 T, f+ Y6 F) Z( N( g& n                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
                    case 1:
! r+ w7 Y5 V" i$ y                      //如果grid[][]存的是障碍物
/ o, ~2 j* F! W* D+ p7 f* L                      obs_grid[j]=obsCount;
+ ?/ _& ]; Q! _6 _3 p% ]                      obsP[obsCount]=new Point(i,j);
/ P6 [" {# O+ S- p2 U                      obsCount++;
                      break;
                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
, s  ^; C. ?7 A  m+ \                      if(OriginPts&lt;100){
                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
, y$ }. F2 Q0 W8 I                      }
9 W: d8 z7 U4 O6 Q" ?                      break;
                    case 3:
                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
; E2 Q& R1 m0 ^$ N: N0 S9 S                          EndPts++;
% q9 l# B" [. \                      }
9 U( [1 l8 C( a                      break;
5 T2 V( C, c6 a                    }
                  }
- j5 M! G1 ?1 ?& B$ t  ~1 f                }
6 S7 D" V- c3 y$ R            //如果没有指定窝，则随机的选择一点
            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
                int  j;
5 Y# p" V9 F) t                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
5 D8 ^% k4 v% r2 f6 Y" c- [                    OriginPt[OriginPts]=new Point(i,j);
                    OriginPts++;
2 u+ S! E$ v. C' g6 v                    break;
                  }
" f  k0 K0 R8 s* [. k. p                }
                if(j&lt;height-1){
                  break;
                }
' _$ f, @. }; S2 ^9 a8 N7 T" m3 ?              }
4 R- |. F, G- }            }
/ I/ O* N. g& D, ~$ S5 u2 p        }
public void reinit(){
                //重新初始化整个环境</P>
<>                //先停止程序的运行
. ]' [  o2 K3 C5 {5 A' G4 V0 H. S                running=false;
                btnStart.setLabel("开始");</P>
9 W2 {: o. N2 \3 {" J<>
7 e# m# ^! d0 G! Y- c7 w/ c* I  //清空所有信息素Pheromone数组中的值
                for(int i=0;i&lt;width;i++){
7 E7 u/ m9 h- f9 D& {9 S6 ?   for(int j=0;j&lt;height;j++){
; k) Z& ^3 w! E; q( {6 `( m8 s                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
7 b& d7 D" m& j; C( @1 S, K/ P! L: T   }
! @# u8 O4 d* V& b  }</P>
" B' Z" Z- J& k* x$ l8 A( n$ @7 @<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
6 h" \3 |* I9 a2 x# G- S+ q  e4 o! k7 t        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
$ o1 U- g: t! t7 \2 v          ants.OriginPt=new Point(OriginPt[index]);
7 {3 O, C" K8 Y7 n                        ants.init();
4 E! ]' d% b6 |  }</P>
# R: r5 E  j: c<>                //清空信息素向量
                phe.removeAllElements();</P>
) U7 k% a8 ^8 a% R% n<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
5 K( ?8 z2 a8 O! E& J  for(int i=0;i&lt;EndPts;i++){
2 ?4 _' c6 g% ^                   for(int x=-FoodR;x&lt;=FoodR;x++){
  q/ Q; w1 N8 X" m' a" S0 b                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        for(int yy=-y;yy&lt;=y;yy++){
; v6 R. U3 v) C3 D4 }' H$ L                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
; v' b, O+ x2 t' j- Z( I5 u) g                        }
5 {$ K( a& V6 Q7 i6 n: j                    }
                }
* C1 W% }- D6 f* v                for(int i=0;i&lt;OriginPts;i++){
. M  F9 |. I& m" [2 k                   for(int x=-FoodR;x&lt;=FoodR;x++){
/ N* Q! F" Z) Y3 c5 J* \                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        for(int yy=-y;yy&lt;=y;yy++){
                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
3 O% L5 u+ P% M7 F8 L                    }
                }</P>
<P>                //重画
1 h/ i: M" O0 i" p$ g: _  i# D  canvas.repaint();</P>
9 _& m/ G  C1 r6 Q2 ^. X<P>                //让程序开始运行
                //running=true;
}
% k% Z+ [" n  o2 C public void paint(Graphics g) {
- U: u5 o8 o  D0 |4 v& Q  canvas.repaint();
}</P>
, L9 M5 P) e  b7 r- G<P>
4 \' j/ q8 z3 h8 R# Fpublic static void main(String[] args) {
& K8 `8 A. y0 w    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
    Frame frame;
    frame = new Frame() {
: l2 l4 z8 r7 \      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
% w' B; g8 v7 d3 p          System.exit(0);
8 E) U7 |! z! d; W# h; k        }
! z: L( P* b4 |( f  }      }
      public synchronized void setTitle(String title) {
        super.setTitle(title);
% l  M4 F1 ]2 W5 x; e        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
( {0 _5 T. Z/ J9 a8 z      }
3 l8 o; r3 L9 f. w    };
( K# d9 C) |# V* N4 k  p    frame.setTitle("Applet Frame");
$ _2 U2 G5 u3 G3 P: m' K    frame.add(applet, BorderLayout.CENTER);
/ c# O2 d/ f. R' p- u) M    applet.init();
    applet.start();
    frame.setSize(300,320);
6 a3 q1 A7 \% W: X  k" J, d3 b6 g    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
    frame.setVisible(true);
8 K! t" q0 E4 S7 y  }
  public void start()
  //下面三个函数是控制线程的
{
1 q0 \3 B8 E% Q: g. ~& W8 O  if (runner == null)
5 g9 T! d" O& E  {
   runner= new Thread(this);
   runner.start();
   //running = true;
6 R" D% R8 S/ T1 y( \7 q% H. U  M  }
}</P>
3 {0 f' p1 |8 N9 c# _# p<P> public void stop()
{
  if (runner!=null)
( |3 N  E: R9 _% _  {
( t& F9 x, \0 I. h+ L) `6 L$ \9 S4 x" U   runner.stop();
   runner=null;
   running = false;
  }
}</P>
<P> public void run() {</P>
<P>  int i;
" c$ \$ T) R! I# j; ^3 R& \                //线程一直运行下去
! l3 P5 r8 H* s3 W& d  while (true) {
          if(running){
       //如果开始动画，就进行canvas的处理
                          canvas.process();
                        }
9 C, Z8 r3 }5 O8 \( j( T. P    try { Thread.sleep(delay);}
" C0 E: J% Q; s2 S* H    catch (InterruptedException e) {
: A' m) x. T% n  d   }
  }</P>
<P> }
) V3 s- [  E! q        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
                //开始编辑地图面板
   running=false;
                        btnStart.setLabel("开始");
0 j+ s8 R* ^" M( y3 K0 j   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
                        ctl.show();
                        return true;
  }else if(evt.target == btnStart){
! i" R# p; @% s                  if(!running){
9 {9 B  w& T$ t! n8 _/ V; H                    //如果刚刚按下了重置按钮就重新初始化一下
7 ?, ]8 I0 [. f& u5 H" x2 g( q* F                    if(reset)reinit();
                    btnStart.setLabel("停止");
# W# R% J: x1 c. f+ N                    reset=false;
1 F* W: x0 ~( J9 _4 V) w, F7 R                    running=true;
                  }else{
' J$ d# o/ m2 A8 G0 }/ g1 m                    btnStart.setLabel("开始");
                    running=false;
                  }
                  return true;
; x  z0 }* w& Q. r8 a$ B                }else if(evt.target == btnReset){
, J6 k1 q0 O( I  a) f! r                  running=false;
$ Q/ G( g" |4 M" v2 E. P) T                  int j=0;
) r% v+ ]. T4 N$ b% p  d                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
                  repaint();
/ O* J4 k9 s' K( t  q# a- }- \                  btnStart.setLabel("开始");
                  return true;
                }else if(evt.target == btnConfig){
: U5 K1 _# Z9 i8 O. V! Y                        running=false;
' a# \  f2 |' W; f! C: ?' L* H                        btnStart.setLabel("开始");
     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
( p$ K, A% b) `0 x$ @                        ctl.show();
3 H, h% m* ~6 P  h' ^: w( y                        return true;
                }else if(evt.target == choPDraw){
0 z; v0 @( B4 H0 j! ], y$ z. V                  //选择画信息素的模式
/ ^+ q. @0 n8 Y                  drawPhe=choPDraw.getSelectedIndex();
. h+ W5 z) D- a6 H6 a/ @8 C, s9 H                  if(drawPhe!=1){canvas.repaint();}
                  return true;
: o0 B3 ?4 ^: {# c                }
3 g1 e% j1 g1 @                return false;</P>
2 Y* N9 v1 z( ]- F8 d) x<P>        }
$ r& D6 R! x  @* W# s/ m# v /**Destroy the applet*/
  public void destroy() {
3 Y$ N- P- p" n8 \3 Q1 M  //当结束程序的时候，把线程也结束
; |, l7 w! a' _' n  r( y! b. ^    if (runner!=null)
    {
       running = false;
       runner.stop();
5 \0 c* F, M: e- m1 h       runner=null;
( }, Y+ O% y; F& K$ [; f' H    }
  }</P>
6 C8 v; I: ^' s. F! K5 l; y<P>}
</P>


2 O( Z' k. m* k; b
% r" o  \: q; l2 X2 H8 F<P>package ant;
4 M% B' _$ W3 L3 @import java.awt.*;
/ b9 G2 r8 D1 f/ L" [: Uimport java.applet.*;
import java.util.Vector;</P>
8 u; z0 ^3 R* w8 v1 F( n<P>public class ant{
9 ^: q9 v7 t, c- J8 x/ @ Point nowPt;//当前点坐标
+ Q5 [, p! C8 m4 o: f int VR;//速度，每次蚂蚁能走动的最大长度
  int id;//标识
& |6 c: i. e' k5 M) g  Point lastPt;//上一点坐标
" T" o& E8 ~+ \% D- q Color color;//蚂蚁的颜色
! s. N& d7 G$ G, \" A6 j Color back_color;//背景的严肃
4 @' f/ [0 j1 p4 _; T; q* s int height,width;//世界的尺寸
        int Phe;//每次释放信息素的数值
Antcolony local_colony;//主程序的指针
        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
1 ]8 u4 H) x9 u/ u- h+ b" j, e        double Main_direct;//主方向
2 E  l% w. d9 {  |5 z1 r. [        Point FoodPt;//记录的食物点，是否找到时候判断用
        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
; h6 u, c: J; b        Point StartPt;//起始点，是窝或者食物
! D3 l7 L8 v) O7 W, s        int FoundTimes;//找到食物或者窝的次数
0 H" a' g$ E9 V! ^        int Max_Pheromone;//最大能够释放的信息素
9 A8 i, @$ d/ ~7 D        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
  s1 A/ c/ j( k! C. Z        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
9 r$ }9 f7 t" c7 C( Q public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
8 P5 w8 u0 A, D0 X4 `  nowPt=new Point(nowpt.x,nowpt.y);
                OriginPt=new Point(nowpt.x,nowpt.y);
                FoodPt=new Point(nowpt.x,nowpt.y);
" A" c$ O& N* a                StartPt=new Point(nowpt);
. V2 O+ j9 b9 [                AimPt=new Point(nowpt);
                lastPt=nowPt;
  VR=vr;
+ ?* V9 W1 r. @* e/ l% g  id=idd;
: G9 V0 ^  E2 b  color=c;
  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
  width=Antcolony.width;
  local_colony=colony;
                Phe=200;
7 P7 k2 N# s4 d; b" D" @6 h4 Z                mistake=mist;
                HistoryPoint=new Vector();
$ l' A7 R3 q2 C# X                Main_direct=-1;
" A' A  Z$ a% N) q) P, s+ K# k                FoundTimes=0;
4 u/ h2 y) a7 H- W+ Z% _2 R                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
                memory=mem;
                Count_distance=0;
! m# m. U! c; ]5 e                Min_distance=-1;
+ N! ~/ B5 M( I2 } }
3 C+ t4 g& \+ {' U6 V2 a, |        public void init(){
/ c. }; w0 i& R/ w. O9 ]          nowPt=new Point(OriginPt);
9 h3 N' [" r9 B% q5 B& D          lastPt=new Point(OriginPt);
' s! F# l. l5 h" R          FoodPt=new Point(OriginPt);
          AimPt=new Point(OriginPt);
/ b" D8 ^2 ]2 E          StartPt=new Point(OriginPt);
- N, K" v, G! y8 x          HistoryPoint.removeAllElements();
- @. n9 u( X: W6 L( O! W          Main_direct=-1;
          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
1 v0 l' R8 R  g% v5 [* T4 {          Count_distance=0;
          Min_distance=-1;
6 l& c, H& v# v9 W8 h        }
public void Draw(Graphics g) {
          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
  g.setColor(back_color);
. ]2 |* R' u9 b& D) J  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
# j% J# m( p- X# t+ A  g.setColor(color);
  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
2 h; ]% P4 m7 @- I4 F, n$ w& e }
2 P, X. `! g: x+ _ public void Process(){
# n- Q( e4 u& M2 s% [+ p, M- z        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
/ J: O' I3 X" k5 F& Q/ ?        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
9 I5 Y7 d) V' X1 V! j: o  o        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
( Y' y, q& T0 N+ p: r' E- H        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
+ P* q1 e' }: {( P/ y/ @+ X4 {        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

<P>        if(Judged==false){
          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
' m/ r2 A9 Y8 B' `3 L% b          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
" L$ E1 O; h$ K0 k& l          if(JudgeEnd()){
, a2 g7 V0 o( ~& [              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
              return;
+ M/ [" ?( ^5 a) x( U          }
        }
        Judged=false;
        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
! q& H6 G$ r$ W! l& i        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
# n5 n* k1 T' O) e* [        //direct是方向角，根据方向计算位移
0 c5 c8 N! k/ I; |- `/ ^        deltx=(int)(VR*Math.cos(direct));
        delty=(int)(VR*Math.sin(direct));</P>
<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
1 [/ R; W9 @4 U8 w6 O& J# ^( D        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
6 h: d, |! Q: z  G/ B( F        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
9 D4 s3 q7 T2 J! n& S<P>        //记录搜索的环境中找到的最大的信息素
( |7 C( x" n2 G# T        int maxphe=here;</P>
6 l, L  X2 V6 I! @# [<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
. N1 p6 J( t2 K1 j/ ^* O2 @) B5 m          int deltx1,delty1;
  W" j& L( F0 @8 w  ~          deltx1=deltx;delty1=delty;</P>
<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
          for(int x=-VR;x&lt;=VR;x++){
             for(int y=-VR;y&lt;=VR;y++){
4 a7 k# Q9 A) G0 H                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
0 f6 Z. D: u- m1 j. y9 Q9 Z; M/ e3 P                //在这个程序中，坐标是循环的，也就是在一个球面上
( a8 M- W: r0 g( c& K/ c* K                int xx=(nowPt.x+x+width)%width;
                int yy=(nowPt.y+y+height)%height;</P>
<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
* Q2 \- p& \* i# X/ V7 n<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
; M3 n/ Q# t7 |) n. m                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
/ a6 E/ s6 y4 n2 Z                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
                          boolean found=false;
& ~  P3 I. ]6 F" X* C2 d                          //查一下内存最近走过的memory的点数，从而避免当地转圈
* r3 Z' G, u, ~2 T2 I, T* I( w3 h                          int size=HistoryPoint.size();
                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
0 X+ k, H, v8 w& ~. |% l" A# J2 t                          for(int i=size-1;i&gt;=size-minsize;i--){
                             Point pt=(Point)(HistoryPoint.elementAt(i));
% q- I# a) t- \4 z                             if(pt.x==xx&amp;&amp;pt.y==yy){
                                found=true;
; U, r. t$ X2 J* _                                break;
& r# F! A4 O9 @2 ~$ _                             }
9 I/ |$ K( Y( L* c( \  S: V) R                          }
                          if(!found){
                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
% c% X' s* C- {/ R' ~, X6 {$ P5 B                            deltx=x;
                            delty=y;
# u) B# l) J6 ]3 t5 n                          }
+ e+ S3 h4 ?/ W( |: o                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
                }//end if x!=0
+ I8 Y4 n! z, ]! A7 p; W            }//end for y
2 a  W9 L5 [" t# J% l        }//end for x
        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
9 \7 L1 J) L# C( D7 X6 M+ `- @. U        pt=Evade_obs(deltx,delty);</P>
<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
$ ?8 |$ y2 X# T, i4 S6 f- P" n        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
- M6 N6 D3 z8 P  x          pt=Evade_obs(deltx1,delty1);
        }</P>
6 G4 L' a2 }3 v2 G! w<P>        //播撒信息素
+ j/ S; h" ~6 W% O        Scatter();</P>
( w1 r8 @) N5 T) h, G2 D. ~<P>        //记录走过的距离
        Count_distance+=Distance(lastPt,nowPt);</P>
( z, b) N  k9 v; p<P>        //改变当前点位置
' R" Z7 j+ x- x' E$ }9 o        lastPt=new Point(nowPt.x,nowPt.y);</P>
<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
, P3 o5 P2 R- m4 y* E) l( {0 P# p        if(HistoryPoint.size()&gt;memory){
          HistoryPoint.removeElementAt(0);
        }
7 d/ N4 U: J* Q6 U* H/ s- }7 N6 N        nowPt=new Point(pt.x,pt.y);
- `$ K- E, e- {     }</P>
9 O) x( D- O( U4 p4 Z1 A' u<P>
; j' h+ G6 Z3 D1 p        private void Scatter(){
        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
9 D3 ?; k! F' y0 F9 B4 K% b            if(Pheromone_count&lt;=0)return;
9 ?' v# K' r: T4 P            //决定释放信息素的种类
            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
% u  ^9 Y' j: s/ k1 ^! _4 T' w            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
& A( T# N% w* g5 |6 d0 {            boolean ofound=false;
            if(Phec!=0){
- J: F8 M, f0 i+ Z* J2 A                //如果当前点已经有信息素了
  D  _: c8 o0 i( I                for(int i=0;i&lt;local_colony.phe.size();i++){
8 ~6 j5 o6 o5 V- @2 a+ L4 ?; n                    //在信息素向量中查找该点的信息
                    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>
<P>                        //如果在表中找到信息素，则用ofound记录。
4 v8 v1 @5 J% h                        ofound=true;
                        boolean found=false;
                        if(size&gt;4){
' T8 p" A1 x1 I2 {                           for(int j=size-4;j&lt;size-1;j++){
                              Point pt=(Point)(HistoryPoint.elementAt(j));
3 c, L; [0 O! H0 v  I) ^                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
2 x+ M" G; V7 y                                //如果当前点重复了以前走过的路，就不释放
- l" @/ J* P1 R" f6 V# e9 T1 A  U                                found=true;
                                break;
                              }
. r7 D; o4 |2 w- }4 R( o                            }
8 a# j7 }( {# Z, G/ U6 f& Q                        }
$ h5 ~' H" b& u) ]# |- m* @2 h                        if(!found){
                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
: O7 @0 ~; h# D2 F                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
<P>                             //让还剩下的信息素总量减少
4 K: @$ T$ W# u$ n$ u# D                             Pheromone_count-=Phe;
                        }
/ \  @; j, y& h                        break;
6 P% Q6 U- _, F# R0 E8 [0 d                    }
                }
( x- @  ?# K0 f# K              }
% V  I; D5 Q, D7 Y8 J          if(Phec==0||!ofound){
- Y* y) Z6 y+ \( A% R: x            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
; @6 K- l5 J3 l1 K% N  x( g0 X- F                ph.Add(Phe);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
$ Z4 A/ @& S' S5 A                local_colony.phe.addElement(ph);
                //让还剩下的信息素总量减少
# Q, E$ u# ]; S$ q3 b                 Pheromone_count-=Phe;
           }</P>
4 |/ t; h; m1 P* g<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
; h5 [' X$ V/ C2 p5 x' i- Y           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
$ D9 J6 h% W2 D2 M" C: d3 q           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
& t7 v' q4 q9 `: W( y; }# P           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
" {8 \8 w3 o% P% r3 K! u* L* x<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
        }
private boolean JudgeEnd(){
# b+ W8 x2 w6 z% G/ z    //这个函数判断是否已经找到了目标点
    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
( [( h! f. a7 _8 r2 z    if(kind==0){
9 t1 k2 `: h& V, X        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
6 Z/ Z2 m# Y* N: ~% H4 t; a        int i;
* N* i) B, N' `        for(i=0;i&lt;local_colony.EndPts;i++){
& ]+ R+ R/ L+ i7 g, z2 ^            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
) z! E1 O$ I5 K. Z5 a              //如果找到了食物，就直接移动到食物点
5 B( {7 p/ x+ O              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
$ ~3 d9 G1 V; U  N, F              nowPt.y=local_colony.EndPt.y;</P>
! T- ~: y' Z9 _3 D' y+ l- _1 J8 t<P>              //计算最后的总距离
! Q, ^0 E' h, y# o6 W) _9 A/ I              Count_distance+=Distance(lastPt,nowPt);
# N: T! ]  I  E, K# e5 X, ~3 ?              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
# L' S+ w* P/ r                 Min_distance=Count_distance;
/ Q# F0 q7 E* b+ E( @, [              }
% Y: ^" ]+ y5 z( c1 Q              //清除总距离记录
& O2 x  ?" f! p              Count_distance=0;</P>
+ C- o+ {5 }2 E* o# O1 f8 d8 g<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
              AimPt=new Point(OriginPt);
              StartPt=new Point(nowPt);
6 T/ J- y5 s* J  g: k; f, ~+ r              //并把当前点标为自己找到的食物点
' e3 R4 B! z+ i$ R              FoodPt=new Point(nowPt.x,nowPt.y);</P>
<P>              //找到了食物就把找到次数+1
5 t" N8 p6 f! s3 [: k              FoundTimes++;</P>
<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
& f4 @# c4 K6 W<P>              //重新把自己能撒的信息素置为最大值
              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
; J5 a/ p: A8 ~' c" q9 e- J<P>              //返回找到为真
              return true;
            }
        }
      //否则没找到
      return false;
5 a+ c+ T# A# {5 {4 F+ W" \    }
    if(kind==1){
$ P9 q1 F7 @4 ?; C1 x8 N/ F        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
7 x  n% v  x$ S+ p6 i( d            lastPt=new Point(nowPt.x,nowPt.y);
            //如果找到了目标，就直接移动到目标点
/ n% c. l, U, t# x( P! n            nowPt.x=AimPt.x;
9 W( u0 ^+ M+ g6 U6 a1 c            nowPt.y=AimPt.y;</P>
2 L  @5 r8 A9 Y5 ?<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
% C: x& m4 J2 n              //比较大小，记录较小的距离
6 W/ h& f0 h$ F0 x9 b( Z              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
              }
              //清除总距离记录
              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
. `% F& A! n$ D/ G( m8 j. K            AimPt=new Point(FoodPt);
0 T. s; k& {# a- u            StartPt=new Point(OriginPt);</P>
<P>            //重新置信息素
            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
<P>            //主方向反向
            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
            FoundTimes++;
            return true;
        }
. {0 V+ h0 M0 v        return false;
    }
" J2 X. X2 \! m5 c" t9 u; [- R2 T    return false;
1 U3 F# R+ I" t4 f/ K: ]}
        private double SelectDirect(){
                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
0 R, I' y8 G0 E                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
3 B/ Y. w5 w3 c; o, z        e=2*Math.PI*Math.random();
& e: e) w6 d. n1 z6 K                      Main_direct=e;
2 `0 D$ v# j/ ~: J* B                }
                //选择主方向角
                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
7 \4 Y- _5 r, [! g! O                double re1=Math.random();
4 T" ?! h) J" N+ S9 z, I0 J7 }$ e5 B                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
" M5 W* J) }$ ?+ W+ a5 ^                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
                       Main_direct=GetDirection(pt,nowPt);
9 q+ B! j- a4 S3 m2 j                    }
                  }
( |( k" n( ?" I/ V1 Q; Y0 Z4 r                }
               return direct;</P>
7 O8 v) s: E, R9 |<P>        }
' _: Z  |# G- r, T        private Point Evade_obs(int deltx,int delty){
( |: q  y5 A# y" Z              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
5 H. h1 F2 ^# C) R9 R( f3 ^" H* Y              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
; O. D4 Q8 O. c% u* P              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
+ Z3 a! M3 a0 j. Y5 G7 u0 K              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
. O6 x# u! C5 C/ B7 x, `              //p1,p2在这里分别是nowPt和nowPt+delt
1 P% J/ Q5 n6 ^5 C7 k7 g% {              Point pt=new Point(0,0);
/ b9 ^! U2 q: H6 t7 |: i( h5 R* @              int x,y;
              int delt=deltx;
3 _8 C' h: A7 O; O: `/ E' x              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))){
$ Y0 W4 w% X/ p9 e                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
                  x=(x+width)%width;
                  y=(y+height)%height;
  H" O2 h/ E" s3 f1 C, V                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
: {: t$ K$ @% \6 u                     double disturb=4*Math.PI*(Math.random()-0.5);
                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
" o6 a3 J5 @6 ^) J7 {. ]$ v                     break;
  F7 h, a: t9 k- }: _                  }
                  pt=new Point(x,y);
                }</P>
<P>                //计算得出实际能够到达的目标点
  x=(nowPt.x+deltx+width)%width;
0 c7 ~0 x$ g. e. Q9 B  y=(nowPt.y+delty+height)%height;
( r, R/ H4 l" H5 K2 L& W         return new Point(x,y);
        }
        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
; I2 I& o: P- u        //其中方向角是所有可能的角中使得两点连线距离最短的角。
               double e;
6 |) q$ L8 g! k1 r) K: j               int deltx1=pt2.x-pt1.x;
( G8 R8 i$ |3 X# f- m' i               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
/ t% }: z6 j4 J* ~8 T1 G               else deltx2=pt2.x+width-pt1.x;
% r0 x8 K2 P$ y( Z9 Y+ B               int delty1=pt2.y-pt1.y;
) B; M+ D* f! N* o- }4 D               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
/ T* v# q2 q6 g8 `' J               else delty2=pt2.y+height-pt1.y;
: h* u6 p! k  E               int deltx=deltx1,delty=delty1;
4 N1 @, V$ A$ v$ |3 B6 y               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
               }
4 E& A0 P4 c5 O% O) U8 L1 M        if(Math.abs(delty2)&lt;Math.abs(delty1)){
8 F. b+ h0 H4 r8 P7 q                  delty=delty2;
' g8 I! r8 X3 W0 t               }
( K6 M2 A& w. U" i, z) ]               if(deltx!=0){
                    e=Math.atan((double)(delty)/(double)(deltx));
- ^- J' J( y  K                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
" n( R; G; N' g                       else e=e+Math.PI;
! r/ U$ G) d) H# Z                    }
                }else{
                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
                }
                e=(e+Math.PI*2)%(2*Math.PI);
; K  J/ i- U- X0 z/ [: t: o                return e;
6 N( d5 }2 s0 r+ o; }3 v, j        }
        private double Distance(Point pt1,Point pt2){
; ]& R5 u$ ?0 I- v        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
# \7 h$ i5 a) ?+ B4 n' t% S            int dx2;
            int dx,dy;
, n$ N; |& X6 G% K/ ~' }3 v            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
            else dx2=pt2.x+width-pt1.x;
6 k9 U& h7 d% t, }. d            int dy1=pt1.y-pt2.y;
  R$ l8 q+ ]( k$ W            int dy2;
5 }* h$ ^  G8 k* f2 w            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
            dy2=pt2.y+height-pt1.y;
5 j0 q0 K8 m# B. v& p6 X# c            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
            else dx=dx2;
( u2 p  o1 `6 y/ u  |+ v. {            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
            else dy=dy2;
            return Math.sqrt(dx*dx+dy*dy);
        }
( d* l0 P. B% \, J( H    public void clone(ant ant1){
/ f( \0 r6 v0 t1 \% l" d. Z        //把蚂蚁ant1的属性拷贝到本蚂蚁
4 \1 _1 ~+ ?2 L) A) b% Z8 x4 N+ k8 l     nowPt=new Point(ant1.nowPt);
: N# R5 V* B! {        OriginPt=new Point(ant1.OriginPt);
% t5 V6 X5 i( T6 n        FoodPt=new Point(ant1.FoodPt);
, U" L; p% y5 A7 l7 U8 B        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
        lastPt=new Point(ant1.lastPt);
" {8 L7 S- R% q3 a        VR=ant1.VR;
        id=ant1.id;
        color=ant1.color;
+ v1 S1 J9 t% i& |9 O# b1 G        back_color=ant1.back_color;
! S6 x% `2 z/ o1 R: b3 ?. y        height=ant1.height;
        width=ant1.width;
" D$ I. j- X7 X' S! c7 q        local_colony=ant1.local_colony;
0 o4 b3 z3 e6 r/ P: J# ?        Phe=ant1.Phe;
% h- E* C$ X1 v        mistake=ant1.mistake;
1 x- C& D% N; {* y        HistoryPoint=ant1.HistoryPoint;
) t1 k3 h2 ?  q) k        Main_direct=ant1.Main_direct;
' o4 `# A& W. s0 Z        FoundTimes=ant1.FoundTimes;
( c/ [) O' ^% Q9 K0 \        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
$ E( g* w6 b6 X5 a% `        memory=ant1.memory;
        Count_distance=ant1.Count_distance;
        Min_distance=ant1.Min_distance;
8 Q6 L6 q) F9 b    }
}</P>