[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
<>package ant;
/*
* @(#)Antcolony.java 1.0 03/05/22
/ o/ W* i2 b% q, f7 b+ s *
* You can modify the template of this file in the
* directory ..\JCreator\Templates\Template_2\Project_Name.java
*
6 H! J  J* _! P. }4 e0 B9 E  z * You can also create your own project template by making a new
* folder in the directory ..\JCreator\Template\. Use the other
7 [& M, v  v* x' J * templates as examples.
+ k) l5 o9 _, V/ U) w *
*/</P>
) ^4 U9 n" H0 t4 W) r<>import java.awt.*;
8 E% e) |8 p. n8 Iimport java.applet.*;
import java.awt.event.*;
! O/ ?6 s- W; q5 ~2 s) zimport java.util.Vector;</P>
<>class AntCanvas extends Canvas
{
    //画布，一切画图操作均由该类完成
- ?0 m' v5 T: G! N4 G //Image image;
Color obs_color;//障碍物颜色
Color origin_color;//我的颜色
$ g6 p! ?4 a7 }8 s# B  O Color back_color;//背景色
        Color end_color;//食物点的颜色
//boolean first;
boolean reset;</P>
- D) i8 G& }, ^6 ^$ u3 q6 b<>/* public AntCanvas(Image img) {</P>
/ K1 G" y0 ^1 z) I  E' z<>  super();
' _1 e9 v- z& _/ K- j   image = img;
  obs_color = Color.white;
  setBackground(Color.black);
9 ~( U5 f8 b! s8 {3 [2 |/ n  setForeground(Color.white);
  first = true;
/ A8 j( o* A5 u$ z  reset = false;</P>
9 g# k! y1 U5 z$ v- U% Q& @7 X# f( e<> }*/</P>
<> public AntCanvas() {</P>
<>  super();
   //image = null;
+ r4 K6 {( l8 i9 n& h7 e   back_color=Antcolony.BACK_COLOR;
  setBackground(back_color);
  setForeground(Color.white);
  obs_color = Antcolony.OBS_COLOR;
  origin_color=Antcolony.ORIGIN_COLOR;
; Y3 c: _4 ]  S; N2 T                end_color=Antcolony.End_COLOR;
  //first = true;
  reset = true;</P>
6 V, e- \4 {; G<> }</P>
9 N4 i" O: Q$ ]& q% l+ }6 T' X6 H8 F<> public void Clear() {
/ S3 w. o! D( F  E) {/ t& v        //清空画布
  reset = true;
  repaint();
! Q7 ~% N: o4 ]* h) ]$ I }</P>
<>
; |6 `8 O5 I8 \4 q3 F public void paint(Graphics g) {
  int i;
                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
; s! B0 s/ P0 Y6 n9 U  g.fillRect(0,0,size().width,size().height);
  g.setColor(obs_color);
" ]0 a, v! H: ~6 H5 I5 R  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
<> }
public void process(){
4 e8 f0 K9 X9 E$ ?& Z' i        //处理动画的过程
  Graphics g=this.getGraphics();
" y( J; C7 `. f! g                g.setColor(end_color);
   for(int j=0;j&lt;Antcolony.EndPts;j++){
                  //画所有的食物点
* _, P; @0 b4 j/ S, ^                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
                }
+ d$ W+ Y8 ]+ R% k) ?$ w: f                for(int i=0;i&lt;Antcolony.antCount;i++){
                  //每只蚂蚁开始决策，并画蚂蚁
, P0 |  A2 s* ]9 e$ J1 O3 n0 ]* S! W   Antcolony.ants.Process();
' ~9 }8 d  e: Y2 I* @% y! G   Antcolony.ants.Draw(g);
- P5 t7 j4 D! [3 w8 `  }
                for(int i=0;i&lt;Antcolony.phe.size();i++){
( d! X2 y' ~' l) z4 ]: K                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
7 [1 Y% L! v, t7 t/ Y! X! [                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
3 D2 |  a! v3 ~1 G1 W" k                        case (1):
& Z, D! l' r8 c( C8 Y9 F( l                            v.Draw(g);
4 G7 [6 C. Y& q; {* g3 s) i                            break;
, g6 X# \: `: y9 y$ E( f. z                        case (2):
& u) k/ M0 M. d8 }, ?                            if(v.kind==1)v.Draw(g);
% a1 H. _7 g: I& T1 q# P                            break;
1 w9 G& y7 \2 ~9 w+ H* p4 Y8 r- ^0 n                        case (3):
* Y9 n# }- F: O                            if(v.kind==0)v.Draw(g);
& X' `/ X3 y5 t% Q$ m                            break;
) {+ I& F8 v7 m6 i                        }
                        v.delimit(g);
                }
3 e# c8 [5 e) v# p( n5 I$ V           g.setColor(origin_color);
: t; k. I7 a4 E                for(int i=0;i&lt;Antcolony.OriginPts;i++){
2 i" G9 `4 W& `- X1 m8 g                  //画所有的窝
                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
3 A- k$ a  k! V# r                }</P>
<> }
  n! i, G5 u* M; b3 w* P) U4 N Graphics GetGra() {</P>
<>  return this.getGraphics();
& s, X! K  p7 y) i }
}
public class Antcolony extends Applet  implements Runnable  {
' P6 i: Q1 P, `5 S5 i7 a boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
- M3 \6 }# Z* t( b$ s8 v6 H, ^5 ?2 K boolean running;//是否让动画运行
5 {! S9 n" y- S. Z  m+ @        boolean reset=false;//是否按下了重置按钮
  f9 N3 v+ ~1 f0 ` static Color OBS_COLOR=Color.red;//障碍物的颜色
9 B8 e8 y* l, p6 ^( G static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
$ L0 {+ J9 j7 n static Color ANT_COLOR=Color.white;//蚂蚁的颜色
& s6 c: |$ o8 z2 o3 X5 n9 r        static Color End_COLOR=Color.cyan;//食物点的颜色
AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
; E, |( z4 W8 }3 o static int obsCount;//障碍物的数量，最大为width*height
! |: s% F+ N2 ^- W& l  F static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
5 S1 G( R; L/ a% u( q8 x: f3 w6 r        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
0 c3 P' ?; Q% {) l static Point OriginPt[];//窝点信息
5 t( x& ?  J. D; y" s, F& V1 l6 G        static int OriginPts=1;//窝的个数，最大为100
7 [3 A$ W7 H" t6 ]  @& |- ^, M static int width=300,height=300;//环境的长和宽
/ i& J, `7 `2 A1 |0 O  D/ t static int antCount;//蚂蚁的数量
+ U# X  b0 t1 c; k        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
        static int FoodR=10;//食物和窝产生梯度的信息素的半径
# f( |2 u) H9 S: X! m* I static ant ants[];//蚂蚁数组
        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
9 b5 M4 q, `6 I6 Q- w int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
        Button btnReset=new Button("重来");
        Button btnMap=new Button("编辑地图");
" |7 y$ a# c  L4 E        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
5 [2 S/ J9 ?6 h3 ]3 J5 [* w public void init() {
& R5 B2 J, |9 E2 r                //初始化函数，先画各种控件
  setLayout(new BorderLayout());
# T6 i) _3 }, ~  M5 l9 p- {/ b                Panel pan=new Panel();
9 D( j( A( o' }- N# O6 q                add("South",pan);
                this.add("Center",canvas);
                pan.add(btnStart);
+ U& X! |% G9 c$ S                pan.add(btnReset);
                pan.add(btnConfig);
                pan.add(btnMap);
- }7 u9 ^8 t* p; W9 Y  t                pan.add(choPDraw);
( v0 k6 X3 E# T: [. k' [+ v  Q                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
, |( s9 ~, I( {+ m1 f                choPDraw.addItem("画食物信息素");
                choPDraw.addItem("画窝的信息素");
                choPDraw.select(2);</P>
$ ~. C. b1 g! G5 y7 I! _<>                //初始化各个数组
! `9 w7 p; 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++){
   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
7 W0 u+ q4 S( A$ i; `3 o                                for(int k=0;k&lt;2;k++){
1 M% E! e: y& ?7 f3 \/ A1 g                                  Pheromone_grid[k][j]=0;
                                }
. f& o; I  X' I$ d- v- j   }
  }</P>
<>   antCount=50;//蚂蚁个数缺省为50
4 I2 k% P8 ]* I/ [8 k                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
; b+ _9 o5 {8 A# @* s7 Y. ~  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
9 \. R2 h7 l/ f) C/ z                Maps maps=new Maps();
                maps.LoadMap(grid,0);
                //初始化地图
0 x& }$ I$ z2 K' G; k7 F                reinit_map(grid);</P>
' a% w7 G+ ~/ O" v% }<>                //初始化所有的蚂蚁
  reinit();
/ a4 b$ d# b  H( Z/ z }
        public void reinit_map(int grid[][]){
                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
: z: ]7 G9 `# g1 `4 J. x& w                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
<>                //先停止程序的运行
+ U( g" U2 y: x5 y# X# Z4 d" i                running=false;
                btnStart.setLabel("开始");</P>
  f5 E/ s' z% n) |' {<>
: m. X# I6 H; M1 c' x; T: r                obsCount=0;
9 A0 x9 g" B- d                EndPts=0;
                OriginPts=0;
                obsP=new Point[width*height];
                OriginPt=new Point[100];
8 ]; _3 r- |% d( f3 D9 D: i                EndPt=new Point[100];</P>
<>                //清空obs_grid和Pheromone两个数组中的值
% [& E$ T) |: f                for(int i=0;i&lt;width;i++){
. S: U2 a+ b' |& g2 `+ A1 t   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
$ V- [- s2 D1 n                                }
   }
  }</P>
<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
; @5 @* K" o# i: n7 {: M1 n                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
4 |, ^# B" B1 ^6 v* f                    case 1:
" Q; t. ?  J, w( s" w' L; Z- O/ t                      //如果grid[][]存的是障碍物
9 T1 H" k: d* F, ]7 {                      obs_grid[j]=obsCount;
8 T/ M! q5 H. @                      obsP[obsCount]=new Point(i,j);
4 Y* d, X# b0 v  y                      obsCount++;
                      break;
                    case 2:
3 N# }* k  V. m) Y! w7 k                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
& g* |: H7 \- O                      if(OriginPts&lt;100){
2 A& g- A, Z) Y: N                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
/ @$ r: b* R; b/ R0 @3 n                      }
' o8 w" P* ~: |                      break;
$ S) r# E5 d9 p7 H- H# L0 Q4 k                    case 3:
                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
                      }
% a6 P- T; e" D8 w' Y" g- X% T1 k( r                      break;
                    }
                  }
                }
+ Z" j- Z* w  I; i            //如果没有指定窝，则随机的选择一点
$ l! [5 e- s5 j7 o0 @            if(OriginPts==0){
' T! e; m7 u7 u; w+ F0 E  T              for(int i=0;i&lt;width;i++){
                int  j;
                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
+ i# `: Y; ^' R* d5 E5 [" ~                    OriginPts++;
& x' S  K% x0 E9 J. H% p; s                    break;
* l$ X0 ^" I# `+ ~- Q. F9 E                  }
                }
                if(j&lt;height-1){
                  break;
                }
              }
* R3 ]- i2 J' R            }
        }
8 k; g# R; c" s. u- \ public void reinit(){
+ P; M9 \+ ~* B$ w# r/ |. c8 e                //重新初始化整个环境</P>
<>                //先停止程序的运行
                running=false;
6 Y  q% a& ]/ U# M                btnStart.setLabel("开始");</P>
% ?# ]9 K. a0 U" d1 C0 K8 U<>
  //清空所有信息素Pheromone数组中的值
0 x7 W6 i) U" \" j; ~                for(int i=0;i&lt;width;i++){
- \8 [0 s0 _1 {   for(int j=0;j&lt;height;j++){
" L/ S+ X/ H5 I, |$ m* d                                for(int k=0;k&lt;2;k++){
( L; r8 U+ u/ M2 c3 V1 n$ s                                  Pheromone_grid[k][j]=0;
                                }
   }
0 W$ U) }% \& u! H1 s  }</P>
/ P2 G/ j8 m2 Y6 B2 H+ L( e<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
                        int index=(int)(OriginPts*Math.random());
1 w) r; w8 |% E/ ]* U3 l          ants.OriginPt=new Point(OriginPt[index]);
7 S9 K+ z3 C7 f                        ants.init();
  }</P>
8 k6 c" l% _( }2 X& Y<>                //清空信息素向量
                phe.removeAllElements();</P>
/ I9 f$ q3 R4 H" r<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
( p( l8 D) L; j: q  for(int i=0;i&lt;EndPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
, ]$ N# E1 d5 b, t                        for(int yy=-y;yy&lt;=y;yy++){
9 Q' c) o- h9 d5 b                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
7 h" f0 R0 J  y/ N+ C; j                    }
                }
                for(int i=0;i&lt;OriginPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        for(int yy=-y;yy&lt;=y;yy++){
/ n  m) V+ ^  S7 u6 M& w                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
/ M& K8 C. C: h- b" {1 M: @6 x                        }
% K2 S, C2 a! |9 A                    }
                }</P>
( b$ F' D+ n/ M$ C<P>                //重画
  canvas.repaint();</P>
<P>                //让程序开始运行
                //running=true;
# W. E0 ?+ F5 }6 \) z1 ?# [ }
public void paint(Graphics g) {
2 G* U. {$ l6 D+ s  canvas.repaint();
}</P>
5 }: L/ K) @2 v8 T# t; p8 w+ {<P>
, h1 f0 D4 N4 T" B! w0 V: q2 Mpublic static void main(String[] args) {
$ {. b! m0 T: l$ s- ~) q0 ~3 x    Antcolony applet = new Antcolony();
$ |3 M5 d5 _/ h+ a5 g0 u    applet.isStandalone = true;
- }* g8 T. p$ j# \    Frame frame;
    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
! P! |8 g' @8 y" [8 S* r        super.processWindowEvent(e);
* d8 V* ^% n; \* H. D9 ^9 C        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
/ v' I: O/ D; s7 Z; n+ L          System.exit(0);
0 R3 h! B% I% n( h  _; L  P. Z  z5 W        }
      }
5 \, [) c4 ]1 D: I4 S* W8 n0 g5 r      public synchronized void setTitle(String title) {
2 y" ]! l) d. b& [8 Y        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
* @* B. N/ p" O3 w      }
; O/ O8 O! z$ S0 r6 L7 |    };
    frame.setTitle("Applet Frame");
0 @/ _  @9 T/ Z# S2 X# b8 q    frame.add(applet, BorderLayout.CENTER);
: f  j6 |: p2 @% b" {" [- K* h3 n# p    applet.init();
$ u! u5 y6 K' b4 K; R. w+ h    applet.start();
6 ^6 R+ h; v* }+ Z1 ~    frame.setSize(300,320);
. u1 C  c7 }. ~4 z    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
0 n4 e6 V. J  j    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
    frame.setVisible(true);
  }
  public void start()
  //下面三个函数是控制线程的
/ K# D% N4 J1 d% ~1 q" ^0 H2 g {
  if (runner == null)
7 U! O: i+ l7 l1 x. o3 d0 c( P* i! o  {
) F- P) m5 T$ ]* m9 ~   runner= new Thread(this);
   runner.start();
   //running = true;
  }
/ J3 N+ G% q! T; R- P }</P>
1 S  N; _5 ?& B4 i9 I<P> public void stop()
3 ~9 v7 V9 }$ @4 E; `8 a* X {
$ e: H3 m2 ?: O2 y  if (runner!=null)
2 R) `6 f9 {  a* ^0 G8 ], u  {
/ t- c/ E5 I) I/ @5 i$ Q   runner.stop();
% f7 t. U- v( z( x8 m; G5 W" V, S   runner=null;
   running = false;
  }
}</P>
<P> public void run() {</P>
& N7 R! y7 X% {* O6 z<P>  int i;
                //线程一直运行下去
5 x8 d+ S( }! p; {: L  while (true) {
          if(running){
       //如果开始动画，就进行canvas的处理
                          canvas.process();
                        }
    try { Thread.sleep(delay);}
+ {9 J; X$ _2 r; T9 c, M  B1 O) x6 p    catch (InterruptedException e) {
   }
  }</P>
<P> }
        public boolean action(Event evt, Object o) {
- H+ M; Q. H2 ]; B      if (evt.target == btnMap) {
                //开始编辑地图面板
   running=false;
                        btnStart.setLabel("开始");
   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
. C& k& |8 {* F; H4 g, I6 F                        ctl.show();
                        return true;
8 h7 }4 a) N- ]/ A% W! [8 \( M9 I, U  }else if(evt.target == btnStart){
                  if(!running){
; b6 ?) P" Q+ R+ n; @: Z6 p                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
8 S. j% ?( I, q' B                    btnStart.setLabel("停止");
9 M, v/ Q. i6 \                    reset=false;
2 j* h" z1 T1 z: s                    running=true;
                  }else{
5 k7 \. i4 V; |& Q$ }! B  O' ?                    btnStart.setLabel("开始");
  b5 ?1 O" g, {, n- q( ]  e                    running=false;
6 A  G" i! ^. l4 t8 F3 g                  }
; b8 N2 h* t( g" i' q                  return true;
) ^$ o% k/ N& W4 E4 w3 |$ b                }else if(evt.target == btnReset){
                  running=false;
                  int j=0;
  Y1 m9 W+ A, f! V5 G                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
3 G% h% {7 X0 n% m# Q                  reset=true;
1 d& z. u) P, Q1 q% h5 P: N9 ?7 R                  repaint();
                  btnStart.setLabel("开始");
                  return true;
                }else if(evt.target == btnConfig){
' i) c; S5 X. `! o  x" e                        running=false;
                        btnStart.setLabel("开始");
6 H$ N" @5 A4 ]- W     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
                        ctl.show();
                        return true;
1 I1 h: H0 o  L1 I) u% F9 f- R9 d' |                }else if(evt.target == choPDraw){
/ z  U" c0 W: ~: m                  //选择画信息素的模式
! b9 ]; {. A# k' Z. b2 u                  drawPhe=choPDraw.getSelectedIndex();
" K1 f: Q% C0 L6 f, {2 B! ^- v                  if(drawPhe!=1){canvas.repaint();}
                  return true;
                }
2 F; D: s( g/ I! U+ e% x) W                return false;</P>
<P>        }
/ j+ _( R0 y, r6 V /**Destroy the applet*/
, m3 f3 f* t/ M. d. O6 D. j  public void destroy() {
0 N3 U1 X3 y% }4 y5 {$ `  //当结束程序的时候，把线程也结束
* {' l. J/ l  F4 N; [( h' Z    if (runner!=null)
    {
       running = false;
3 R1 i* g! @: m% s       runner.stop();
       runner=null;
+ }1 U' a3 s  |2 N1 b    }
& e) U, Y( }* y$ O3 e) N7 f  }</P>
* l/ q6 z  {; Z$ j/ g<P>}
. Y6 \# Z& p2 y$ O2 {) D! m</P>



+ ?: C; w/ y, i' _! f- m( O; \<P>package ant;
import java.awt.*;
7 P: M- L6 W3 v/ ?- d# \import java.applet.*;
- U4 @: S/ f; S" Z- \' d! H+ S0 @5 g( himport java.util.Vector;</P>
<P>public class ant{
Point nowPt;//当前点坐标
+ G" g3 n9 P& F0 w, V int VR;//速度，每次蚂蚁能走动的最大长度
  int id;//标识
" S( a$ a( d9 X& D% B( u6 F$ f  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
int height,width;//世界的尺寸
        int Phe;//每次释放信息素的数值
7 l: f& H- J7 R: c; c4 t' ` Antcolony local_colony;//主程序的指针
- k6 S9 W  D! Z6 Z3 L) \5 a        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
" n+ E5 s& L; @! c& _, j' J        double Main_direct;//主方向
        Point FoodPt;//记录的食物点，是否找到时候判断用
  `+ U% g5 B! Y9 r4 a4 w' ~5 J        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
        Point StartPt;//起始点，是窝或者食物
8 v  e( M9 D* n4 S. S6 _        int FoundTimes;//找到食物或者窝的次数
, D* m: ^  z! K6 P! s        int Max_Pheromone;//最大能够释放的信息素
$ N1 q8 e9 R2 q2 X; }1 d        int Pheromone_count;//当前还拥有的信息素的总量
) J+ Q. i4 r' U+ E: A9 m; d        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
; q! Q$ q0 s& K/ Z( V        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
( t  G# o3 D3 A$ T        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
* I/ r9 ?3 u9 k/ p public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
3 h; l/ s  d: [0 c4 b  nowPt=new Point(nowpt.x,nowpt.y);
                OriginPt=new Point(nowpt.x,nowpt.y);
% M) f& a) a# m1 s5 J& I* M. i                FoodPt=new Point(nowpt.x,nowpt.y);
                StartPt=new Point(nowpt);
1 ]; h# z' ]% D# w4 S" _* W. j                AimPt=new Point(nowpt);
2 H6 @' V4 U7 |                lastPt=nowPt;
( p% i( m* d5 U  VR=vr;
  id=idd;
# E& l4 P% |/ ?- d( y  color=c;
  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
  width=Antcolony.width;
  local_colony=colony;
                Phe=200;
: F' @# e( j" n  ]                mistake=mist;
                HistoryPoint=new Vector();
( d3 i3 l1 Y5 j1 B$ ]8 Q8 S$ g8 P$ A                Main_direct=-1;
. r! r  M/ D, T1 J& t                FoundTimes=0;
' m9 G# s" p$ f! z! m                Max_Pheromone=local_colony.Max_Pheromone;
6 v* o8 w! f- K                Pheromone_count=Max_Pheromone;
                memory=mem;
                Count_distance=0;
                Min_distance=-1;
  c$ y. n+ L4 E- A" U }
  D( A- X2 k+ }9 u6 B        public void init(){
          nowPt=new Point(OriginPt);
5 c) W& e7 ^* z' H          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
: [$ `  A0 s" |          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
          Main_direct=-1;
, b. D3 d+ e9 o  W3 ?. f          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
          Count_distance=0;
          Min_distance=-1;
        }
public void Draw(Graphics g) {
8 v7 f7 y  I; z1 n0 r" j1 L3 |- U          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
& v% I& M3 Q! ^3 A  g.setColor(back_color);
5 f+ M. d" f- W" o, r, F) o  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
3 t& x  F5 }2 m" z- q( x  g.setColor(color);
& z7 Y7 H1 s4 }3 O( L  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
}
3 d  [( [  s, q) r* e public void Process(){
        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
. q; |  S) a4 r2 t  W        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
0 o& ?$ j6 k  f) @9 ~* q. a" t        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>
# F# C% w  S  V; M7 U- R2 X
# b/ I9 o' [- U8 y8 A4 d9 m6 _* j<P>        if(Judged==false){
          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
3 d+ H' Q' ^5 O          if(JudgeEnd()){
. E2 o; `3 |; J% A% m              //判断，如果找到了目标点那么就退出该程序
( R; k: @& K$ Y4 c              Judged=true;
              return;
          }
, L6 d# ?" l# b9 f% p5 m0 V& `        }
        Judged=false;
7 N- H% {: l8 D        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
) b: y8 U" }; F4 k: r6 @        deltx=(int)(VR*Math.cos(direct));
* }3 Y1 J, d- R        delty=(int)(VR*Math.sin(direct));</P>
<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
+ \7 ^' y6 v0 o' S; C( V<P>        //记录搜索的环境中找到的最大的信息素
. O- i$ r) C9 ?( B" m% u% K5 A        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
          for(int x=-VR;x&lt;=VR;x++){
& B( m7 z, Z6 \- t% f1 u1 U- h- h             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
                int yy=(nowPt.y+y+height)%height;</P>
<P>                //循环的时候要除去当前点。
1 G4 \, @' [. F* E                if(x!=0||y!=0){
                  //的到要搜寻的点的信息素
, T* B+ c5 k  T- x/ f                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
5 x2 H5 ?* k2 n/ g5 t<P>                  //如果搜索点的信息素比已经找到过的信息素多
% l+ A5 c* x! Q9 K                  if(maxphe&lt;phe){</P>
<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
4 @( c5 w5 e8 y! F4 o" m                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
5 `+ n  L7 Q' B  ?                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
: `4 x  M9 f, k& o                          boolean found=false;
                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
                          int minsize=memory;
0 C) n4 z% A$ o3 G  l- h; r                          if(size&lt;memory)minsize=size;
0 @) f) i# F1 e4 M: U                          for(int i=size-1;i&gt;=size-minsize;i--){
0 |! c6 L1 Y% g) u' j( w7 M                             Point pt=(Point)(HistoryPoint.elementAt(i));
                             if(pt.x==xx&amp;&amp;pt.y==yy){
                                found=true;
' x7 h  A# o  n! ?9 u" s                                break;
                             }
  w/ a  K0 @# M  b0 [                          }
# e5 g. L6 [6 o                          if(!found){
                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
                            delty=y;
5 e' F. ]% M$ X/ v* C' m                          }
                      }//end here==0||ra&gt;0.001
1 N5 b! P1 u( P! K8 v) g# I( ^                    }//end maxphe&lt;here
                }//end if x!=0
; X0 r6 t# E) B  L8 i$ t1 ]" s            }//end for y
' ~7 Q& K, O* V        }//end for x
& a% X. ~2 ?' l" ?- ~2 P! I        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
        pt=Evade_obs(deltx,delty);</P>
# m& g: ]: Y: T* o1 j( t<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
          pt=Evade_obs(deltx1,delty1);
( ~' g; ?, s$ F* o( O) m        }</P>
+ b+ c2 K  E' n: N3 b7 o. {/ v) g1 U<P>        //播撒信息素
        Scatter();</P>
6 V% s: T& a! U& M<P>        //记录走过的距离
& r" Q2 x1 b8 {0 p        Count_distance+=Distance(lastPt,nowPt);</P>
% o" Z6 J8 Q' e$ h( }/ w<P>        //改变当前点位置
        lastPt=new Point(nowPt.x,nowPt.y);</P>
2 n) {* s: t8 g1 `<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
        if(HistoryPoint.size()&gt;memory){
          HistoryPoint.removeElementAt(0);
2 I  b) l8 t1 p9 ^, S8 Q        }
        nowPt=new Point(pt.x,pt.y);
* S5 `0 q' C4 F& g+ j# }( F/ H; T9 d     }</P>
( `! W) I. s, u<P>
+ I4 ^8 w- L$ c0 y- R! K" Q, V        private void Scatter(){
  q$ D+ a1 L$ P% X" L& E9 j        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
- V/ y% G& C3 h, a: b0 b6 }+ u) R        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
9 H3 c! {9 N# |" {0 P9 y7 g            if(Pheromone_count&lt;=0)return;
0 a8 _6 Z- R% }            //决定释放信息素的种类
            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
; B$ ~+ `+ ~9 k* f            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
- w" O- ?: E" s$ o1 A            boolean ofound=false;
2 G2 \' v; R. t$ U! ]) V            if(Phec!=0){
1 k% C+ |/ g. [                //如果当前点已经有信息素了
, x, h7 J: F  q/ w4 |' e, q                for(int i=0;i&lt;local_colony.phe.size();i++){
                    //在信息素向量中查找该点的信息
) ]  X5 O+ Z$ s8 A& M4 `7 G                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
- ]5 c- x" }9 a8 t- v8 x, \                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
                        int size=HistoryPoint.size();</P>
; _( \1 e- C6 U- f5 i; V<P>                        //如果在表中找到信息素，则用ofound记录。
: |* U/ l' h# A. _8 s/ t$ F& t6 O) Y                        ofound=true;
: d( o( v8 E0 A( ]2 m# z2 Q                        boolean found=false;
                        if(size&gt;4){
                           for(int j=size-4;j&lt;size-1;j++){
                              Point pt=(Point)(HistoryPoint.elementAt(j));
8 n" R" s' v. z0 \                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
2 {' E3 d8 u2 \4 v* T3 E+ P7 N                                //如果当前点重复了以前走过的路，就不释放
                                found=true;
" y1 u2 {- @8 b3 h                                break;
  m2 d$ H$ Q; `; R7 o4 _                              }
7 @  z, f+ k/ k( V" y, X                            }
                        }
" w" K4 D5 @8 W                        if(!found){
                        //如果当前点不重复，则开始撒
1 c% X+ U' \! J% f  e                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
<P>                             //让还剩下的信息素总量减少
                             Pheromone_count-=Phe;
% f$ g2 k: s( Q8 y                        }
6 n3 O$ \' y+ e" a* {) Z8 s: g! J, ]                        break;
                    }
                }
              }
1 v1 Q" s; M7 I  h          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);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
. y: u. |! G& W5 t! u' t5 T9 _  G                local_colony.phe.addElement(ph);
/ \" N4 n. u8 f: ~& R                //让还剩下的信息素总量减少
" i! `4 j: w( n, G5 I                 Pheromone_count-=Phe;
           }</P>
<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
; s, d8 Z4 m4 S           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
' j  i2 W4 |. J, I! P           Phe=(int)(0.005*Pheromone_count);</P>
<P>           //如果剩余信息素已经太小了，则按照等差数列递减
! |4 ^1 `( B( E           if(Phe&lt;=10)Phe=10;
        }
private boolean JudgeEnd(){
/ N/ M3 t! m7 \4 h    //这个函数判断是否已经找到了目标点
& C& e9 S) |; ?/ f2 k    //首先获得当前蚂蚁是正在找窝还是在找食物。
1 f6 k% ~! G* _* _6 p    int kind=FoundTimes%2;
    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
        int i;
  U, l! e  A% |! V        for(i=0;i&lt;local_colony.EndPts;i++){
7 ^6 z# i+ A  Y5 Y% L5 q            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
3 ?, T% x9 v& a( i4 M/ h. l1 w6 x              //如果找到了食物，就直接移动到食物点
& {1 ~/ Z0 X" @$ Z" o" W6 \+ [              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
* Z2 Y) k8 {0 o" o4 i# ]  g              nowPt.y=local_colony.EndPt.y;</P>
2 [$ S3 T- _& R8 y$ T, p<P>              //计算最后的总距离
& R4 o3 M& k+ n- z              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
              }
              //清除总距离记录
2 o5 z1 c  r  c: L5 \              Count_distance=0;</P>
<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
3 ?2 n7 L; B; ?8 V+ o              AimPt=new Point(OriginPt);
4 i- Z9 A( [, {/ b1 H4 S              StartPt=new Point(nowPt);
8 f5 @( @7 y( o3 j: h$ |              //并把当前点标为自己找到的食物点
# j0 ]4 {2 |6 c" Q* I9 ^/ C              FoodPt=new Point(nowPt.x,nowPt.y);</P>
1 N1 c0 A# X+ T1 @<P>              //找到了食物就把找到次数+1
0 S9 h9 ]: Q, O( c% Q              FoundTimes++;</P>
<P>              //改变主方向为原来方向的镜面反方向
! B1 H9 B9 x! U/ k# e              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
3 Z( l, P2 K* J4 p) M1 w5 x. u<P>              //重新把自己能撒的信息素置为最大值
$ r9 j2 n% `) X% d6 h              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
+ h# M8 Q% n- i% U9 j+ Q              HistoryPoint.removeAllElements();</P>
& D0 z- o6 ?: ?. W% x1 n% `<P>              //返回找到为真
              return true;
            }
        }
/ s* I2 c9 Y' }8 Z      //否则没找到
      return false;
    }
$ y* q& h/ @' e  B, `% p8 o$ A    if(kind==1){
        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
            lastPt=new Point(nowPt.x,nowPt.y);
5 n3 c8 B# R3 g6 _, b            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
' z+ I. K  u/ R* u2 `<P>              //计算最后的总距离
$ y) x0 q; v( v' y) ^3 A              Count_distance+=Distance(lastPt,nowPt);
: {) Y, |- t2 _: j# t% p5 Q              //比较大小，记录较小的距离
% r( G/ H7 k7 R8 l1 u              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
. b2 ?' F6 u. V- {2 B5 n! V                  Min_distance=Count_distance;
              }
) V; n7 C8 e5 O              //清除总距离记录
9 x" B5 O( D3 [" U% c  x              Count_distance=0;
. O. {; F" c: g# v) Q3 F            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
+ Z: ?( ?0 M4 A- |- e            StartPt=new Point(OriginPt);</P>
<P>            //重新置信息素
. \! ^& K( z; S$ z/ H/ t2 u3 L0 ]            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
8 K6 i* J+ h/ U  s            HistoryPoint.removeAllElements();</P>
* f4 \9 A$ T! S# s' _3 T7 F4 [* t<P>            //主方向反向
            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
            FoundTimes++;
            return true;
        }
5 M& o& u9 v: x1 b; q        return false;
5 ?' L4 d$ e# B' P    }
, t4 H. S8 r! l7 Z9 p, A    return false;
7 B/ n1 \. I7 J}
  M7 j4 j! E/ R; t7 \5 H        private double SelectDirect(){
                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
+ Q$ c" j# u# W5 ^0 j/ J* J0 b                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
- H& ]& l& ^9 M5 G( W        e=2*Math.PI*Math.random();
                      Main_direct=e;
' }4 w- F  Z! S" m                }
                //选择主方向角
                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
                double re1=Math.random();
$ R. D. D' X( J+ P5 c9 L7 e. T& M) k                direct+=Math.PI*(re*re-re1*re1)/2;
" H- ~* o8 n0 h7 p                if(re&lt;0.02){
2 o' [- K: Y4 d8 {' _9 |                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
& v1 u& ~+ m1 Y: }7 r4 }- B& j& j                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
7 i3 I9 L6 |5 ]$ F7 V, [                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
                       Main_direct=GetDirection(pt,nowPt);
                    }
* }; D) a. M2 ]' h) R                  }
                }
               return direct;</P>
<P>        }
. h* X* M0 g) s& f# S        private Point Evade_obs(int deltx,int delty){
" s  S+ Q& |2 S              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
* X+ K. i  g5 ^6 Q* x3 g3 P              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
9 Z; T0 I/ |4 i3 T. z% ~9 K  S              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
9 Y) h3 u8 Z& l              //p1,p2在这里分别是nowPt和nowPt+delt
/ t& _. O1 P( C7 q% z              Point pt=new Point(0,0);
              int x,y;
& J# u8 w7 y7 l" A# n% h3 H              int delt=deltx;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
2 r  ~- O1 u+ A$ [" z              if(delt==0)return nowPt;
6 `" r' Z4 T8 p  |              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
: g5 m4 C! Q* y                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
                  x=(x+width)%width;
                  y=(y+height)%height;
                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
4 L4 x, h7 ]5 T" F<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
$ W/ V9 V5 H- S5 k5 l                     //新目标点为障碍物前方的点，主方向随机取值
$ |) m0 o- F5 ~, G* j" ]                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
  O- b* ^, [  K! \                     double disturb=4*Math.PI*(Math.random()-0.5);
                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
8 `  a! e0 a9 B1 x                     break;
: ~, k) N0 h# {                  }
7 N# |0 f6 I+ T) I/ [1 e8 W& ?: {                  pt=new Point(x,y);
                }</P>
<P>                //计算得出实际能够到达的目标点
  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
         return new Point(x,y);
1 N5 q# f/ w% L  q- j9 W        }
( b9 e9 z* {8 ?2 v- U/ h. w# ]5 \# |        private double GetDirection(Point pt1,Point pt2){
        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
* j+ k8 R* I% Z: ]& b& F2 Y4 m        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
! p5 R) C; ~1 c! P9 l        //其中方向角是所有可能的角中使得两点连线距离最短的角。
               double e;
               int deltx1=pt2.x-pt1.x;
               int deltx2;
" H' ]; a- U; J               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
; I  t8 B' |# ~( |3 x3 B               else deltx2=pt2.x+width-pt1.x;
8 E1 n& \2 Q! G7 h& }0 l               int delty1=pt2.y-pt1.y;
               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
               else delty2=pt2.y+height-pt1.y;
               int deltx=deltx1,delty=delty1;
2 @- j" C" {5 l4 T2 ?0 L% S2 z, G               if(deltx==0&amp;&amp;delty==0)return -1;
7 V3 I' V- t+ u. Y8 T9 M/ ~               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
               }
# J/ L; }5 A" a, O) ]! }        if(Math.abs(delty2)&lt;Math.abs(delty1)){
5 G8 _: t- ~  p1 v2 ]                  delty=delty2;
: W" A5 I9 h# o2 ^1 o1 R5 Y( L               }
) O9 r' ?  m$ Q0 {0 d# j# V$ ~! X/ l               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;
                    }
                }else{
$ z! h  ]* V5 R; j+ J+ l1 Z                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
                }
2 E) E$ O- R  X* j8 \* k! E                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
& y6 I8 @/ M! y2 s- |        }
        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
            int dx1=pt1.x-pt2.x;
, @0 ?4 @! ~) j8 n& b# ~            int dx2;
9 o  R& }7 v2 }9 I            int dx,dy;
/ a+ [2 M# ^. m$ i            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
4 F. K0 g! P" h& G6 m) w            else dx2=pt2.x+width-pt1.x;
            int dy1=pt1.y-pt2.y;
            int dy2;
            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
            dy2=pt2.y+height-pt1.y;
            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
6 C: m% j8 ~) n; q6 H6 q            else dx=dx2;
7 a; P& ?# c8 ~. X- ~            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
6 e% H% g( X  P9 _3 k  }! }7 }            else dy=dy2;
/ P) @% l" X6 n0 O4 ]6 f            return Math.sqrt(dx*dx+dy*dy);
1 g$ f# G, U, y        }
    public void clone(ant ant1){
        //把蚂蚁ant1的属性拷贝到本蚂蚁
     nowPt=new Point(ant1.nowPt);
        OriginPt=new Point(ant1.OriginPt);
        FoodPt=new Point(ant1.FoodPt);
7 f( b( K% P; a4 Z) Z; n        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
0 W' t. Z9 Y+ ~/ q        lastPt=new Point(ant1.lastPt);
# L8 K% Y7 h8 j3 R0 Y# m        VR=ant1.VR;
( J& \9 \- a0 L. a        id=ant1.id;
        color=ant1.color;
        back_color=ant1.back_color;
& K  l6 Y3 C- W7 b+ T6 e        height=ant1.height;
) @) N" D. _. `9 i- D# w& Z        width=ant1.width;
& ]# Y$ ]) K8 Q0 L        local_colony=ant1.local_colony;
        Phe=ant1.Phe;
- h; S  h1 K) N8 I8 b        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
, X8 a: k" b& |1 a        Max_Pheromone=ant1.Max_Pheromone;
2 ^# G# k: }, l/ `" q9 t" N        Pheromone_count=ant1.Pheromone_count;
        memory=ant1.memory;
: a) k# n0 k5 |5 I8 t        Count_distance=ant1.Count_distance;
        Min_distance=ant1.Min_distance;
1 m4 t* U6 g, S! w, s4 E. G* Y- ?    }
6 X- t0 [# u1 P0 Y1 G- b- w}</P>