[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
<>package ant;
9 m/ c& z+ W8 i/ D/*
* @(#)Antcolony.java 1.0 03/05/22
; {0 d. v% b! s/ k* ]: k, w  r *
- M8 h: H2 B1 y" K * You can modify the template of this file in the
0 y2 e) Q% c4 Q. D * directory ..\JCreator\Templates\Template_2\Project_Name.java
- `* c! d1 y* q( C  \6 } *
' }5 T' D+ [& w  b3 k; K * You can also create your own project template by making a new
  M+ n; }0 S6 f1 m$ t * folder in the directory ..\JCreator\Template\. Use the other
9 p' q2 q5 i5 s5 ^$ e, e( i * templates as examples.
*
*/</P>
; L5 \+ T5 b: F, N+ P3 a# O<>import java.awt.*;
4 q; i% B4 @# w% @/ Jimport java.applet.*;
import java.awt.event.*;
import java.util.Vector;</P>
<>class AntCanvas extends Canvas
# ?' u# [9 F% K: @. j* i{
    //画布，一切画图操作均由该类完成
//Image image;
, E8 [+ `* ]$ i$ f" Q9 M Color obs_color;//障碍物颜色
4 Q% r4 D8 j% I+ e Color origin_color;//我的颜色
Color back_color;//背景色
        Color end_color;//食物点的颜色
//boolean first;
boolean reset;</P>
4 A0 j" S5 o6 Z4 _9 I<>/* public AntCanvas(Image img) {</P>
5 x8 t, U- w- J& J. H<>  super();
$ E4 z* U( _2 G   image = img;
: h% Q( D/ W8 B* \% V- E& x5 |; O  obs_color = Color.white;
  setBackground(Color.black);
  setForeground(Color.white);
7 E) n5 b4 g$ d3 e6 Q  first = true;
  reset = false;</P>
6 u0 g( f7 e: ?<> }*/</P>
<> public AntCanvas() {</P>
/ L- I3 g3 N. ~( `<>  super();
   //image = null;
* |. e& i8 i' a6 m5 e   back_color=Antcolony.BACK_COLOR;
  setBackground(back_color);
  setForeground(Color.white);
0 u. o7 l( N0 a! U# S% M% W  obs_color = Antcolony.OBS_COLOR;
  origin_color=Antcolony.ORIGIN_COLOR;
/ g4 r/ U( ^7 Y- M% P/ d                end_color=Antcolony.End_COLOR;
# N3 _3 {7 C. G/ M! C! b) g1 H  //first = true;
! N8 H# A( _. W5 P  reset = true;</P>
: e/ O3 n9 C5 |2 K2 U& q<> }</P>
* n# x( Z# `# S" w: F<> public void Clear() {
        //清空画布
; {0 i; T* ]7 O  c  reset = true;
) ?' T2 P/ E  x# B; g. f$ b- Y+ N( }  repaint();
: Y! X2 n" E3 g# [* Y7 d1 Q8 k }</P>
: {6 G' D! s  F<>
1 B) ?( I  \! ]" p) Y public void paint(Graphics g) {
1 g& [/ V. W$ Z& z8 A# P  int i;
                //重画的时候仅仅画障碍物
. E2 j4 \( k& B+ t! Q. O  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
* Z! c8 {6 Z3 o1 K; K) x  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
+ E0 D0 |% R) |   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
7 a% P4 `- [; K8 S3 U9 b<> }
public void process(){
0 t& u8 s5 Y* O- B, }) z4 @0 z6 E3 i        //处理动画的过程
  Graphics g=this.getGraphics();
! V6 h4 U7 t% m' P9 w) k                g.setColor(end_color);
6 T' w/ \/ N( P5 {, \   for(int j=0;j&lt;Antcolony.EndPts;j++){
, Z% o( P& B$ s2 C% X3 r                  //画所有的食物点
                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
                  //每只蚂蚁开始决策，并画蚂蚁
   Antcolony.ants.Process();
, Q8 @1 r; b3 E; |9 D, h" e   Antcolony.ants.Draw(g);
5 V2 j  J# j: G# P3 m  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
( p' Y) f, u( y# E( [- v2 o& o# m                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
                        case (1):
( w1 |) Z( j( Z* D1 f" L                            v.Draw(g);
                            break;
' @; b( l% _. w# u* z$ Y                        case (2):
                            if(v.kind==1)v.Draw(g);
                            break;
3 Y# p. Z; Y$ R5 q# i                        case (3):
/ ?# r4 m7 P4 N7 |                            if(v.kind==0)v.Draw(g);
4 F$ q* ], [) I; t5 g4 U( a                            break;
                        }
                        v.delimit(g);
3 ^) g3 g& W  \) L/ O1 ^* y( @1 Z                }
           g.setColor(origin_color);
7 j* H* ^& Y* l. H( Q3 p                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
4 k! h+ F7 a; X: a6 e/ v                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
                }</P>
7 d( n2 l4 ~* J9 c, N<> }
" s% T" A( N& j; F, S" A/ |; g/ c Graphics GetGra() {</P>
<>  return this.getGraphics();
}
}
public class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
+ q# k: z9 e5 \2 ~/ ]        boolean reset=false;//是否按下了重置按钮
; D9 K) t& O& S0 q static Color OBS_COLOR=Color.red;//障碍物的颜色
' T/ |, N/ h8 ~3 F static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
) z8 O, P/ a5 Y static Color BACK_COLOR=Color.black;//背景色
static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
  d$ x; O1 }0 }  t$ T AntCanvas canvas=new AntCanvas();//画图用的画布
$ B4 _. Q% U1 ?: H4 X/ i: U7 Z, u  ~ int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
% t/ U; [7 |9 \ static Point EndPt[];//食物点数组，值为食物点坐标。
. ?' k& ^# P: ]/ U9 S* S6 k2 X9 Z        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
2 E9 `# W+ d. J. c$ h        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
4 a& t6 _0 r/ Z) Z5 d$ \2 q        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
6 @5 i$ ~1 s) R( b7 w  K) \        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
% _% S' Q% h/ [9 w        static int OriginPts=1;//窝的个数，最大为100
static int width=300,height=300;//环境的长和宽
" _4 T& K/ P8 [! ]9 R$ D4 T static int antCount;//蚂蚁的数量
6 q( t: q1 _. L/ G3 g( h        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
        static int FoodR=10;//食物和窝产生梯度的信息素的半径
5 V, O  }+ h+ [4 r: i5 g, M static ant ants[];//蚂蚁数组
        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
- U6 b( o) L/ y2 h4 G! G: t  e int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
- J7 M5 ~# R5 M( w<>        //下面是一些控件信息
6 k; Z2 E8 z- n( O& J. G6 A        Button btnStart=new Button("开始");
        Button btnReset=new Button("重来");
' h. z- X1 g: [$ p7 f7 Y; y        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
public void init() {
5 j: d: N9 P: g. f& F" o4 ^                //初始化函数，先画各种控件
; F2 U0 S" m4 h" h" u  setLayout(new BorderLayout());
4 c" g2 {2 b0 c" V                Panel pan=new Panel();
                add("South",pan);
                this.add("Center",canvas);
                pan.add(btnStart);
; |2 |0 N% _4 o+ V- L# y- ^' w7 @                pan.add(btnReset);
! u% f5 I3 B. Z8 o- @+ X* [3 ^                pan.add(btnConfig);
                pan.add(btnMap);
                pan.add(choPDraw);
                choPDraw.addItem("不画信息素");
2 Z. f' Q5 Q' X) n, h                choPDraw.addItem("画所有信息素");
; Z( c+ s+ D* p6 w& n9 }+ }# n                choPDraw.addItem("画食物信息素");
                choPDraw.addItem("画窝的信息素");
                choPDraw.select(2);</P>
<>                //初始化各个数组
2 t$ d1 p5 f8 ~% X$ D) x. m  obs_grid=new int [width][height];
4 Z* ~4 p4 j# C                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;
: U' ^  Y. q: t                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
. {- N+ C# X0 F  ?   }
  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
8 Y9 X2 b" ~- F                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
7 {$ q: V% ?* r- Y" J& e  ants=new ant[antCount];
2 {' b4 L% C8 y5 S7 X4 u        for(int i=0;i&lt;antCount;i++){
0 v$ B6 h/ l- z: m7 j' X$ o/ B          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
. l4 b4 N' S' ?& @' A! e3 @: N  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
0 y: B8 P9 A% s- V3 }                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
                Maps maps=new Maps();
1 U! s7 K  W0 s' B& Y* j& k                maps.LoadMap(grid,0);
                //初始化地图
                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
- z; M; M4 Y. R6 z/ W0 v4 O  reinit();
}
        public void reinit_map(int grid[][]){
' v6 g; _0 q- N4 R                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
( K- C- F  y+ f- C- J                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
: P: j( z+ w( N- l<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
1 u" `* O! Z4 `" Z0 q8 r3 s<>
                obsCount=0;
- H4 X# q% ~' [4 t$ _! v                EndPts=0;
                OriginPts=0;
% d  c2 f* w& R. U4 b                obsP=new Point[width*height];
6 U  L$ V5 y% s7 U                OriginPt=new Point[100];
                EndPt=new Point[100];</P>
# D7 q; ?8 \5 U* {  A<>                //清空obs_grid和Pheromone两个数组中的值
                for(int i=0;i&lt;width;i++){
4 {' i( c- ?( c, e7 M9 d   for(int j=0;j&lt;height;j++){
  Q+ I2 D3 W; y    obs_grid[j]=-1;
, X3 S; O5 n) Y/ V) P* B% g; O                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
* M! j: A2 |5 b: d+ T/ h# p2 W! j                                }
   }
3 x6 A* Y$ ?' D- T. e+ b+ o8 M7 [  }</P>
1 g% P' E. m$ M<>                //从grid数组中读取信息
% C; q7 ~# B6 X: s. {4 s0 f; e& R4 ?                for(int i=0;i&lt;width;i++){
1 M! X% \4 n  Y/ ^; k6 a9 z                  for(int j=0;j&lt;height;j++){
* Q* `6 d, M  z+ u                    switch (grid[j]){
                    case 1:
( B) n/ s6 p+ x$ V3 a; q6 o                      //如果grid[][]存的是障碍物
                      obs_grid[j]=obsCount;
1 `/ M+ Y  w" A( q: [6 Q9 Q" P! [                      obsP[obsCount]=new Point(i,j);
                      obsCount++;
                      break;
* `, @% t8 \* D$ u0 m                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
' F0 a4 T) T- Q6 N                      }
                      break;
6 [+ c0 V+ b9 r, V3 h; }& i# z3 Q                    case 3:
- ?1 z$ _& o5 _. d                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
                      if(EndPts&lt;100){
1 k/ |6 G) r8 r. [4 q1 E# n                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
                      }
                      break;
                    }
6 B1 H- g8 O3 P; L. ^. h                  }
* ~  ^) [1 u9 T; _8 g$ g8 b% R                }
            //如果没有指定窝，则随机的选择一点
' n, s8 V4 Q" o1 D1 E            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
                int  j;
                for(j=0;j&lt;height;j++){
$ O7 B7 n+ c- q: `$ \7 t- U                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
                    OriginPts++;
7 [) C% c4 x5 Y* \/ \# W, z- g0 R                    break;
                  }
                }
                if(j&lt;height-1){
                  break;
                }
; _. N0 N  O7 r) r              }
            }
' `  j; q4 y) _( s7 y7 R5 |        }
public void reinit(){
& l  `! Q4 s+ }( l3 J                //重新初始化整个环境</P>
: a7 _; Z6 U5 F! l- r2 f& j<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
<>
  //清空所有信息素Pheromone数组中的值
                for(int i=0;i&lt;width;i++){
+ U; g  \: _% o" I   for(int j=0;j&lt;height;j++){
* ~3 [+ V; I# S2 J                                for(int k=0;k&lt;2;k++){
  p7 A% x; \( d7 t5 e  W$ \$ D                                  Pheromone_grid[k][j]=0;
3 m6 \- b. Q: |; A9 s0 N                                }
  }; P' c3 q: D5 o; |" _$ B. t   }
; h5 r9 ^& W: H  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
4 r/ Q1 ]. B% Z                        int index=(int)(OriginPts*Math.random());
( D* P% L- ^" G. r/ ~1 O          ants.OriginPt=new Point(OriginPt[index]);
                        ants.init();
  n3 Z! w3 N% D& I  }</P>
; G/ @; E0 c) l! I5 ~! e<>                //清空信息素向量
                phe.removeAllElements();</P>
<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
  for(int i=0;i&lt;EndPts;i++){
5 \. J0 d; W/ m                   for(int x=-FoodR;x&lt;=FoodR;x++){
% S9 Z& B6 S: J* u8 m                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
! K% @$ W: G/ w1 z& p                        for(int yy=-y;yy&lt;=y;yy++){
                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
2 S8 y0 B$ M% M+ C3 `! w: @                    }
- O) b2 e! A% Y" A                }
                for(int i=0;i&lt;OriginPts;i++){
8 t2 E* C6 l1 h                   for(int x=-FoodR;x&lt;=FoodR;x++){
) b4 }' L7 T0 ~! w7 C. U                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
# T$ T, }3 l" ?3 P( y7 B) e                        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));
5 x1 p9 S: p6 G+ C+ Z0 ?                        }
4 D7 @4 p) `1 d: @# ?+ [3 y) o- B                    }
/ T8 O2 O8 ~: P( r3 B                }</P>
<P>                //重画
  canvas.repaint();</P>
<P>                //让程序开始运行
% S3 v/ i8 x: _% p# M* J1 q                //running=true;
  }- m; B5 L" F& Y  }8 ?! a0 t }
4 p3 U$ S$ D5 J0 Z  _  F( M9 ] public void paint(Graphics g) {
9 h8 a! u% D7 s- v. S( `. x  canvas.repaint();
* [5 V: h2 Y; e9 P- ~# `& j  y }</P>
; [& ^6 ^" }, T- q  L<P>
public static void main(String[] args) {
    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
  S8 z. q# P9 D  L    Frame frame;
5 T, O  A3 D5 x% I8 q    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
( a; R# Q) m  D        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
          System.exit(0);
        }
, I$ q2 q- H4 u  A  w3 b* i  X      }
) S6 n1 x4 u  z      public synchronized void setTitle(String title) {
$ N# {5 {- j1 e2 Z( e- v        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
    };
    frame.setTitle("Applet Frame");
! a" E- A* n* m  H' U" ?    frame.add(applet, BorderLayout.CENTER);
0 ~  f, ?' O" y' ^  _  H    applet.init();
    applet.start();
% D0 S! ], u% \; C, I    frame.setSize(300,320);
# [6 J- Q7 ?7 X" j: [# [$ E( V    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
    frame.setVisible(true);
8 G6 x. s. _9 }) H  }
5 w; D! k) \; b. S" C  public void start()
2 g' b1 n* V$ v  //下面三个函数是控制线程的
{
  if (runner == null)
  {
* [% b' p% O* K; [   runner= new Thread(this);
   runner.start();
   //running = true;
$ k; `& r+ F7 U  }
, A, u% u! A( K1 E1 W }</P>
<P> public void stop()
, h( j# }3 Q' ~ {
  if (runner!=null)
  {
   runner.stop();
/ Z, \+ N6 s% u) M" r2 Q& b" D   runner=null;
   running = false;
; ]) S! W& ~1 m* o) h* {7 \  }
}</P>
<P> public void run() {</P>
6 k; [2 K! w- U- R- s<P>  int i;
0 l, d, {3 Y# [5 P/ t                //线程一直运行下去
; U- H6 r( E9 R; |/ N2 P( n  while (true) {
/ ?. v: x( A+ u          if(running){
4 X, Y* f7 z7 P# y9 k" t       //如果开始动画，就进行canvas的处理
                          canvas.process();
                        }
# b- K% y  b: R# y) H/ l7 K2 R    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
6 F4 P& Y; F: X% E3 C9 @   }
  {7 u+ e; ]3 b5 s# V- w  }</P>
: L2 V4 f' b! |: ^7 m5 Q* Y9 t<P> }
$ E! j5 Q; E( t! u+ ]        public boolean action(Event evt, Object o) {
) {* i) Y% u7 a3 R$ a& H      if (evt.target == btnMap) {
8 P- e  Q- W% y% g                //开始编辑地图面板
   running=false;
                        btnStart.setLabel("开始");
   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
                        ctl.show();
, f6 h% U0 `1 B; S                        return true;
5 T' U4 T4 B5 \) z  }else if(evt.target == btnStart){
& J# _! H2 @3 C7 R) }1 |                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
                    btnStart.setLabel("停止");
                    reset=false;
                    running=true;
                  }else{
                    btnStart.setLabel("开始");
. z7 q- Y' p8 F; ^+ F4 o( N                    running=false;
                  }
! x2 L2 Y* j$ B- G7 U  E                  return true;
                }else if(evt.target == btnReset){
                  running=false;
                  int j=0;
3 Q7 H2 d* [. B# \" ^4 u' ?                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
: `9 d5 ^' S' t* k2 q                  repaint();
                  btnStart.setLabel("开始");
2 w6 [, D0 q3 _                  return true;
2 r. I# T( I; ?/ k, t                }else if(evt.target == btnConfig){
                        running=false;
) y* B! h; m; j3 @/ Z4 ]! K8 N& {8 A                        btnStart.setLabel("开始");
9 k( o4 ?% p5 ~     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
- k3 ?! @7 S: D' o                        ctl.show();
, q# N+ x/ H- R6 K4 J6 T+ {' \8 N$ c* p                        return true;
                }else if(evt.target == choPDraw){
                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
                  return true;
- z" f* k- Q8 _  J$ ]$ m                }
2 T" R. A2 l& _9 [! J- o                return false;</P>
6 h, H+ F+ K& E<P>        }
( D5 a4 l) `% T( c /**Destroy the applet*/
  public void destroy() {
* n8 b$ }+ w, F4 a" d6 u* Y, \! X  //当结束程序的时候，把线程也结束
    if (runner!=null)
0 F* k! }6 Q0 e! C: C/ u$ O    {
# z4 u5 {! u0 P( V3 y" y       running = false;
: e4 }7 L* k1 f. r2 A$ |       runner.stop();
/ d) n0 x7 J% d# p# L9 W       runner=null;
$ }! w5 L/ K; j. _    }
  W+ h) E( S4 f, @" W* V7 L  }</P>
<P>}
</P>
' _0 @! ]- p8 a! {' L


. P% U( i1 c3 V/ h( {0 S<P>package ant;
import java.awt.*;
" m; e1 p2 ^* W# Simport java.applet.*;
import java.util.Vector;</P>
' K' d7 z- q: R/ l0 F: m<P>public class ant{
5 z3 `- J+ Q. L% Q Point nowPt;//当前点坐标
int VR;//速度，每次蚂蚁能走动的最大长度
  int id;//标识
8 M1 G, k  H% V. Z" v  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
& g# f: P  c, W7 ] int height,width;//世界的尺寸
        int Phe;//每次释放信息素的数值
Antcolony local_colony;//主程序的指针
8 }! k4 f' M. B6 U& o0 o9 h8 W( t        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
0 j2 x' ^( W, o0 M; g        double Main_direct;//主方向
5 a5 |8 H) y) z- ^% K& z        Point FoodPt;//记录的食物点，是否找到时候判断用
        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
2 V, u7 h4 V5 E( n$ L$ I        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){
$ t$ J! R" o2 s: S* R  nowPt=new Point(nowpt.x,nowpt.y);
7 A  B3 s. r7 A, w1 @0 |' W5 B                OriginPt=new Point(nowpt.x,nowpt.y);
                FoodPt=new Point(nowpt.x,nowpt.y);
1 a( M( k6 z1 f% m                StartPt=new Point(nowpt);
. a% |* ?  l8 [  m                AimPt=new Point(nowpt);
                lastPt=nowPt;
4 v+ L& }% L! |# t3 b' V  VR=vr;
  id=idd;
  color=c;
  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
  width=Antcolony.width;
  local_colony=colony;
+ _& S7 z/ K# e6 K1 z) F- X& @                Phe=200;
                mistake=mist;
, y7 L3 s- V8 u% o/ L7 ^  q                HistoryPoint=new Vector();
/ G# n) G$ f/ `# Y. j                Main_direct=-1;
                FoundTimes=0;
9 X+ x0 G( z9 R, b                Max_Pheromone=local_colony.Max_Pheromone;
% A1 w" U4 z5 S- d                Pheromone_count=Max_Pheromone;
                memory=mem;
                Count_distance=0;
                Min_distance=-1;
}
        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
- A/ s! F9 ]* k" Y( ]& u  n          AimPt=new Point(OriginPt);
- P$ i# b$ _" ~) C7 ]          StartPt=new Point(OriginPt);
8 X7 N) b. D" s! X          HistoryPoint.removeAllElements();
          Main_direct=-1;
4 \- w2 c* r9 V. {, T/ R          FoundTimes=0;
+ R; L( b1 v/ u* o          Pheromone_count=Max_Pheromone;
6 E' J6 |; s& I' `" H3 p          Count_distance=0;
          Min_distance=-1;
        }
public void Draw(Graphics g) {
  n; |1 H4 p* d$ ]  |          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
1 N* p9 m5 N6 l& N  g.setColor(back_color);
  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
8 D! A# |, F. Z9 o  g.setColor(color);
4 ?- m" g3 J3 y/ y8 {$ C8 x  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
}
public void Process(){
. |$ S3 U4 _1 ]! x        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
! I+ y5 B$ @$ ^, n        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
0 o8 a! i' x6 `& [3 c& L        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>

- F/ U' n: S; x1 Z, h<P>        if(Judged==false){
' Y  G% U& ^. P% i          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
( l' w6 V# ^2 B2 U2 s# Q          if(JudgeEnd()){
              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
              return;
" l9 I8 y# |' Z% x( C1 t6 e- k7 `          }
        }
2 B  [: _! g- R' n/ N        Judged=false;
0 {- R( _2 c+ H* D0 B        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
& q9 F/ A& P- s# k. u8 i0 `        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
        deltx=(int)(VR*Math.cos(direct));
        delty=(int)(VR*Math.sin(direct));</P>
) G3 i; v/ K+ I: ~1 D7 G, ^<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
; x; V, V* R; ?+ R  S<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
9 O$ w# m( ?3 r        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
# Q- r7 u$ V0 j, k) \- ~        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
4 o8 }4 ~6 a; H9 x2 d          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
+ \4 M5 w  {$ v1 F' I* J          for(int x=-VR;x&lt;=VR;x++){
  y0 ~6 m1 r" n) R             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
/ R2 H& r. l2 E+ K( q                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
5 _+ b- ~4 I  s1 d. g% d                int yy=(nowPt.y+y+height)%height;</P>
<P>                //循环的时候要除去当前点。
$ Z# q2 [1 N: n* [8 r5 o                if(x!=0||y!=0){
# P; N- |. c& U+ W( g                  //的到要搜寻的点的信息素
1 f0 E# z" a% t! ]3 R$ F9 ?- }                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
<P>                  //如果搜索点的信息素比已经找到过的信息素多
- `6 h1 l! X" G, H9 b. H  [                  if(maxphe&lt;phe){</P>
<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
$ S& }2 F. f: ^* R, M/ M* Z& ]                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
! k- @) H, w( T3 w                          boolean found=false;
3 b! Q3 r- \% P+ h4 J  k                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
                          int minsize=memory;
% X' w& O! T3 ~                          if(size&lt;memory)minsize=size;
                          for(int i=size-1;i&gt;=size-minsize;i--){
% X3 [- I4 p9 U) J/ u1 z                             Point pt=(Point)(HistoryPoint.elementAt(i));
) J) E# t* ?' l0 _9 g+ d9 e: U                             if(pt.x==xx&amp;&amp;pt.y==yy){
( R0 _' v& S) @, v. M2 _                                found=true;
$ w. x" N1 X6 p1 ^: S                                break;
0 k$ q* F$ ~1 a' j5 K- C                             }
5 w6 s' N0 w5 X; a. L* d                          }
                          if(!found){
9 r7 b" r/ I3 Q2 g, I8 V                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
                            delty=y;
                          }
                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
                }//end if x!=0
1 S5 N; R1 B( r% k) j+ |( r0 H            }//end for y
, ~& C5 I2 O! n# s7 o- {        }//end for x
* Q! Q# B5 [+ b, ~0 F2 {        Point pt;</P>
% l  \  U% q$ n; u& G5 r<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
5 L, F* ]; L7 i/ r. b9 J# z' t' g, `        pt=Evade_obs(deltx,delty);</P>
' G$ d6 {6 h; d! J0 t<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
( M7 e; Z2 X* L2 v- y4 O  W0 f! K* L        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
          pt=Evade_obs(deltx1,delty1);
, w: e1 p3 p/ Z5 O. f+ ~& w/ X        }</P>
3 c9 W4 r1 ]6 o<P>        //播撒信息素
        Scatter();</P>
<P>        //记录走过的距离
        Count_distance+=Distance(lastPt,nowPt);</P>
' V: x2 U! G/ ]<P>        //改变当前点位置
        lastPt=new Point(nowPt.x,nowPt.y);</P>
<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
) F3 R, Y" x) c5 n% b- n        if(HistoryPoint.size()&gt;memory){
1 O0 D0 h0 S- {% P/ H( b          HistoryPoint.removeElementAt(0);
/ c2 l' ^4 Z8 X! [: {        }
        nowPt=new Point(pt.x,pt.y);
     }</P>
<P>
        private void Scatter(){
1 u1 m+ W2 A: e) ^0 j, z        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
5 C8 X1 F' R+ @3 I/ u( H5 `        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
# r3 {7 I' G, ~7 g! V" d            if(Pheromone_count&lt;=0)return;
$ Q( G; `' Y( i: b            //决定释放信息素的种类
7 C, @$ D, a. O6 _( q* ]            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
6 G1 q; K' }# D6 ]9 [            boolean ofound=false;
9 G" \2 p+ b' `$ J4 ]            if(Phec!=0){
1 y' H6 m& R! P                //如果当前点已经有信息素了
! d6 o) U# u/ p/ y7 m2 k                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记录。
                        ofound=true;
3 n2 M" I" ]. ?: W                        boolean found=false;
8 G$ f# p, K4 G; G* u                        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){
                                //如果当前点重复了以前走过的路，就不释放
3 Y: H6 d8 E2 D0 ^6 E" z                                found=true;
                                break;
                              }
/ p4 U0 F' v( u, N8 D                            }
0 P; J$ z8 O9 J0 {                        }
3 x6 p( x- }" D: }5 K/ z% v9 ~6 r  v8 T                        if(!found){
$ C; |5 f4 u! {" p6 h                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
+ j( l$ X& Y: a! O& z+ w, ?- m* c<P>                             //让还剩下的信息素总量减少
, r. x$ U$ {% |6 @* E. ?' J                             Pheromone_count-=Phe;
                        }
                        break;
8 Q$ u5 }) C9 `, e( m( z! X3 d                    }
                }
( @& E# M, c, f/ o' a8 \0 f# D* e              }
          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);
9 s5 P0 r. i) [! p                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
/ n' Y! U/ t1 A0 U2 U2 T                local_colony.phe.addElement(ph);
                //让还剩下的信息素总量减少
                 Pheromone_count-=Phe;
           }</P>
' w% h! \1 Z5 @& I' c0 H! T<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
: X: {) p; ~$ h3 i           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
! |% h8 A( m7 E# b0 J3 o           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
$ {) q6 ]+ P6 q+ U& H4 j<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
        }
- q, @6 ~5 x' K$ X# d  R0 u7 u. fprivate boolean JudgeEnd(){
- b4 Y  a9 h: C9 e' X! f2 d9 t! ^    //这个函数判断是否已经找到了目标点
    //首先获得当前蚂蚁是正在找窝还是在找食物。
4 s4 y$ x+ ]# [5 N; v* f. N+ J    int kind=FoundTimes%2;
- \1 i( [. Q- }7 [    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
7 n5 T; R6 N$ q, T  e( \& _        int i;
/ T9 ]' D+ e3 w        for(i=0;i&lt;local_colony.EndPts;i++){
# R7 k0 q( O% }5 G) C7 b            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
              //如果找到了食物，就直接移动到食物点
              lastPt=new Point(nowPt.x,nowPt.y);
8 Q# W' \* }" d6 Y8 M; K7 }              nowPt.x=local_colony.EndPt.x;
. ?; B1 q  N* v0 T7 K5 x              nowPt.y=local_colony.EndPt.y;</P>
3 _$ \; M6 D) v7 }1 J2 U2 G; q<P>              //计算最后的总距离
; |( S3 R; v5 W- a4 b              Count_distance+=Distance(lastPt,nowPt);
6 o8 {1 v# u8 _4 p              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
              }
              //清除总距离记录
              Count_distance=0;</P>
<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
# a; q0 z9 n& H              AimPt=new Point(OriginPt);
+ z! l7 X' q8 Y/ h. N0 w              StartPt=new Point(nowPt);
              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
<P>              //找到了食物就把找到次数+1
              FoundTimes++;</P>
<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
* k( I& D6 c8 B; ^5 G<P>              //重新把自己能撒的信息素置为最大值
8 ~+ ?: Y: H0 N( U              Pheromone_count=Max_Pheromone;</P>
# Y, Q6 x# k% W8 q: F<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
6 Q1 A; V; l; U& R5 B<P>              //返回找到为真
1 K: N  U( E% h1 C+ I              return true;
            }
2 x7 T& S4 b" H* u) Q        }
) L. G' y; E: u" x  `1 ]9 l. Q. g      //否则没找到
      return false;
    }
/ g- w: p, d6 I5 q% H4 w6 I9 }# D! j    if(kind==1){
4 U8 I0 J7 r' J' o9 G; n2 J        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
; Z0 M( h: ^- z4 s" A        if(Distance(nowPt,AimPt)&lt;=VR){
* u0 a( H7 j: ~4 G" J# F; Z            lastPt=new Point(nowPt.x,nowPt.y);
            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
4 K* z& i4 e- ~6 {" y              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
              }
9 a1 w& M- ~% |7 H" l) k8 V; c              //清除总距离记录
              Count_distance=0;
            //把目标点定为食物点，起始点定为窝
' R; Y& n7 w7 h* H, k" H# @            AimPt=new Point(FoodPt);
            StartPt=new Point(OriginPt);</P>
4 V& r9 x4 [0 F! R8 O<P>            //重新置信息素
* }- l2 G; o# c7 d            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
<P>            //主方向反向
% A5 p7 v6 a  E- ?( I$ ~            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
" F& ~- U- \+ Z8 ~% A7 _            FoundTimes++;
            return true;
) a1 K* B* L& q  y3 |& m# X  @        }
) }6 u$ i" X  O' g+ K8 d        return false;
    }
* R# ~, R8 M- @, g# [( h    return false;
- A& P: {: z8 {1 @4 n. x" q4 t( t5 D4 l}
( P- i; a$ E9 q0 A' G        private double SelectDirect(){
                //选择方向，最后选择的方向为主方向加一个随机扰动
7 F& f4 S8 y) M* O4 H# l9 B                double direct,e=0;
- Y. P6 W$ Z7 i, H) x: n; K                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
, ]* h: k9 o6 X( |1 E% \        e=2*Math.PI*Math.random();
7 G; q; U/ N5 n                      Main_direct=e;
2 {) Z3 q: _" e2 r+ W6 L# c                }
/ ]" ^) m! m! |$ `2 _                //选择主方向角
- B  w4 _' i; O* t4 X                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
" [$ J4 c8 L0 ]                double re=Math.random();
                double re1=Math.random();
                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
' ?: V) ~& f7 N* z                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
                  int size=(int)(re1*memory)+1;
8 R, t, s3 E2 a" x7 E                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
                       Main_direct=GetDirection(pt,nowPt);
, s: u* z& X; C+ v0 p/ Y0 N                    }
, b" @# E8 R% Q7 V! P9 ?3 i0 X, p                  }
                }
               return direct;</P>
<P>        }
" D7 K! Y" u( U        private Point Evade_obs(int deltx,int delty){
- c1 Z5 D$ J; K2 G              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
7 o$ @) \3 E0 w% V              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
6 }  L  Y. s3 k              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
: @- Y/ N% b8 }/ n+ B              Point pt=new Point(0,0);
              int x,y;
              int delt=deltx;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
              if(delt==0)return nowPt;
              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
                  x=(x+width)%width;
                  y=(y+height)%height;
& D) [' N; N8 D0 ^" n  _                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
6 m+ j; Y8 U  B3 u( j- w4 {; C% n                     double disturb=4*Math.PI*(Math.random()-0.5);
6 x' L! A( t" A- _$ d) E9 l* k3 I0 E                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
                     break;
9 Y+ F% P% d3 d/ K( n& ]                  }
  O/ w! B( X3 u' M# D$ l                  pt=new Point(x,y);
% z  n! t4 J8 k$ A                }</P>
<P>                //计算得出实际能够到达的目标点
  x=(nowPt.x+deltx+width)%width;
1 _- m& z4 T" }( }3 |/ I: w  y=(nowPt.y+delty+height)%height;
9 X/ v; d# h$ t# Y. A         return new Point(x,y);
. w# \* c5 \3 r; ?! @9 N0 ^        }
1 T' ^! {( p9 s' Y! u        private double GetDirection(Point pt1,Point pt2){
$ M; E$ n0 m# h( P' m/ e- x* f        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
        //其中方向角是所有可能的角中使得两点连线距离最短的角。
               double e;
               int deltx1=pt2.x-pt1.x;
8 ?! n- V* g- |: c, `8 a5 e& C               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
               else deltx2=pt2.x+width-pt1.x;
  M4 a) s8 q2 [7 ?' ^               int delty1=pt2.y-pt1.y;
7 @. j) v+ o  k" V* J: M5 O! M               int delty2;
  Q8 F/ u% U! [+ H# \: r2 n               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
6 r% s- `' y( t+ t) q% ^               else delty2=pt2.y+height-pt1.y;
               int deltx=deltx1,delty=delty1;
: w5 ~6 J3 p" V( h' \5 G9 {' a               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
/ S$ d1 X6 c( k1 O    deltx=deltx2;
               }
8 d! M" T8 v" `        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
0 B  W4 u. y) t0 W2 _               }
$ k* f( n. b! Y$ |( Y" d; P               if(deltx!=0){
                    e=Math.atan((double)(delty)/(double)(deltx));
                    if(deltx&lt;0){
/ G% v; ~3 Y' R% L9 \2 w                       if(e&lt;0) e=e-Math.PI;
- n- c: l" n4 u0 |                       else e=e+Math.PI;
$ A: `) m% t# x+ x3 U& U; L                    }
* k; O; w- k; u) U4 E                }else{
; g3 H3 Z" t# T  T                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
* \1 t' l4 F- `/ q* I5 w3 W! N5 |                }
                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
* d' E6 m0 ^! _        }
        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
6 M5 W% f& G6 u2 ~+ f+ @        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
, V1 j: g4 i: }- d6 j- x            int dx2;
            int dx,dy;
- ^) B: N( I0 a1 H1 @" \9 Q& j            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;
5 S0 P* h8 k- H/ J            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
            dy2=pt2.y+height-pt1.y;
) q  g* E( m: j            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
  d/ M: |- c. ~- x7 Q: b            else dx=dx2;
, j/ x: P& G6 B2 w) N+ C, A            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
* X5 T: l* d7 c% ^            else dy=dy2;
            return Math.sqrt(dx*dx+dy*dy);
        }
3 x0 q- D: C' R4 G5 u0 w- l7 W    public void clone(ant ant1){
$ m5 b  j9 K9 p: V$ |, o        //把蚂蚁ant1的属性拷贝到本蚂蚁
     nowPt=new Point(ant1.nowPt);
$ v/ q  J3 E: M( N        OriginPt=new Point(ant1.OriginPt);
/ p- X0 x0 L$ {8 U+ K* L4 ^        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
        lastPt=new Point(ant1.lastPt);
3 o3 Q' k- F; s4 a" g8 O        VR=ant1.VR;
6 m- T8 p9 V4 }% K3 H+ K        id=ant1.id;
7 {. ]1 ?4 |6 Q5 Z        color=ant1.color;
        back_color=ant1.back_color;
9 _  d+ c# v) v' z        height=ant1.height;
) B5 z  Y0 W; N3 t; A        width=ant1.width;
        local_colony=ant1.local_colony;
6 c$ K- S! y6 Z3 C' m1 H        Phe=ant1.Phe;
6 K! v8 G+ o1 n- f8 Q! h        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
2 u+ Z7 R8 @$ h" j; @        Max_Pheromone=ant1.Max_Pheromone;
( X& }+ _8 y. E        Pheromone_count=ant1.Pheromone_count;
        memory=ant1.memory;
7 x0 N7 W5 j, [& w7 N' S        Count_distance=ant1.Count_distance;
        Min_distance=ant1.Min_distance;
  w9 ]9 C/ r/ r6 H, ?8 d; S9 X+ G' P    }
8 j9 \8 Z* T2 u( y}</P>