[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
% X- z( C$ n& H2 @* |<>package ant;
/*
5 d% m3 j; J/ z2 |. K * @(#)Antcolony.java 1.0 03/05/22
*
  o; ~/ J/ Q' O8 i. F, g  ~* g. ~ * You can modify the template of this file in the
0 P+ _. t3 u6 e; N * directory ..\JCreator\Templates\Template_2\Project_Name.java
8 n9 X' K/ m7 i3 v% C *
* You can also create your own project template by making a new
* folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
*
*/</P>
0 T2 K+ l1 x, k/ U<>import java.awt.*;
# n) {: g3 @* O( h/ s( G7 O$ X) Pimport java.applet.*;
% F3 u4 s; G8 Z  ?8 Z) e4 |import java.awt.event.*;
import java.util.Vector;</P>
4 B- k9 X. A6 R6 R<>class AntCanvas extends Canvas
. ^0 h+ q, ?9 x  }5 S+ J{
% [$ V/ K8 h2 r: e" B6 [" o    //画布，一切画图操作均由该类完成
# p1 k& z# t8 m) c# U$ j: _$ f //Image image;
Color obs_color;//障碍物颜色
Color origin_color;//我的颜色
Color back_color;//背景色
# W/ K$ s) G) S* g( Q8 A        Color end_color;//食物点的颜色
( E' w3 G! f0 \  u' _ //boolean first;
  {. c$ k' `7 s) Q5 M% ~ boolean reset;</P>
<>/* public AntCanvas(Image img) {</P>
1 q$ B& X4 r/ U& _3 W' `* f<>  super();
: H+ s* w% M) y4 U: o3 T+ \" X  u   image = img;
  obs_color = Color.white;
  setBackground(Color.black);
  setForeground(Color.white);
9 B$ V& P' T/ b$ V' A3 @/ u  first = true;
  reset = false;</P>
<> }*/</P>
! N; }8 m% }2 _2 {4 Y7 a<> public AntCanvas() {</P>
8 h: p2 b1 N" i9 J9 E<>  super();
- u' Z) [+ [9 O! R   //image = null;
  z  k+ }# t3 g$ z, `+ ]! V- O) f3 M   back_color=Antcolony.BACK_COLOR;
  setBackground(back_color);
; l7 f! u5 i2 ^6 S# M; @  setForeground(Color.white);
$ x' _7 i4 {5 x, V( @) y  obs_color = Antcolony.OBS_COLOR;
6 J4 `0 `: B% `) W4 s. h& p% q1 S7 \  origin_color=Antcolony.ORIGIN_COLOR;
                end_color=Antcolony.End_COLOR;
  //first = true;
, ]. I- `. p8 u% y; O: a  reset = true;</P>
- @0 c% R8 f/ \- u( }<> }</P>
' O* ~* Y* c/ H$ ~: ]: p<> public void Clear() {
: h: [+ D2 A8 z3 v! A        //清空画布
# U9 m* X, ^6 D& e  reset = true;
  repaint();
}</P>
$ ], R. }  A$ p, K9 p<>
public void paint(Graphics g) {
  int i;
                //重画的时候仅仅画障碍物
) g' G) K& m4 E/ [! S6 q( O9 I  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
  J; y# X* n" E' g' T  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
<> }
public void process(){
' V2 e7 V$ I  o        //处理动画的过程
/ J' }' D# f) V5 x  Graphics g=this.getGraphics();
1 \+ C( \, K- p                g.setColor(end_color);
6 M! g9 l, m$ g7 E. [/ R   for(int j=0;j&lt;Antcolony.EndPts;j++){
                  //画所有的食物点
* ]. A/ x# R, {7 \$ ?- T) F  E# j                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
                }
+ H) E/ t( P" |                for(int i=0;i&lt;Antcolony.antCount;i++){
! m# o# O$ U, k7 m8 Y: i6 i) \                  //每只蚂蚁开始决策，并画蚂蚁
) h5 m% N6 f& a  y   Antcolony.ants.Process();
' C% a' r' S. g+ j  B   Antcolony.ants.Draw(g);
' a! P. c0 T# H; N/ {, Q# w  }
5 v/ b- D: n8 S                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
* I; Q* H% t( B# ]                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
                        case (1):
                            v.Draw(g);
                            break;
+ _( v: l$ \, e+ q" o: z$ K: B: h                        case (2):
% K5 I2 U' G8 R# s                            if(v.kind==1)v.Draw(g);
; ?0 V- b/ t, k) b4 x& B                            break;
                        case (3):
                            if(v.kind==0)v.Draw(g);
! W# _4 f, C0 I- n' B                            break;
                        }
                        v.delimit(g);
2 w# r+ H/ Z+ z( q; `                }
5 @( Y) S1 g8 b, y5 [0 F, g! Z           g.setColor(origin_color);
                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
7 w1 [8 U2 C% |% K) C/ m                }</P>
<> }
% Z3 ?4 G; y( Y, E. Z- b; p6 ~0 R/ y Graphics GetGra() {</P>
% f! {1 ?+ j* L4 r6 E<>  return this.getGraphics();
}
}
! q& J( r! L3 G9 F3 s. ~3 Ypublic class Antcolony extends Applet  implements Runnable  {
, P( M3 \6 \, h# _" H: K boolean isStandalone = false;//系统的参数，是否独立运行，不用管
3 Z  F* G2 e3 }3 ^- ^5 z+ e# W Thread runner;//创建一个线程，让动画平滑的运行
$ G3 s! f9 g0 i  s% Y3 Q+ T boolean running;//是否让动画运行
* l$ d/ J& S/ p7 t1 H0 W6 b        boolean reset=false;//是否按下了重置按钮
static Color OBS_COLOR=Color.red;//障碍物的颜色
7 C7 }( t6 ]1 e4 h2 V& s2 _ static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
static Color ANT_COLOR=Color.white;//蚂蚁的颜色
5 U/ b" P1 ]# z) s9 Y        static Color End_COLOR=Color.cyan;//食物点的颜色
AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
% D  W6 G- v8 a6 w- T7 R8 U        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
/ [! k: N; p. ^# ]/ A/ _ static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
  `* M9 M& O" Q* M% _- L        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
0 q+ T9 n. z/ @$ \        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
        static int OriginPts=1;//窝的个数，最大为100
: t' b. P! F( n9 ?: Y$ B static int width=300,height=300;//环境的长和宽
' n4 H4 b! ~) D- Y static int antCount;//蚂蚁的数量
        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
  P; F! [. F- C- A% H        static int FoodR=10;//食物和窝产生梯度的信息素的半径
static ant ants[];//蚂蚁数组
0 H, l% U# N6 m8 O/ f0 t3 \        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
9 M! J2 e9 C- v int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
( z; _4 k8 ~/ p8 d$ T' q; m        Button btnStart=new Button("开始");
1 P% y- N7 z$ _0 T. @        Button btnReset=new Button("重来");
3 P3 u4 T' M) f, t: }) u1 {% r& }        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
public void init() {
                //初始化函数，先画各种控件
# F1 T+ [! v% y- t: V1 z& B2 ]1 W  setLayout(new BorderLayout());
                Panel pan=new Panel();
                add("South",pan);
                this.add("Center",canvas);
                pan.add(btnStart);
9 q% \) A9 J9 s5 a, l/ T                pan.add(btnReset);
                pan.add(btnConfig);
. Y6 B7 o! @3 C. `' O4 Y                pan.add(btnMap);
7 w9 s  a$ S4 O7 k* \                pan.add(choPDraw);
% U8 N7 l9 P( y8 ]9 d+ P                choPDraw.addItem("不画信息素");
/ g, M% \# K5 `$ h: H                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
6 N9 b& f3 g  d2 d7 P3 M8 n                choPDraw.addItem("画窝的信息素");
6 U5 c; X+ A2 W% }. d8 v                choPDraw.select(2);</P>
- m& t) j7 W$ V% ]" k<>                //初始化各个数组
; M1 K; z; l# e$ E  obs_grid=new int [width][height];
                phe=new Vector();
                Pheromone_grid=new int [2][width][height];
                for(int i=0;i&lt;width;i++){
* s) H5 l; i5 h$ E; H! J3 I   for(int j=0;j&lt;height;j++){
; G9 k, p- K7 A# Q% f8 P    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
) C; B1 w3 S, q( W7 v" u, b; R                                }
   }
& k+ v, |( u1 W7 r  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
1 a7 |9 r5 D% W                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
" j* U; C, C9 c& B; i; @          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
/ ~4 g* P" f/ a/ I- ]; h" V  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
3 i7 _1 t+ ^" v                Maps maps=new Maps();
! @  j: B( ]2 ^9 {7 L/ A                maps.LoadMap(grid,0);
" t0 n9 h, b7 v+ r, |6 v                //初始化地图
7 r$ G2 W/ C  ~+ [3 g% y                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
  reinit();
! s8 D5 U' V) W }
        public void reinit_map(int grid[][]){
                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
& \  v- Q4 [( J% Q7 [) I5 z                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
. [; S+ ^$ v2 J<>                //先停止程序的运行
$ d9 K" S' d9 ^& I( l                running=false;
8 Z* n9 Z/ H" c1 ]4 y( ]# {9 u; g                btnStart.setLabel("开始");</P>
<>
                obsCount=0;
                EndPts=0;
" c+ M/ [  Q( f                OriginPts=0;
                obsP=new Point[width*height];
                OriginPt=new Point[100];
                EndPt=new Point[100];</P>
6 E$ e/ U' A8 N<>                //清空obs_grid和Pheromone两个数组中的值
                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
+ U4 }7 q  Q+ I+ A% R7 ?$ L    obs_grid[j]=-1;
* {! X/ a/ r& J                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
0 c- Q4 ]8 r& O8 G' w+ i* H                                }
   }
% n4 F" ?4 Z+ @$ f9 W  }</P>
5 {) z% I0 k, R$ P) A<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
7 Z) C! |. h7 v$ w: l4 F                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
                    case 1:
                      //如果grid[][]存的是障碍物
  H# s+ p! b) e+ h! ~) `; S4 @/ Y                      obs_grid[j]=obsCount;
% J9 c5 a5 ^6 P. \4 i) N! E                      obsP[obsCount]=new Point(i,j);
                      obsCount++;
                      break;
8 l" g0 n& J% z; [                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
% B& o2 d& k0 w8 y. C, u$ n                      if(OriginPts&lt;100){
2 Q1 `; O) g2 l! v2 _2 y: L                          OriginPt[OriginPts]=new Point(i,j);
5 I8 Q  m" c/ g                          OriginPts++;
                      }
5 _  h4 o+ u4 X; ~9 W                      break;
                    case 3:
/ S" F8 G  ?. ]  R2 s. Q+ n- F                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
' H% U8 Z) r/ R4 H- g: c! |  b6 X  T                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
8 P! c5 }0 D! E  L0 ?" N2 J                      }
0 m* B6 h. l# f0 y+ O                      break;
, u" z6 y9 }& [1 P' T% K) h* B                    }
                  }
                }
. M& r  k  W. d            //如果没有指定窝，则随机的选择一点
            if(OriginPts==0){
' u  X7 E4 b0 v7 n1 K7 C( t9 @& Y              for(int i=0;i&lt;width;i++){
                int  j;
                for(j=0;j&lt;height;j++){
' b# B: k* Z: q, ~3 Q                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
                    OriginPts++;
6 o1 x- D+ Y# O+ }  Z! h8 u                    break;
; K6 z2 b+ P4 H" o3 h! a. H/ R" @                  }
. O8 Z" Q2 a- D8 ^                }
0 n2 d/ `  y$ q, N/ B& v                if(j&lt;height-1){
) q& G3 h. @! N6 F, |                  break;
4 N! T# Z: T+ ?6 V* G$ @+ [3 J                }
0 y9 g$ p+ Y7 K; q7 N              }
: J5 r; b0 t, B- U) i1 ]5 b3 w1 d* V            }
        }
public void reinit(){
6 O9 L: {! s  N7 R! V0 ?                //重新初始化整个环境</P>
<>                //先停止程序的运行
$ k/ b: D/ b- g5 P$ [! ?7 F) i                running=false;
9 x9 P5 P4 v8 F' ?4 D                btnStart.setLabel("开始");</P>
<>
  //清空所有信息素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++){
! G7 o/ q: c3 ^! n2 Y, w; ]                                  Pheromone_grid[k][j]=0;
3 c* g' B* i. x' d  e1 T                                }
   }
  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
0 w% M0 S, n: J: b* j3 K, m          ants.OriginPt=new Point(OriginPt[index]);
                        ants.init();
  }</P>
5 I% x6 n9 e! I0 g- h! P% e<>                //清空信息素向量
# h  F: r# l0 [2 k" P' K                phe.removeAllElements();</P>
: }& ~' A2 M2 F0 J5 U<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
  for(int i=0;i&lt;EndPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
$ D  O7 G. m  W* y( t1 J0 _0 {                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
, B# H2 P0 |$ u2 z1 T                        for(int yy=-y;yy&lt;=y;yy++){
$ v: |3 a, J$ l- _                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
/ a% H5 M4 U) D: ]! }                        }
7 Z/ Y1 I% t& T                    }
                }
                for(int i=0;i&lt;OriginPts;i++){
' F2 u: \2 N* p5 h$ C5 f2 I  Y                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
. M, B& t7 G' M) b/ G4 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));
                        }
                    }
8 N1 w* j$ F) u+ J4 i1 W9 V                }</P>
<P>                //重画
+ ]) _4 [/ @6 ?8 U9 d1 H+ y  canvas.repaint();</P>
' D9 U! F; T) n<P>                //让程序开始运行
  R% g. o* L7 }9 E  N                //running=true;
}
" ^& @; l9 D/ U6 P$ u( S+ p; i public void paint(Graphics g) {
' M7 P, L. s8 R# Q7 ]  B; Z& G  canvas.repaint();
, l4 Y6 ]2 S! L# w; T& ?% i }</P>
+ P" h" N; J! g( q: F<P>
$ s9 ]. j5 q8 g4 s7 U5 |5 w' d/ Wpublic static void main(String[] args) {
5 [! j4 }/ l+ s' L. t    Antcolony applet = new Antcolony();
" k# L3 F! f4 h9 Z2 \9 L9 e    applet.isStandalone = true;
9 C0 v) S2 w8 B    Frame frame;
    frame = new Frame() {
$ y, E$ b8 r4 e1 M  z      protected void processWindowEvent(WindowEvent e) {
' l+ F) J. d! k. Y0 I        super.processWindowEvent(e);
) K) j* F2 B3 j. S        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
/ o0 h4 O/ D- G$ q+ t* `* ?          System.exit(0);
- P- H& |1 O: ]! C8 o2 n7 s7 \        }
      }
' i4 N" S4 K+ k. s  ~4 @3 h      public synchronized void setTitle(String title) {
        super.setTitle(title);
* U- P5 v9 k  h4 ~  R! x        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
3 Q5 r2 e- D* h+ K; J      }
& e7 ~2 w% H, x; W* ]5 x    };
$ m8 d( m. j; v5 H$ p    frame.setTitle("Applet Frame");
" f! E; N) _" i  ]; R  [    frame.add(applet, BorderLayout.CENTER);
3 n0 e2 X% Z8 c3 p    applet.init();
    applet.start();
. F  F4 }0 k0 [" E& x    frame.setSize(300,320);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
7 g  n, c) K! Y    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
    frame.setVisible(true);
  }
$ T8 a% k( i5 L9 }& q, p5 m  k, o  public void start()
  //下面三个函数是控制线程的
{
7 K" ?! k: t# j$ C  if (runner == null)
8 I# ?* r5 {, a( r  {
   runner= new Thread(this);
   runner.start();
   //running = true;
  }
  z" z) n4 l0 M( S1 p& W# Y }</P>
, m0 y7 `4 C! t, m7 P2 T<P> public void stop()
6 m" C$ p* k# e' F( S! s {
* [' f" \8 a0 L  a  if (runner!=null)
5 R3 g# M' p% M) y% T9 m2 P  {
   runner.stop();
  z$ W8 o1 s# [3 E" y; o( H' z   runner=null;
   running = false;
0 }2 A4 D) s( _0 |6 U( v  }
}</P>
<P> public void run() {</P>
<P>  int i;
                //线程一直运行下去
  while (true) {
          if(running){
7 H9 U" i# ^$ {1 ^; ?9 s       //如果开始动画，就进行canvas的处理
                          canvas.process();
                        }
5 Z  X' |1 [' ~# o, N5 h) z3 ^    try { Thread.sleep(delay);}
* b+ c* A3 j" g) `/ j, |6 F! b    catch (InterruptedException e) {
   }
% y. W  M) I4 h% K0 b* h  C  }</P>
<P> }
        public boolean action(Event evt, Object o) {
8 V% {8 B* M. x! D# r; a      if (evt.target == btnMap) {
% r  A4 z6 p7 l* e* }" F& i$ b; i                //开始编辑地图面板
6 n, `  }/ t, P. m# Y, k! J   running=false;
                        btnStart.setLabel("开始");
( s" z/ j3 }3 r& b/ F   MapPad ctl = new MapPad(this);
, C7 ?9 Y, A! g/ G0 u8 q# L; D' _                 ctl.setSize(308,380);
" @+ G4 n/ c" V                        ctl.show();
: ]9 _1 p* J8 l6 L                        return true;
9 S0 A# I7 ?7 W# }& x% A  }else if(evt.target == btnStart){
                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
/ d# o# f9 q* P/ C0 m% U. j                    if(reset)reinit();
                    btnStart.setLabel("停止");
- Q8 P; E  T, n. q! ^/ X: B" K. w' g                    reset=false;
                    running=true;
/ e: u' [: p/ {0 `                  }else{
, U5 E. J" R( e, }5 C4 i                    btnStart.setLabel("开始");
                    running=false;
5 o' K6 f* ~; H+ v                  }
8 G6 v+ |6 J; C3 T6 `                  return true;
                }else if(evt.target == btnReset){
1 @0 R% ?$ Z  R  q4 c6 w" N                  running=false;
                  int j=0;
% l' F0 }& H7 r. r# {                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
                  repaint();
                  btnStart.setLabel("开始");
1 P$ J: l4 E) q; n2 Y                  return true;
                }else if(evt.target == btnConfig){
! r8 S7 |3 O9 G# p' c( X# M                        running=false;
                        btnStart.setLabel("开始");
* d: H8 a+ N( }; O4 N' Y' A! w     Configer ctl = new Configer(this);
( B/ L. l" L+ `                 ctl.setSize(300,300);
                        ctl.show();
                        return true;
- U0 l* P' s6 E% R( V                }else if(evt.target == choPDraw){
                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
: V9 X' a/ w* w, v: w                  if(drawPhe!=1){canvas.repaint();}
; J0 I* h& n; S+ ]+ a7 {0 }                  return true;
' P! L) B' Q) W  E5 R+ B% b                }
1 V6 f* ]. Z5 M9 Q5 p# v                return false;</P>
' H$ ~, r+ C2 m, Q$ m# Z4 P<P>        }
/**Destroy the applet*/
3 `/ E4 ~" o) }; g- g8 C0 p7 e  public void destroy() {
/ m% g& ^4 F8 _! x# T8 T% w$ T  //当结束程序的时候，把线程也结束
    if (runner!=null)
7 \5 @5 J. n2 @    {
+ c* N. Y# e" I3 G' x( ~0 z) I" f       running = false;
       runner.stop();
       runner=null;
' d* ~( l( g  K/ @    }
  }</P>
<P>}
! k: T& ], w" B# o</P>
5 U8 R% o+ e' U$ e. X/ p" V4 \& C& S


<P>package ant;
: M) C! j/ f' T8 Mimport java.awt.*;
+ U1 i# V3 ]; G: P2 Qimport java.applet.*;
! L" o& e& ?- I# T, b: [import java.util.Vector;</P>
8 b3 @- }; G: b# p: ^& Q<P>public class ant{
8 j' e) Z6 |+ X* N+ s2 h  h Point nowPt;//当前点坐标
! M, {8 j% A$ X' V1 s; n int VR;//速度，每次蚂蚁能走动的最大长度
  int id;//标识
/ P+ l. h* k9 u4 T$ I  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
int height,width;//世界的尺寸
) V; n+ w. l! u: Y        int Phe;//每次释放信息素的数值
# s4 C+ Y, r! r Antcolony local_colony;//主程序的指针
  o$ u& B: Z9 B% `        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
        double Main_direct;//主方向
9 Q( S, ^* |2 O! u' g/ [- Z  u* w! V        Point FoodPt;//记录的食物点，是否找到时候判断用
# f1 _0 r$ B6 i) U        Point OriginPt;//窝的坐标
5 L" \2 d0 s- k' x/ y" a9 r        Point AimPt;//目标点，是窝或者食物
        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
' K7 d/ ?- B  c: x3 A        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
4 l- q7 S7 T6 C) ?9 c6 c        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
' \' b# l: G  U$ `, K- b" y        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
  nowPt=new Point(nowpt.x,nowpt.y);
% f  b1 y! s5 S* n: t                OriginPt=new Point(nowpt.x,nowpt.y);
' o! a( V7 `6 W( }8 |( S                FoodPt=new Point(nowpt.x,nowpt.y);
                StartPt=new Point(nowpt);
3 k, f; N" M+ p1 j2 B$ ^                AimPt=new Point(nowpt);
, s- r! Y% Z8 e  b                lastPt=nowPt;
! m3 w. z- J9 G# c  VR=vr;
  id=idd;
2 E4 W3 ?# d9 U8 f2 x! y  T' }  color=c;
* W/ Q, Z. z7 S/ y$ j# s  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
  width=Antcolony.width;
, b* ~6 e3 W5 `- o6 o, W6 d8 b  local_colony=colony;
4 s) U0 E% Q; Q) ]1 {                Phe=200;
8 Q. M9 a1 e. O  [                mistake=mist;
* |1 U, r- C; v/ P                HistoryPoint=new Vector();
                Main_direct=-1;
& J3 p8 b8 M' {8 X4 D                FoundTimes=0;
                Max_Pheromone=local_colony.Max_Pheromone;
* R# D% n0 ~% k2 o: V  @                Pheromone_count=Max_Pheromone;
+ {1 K4 S% k- @! e# b9 w                memory=mem;
                Count_distance=0;
% r6 y5 N5 W. a3 Z( S- @                Min_distance=-1;
5 B1 C  |2 g. m6 q  L }
        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
+ M! U. V- O) ]5 |. z! D* l/ k" x, E( V          FoodPt=new Point(OriginPt);
+ @% l* D0 t1 E% q$ q! R) T1 m          AimPt=new Point(OriginPt);
" a. l5 s, g" z: d          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
          Main_direct=-1;
; }* D6 s9 t/ c: L. @% x          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
: d6 h6 v6 @9 I6 _( {0 G% C1 k          Count_distance=0;
          Min_distance=-1;
        }
% g, F) X- W3 O7 v public void Draw(Graphics g) {
7 E! @7 A# M( }  ~          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
  g.setColor(back_color);
1 Y- P! U- i) e' w) k" {# a  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
% p8 W# w, M) T. D/ p  g.setColor(color);
2 }; g6 q- J: o4 z! c& k$ \  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
}
public void Process(){
        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
% A- r6 \5 c$ x8 {% d7 K4 ^        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

' l0 N: B' C/ Q7 A  |<P>        if(Judged==false){
+ I- I( |' P1 t2 m! r          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
  F! `& }+ j% _5 c* h              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
2 Z9 s6 |, i) h8 E. W+ D8 G              return;
          }
        }
        Judged=false;
        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
" K) H+ J7 n  R& ^        //direct是方向角，根据方向计算位移
        deltx=(int)(VR*Math.cos(direct));
* O# _5 W# v- b/ P        delty=(int)(VR*Math.sin(direct));</P>
( |" P2 V5 |2 C4 Y, X<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
/ L: o& [! r3 K  Q. H) @8 T        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
$ d; M3 _' Y* y% i4 O( P        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
2 _8 S: t2 ~" y4 h# I7 ]        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
2 t5 B: a, t  @3 z( O          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
/ t0 L3 w! r6 ~" [          for(int x=-VR;x&lt;=VR;x++){
9 [2 n9 K" i- F& \             for(int y=-VR;y&lt;=VR;y++){
/ \- T& B: H1 x& ~, S) K- H                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
9 |+ W6 G" J4 o) p1 G- U" y8 p                //在这个程序中，坐标是循环的，也就是在一个球面上
9 x0 V$ q% m  T' r& b4 V                int xx=(nowPt.x+x+width)%width;
2 T; V+ h; B! i! C0 {5 V! }                int yy=(nowPt.y+y+height)%height;</P>
<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
! x9 g3 n& B* Z( [+ k                  //的到要搜寻的点的信息素
( d7 ~4 H: c) P; _1 C                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
, g. ~# n$ k. f0 k2 L8 L<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
' T# S) [3 F/ ]3 ~) f" E) h( k. w                          boolean found=false;
                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
                          for(int i=size-1;i&gt;=size-minsize;i--){
                             Point pt=(Point)(HistoryPoint.elementAt(i));
                             if(pt.x==xx&amp;&amp;pt.y==yy){
                                found=true;
* a5 @1 g6 _3 Y* L! V" I                                break;
                             }
                          }
                          if(!found){
                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
                            delty=y;
- E$ f) i: s! F* H' R! U/ i9 g                          }
' w, b' _. X# Y5 [! g8 O                      }//end here==0||ra&gt;0.001
2 w, ]+ a2 S, }/ \                    }//end maxphe&lt;here
6 K! W/ ^' z0 r; |                }//end if x!=0
            }//end for y
  q$ ?  T) c) R( @9 L        }//end for x
  {  n* j6 z' E. `5 u( ?) v        Point pt;</P>
% p+ ]- d4 d* S; S! n" a2 r" ^" w<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
1 x8 K0 d! @. t+ y3 i% t: u        pt=Evade_obs(deltx,delty);</P>
6 D# Z) `# L/ P" U* d9 |% }<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
5 e1 L6 o5 N/ h5 Z* O          pt=Evade_obs(deltx1,delty1);
        }</P>
<P>        //播撒信息素
        Scatter();</P>
- X% \5 K) V* Z% x8 I<P>        //记录走过的距离
        Count_distance+=Distance(lastPt,nowPt);</P>
# }8 b. n4 l( k  L2 m+ i6 `<P>        //改变当前点位置
        lastPt=new Point(nowPt.x,nowPt.y);</P>
/ a# L. o  }& }/ {  X; S) ]* ~7 [<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
! v/ q  g; h0 ^& _        if(HistoryPoint.size()&gt;memory){
          HistoryPoint.removeElementAt(0);
4 {! e! D+ _  ^- k        }
" k7 n/ t2 k. X& p+ |+ Y' T        nowPt=new Point(pt.x,pt.y);
     }</P>
( I# r5 [* z) H9 \<P>
        private void Scatter(){
: L  }  ?6 i: H6 w* Y        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
0 [9 F3 G" t5 {, K        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
' O+ ~3 f" }0 m9 y/ L* B            if(Pheromone_count&lt;=0)return;
3 p8 p+ D7 j& t            //决定释放信息素的种类
5 ^+ t7 ?" @+ x1 }            int kind=FoundTimes%2;</P>
5 v; z. t7 p. k9 R$ S6 a3 `<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
5 r" O% b7 A4 Z' U2 {" Y6 S- }            boolean ofound=false;
            if(Phec!=0){
' i0 h9 Y1 m# `( z; X. O4 L                //如果当前点已经有信息素了
% d6 q! N! ^; Y& Q& k: l' [) |$ P7 S                for(int i=0;i&lt;local_colony.phe.size();i++){
                    //在信息素向量中查找该点的信息
                    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记录。
' F( }, `; @( e/ Q5 x% t                        ofound=true;
/ O* A7 K2 I$ }8 ^6 y: e% I* g                        boolean found=false;
                        if(size&gt;4){
                           for(int j=size-4;j&lt;size-1;j++){
                              Point pt=(Point)(HistoryPoint.elementAt(j));
                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
7 `5 W8 h4 H, Y0 Y7 P3 T0 C& t/ E9 ^                                //如果当前点重复了以前走过的路，就不释放
& T' X% M0 L6 p, n2 n, ]                                found=true;
                                break;
$ ~, B" ~4 O5 c( L& P2 ?                              }
                            }
0 _* A$ F& Q$ ~, C                        }
                        if(!found){
                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
: x, W* B' y6 L8 o                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
<P>                             //让还剩下的信息素总量减少
, Y# b3 c6 K# j2 i& W! B, \# a                             Pheromone_count-=Phe;
                        }
0 |5 ?: s% v- l# @                        break;
& Q4 m! z8 c8 K% B                    }
; Y. r1 u+ Z, ]8 A                }
              }
          if(Phec==0||!ofound){
& B  s% E9 M0 m            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
, [. t# h7 `# P/ X8 h& {                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
, B) U6 i( u1 n9 J8 _$ `                ph.Add(Phe);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
4 f' u+ p" a8 p/ n                local_colony.phe.addElement(ph);
                //让还剩下的信息素总量减少
# \) D2 `; q) h. X8 V) y' W                 Pheromone_count-=Phe;
           }</P>
<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
) A! |1 D# g, ]           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
8 d$ U/ @6 j" g* @7 R! A           //这个模型是否科学？有待研究
8 P0 A; c& y5 f. h# p3 N3 D           Phe=(int)(0.005*Pheromone_count);</P>
7 B; g8 h- K2 [5 S" O<P>           //如果剩余信息素已经太小了，则按照等差数列递减
+ e6 ]" W5 @% Y. m) g/ Q/ ~           if(Phe&lt;=10)Phe=10;
        }
' N' O5 ^3 x% n% \3 rprivate boolean JudgeEnd(){
- x8 q* J/ u6 k+ H: q) u    //这个函数判断是否已经找到了目标点
5 A6 k& b9 d6 U) \    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
6 ?9 ~1 ^: G+ r" t: F$ W    if(kind==0){
' E; B+ G' b/ ?$ a        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
0 \# p3 Q4 f) z$ a- o! _1 C        int i;
        for(i=0;i&lt;local_colony.EndPts;i++){
# r( g- G3 O1 Y: Q) n* o            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
6 W9 ^0 W6 [, g  ]( }              //如果找到了食物，就直接移动到食物点
% G' q0 [! x6 P3 y: m0 ?* T) }              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
) `& C) b  i3 W<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
2 K, g' n$ I  K              //比较大小，记录较小的距离
  h' p! V! w8 s' o  i) X              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
; K7 m4 c5 L- N  _. I                 Min_distance=Count_distance;
5 M3 M' o( q2 j3 C( r              }
              //清除总距离记录
              Count_distance=0;</P>
<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
* i8 x6 J( D6 p( y; X; Z( i% K4 i              AimPt=new Point(OriginPt);
              StartPt=new Point(nowPt);
, _7 d' n$ U; o5 A3 d              //并把当前点标为自己找到的食物点
  i& Q5 e% `7 R) a5 _              FoodPt=new Point(nowPt.x,nowPt.y);</P>
$ |' G$ @# e9 Y9 W  v) t. j<P>              //找到了食物就把找到次数+1
              FoundTimes++;</P>
% z7 X5 ]& j* `<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>              //重新把自己能撒的信息素置为最大值
              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
" R* n) E+ L3 `+ m6 r' j              HistoryPoint.removeAllElements();</P>
7 e/ j: S9 X2 L$ Q: |& A, h<P>              //返回找到为真
              return true;
9 ^! Z% t* Z3 A2 ?) M) X0 e& a            }
        }
3 R$ j; R% [/ R9 v: z* a4 v; a      //否则没找到
; v4 u+ v3 n) N& \2 N' |3 A      return false;
$ ?( R0 |9 k5 f2 C    }
    if(kind==1){
& W7 W# J8 n% l& I$ n        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
8 |* B" c) r6 `) V$ d5 L0 V& S        if(Distance(nowPt,AimPt)&lt;=VR){
            lastPt=new Point(nowPt.x,nowPt.y);
: H; g; d& c0 g: f            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
; b6 u( @3 e( E% W* A9 N0 F5 d; {            nowPt.y=AimPt.y;</P>
$ V- }$ J  Q6 x! x4 e<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
' Q+ t4 q' j7 @8 {                  Min_distance=Count_distance;
              }
3 W# J) P) E% _; c" Q              //清除总距离记录
              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
& p* s2 [4 J# I" x- ]7 r4 J            AimPt=new Point(FoodPt);
            StartPt=new Point(OriginPt);</P>
<P>            //重新置信息素
( I( I' `2 }; C4 _& W" a            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
5 o" _( T) s. b; t1 @; W7 H: C' n<P>            //主方向反向
            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
: K5 j  s$ J) n5 A3 w5 |            FoundTimes++;
. m0 Z  v: E" R+ o! S* ~! @            return true;
: d& r8 {8 O0 p1 T3 x% _% g& D        }
        return false;
  A; P+ V) p; K( r1 p* m% o7 `    }
$ y5 s/ r% Q4 u1 |  x) e. J& U    return false;
}
        private double SelectDirect(){
                //选择方向，最后选择的方向为主方向加一个随机扰动
& E7 h0 f: o. M1 \                double direct,e=0;
  E, c' B' U' p7 A                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
        e=2*Math.PI*Math.random();
                      Main_direct=e;
                }
                //选择主方向角
                direct=Main_direct;</P>
: _* ~2 D/ q/ [; j( x/ Z3 v: F3 y<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
; I: f9 A5 G7 E6 O; u6 e7 z                double re1=Math.random();
                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
& T1 l5 J6 Z! x$ D. u: ~0 Y: l                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
$ l( s, n0 P' \$ ~$ U# }* L                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
0 _: ~5 X% i+ t5 y                       Main_direct=GetDirection(pt,nowPt);
                    }
" {' X5 M0 a: y( e                  }
  c$ r/ G3 f4 ^. ~6 G                }
  r# t" p5 [9 i3 \               return direct;</P>
<P>        }
% S1 |! c2 D5 q% Z7 i2 M% H        private Point Evade_obs(int deltx,int delty){
' A/ I8 r( r1 I8 n8 Y  Q2 M; n4 L              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
1 p. s0 n5 [1 [6 D- O0 M              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
7 m" `; m# p; M3 i) A4 p0 o              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
  i1 X- }5 d7 T. x0 B2 I- s              //p1,p2在这里分别是nowPt和nowPt+delt
7 i: Q( J/ ^8 c( Q# L+ R* e              Point pt=new Point(0,0);
, }+ ]9 s/ f2 i/ M( a: K              int x,y;
7 H! X" T$ G, K" Y0 P              int delt=deltx;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
. W& X( N5 H9 W& R! }' y              if(delt==0)return nowPt;
              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
                  x=(x+width)%width;
                  y=(y+height)%height;
; S  f9 N$ D# q. V3 ^                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
+ J9 g& F# D# p- S+ t, k                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
( L- U5 W& K" {4 |                     double disturb=4*Math.PI*(Math.random()-0.5);
, }+ n& K$ g' p/ r$ F                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
                     break;
                  }
9 D3 T3 r; @- f% o                  pt=new Point(x,y);
+ @) O- E8 G- q  ~' I% e5 p7 L                }</P>
<P>                //计算得出实际能够到达的目标点
  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
' T6 Z: g* h5 c3 W         return new Point(x,y);
# `$ @5 P& R. B. H3 p( P( x        }
. e! s/ ?6 Y, C- g" F, a  \        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
8 `1 t+ ^; E/ ?+ x1 ?) S        //其中方向角是所有可能的角中使得两点连线距离最短的角。
2 \. Z, o3 ~" [; i0 ]& z               double e;
               int deltx1=pt2.x-pt1.x;
- m8 Z: G' d0 x7 k               int deltx2;
1 g/ Q7 J' L8 O8 a' j               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
               else deltx2=pt2.x+width-pt1.x;
               int delty1=pt2.y-pt1.y;
               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
* K$ N* x9 H+ n               else delty2=pt2.y+height-pt1.y;
4 [6 r) x0 G+ [" J               int deltx=deltx1,delty=delty1;
, D: Q( ~7 g5 K6 u8 V* M               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
* u% O( X, ]. X! i; X               }
, v6 b% Z# u* n. j3 T9 x; N        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
3 n) x& J- ^4 |9 R               }
               if(deltx!=0){
                    e=Math.atan((double)(delty)/(double)(deltx));
7 X! G$ |# |0 g  \- R6 v" Q                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
5 v. |% J9 G; a3 N! v  H                       else e=e+Math.PI;
& P! }! o3 x1 L! Q' A8 t                    }
                }else{
! }  B+ `, J( u+ P0 a! k                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
9 J% j- H7 p8 N! K1 Y/ H                }
                e=(e+Math.PI*2)%(2*Math.PI);
2 m$ H2 j5 [8 V% J0 x5 H: h/ h# b                return e;
        }
        private double Distance(Point pt1,Point pt2){
( n) Q3 s4 x- v5 I% u; L        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
& m$ I4 P9 B# E1 y5 L( f            int dx2;
            int dx,dy;
# l7 t. K% q% \6 Z$ T) C1 e& P+ `/ [( c            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
            else dx2=pt2.x+width-pt1.x;
            int dy1=pt1.y-pt2.y;
            int dy2;
) a1 G3 Z8 Z8 f5 R& I, I$ s- Y$ @% S            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
; V) ~" ^" C! {            dy2=pt2.y+height-pt1.y;
; r6 U+ U! m2 Y) }. J  K9 v            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
7 @4 |  S! {* j            else dx=dx2;
* t9 x$ T- p$ k4 j* U, U+ U            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
            else dy=dy2;
6 D# P1 {/ {& W8 N. F- o& `            return Math.sqrt(dx*dx+dy*dy);
# g+ _& J7 x) o9 E6 G        }
    public void clone(ant ant1){
) J, ]# x7 X& y5 w- F7 V: `! G        //把蚂蚁ant1的属性拷贝到本蚂蚁
     nowPt=new Point(ant1.nowPt);
' {; j) p' b: f" s        OriginPt=new Point(ant1.OriginPt);
2 q  v5 X$ U/ l+ ?6 d: A! q        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
, W( ^  D/ s3 E# U- L( W) ?        lastPt=new Point(ant1.lastPt);
        VR=ant1.VR;
3 `( z, f9 W1 D        id=ant1.id;
2 ?0 W4 Z3 x+ |) a$ c* ^! F        color=ant1.color;
        back_color=ant1.back_color;
% y# a9 y7 }' s1 v( C        height=ant1.height;
$ Z& e- L$ M# `0 Y+ c! J        width=ant1.width;
        local_colony=ant1.local_colony;
" }/ s8 w! L' q. q1 ^. p        Phe=ant1.Phe;
        mistake=ant1.mistake;
7 R# \1 {1 L& l( l: f' T$ T        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
9 E' r  B7 a- {  b        memory=ant1.memory;
6 B8 N$ K3 V5 b# e        Count_distance=ant1.Count_distance;
3 t$ r  G% F/ k! o- }& |        Min_distance=ant1.Min_distance;
    }
}</P>