[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
4 O; O# \  V; ]5 T4 v! ~<>package ant;
/*
* @(#)Antcolony.java 1.0 03/05/22
*
4 [) p3 w2 s0 B2 D5 d * You can modify the template of this file in the
9 H, m" F, \" ?0 f8 c * directory ..\JCreator\Templates\Template_2\Project_Name.java
*
* You can also create your own project template by making a new
* a0 N& {" ]; D) b. t) L8 F * folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
*
0 I: Q! |1 C3 N+ ?4 Y */</P>
<>import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.util.Vector;</P>
$ \' T$ x4 X3 a  A8 q5 O<>class AntCanvas extends Canvas
6 X( s+ k/ f% {{
) w6 a, \( ?4 v# b' k    //画布，一切画图操作均由该类完成
//Image image;
( C# o- E9 W2 y6 q) l Color obs_color;//障碍物颜色
Color origin_color;//我的颜色
( {0 B' `; y9 a/ t Color back_color;//背景色
( u+ P+ q$ c, ~2 G2 Q# k: S! j5 `* ~        Color end_color;//食物点的颜色
) F- D2 m2 c$ x3 y# `1 p0 f //boolean first;
boolean reset;</P>
<>/* public AntCanvas(Image img) {</P>
<>  super();
: F1 H3 n# M5 Y# P   image = img;
  obs_color = Color.white;
  setBackground(Color.black);
  setForeground(Color.white);
  first = true;
0 U6 Q' y' h* ^  reset = false;</P>
! E% ?; K: r" ~- {' b% M<> }*/</P>
<> public AntCanvas() {</P>
<>  super();
; \( E& b9 s/ E6 V( a$ d$ l8 p- K  _   //image = null;
$ R& E+ l/ i; ^/ O3 G0 K  c   back_color=Antcolony.BACK_COLOR;
/ Z2 K( J7 b* d4 F7 L4 \  setBackground(back_color);
( }+ N* L  g/ D! }3 N: S9 F  setForeground(Color.white);
( }, |3 c2 g) x" t  obs_color = Antcolony.OBS_COLOR;
" j) |- k" d7 Z4 j  origin_color=Antcolony.ORIGIN_COLOR;
! R2 C! m( _5 P( E                end_color=Antcolony.End_COLOR;
  //first = true;
# y! W3 A! _+ {  reset = true;</P>
: V# _" J% s7 ^) W, x0 k5 I<> }</P>
<> public void Clear() {
        //清空画布
  reset = true;
  repaint();
}</P>
<>
public void paint(Graphics g) {
  int i;
                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
7 v/ m1 d) ?7 q# A0 X5 z  g.fillRect(0,0,size().width,size().height);
  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
<> }
! n8 V4 y' t; x5 g& I8 Q) A' L& ? public void process(){
        //处理动画的过程
  Graphics g=this.getGraphics();
: ~/ z8 {/ n# [; T                g.setColor(end_color);
0 l: l( r# E) u1 R9 M" B   for(int j=0;j&lt;Antcolony.EndPts;j++){
                  //画所有的食物点
                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
, p1 E! G+ @5 X0 ~6 C                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
                  //每只蚂蚁开始决策，并画蚂蚁
   Antcolony.ants.Process();
3 [. L/ D. @* ?1 o5 @   Antcolony.ants.Draw(g);
0 `  C- }+ q# S& v  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
$ Q: k: B# [( |0 f. i. w0 _                        //Antcolony的drawPhe变量标志是否画信息素
; l, ]6 ^5 Z6 B' {. V. t2 v                        switch(Antcolony.drawPhe){
0 K) F$ H. @; f' S# S                        case (1):
6 l9 ]& x4 Z- S1 O; O$ K                            v.Draw(g);
                            break;
                        case (2):
9 q, T7 q$ o; F' ?                            if(v.kind==1)v.Draw(g);
                            break;
- I$ E. G0 F4 ~4 P/ E                        case (3):
                            if(v.kind==0)v.Draw(g);
                            break;
                        }
                        v.delimit(g);
                }
           g.setColor(origin_color);
                for(int i=0;i&lt;Antcolony.OriginPts;i++){
& m& g) ]: j3 f5 U$ F* L! D                  //画所有的窝
: p/ f3 Y' M, `6 P                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
                }</P>
* g' x: h; W( |" a( |0 R1 b<> }
# B7 `) D$ ^9 x% Y! y$ P$ e! j Graphics GetGra() {</P>
; ^/ T, ]$ P  `! Y: K) |8 a# K<>  return this.getGraphics();
' v2 s  p( _4 {% g }
1 O, K. [3 H6 J: d2 v2 Z  L/ d}
' Z7 P3 B) E/ Tpublic class Antcolony extends Applet  implements Runnable  {
1 z4 u. z$ ~  S: w9 }0 O boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
/ A3 N5 X( t2 z. L static Color OBS_COLOR=Color.red;//障碍物的颜色
static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
. @6 |7 Q' W# R) W) o# R static Color BACK_COLOR=Color.black;//背景色
static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
6 n8 ]+ j- P: P+ u- Y4 K AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
& d& H3 v- s, n        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
0 k! N7 C6 D7 t% U7 w4 a static int obsCount;//障碍物的数量，最大为width*height
* Y7 x4 J9 H9 `. x, p- p static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
/ v$ f, g6 a! }+ T8 `        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
3 m. Y  x7 A- b" E5 O; r- Z$ l) h4 A        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
+ |7 G& ~: ]( p# ~        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
- K9 z0 e7 i* m3 v        static int OriginPts=1;//窝的个数，最大为100
' D" D- I! c- j: z static int width=300,height=300;//环境的长和宽
/ v: P7 d/ ~& q  s6 T) z static int antCount;//蚂蚁的数量
0 b) r  a1 \3 P" S: V( x. U        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
$ D& a2 E- J1 c5 @% P        static int FoodR=10;//食物和窝产生梯度的信息素的半径
static ant ants[];//蚂蚁数组
  o4 i, K' P2 q% Z$ x/ o        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
% Q' ~$ w9 l5 ]- a) @$ w( e+ A& R* E        Button btnReset=new Button("重来");
; O6 m  Z* b- q, t- Q8 }        Button btnMap=new Button("编辑地图");
. H: {+ H/ k( i. A1 `# g+ }4 ]        Button btnConfig=new Button("设置");
1 x4 o) Q7 \% X2 O# T& \2 p        Choice choPDraw=new Choice();
public void init() {
                //初始化函数，先画各种控件
! t; J4 j/ ]2 v8 c& i- z, o4 ~- n  setLayout(new BorderLayout());
6 I+ |' o6 l0 D7 n3 n5 r                Panel pan=new Panel();
/ V# Q, N: @: d& N& e9 A                add("South",pan);
% @; ]9 Y% b: P/ Y6 ^0 V                this.add("Center",canvas);
2 J3 L2 q  O# S8 v3 `                pan.add(btnStart);
/ A2 Y& |" o1 `/ j) k$ I                pan.add(btnReset);
. z( M3 B" b4 }8 F$ }; P* |; K0 z                pan.add(btnConfig);
                pan.add(btnMap);
) W& z8 ?1 k! j+ p                pan.add(choPDraw);
/ i( C1 k$ Q8 X: ^7 o. Z! q                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
' U. a6 b* \& g0 \) t                choPDraw.addItem("画窝的信息素");
                choPDraw.select(2);</P>
. b. d# ^  k; u% X1 u<>                //初始化各个数组
; H5 D# N; i9 c8 }& [: j  obs_grid=new int [width][height];
                phe=new Vector();
                Pheromone_grid=new int [2][width][height];
                for(int i=0;i&lt;width;i++){
  M( o" F% k; m  d- B# I; y. r1 `) p   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
/ ?. w% X9 `* Z. w! ^                                  Pheromone_grid[k][j]=0;
                                }
   }
5 @- [% _1 \" |1 ~  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
% A! a" w4 {& d/ n3 \                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
. {+ t- @/ P  f  ants=new ant[antCount];
" @$ f* C0 N2 U! s# o4 }% N        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函数统一处理
- v: V1 B: a# ~. h& R% X! o! T3 X                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
                Maps maps=new Maps();
2 w5 O6 ?; C" J! d5 h                maps.LoadMap(grid,0);
" z8 B9 C( C" R' y8 I; J  j                //初始化地图
+ A0 J" Q3 ^( ~% t) i                reinit_map(grid);</P>
" V8 Z. _6 X, }7 t8 V% b( m2 K0 t<>                //初始化所有的蚂蚁
  reinit();
& K# w, H5 G6 H }
& q6 K3 @4 j. B% |. N5 C6 Q        public void reinit_map(int grid[][]){
1 J7 |: B/ z! k, U5 q. C                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
5 c. G/ ^# k0 p# `! C4 ~                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
<>                //先停止程序的运行
* E! m' S% m# M: M" |5 W                running=false;
( @, S/ }. a9 U; U9 P                btnStart.setLabel("开始");</P>
* m  ~$ e1 p' {* Z; r: S<>
7 j% M* i! G  }7 |6 P: y                obsCount=0;
                EndPts=0;
                OriginPts=0;
                obsP=new Point[width*height];
                OriginPt=new Point[100];
                EndPt=new Point[100];</P>
<>                //清空obs_grid和Pheromone两个数组中的值
  @; F$ T6 K% S4 F/ T                for(int i=0;i&lt;width;i++){
! ^% n$ N* y0 I9 Y2 Q   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
0 T$ ?( T7 K& J                                for(int k=0;k&lt;2;k++){
1 z- @" `4 x! p) V# a; G$ t                                  Pheromone_grid[k][j]=0;
                                }
   }
  }</P>
3 L* E7 E' ]3 Y" N<>                //从grid数组中读取信息
* y. ^6 F5 u( P- O                for(int i=0;i&lt;width;i++){
) R! M2 @! [9 ^+ L# }) _' D( z                  for(int j=0;j&lt;height;j++){
; p* v/ B/ l" h& \- W. _                    switch (grid[j]){
; ~7 y7 P  l2 S$ g6 |                    case 1:
( ~$ y# w( }5 K3 N; M' [                      //如果grid[][]存的是障碍物
                      obs_grid[j]=obsCount;
4 R- h, Q( u- @; z                      obsP[obsCount]=new Point(i,j);
                      obsCount++;
( o. \8 `' [8 L3 B  \                      break;
                    case 2:
: F1 R0 [# U0 `  [5 i! `+ L                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
1 \' I( E6 o+ {% D9 i3 j                          OriginPt[OriginPts]=new Point(i,j);
$ J; f0 @3 F4 p6 g& ?$ Y                          OriginPts++;
8 a: D9 U5 ]6 @2 T; `  }; K                      }
& F- ^2 Y6 U% L; h                      break;
* D0 L: y: @9 l                    case 3:
                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
6 U6 h; ?% I5 L3 P  S6 j. x" U                      if(EndPts&lt;100){
8 f. d! X6 p+ O4 u1 j                          EndPt[EndPts]=new Point(i,j);
) G2 P0 T3 s7 A" ^                          EndPts++;
                      }
                      break;
  l8 h# y( z( i+ @# H/ u1 a                    }
1 p% y" T  w4 K6 v                  }
! t7 k& u+ b, u                }
/ o  @5 ~  Q/ P            //如果没有指定窝，则随机的选择一点
& b) y+ \: `0 b' {/ L            if(OriginPts==0){
; [$ W2 S; N) B7 A5 ]              for(int i=0;i&lt;width;i++){
                int  j;
                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
8 ~2 _: ^! f- M# q                    OriginPt[OriginPts]=new Point(i,j);
- B7 e- A/ x' Y$ V/ M# V: X                    OriginPts++;
0 K$ Y& H9 a3 R8 _7 |8 W) m: e; c                    break;
                  }
                }
                if(j&lt;height-1){
9 }- w8 V3 G, [' k8 w. N' C                  break;
                }
              }
            }
        }
public void reinit(){
                //重新初始化整个环境</P>
<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
0 r3 L: W4 M- h3 _<>
& e( c: I5 I- u! q0 x- W/ b, M  //清空所有信息素Pheromone数组中的值
: E2 n& `: F* m3 H6 _% s                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
                                for(int k=0;k&lt;2;k++){
8 ^9 H: j7 p  l; m/ \                                  Pheromone_grid[k][j]=0;
! n; e5 d: q( @: J; x9 p1 N3 r                                }
- ?2 Z  A8 i; r4 l/ P- M   }
! j+ E9 K% J' b% q/ ]* u8 M8 v. h  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
) n$ B+ q4 o5 a; ~# S        for(int i=0;i&lt;antCount;i++){
8 Y1 d% {/ w8 G                        int index=(int)(OriginPts*Math.random());
4 {) O7 y; a, v! u          ants.OriginPt=new Point(OriginPt[index]);
                        ants.init();
  }</P>
. V( R. @% f! s5 Y. T( ~, G2 d<>                //清空信息素向量
                phe.removeAllElements();</P>
7 z  z( Y4 E& J/ L; [<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
3 Y. m' w$ K9 |" @+ R" ?  for(int i=0;i&lt;EndPts;i++){
$ r2 o$ @/ h* Z% [2 H                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
: C8 _" l* _! u! @% ~1 U+ @% J                        for(int yy=-y;yy&lt;=y;yy++){
( k+ `& L* z! J" H7 P/ j                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
                    }
( z6 j) z. H. o$ F% J                }
) R7 W. t6 i) z3 b8 h' X' |6 E9 J                for(int i=0;i&lt;OriginPts;i++){
+ J% q5 n( D0 m7 p                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
! @3 y+ Q9 `5 C9 h& u                        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));
                        }
+ i" @$ p. a8 |/ J" N8 K* i                    }
                }</P>
8 X6 o/ L' K' }<P>                //重画
  canvas.repaint();</P>
<P>                //让程序开始运行
1 U& f% P" b" [1 i, }& }                //running=true;
}
" Y4 z7 G0 N- S4 F public void paint(Graphics g) {
  canvas.repaint();
7 t' ~# T/ Y7 r& S }</P>
<P>
# y4 v& Q6 E, j$ Zpublic static void main(String[] args) {
0 ~$ m6 N  W7 R5 x9 ]* d# T  x    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
" T; _7 H& W' b    Frame frame;
    frame = new Frame() {
5 S0 g# ^) G) r  t      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
: t  G" u! g9 e7 B        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
          System.exit(0);
+ a2 ^# i+ \$ F( p        }
      }
1 e5 @( `/ S6 k2 }* |0 F7 x      public synchronized void setTitle(String title) {
* o9 i8 h) \, J+ T. p        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
    };
! |* M( n; q1 c$ W. C    frame.setTitle("Applet Frame");
    frame.add(applet, BorderLayout.CENTER);
/ h2 A. t# |& K& X    applet.init();
    applet.start();
/ ]& x- t/ q4 o. m. u% n, C    frame.setSize(300,320);
! o9 A# n6 @& i& ^, E4 i2 C, z    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
( |1 \# P9 Q; f+ T% J    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
* b$ ^" k9 w9 N4 h  b6 E% ^    frame.setVisible(true);
8 w- g/ S, a2 h  f- K$ r7 L  }
  public void start()
  //下面三个函数是控制线程的
{
  if (runner == null)
  {
7 q, @" I8 Y9 t2 z: [) ^   runner= new Thread(this);
   runner.start();
   //running = true;
  }
}</P>
8 j- Z' p) L3 y* S<P> public void stop()
1 O% c& s3 r& G+ D2 p3 x {
: X) N; @' O" T  if (runner!=null)
  {
   runner.stop();
2 H! Q9 B' n# F- ~  _( h   runner=null;
   running = false;
  }
3 m6 X# X% q) J  Q }</P>
* R7 I- |- K$ c: d5 X<P> public void run() {</P>
+ T  ^9 _& M5 ^8 P<P>  int i;
                //线程一直运行下去
/ t3 N0 W! q6 l. n& R: e  while (true) {
          if(running){
       //如果开始动画，就进行canvas的处理
1 Y: s7 r) J1 m, m                          canvas.process();
- d9 T4 U3 U! |$ {                        }
    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
   }
  }</P>
& p& p( A3 ^2 q4 o- u% B( c3 s<P> }
        public boolean action(Event evt, Object o) {
3 u/ |3 [2 u2 D: N5 C      if (evt.target == btnMap) {
/ c8 m) v) H/ O" X+ j; }5 j                //开始编辑地图面板
) o! a/ a& f4 T# m6 i   running=false;
                        btnStart.setLabel("开始");
+ U. }' p9 s+ Y6 |+ w   MapPad ctl = new MapPad(this);
  u+ C7 d( X3 e% Y2 P4 [, Y" v. \                 ctl.setSize(308,380);
                        ctl.show();
                        return true;
  }else if(evt.target == btnStart){
                  if(!running){
. l  m1 B$ G& z2 e  ?1 S6 [* G                    //如果刚刚按下了重置按钮就重新初始化一下
$ {. n3 X. t% f1 p+ N; L& b, L                    if(reset)reinit();
) r+ s2 s# a) Q2 o                    btnStart.setLabel("停止");
  n1 s6 K8 v3 x, `# t, `                    reset=false;
                    running=true;
. s2 R$ @0 m+ _: B2 z7 m                  }else{
3 C# _/ J# H  ~                    btnStart.setLabel("开始");
' }0 j/ V6 }% H' d; V                    running=false;
7 @% l% Y6 N1 x                  }
                  return true;
                }else if(evt.target == btnReset){
                  running=false;
: C" e: A$ G% s5 E" \! x+ O/ D                  int j=0;
                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
( N4 b; M( f3 O1 S" q  z                  reset=true;
: {$ W6 b$ W& v2 x8 Q6 Z: x                  repaint();
+ V# D4 S1 e, j6 z                  btnStart.setLabel("开始");
# o) X9 ?+ H) L8 B                  return true;
                }else if(evt.target == btnConfig){
                        running=false;
% U! w2 N5 x" r# V                        btnStart.setLabel("开始");
9 o# t# G' ~! V8 l2 Y) T     Configer ctl = new Configer(this);
: U1 Y* D$ m# {) o7 e                 ctl.setSize(300,300);
4 I! u: @5 ^* [1 h" _3 ?' ?1 d+ S% T; P                        ctl.show();
                        return true;
# ?# K0 y& W& g: z& D                }else if(evt.target == choPDraw){
                  //选择画信息素的模式
/ A  q' X' i; G, e/ _6 f                  drawPhe=choPDraw.getSelectedIndex();
: C1 S2 s! g* N+ M                  if(drawPhe!=1){canvas.repaint();}
                  return true;
                }
                return false;</P>
<P>        }
/**Destroy the applet*/
  public void destroy() {
" h4 s& h4 s& }- x' a( u  //当结束程序的时候，把线程也结束
' [# b6 u% Y$ i0 R$ ]' ~    if (runner!=null)
( C7 Q  F' T  t, K    {
8 S9 Z! ~6 _* U: l3 i! Z       running = false;
       runner.stop();
       runner=null;
7 `+ O1 f8 E5 f% A: W/ x( L+ s( Z" }    }
$ X# [. _  V8 K/ k5 t; N7 J  }</P>
- x3 t7 s. z5 d" I- v<P>}
</P>

& R: m5 A4 b- ?# {
# Z6 n# x( Z( b$ T7 P2 Z6 Q
<P>package ant;
import java.awt.*;
' c( D! M. M& D$ ^6 j1 limport java.applet.*;
import java.util.Vector;</P>
& W4 T) R) ^# e$ p7 U<P>public class ant{
Point nowPt;//当前点坐标
int VR;//速度，每次蚂蚁能走动的最大长度
  int id;//标识
' b! h( k. N, l, D0 l" G; F9 ^% q  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
3 ]( ]" R9 x4 G int height,width;//世界的尺寸
2 l, b  [6 n* s9 x8 C! l* U        int Phe;//每次释放信息素的数值
2 z# k; h' D$ p9 y$ b. J4 l( i- J Antcolony local_colony;//主程序的指针
        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
" @( m( ^3 I- N# k& ?; _' i. f0 i" s        double Main_direct;//主方向
        Point FoodPt;//记录的食物点，是否找到时候判断用
. H9 F& z; J9 p/ j* M& m( G- |2 R6 l        Point OriginPt;//窝的坐标
9 g; _7 C" N3 @9 V        Point AimPt;//目标点，是窝或者食物
) s6 @7 ^. `& x/ R4 |* K( J0 S( c. h& _3 i        Point StartPt;//起始点，是窝或者食物
8 X; \3 \1 G: r8 J- B% W. m8 ^        int FoundTimes;//找到食物或者窝的次数
1 Z' f1 n$ t6 [: c2 S* }        int Max_Pheromone;//最大能够释放的信息素
        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
8 g" T! J- f1 p- H        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
8 g9 }  F, ?0 ^. _+ R) O. d1 H( I  nowPt=new Point(nowpt.x,nowpt.y);
3 e/ S5 w$ s% y; S$ m+ k. P, n                OriginPt=new Point(nowpt.x,nowpt.y);
/ a- ~' k+ Y  M$ u- h: e: _                FoodPt=new Point(nowpt.x,nowpt.y);
2 ?2 ?0 @2 v/ A8 o& O( ~                StartPt=new Point(nowpt);
' W* \* p5 _' k! p8 y$ ~2 D                AimPt=new Point(nowpt);
                lastPt=nowPt;
# v4 c' n9 |# j, \5 g& U  VR=vr;
  id=idd;
+ }% y' {) T" f3 r7 S: x, ^& V  color=c;
  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
  width=Antcolony.width;
  local_colony=colony;
8 u6 e4 n& H; C* q                Phe=200;
, C! l' V' F2 i: I                mistake=mist;
0 a% a5 {* x' i1 f0 B                HistoryPoint=new Vector();
8 P$ Q: O( T2 n9 R7 x# c: U1 u                Main_direct=-1;
                FoundTimes=0;
                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
' K0 M$ k$ G+ N, S6 J+ ?  r. P) T                memory=mem;
                Count_distance=0;
                Min_distance=-1;
# ?4 _! i# p8 U; w7 u }
        public void init(){
% k2 f+ X) a9 _& ~0 z, W/ u          nowPt=new Point(OriginPt);
( b$ f! P, @+ R/ w          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
          AimPt=new Point(OriginPt);
4 P$ G2 w1 F4 Y9 o/ n          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
          Main_direct=-1;
          FoundTimes=0;
0 I" l0 J. ]% y          Pheromone_count=Max_Pheromone;
          Count_distance=0;
          Min_distance=-1;
/ T. M9 _2 S8 J- G( Y' Q+ r        }
8 q5 a9 X7 |* T# h( z4 H public void Draw(Graphics g) {
( U) A- u6 _% f7 {! K6 {# R          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
; g6 u3 y% s  I! p  g.setColor(back_color);
/ g+ s4 {( e: u$ M2 |  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
  g.setColor(color);
5 s/ H- C4 D$ u& J$ k5 \) U  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
}
: D4 D6 o1 u: ~; t8 I: e1 A public void Process(){
        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
/ h, Z$ [) \2 F) G0 W& i        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
" x' Y1 X7 T: Z" Q" {% j$ r        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
, T; q( r! ]8 D4 E0 @        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

<P>        if(Judged==false){
          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
) V% E7 k: n' k% m* M4 A7 b" h9 N          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
: ?. g. }: M5 k; k          if(JudgeEnd()){
" }% }7 x1 ~( W! }% a/ T3 s              //判断，如果找到了目标点那么就退出该程序
! \: e- S  J2 i+ n. D2 G              Judged=true;
              return;
4 d: ^8 U; H" ^8 Q          }
        }
        Judged=false;
3 z/ m( f7 Q! s        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
1 _# W7 `3 O1 H. L/ x( }        int deltx=0,delty=0;
, q# e+ @& }2 C4 b$ w1 e2 ?- N        //direct是方向角，根据方向计算位移
        deltx=(int)(VR*Math.cos(direct));
        delty=(int)(VR*Math.sin(direct));</P>
/ h: w+ I$ `. F: c7 J$ C5 A<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
. J5 F- `8 [' H" k+ C        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
/ t( q! k' @# y& i<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
          int deltx1,delty1;
+ ~+ m0 f- W9 i' \: A          deltx1=deltx;delty1=delty;</P>
  n/ g0 v$ C5 L0 u4 p<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
          for(int x=-VR;x&lt;=VR;x++){
" Z# M8 V. K  _# V; K0 O' q             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
/ N  l) ~  n" S" _2 K# B  k% E                //在这个程序中，坐标是循环的，也就是在一个球面上
- o0 Z' G2 O0 f& p                int xx=(nowPt.x+x+width)%width;
: h) [" {5 e' S7 V4 ^$ D, u                int yy=(nowPt.y+y+height)%height;</P>
) s% n" C/ w: [1 s<P>                //循环的时候要除去当前点。
& G2 E, W" i1 k3 n. ^( R                if(x!=0||y!=0){
                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
8 L% Q4 D: @6 b' I& L<P>                  //如果搜索点的信息素比已经找到过的信息素多
: |2 B( v% t( n* O5 x2 R8 n                  if(maxphe&lt;phe){</P>
' U1 F( h; A) r2 N( g, R8 J8 _<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
# n# c9 j( x! B- `, d; ~                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
! x  M2 ]) d# H6 d* Q1 ?                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
& A# A' R4 L6 Z. ?& V                          boolean found=false;
                          //查一下内存最近走过的memory的点数，从而避免当地转圈
+ g) e" k' f5 [5 a+ c                          int size=HistoryPoint.size();
                          int minsize=memory;
                          if(size&lt;memory)minsize=size;
4 g$ ^9 ?7 a$ U. `! u! y                          for(int i=size-1;i&gt;=size-minsize;i--){
                             Point pt=(Point)(HistoryPoint.elementAt(i));
8 k2 h- Q# \1 r$ O$ f$ M( }& ]6 e                             if(pt.x==xx&amp;&amp;pt.y==yy){
                                found=true;
/ m# n2 l' r' i; d                                break;
, [0 I! F$ T% E6 W$ o6 q# I7 T* Y                             }
                          }
                          if(!found){
, m5 N# V& G9 ^- e( p- J- q3 F; g# q                            //如果没有原地转圈，那么记录信息素。
2 D( l+ x- P- Q! O6 G; X                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
                            delty=y;
                          }
. g1 g3 |( z; H6 D. P! U9 ]                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
                }//end if x!=0
8 a! _2 o# S5 t3 X            }//end for y
/ y8 S4 b2 W' k2 w: F: W        }//end for x
6 {+ `: J) }% C        Point pt;</P>
& f* V; n  c6 ], j<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
) U, D& A5 a% b$ j: W+ S% Z        pt=Evade_obs(deltx,delty);</P>
+ T! R) V" U9 Z- g- m: q<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
( O1 Q! W3 y1 u2 t        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
- e% f% t+ C( c* x6 d: `          pt=Evade_obs(deltx1,delty1);
        }</P>
<P>        //播撒信息素
( ^  L0 N/ ]$ |        Scatter();</P>
<P>        //记录走过的距离
; N: h+ J1 x( w        Count_distance+=Distance(lastPt,nowPt);</P>
! X, l7 s, j6 A3 b) \<P>        //改变当前点位置
        lastPt=new Point(nowPt.x,nowPt.y);</P>
<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
3 b  P2 w1 B' k2 x        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
" _- y3 M; I' R$ \, h* A        if(HistoryPoint.size()&gt;memory){
          HistoryPoint.removeElementAt(0);
        }
/ c' F# t/ S- h6 t        nowPt=new Point(pt.x,pt.y);
7 c+ l% l9 k; x. p5 x0 Y, k     }</P>
<P>
        private void Scatter(){
        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
! R% g/ \6 V. c( e2 D9 D        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
            if(Pheromone_count&lt;=0)return;
3 S/ r7 S' {5 M0 R            //决定释放信息素的种类
            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
            boolean ofound=false;
            if(Phec!=0){
% U/ Z5 v1 o# v                //如果当前点已经有信息素了
                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){
0 G- B  v! V2 R                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
                        int size=HistoryPoint.size();</P>
3 W: l1 u6 |- d; f<P>                        //如果在表中找到信息素，则用ofound记录。
                        ofound=true;
                        boolean found=false;
                        if(size&gt;4){
% \  L' u+ f$ S7 t7 t                           for(int j=size-4;j&lt;size-1;j++){
% ?: X! ^/ I8 E7 a5 Y                              Point pt=(Point)(HistoryPoint.elementAt(j));
                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
                                //如果当前点重复了以前走过的路，就不释放
' k2 u. \+ o" s( O/ b                                found=true;
                                break;
0 k4 U% ^7 J. q! p6 ~) h                              }
- A' U! W# n5 v                            }
* Y4 U' {( Z  s7 h/ p                        }
) I7 M/ j' [  f8 g8 p4 J# W) i                        if(!found){
  _3 F2 ]. l% ~( Y5 N' m9 h. l                        //如果当前点不重复，则开始撒
! L  R3 d9 m8 w# ]4 E6 `/ ]                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
% D5 b5 A; s( c<P>                             //让还剩下的信息素总量减少
( R! ^: ?$ t5 c1 o) G0 [+ W                             Pheromone_count-=Phe;
                        }
                        break;
$ d6 {% K) \6 U6 }- w0 G2 C/ K                    }
                }
              }
8 h6 ?" Z% D$ ]; d8 I          if(Phec==0||!ofound){
            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
                ph.Add(Phe);
+ P1 {. p& @. W4 @% w                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
" P0 Q: _' V9 p/ t7 V% w                local_colony.phe.addElement(ph);
* a# r" l$ G) z& P                //让还剩下的信息素总量减少
  J$ t- S' f5 g! }0 X                 Pheromone_count-=Phe;
           }</P>
% b# \$ X/ s$ {- N" C<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
9 ]. a& k6 }! ^/ s           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
; c  k* Y0 F- H1 p- n2 V# m           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
# A) E& R, T0 b7 A' k, c           //这个模型是否科学？有待研究
! I5 v0 o& Y0 I! |4 l) R           Phe=(int)(0.005*Pheromone_count);</P>
* R0 H- x" l( a<P>           //如果剩余信息素已经太小了，则按照等差数列递减
# L) ?6 ]# L6 Y( }! f/ F           if(Phe&lt;=10)Phe=10;
        }
& A# X$ S( N' h' _private boolean JudgeEnd(){
    //这个函数判断是否已经找到了目标点
    //首先获得当前蚂蚁是正在找窝还是在找食物。
9 m( D* |+ K4 D& q; C: @# d    int kind=FoundTimes%2;
# Y" s/ x5 A' ^# [7 u+ U    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
        int i;
        for(i=0;i&lt;local_colony.EndPts;i++){
3 C: v- w) F: s" B& P            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
6 j; {- _3 h: O! E7 J8 B0 Y6 k9 i2 Q              //如果找到了食物，就直接移动到食物点
3 W7 F' T% O7 N              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
7 F# K# ~6 t6 Y( {              nowPt.y=local_colony.EndPt.y;</P>
<P>              //计算最后的总距离
6 y% [& a+ q9 ~& ]              Count_distance+=Distance(lastPt,nowPt);
* k9 {, v, B! x- k              //比较大小，记录较小的距离
& X) B# [1 d- }              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
. T# s' o8 ]" S3 |7 p3 K* u, n, ~% D                 Min_distance=Count_distance;
) R* K, x  Z4 o9 q              }
8 T3 j2 i2 \/ M; S0 k              //清除总距离记录
- T- e/ X2 x3 x  b+ o: S0 p; y3 i' S              Count_distance=0;</P>
7 J1 w' Y7 F# U1 F: h! f<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
              AimPt=new Point(OriginPt);
              StartPt=new Point(nowPt);
              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
<P>              //找到了食物就把找到次数+1
              FoundTimes++;</P>
. x! |3 N6 w7 r+ x$ a6 l2 A<P>              //改变主方向为原来方向的镜面反方向
+ W+ k% q3 e! S! l: a# X              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
7 I) e8 B/ {8 O0 [6 @# l( W, M# A<P>              //重新把自己能撒的信息素置为最大值
9 p3 t8 i, Z% s' n' E$ [, Z8 ^  D              Pheromone_count=Max_Pheromone;</P>
* [/ C7 @  ]& x. w* b5 |7 J<P>              //清空记录的所有点
& `. m' h+ \& o. b              HistoryPoint.removeAllElements();</P>
6 @8 D+ L, C* Z# H9 p$ @<P>              //返回找到为真
6 |) I, N* T( [" E" {              return true;
            }
( s2 u  L3 z! `3 V; O9 }! |        }
! z! s3 P' G, f$ g      //否则没找到
4 i; w/ t2 C* B! N& a# l! b& o4 n7 }1 l      return false;
' M' r$ R+ r3 F1 E8 F( E    }
3 I4 U4 g" T: Q5 S! ~- k9 g    if(kind==1){
9 h# Y# y! ?0 L' X4 c2 X+ D' x& G        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
( f* b- a& r% a6 V$ _        if(Distance(nowPt,AimPt)&lt;=VR){
            lastPt=new Point(nowPt.x,nowPt.y);
            //如果找到了目标，就直接移动到目标点
! E6 u, ^( f* x8 J% s: [' X            nowPt.x=AimPt.x;
: T3 a. H. c  H0 d4 Q            nowPt.y=AimPt.y;</P>
1 l+ e/ F( ]) U7 b- b. v- W<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
  _# {4 u! }7 Y) x2 F% ?1 f( V              }
) L2 l1 i% C' @( i% I$ q- f* }0 J1 \% f              //清除总距离记录
; Y! p9 B) B( g; a  B0 ?              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
            StartPt=new Point(OriginPt);</P>
) `( Q5 x! }0 n. V( }$ a3 a<P>            //重新置信息素
            Pheromone_count=Max_Pheromone;</P>
( a+ y' a* D) @/ B<P>            //清空历史纪录
0 |# ~  M& L. J: T6 k            HistoryPoint.removeAllElements();</P>
<P>            //主方向反向
" k0 c4 T* p9 n            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
# `. W2 r4 g' p+ k, x            FoundTimes++;
            return true;
* z% g3 S1 D& F* w; x7 j8 T        }
        return false;
& S- f9 ~! w' _3 @  [$ Q' V    }
    return false;
5 J7 ~- O8 Y0 S) I# a5 }}
/ i! V! `) ~6 S& o3 H        private double SelectDirect(){
0 P/ D- B' m' z                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
1 d( }8 U* v- \! N4 D2 q                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
/ F6 _! y8 T: f; e" H3 x$ p        e=2*Math.PI*Math.random();
- P$ x: @0 M' r. A& }) h5 P* r                      Main_direct=e;
                }
                //选择主方向角
9 H6 A2 K. v4 G2 o. C% c, E" W                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
( L2 w: L5 W3 s1 a                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
                double re1=Math.random();
$ H6 Y, k- ~  }3 z5 R$ S' U+ k$ |. C                direct+=Math.PI*(re*re-re1*re1)/2;
  V7 _( |* u/ Y8 ?/ v- H                if(re&lt;0.02){
                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
6 W0 s- J- O6 e8 v                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
0 z3 _0 l" F) \* r                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
2 h, e+ z9 G6 e1 V( }* E; m                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
! s# k# d. a2 Y" H' W6 @- w                       Main_direct=GetDirection(pt,nowPt);
7 u, {1 t; e+ f; E                    }
  Y! N$ O# H& V5 h2 [& v; Q                  }
+ x9 O, d) O0 S. B5 a, ^$ i. n                }
9 q% _, q6 ?& @) b9 x- H               return direct;</P>
<P>        }
        private Point Evade_obs(int deltx,int delty){
' V/ z( n1 @% ]              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
: [- f' p0 T" W8 p0 v- h+ ?; r              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
4 J: B' |. H2 ~5 c/ N- |              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
4 o3 J, }. G1 G. R              //p1,p2在这里分别是nowPt和nowPt+delt
) Q/ u: x7 k6 j$ Y6 ?  ?              Point pt=new Point(0,0);
% z% y- n' |' Q! C0 C              int x,y;
              int delt=deltx;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
3 v1 H  }8 W* r1 ?: @6 y$ y6 C/ 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);
; I  P( [. y' R                  x=(x+width)%width;
7 ~: @3 S/ c+ f- P. X                  y=(y+height)%height;
7 Q" f! T# Q3 E9 {                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
( p% G0 F5 ], X4 e<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
. n9 t8 x2 f, @+ Y* I                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
. b+ x$ w: y6 L3 T; m; ~$ t0 A                     double disturb=4*Math.PI*(Math.random()-0.5);
. s9 m3 d5 }" g6 Z6 E; r                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
& i. \1 R6 f$ ?                     break;
! Z0 e3 u# O; D& K( F/ B                  }
, m- `+ K: ^, m- D0 @                  pt=new Point(x,y);
9 m6 W( B( R5 U4 D4 D! v6 V6 D7 C- G* _                }</P>
<P>                //计算得出实际能够到达的目标点
  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
1 X( [8 W. v/ S, b7 t  g         return new Point(x,y);
$ {8 H9 m& a0 f& q7 y: B% e! v        }
1 j, i) s) |* C6 _        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
1 W5 C4 L5 l( r- o7 q$ j$ O( a        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
; F& o8 o5 O  l        //其中方向角是所有可能的角中使得两点连线距离最短的角。
               double e;
               int deltx1=pt2.x-pt1.x;
               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
5 X  O1 o, ]2 h) T               else deltx2=pt2.x+width-pt1.x;
& A, z# n1 q/ d; E               int delty1=pt2.y-pt1.y;
/ O* {! }0 z" r1 r8 p# d; t" a               int delty2;
9 V4 l8 O* A, n! r, W7 P               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
9 W5 R0 H7 z# A3 t9 f               else delty2=pt2.y+height-pt1.y;
' {& T" K. s9 z! [' P               int deltx=deltx1,delty=delty1;
1 h- m- ^& s4 D$ E6 f( U& O               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
* }3 Y) k7 v1 b# Y$ B8 B/ w    deltx=deltx2;
               }
0 k. U& \% t" I( O, N        if(Math.abs(delty2)&lt;Math.abs(delty1)){
# a- Q# F: t: Q8 n* Q; `8 R( d8 Z                  delty=delty2;
( Q+ Z5 c. T* v               }
2 {, w# F, W6 }: T. ?               if(deltx!=0){
                    e=Math.atan((double)(delty)/(double)(deltx));
                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
                       else e=e+Math.PI;
                    }
5 z8 K7 A7 }& q$ M9 v$ J; P" [                }else{
                    if(delty&gt;0)e=Math.PI/2;
% E) f4 A, |4 a2 b% k: x  x* v) N! v                    else e=-Math.PI/2;
& F3 U$ F$ D* n3 ~, g5 e                }
" y7 h" ^) I  U0 Y* Y# S) s                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
  H8 ]9 g. Z- h/ i        }
$ e8 u, N+ g; j+ q; f, ?1 U        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
# Y$ r3 q) D: n' F) S$ ~2 x/ A0 G7 y            int dx1=pt1.x-pt2.x;
            int dx2;
) P. K0 d# ]9 ]) H* r' O- _3 j6 v            int dx,dy;
. D* u$ ~! m( A% V/ I5 [            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
( k( m( Q/ U! p! P+ |: w- X! l; H            else dx2=pt2.x+width-pt1.x;
            int dy1=pt1.y-pt2.y;
            int dy2;
  ?# r  J" E8 G% Q' ?8 P            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
# L  k' [* m8 [  m7 o9 F, W            dy2=pt2.y+height-pt1.y;
5 ^& H/ z% i$ f6 n            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
" h8 J, t- g9 A. H$ E& |            else dx=dx2;
# ]' v$ O5 [8 a            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
            else dy=dy2;
6 s" J4 O4 L- c" O$ c7 C            return Math.sqrt(dx*dx+dy*dy);
& v/ c, C6 [6 F1 J( n/ }5 o: j        }
# l. A% {6 E2 Z6 d8 X3 e0 S    public void clone(ant ant1){
' k9 V" Z" z' v2 l        //把蚂蚁ant1的属性拷贝到本蚂蚁
     nowPt=new Point(ant1.nowPt);
        OriginPt=new Point(ant1.OriginPt);
' @6 e& J0 s; ?/ d7 |+ ]& G; S        FoodPt=new Point(ant1.FoodPt);
+ v$ f8 P8 g3 o6 x. o2 Y- Y' R        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
9 q% K9 u8 E; n! R) N. Z" o        lastPt=new Point(ant1.lastPt);
" ^5 T$ z7 Z( q$ |; H8 O. g; [% J        VR=ant1.VR;
        id=ant1.id;
        color=ant1.color;
4 |$ @( I+ A; i/ h+ M        back_color=ant1.back_color;
        height=ant1.height;
        width=ant1.width;
        local_colony=ant1.local_colony;
4 m( Z! B/ O$ i* T" P# j! \8 }4 b        Phe=ant1.Phe;
0 ?) a( I/ R  a  q% H) }        mistake=ant1.mistake;
8 Q5 l2 X+ a) Z        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
        memory=ant1.memory;
        Count_distance=ant1.Count_distance;
        Min_distance=ant1.Min_distance;
+ {5 E& Q  L: A3 Y9 g# U    }
}</P>