[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
. q3 _! l! x/ B& k<>package ant;
/*
* @(#)Antcolony.java 1.0 03/05/22
*
5 G  P! D3 p% q1 `; e * You can modify the template of this file in the
* directory ..\JCreator\Templates\Template_2\Project_Name.java
*
* You can also create your own project template by making a new
+ l+ V( A) t+ {, a7 a2 t1 s" v * folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
*
( t" i; ?; H! V6 f& l+ ` */</P>
8 T) ?1 ~9 C9 m, y* L<>import java.awt.*;
import java.applet.*;
3 ]7 p% ]4 ^" eimport java.awt.event.*;
* n8 k; J" _( Q" n5 Z' y8 ~import java.util.Vector;</P>
' q4 A! O" V6 T4 A! ~; {2 B& j<>class AntCanvas extends Canvas
{
    //画布，一切画图操作均由该类完成
//Image image;
Color obs_color;//障碍物颜色
1 u; T8 ^( F. ]5 S Color origin_color;//我的颜色
Color back_color;//背景色
/ G; @2 {0 J1 W6 s/ `        Color end_color;//食物点的颜色
! G3 Z! o, V* [4 q& P //boolean first;
" D! d; H6 J( |# g$ Y) _6 n boolean reset;</P>
- |- O( ?( }' B: _<>/* public AntCanvas(Image img) {</P>
<>  super();
   image = img;
7 I. [: ]* z% q3 O' O( }5 j  obs_color = Color.white;
  setBackground(Color.black);
( {8 X$ H+ b3 B7 |; u3 Z/ ?& F  setForeground(Color.white);
  first = true;
  reset = false;</P>
<> }*/</P>
<> public AntCanvas() {</P>
$ g9 e) b& j2 @8 G0 u<>  super();
3 ]5 Z- L1 J7 \   //image = null;
   back_color=Antcolony.BACK_COLOR;
  setBackground(back_color);
* a7 n5 }+ j1 T6 X: C4 t  setForeground(Color.white);
  obs_color = Antcolony.OBS_COLOR;
1 ?, P) C" W4 ]$ X6 m  X( g  origin_color=Antcolony.ORIGIN_COLOR;
8 o& S8 X* b1 S3 c& f/ m                end_color=Antcolony.End_COLOR;
9 x) }7 v, Q; k! m+ S5 c4 T  //first = true;
/ A6 R" A0 a0 j+ V1 G: {  reset = true;</P>
1 w  ~1 e7 g1 i- x" v; M3 H<> }</P>
# P( Z/ L' P. c( |9 j9 A3 B0 P1 U<> public void Clear() {
; X# ~* P3 i  ~) l        //清空画布
  reset = true;
  repaint();
}</P>
<>
0 A$ N6 e, r9 b6 n1 U9 D public void paint(Graphics g) {
  int i;
                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
- A( ^! p* N- I- Z$ ]- Q  g.fillRect(0,0,size().width,size().height);
* R9 V+ j8 a5 Y! K  g.setColor(obs_color);
& X* x$ V: L8 K5 `! t0 ~, {  for(i=0;i&lt;Antcolony.obsCount;i++){
- ]' l1 a/ \% X. S: S   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
  j' l# I( c8 g, S<> }
public void process(){
        //处理动画的过程
  Graphics g=this.getGraphics();
# g3 y+ F# f% @. @. n4 @                g.setColor(end_color);
   for(int j=0;j&lt;Antcolony.EndPts;j++){
5 l  ^( Y$ f1 ]' {# r5 c* ~                  //画所有的食物点
* U9 F5 |# h. P% n. E9 B; }- J7 y7 T                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
( w& P) `- O8 u* V# L                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
- i5 p6 n8 K; e( R: A+ D                  //每只蚂蚁开始决策，并画蚂蚁
   Antcolony.ants.Process();
: J. Y; V& V1 r9 F. I6 n$ n   Antcolony.ants.Draw(g);
5 j; J: e* W- Y2 l& q' U  }
: C0 ^0 @4 r- a) N7 J4 X                for(int i=0;i&lt;Antcolony.phe.size();i++){
1 d2 z- p! P  v; L. T6 u5 u. B$ M* {                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
) u0 f! ^, `* ~                        //Antcolony的drawPhe变量标志是否画信息素
% o) Z) U# x! {6 F. J. M                        switch(Antcolony.drawPhe){
                        case (1):
5 U; U! C$ ]3 l8 g; y7 c                            v.Draw(g);
% O# }7 b- ~, d                            break;
/ I: [  Z! c9 ~# `& z' g                        case (2):
                            if(v.kind==1)v.Draw(g);
# q5 _' Z3 j* z                            break;
* G- G% ^# @0 Z( G1 S                        case (3):
4 k% m3 r! G9 n; s                            if(v.kind==0)v.Draw(g);
                            break;
                        }
! Z+ m9 U. s' g1 \0 v, q                        v.delimit(g);
                }
+ o# V3 m. ^9 @: S: |" @           g.setColor(origin_color);
+ N' m- E7 C7 D1 t9 K$ R                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
, @" `" N; u" L                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
+ L3 T) g0 o( E$ P                }</P>
<> }
Graphics GetGra() {</P>
<>  return this.getGraphics();
" ]0 B0 d: S% v% A }
}
* ?$ Y/ e3 q! d9 @) L8 T" v+ Jpublic class Antcolony extends Applet  implements Runnable  {
boolean isStandalone = false;//系统的参数，是否独立运行，不用管
, S& O& A1 @: T$ L5 v9 H* A Thread runner;//创建一个线程，让动画平滑的运行
6 O- i6 A, l8 v; V; t boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
0 Z- ?6 {8 X' T; M( P static Color OBS_COLOR=Color.red;//障碍物的颜色
4 ~  p1 Z! _$ P4 W/ L  w static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
: N0 ^8 n; t  D, P. b0 `. M static Color BACK_COLOR=Color.black;//背景色
$ V' ?, Z& P* |! }0 m; q& P. J static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
) L& K/ Q, T" i7 o6 j AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
3 @! Q$ c+ J! Q& |3 u static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
  [( f3 i  x  x3 @! b        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
static Point OriginPt[];//窝点信息
        static int OriginPts=1;//窝的个数，最大为100
3 X9 [) i* p; G2 t* ^( g! [ static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
        static int FoodR=10;//食物和窝产生梯度的信息素的半径
! b* m7 y& A6 z5 U7 [9 o static ant ants[];//蚂蚁数组
9 Z6 k. y2 U% l9 r9 U# E8 g        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
  \4 @; s0 D+ Y5 }<>        //下面是一些控件信息
4 f7 @4 O4 c2 E) e+ I" P        Button btnStart=new Button("开始");
        Button btnReset=new Button("重来");
        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
        Choice choPDraw=new Choice();
public void init() {
/ }: A' \- e' _7 V3 M                //初始化函数，先画各种控件
( c" t- V& s7 h4 s( h  setLayout(new BorderLayout());
                Panel pan=new Panel();
- B6 O$ F5 ]1 V- }2 C' n                add("South",pan);
1 d% o& Q+ i& c; j( Y& H1 x- m+ o                this.add("Center",canvas);
                pan.add(btnStart);
                pan.add(btnReset);
                pan.add(btnConfig);
                pan.add(btnMap);
' q+ A- n: [# V) x1 X7 |                pan.add(choPDraw);
, }8 q- o- `4 j1 E                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
& |/ W$ N. f( X5 t6 {) G                choPDraw.addItem("画食物信息素");
* x' `. \9 I6 ]                choPDraw.addItem("画窝的信息素");
& I, e& N5 ^/ L' s4 b                choPDraw.select(2);</P>
) p0 H3 N5 B7 m1 i<>                //初始化各个数组
: i3 E1 i9 E$ x  obs_grid=new int [width][height];
, x# N; r0 h9 D: @3 z2 U7 F) t$ q+ v                phe=new Vector();
                Pheromone_grid=new int [2][width][height];
3 H* D" J; {" [' N/ o: \. I, }                for(int i=0;i&lt;width;i++){
9 ?; T) y4 V  ^$ e9 s/ S! A9 _   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;
                                }
) Z' }  ?1 R' @6 x   }
5 i: F. H* u+ v6 c  }</P>
* v* a1 T+ R8 ^5 @9 V5 p4 R7 z3 T( ]<>   antCount=50;//蚂蚁个数缺省为50
5 J6 q- p/ d, W  U$ V4 r                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
& P; w/ C5 j2 l2 ]* ]& `1 [  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>
<>                //下面从地图库中加在地图
                Maps maps=new Maps();
                maps.LoadMap(grid,0);
/ L3 P8 }; S/ @6 T9 S* _                //初始化地图
                reinit_map(grid);</P>
6 m! U$ Y2 C' w( e; @- I<>                //初始化所有的蚂蚁
  reinit();
( x0 B" D: Z) a% `0 f: M& I1 J" s }
        public void reinit_map(int grid[][]){
9 I0 N- y0 C; s% g                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
  r0 @6 h9 k& u2 F: i) T  J                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
6 H; w, X* h3 m7 f. w5 ?( L<>                //先停止程序的运行
( \4 s6 Y0 c1 T! v                running=false;
- [$ P4 a, z8 O. R7 l# _. Z" I                btnStart.setLabel("开始");</P>
# A' Y# \  N5 b- D7 g4 v" H<>
                obsCount=0;
7 G: ]0 z/ e4 M                EndPts=0;
                OriginPts=0;
                obsP=new Point[width*height];
. i0 L+ _: u2 E5 x' O                OriginPt=new Point[100];
                EndPt=new Point[100];</P>
$ ~6 f/ r  e7 @. ~! _( E<>                //清空obs_grid和Pheromone两个数组中的值
( Y- y9 K% v4 x1 K. J                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
, g5 A) B  }  [                                }
   }
- v6 S% Y0 h; m# D4 B% Q# |0 ~  }</P>
! c7 I# n5 f( I, k1 E<>                //从grid数组中读取信息
                for(int i=0;i&lt;width;i++){
# O% a- E6 x( N! I8 Z' L                  for(int j=0;j&lt;height;j++){
                    switch (grid[j]){
                    case 1:
3 u* H5 F7 G% S5 f, C" \                      //如果grid[][]存的是障碍物
: L1 e8 ?, \8 y% J                      obs_grid[j]=obsCount;
0 ~, c; Z% e: t                      obsP[obsCount]=new Point(i,j);
( D- _8 \3 s# d% Z3 ]1 }                      obsCount++;
  F; G4 N% V$ i! ^: {                      break;
                    case 2:
. F/ j9 K2 U$ m4 ]$ [                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
' F4 y$ L" w% ]  ~7 e5 Q7 Y                      if(OriginPts&lt;100){
( [9 X. G9 m% m6 a; G% ?1 f' p8 Q                          OriginPt[OriginPts]=new Point(i,j);
5 [4 ^2 w( V; t# r- U1 ~, [! H0 h: w                          OriginPts++;
, f: Z/ [; f5 N  n2 f% R                      }
6 Q5 N# K4 y# a$ z                      break;
                    case 3:
) K, ^) [) l" j, ?& t6 A- ^% G                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
9 x" m! t* t4 n. y$ a4 D$ m                      }
                      break;
                    }
                  }
                }
            //如果没有指定窝，则随机的选择一点
" t5 C7 n9 o& F; d4 U& h            if(OriginPts==0){
              for(int i=0;i&lt;width;i++){
6 r' k0 _# W' _                int  j;
9 `- K' u- M. `& c2 M% ?                for(j=0;j&lt;height;j++){
! F" H6 s' J2 [$ M, v5 ]                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
$ X8 n9 p0 k% g1 o1 ]                    OriginPts++;
" N0 {) ~: f9 ^$ c4 o                    break;
                  }
. O6 V3 a* h& D4 Z                }
                if(j&lt;height-1){
* @% G+ Y4 s- S. [: y4 y- Y                  break;
                }
              }
            }
        }
public void reinit(){
6 F: d" P4 X1 a' i4 e% ?. |5 b% R                //重新初始化整个环境</P>
# O2 [5 W1 `5 ~) {" d9 X- l3 ?<>                //先停止程序的运行
+ V% A4 [8 d; U6 ]* N$ {                running=false;
! W# g5 ]9 N% Z1 f8 @                btnStart.setLabel("开始");</P>
* _: G$ o- ]) i3 M9 K+ @  h<>
  f( w6 r+ `$ M# c% R9 d  //清空所有信息素Pheromone数组中的值
                for(int i=0;i&lt;width;i++){
9 q4 i4 B% Q0 o/ n* {# T7 w# d   for(int j=0;j&lt;height;j++){
3 e# e) G9 p- ]5 Y  p& R                                for(int k=0;k&lt;2;k++){
' m$ F8 d' w, M) e6 {7 m                                  Pheromone_grid[k][j]=0;
                                }
   }
1 x" m# P6 Y+ A" v  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
: J% h7 l+ \3 D4 Q6 l        for(int i=0;i&lt;antCount;i++){
& G: b3 ~: W/ ~# F( D4 a+ P, P                        int index=(int)(OriginPts*Math.random());
" ]4 [' |: q! x# Y7 o          ants.OriginPt=new Point(OriginPt[index]);
  X& F' E! J0 d  S! u                        ants.init();
  }</P>
; h1 r4 K4 [2 b- a$ L/ N9 `( B<>                //清空信息素向量
( i, T  G0 Q' L5 Z& K                phe.removeAllElements();</P>
" E% h' s$ _3 D" Z4 c<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
  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));
" t' Y: Q% j' Z! P6 G' L! i                        for(int yy=-y;yy&lt;=y;yy++){
  J& S# N  B$ B; v  G                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
- ]& `, {& D( u# C  S                        }
; s4 F; B9 z$ s8 `7 W# N/ M5 d. J+ A                    }
                }
* T. d) U& O3 M" \                for(int i=0;i&lt;OriginPts;i++){
; _# [! a1 y; |$ `* y                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
: O3 d+ _. x0 b" W1 M                        for(int yy=-y;yy&lt;=y;yy++){
/ X1 b+ K; |% T6 |  S                            Pheromone_grid[0][(OriginPt.x+x+width)%width][(OriginPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
                        }
' L& {; X* `4 t- [" h: X                    }
4 J$ O! c, D$ V3 A3 q, c                }</P>
<P>                //重画
3 t+ E: x) w/ ~/ @4 q6 P* \  canvas.repaint();</P>
<P>                //让程序开始运行
0 R. y4 I/ N8 O+ j7 H6 k( x: n                //running=true;
$ `% k, m  l- G: I# F }
3 Q) g- l" D  B8 t/ \ public void paint(Graphics g) {
  canvas.repaint();
/ r7 a" l$ r) R% ^" B }</P>
<P>
public static void main(String[] args) {
" \1 O3 \. y7 P+ @7 b) b3 g    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
    Frame frame;
    frame = new Frame() {
9 \( f1 I$ J% O; B% G6 O4 r      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
" ]  o; |$ K+ w' P" z        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
$ t( y: |0 G0 |+ L6 m+ d( E          System.exit(0);
& z. a* B3 K. v$ f- S! [        }
  d3 _1 M* z, m0 v# [      }
$ [$ _6 A" _+ \% ~      public synchronized void setTitle(String title) {
7 ]+ D0 m# q7 A4 _5 Y4 I        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
& z7 n: A4 R. r    };
    frame.setTitle("Applet Frame");
    frame.add(applet, BorderLayout.CENTER);
' b0 r+ M2 ~+ ]. A7 f0 d! O    applet.init();
+ n6 p7 u, I: h2 P( D" b    applet.start();
    frame.setSize(300,320);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
" r2 k" i" L" W    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
    frame.setVisible(true);
  }
& ]/ h0 ]) Y* R0 l" `& E  public void start()
  //下面三个函数是控制线程的
{
  if (runner == null)
. L7 C5 ^. A* C0 q; D8 |  {
8 W; d( ], e: e   runner= new Thread(this);
   runner.start();
   //running = true;
7 t! E  |' _6 h9 [  }
0 i$ T% w- a4 c5 j }</P>
<P> public void stop()
* _9 ?3 b  a8 |; b' v- F {
0 @/ l4 A6 M4 w2 q7 q3 q  if (runner!=null)
" X, {6 E3 x% g% I( E3 O  {
   runner.stop();
   runner=null;
$ t" A! Q* K6 w* i" I   running = false;
  }
4 ~9 y! w, K5 r }</P>
<P> public void run() {</P>
<P>  int i;
                //线程一直运行下去
1 T' o2 v' s! g3 k  while (true) {
) V9 Y: B0 K' T- p# k- H8 z          if(running){
, k7 |, x& ^7 t1 Q* [       //如果开始动画，就进行canvas的处理
1 x* |- z4 N6 R1 u) T                          canvas.process();
& r* L9 Z: D3 m& m: t                        }
    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
   }
  }</P>
<P> }
        public boolean action(Event evt, Object o) {
$ x' m  o' f1 D  v8 I2 v      if (evt.target == btnMap) {
% F8 j; I! Z% x. M1 ]' j+ `6 U                //开始编辑地图面板
. J, i( d" v: y( ~% I: i, L   running=false;
6 P/ L4 E# q8 J1 S6 E; i. W: s                        btnStart.setLabel("开始");
# L2 }( N. I- t! n   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
                        ctl.show();
4 u3 z) U0 Z7 d! F                        return true;
  }else if(evt.target == btnStart){
                  if(!running){
6 l3 O( l0 t! }+ C: Y                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
                    btnStart.setLabel("停止");
2 B8 M* e( {% M3 l# @                    reset=false;
                    running=true;
                  }else{
                    btnStart.setLabel("开始");
# d- q! M+ j0 o* O( U                    running=false;
; ?0 B/ O' X. H8 _# T                  }
% K" i7 s# C  O0 i# j" r  k8 M& r                  return true;
6 Z4 g# r2 ^' _- i, |6 a" N, x                }else if(evt.target == btnReset){
. B3 E5 R0 n, {8 E3 I                  running=false;
$ w8 Z4 y" v8 f$ w5 D                  int j=0;
                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
                  repaint();
3 J! F# e( [. N& w+ w. o$ v                  btnStart.setLabel("开始");
8 B7 v0 D6 U2 e* s2 D2 k; \; ]" L8 [                  return true;
. M9 Y2 t" Q+ P                }else if(evt.target == btnConfig){
                        running=false;
* a3 S' I* ^8 @0 ]0 n                        btnStart.setLabel("开始");
     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
5 s( V" S0 i8 E$ y$ L( h                        ctl.show();
) h% {. M. v5 _! w8 l) o& D7 ~                        return true;
                }else if(evt.target == choPDraw){
                  //选择画信息素的模式
/ }8 q5 T4 N5 p/ ]1 V, p                  drawPhe=choPDraw.getSelectedIndex();
                  if(drawPhe!=1){canvas.repaint();}
/ P% i+ P; q5 [1 [9 H: X* f                  return true;
                }
" N+ L; [2 d8 h/ ~( M$ r( ?) r                return false;</P>
: W; v8 J7 H% X' B9 O<P>        }
3 A5 p; }: f' Z) [ /**Destroy the applet*/
. r2 @: K1 r8 A, N* k/ n  public void destroy() {
3 r1 t" @6 J* y8 L' s  //当结束程序的时候，把线程也结束
    if (runner!=null)
    {
       running = false;
  V1 b& Y2 o' _& g" Z# ]) P; c4 h       runner.stop();
       runner=null;
    }
/ u6 q; E) N8 J9 \0 {- z  }</P>
5 q! q9 B$ g  }) G" H<P>}
</P>

7 l. s4 A3 Q. t8 m) k

) [+ G0 n1 ?; H, ]<P>package ant;
  @* r- J  ~$ Y% }import java.awt.*;
import java.applet.*;
' Z, \4 @2 C1 c& f% t. P7 timport java.util.Vector;</P>
<P>public class ant{
: ~0 R3 N2 Z+ F8 A6 K Point nowPt;//当前点坐标
0 t7 j; i6 ]# E int VR;//速度，每次蚂蚁能走动的最大长度
  int id;//标识
  Point lastPt;//上一点坐标
Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
int height,width;//世界的尺寸
* b1 O& B5 R6 w) P, O- a( f8 ~        int Phe;//每次释放信息素的数值
5 `7 ^' g6 P% m6 c4 c Antcolony local_colony;//主程序的指针
. u2 k' J! b) S/ u& c4 |1 z        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
        double Main_direct;//主方向
        Point FoodPt;//记录的食物点，是否找到时候判断用
8 A1 N4 c  L2 C        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
; }% [* e9 C0 f4 W' n/ h. p        Point StartPt;//起始点，是窝或者食物
: i* W4 q  b& D& ?' ~        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
2 Z: q& r8 ?* @$ F0 R        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
, ]5 c% Y5 |$ y- p6 S+ X        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
0 X! r) i( q; ^! ?- y        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
! P5 D  m5 V- q- ?$ M: X# m+ k public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
  nowPt=new Point(nowpt.x,nowpt.y);
( O+ M$ m! |' d1 Z                OriginPt=new Point(nowpt.x,nowpt.y);
0 U2 X- `6 M" \, H                FoodPt=new Point(nowpt.x,nowpt.y);
& Z% }1 `, O$ ^3 e1 P) D                StartPt=new Point(nowpt);
  E/ m4 V& {4 p. N2 D% U                AimPt=new Point(nowpt);
- @% e$ W1 }1 N4 @2 C                lastPt=nowPt;
  VR=vr;
( y! r; q% J1 A) t' y  id=idd;
  color=c;
8 ~$ b& b! i+ M. Z  back_color=Antcolony.BACK_COLOR;
  height=Antcolony.height;
  width=Antcolony.width;
7 M) C7 V- F8 Z9 z" Z% ], q  local_colony=colony;
                Phe=200;
3 V$ M7 L6 }. z/ D& m                mistake=mist;
) n" u) C  Z  i                HistoryPoint=new Vector();
                Main_direct=-1;
/ l7 V. ?. u( q+ w$ I                FoundTimes=0;
$ ^( n  C: U! I6 ^: Y7 K% |                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
                memory=mem;
1 F% r, {0 s9 L" A$ A8 m                Count_distance=0;
                Min_distance=-1;
}
3 S7 J8 v6 h$ N        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
- O, z6 E5 J( n; ?9 N7 ~+ x          AimPt=new Point(OriginPt);
- ?! _' P; o. l; F- K( c          StartPt=new Point(OriginPt);
          HistoryPoint.removeAllElements();
0 w7 }9 |) Q5 }& R& s+ d1 S( k          Main_direct=-1;
          FoundTimes=0;
& X: Q% b5 Y: V9 ^$ R4 r& ~          Pheromone_count=Max_Pheromone;
          Count_distance=0;
8 y. l  }; F" E9 n& |, I: N- l! ]          Min_distance=-1;
        }
7 @. \- D: E  J* s6 {' R- ` public void Draw(Graphics g) {
          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
! o/ A( U) V1 [. m0 O* Y  g.setColor(back_color);
  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
, j* _- Z; g/ \% |7 u: D9 G  g.setColor(color);
  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
}
public void Process(){
        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
. y2 y. m! r0 V, g0 Q( Y& I        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
2 G& [! X6 P( B# ~        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>
4 @2 O' e& `9 u& V6 o
7 W3 j) a) ^* L+ Z% c4 ~/ {8 u1 ?<P>        if(Judged==false){
) Y3 E' r9 ~5 x" |9 c          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
* t/ p, M8 G# U2 W          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
. J& D/ b8 V' H  f              //判断，如果找到了目标点那么就退出该程序
8 h8 z% d- c& \! R5 B, r8 t5 o7 h; a              Judged=true;
5 t/ r6 ~  r0 I: g  a              return;
7 }2 K8 \7 M# N% l' R$ `8 R          }
        }
8 r) A- K- N. X        Judged=false;
& N9 B4 P/ q+ Z2 m& o8 ~: k        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
) r5 g2 o* D2 V4 l        double direct=SelectDirect();</P>
; ~: r) F& K5 _% R9 O5 |<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
0 s3 q, ^4 O/ n" g/ e        //direct是方向角，根据方向计算位移
" w* f+ O+ f. V) F        deltx=(int)(VR*Math.cos(direct));
        delty=(int)(VR*Math.sin(direct));</P>
, b& f( T1 j# x2 c1 R; @; U<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
/ F% [) t, Z! U        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
<P>        //记录搜索的环境中找到的最大的信息素
        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
% p3 _3 Z  {" u/ i4 m& G: ?) r4 n          for(int x=-VR;x&lt;=VR;x++){
             for(int y=-VR;y&lt;=VR;y++){
9 k4 N  F$ V) ]/ P" o) @3 k' {                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
$ D7 Z' B5 [* N2 C. a$ V5 T                //在这个程序中，坐标是循环的，也就是在一个球面上
, Q) z" [% ?/ K) L1 m! L% Q                int xx=(nowPt.x+x+width)%width;
                int yy=(nowPt.y+y+height)%height;</P>
. T) W1 o# v, m6 A3 C<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
; h/ ~4 Z; k5 z. y+ ?/ ~& @; F                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
3 b2 |7 Y; j4 H% y<P>                  //如果搜索点的信息素比已经找到过的信息素多
/ E6 }, c1 |7 M6 g: Y4 @                  if(maxphe&lt;phe){</P>
<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
                          boolean found=false;
, {! x9 r+ ~5 c5 S$ C, M                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
                          int minsize=memory;
+ U& `. ]4 o: k                          if(size&lt;memory)minsize=size;
( I, l! w" P3 _3 w+ k! R                          for(int i=size-1;i&gt;=size-minsize;i--){
                             Point pt=(Point)(HistoryPoint.elementAt(i));
                             if(pt.x==xx&amp;&amp;pt.y==yy){
+ L8 A3 B) c$ Q1 b9 }- ]                                found=true;
# I& _$ C1 f4 O. P8 k1 T  u2 T* s                                break;
; D5 G  }# m# z" I& y: a( z                             }
                          }
                          if(!found){
, t/ m0 x; h, N( x  ?" ^                            //如果没有原地转圈，那么记录信息素。
                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
" ]5 n2 F: D5 P1 R/ R: \                            deltx=x;
                            delty=y;
                          }
                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
1 e0 N8 ~3 w1 w+ M                }//end if x!=0
            }//end for y
1 M) B  G& @& b! O4 s1 y9 B        }//end for x
. A2 N. ~2 S, O; N( q1 n6 A        Point pt;</P>
( Q+ Q7 J3 }8 {0 C/ c<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
        pt=Evade_obs(deltx,delty);</P>
$ Q% t0 F, o2 v$ {<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
- y$ e" [/ G0 D1 K0 U8 _        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
          pt=Evade_obs(deltx1,delty1);
' w& i* O' H3 n3 f( f( l1 }        }</P>
( l% v; x& q( g6 g9 \<P>        //播撒信息素
        Scatter();</P>
<P>        //记录走过的距离
# L8 N! B2 S/ a: e0 o        Count_distance+=Distance(lastPt,nowPt);</P>
<P>        //改变当前点位置
3 J/ M; L7 k* i% o* V' M        lastPt=new Point(nowPt.x,nowPt.y);</P>
<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
        if(HistoryPoint.size()&gt;memory){
          HistoryPoint.removeElementAt(0);
7 y( t/ X, s0 q        }
        nowPt=new Point(pt.x,pt.y);
     }</P>
9 a1 [* U6 |1 l3 B<P>
        private void Scatter(){
( e% O& E8 m% l4 Z        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
, {" M5 t' B( x. h        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
            if(Pheromone_count&lt;=0)return;
. r& J4 b0 Q/ i# s2 p* C9 y            //决定释放信息素的种类
% q, c& A5 V+ }7 @1 K5 k! r" n            int kind=FoundTimes%2;</P>
<P>            //获得当前点环境已有信息素的值
% b1 B; b. x! |: m: A4 L            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
% E4 `+ q) `) t( n, `) V% ^6 y& }# o            boolean ofound=false;
* L* E7 C8 Q8 F, F7 U1 ~, E) h" S8 u1 P            if(Phec!=0){
                //如果当前点已经有信息素了
# f! D) D7 b3 |% _- u                for(int i=0;i&lt;local_colony.phe.size();i++){
$ w2 G& U, h2 [5 p2 D: R0 x' @                    //在信息素向量中查找该点的信息
                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
" f  S& R. a  E2 t5 `) ]                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
                        ofound=true;
                        boolean found=false;
                        if(size&gt;4){
' k; T, a- E) W! _% k% H8 K                           for(int j=size-4;j&lt;size-1;j++){
                              Point pt=(Point)(HistoryPoint.elementAt(j));
6 X, h! ~: S& g! i0 I$ X' d                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
                                //如果当前点重复了以前走过的路，就不释放
) j5 ^. e5 G, S                                found=true;
" ^: `  G" o( A                                break;
                              }
1 V5 [7 [1 v! Y. G; f                            }
                        }
0 b  |- p- D. u) j& c                        if(!found){
0 C: `7 M) Z# z: \  _                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
( V( S6 G4 l( v3 [<P>                             //让还剩下的信息素总量减少
9 L! v; k6 B3 D2 f3 x! j) Z0 U                             Pheromone_count-=Phe;
                        }
                        break;
. v% S$ a0 J; G2 s+ h& _; r                    }
                }
              }
          if(Phec==0||!ofound){
9 d9 D+ ~9 d% R6 A            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
- T1 k7 Z+ t, h4 N                ph.Add(Phe);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
: o# Q- J/ p  L1 m                local_colony.phe.addElement(ph);
                //让还剩下的信息素总量减少
3 u1 g! x$ ~. `; w0 e* Z# Z                 Pheromone_count-=Phe;
+ e& D" ^- p' \5 m' H* c           }</P>
<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
  k6 a6 o' H# J* g* [           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
8 E0 y, k1 t2 f: F, [  O           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
& {: ?0 m0 y7 B           //这个模型是否科学？有待研究
/ y4 }9 {$ J2 z0 B* z           Phe=(int)(0.005*Pheromone_count);</P>
1 C, n3 E2 L* ?" B( I8 h<P>           //如果剩余信息素已经太小了，则按照等差数列递减
7 F% P: ^# R8 x# O+ J           if(Phe&lt;=10)Phe=10;
        }
& L' B& ~$ t7 g6 lprivate boolean JudgeEnd(){
    //这个函数判断是否已经找到了目标点
    //首先获得当前蚂蚁是正在找窝还是在找食物。
    int kind=FoundTimes%2;
% P1 A  C; v$ U    if(kind==0){
/ ~. Y, V8 S$ [0 p" D        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
        int i;
8 ^* M3 I) j" W0 `# e  m9 ^2 r1 ]        for(i=0;i&lt;local_colony.EndPts;i++){
            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
; W! E( j9 b1 `              //如果找到了食物，就直接移动到食物点
1 m& G# ?7 L2 N; w( o) D* W              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
$ F) L9 k3 \2 o0 o2 z3 G0 i! |              nowPt.y=local_colony.EndPt.y;</P>
8 u' y- V, M% c6 V" ?6 I: c<P>              //计算最后的总距离
/ k  d, m8 L# L. A/ \              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
              }
' p* y. m+ E. [  S8 y# E7 m              //清除总距离记录
+ j. g+ o' M+ w6 E9 c              Count_distance=0;</P>
- o' N: s3 n# n( a, W5 T, _<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
              AimPt=new Point(OriginPt);
              StartPt=new Point(nowPt);
& t# G8 w4 h. V- P1 p; h; b              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
7 v, ]$ I$ ]+ k<P>              //找到了食物就把找到次数+1
: r1 Q3 z; `) v/ g              FoundTimes++;</P>
' ~$ O1 w3 R, E  ?<P>              //改变主方向为原来方向的镜面反方向
. }9 ^2 g- B2 x; a              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>              //重新把自己能撒的信息素置为最大值
              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
. H( L$ j1 V3 g# `1 y4 h& @$ o<P>              //返回找到为真
              return true;
            }
) F3 C5 {5 y+ a7 L. n        }
      //否则没找到
% x' A2 Q& A/ M      return false;
7 s% ~9 m9 R$ b: ?* O3 t    }
1 E* z1 ^! k9 w8 K    if(kind==1){
        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
        if(Distance(nowPt,AimPt)&lt;=VR){
3 b) G8 S# J1 x" C- i9 \            lastPt=new Point(nowPt.x,nowPt.y);
- H$ D6 e- e4 E            //如果找到了目标，就直接移动到目标点
; O" @/ f1 p1 W* I6 S7 T: t6 Y            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
& U8 |; l. W4 k' r4 R- A9 S<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
/ q, t) _; x' D                  Min_distance=Count_distance;
3 ?$ f4 ^! V( R% b. A              }
              //清除总距离记录
              Count_distance=0;
  m; I- ~" b; [/ \: ~9 p            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
' r" Q" i7 U  c- h2 q4 X            StartPt=new Point(OriginPt);</P>
. J$ e7 z5 j- U8 {$ k<P>            //重新置信息素
6 G+ r& v+ Z( B! k6 v            Pheromone_count=Max_Pheromone;</P>
+ j, D$ ~4 l3 I/ Z<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
6 m& m4 F9 [8 W8 H3 n<P>            //主方向反向
. c; F# F4 C! x; E6 }- m            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>            //找到次数+1
            FoundTimes++;
            return true;
        }
# M2 J, a; @. i7 i6 L7 h" ?; k+ E        return false;
    }
. _( u& b6 p/ t( \    return false;
}
        private double SelectDirect(){
+ `- _  ]- L3 }& B                //选择方向，最后选择的方向为主方向加一个随机扰动
4 q  t4 Y  e/ p# K' k# o4 R. g                double direct,e=0;
                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
        e=2*Math.PI*Math.random();
                      Main_direct=e;
                }
                //选择主方向角
                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
- m- @( L) m# J- J                double re=Math.random();
                double re1=Math.random();
0 M* o" W$ x# ^3 V$ V  X                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
- [6 Y4 q) j0 H; v, A. h! x                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
( Q: D: S9 @" Z/ ~  _1 G- L, Y                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
3 E' J$ K$ {2 p9 c2 `- b/ w/ m                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
/ b1 Q) F8 ^+ a# c                       Main_direct=GetDirection(pt,nowPt);
/ z) H4 u- r* @' m4 y* E" w% g                    }
                  }
3 {+ R3 I4 u2 k6 E                }
: s& S+ ~8 b( F0 l* N' a& t               return direct;</P>
<P>        }
        private Point Evade_obs(int deltx,int delty){
              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
- S1 J6 P: U  e0 U' l              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
  f, N" ]2 A; j0 g# F              //p1,p2在这里分别是nowPt和nowPt+delt
              Point pt=new Point(0,0);
              int x,y;
1 Z/ @( I, I4 J/ s9 t$ V              int delt=deltx;
7 P: q; ~: Z7 T/ w; X7 }' P              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;
                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
2 ~+ q9 C* B- _<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
* G/ \0 @& y' z4 Q5 G" K5 V                     //新目标点为障碍物前方的点，主方向随机取值
8 k" j1 f, t  h* K/ V( d                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
# T, m7 ^& R4 g! d                     double disturb=4*Math.PI*(Math.random()-0.5);
                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
3 o. \  Z9 a' Z/ s/ [5 U3 p                     break;
                  }
                  pt=new Point(x,y);
                }</P>
<P>                //计算得出实际能够到达的目标点
  x=(nowPt.x+deltx+width)%width;
- a+ ?/ G# M& N: x8 @4 S3 x  y=(nowPt.y+delty+height)%height;
+ z4 F9 M$ w! i         return new Point(x,y);
        }
        private double GetDirection(Point pt1,Point pt2){
$ Q" W- ~& W; Q+ S        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
4 V5 A2 N1 x5 ^# g# p* o* r, f        //其中方向角是所有可能的角中使得两点连线距离最短的角。
; x# y/ \# A, s$ M, c% |               double e;
; K7 t8 r) ?0 l, L3 p  S               int deltx1=pt2.x-pt1.x;
               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
; Q3 W6 Z7 z/ z) W4 X               else deltx2=pt2.x+width-pt1.x;
               int delty1=pt2.y-pt1.y;
               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
               else delty2=pt2.y+height-pt1.y;
- y0 B8 j+ s( x5 c( C8 m               int deltx=deltx1,delty=delty1;
               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
               }
  f( |6 V& `' Q        if(Math.abs(delty2)&lt;Math.abs(delty1)){
                  delty=delty2;
               }
               if(deltx!=0){
                    e=Math.atan((double)(delty)/(double)(deltx));
                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
% y, [3 ~6 n1 _  S* z- L                       else e=e+Math.PI;
                    }
                }else{
# a  S" U6 W9 G4 w* W                    if(delty&gt;0)e=Math.PI/2;
                    else e=-Math.PI/2;
                }
- G, Z' Y" A$ V* b# _$ m- @7 y                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
        }
( \0 S4 S& U2 p4 ~( ~) }% Z% O  \        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
0 D% e( X  W' t. H3 @. B            int dx1=pt1.x-pt2.x;
  W# ^: J% m4 d1 x$ t            int dx2;
0 D  [$ H/ v% G% t+ a            int dx,dy;
/ o, E6 O+ o- P1 o! D0 ]" v* k+ F            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
            else dx2=pt2.x+width-pt1.x;
: X3 j7 X6 M2 E, W4 ^4 T$ o            int dy1=pt1.y-pt2.y;
+ w7 {2 u1 e" z8 c5 I, G; V            int dy2;
            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
# q( D8 @. }  y9 n, }+ \            dy2=pt2.y+height-pt1.y;
! ~. r7 z# |' Y* T: j" Y6 I: B! ~            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
            else dx=dx2;
            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
  l9 ~! L/ q4 I2 ^2 u4 `0 Z            else dy=dy2;
8 j3 N7 n: ?' c* v" q) b: K            return Math.sqrt(dx*dx+dy*dy);
        }
0 b+ `8 l+ J( W) _  `) I0 Q    public void clone(ant ant1){
        //把蚂蚁ant1的属性拷贝到本蚂蚁
8 O0 b& _* ]9 R) n- w     nowPt=new Point(ant1.nowPt);
        OriginPt=new Point(ant1.OriginPt);
        FoodPt=new Point(ant1.FoodPt);
8 V# S* ^- @/ l9 n' G9 F2 K1 N* Z        StartPt=new Point(ant1.StartPt);
" F) m4 H% t6 P) E) ~        AimPt=new Point(ant1.AimPt);
        lastPt=new Point(ant1.lastPt);
; g" x9 b$ ?0 u/ w        VR=ant1.VR;
6 k3 @9 w, |1 v) G- _# y        id=ant1.id;
        color=ant1.color;
# e( ^  k9 X$ ~        back_color=ant1.back_color;
        height=ant1.height;
( ~- K$ V8 d) B0 s9 |! L. }        width=ant1.width;
        local_colony=ant1.local_colony;
& b, g9 s4 Y  w% @8 z1 P        Phe=ant1.Phe;
! H; ]. H3 g* _; o3 ~        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
; a1 i: A5 j' j! ~( m7 R        FoundTimes=ant1.FoundTimes;
% h, y0 j+ l/ l0 g  j' }3 @) b        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
: Y) ^# O1 K$ Z0 D3 L$ X! O        memory=ant1.memory;
        Count_distance=ant1.Count_distance;
        Min_distance=ant1.Min_distance;
    }
1 X3 x" {' D# L}</P>