[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
<>package ant;
/*
4 R$ \% k" b' G3 Z * @(#)Antcolony.java 1.0 03/05/22
*
9 D' D4 H7 w  v6 j* d" p * You can modify the template of this file in the
* directory ..\JCreator\Templates\Template_2\Project_Name.java
/ \. t* T# {$ v2 h8 i *
4 v: d" A" Q# D5 u8 s4 l1 v * You can also create your own project template by making a new
* folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
% B* ^; Y5 b* _) u3 \. \! v5 U$ g8 R *
# R) g0 y6 V4 V$ t! ? */</P>
<>import java.awt.*;
import java.applet.*;
# y5 ^# ], w: ?  ]( ?import java.awt.event.*;
5 H  i  i  j' Z) M8 A0 l  `* k) nimport java.util.Vector;</P>
' G* [1 m1 e( O<>class AntCanvas extends Canvas
; t% f. b' s, K7 }0 F# B5 r5 Z{
    //画布，一切画图操作均由该类完成
4 D) J) i: Q, d7 [1 V //Image image;
Color obs_color;//障碍物颜色
% K1 |- E9 w8 ]$ E Color origin_color;//我的颜色
4 z/ O9 n& v% s# V0 a9 \ Color back_color;//背景色
        Color end_color;//食物点的颜色
//boolean first;
9 s3 Y- A9 S' @; u boolean reset;</P>
<>/* public AntCanvas(Image img) {</P>
8 P/ r# _8 O3 l# u$ w/ y<>  super();
   image = img;
9 w6 B  K) x( k- Z1 X" \* w  obs_color = Color.white;
* B9 N0 W) g) }: @- B" n  setBackground(Color.black);
  setForeground(Color.white);
  first = true;
/ q- s0 ~) _. T" Y$ S' H5 q% `+ Z  reset = false;</P>
<> }*/</P>
<> public AntCanvas() {</P>
! l) ~/ `2 a. j5 p+ _<>  super();
   //image = null;
  D' A$ f; G/ P2 \, Q: h   back_color=Antcolony.BACK_COLOR;
  setBackground(back_color);
8 w7 c2 g& A; F- ~* r* U  setForeground(Color.white);
  obs_color = Antcolony.OBS_COLOR;
  origin_color=Antcolony.ORIGIN_COLOR;
5 X& e  C0 O" z; t" ?                end_color=Antcolony.End_COLOR;
  //first = true;
$ _- C# A. S! ^' j4 U+ B. p" U  reset = true;</P>
<> }</P>
  Z8 t! h7 O% M<> public void Clear() {
        //清空画布
- M  K& I0 w. U9 O( @' q  reset = true;
/ Z! V# v) L& d$ J/ J" S: j9 @  repaint();
}</P>
7 i; R5 K; w$ u8 w<>
8 j" F" x8 }& A5 ?. [2 o7 \) D public void paint(Graphics g) {
1 Y1 w, k% y% N9 `' I" W7 D2 \; G  int i;
                //重画的时候仅仅画障碍物
/ Q( l" e' q- ]0 p2 N0 h  g.setColor(Color.black);
1 S% k# k( R& Z! H* e  g.fillRect(0,0,size().width,size().height);
* f" z+ p! s/ u/ j. K  g.setColor(obs_color);
  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
  }</P>
<> }
public void process(){
; @( V7 T8 [% N+ _8 d7 A; [        //处理动画的过程
& H  N) c4 W! [; j  _, x  Graphics g=this.getGraphics();
  ~) u7 a/ K! T3 [" i7 e5 D                g.setColor(end_color);
   for(int j=0;j&lt;Antcolony.EndPts;j++){
, }, V9 |4 {) y7 |: U3 b                  //画所有的食物点
                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
5 C3 x$ M: w; I  g. Z7 o                }
                for(int i=0;i&lt;Antcolony.antCount;i++){
                  //每只蚂蚁开始决策，并画蚂蚁
. H. @7 K- E! Z" w4 j; M) g- v4 @   Antcolony.ants.Process();
9 s4 W- b! h' i' I. @* s   Antcolony.ants.Draw(g);
6 a5 j% m  D% `1 j# s" s  {8 P) Z% K  }
3 I5 r+ ]5 R: y* ]                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
                        //Antcolony的drawPhe变量标志是否画信息素
4 r  X  Z- m; \                        switch(Antcolony.drawPhe){
7 F1 A/ u5 K4 d" g) m9 F                        case (1):
                            v.Draw(g);
, B6 \9 n, v3 D1 M                            break;
2 b1 I6 @( i% u9 J* E% D% l                        case (2):
                            if(v.kind==1)v.Draw(g);
) a& K+ _0 V4 J( E                            break;
" i8 B  D6 D1 O8 T8 n/ E                        case (3):
8 \% M, F" u3 J7 J$ I3 h( `" a                            if(v.kind==0)v.Draw(g);
. t7 |4 g7 i& h2 I4 b9 F: q                            break;
, T! Z! p  z% ^                        }
                        v.delimit(g);
                }
7 X! n  K8 q+ v0 I3 y" O7 {           g.setColor(origin_color);
7 R+ ?" X+ k" [- E                for(int i=0;i&lt;Antcolony.OriginPts;i++){
5 H" e8 }8 p/ q4 S- }$ I                  //画所有的窝
                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
9 l% i" K( \5 Q                }</P>
<> }
  n! K2 [3 G) H/ O  { Graphics GetGra() {</P>
<>  return this.getGraphics();
}
9 e$ g& \, j) b1 x, r* e}
public class Antcolony extends Applet  implements Runnable  {
" o6 k7 O% n# g3 Q6 H  A' O8 t boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
static Color OBS_COLOR=Color.red;//障碍物的颜色
static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
; U# a6 T* B/ n5 l: e static Color BACK_COLOR=Color.black;//背景色
( ]# M% G. \/ x4 H% t# z static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
  Q3 J' i& W' d2 x, a$ }1 Y2 g& S2 h AntCanvas canvas=new AntCanvas();//画图用的画布
2 Y, P3 F8 A5 O  l. ?% y" k int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
! Z6 i9 k0 d& Y* M: R0 L% O, D) ~        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
$ t8 w7 Z: X' o0 k" A. |3 {6 k static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
& R+ a+ j1 C6 W0 k$ n! G* F        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
7 E' E- Z+ z! I5 ]        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
2 o+ m& L  X6 o, y$ f3 A static Point OriginPt[];//窝点信息
        static int OriginPts=1;//窝的个数，最大为100
static int width=300,height=300;//环境的长和宽
& f1 T* K# E3 A, g$ A3 B" l( o static int antCount;//蚂蚁的数量
        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
        static int FoodR=10;//食物和窝产生梯度的信息素的半径
. y+ G& i8 O3 ~7 L2 O9 j static ant ants[];//蚂蚁数组
' ]# c) k4 E+ v: U        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
5 q) m/ L' e' v* c int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
$ w: A+ h9 R6 C8 P; ^, i<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
        Button btnReset=new Button("重来");
  t$ W* t' M" e- X7 {  Z7 F        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
+ ~# U1 e  a: _; N; J4 ]: F        Choice choPDraw=new Choice();
public void init() {
) R: ?9 o5 e. W* p                //初始化函数，先画各种控件
7 q/ f, }1 ]% }3 ?# P) `  setLayout(new BorderLayout());
# C( c% g' f% i+ }" q% e( S                Panel pan=new Panel();
                add("South",pan);
                this.add("Center",canvas);
                pan.add(btnStart);
                pan.add(btnReset);
                pan.add(btnConfig);
                pan.add(btnMap);
                pan.add(choPDraw);
% r3 i8 e( b$ {3 m2 n/ C0 ~                choPDraw.addItem("不画信息素");
: R" q9 h7 R4 W                choPDraw.addItem("画所有信息素");
                choPDraw.addItem("画食物信息素");
                choPDraw.addItem("画窝的信息素");
7 h! q! G% M4 Z$ a2 t! I                choPDraw.select(2);</P>
<>                //初始化各个数组
  obs_grid=new int [width][height];
9 }+ k. f2 S9 `. {                phe=new Vector();
5 V6 @0 |/ C/ d: ]. E; S, @                Pheromone_grid=new int [2][width][height];
' l2 K* a- @$ n* U' L. H3 c                for(int i=0;i&lt;width;i++){
7 d& a% G& R& A+ n' ^0 g( t   for(int j=0;j&lt;height;j++){
5 X$ @6 T" C3 @4 k% H0 J# E    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
   }
  }</P>
8 {  Y4 L. k8 F1 D& q<>   antCount=50;//蚂蚁个数缺省为50
                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
  ants=new ant[antCount];
9 X' P2 {7 f4 @* P+ n        for(int i=0;i&lt;antCount;i++){
& h5 U* _! D! A' n) @' i          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
4 T) z8 B# l: F  }</P>
7 e/ [' Y8 m5 y# w% o) R8 @<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
                int grid[][]=new int[width][height];</P>
<>                //下面从地图库中加在地图
                Maps maps=new Maps();
                maps.LoadMap(grid,0);
                //初始化地图
                reinit_map(grid);</P>
<>                //初始化所有的蚂蚁
  reinit();
, C2 H2 a/ U. n6 p! x }
! S6 s2 m' N5 T( d6 D        public void reinit_map(int grid[][]){
5 E+ m4 P4 }# i  [" v  T4 N5 K+ k                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
. u" Z! ]4 g/ j                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
+ i6 G  Q% c& w  D: Y<>                //先停止程序的运行
                running=false;
) q9 v) {% M2 {5 g                btnStart.setLabel("开始");</P>
<>
0 r$ h! \' ]' G; P                obsCount=0;
: Q6 Y; q: N* [! Z7 o. K                EndPts=0;
                OriginPts=0;
9 d, [/ D. i+ r$ e7 p4 R' c                obsP=new Point[width*height];
                OriginPt=new Point[100];
                EndPt=new Point[100];</P>
<>                //清空obs_grid和Pheromone两个数组中的值
                for(int i=0;i&lt;width;i++){
; T& j: H$ c9 U& X5 x1 X9 C   for(int j=0;j&lt;height;j++){
) [3 Y; \* L) `    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
0 d$ Q( a" ~3 m2 p+ T: N# C                                }
/ r1 M2 e/ s3 J- P( f   }
  }</P>
0 u8 k/ g6 K# x: A) K6 ^. _+ z<>                //从grid数组中读取信息
# K, ?* k6 L' e                for(int i=0;i&lt;width;i++){
8 j/ h+ X( c% Q; M1 T3 e/ e                  for(int j=0;j&lt;height;j++){
2 \, {& z" W9 B; X& p0 V/ o                    switch (grid[j]){
( Z0 |8 q& o) k( f                    case 1:
                      //如果grid[][]存的是障碍物
* m7 x3 h* a+ W+ ?3 s$ o0 ^' A& x3 V                      obs_grid[j]=obsCount;
                      obsP[obsCount]=new Point(i,j);
$ I; \, b! D$ F  t2 f% B% O                      obsCount++;
                      break;
                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
0 ]& w5 M, Y! c/ g; p                      if(OriginPts&lt;100){
                          OriginPt[OriginPts]=new Point(i,j);
# S8 O' S( a* b# m                          OriginPts++;
                      }
                      break;
                    case 3:
                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
# ~! D3 s- z  ]0 L$ f- Y' n                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
$ F( H2 ^  s- |1 Q6 O- t                          EndPts++;
, E5 }$ P( s0 E- |7 u: s                      }
                      break;
& M' X: r% l' T1 @& h1 g                    }
                  }
                }
            //如果没有指定窝，则随机的选择一点
  o) L$ W# `/ Z4 K+ m            if(OriginPts==0){
% F7 m* \3 q; |# Y3 p- E: K  A( U              for(int i=0;i&lt;width;i++){
0 z8 G; J9 j8 ~- q$ E                int  j;
3 w$ y- [0 U) J& m! L5 X                for(j=0;j&lt;height;j++){
                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
  G: I6 }+ ?1 ?& K7 G                    OriginPts++;
                    break;
                  }
- z% q3 M8 W! B0 q) ^" w+ h7 V3 k                }
                if(j&lt;height-1){
* T) Q' b+ W6 [# ?( o1 |                  break;
                }
1 H9 e3 D& }% v  Z              }
! U; P3 t1 t) U' i            }
        }
public void reinit(){
% k: _# h1 j4 O) ~! X                //重新初始化整个环境</P>
<>                //先停止程序的运行
' X$ O* X( i6 N2 h9 O/ B                running=false;
6 `/ I" q& F9 v6 s5 v                btnStart.setLabel("开始");</P>
<>
/ e: v5 }: @6 |: ]. {. s% _6 ^  //清空所有信息素Pheromone数组中的值
                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
                                for(int k=0;k&lt;2;k++){
- t  s7 d! H0 d6 q                                  Pheromone_grid[k][j]=0;
$ Z/ q1 B, d" i+ C& m                                }
6 w! U( M* j+ ], m; B: Q* v9 v. {) v   }
! R6 S# X7 |+ U. M! r; i8 Z: v  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
0 G+ A% ~' e' X1 I        for(int i=0;i&lt;antCount;i++){
  v% l3 o3 F8 m! x( [) B4 n5 Y                        int index=(int)(OriginPts*Math.random());
          ants.OriginPt=new Point(OriginPt[index]);
$ e5 E7 Q' J( Y2 @/ v+ d                        ants.init();
  }</P>
<>                //清空信息素向量
, M2 E6 S& v( f0 Q( a% f$ R3 s: ^                phe.removeAllElements();</P>
<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
" @( {7 u* E& Y  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));
* ^0 R8 b, `  ^1 q8 T                        for(int yy=-y;yy&lt;=y;yy++){
# N; b: R$ w6 }7 r' ?: N8 f                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
$ N3 e9 k' W4 s8 v- b% l                        }
8 y7 c: n/ l6 k* ?1 x6 s8 n5 z                    }
                }
7 x7 |$ U# [7 h9 ]9 v- ]; h                for(int i=0;i&lt;OriginPts;i++){
4 o0 N. V9 m0 [& p/ T( @1 Z% _                   for(int x=-FoodR;x&lt;=FoodR;x++){
                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
7 ~, Y; B9 C5 Z                        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));
* C: i2 W2 [# R& U7 L                        }
: i. e. i- G7 `# n: y                    }
                }</P>
<P>                //重画
; M5 M6 u0 U8 ^5 u" @  }# |  canvas.repaint();</P>
. q' ~1 d* M9 n8 Q% ~5 r<P>                //让程序开始运行
! I  o2 h3 R; w9 [; G3 A5 N9 U                //running=true;
) }) x+ \( t# m, F) {  h/ x }
public void paint(Graphics g) {
+ Q1 N) A/ o! b7 e( x  canvas.repaint();
}</P>
<P>
! T9 H% Y) j2 g; v1 V$ }# Upublic static void main(String[] args) {
    Antcolony applet = new Antcolony();
    applet.isStandalone = true;
5 p& L7 \3 x3 y5 Q7 d- }# e    Frame frame;
    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
        super.processWindowEvent(e);
; Y/ c; v6 w% o1 G- I* `' |        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
          System.exit(0);
        }
. [; S3 [6 b3 P! l4 W6 e      }
      public synchronized void setTitle(String title) {
; d0 @% M& d% \+ T        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
    };
- K# Y2 w8 x1 j9 f    frame.setTitle("Applet Frame");
2 n: z( j, }4 A3 h! x4 B0 p    frame.add(applet, BorderLayout.CENTER);
    applet.init();
    applet.start();
% D5 W1 y/ V- q' t. _    frame.setSize(300,320);
; B" ~. \8 u  L1 Z    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
& M7 M' _) w9 C7 p    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
    frame.setVisible(true);
  }
  public void start()
4 u' i+ M9 l. t# E' w  E( m! F  //下面三个函数是控制线程的
{
) a& `+ q' _! m: P  if (runner == null)
  {
5 o$ d" W: c/ `# i* j% P   runner= new Thread(this);
   runner.start();
   //running = true;
  }
( G/ D# Z0 p  n3 j. ~ }</P>
<P> public void stop()
{
  if (runner!=null)
* Z. y8 ]8 r+ q  {
4 ~& ]5 b: P0 j3 _) R# o$ x; \   runner.stop();
) O. ?( R6 V7 i! V, k   runner=null;
   running = false;
% D% @) T% Q; X) V& v  }
}</P>
<P> public void run() {</P>
<P>  int i;
                //线程一直运行下去
5 L' M3 E& B" e  while (true) {
) s4 t1 ?+ t4 L1 j: h          if(running){
       //如果开始动画，就进行canvas的处理
; [& l% D' ]0 ~) B3 Q                          canvas.process();
) y- q/ {0 U$ y" \2 d4 \                        }
. Y0 V) b0 \5 [3 k5 T8 k    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
( }4 J9 i/ f4 D6 L# I' R   }
  }</P>
- ?! t* u. z) _/ p  F<P> }
        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
                //开始编辑地图面板
   running=false;
                        btnStart.setLabel("开始");
0 Q3 l) W5 v8 w. }   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
                        ctl.show();
) a! W. U% d/ b  r2 n1 d' D& X                        return true;
  }else if(evt.target == btnStart){
                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
# ]6 U+ ?! B$ b9 x3 U) H& d                    if(reset)reinit();
' i' o; J+ `- x5 k9 E                    btnStart.setLabel("停止");
                    reset=false;
8 ~/ M% h; O5 c; R                    running=true;
; h7 ~" y  h" `2 \; A/ G- f                  }else{
: K# x) V+ {$ G) i                    btnStart.setLabel("开始");
                    running=false;
# M( C8 h8 K0 t                  }
9 t( n" n4 o. A% G3 T" S                  return true;
                }else if(evt.target == btnReset){
                  running=false;
" G9 `, x8 e5 B3 i, f$ B% [                  int j=0;
$ O5 ]9 a3 Q( u; V                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
8 O) p" ~. @( H                  repaint();
" y) t" e' X8 g                  btnStart.setLabel("开始");
                  return true;
! A9 t( o6 G' x: W                }else if(evt.target == btnConfig){
3 Z; |! u; {) _1 l8 m                        running=false;
3 \; r) f$ Y! J& v3 {& |                        btnStart.setLabel("开始");
  L& K7 @7 m* V$ x! w% ~     Configer ctl = new Configer(this);
                 ctl.setSize(300,300);
, A( v2 x* B+ y3 i; S                        ctl.show();
                        return true;
4 J: `7 S. \$ H, }                }else if(evt.target == choPDraw){
+ j# f- r) k3 L3 C/ S                  //选择画信息素的模式
# J( ]0 \# E, S6 b( q5 P5 Q                  drawPhe=choPDraw.getSelectedIndex();
7 f/ H- E9 F  n1 i0 u                  if(drawPhe!=1){canvas.repaint();}
                  return true;
                }
( f8 Q3 i7 Y7 J# m8 ]8 ^- F' f                return false;</P>
<P>        }
/**Destroy the applet*/
  public void destroy() {
! |4 c/ D6 ]/ N: M+ W  //当结束程序的时候，把线程也结束
    if (runner!=null)
, I& y/ C8 L& @/ w    {
# O4 T, C& V9 u. U       running = false;
       runner.stop();
       runner=null;
: y" B' G5 E& B0 k, |* ^    }
' J' w3 Q0 m' k0 ?, B! Y  }</P>
<P>}
0 v& ~6 G' S( y9 W  m1 E0 u</P>

' `0 l: ]- ~2 K' [. ?& o
/ m4 u4 j8 \2 K
<P>package ant;
import java.awt.*;
import java.applet.*;
import java.util.Vector;</P>
<P>public class ant{
Point nowPt;//当前点坐标
5 b+ ^+ D) ~, f int VR;//速度，每次蚂蚁能走动的最大长度
6 A2 ]1 \/ P) @' K+ Z  int id;//标识
7 U. Z& c: W, o. u+ ?. E  Point lastPt;//上一点坐标
3 C  K4 w$ [  ^- ]& Z Color color;//蚂蚁的颜色
Color back_color;//背景的严肃
int height,width;//世界的尺寸
5 w+ a) K3 z4 T! Y( Q5 ^0 M        int Phe;//每次释放信息素的数值
, a0 _3 o3 S# r0 M% E Antcolony local_colony;//主程序的指针
        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
        double Main_direct;//主方向
        Point FoodPt;//记录的食物点，是否找到时候判断用
        Point OriginPt;//窝的坐标
        Point AimPt;//目标点，是窝或者食物
* H8 D( P4 g( P7 ?4 f        Point StartPt;//起始点，是窝或者食物
        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
# j% ^; E) l+ l- ?$ j/ E. [) C        int Pheromone_count;//当前还拥有的信息素的总量
        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
( e, h6 Y6 `0 [$ j' R        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
5 _0 I4 ]: `* O' e8 c3 L( ~1 S public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
* C# f6 P: [9 Q* m  nowPt=new Point(nowpt.x,nowpt.y);
* _0 Z5 V8 \' C                OriginPt=new Point(nowpt.x,nowpt.y);
5 k! `+ n% ?2 l6 P% @2 z; ~                FoodPt=new Point(nowpt.x,nowpt.y);
0 l: U; C. K* M                StartPt=new Point(nowpt);
                AimPt=new Point(nowpt);
                lastPt=nowPt;
  VR=vr;
  id=idd;
  color=c;
8 r8 m; H/ @: S+ d5 P+ o" E6 z  back_color=Antcolony.BACK_COLOR;
. Z" K& w( W- z' I2 n- H  height=Antcolony.height;
  width=Antcolony.width;
. b; N0 D4 L! ]5 x+ }* v  local_colony=colony;
                Phe=200;
/ T; B% L. O1 k! k! J" A0 Q                mistake=mist;
9 X. K7 Z  B- {+ j9 I+ A                HistoryPoint=new Vector();
                Main_direct=-1;
2 B$ V& D* b4 B3 v# J0 ~) U                FoundTimes=0;
: A' v5 G1 s* o4 n9 {: B# L                Max_Pheromone=local_colony.Max_Pheromone;
                Pheromone_count=Max_Pheromone;
0 T6 ^: j+ F" M3 R                memory=mem;
- C8 t) R' y8 h: ^7 V                Count_distance=0;
                Min_distance=-1;
3 {) `* s- l& T2 z }
% t9 G" W! c" B1 A8 V2 v6 b- t        public void init(){
          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
) `% W1 {" k( f; Z$ l/ d          FoodPt=new Point(OriginPt);
$ ~6 O/ R7 e: B          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
6 ?: z/ I, S* q1 M# ^# k+ }/ A' ]          HistoryPoint.removeAllElements();
          Main_direct=-1;
          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
          Count_distance=0;
# P3 m( L4 v0 k' O) Q3 f          Min_distance=-1;
) X: n" Y: A$ B" Y1 G& G* ?3 B        }
public void Draw(Graphics g) {
! |" K0 {0 u/ M# g          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
  g.setColor(back_color);
  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
/ c' @0 J5 m( {" n# q/ g  P  g.setColor(color);
  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
! n" t! u4 x( `* U8 ?7 v& H }
: k$ @% b5 l# ]7 C8 C: m. C public void Process(){
- ~) U! ?  d$ v- I        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
8 z6 `1 g( _# O" B, h        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
) J, ^9 M" _( U1 h6 \        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
$ Y- o" @# U# D- d        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>
8 u/ a# H& m! r7 B- b, b8 m
<P>        if(Judged==false){
2 {& P6 w& P, Z/ p- {" w- l1 N! n          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
( B' I' `- Q# D- p) f" q1 ~              return;
' C8 x+ z3 N9 l6 A9 ?' `; p; @' O" Z          }
9 Y0 N9 A/ ?3 Y" y        }
        Judged=false;
1 F" V9 o: B! O2 u7 v        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
        //direct是方向角，根据方向计算位移
        deltx=(int)(VR*Math.cos(direct));
6 e( `4 u' K2 S8 u% b        delty=(int)(VR*Math.sin(direct));</P>
<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
7 n# y$ h* b$ ~) g" o, j! _        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
0 B+ C9 d, v) q( @& z. v        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
8 }' ]' Z. j2 M/ ]" `& Y1 `& c2 r<P>        //记录搜索的环境中找到的最大的信息素
/ n, q0 _' U5 o7 X& P5 H, ^        int maxphe=here;</P>
6 Q- T) n3 @5 F/ A( A+ J4 G<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
, a/ \, ^4 r; K4 y/ f$ U          int deltx1,delty1;
          deltx1=deltx;delty1=delty;</P>
<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
, o/ W. q1 ]' _. H" u          for(int x=-VR;x&lt;=VR;x++){
             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
6 ~7 a0 W" I$ t1 Q' a4 `* _                //在这个程序中，坐标是循环的，也就是在一个球面上
! H. O8 g, y% S  x3 E; ~7 h                int xx=(nowPt.x+x+width)%width;
                int yy=(nowPt.y+y+height)%height;</P>
<P>                //循环的时候要除去当前点。
                if(x!=0||y!=0){
                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
$ H$ d' M. c; Y- {<P>                  //如果搜索点的信息素比已经找到过的信息素多
5 t8 q/ s8 C2 {3 V                  if(maxphe&lt;phe){</P>
) {& O/ u" O. K9 O7 f# q<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
8 \9 ]* L3 S4 Y) N0 s                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
                          boolean found=false;
                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
, x6 c, O- a0 L1 N9 E                          int minsize=memory;
" ]7 P3 h/ l( u/ J                          if(size&lt;memory)minsize=size;
                          for(int i=size-1;i&gt;=size-minsize;i--){
5 {" w5 }* p9 Y                             Point pt=(Point)(HistoryPoint.elementAt(i));
% P$ E+ @/ U1 `7 j6 g$ I3 c8 ?1 n+ ?                             if(pt.x==xx&amp;&amp;pt.y==yy){
                                found=true;
                                break;
# I1 Y" G4 u$ [, E9 s/ ^                             }
                          }
                          if(!found){
9 U* n  B, {% ~4 e                            //如果没有原地转圈，那么记录信息素。
! Y  C: F( r8 n  _8 R' C                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
                            delty=y;
                          }
/ L, P1 z  a4 `                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
! t) @- a! @2 r2 L  u, A7 d1 d- \                }//end if x!=0
: V( J9 D0 G" _9 u' }4 O6 d            }//end for y
: G! |, x) W8 _+ _  A' P; P        }//end for x
7 ]5 T* D* y0 }# Q. b1 |/ ]7 ~        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
        pt=Evade_obs(deltx,delty);</P>
<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
5 v& K$ w) B3 L1 B; D7 b7 T; q        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
! d: @3 j' H" m1 F5 D" t          pt=Evade_obs(deltx1,delty1);
        }</P>
<P>        //播撒信息素
        Scatter();</P>
<P>        //记录走过的距离
        Count_distance+=Distance(lastPt,nowPt);</P>
/ Y* o# b2 z* g1 y  i<P>        //改变当前点位置
5 M" T: n: f# C        lastPt=new Point(nowPt.x,nowPt.y);</P>
* k/ }1 v. S- r; p+ {7 F. y<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
# f8 X, n3 ]! G5 l9 g( z        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
        if(HistoryPoint.size()&gt;memory){
: @" P, o3 G- W" V6 I: ^  e          HistoryPoint.removeElementAt(0);
        }
" C, [( U2 I" F        nowPt=new Point(pt.x,pt.y);
     }</P>
( C! g+ v, q$ w) n  u; s5 x<P>
. z) A6 X' B% }        private void Scatter(){
* K3 k: K9 j' H        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
: w* g9 ~$ m+ Q) Z. M            int kind=FoundTimes%2;</P>
" y5 f& g( M. `- `1 R  R0 e4 I<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
9 f8 C7 _4 c4 {6 Q; X            boolean ofound=false;
            if(Phec!=0){
                //如果当前点已经有信息素了
                for(int i=0;i&lt;local_colony.phe.size();i++){
1 H3 }! ?; F6 `2 X4 D                    //在信息素向量中查找该点的信息
- P: N5 [  W# e0 ]                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
9 `  F, n1 a" S7 `& ^                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
) ~) L# ~0 T( s3 d8 L                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
. ~1 E" m7 P6 d& Z3 N% C8 i. ?                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
                        ofound=true;
0 }  V4 ]1 V) P$ a5 u                        boolean found=false;
- f1 Z. b* c. t1 t4 m8 Y                        if(size&gt;4){
& L- F# B$ H4 @0 K5 g                           for(int j=size-4;j&lt;size-1;j++){
                              Point pt=(Point)(HistoryPoint.elementAt(j));
" m, J3 P8 r8 }* r1 P5 M9 g/ W# S                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
                                //如果当前点重复了以前走过的路，就不释放
+ X& `( a5 A/ F0 k                                found=true;
                                break;
5 ^3 M* J$ W2 P3 g3 v7 [                              }
$ n1 E' F3 M& W8 \) R                            }
9 I) n. t/ S7 J& j3 }                        }
3 W0 Q  h' w2 d7 \                        if(!found){
: }1 x9 V7 }8 G: ~1 Q$ D                        //如果当前点不重复，则开始撒
$ ~' x! Z  b. y! H' C1 e                             ph.Add(Phe);
8 v7 Z3 @$ U% G( c1 ^6 `                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
<P>                             //让还剩下的信息素总量减少
6 Z' N8 G' i/ g4 u                             Pheromone_count-=Phe;
                        }
% {- `# b( \" {                        break;
- V& m, e: T- u9 d  X                    }
1 \) f2 ?# x$ `1 ?: P                }
              }
          if(Phec==0||!ofound){
& j3 T; b& u1 R: y, G) P  I6 M            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
; j  D% G4 Q9 N- e9 F: f; q/ Q                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;
                local_colony.phe.addElement(ph);
# T% ?7 ?* U0 S) |: I2 R$ f                //让还剩下的信息素总量减少
                 Pheromone_count-=Phe;
# {) I* i4 c! Q$ J6 q6 n* p' h           }</P>
4 ]9 U0 d7 j5 ], ^$ t9 T' `7 J& i<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
  j1 ~7 v( M  Z+ n           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
           Phe=(int)(0.005*Pheromone_count);</P>
- t7 s/ i% }5 n' ]! ~8 t<P>           //如果剩余信息素已经太小了，则按照等差数列递减
           if(Phe&lt;=10)Phe=10;
* k' r2 Z) u$ a4 T        }
. b+ Z, k- U  Aprivate boolean JudgeEnd(){
' k+ f7 E& h: D2 b8 M    //这个函数判断是否已经找到了目标点
$ P* D7 v8 Z$ M) r    //首先获得当前蚂蚁是正在找窝还是在找食物。
* X0 H1 r* i( A; N1 v3 W, d    int kind=FoundTimes%2;
    if(kind==0){
        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
3 b% \# b2 \2 d4 Z( e9 W0 G        int i;
        for(i=0;i&lt;local_colony.EndPts;i++){
: S# K* |; K* w4 ~1 }            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
4 ^" z- `7 T) i* A8 X. g              //如果找到了食物，就直接移动到食物点
$ X" m: M4 w1 {1 I; j- E              lastPt=new Point(nowPt.x,nowPt.y);
              nowPt.x=local_colony.EndPt.x;
              nowPt.y=local_colony.EndPt.y;</P>
6 C8 c# f: V$ [2 b' r, }1 n<P>              //计算最后的总距离
              Count_distance+=Distance(lastPt,nowPt);
$ k) B5 h) R8 F0 r  n) x              //比较大小，记录较小的距离
9 Y6 K) E2 B; {; ~2 L              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                 Min_distance=Count_distance;
/ B; o' d8 `. \) z# ~5 N* J              }
              //清除总距离记录
) S5 S8 ]9 ~' U5 [( L1 V6 g              Count_distance=0;</P>
1 B$ p7 ?0 z+ T" e6 f0 S; Y  b* B<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
& ~0 ~- b8 Z6 r& ^- R              AimPt=new Point(OriginPt);
              StartPt=new Point(nowPt);
9 @8 E* G/ Q% {9 ~4 ]( F2 V              //并把当前点标为自己找到的食物点
; Y2 I" c, D- m7 `8 V2 M7 \5 y              FoodPt=new Point(nowPt.x,nowPt.y);</P>
$ M# u, _& N6 |: d. s5 r<P>              //找到了食物就把找到次数+1
9 E& x: y" ?: w1 \" i              FoundTimes++;</P>
( n3 j# B) U4 o% Q$ R<P>              //改变主方向为原来方向的镜面反方向
              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
' s5 _  u9 R- s<P>              //重新把自己能撒的信息素置为最大值
              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
) M; G. ^( ^- H" [" [( z              HistoryPoint.removeAllElements();</P>
4 H" K/ @% B# Q0 _; ^5 R' K( S<P>              //返回找到为真
              return true;
            }
" L5 s! U9 v) F; l        }
      //否则没找到
: v  t$ ?' k8 N+ I      return false;
    }
& L  Z8 B3 N$ ]2 j    if(kind==1){
# d1 ^% C4 w2 J. n& ^! a% ?% x        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
4 N9 B3 `) }0 E4 s+ J, D: ~        if(Distance(nowPt,AimPt)&lt;=VR){
            lastPt=new Point(nowPt.x,nowPt.y);
/ c, Y( v% V6 W            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
            nowPt.y=AimPt.y;</P>
<P>              //计算最后的总距离
5 |# V% f) `6 U1 |* j) [/ s8 ~; X              Count_distance+=Distance(lastPt,nowPt);
; ~$ ]' B3 M6 s! J$ I              //比较大小，记录较小的距离
2 i, ~4 ^6 X2 Y! \6 t. x              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
/ [0 N4 J! X+ H( L) C6 f/ r$ `              }
; @& w- e0 r2 F& z) e              //清除总距离记录
: Z1 T- Q# E5 ?              Count_distance=0;
! q# z- J" v3 ?3 g6 B. K0 A% q& ]            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
) p6 k: P. d8 L            StartPt=new Point(OriginPt);</P>
- ^1 X1 E0 s5 F3 Y% w* |1 E<P>            //重新置信息素
            Pheromone_count=Max_Pheromone;</P>
<P>            //清空历史纪录
+ [/ y& [; g7 U) ], P8 }0 V2 ~2 t7 V            HistoryPoint.removeAllElements();</P>
<P>            //主方向反向
/ j1 W) \  O, A* `            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
1 ?( H/ X& e: H1 A" j. e* D  N<P>            //找到次数+1
; _( g7 q6 f- z- P: i" D5 M) }            FoundTimes++;
            return true;
% U2 ~+ ?& u# K# F% A4 l        }
6 S6 d. m; U# J1 c* Z        return false;
    }
8 o7 _; e* y, l" \: H( b7 c    return false;
}
        private double SelectDirect(){
, u! ]! d9 \; o. L6 }: l" s                //选择方向，最后选择的方向为主方向加一个随机扰动
                double direct,e=0;
) @4 \9 p; I5 Q! R* G+ S3 x                if(Main_direct&lt;0){
                      //如果目前还没有主方向角，就随机的选择一个
        e=2*Math.PI*Math.random();
" O# N$ y4 G1 o) P1 }2 r                      Main_direct=e;
4 w# p# `" P  L7 i) n                }
                //选择主方向角
; _" Y8 Y5 K+ g" d4 C/ y  S5 G                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
: Q3 X* v  N2 o( Q8 u2 J5 C                //[-1，1]的随机数，并且在0点附近的概率大，两边小
) N% d& z$ C  U                double re=Math.random();
                double re1=Math.random();
                direct+=Math.PI*(re*re-re1*re1)/2;
* I3 A& ]5 G; {& t5 O/ C1 J9 n                if(re&lt;0.02){
: ^7 D2 {# f4 V2 F7 m( H6 ~, z                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
- L8 q" {" P+ d+ ]8 W: s                  int size=(int)(re1*memory)+1;
+ W/ T& a0 I/ @! y# |                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
$ t+ M# g3 H" r: R9 a# P' V                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
/ U7 d& R- I! ~7 j! Z                       Main_direct=GetDirection(pt,nowPt);
4 u0 G5 o; L: ?+ B% ?0 r* a                    }
                  }
3 [& c5 D( y1 N! g                }
5 [) A  x+ T; v! X' c9 N               return direct;</P>
<P>        }
* j" a4 k. ^- G* E7 |0 F        private Point Evade_obs(int deltx,int delty){
. Y, N7 u7 e* f2 t              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
$ o  D9 G5 u; q" P6 C              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
0 r8 @; j8 s. o8 k0 r  D# x              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
              Point pt=new Point(0,0);
: G1 u, p5 M, P' F) d3 `& k/ m! a0 Z* p              int x,y;
  b/ \+ E, ~& V# x) X* \1 A              int delt=deltx;
5 R/ F/ d3 t/ g% N1 b9 }8 J( U              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);
# j# B! o8 [; R) A. i& b) I3 x: }                  y=(int)(delty*t+nowPt.y);
                  x=(x+width)%width;
                  y=(y+height)%height;
2 H4 G: Z/ k5 H                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
/ @/ M! c0 y" {  u<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
0 C8 q) U/ @  I" ^% c                     double disturb=4*Math.PI*(Math.random()-0.5);
9 U6 i, D# m1 l9 O- X" N                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
2 `! D1 G" b) q% @                     break;
" [+ \( d. `! [$ g7 W6 o) K, d4 D6 i                  }
+ S, R+ g# m  e% u8 D8 Z! d                  pt=new Point(x,y);
4 g# _9 y& J2 x# m; C" ]                }</P>
<P>                //计算得出实际能够到达的目标点
: [) q* m- R9 d: x, g  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
         return new Point(x,y);
        }
        private double GetDirection(Point pt1,Point pt2){
2 l9 a7 R2 H3 y; ?  f        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
. u* u1 H/ e2 [+ \        //其中方向角是所有可能的角中使得两点连线距离最短的角。
# J* G5 n* }* I8 Q4 e( W               double e;
               int deltx1=pt2.x-pt1.x;
1 R5 J4 S7 x# E5 G$ I               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
' [3 C3 K; D/ T3 Z               else deltx2=pt2.x+width-pt1.x;
               int delty1=pt2.y-pt1.y;
5 E; D$ J/ a0 g8 b1 Q' B               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
' P# a, M3 w& }! Y, d8 i, F               else delty2=pt2.y+height-pt1.y;
/ {# i: G/ X% z! B1 K3 v               int deltx=deltx1,delty=delty1;
2 Z& J2 e9 X5 }3 ]8 z  f               if(deltx==0&amp;&amp;delty==0)return -1;
5 a3 S; K; V. @; i( Z8 a: x               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
. }# V% V4 s6 m8 V4 N" g1 v* k* Z    deltx=deltx2;
               }
        if(Math.abs(delty2)&lt;Math.abs(delty1)){
# T$ D1 ]6 i2 W                  delty=delty2;
               }
' R4 n& o+ n! _; i  ?               if(deltx!=0){
                    e=Math.atan((double)(delty)/(double)(deltx));
* }% m0 ~8 M4 J1 U6 p                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
  j. T; k! o- B! R# f1 }6 L# I/ D                       else e=e+Math.PI;
                    }
. L  P7 T/ c& @1 q6 u                }else{
                    if(delty&gt;0)e=Math.PI/2;
( }( C! I' T# N7 C# P8 u                    else e=-Math.PI/2;
                }
+ a( x( ?0 j% e  f9 Q) \                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
3 b4 k+ U* G( D  s0 c- T# q" J        }
9 c5 z/ g5 n- }$ f' ^4 G        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
" a) q) y* s# D  [4 C            int dx1=pt1.x-pt2.x;
8 h$ C+ E' \; E2 S            int dx2;
9 }( v& h0 q. k+ \9 z$ H            int dx,dy;
            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
2 h; _: b# u! ~, W            else dx2=pt2.x+width-pt1.x;
" E; J4 p$ M0 o& K9 O  q            int dy1=pt1.y-pt2.y;
- P- \4 n  @3 a  r            int dy2;
            if(pt1.y&gt;pt2.y)dy2=pt1.y+height-pt2.y;
            dy2=pt2.y+height-pt1.y;
7 \. S# a. F1 `+ x, g& ~            if(Math.abs(dx1)&lt;Math.abs(dx2))dx=dx1;
            else dx=dx2;
            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
            else dy=dy2;
# J! c+ [- O3 V- I            return Math.sqrt(dx*dx+dy*dy);
  ^9 a; u' W( S1 J        }
8 {8 Q" R6 z- ]+ u    public void clone(ant ant1){
- ^" r( Q$ i) _5 U1 [/ N- G' @. a        //把蚂蚁ant1的属性拷贝到本蚂蚁
     nowPt=new Point(ant1.nowPt);
: q! C6 d2 f9 D5 S        OriginPt=new Point(ant1.OriginPt);
' A; y% j! M* f' \8 ?2 a        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
        AimPt=new Point(ant1.AimPt);
* w& }' D- I/ ^% n! b2 F        lastPt=new Point(ant1.lastPt);
6 |/ U4 [2 Z! x& y        VR=ant1.VR;
$ q0 w' M3 K0 r9 o% @        id=ant1.id;
& t( _' C' z& u1 n        color=ant1.color;
        back_color=ant1.back_color;
        height=ant1.height;
2 Y/ i0 v8 A+ Y: v8 ]        width=ant1.width;
. @! P( @' O- e8 S  r" y) O3 |1 n        local_colony=ant1.local_colony;
        Phe=ant1.Phe;
( g, M4 ^: Q& p        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
        FoundTimes=ant1.FoundTimes;
* o) `8 Z( z) i* j+ L        Max_Pheromone=ant1.Max_Pheromone;
        Pheromone_count=ant1.Pheromone_count;
$ D9 t( Q$ _$ T' C4 q) q2 ^        memory=ant1.memory;
        Count_distance=ant1.Count_distance;
        Min_distance=ant1.Min_distance;
    }
}</P>