[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
<>package ant;
8 A) U, X* G2 S3 E' P. D7 g/*
+ d  O( Y9 b% Y5 u6 g$ L# ?- L * @(#)Antcolony.java 1.0 03/05/22
! o; U6 E5 j, y2 J! { *
* You can modify the template of this file in the
1 x* S. h( P2 @. I6 n- e5 r * directory ..\JCreator\Templates\Template_2\Project_Name.java
*
9 B' S5 G+ t8 C * You can also create your own project template by making a new
* folder in the directory ..\JCreator\Template\. Use the other
9 U1 e; `! D  p' b# F3 y * templates as examples.
*
! \! I2 f' v8 x# m; g  k0 D3 F' [7 x */</P>
<>import java.awt.*;
import java.applet.*;
import java.awt.event.*;
+ j. c1 m$ N, b# @) i, i# r1 Fimport java.util.Vector;</P>
<>class AntCanvas extends Canvas
{
    //画布，一切画图操作均由该类完成
6 r7 `0 m( S1 g1 [9 l& ? //Image image;
Color obs_color;//障碍物颜色
Color origin_color;//我的颜色
Color back_color;//背景色
        Color end_color;//食物点的颜色
, \6 E; {1 b5 e- n //boolean first;
boolean reset;</P>
" G" f4 A7 _0 h3 p: X7 @' U5 J8 ?<>/* public AntCanvas(Image img) {</P>
<>  super();
   image = img;
; Q& N8 B) h, C  obs_color = Color.white;
  setBackground(Color.black);
- p4 M" D0 U5 p1 J  setForeground(Color.white);
9 t+ v. R% Z9 h0 {+ s& Q  first = true;
$ J8 Z" L5 P7 c& m& W. y' J  reset = false;</P>
<> }*/</P>
1 Z6 W& `# a4 n" N7 m9 Z9 Y$ q- \9 p<> public AntCanvas() {</P>
<>  super();
   //image = null;
+ X1 B* K+ M' B: a0 A  J. Q   back_color=Antcolony.BACK_COLOR;
$ ]5 H' z# ~! ]1 f8 j7 B0 m$ B  setBackground(back_color);
  setForeground(Color.white);
  N+ P: g- g4 J' a3 T2 I6 @# J  obs_color = Antcolony.OBS_COLOR;
: K# s4 i) ~) E7 {  V0 V& l  origin_color=Antcolony.ORIGIN_COLOR;
                end_color=Antcolony.End_COLOR;
" u' ?1 T; c7 H- P  //first = true;
  reset = true;</P>
1 p. b, e8 j3 P1 t3 U<> }</P>
% D/ G+ V; P, d. j2 b/ \9 Q<> public void Clear() {
- H& u3 m9 M$ T9 J- ^        //清空画布
  reset = true;
3 A0 \2 k5 h% t5 z! e! d, e0 e  repaint();
% B7 w& C. h+ _( B# r( h }</P>
<>
public void paint(Graphics g) {
  int i;
/ e( M/ C6 h' }1 E& H5 _$ ]                //重画的时候仅仅画障碍物
* @# @& x5 F+ C9 w1 i  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
: Z; H" I3 P8 A6 H0 o5 W  g.setColor(obs_color);
. ~& i8 r& Q, V6 @# O$ Z1 p  for(i=0;i&lt;Antcolony.obsCount;i++){
8 ~$ ]! Y' f! \9 n' s- d   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
# K- e7 {' U/ Z% m. i8 r: a  }</P>
<> }
; s' k4 f& a+ ]# w; q- f public void process(){
        //处理动画的过程
  Graphics g=this.getGraphics();
                g.setColor(end_color);
4 @, u0 `8 d5 W1 I+ z   for(int j=0;j&lt;Antcolony.EndPts;j++){
7 z( v( L! {! u                  //画所有的食物点
                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
/ q$ o* x4 o: X' `) b" @5 ?                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
1 P- |0 w, I2 b% J. I0 H- O                  //每只蚂蚁开始决策，并画蚂蚁
4 L: _) n: G$ r) [   Antcolony.ants.Process();
   Antcolony.ants.Draw(g);
  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
                        //Antcolony的drawPhe变量标志是否画信息素
2 l: }# Z6 U8 z) \2 \5 L8 [                        switch(Antcolony.drawPhe){
                        case (1):
                            v.Draw(g);
0 K" e$ l% E6 F                            break;
, U' o; j0 \: K1 h+ W* s# C                        case (2):
                            if(v.kind==1)v.Draw(g);
                            break;
                        case (3):
                            if(v.kind==0)v.Draw(g);
5 Q6 S; s2 X- d. G2 @& {                            break;
                        }
                        v.delimit(g);
$ j) i5 W8 l4 z; q                }
           g.setColor(origin_color);
                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
* `+ \! Z# V" ]! I5 G                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
                }</P>
<> }
2 X5 {# B( ~' L( `, @ Graphics GetGra() {</P>
& i9 W; a$ L# q2 z7 K<>  return this.getGraphics();
" q- b3 a! s9 i' S9 } }
}
public class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
( S# y- Y0 }2 n static Color OBS_COLOR=Color.red;//障碍物的颜色
& L/ J7 c9 c6 l. O+ L: m static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
AntCanvas canvas=new AntCanvas();//画图用的画布
1 z- f4 Q/ S6 ~3 L: q" F! ]# \ int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
0 Z! G" K7 E* z) G  q5 D        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
+ I% X5 m, v! n+ i        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
4 G6 s" ~# F) g5 T; R4 ~        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
7 C* N2 J% M! W, [  ^4 X- Q        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
2 r  H& Y+ Q# Y$ c1 c        static int OriginPts=1;//窝的个数，最大为100
# S; P) ]0 H; w6 x# @ static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
# z7 R: g' Z; I        static int FoodR=10;//食物和窝产生梯度的信息素的半径
static ant ants[];//蚂蚁数组
        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
, t% Y9 W7 Q% t# B% E& n; s int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
7 m) G! X! k; X7 c# e# H        Button btnReset=new Button("重来");
        Button btnMap=new Button("编辑地图");
$ U, E4 G* V7 z2 u        Button btnConfig=new Button("设置");
/ |9 I0 y2 n1 s* b% h        Choice choPDraw=new Choice();
* V0 A* I: i4 L. n2 r/ J0 P, m. K public void init() {
                //初始化函数，先画各种控件
  setLayout(new BorderLayout());
                Panel pan=new Panel();
                add("South",pan);
                this.add("Center",canvas);
                pan.add(btnStart);
  N& ^; I4 r4 `4 }( \                pan.add(btnReset);
                pan.add(btnConfig);
                pan.add(btnMap);
                pan.add(choPDraw);
                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
7 r3 O  ~1 @. v( i# b2 v                choPDraw.addItem("画食物信息素");
3 f' _" b4 x7 l8 h                choPDraw.addItem("画窝的信息素");
                choPDraw.select(2);</P>
<>                //初始化各个数组
$ O# F) z+ d  O% x. Z4 E  obs_grid=new int [width][height];
: n/ X9 g4 {/ l$ j6 J                phe=new Vector();
                Pheromone_grid=new int [2][width][height];
                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
( H; B; b0 j. {                                  Pheromone_grid[k][j]=0;
2 f; g( A5 z5 z: e5 o% p) j                                }
   }
1 G1 s: j. r5 C/ c; C0 P  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
+ \! j6 ?/ F. h1 F- W  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);
  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
' j8 h( v4 h) n7 C1 y                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
                Maps maps=new Maps();
                maps.LoadMap(grid,0);
                //初始化地图
                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
1 _( G) U% {" h3 w. E: N7 N5 Y  reinit();
" l/ J2 B9 L. f/ f; w* D! U }
        public void reinit_map(int grid[][]){
3 U6 T: N# n2 B) x: ?                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
! j8 ~* X' g) I+ I' A" V<>                //先停止程序的运行
                running=false;
4 ?1 p3 Z4 t4 x7 O' L                btnStart.setLabel("开始");</P>
9 {( j* ?% ~9 h, k1 A<>
3 e6 {) W+ {7 z$ R# ], L$ z8 q& g                obsCount=0;
- b1 _% i2 r2 @                EndPts=0;
) K9 L. z7 R  e9 Z* @- ]9 a( R4 ?                OriginPts=0;
' F+ E: |0 m) a$ g6 d                obsP=new Point[width*height];
3 `% @" w" ?6 k" O3 F                OriginPt=new Point[100];
& x7 l% e# p6 G                EndPt=new Point[100];</P>
  m& Y- |+ D- J<>                //清空obs_grid和Pheromone两个数组中的值
5 W$ I7 G8 l& J                for(int i=0;i&lt;width;i++){
% R) X0 \$ r' N* r( F3 u! Y) G   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;
: x3 W- z& F7 w7 m% A0 W2 V* a                                }
   }
* [! V+ E+ h, X- H  }</P>
<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
, m0 P& x6 y9 X% d                  for(int j=0;j&lt;height;j++){
/ P; g+ A8 q" R) s# u( x                    switch (grid[j]){
1 I7 u9 ~% Q2 }- R' m                    case 1:
, s6 V1 t+ w+ v/ g. R# a% Q& _                      //如果grid[][]存的是障碍物
                      obs_grid[j]=obsCount;
                      obsP[obsCount]=new Point(i,j);
4 Y' V* q0 _$ v& j$ M4 }+ w  `                      obsCount++;
                      break;
# ?: E; h7 G% R! J1 j' t                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
                          OriginPt[OriginPts]=new Point(i,j);
" o; Q* S# R# z& P, _2 @) v$ o0 v                          OriginPts++;
, y1 C% p6 }' |  u. D                      }
                      break;
                    case 3:
+ Q7 |1 g8 h; `                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
1 d- W7 J4 X; o0 e5 a                      }
0 s. b6 K' L( x7 T7 P( Y7 k2 n                      break;
                    }
! ~# ^: E% S2 l7 [( {% Y8 |                  }
+ O" O) K. B8 `2 V, ]- F                }
            //如果没有指定窝，则随机的选择一点
, l2 |) L: r. J0 Q, h8 G            if(OriginPts==0){
/ f. t' D* z- P" {8 d. a              for(int i=0;i&lt;width;i++){
, U$ A( k( f' Y. U9 z4 {. V                int  j;
  f+ F3 R: |& K0 u, v( ~5 ?. Z                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
5 h, E7 s* f2 o" T, n! n  G                    OriginPts++;
                    break;
: G7 p, _/ M# }$ V                  }
$ g/ J1 ~  j  |% q/ b( S" Z                }
                if(j&lt;height-1){
                  break;
6 u8 b! R5 U; Y& g                }
8 _" _- R" r7 I              }
$ N* p% R6 p9 {  L- l; B            }
! j# s- c% b; g& g        }
1 f$ l# s" O3 F3 N+ P public void reinit(){
                //重新初始化整个环境</P>
0 R- J$ L5 P( e4 S<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
<>
! R  N' E3 _7 d; `: d  //清空所有信息素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;
: q4 h( E0 U1 F                                }
   }
: N# a, f& X# y5 g+ W; u: ^( u  }</P>
" M% z# }! t8 o0 F# Y% w- B% o<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
  d6 B9 q+ f) B5 g$ G: x          ants.OriginPt=new Point(OriginPt[index]);
                        ants.init();
6 S; l) C  n( m' K* ^  }</P>
! p5 B+ S  r; h: G3 p2 A, I. _<>                //清空信息素向量
' }2 K2 a$ {& l8 _, {$ e                phe.removeAllElements();</P>
6 G- j( C! i. a9 @/ M9 A<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
  for(int i=0;i&lt;EndPts;i++){
# A3 b9 i, g0 P                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
5 t' R' Y$ {* v4 L! ^                        for(int yy=-y;yy&lt;=y;yy++){
6 ~3 _- S! F3 o& f                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
8 \# e5 A3 @& v, q                    }
                }
; ~2 j! v2 r5 l+ h! e* c9 D                for(int i=0;i&lt;OriginPts;i++){
& R7 P, S- Q; r, H! T' X. w2 P                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        for(int yy=-y;yy&lt;=y;yy++){
                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
                    }
                }</P>
2 H7 f3 I5 f( Y  K<P>                //重画
  canvas.repaint();</P>
<P>                //让程序开始运行
, E6 p* e, p0 t$ j2 G$ k                //running=true;
. W$ l1 S+ @1 z/ h6 p. \0 m9 F }
7 A' h, V1 Q; t+ r7 M& S* A8 y public void paint(Graphics g) {
  canvas.repaint();
}</P>
5 B6 i6 z1 u5 [, c( s- w<P>
' v1 A* D. W, F. C+ v/ ~$ ypublic static void main(String[] args) {
    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
4 L! I: c8 V9 K& Y, `7 p7 W$ w/ J    Frame frame;
    frame = new Frame() {
) D3 ^+ z/ t! ^$ X      protected void processWindowEvent(WindowEvent e) {
1 w& O. \0 d& c/ B; _        super.processWindowEvent(e);
" [3 B, y' ~. u( d. w+ l        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
          System.exit(0);
        }
      }
( V, C* x; D8 L4 i1 u. y, ?' g1 G& |      public synchronized void setTitle(String title) {
& O% P( _, f" X$ x& t        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
* Q' @2 i% ?0 S+ {, ?8 u8 g! c      }
    };
3 a8 L8 R3 K! x$ f3 O6 Y    frame.setTitle("Applet Frame");
    frame.add(applet, BorderLayout.CENTER);
9 T# l$ F6 j/ O  X5 _1 [1 P    applet.init();
0 V8 U5 w& n/ F% I( h. g/ _/ _    applet.start();
% D' @; ?) p3 o" U9 A$ c    frame.setSize(300,320);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
% O; z6 f% f: ?: S    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
- K7 n5 |9 ~/ Z6 m6 q' ]8 L; i" @    frame.setVisible(true);
7 U* O- O8 t; c) H* D5 A% ?) a6 T& c  }
  public void start()
  //下面三个函数是控制线程的
, z* C4 c- L% L' P5 x0 m2 b {
  if (runner == null)
, D- @  R( c) u, l! }  [" E  {
   runner= new Thread(this);
. }1 p0 O7 i- U   runner.start();
   //running = true;
  }
% H  w9 C1 j7 M( z. p2 t' K }</P>
! c* J, R" Q5 D7 q<P> public void stop()
{
+ H9 r( B+ w8 z9 N9 a# I$ I: E  if (runner!=null)
  {
   runner.stop();
   runner=null;
/ x, n* I$ n8 [- |# {* n   running = false;
  }
3 p$ Y5 \; Z, E }</P>
1 |! Q. w  t1 ]. x( Q/ Y# q  \. f<P> public void run() {</P>
# z  }- K9 l- T7 S0 s, R( A) c8 G<P>  int i;
* K$ C' Z. o4 _) e: f                //线程一直运行下去
- |7 _9 J; u# p! m2 }" q  while (true) {
" h( `/ G6 W% F% P          if(running){
       //如果开始动画，就进行canvas的处理
( M" f! m. }: ~                          canvas.process();
                        }
    try { Thread.sleep(delay);}
2 |  v( s) m9 d1 c    catch (InterruptedException e) {
   }
' a; E! o% |+ J) P7 C  }</P>
7 e: z5 A4 ], \! J% F  r7 Z1 T<P> }
        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
' I! D  n2 ^: g7 ]                //开始编辑地图面板
* t3 ]. L) L; P5 U5 A* t# ?   running=false;
                        btnStart.setLabel("开始");
  w6 @& }+ }- a# g   MapPad ctl = new MapPad(this);
# `" i# l8 J( f! R# ^6 s" y/ B                 ctl.setSize(308,380);
                        ctl.show();
. ?- M" B# [9 M. E' X                        return true;
) i& U* x6 }2 M2 W/ P  }else if(evt.target == btnStart){
6 \3 i) q, @7 B  f                  if(!running){
9 z  ~" \( ~$ y$ |2 O                    //如果刚刚按下了重置按钮就重新初始化一下
7 u: u/ b; O) |                    if(reset)reinit();
                    btnStart.setLabel("停止");
" \5 s+ _+ @" o- f) G                    reset=false;
                    running=true;
+ ]1 w( ]3 C6 r& i% K  U                  }else{
3 `" R( L+ Z, y8 q; |                    btnStart.setLabel("开始");
                    running=false;
! L# _. W. W" ?6 i/ ]/ w                  }
! L8 M8 J5 \8 r( H7 c                  return true;
                }else if(evt.target == btnReset){
1 k5 W- s, S1 c/ D0 p0 j9 g                  running=false;
7 i! ?7 Q; E. ]: K4 G$ U                  int j=0;
                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
1 g5 k5 W" j) x4 o1 T8 t                  reset=true;
0 K, p- k, y( p3 X5 w' w3 B0 f3 X                  repaint();
                  btnStart.setLabel("开始");
/ z! B; A% X* [) Z; v5 @% Y% _0 e                  return true;
                }else if(evt.target == btnConfig){
                        running=false;
                        btnStart.setLabel("开始");
     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
                        ctl.show();
                        return true;
                }else if(evt.target == choPDraw){
. }& W. A. i3 D% I; A                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
  @5 Q4 F+ N4 L# Y/ ~2 Y+ R, v! H                  if(drawPhe!=1){canvas.repaint();}
$ {6 n8 @+ t" t) W' u2 _                  return true;
                }
$ T) r$ J* O& Q) M5 m: J) q                return false;</P>
<P>        }
7 j8 S" o0 T! Q4 W  Y, T /**Destroy the applet*/
. m* ~# a- z( S% w/ D) {  public void destroy() {
  //当结束程序的时候，把线程也结束
+ A: b( b" W: Y- ?) T) [9 [. l    if (runner!=null)
$ E2 x' b) ]) n) X& ^    {
       running = false;
/ s  w) }' H6 j. I% h5 ?       runner.stop();
       runner=null;
3 }4 S8 l1 Z# w8 t# R5 a+ l    }
$ p& s6 R9 x2 N4 d; \  }</P>
<P>}
, D) `. X$ T+ m' r: W6 T* A</P>
! S3 h3 {; C8 P9 X3 }

! X" c# p$ P+ p" @! ]  s
$ R% r4 z- b: U0 A4 X<P>package ant;
: T5 P9 D" a8 Q& m6 O: X: D7 ?import java.awt.*;
import java.applet.*;
import java.util.Vector;</P>
<P>public class ant{
7 u. N1 `2 i- ~ Point nowPt;//当前点坐标
int VR;//速度，每次蚂蚁能走动的最大长度
* ^7 g* Z9 p! c& q  int id;//标识
! `, Z3 E* {9 Y' Z: e  Point lastPt;//上一点坐标
% f! f9 t. t" o. i- X Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
4 u/ G! H/ _' D5 [0 ^6 P int height,width;//世界的尺寸
        int Phe;//每次释放信息素的数值
Antcolony local_colony;//主程序的指针
; d3 [  n9 C" G6 U        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
        double Main_direct;//主方向
        Point FoodPt;//记录的食物点，是否找到时候判断用
        Point OriginPt;//窝的坐标
. E) t* I& c9 V9 F        Point AimPt;//目标点，是窝或者食物
4 B) B: ^8 ~. l1 \+ u        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
1 x7 a1 d2 L9 ]! U4 Q1 A! E        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
7 i( W) S9 @" E- E3 U        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){
0 V$ W) W" M9 ~1 C3 @  q! K5 j  nowPt=new Point(nowpt.x,nowpt.y);
                OriginPt=new Point(nowpt.x,nowpt.y);
2 D8 L: H( R8 Z2 ~- h  f                FoodPt=new Point(nowpt.x,nowpt.y);
                StartPt=new Point(nowpt);
/ G7 `: P9 y/ i! y! p                AimPt=new Point(nowpt);
                lastPt=nowPt;
  VR=vr;
1 W! t- z! Y1 @" E, Q  id=idd;
  color=c;
2 M0 l3 i7 O$ _" p7 R6 s" `  back_color=Antcolony.BACK_COLOR;
4 q7 @  w7 y. G9 E' M  height=Antcolony.height;
; S& `3 V- ^& }# ^  width=Antcolony.width;
  local_colony=colony;
                Phe=200;
# d( X, C. k. Y2 A" ]' f, [# ]                mistake=mist;
                HistoryPoint=new Vector();
                Main_direct=-1;
/ X$ C) M! p: D9 D7 A' j                FoundTimes=0;
$ b8 v+ N4 a! U                Max_Pheromone=local_colony.Max_Pheromone;
* N$ m1 Q* ^1 Y4 e" i# @                Pheromone_count=Max_Pheromone;
                memory=mem;
4 X+ O0 E/ v+ m9 }( \                Count_distance=0;
$ E0 |' f# Q+ u# |                Min_distance=-1;
}
9 p: U& z; h8 @+ y  G' J+ z0 h        public void init(){
: _9 F" D9 p) n$ X/ h          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
# o4 R2 k$ W& [% a          AimPt=new Point(OriginPt);
9 @! [7 F1 ~2 f$ L& I          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
! ]6 }3 i, h! f# ^. z          Main_direct=-1;
          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
# L6 u* A  b  x( [          Count_distance=0;
          Min_distance=-1;
        }
  v% f6 V) Q- r& h/ U; W public void Draw(Graphics g) {
          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
! A& |/ T' Z1 x( z$ {: C' `  g.setColor(back_color);
4 ^' z2 U1 i& f' b8 e7 `* s* K$ _% o  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
" n7 p! y" ~# a5 h  g.setColor(color);
  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
' Q- T) T% d6 g( K7 i }
public void Process(){
% N, m( o5 a! l# Z4 ^0 W3 u        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

) T$ b- X7 I6 E8 X) U. V<P>        if(Judged==false){
          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
( ]* ~) c2 ~: g8 a. D          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
4 I2 K) d' r- j2 y( n7 v              //判断，如果找到了目标点那么就退出该程序
; J3 I4 F5 F/ p3 @3 F% `- F              Judged=true;
              return;
' Y9 r  {. C, Z. V0 `          }
        }
" n, U& o, P* Q        Judged=false;
        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
$ T, ?3 e, o& H: v9 |$ [1 N& k1 }        double direct=SelectDirect();</P>
! u9 z6 P+ K1 b7 t% p4 [! S. P<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
& }3 @! q3 G0 Z- G+ s        int deltx=0,delty=0;
  C0 z8 v/ X4 H4 I/ N9 [" d! _! B        //direct是方向角，根据方向计算位移
( Z* _5 l* M" l# G4 B/ D% J  D        deltx=(int)(VR*Math.cos(direct));
        delty=(int)(VR*Math.sin(direct));</P>
<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
8 t$ U" _' m2 ~% i8 Z        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
0 L3 ~' t4 l0 A' i- W7 g$ ^        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
          int deltx1,delty1;
" N2 Q* g5 z/ G) O# P. Z          deltx1=deltx;delty1=delty;</P>
* n/ e8 l4 A' A. a! B1 Z; t% ~9 i<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
, }' W+ f+ g* C9 U" V# J! Z          for(int x=-VR;x&lt;=VR;x++){
0 l% |, w3 x4 v8 S, |( }* C             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
; Q! k; `# y9 D" k+ p                int yy=(nowPt.y+y+height)%height;</P>
9 ?/ B( m# f$ I' P3 O' ]! q<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
+ a9 }5 a* G" t5 y                  //的到要搜寻的点的信息素
. T7 [% [: e4 G  q                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
. G% K, `* }+ X: d' j+ o  v8 o& L. I                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
+ r  e" z! J0 z1 E* Z                          boolean found=false;
9 @- u7 }. Z& q5 C                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
                          int minsize=memory;
2 i5 a9 O  \8 v7 ~0 c: w                          if(size&lt;memory)minsize=size;
" S9 D8 Z0 B" _7 r5 n                          for(int i=size-1;i&gt;=size-minsize;i--){
  H3 g1 \' Q" E! {                             Point pt=(Point)(HistoryPoint.elementAt(i));
4 ^: j6 s7 _7 a$ E                             if(pt.x==xx&amp;&amp;pt.y==yy){
9 W4 C) ^' S0 n3 v" w+ n                                found=true;
- u% c' h* H+ Y$ T) H# M( ]                                break;
! R: h; ]; b/ N6 b9 R0 L                             }
                          }
                          if(!found){
                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
4 L& V  |. d# [1 f+ V! G                            deltx=x;
* `5 w/ h7 ~; |% r0 [                            delty=y;
& M. w9 g) ]5 F( }% q$ E                          }
                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
0 S- R# p- E; [$ A                }//end if x!=0
" c; W5 t  w7 _" [$ H7 r8 G            }//end for y
        }//end for x
6 C- j; D& p7 R" X; V3 M        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
( y  \4 y% C, R, n7 h4 K4 E7 m        pt=Evade_obs(deltx,delty);</P>
<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
! C( K& I$ s& g; H% ^        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
          pt=Evade_obs(deltx1,delty1);
        }</P>
8 h/ d* `9 k# L2 Z, Y! _; i1 y<P>        //播撒信息素
        Scatter();</P>
<P>        //记录走过的距离
3 h4 s6 ^7 Z3 h, a! m        Count_distance+=Distance(lastPt,nowPt);</P>
& N' S: x+ r7 n+ l% y6 @% h. O1 H<P>        //改变当前点位置
        lastPt=new Point(nowPt.x,nowPt.y);</P>
# u0 r3 m* f: D0 _* J9 ~" X8 u<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
, T( i) M0 L) V6 y        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
        if(HistoryPoint.size()&gt;memory){
/ b/ U* B( j9 h0 E7 l- V% I! v          HistoryPoint.removeElementAt(0);
        }
3 m5 r# E& S1 C; [( x2 E4 l        nowPt=new Point(pt.x,pt.y);
( I* e! P* ]" v     }</P>
. i" P3 w% f1 D5 Y<P>
        private void Scatter(){
: ^- t7 n' @3 O* O  ]/ l' p& p        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
& }8 L3 ~4 A' @! V% u* Y( u/ j        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
' R: N8 ^5 M. E* e            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
* m- r+ r+ F' z! @# _, @            int kind=FoundTimes%2;</P>
) _# M0 @# O* E8 J0 i; F; D3 `<P>            //获得当前点环境已有信息素的值
/ [+ a9 v6 {5 I            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
            boolean ofound=false;
4 H' m' ^2 B& J5 b            if(Phec!=0){
, {2 {% x# t' i, @) N                //如果当前点已经有信息素了
                for(int i=0;i&lt;local_colony.phe.size();i++){
5 C3 s& s2 r2 k& D4 K                    //在信息素向量中查找该点的信息
  e" Y, \. M& b9 f" G                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
1 e& `! m- R" [7 C                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
  Y5 O9 \) \& j, n3 U; u                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
1 E5 L" T  ]$ Z: Q8 z; \: q' f                        ofound=true;
                        boolean found=false;
/ ]% c0 C0 Z& D6 E% e                        if(size&gt;4){
$ I2 l" z1 t8 S" ?7 V) ?                           for(int j=size-4;j&lt;size-1;j++){
$ F( D3 h3 _% U  \                              Point pt=(Point)(HistoryPoint.elementAt(j));
                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
1 g8 P) g# S) Q                                //如果当前点重复了以前走过的路，就不释放
                                found=true;
* A" |* K# s3 h                                break;
+ q1 W3 A8 ]5 Q$ \" n$ R                              }
                            }
                        }
                        if(!found){
                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
1 G4 |4 s! c# b<P>                             //让还剩下的信息素总量减少
                             Pheromone_count-=Phe;
                        }
5 d& ]8 w( t1 P: n! S5 D/ d                        break;
                    }
- _2 q5 I1 _. J5 V9 L+ i/ l7 h                }
2 }0 j, m& c  p* m" L$ t6 ^8 {              }
          if(Phec==0||!ofound){
4 i$ B4 m- h) _+ e            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
5 @" D9 u7 C$ A, ~, H                ph.Add(Phe);
' Z9 C5 L, T+ W  z" e# D0 v- y                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
                local_colony.phe.addElement(ph);
% I% f' n4 a. n' C  d                //让还剩下的信息素总量减少
                 Pheromone_count-=Phe;
           }</P>
, X6 @4 q/ \) W1 P, j3 D<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
9 e0 F1 X& \' v% q2 e: u" u           Phe=(int)(0.005*Pheromone_count);</P>
# E; R8 R. K* F+ n( d( n<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
        }
  f, f1 Z3 q2 b6 iprivate boolean JudgeEnd(){
( f9 z) h6 v" h    //这个函数判断是否已经找到了目标点
: b3 S) \4 r# V% \7 h! b    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
& h3 M, l/ V4 F/ W) L" \, M    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
( W! b7 R( K& ^# H. v; P" v        int i;
- t+ [8 G! r: n* r  Z5 R        for(i=0;i&lt;local_colony.EndPts;i++){
9 c' E* B& A& p' o* U4 n            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
0 G& L$ t( O8 P4 |  l              //如果找到了食物，就直接移动到食物点
              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
  ~" v# N' Q6 S7 ]3 H              nowPt.y=local_colony.EndPt.y;</P>
<P>              //计算最后的总距离
. B! A2 [% h, y; ?              Count_distance+=Distance(lastPt,nowPt);
2 g  L. E5 H& t: u/ a. L              //比较大小，记录较小的距离
* Z$ ?2 r: v9 B; t7 x! V              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
+ v& a. K! k# N! i0 D, M$ D1 @& {) v                 Min_distance=Count_distance;
              }
4 D9 E8 v/ X0 ^3 j; g& e              //清除总距离记录
              Count_distance=0;</P>
5 o9 ^) I  N) i: Q' @1 d( n<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
( p' I* a! u+ B, Z$ [' p' x              AimPt=new Point(OriginPt);
0 c4 m0 `9 B8 ~+ n& j              StartPt=new Point(nowPt);
              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
<P>              //找到了食物就把找到次数+1
              FoundTimes++;</P>
/ U% X7 a. Q; o- i* r7 o/ H<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
% x, `3 m" s. W' {<P>              //重新把自己能撒的信息素置为最大值
: z# `% ?3 H$ o0 }& f* b# s              Pheromone_count=Max_Pheromone;</P>
, w& m$ f* I6 G6 i3 `, z; W+ e0 W! o<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
) F2 F9 ?7 z% t<P>              //返回找到为真
, s' Q- b6 m1 n              return true;
            }
5 Y! b' s3 @2 P9 A' M/ J! ?- [$ e: ?        }
      //否则没找到
# I/ C! d2 F- I9 {0 U) F% V! D' B      return false;
. ^& g9 e/ a8 P: n1 a    }
    if(kind==1){
% i$ I/ k4 b* E( Y# S% W/ L) e- c        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
- o$ A* C. c5 K6 U2 }2 v/ A! I2 k        if(Distance(nowPt,AimPt)&lt;=VR){
1 V! A% s5 W; `7 }            lastPt=new Point(nowPt.x,nowPt.y);
            //如果找到了目标，就直接移动到目标点
+ J4 L6 Z9 F& x* W' G            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
/ ?- E9 X4 N5 X: X9 U<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
6 D% Q5 G/ S. f% ]4 E$ N5 l              //比较大小，记录较小的距离
$ o" `* _0 u0 @- o% S              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
              }
2 e! N8 X" H9 g1 U5 I; i( ~              //清除总距离记录
% z/ i4 k- @6 \% f' g4 a$ ?              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
1 F7 I8 v. Q: C- i* K# e            StartPt=new Point(OriginPt);</P>
<P>            //重新置信息素
/ R! ^& H5 q2 c1 d            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
) K7 F" g* w1 Z) `4 F4 L( r8 \9 T<P>            //主方向反向
            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
7 {4 ~$ [/ ^' [' E            FoundTimes++;
6 A4 S3 X9 p2 y/ ]0 p            return true;
        }
! B& t. d; \$ p1 w$ y% O        return false;
    }
    return false;
) y8 F- }$ l& U  F. L}
        private double SelectDirect(){
                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
9 }- c* y7 t$ U  C% X0 t3 w% x; C        e=2*Math.PI*Math.random();
6 F, D# w* R. ?; x7 L& B$ ?' l                      Main_direct=e;
                }
. u/ ~1 z+ Y- d: e                //选择主方向角
                direct=Main_direct;</P>
) V3 z: B4 \) o; K+ m& ~<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
8 d/ p8 {$ \& ?                //[-1，1]的随机数，并且在0点附近的概率大，两边小
) E- w* z1 g% n- Q                double re=Math.random();
% ?4 y  f% N6 i$ h+ e                double re1=Math.random();
: [/ a' [! A/ B. f                direct+=Math.PI*(re*re-re1*re1)/2;
4 U8 |, u( J5 x# n  f& S) B2 x                if(re&lt;0.02){
                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
$ P3 R. o! G9 d1 B; p( x+ T7 T                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
7 C* n3 U0 C# }  ^2 I9 U7 h) h                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
                       Main_direct=GetDirection(pt,nowPt);
                    }
                  }
" @* j) [# g2 [1 X+ y* t                }
. Q7 |5 b. D! z2 y               return direct;</P>
* `* O8 G5 _% k6 g2 u- v: _9 r<P>        }
) Z+ \; c4 R& ?/ n        private Point Evade_obs(int deltx,int delty){
              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
2 Z0 v) R# t( r2 a              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
- J. v, ^1 `0 I0 s6 Q              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
+ V6 `5 ^- F& i4 a& |              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
              Point pt=new Point(0,0);
              int x,y;
              int delt=deltx;
6 V8 T5 q8 v$ p9 l; r8 N3 P& |              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
' Q  {( k- {& e              if(delt==0)return nowPt;
6 }. [5 A2 ~' ]              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
/ R! n) N& m% s* Q, o1 B                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
, _- t( r+ L5 A                  x=(x+width)%width;
                  y=(y+height)%height;
: R% u7 J/ n6 R! r- U5 M  e                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
0 S6 K3 E& r$ P$ c, Z<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
$ h+ `0 Z1 U. ?! u' U$ o# @! ~                     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);
& Z/ {; N* s+ ]  f. l                     break;
                  }
! O: b4 y. X! j9 `                  pt=new Point(x,y);
                }</P>
<P>                //计算得出实际能够到达的目标点
& v7 v! L0 ]" Y; z% r  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
2 G+ z0 U/ h# B8 s         return new Point(x,y);
        }
        private double GetDirection(Point pt1,Point pt2){
4 u  [2 Y/ H& H4 u- H4 h        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
! H7 m5 S3 ?9 [* c* j0 W        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
8 {. k2 z5 y- H4 x& }        //其中方向角是所有可能的角中使得两点连线距离最短的角。
4 V# S. a% f8 M0 z) k% w0 ^               double e;
. C: X$ i: z6 v. V$ V) l  B; `, B               int deltx1=pt2.x-pt1.x;
               int deltx2;
- _- Y# Y% h  |) S( \5 u; O               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
2 W/ L: D8 d) L               else deltx2=pt2.x+width-pt1.x;
               int delty1=pt2.y-pt1.y;
               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
) @( q7 |! f9 Z" |2 c2 ?               else delty2=pt2.y+height-pt1.y;
( L1 v7 Q* h) H" f+ x  u" Z               int deltx=deltx1,delty=delty1;
               if(deltx==0&amp;&amp;delty==0)return -1;
4 L# g" i' s2 _               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
0 r4 E- `9 w( J4 v- d3 O    deltx=deltx2;
               }
        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
2 Z& X& D- w& G" w$ L/ r7 v. I               }
               if(deltx!=0){
                    e=Math.atan((double)(delty)/(double)(deltx));
                    if(deltx&lt;0){
& I  ^5 s8 L3 B8 ~( F                       if(e&lt;0) e=e-Math.PI;
" d, {# r' h, h                       else e=e+Math.PI;
# r' [& G$ u6 o4 \, u1 {7 ~+ B                    }
1 O: w" r6 U) s. s                }else{
6 C+ H5 |9 ?& g+ ^5 U# @2 |1 Y. t                    if(delty&gt;0)e=Math.PI/2;
, p( R; L/ ]2 x3 p                    else e=-Math.PI/2;
                }
* p- _) x! X: \0 p                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
        }
        private double Distance(Point pt1,Point pt2){
% m  z" ^/ n1 I. k' e5 U        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
4 M3 e1 F6 k+ G! v            int dx2;
            int dx,dy;
1 [1 `- q& F8 E! Q& @/ w            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
' Z' Z* }3 o  ^0 n8 n; e1 r) s9 R; r            else dx2=pt2.x+width-pt1.x;
            int dy1=pt1.y-pt2.y;
            int dy2;
            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
" t2 P$ l+ f/ I* Z- X( P; ^, I            dy2=pt2.y+height-pt1.y;
            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
            else dx=dx2;
. e( s6 s4 b& G            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
            else dy=dy2;
            return Math.sqrt(dx*dx+dy*dy);
. ?( {6 M( y8 L, j        }
# x3 z' [( @: [0 ^5 ]    public void clone(ant ant1){
& K' ?) L1 ~! A9 p# {        //把蚂蚁ant1的属性拷贝到本蚂蚁
- }* Q6 e; O1 D3 r, ]: f, e     nowPt=new Point(ant1.nowPt);
( y/ ^3 o0 W6 q( D- u        OriginPt=new Point(ant1.OriginPt);
  s8 }9 |8 {7 B9 j0 V% H        FoodPt=new Point(ant1.FoodPt);
$ I: j: K/ }+ J& S. Q        StartPt=new Point(ant1.StartPt);
% t. E0 N) S* Z2 H2 g3 W$ T        AimPt=new Point(ant1.AimPt);
        lastPt=new Point(ant1.lastPt);
        VR=ant1.VR;
3 K  |. I) F  ^1 k4 x0 v9 e0 Y6 I        id=ant1.id;
0 o7 w; `1 c7 Y. z" }* `        color=ant1.color;
        back_color=ant1.back_color;
        height=ant1.height;
        width=ant1.width;
        local_colony=ant1.local_colony;
        Phe=ant1.Phe;
. H; j3 @, ?1 S0 w% d8 Z        mistake=ant1.mistake;
9 B2 B! x- [9 L6 ]        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
! _& Y6 _, [7 Z. D4 c1 O        Max_Pheromone=ant1.Max_Pheromone;
8 G1 j8 [0 r6 x1 G8 h- M6 `        Pheromone_count=ant1.Pheromone_count;
+ [5 U, f( [+ r. M" u        memory=ant1.memory;
        Count_distance=ant1.Count_distance;
$ ]- H% E* l7 l$ ]  X. \6 F- w        Min_distance=ant1.Min_distance;
    }
( T* T# Y1 }/ ]; D}</P>