[求助]帮改一下程序

xiaolu1998

<>我搜到一个java版蚂蚁算法的程序，我不懂JAVA请高手帮我改成c或matlab</P>
<>package ant;
& r6 A$ ~/ A# d8 W/*
* @(#)Antcolony.java 1.0 03/05/22
*
1 D; r9 K1 R. G/ w4 B: d' g1 M! k3 Y * You can modify the template of this file in the
& E. Q; D+ [+ `& P * directory ..\JCreator\Templates\Template_2\Project_Name.java
: F% y: K# s& k& ]2 k" }9 i *
2 E6 Q* k& d% z- J, w, g9 u * You can also create your own project template by making a new
' |3 p6 v7 W. p% g7 @: P2 ` * folder in the directory ..\JCreator\Template\. Use the other
* templates as examples.
*
*/</P>
<>import java.awt.*;
- Z0 N- @1 f/ K/ }( ~import java.applet.*;
import java.awt.event.*;
import java.util.Vector;</P>
<>class AntCanvas extends Canvas
) b# P" m- d! N4 |{
" M: W* F* e! X8 h1 v+ t    //画布，一切画图操作均由该类完成
//Image image;
Color obs_color;//障碍物颜色
- j6 W0 N" v% N2 I Color origin_color;//我的颜色
Color back_color;//背景色
        Color end_color;//食物点的颜色
$ s1 X) C' G+ b; x3 a //boolean first;
4 A+ ~6 g: A, A* P0 o8 x3 x boolean reset;</P>
9 n& F( O. {+ R1 D0 _) [5 X<>/* public AntCanvas(Image img) {</P>
<>  super();
   image = img;
  obs_color = Color.white;
  setBackground(Color.black);
  setForeground(Color.white);
  first = true;
/ D$ g, \3 O1 [; Z  reset = false;</P>
<> }*/</P>
<> public AntCanvas() {</P>
<>  super();
   //image = null;
: H! ~! ~0 I6 G* v' k   back_color=Antcolony.BACK_COLOR;
) D/ o7 Z9 a7 Q) `- y  setBackground(back_color);
) C9 x; p: m4 i/ j8 g' |6 d& k  setForeground(Color.white);
5 m8 {- r: P3 c  obs_color = Antcolony.OBS_COLOR;
  origin_color=Antcolony.ORIGIN_COLOR;
8 _( Q5 t0 f' d3 [/ r1 c                end_color=Antcolony.End_COLOR;
  //first = true;
  reset = true;</P>
<> }</P>
& c; a. P& V$ H2 h1 y/ v<> public void Clear() {
- o1 Q5 f% L5 V7 X( u9 r        //清空画布
  reset = true;
  repaint();
}</P>
6 Z# A& O+ e# c" r4 d- ~, O<>
public void paint(Graphics g) {
  int i;
+ Z" @% Y4 ~  u                //重画的时候仅仅画障碍物
  g.setColor(Color.black);
  g.fillRect(0,0,size().width,size().height);
, D- E4 D% t* F2 b8 ?  g.setColor(obs_color);
; n% B, P9 o4 _, J7 A: M& N  for(i=0;i&lt;Antcolony.obsCount;i++){
   g.fillRect(Antcolony.obsP.x,Antcolony.obsP.y,1,1);
, ]2 Y# z: ]0 [) [* |  }</P>
<> }
4 g- L3 [+ U3 l9 S( J public void process(){
        //处理动画的过程
  Graphics g=this.getGraphics();
6 h, C5 _$ K4 S* Y8 l3 J! y; _                g.setColor(end_color);
2 \2 d7 S& z2 e7 n4 b" ^1 u   for(int j=0;j&lt;Antcolony.EndPts;j++){
                  //画所有的食物点
0 }$ o4 h6 I, Z6 @# Y( J2 t( a                  g.fillRect(Antcolony.EndPt[j].x,Antcolony.EndPt[j].y,2,2);
1 }/ A4 `( u6 h* e- s+ R                }
2 d& y+ e! H$ S/ _                for(int i=0;i&lt;Antcolony.antCount;i++){
) u' U' t5 [% m; ?$ q6 G                  //每只蚂蚁开始决策，并画蚂蚁
. Z$ Y' `8 E" p4 G; w4 k6 F   Antcolony.ants.Process();
   Antcolony.ants.Draw(g);
  }
; d3 [+ X. @* d$ H                for(int i=0;i&lt;Antcolony.phe.size();i++){
                        Pheromone v=(Pheromone)(Antcolony.phe.elementAt(i));
                        //Antcolony的drawPhe变量标志是否画信息素
                        switch(Antcolony.drawPhe){
6 c+ W0 Z0 Z- h9 k5 O                        case (1):
) h$ {1 p+ }' m' U                            v.Draw(g);
                            break;
1 b& A( g# G% A7 N- b) e5 O0 L                        case (2):
. F% p# M8 {  ]3 \' \" w                            if(v.kind==1)v.Draw(g);
                            break;
: ~2 N$ j0 c2 |7 m                        case (3):
% b% S" ]: i( w                            if(v.kind==0)v.Draw(g);
- g8 O% Y* O; R4 s+ @( b! o                            break;
                        }
. N) |) i$ f" p! g* g2 h0 c                        v.delimit(g);
                }
           g.setColor(origin_color);
: C2 G% r7 Q* S. [                for(int i=0;i&lt;Antcolony.OriginPts;i++){
                  //画所有的窝
; d' ?2 D- |* X6 j# o                  g.fillRect(Antcolony.OriginPt.x,Antcolony.OriginPt.y,2,2);
! J% y* w/ V  U$ ^* ^1 q8 a0 U                }</P>
$ T% y5 O$ N! K2 U2 H0 \# X<> }
! p# [  g0 D- W" o. w: U Graphics GetGra() {</P>
<>  return this.getGraphics();
3 g7 \5 S: m7 J3 o' ` }
}
6 O* ]1 }1 F. w- u0 Y6 N$ Vpublic class Antcolony extends Applet  implements Runnable  {
' l2 L3 x* f- P  i/ D, z3 ~ boolean isStandalone = false;//系统的参数，是否独立运行，不用管
Thread runner;//创建一个线程，让动画平滑的运行
boolean running;//是否让动画运行
        boolean reset=false;//是否按下了重置按钮
1 p* K2 {: B$ Z! V static Color OBS_COLOR=Color.red;//障碍物的颜色
+ s! v# r4 O9 ?# ?6 m  \: a. a static Color ORIGIN_COLOR=Color.yellow;//窝的颜色
static Color BACK_COLOR=Color.black;//背景色
static Color ANT_COLOR=Color.white;//蚂蚁的颜色
        static Color End_COLOR=Color.cyan;//食物点的颜色
AntCanvas canvas=new AntCanvas();//画图用的画布
int obs_grid[][];//障碍物网格数组，这是个width*height的矩阵，数组中存储的是障碍物数组（obsP[]）的指标，这样做可以加快索引的速度
' v# p! O: M4 P3 a  s' i9 B0 o- g        static Point obsP[];//障碍物数组，存储的是点的信息，指标是障碍物的总数
static int obsCount;//障碍物的数量，最大为width*height
static Point EndPt[];//食物点数组，值为食物点坐标。
        static int EndPts=1;//食物点的个数，初始的时候为1，最大数为100
- M" x, n$ W, E& k. x. q9 f+ F        static int Pheromone_grid[][][];//信息素网格数组，2*width*height的三维矩阵，第一维是信息素种类（窝的信息素为0，食物的为1），它存储的是信息素的种类和值
        static Vector phe;//信息素向量（相当于一个数组），当环境更新信息素的时候，只需要查找这个向量就可以了，不用搜索整个width*height这么多的Pheromone_grid数组点
        static int Max_Pheromone=500000;//最大信息素数值，应该根据地图的复杂程度来定，越复杂越大！
& [0 D. z3 y+ ~  B static Point OriginPt[];//窝点信息
        static int OriginPts=1;//窝的个数，最大为100
3 H1 G& U& k6 A1 @! Q static int width=300,height=300;//环境的长和宽
static int antCount;//蚂蚁的数量
$ M- ?4 H0 d; ^' ?9 Q% x7 @        static int Delimiter=5;//信息素消散的速率，为整数，越大则消散的越快
, t9 i. |2 v! Z        static int FoodR=10;//食物和窝产生梯度的信息素的半径
static ant ants[];//蚂蚁数组
6 d1 x2 M# g; B        static int drawPhe=2;//画信息素的模式，0为不画，1为画所有的信息素,2为画食物的信息素，3为画窝的信息素
. f9 K6 E. n, S int delay=10;//每次运行的间隔速率，越小程序运行越快（这个参数基本没用，因为当蚂蚁多了以后，处理过程很耗时间）</P>
1 h* ?) P1 |3 R0 q$ G<>        //下面是一些控件信息
        Button btnStart=new Button("开始");
        Button btnReset=new Button("重来");
        Button btnMap=new Button("编辑地图");
        Button btnConfig=new Button("设置");
( ?: _- c% l# h        Choice choPDraw=new Choice();
public void init() {
                //初始化函数，先画各种控件
; M* F5 B  m+ G( V  setLayout(new BorderLayout());
                Panel pan=new Panel();
                add("South",pan);
! H7 A+ R; u" q* u                this.add("Center",canvas);
1 X! T% M5 z, N6 y; `; z2 Q                pan.add(btnStart);
                pan.add(btnReset);
                pan.add(btnConfig);
                pan.add(btnMap);
                pan.add(choPDraw);
                choPDraw.addItem("不画信息素");
                choPDraw.addItem("画所有信息素");
0 X7 `' k: A& A. `# o% P1 r/ B                choPDraw.addItem("画食物信息素");
                choPDraw.addItem("画窝的信息素");
                choPDraw.select(2);</P>
<>                //初始化各个数组
- X, U# Z5 Q: K5 D4 t  obs_grid=new int [width][height];
. Z: g, m5 E6 e% S                phe=new Vector();
9 a  }% @$ i7 F) P$ e. a9 k                Pheromone_grid=new int [2][width][height];
                for(int i=0;i&lt;width;i++){
3 r, m: j2 M: j' C# g   for(int j=0;j&lt;height;j++){
3 @( F. k; a/ K2 N2 R& f  \" h, b    obs_grid[j]=-1;
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
   }
9 ^  k, t0 y; D" `+ e- S5 C  }</P>
; r* _' m4 u" {" i<>   antCount=50;//蚂蚁个数缺省为50
6 b% z' B; d+ a6 E2 s# [- @                //初始化蚂蚁，这些属性都是蚂蚁的最原始的属性
' W/ U; O; k1 |" c6 O4 I: K" `+ P) E  ants=new ant[antCount];
        for(int i=0;i&lt;antCount;i++){
3 s+ }6 v: m: a8 @          ants= new ant(new Point(0,0),3,i,this,ANT_COLOR,0.001,50);
' x( e9 _/ ]- |+ `  }</P>
<>                //下面装载缺省的地图，包括障碍物、食物点、窝点的位置，都放到数组grid[][]中然后交给init_map函数统一处理
8 O+ R/ `2 ]& d8 h; D" j$ x                int grid[][]=new int[width][height];</P>
) I* }# s8 N7 D  F' `* T<>                //下面从地图库中加在地图
# Z' ~2 v9 u+ A0 `! i+ q$ K                Maps maps=new Maps();
( I8 f4 r" s6 I# j/ M& O                maps.LoadMap(grid,0);
                //初始化地图
                reinit_map(grid);</P>
& [0 {& e  U" O1 X  i<>                //初始化所有的蚂蚁
  reinit();
}
+ y8 ]8 M' h7 j% n% h        public void reinit_map(int grid[][]){
                //将数组grid[][]中存储的信息转换到当前的环境数据结构中
/ \! d0 Y* X- P+ n! x" p' }                //相当于把一个位图信息width*height像素转化成窝、食物、障碍物</P>
0 r8 j" ?% K, h: n& F9 ?, t<>                //先停止程序的运行
                running=false;
9 A; N6 m! B$ D% z  ?7 g6 x' g                btnStart.setLabel("开始");</P>
/ g/ z4 I+ M. q<>
                obsCount=0;
' Q3 l9 q. E: e6 a) [2 @* O0 a                EndPts=0;
                OriginPts=0;
$ p/ ^$ c  u( i- N2 B0 Y* x                obsP=new Point[width*height];
, `9 e1 D! z# Q: L8 Q                OriginPt=new Point[100];
  h2 d/ O$ b' n) A4 j                EndPt=new Point[100];</P>
% Y. H9 g8 s: \; M4 n<>                //清空obs_grid和Pheromone两个数组中的值
                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
    obs_grid[j]=-1;
/ X' W- \- z" {1 U                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
3 E: K4 m6 V' @$ Y                                }
% D% F7 I( @  Q( `) l% P   }
" c7 C8 I& Y( b+ ~+ t2 Y/ F$ Y  }</P>
. }: i/ p1 q' {4 D& L" ^1 {<>                //从grid数组中读取信息
/ \' D3 |* }: W7 }% [" V4 u: U                for(int i=0;i&lt;width;i++){
- q% h6 k( P. }4 `% R+ e                  for(int j=0;j&lt;height;j++){
* P6 n7 W9 n# N                    switch (grid[j]){
                    case 1:
% d. e* f! l+ x! T$ B% t                      //如果grid[][]存的是障碍物
" U% [8 P+ ]) {. V5 F                      obs_grid[j]=obsCount;
                      obsP[obsCount]=new Point(i,j);
                      obsCount++;
5 c, x- q, X, p. t& @                      break;
( x6 Z0 K* Q# v# K* Y( S                    case 2:
                      //如果grid[][]存的窝点信息，多余的窝点信息省去了
                      if(OriginPts&lt;100){
, A: t9 S4 _; n7 g$ x                          OriginPt[OriginPts]=new Point(i,j);
                          OriginPts++;
                      }
                      break;
" A& f% L2 V/ F* Z                    case 3:
                      //如果grid[][]存的食物点信息，多余的食物点信息省去了
                      if(EndPts&lt;100){
                          EndPt[EndPts]=new Point(i,j);
                          EndPts++;
                      }
: F# J5 S5 l4 {, N) \3 R                      break;
% o7 B& M* `' T8 ~& ~4 F, q                    }
# x) @- U8 _6 h: S! p8 S  K                  }
                }
            //如果没有指定窝，则随机的选择一点
6 J- r2 c& n# _- z4 I& ]: i            if(OriginPts==0){
9 C+ W# a& R: r8 V8 r; R5 Z              for(int i=0;i&lt;width;i++){
7 }/ g# ?5 z. ~: C# K: C                int  j;
3 F+ Z8 z& y, g- g6 |- c& Y                for(j=0;j&lt;height;j++){
! {, Z$ C  z$ B9 B                  if(obs_grid[j]&lt;0){
                    OriginPt[OriginPts]=new Point(i,j);
" ?" V+ m1 r/ S7 A* \                    OriginPts++;
                    break;
                  }
7 y, Z4 E& z6 x$ t+ K; ?                }
& P, J' P: X0 E( u# h' ^5 }( H                if(j&lt;height-1){
                  break;
                }
              }
            }
        }
public void reinit(){
7 h& d; Z9 n. U: I- K8 h: i' X                //重新初始化整个环境</P>
) F+ ^( a  o9 e+ E<>                //先停止程序的运行
                running=false;
                btnStart.setLabel("开始");</P>
/ \. W' r: @7 z8 x+ o<>
( M/ b, [. T0 ^+ w9 l  //清空所有信息素Pheromone数组中的值
$ i" |6 f/ K' ]( @7 C9 w, Q8 Y                for(int i=0;i&lt;width;i++){
   for(int j=0;j&lt;height;j++){
                                for(int k=0;k&lt;2;k++){
                                  Pheromone_grid[k][j]=0;
                                }
   }
# [- j: L( t  z8 W/ j8 p  }</P>
<>                //初始化蚂蚁数组，antCount只蚂蚁在不同的窝点之间进行随机的分配
        for(int i=0;i&lt;antCount;i++){
8 H0 t7 e# j8 u$ k" L                        int index=(int)(OriginPts*Math.random());
          ants.OriginPt=new Point(OriginPt[index]);
; i7 y) z0 P4 e                        ants.init();
* M, s& l# {# q' b  }</P>
<>                //清空信息素向量
* E) j; Y; L/ T' o# I5 J# K6 l                phe.removeAllElements();</P>
9 b+ H, Z9 a" }# b" @<>                //在每个食物点和窝点周围分布一定量的按照梯度递减的信息素，分配的是一个点为中心的半径为FoodR的圆，并且信息素按照半径递减
3 J! t6 n, d5 O3 W7 p  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));
                        for(int yy=-y;yy&lt;=y;yy++){
                            Pheromone_grid[1][(EndPt.x+x+width)%width][(EndPt.y+yy+height)%height]=(int)(1000*(1-Math.sqrt(x*x+yy*yy)/FoodR));
) ^- B2 P5 s3 \- j3 \) @9 ~5 d                        }
                    }
                }
$ O' d, \" R" R7 c4 A                for(int i=0;i&lt;OriginPts;i++){
                   for(int x=-FoodR;x&lt;=FoodR;x++){
  @1 q2 u0 R9 Y8 a1 f                        int y=(int)(Math.sqrt(FoodR*FoodR-x*x));
                        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));
                        }
, m4 Q& R: u; B% ^0 t" e                    }
  X- e1 @& O) c                }</P>
<P>                //重画
" I9 z% }2 Y) Y$ P  canvas.repaint();</P>
8 o, B! k# u& a! L, ~<P>                //让程序开始运行
                //running=true;
6 q' r' q1 {6 A1 Y' c }
public void paint(Graphics g) {
  canvas.repaint();
}</P>
<P>
0 v  o3 d; s& h; K" |public static void main(String[] args) {
    Antcolony applet = new Antcolony();
, Q1 G! t" q+ s4 x4 H: X  x    applet.isStandalone = true;
, s# V8 ?" O% H7 Q4 R; O9 ]' M, b% p    Frame frame;
    frame = new Frame() {
      protected void processWindowEvent(WindowEvent e) {
6 z; T# r; M/ L% X( U' W- B+ n        super.processWindowEvent(e);
7 ?4 v4 M  H8 j        if (e.getID() == WindowEvent.WINDOW_CLOSING) {
          System.exit(0);
& n9 b, x  J1 D4 e        }
      }
' o7 n! _- {7 G) w* r, o- q      public synchronized void setTitle(String title) {
        super.setTitle(title);
        enableEvents(AWTEvent.WINDOW_EVENT_MASK);
      }
1 n2 ]& @  Y: s- o8 x; E    };
9 q* Y" v! P! t  B7 P$ n2 v" S    frame.setTitle("Applet Frame");
$ p) g9 P2 k7 \8 E    frame.add(applet, BorderLayout.CENTER);
7 x" |, p' y7 E5 L# u; q8 I! f    applet.init();
0 B% o# _3 q% j" ~    applet.start();
    frame.setSize(300,320);
! M$ @1 H( O2 @5 @    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    frame.setLocation((d.width - frame.getSize().width) / 2, (d.height - frame.getSize().height) / 2);
3 ?* y+ R  t) ?5 P; A, C! h% x$ V    frame.setVisible(true);
  }
4 ]6 s8 w9 S3 R) D  public void start()
% R0 }$ d& q' V* G. z0 U  //下面三个函数是控制线程的
; L) b' [/ ~- l) n {
3 ]5 Q0 q3 D/ k3 S8 d  if (runner == null)
  {
& e- J) a" G3 B8 ^1 K   runner= new Thread(this);
   runner.start();
$ H- _# t/ P: S' C. w# a/ G5 c   //running = true;
5 Z2 U: |/ c" i' v, u  }
}</P>
" {8 |/ m! Z; a3 W4 j/ p0 g<P> public void stop()
{
  if (runner!=null)
" @( V) [8 S* e: n* p: S  {
   runner.stop();
4 E- H1 B2 k& i$ f   runner=null;
& q+ S- K# N/ [/ a- U7 Z   running = false;
  }
$ f9 m4 G) v% t# k' Z2 e" B! E9 y }</P>
% x/ h& C( V  ^<P> public void run() {</P>
<P>  int i;
; s3 r9 s0 `& B* Z* i5 j# U                //线程一直运行下去
2 h# Z3 G. [% `  while (true) {
$ g4 O6 m9 S& I( e          if(running){
       //如果开始动画，就进行canvas的处理
                          canvas.process();
                        }
    try { Thread.sleep(delay);}
    catch (InterruptedException e) {
  U  y8 f) e$ B3 |; q; o4 }   }
  }</P>
<P> }
        public boolean action(Event evt, Object o) {
      if (evt.target == btnMap) {
                //开始编辑地图面板
# f4 {* f* P! o6 z+ ^# \  z' J' p   running=false;
# Y& ]: E4 G  ~6 {0 G  Q1 u' M                        btnStart.setLabel("开始");
   MapPad ctl = new MapPad(this);
                 ctl.setSize(308,380);
( Q+ F2 C0 {& ]. P& D' o% L                        ctl.show();
7 x2 N# E3 ~* S                        return true;
1 m4 p+ @& P: h1 h' G  }else if(evt.target == btnStart){
                  if(!running){
                    //如果刚刚按下了重置按钮就重新初始化一下
                    if(reset)reinit();
                    btnStart.setLabel("停止");
                    reset=false;
                    running=true;
                  }else{
: j7 ]9 F9 I! W1 ?( x5 M- G                    btnStart.setLabel("开始");
/ H( |5 L% F8 a& l                    running=false;
                  }
                  return true;
) Z* E- V* A; M6 D                }else if(evt.target == btnReset){
                  running=false;
                  int j=0;
                  //表示已经按下了重置按钮，以便下次开始的时候进行重新初始化
                  reset=true;
; {, Z* _6 L. n  f, `- K: q                  repaint();
                  btnStart.setLabel("开始");
                  return true;
                }else if(evt.target == btnConfig){
4 Z# n5 H" B4 N" D5 E/ T                        running=false;
                        btnStart.setLabel("开始");
     Configer ctl = new Configer(this);
2 G8 l+ w4 ~" v. s8 w                 ctl.setSize(300,300);
                        ctl.show();
: p) J% f1 W. l2 \8 A8 Q( I( E1 J9 A) L                        return true;
                }else if(evt.target == choPDraw){
                  //选择画信息素的模式
                  drawPhe=choPDraw.getSelectedIndex();
* B! l5 s$ V; U0 M6 E% n                  if(drawPhe!=1){canvas.repaint();}
3 u1 [2 \4 w- s, r" A3 \0 y                  return true;
                }
                return false;</P>
* L) K6 z! O4 X0 g' s8 P<P>        }
# H2 Q* N. h3 D0 X. d /**Destroy the applet*/
2 F- j' O" U7 k- p& u+ T* a  public void destroy() {
  //当结束程序的时候，把线程也结束
* s' h# |# L2 S7 x# O    if (runner!=null)
    {
  w. q. k7 U  n& Z       running = false;
       runner.stop();
* [! n6 V4 T  r$ B+ n       runner=null;
* W" j! o. {, ]8 q  i% P    }
  }</P>
/ J  ~2 m$ v+ c9 x1 Q<P>}
% a- J3 P4 J( A& g, D</P>
5 j% V; p3 G/ U8 E$ n

4 L* _  @1 v% D
8 O# t* t1 ^; Q; q$ g; _& h  j. V<P>package ant;
1 t* {) M' B3 Y  w1 Wimport java.awt.*;
* b0 I& v& X/ K8 B2 I$ m: E1 l' X9 limport java.applet.*;
# ~, t3 X/ v. u3 fimport java.util.Vector;</P>
  E" p( e; q) E% M5 K' v<P>public class ant{
( X/ k0 S3 j# l. P1 m, i. V Point nowPt;//当前点坐标
+ k; {" t: ~6 d int VR;//速度，每次蚂蚁能走动的最大长度
  int id;//标识
  Point lastPt;//上一点坐标
  v* _( ?9 D! U9 b1 y Color color;//蚂蚁的颜色
# s4 r8 l* h$ Z4 v( N8 _% I) R: \ Color back_color;//背景的严肃
int height,width;//世界的尺寸
        int Phe;//每次释放信息素的数值
Antcolony local_colony;//主程序的指针
. P, Q* {; H' A        Vector HistoryPoint;//记录一次觅食过程历史上的所有点
        double Main_direct;//主方向
        Point FoodPt;//记录的食物点，是否找到时候判断用
        Point OriginPt;//窝的坐标
5 H  ]9 v9 m' ^4 j8 o- C        Point AimPt;//目标点，是窝或者食物
        Point StartPt;//起始点，是窝或者食物
! O: d4 w8 }/ t6 n  l        int FoundTimes;//找到食物或者窝的次数
        int Max_Pheromone;//最大能够释放的信息素
, x  I: F/ z  _" J        int Pheromone_count;//当前还拥有的信息素的总量
# `6 i6 `5 z6 x  a. y' h        boolean Judged=false;//判断寻找目标点的工作是否已经进行了
        double mistake;//犯错误的概率
        int memory;//记忆走过点的数目
$ r, E% R, A' z2 E, G: T& }# P* D        double Count_distance;//走过的总路程,为单程的路程，也就是说找到食物或者窝就从新计数了。
        public double Min_distance;//当前这只蚂蚁再没次往返的时候的最小总距离
  B( ^) r- [* V+ @% D+ I! H. G public ant(Point nowpt,int vr,int idd,Antcolony colony,Color c,double mist,int mem){
$ C4 c4 o+ ?3 I: Y+ u; u  nowPt=new Point(nowpt.x,nowpt.y);
# Q  C, h4 }: w: v8 U  B/ p* i                OriginPt=new Point(nowpt.x,nowpt.y);
/ e2 V' L" h: f9 e: g+ _% w" S                FoodPt=new Point(nowpt.x,nowpt.y);
. ~) k. f5 ~, ]                StartPt=new Point(nowpt);
                AimPt=new Point(nowpt);
                lastPt=nowPt;
1 `$ w# Q: z0 q3 f; j0 x' U/ C! ^$ i  VR=vr;
  id=idd;
  color=c;
  back_color=Antcolony.BACK_COLOR;
# ^% o, {( M# G& c+ D9 C0 k) G2 k* h, {$ A  height=Antcolony.height;
  width=Antcolony.width;
$ i) e$ \6 u% ~  local_colony=colony;
  e/ I, a/ P% M2 Z; c6 ?5 }0 g                Phe=200;
' N- g/ U  A9 t4 A# ~                mistake=mist;
! |7 x! U, S: U1 J( M5 d8 c% y                HistoryPoint=new Vector();
8 S- t' k4 r' ?) W7 L                Main_direct=-1;
                FoundTimes=0;
                Max_Pheromone=local_colony.Max_Pheromone;
  O9 n2 L1 _2 }. w( y  |8 p/ }                Pheromone_count=Max_Pheromone;
                memory=mem;
/ E' F* `6 e, H9 g  g1 v4 {/ J                Count_distance=0;
                Min_distance=-1;
" Y0 Z. N8 p! ~! m1 ?3 @ }
! ?; q! t8 m9 Y5 B8 X        public void init(){
8 G9 X9 d  m0 k/ n/ p# k& m* B          nowPt=new Point(OriginPt);
          lastPt=new Point(OriginPt);
          FoodPt=new Point(OriginPt);
          AimPt=new Point(OriginPt);
          StartPt=new Point(OriginPt);
% u: Z* P7 }/ o' u* O& F% l          HistoryPoint.removeAllElements();
          Main_direct=-1;
          FoundTimes=0;
          Pheromone_count=Max_Pheromone;
          Count_distance=0;
( p* p2 ^3 p% }) H" |% p          Min_distance=-1;
; D3 E6 B2 @. q9 E, f& I: y* P        }
* H) y3 t/ l( z# o5 @ public void Draw(Graphics g) {
  b' u! K' A  ^; j! U          //把蚂蚁在屏幕上画出来，先擦除上次画的点，然后再画蚂蚁现在的点。
  g.setColor(back_color);
  g.fillOval((int) lastPt.x,(int)lastPt.y,1,1);
  g.setColor(color);
  g.fillOval((int) nowPt.x, (int) nowPt.y,1,1);
& c4 b% Z" S) y }
public void Process(){
2 z, ^+ \1 Z) F+ c. _        //这个函数是蚂蚁进行决策的主程序，首先判断蚂蚁是否已经找到了目标点
        //（目标点在没找到食物的时候是食物点，找到以后是自己的窝）
        //然后计算蚂蚁的主方向，也就是让蚂蚁的爬动有一个惯性，当没有信息素作指导的时候蚂蚁按照主方向运动
        //开始搜索自己周围的空间信息，包括有多少信息素，是否有障碍物。最后根据信息素的大小决定移动到那个点
5 _# V. B+ z0 i$ i) A        //根据决策的目标进行真实的移动，其中包括了避障的行为，洒下信息素。</P>
+ ^0 C" V2 u2 L- n5 B
<P>        if(Judged==false){
4 a' j$ e6 p% t0 O  v" u; b          //如果已经判断完结束与否了就不进行再一次的判断了，也就是说目前蚂蚁已经到了目标点，
          //如果再判断，它就会在目标点原地不动了，因此这是候不判断，让蚂蚁走起来
          if(JudgeEnd()){
              //判断，如果找到了目标点那么就退出该程序
              Judged=true;
              return;
8 b5 ]  y. i" k, w% P1 x. g. N          }
' K: T; `* S  p! B0 M        }
! g: g8 `/ m* b6 J5 F; A& @        Judged=false;
        //如果没找到，就选择一个方向，这个方向是主方向加上一个随机扰动得到的，有SelectDirect函数完成
        double direct=SelectDirect();</P>
4 b5 Y1 A; g+ ^2 E5 z6 W<P>        //下面是如果根据计算的移动方向得到蚂蚁的下一点，即deltx,delty
        int deltx=0,delty=0;
3 j/ y; D7 t* V4 @" f9 y( |0 s        //direct是方向角，根据方向计算位移
        deltx=(int)(VR*Math.cos(direct));
        delty=(int)(VR*Math.sin(direct));</P>
5 a, m3 }1 m1 d2 h<P>        //kind表示当前蚂蚁是在找食物还是在找窝，如果是找窝就是1，找食物就是0。
2 M; J" W0 C4 Q- W2 ?8 b: g5 x        int kind=FoundTimes%2;</P>
<P>        //计算当前点的信息素，注意，如果获得的信息素总跟kind变量相反，
        //也就是说，如果当前蚂蚁找食物呢，那么它所关心的信息素就是找我的蚂蚁留下的，反之亦然。
        int here=local_colony.Pheromone_grid[1-kind][nowPt.x][nowPt.y];</P>
0 }" n4 B3 Q7 ^1 c- ^% w<P>        //记录搜索的环境中找到的最大的信息素
# s$ p. z/ E* A4 {+ b        int maxphe=here;</P>
<P>        //记住根据主方向角得到的位移，如果信息素并不能告诉蚂蚁应该往那里走，那么就要根据主方向角决定了
          int deltx1,delty1;
; v9 M( V2 R  _4 l. ?          deltx1=deltx;delty1=delty;</P>
. F2 ?3 K( V$ B7 K" R0 W' j<P>        //开始搜索环境，搜索的空间是以当前点为中心，VR为半径的四方形内，即VR/2*VR/2的正方形
8 l+ h8 f9 v& X7 n5 R1 d& [" U          for(int x=-VR;x&lt;=VR;x++){
             for(int y=-VR;y&lt;=VR;y++){
                //xx,yy表示搜索到哪一个点了，+width然后再%width是为了让坐标循环起来，
                //在这个程序中，坐标是循环的，也就是在一个球面上
                int xx=(nowPt.x+x+width)%width;
4 Z, M4 [3 L* j8 r. K; L) p) }1 O                int yy=(nowPt.y+y+height)%height;</P>
<P>                //循环的时候要除去当前点。
# R7 o5 n! b: K3 D                if(x!=0||y!=0){
                  //的到要搜寻的点的信息素
                  int phe=local_colony.Pheromone_grid[1-kind][xx][yy];</P>
" c0 ]4 e) o: N& F3 D( f<P>                  //如果搜索点的信息素比已经找到过的信息素多
                  if(maxphe&lt;phe){</P>
<P>                      //如果当前点的信息素是0，没说的，赶紧上正轨，否则，就要根据随机数
                      //以mistake来决定蚂蚁犯错误的概率，即如果犯错误，它就不按信息素最大的方向走
) N* R( a$ M5 H8 u7 r: }                      double ra=Math.random();
                      if(here==0||ra&gt;mistake){
                          boolean found=false;
                          //查一下内存最近走过的memory的点数，从而避免当地转圈
                          int size=HistoryPoint.size();
! T- C$ k1 l( m# I3 i                          int minsize=memory;
, M& ^, `& P6 o# Z. `) e: E                          if(size&lt;memory)minsize=size;
- N, u$ V' W, Z/ h2 d) B2 K                          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){
                                found=true;
8 M: _4 r/ G* O, x- K                                break;
% W* w4 I: O  P) U, n( Z1 g7 S! B                             }
                          }
+ C" r. z, j# q: t& F; X; e                          if(!found){
                            //如果没有原地转圈，那么记录信息素。
7 y0 V& Q0 K, G. a* M/ e. a                            maxphe=local_colony.Pheromone_grid[1-kind][xx][yy];
                            deltx=x;
8 u- P8 I8 ^$ o- ?+ N; R! U4 V                            delty=y;
                          }
                      }//end here==0||ra&gt;0.001
                    }//end maxphe&lt;here
: N( M: t6 G- a8 r8 T" a1 H                }//end if x!=0
; Z/ r6 d: l. o% |( u6 a' B            }//end for y
; z" T0 Q& ~4 N$ A& y4 g: q3 t) U        }//end for x
/ ~1 d4 Y" o, \: G' ^' I        Point pt;</P>
<P>        //根据获得的信息的来的位移deltx,delty，来具体的进行移位
6 y+ ~7 C) F& S/ @( _        pt=Evade_obs(deltx,delty);</P>
<P>        //如果卡住了，就根据主方向来确定位移，如果主方向也卡住了，那蚂蚁就会随机变换自己的主方向！
! t: ]( p% W# V9 o! J; d9 X        if(pt.x==nowPt.x&amp;&amp;pt.y==nowPt.y){
4 j. Y+ M- `* H$ `+ A# u" N          pt=Evade_obs(deltx1,delty1);
        }</P>
<P>        //播撒信息素
' m  M4 y7 U& `4 c' A        Scatter();</P>
# f! r' r9 D& Z& `7 j<P>        //记录走过的距离
, ?7 i3 {' s) o. ^        Count_distance+=Distance(lastPt,nowPt);</P>
6 G6 H. J6 [( K7 R5 h3 J3 f( {$ _<P>        //改变当前点位置
# y% X! Q& P9 f) b+ r        lastPt=new Point(nowPt.x,nowPt.y);</P>
; X0 B) \9 Z" f, v  M# r6 W<P>        //根据memory的大小记录走过的点，并忘掉memory以前的点
% S1 O5 r; F2 _' G/ p& k        HistoryPoint.insertElementAt(lastPt,HistoryPoint.size());
& Z; m7 T+ p2 }6 _* u4 s$ t        if(HistoryPoint.size()&gt;memory){
          HistoryPoint.removeElementAt(0);
        }
        nowPt=new Point(pt.x,pt.y);
8 ^7 ?/ E+ L# s: x) O: e# H     }</P>
<P>
        private void Scatter(){
        //释放信息素函数，每只蚂蚁有一个信息素的最大含量max_Pheromone，
8 H: O" ~5 N9 j        //并且，每次蚂蚁都释放Phe单位信息素，并且从总量Phe_count中减去Phe，直到用完所有的信息素。
& n- q* k' v: G7 D: F( q+ ?5 W# t            if(Pheromone_count&lt;=0)return;
            //决定释放信息素的种类
& S) h. C5 K" z/ S0 }# m; [$ V% _1 _            int kind=FoundTimes%2;</P>
# |( }  Q- t4 S) Q% f<P>            //获得当前点环境已有信息素的值
            int Phec=local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y];
            boolean ofound=false;
8 s/ e) _4 o7 Y, y            if(Phec!=0){
                //如果当前点已经有信息素了
/ y2 n& V# O9 T& F+ v# d' B                for(int i=0;i&lt;local_colony.phe.size();i++){
                    //在信息素向量中查找该点的信息
6 n: o3 n& c0 q! r0 l' E: ?: i. R& b                    Pheromone ph=(Pheromone)(local_colony.phe.elementAt(i));
                    if(lastPt.x==ph.x&amp;&amp;lastPt.y==ph.y&amp;&amp;ph.kind==kind){
                        //找到了，则看看蚂蚁所在的位置是否是刚刚走过的，如果不是才撒信息素
" y2 M) J$ L2 A                        int size=HistoryPoint.size();</P>
<P>                        //如果在表中找到信息素，则用ofound记录。
, ?- k( X! J$ u. c6 G% R/ p                        ofound=true;
; ~! }* W- P6 q' {, l3 f, V                        boolean found=false;
                        if(size&gt;4){
                           for(int j=size-4;j&lt;size-1;j++){
9 `# Q9 v7 F9 t% H3 x" y                              Point pt=(Point)(HistoryPoint.elementAt(j));
: N7 Z& W" T) |4 g+ |& d                              if(pt.x==lastPt.x&amp;&amp;pt.y==lastPt.y){
+ a; l) ^( U. F9 C* l8 M                                //如果当前点重复了以前走过的路，就不释放
                                found=true;
0 ]) s, X7 o7 l$ F, U                                break;
* \- U7 |; K7 |5 [: |, [1 a9 Q                              }
                            }
8 G4 p. \" d' y4 f, G8 p                        }
+ N1 Y  }8 J' U' I1 q                        if(!found){
1 B* u: E7 u* y( K" n) u- F                        //如果当前点不重复，则开始撒
                             ph.Add(Phe);
$ N9 p5 G0 a) e! d                             local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;</P>
+ e3 i0 O; B7 M5 D7 N2 d3 S<P>                             //让还剩下的信息素总量减少
                             Pheromone_count-=Phe;
                        }
) ^% i% K' }. Q; i                        break;
% n+ \+ {8 q6 z  W                    }
2 B$ N& W% N' e& t# s  R* g& ~                }
              }
          if(Phec==0||!ofound){
& U5 k% n4 C3 _9 U6 [            //如果当前环境没有信息素，或者当前环境的信息素来自窝或者食物，则新建一个信息素元素放到列表中
  A# A! O" r, H1 O" H* e# o                Pheromone ph=new Pheromone(lastPt.x,lastPt.y,local_colony.phe.size(),local_colony.Delimiter,id,local_colony,Phec,kind);
8 ]( w9 u* L9 P1 X) i                ph.Add(Phe);
                local_colony.Pheromone_grid[kind][lastPt.x][lastPt.y]+=Phe;
3 V  G+ S' r  l( J1 T                local_colony.phe.addElement(ph);
, W+ |6 ?2 g! U# Y                //让还剩下的信息素总量减少
                 Pheromone_count-=Phe;
           }</P>
# t+ w& L; @) |7 Q' T<P>           //根据还剩下信息素的量调整释放信息素的数值Phe，这里为线性模型即Phe=0.0005*Pheromone_count
           //如果把剩余信息量看成数组count(n)的话，那么根据本模型，
7 @% z5 Q+ @" W9 ^7 V. H6 q           //count(n)满足下面的递推公式count(n)=(1-0.005)*count(n-1)
$ Z+ p( [; V& D& _; r$ \6 \           //也就是说count(n)以几何级数的速度递减，这样，蚂蚁刚走出的地方信息素远远高于后走的地方
           //这个模型是否科学？有待研究
% p2 ?, G+ n& v0 r           Phe=(int)(0.005*Pheromone_count);</P>
. H, G/ K" b; o1 G& l0 Y7 ^/ A<P>           //如果剩余信息素已经太小了，则按照等差数列递减
: o; F) d" q8 P           if(Phe&lt;=10)Phe=10;
% D; c3 n& H* z' x- G! {        }
$ ?/ V' [) \* _$ S. I: \( Zprivate boolean JudgeEnd(){
! L$ e4 q% N% o+ r0 g    //这个函数判断是否已经找到了目标点
  u. h! V5 B1 {1 B) P& `    //首先获得当前蚂蚁是正在找窝还是在找食物。
& U9 r' B, \  a, ^    int kind=FoundTimes%2;
    if(kind==0){
- p3 W9 O; w2 Z8 B. X4 O        //如果是找食物，那么需要把所有的食物点坐标与当前点比较，距离小于VR就认为是找到
/ v8 X0 Y- D4 d  J# t' T4 i        int i;
        for(i=0;i&lt;local_colony.EndPts;i++){
            if(Distance(nowPt,local_colony.EndPt)&lt;=VR){
              //如果找到了食物，就直接移动到食物点
  F: `8 L6 ^2 |8 o& i              lastPt=new Point(nowPt.x,nowPt.y);
4 R* r; e# m8 H  k              nowPt.x=local_colony.EndPt.x;
. T( a! U+ W6 C9 \5 Q' R$ F/ X              nowPt.y=local_colony.EndPt.y;</P>
) F7 W) ^$ A7 L. N<P>              //计算最后的总距离
. A# w, I8 h7 r              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
9 {3 Y, [6 d9 L: ^, h                 Min_distance=Count_distance;
* G! j5 I5 z3 l9 E& Z              }
              //清除总距离记录
              Count_distance=0;</P>
<P>              //同时记录这只蚂蚁的目标点是它的窝，起始点是这个找到的食物点
9 \' S3 n& Q9 G* \              AimPt=new Point(OriginPt);
              StartPt=new Point(nowPt);
              //并把当前点标为自己找到的食物点
              FoodPt=new Point(nowPt.x,nowPt.y);</P>
<P>              //找到了食物就把找到次数+1
              FoundTimes++;</P>
  r- B0 h: M1 U<P>              //改变主方向为原来方向的镜面反方向
6 S3 }! Q! r$ F6 O4 s7 C7 D( M              Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
<P>              //重新把自己能撒的信息素置为最大值
9 R$ v- N2 ?( ?5 j5 w4 s+ _2 f% V5 E              Pheromone_count=Max_Pheromone;</P>
<P>              //清空记录的所有点
              HistoryPoint.removeAllElements();</P>
! Z# R7 @* C, l/ j1 F- o8 W<P>              //返回找到为真
# U8 Q. U$ X- A" E! }2 G              return true;
+ W* ^! [4 I* Y" f+ j  b            }
8 X6 @- ?7 l7 m* ]- @6 x; w        }
3 v- f+ s$ W9 W0 J  r      //否则没找到
      return false;
    }
; p3 t7 Q! i7 x1 ^& o    if(kind==1){
: p* [7 T) S* r3 P9 ?        //如果是找窝，因为目标点已经明确，所以比较目标点和当前点的距离，小于VR表示已经找到
0 P: d3 Z7 D! |& ^        if(Distance(nowPt,AimPt)&lt;=VR){
( ?5 B) R6 j# I& u# k            lastPt=new Point(nowPt.x,nowPt.y);
3 @% Y+ {% ?8 k0 U0 F0 S6 _            //如果找到了目标，就直接移动到目标点
            nowPt.x=AimPt.x;
# ?+ H8 T; \2 e9 T! S) q2 t: u            nowPt.y=AimPt.y;</P>
- N; o. O, Q$ J/ Q<P>              //计算最后的总距离
2 M. c4 e% ?; X& F( @. S              Count_distance+=Distance(lastPt,nowPt);
              //比较大小，记录较小的距离
              if(Count_distance&lt;Min_distance||Min_distance&lt;0){
                  Min_distance=Count_distance;
              }
              //清除总距离记录
/ t) P9 t7 ~% P' x              Count_distance=0;
5 s- {+ T& B' E+ W7 r4 E9 y  p            //把目标点定为食物点，起始点定为窝
            AimPt=new Point(FoodPt);
            StartPt=new Point(OriginPt);</P>
4 R7 {0 p. _, c: D4 H9 V% f: \<P>            //重新置信息素
            Pheromone_count=Max_Pheromone;</P>
" M* }# ~1 g( I1 V$ h<P>            //清空历史纪录
            HistoryPoint.removeAllElements();</P>
<P>            //主方向反向
            Main_direct=(Math.PI+Main_direct)%(2*Math.PI);</P>
" e- P5 B$ L0 y9 C<P>            //找到次数+1
! D$ i# V+ D0 L! }! |            FoundTimes++;
            return true;
, S7 @( q0 u/ B( J" s        }
        return false;
    }
# D% [1 t1 F3 i6 c8 Z! x; l5 p    return false;
}
1 T& T) z$ e! I        private double SelectDirect(){
                //选择方向，最后选择的方向为主方向加一个随机扰动
$ ?& K/ P  K" b                double direct,e=0;
                if(Main_direct&lt;0){
% T0 Q) h& _+ B8 m7 h3 |, c                      //如果目前还没有主方向角，就随机的选择一个
        e=2*Math.PI*Math.random();
9 F5 H/ V$ H( e" v/ s0 M                      Main_direct=e;
5 E' g/ a+ D2 N8 Y" D                }
                //选择主方向角
1 _% S" [4 I# o- Y5 V" p                direct=Main_direct;</P>
<P>                //做一个随机模型，产生两个随机数，x,y都是[0,1]内的，这样x^2-y^2就是一个
                //[-1，1]的随机数，并且在0点附近的概率大，两边小
                double re=Math.random();
+ `+ U1 U" k9 n) ~* m1 d                double re1=Math.random();
                direct+=Math.PI*(re*re-re1*re1)/2;
                if(re&lt;0.02){
- h. j) ]# G" Z                  //以小概率0.02改变主方向的值，主方向的选取为从蚂蚁记住的点中随机选一个点，计算当前点和这个点之间的方向角。
                  int size=(int)(re1*memory)+1;
                  if(HistoryPoint.size()&gt;size){
                    Point pt=(Point)(HistoryPoint.elementAt(HistoryPoint.size()-size));
7 `8 o- d7 _9 ^: I/ M                    if(pt.x!=nowPt.x||pt.y!=nowPt.y){
                       Main_direct=GetDirection(pt,nowPt);
                    }
                  }
5 S1 o% C; x  e+ y                }
' Z8 p& d1 n7 c1 M: D$ z& ~0 I$ O               return direct;</P>
8 }1 J; p9 l( m! I2 |; @<P>        }
        private Point Evade_obs(int deltx,int delty){
              //这个函数根据决策的位移值进行敝张的判断，算出真实可以移动到的点
( u/ B8 O# ^4 S0 x; b+ z/ {              //要移动到的目标点是(nowPt+delt),当前点是nowPt，那么搜索nowPt到(nowPt+delt)
+ b" N9 {$ B  I7 R% j              //这条直线上的所有点，看有没有障碍物！根据直线的参数方程：
              //x=p1x+(p2x-p1x)*t,y=p1y+(p2y-p1y)*t;
              //其中t是参数，取值[0,1]，步长为abs(max{p2x-p1x,p2y-p1y})，
              //p1,p2在这里分别是nowPt和nowPt+delt
              Point pt=new Point(0,0);
              int x,y;
              int delt=deltx;
              if(Math.abs(delty)&gt;Math.abs(deltx))delt=delty;
              if(delt==0)return nowPt;
              for(double t=0;t&lt;=1;t+=1/(double)(Math.abs(delt))){
$ \! r% L. q( E5 Q5 x+ @3 F# Z' w                  x=(int)(deltx*t+nowPt.x);
                  y=(int)(delty*t+nowPt.y);
# a7 U8 I; a, N6 ~                  x=(x+width)%width;
% g4 V! @; J: Q( M% ?                  y=(y+height)%height;
                  if(local_colony.obs_grid[x][y]&gt;=0){</P>
<P>                     //如果移动方向发现障碍物，那么就改变目标点和主方向
                     //新目标点为障碍物前方的点，主方向随机取值
                     deltx=pt.x-nowPt.x;delty=pt.y-nowPt.y;
* ?5 x8 G* f/ p8 c1 K% F                     double disturb=4*Math.PI*(Math.random()-0.5);
9 E9 R0 p8 [6 I6 z, v5 [/ ^                     Main_direct=(disturb+2*Math.PI)%(2*Math.PI);
                     break;
6 J3 y6 l* G. Q  E% r( s2 ]                  }
                  pt=new Point(x,y);
! Q' z, K" F2 e; k6 }                }</P>
<P>                //计算得出实际能够到达的目标点
" _) h5 c9 a, Y8 _: ~8 ?  x=(nowPt.x+deltx+width)%width;
  y=(nowPt.y+delty+height)%height;
5 v- P( f& X+ V( Y         return new Point(x,y);
        }
$ g9 u4 h) N& k- W# E        private double GetDirection(Point pt1,Point pt2){
! e# J( K% V9 q) ~9 a        //这个函数为指定两个点pt1和pt2，给出pt1--&gt;pt2的方向角
        //此函数的难度主要在于，我们的世界是球面，因此需要从多个方向计算方向角，
: w, Z; }4 J" Y3 i* h0 s7 I# k        //其中方向角是所有可能的角中使得两点连线距离最短的角。
               double e;
               int deltx1=pt2.x-pt1.x;
8 c' R% z" f; n2 a! e               int deltx2;
               if(pt2.x&gt;pt1.x)deltx2=pt2.x-pt1.x-width;
               else deltx2=pt2.x+width-pt1.x;
3 k* g- K8 U' C8 k9 Z' Y% I7 A/ U+ ?               int delty1=pt2.y-pt1.y;
0 X5 O  N; `; W. \2 \               int delty2;
               if(pt2.y&gt;pt1.y)delty2=pt2.y-pt1.y-height;
! o' d9 X6 }7 m               else delty2=pt2.y+height-pt1.y;
" _: j3 Y' b6 l" k' V               int deltx=deltx1,delty=delty1;
- u* c/ }% f, T  N1 b/ m               if(deltx==0&amp;&amp;delty==0)return -1;
               if(Math.abs(deltx2)&lt;Math.abs(deltx1)){
    deltx=deltx2;
               }
        if(Math.abs(delty2)&lt;Math.abs(delty1)){
% T3 o4 e) d3 B" ]7 F  C                  delty=delty2;
* p( y7 N. b, h. {0 z               }
/ _6 V, Z0 r9 x! Q               if(deltx!=0){
& R* j" Q* W/ p! \                    e=Math.atan((double)(delty)/(double)(deltx));
4 \; n; C1 `/ Z; s- i                    if(deltx&lt;0){
                       if(e&lt;0) e=e-Math.PI;
! Q7 E0 [' \- z' @( l3 b" ~                       else e=e+Math.PI;
" \5 I' y2 R+ m- T1 x6 }4 p8 _                    }
                }else{
                    if(delty&gt;0)e=Math.PI/2;
" s* P0 g& U/ m; K% v0 |                    else e=-Math.PI/2;
- Q4 e- q7 z  ?6 _$ g0 ~                }
0 D) }; M! a  f                e=(e+Math.PI*2)%(2*Math.PI);
                return e;
        }
        private double Distance(Point pt1,Point pt2){
        //给定两点pt1,pt2，计算它们之间的距离，难点在于世界是球面，所有有坐标循环的情况，
        //这里计算的是所有可能距离中最小的
" [6 p% Z. q' x. J& Z            int dx1=pt1.x-pt2.x;
            int dx2;
            int dx,dy;
            if(pt1.x&gt;pt2.x)dx2=pt1.x+width-pt2.x;
            else dx2=pt2.x+width-pt1.x;
3 \& j9 x# f: l- K: j            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 m* Q7 \9 [2 W' O8 V: Q            else dx=dx2;
            if(Math.abs(dy1)&lt;Math.abs(dy2))dy=dy1;
0 h9 A  G3 m' j            else dy=dy2;
            return Math.sqrt(dx*dx+dy*dy);
        }
& z6 y! v, ~+ X8 ^$ }. F" o    public void clone(ant ant1){
" L" H' k$ G: J4 w" `& ^. J3 M# N. C        //把蚂蚁ant1的属性拷贝到本蚂蚁
5 W& s5 y8 e3 X7 S     nowPt=new Point(ant1.nowPt);
        OriginPt=new Point(ant1.OriginPt);
/ S' b7 I# O& N- o: o        FoodPt=new Point(ant1.FoodPt);
        StartPt=new Point(ant1.StartPt);
+ z, ~0 b1 b( l2 q! W; X9 I3 g% k9 }        AimPt=new Point(ant1.AimPt);
        lastPt=new Point(ant1.lastPt);
        VR=ant1.VR;
        id=ant1.id;
        color=ant1.color;
  Y8 c# [. M" e/ t# P        back_color=ant1.back_color;
7 `; \4 c  s: v$ i' q0 \        height=ant1.height;
        width=ant1.width;
' {7 m/ U2 ]" {& [$ A! P        local_colony=ant1.local_colony;
# G) Y) [6 q- P4 A+ ~1 {' J        Phe=ant1.Phe;
6 L  ]# k7 s2 `& P        mistake=ant1.mistake;
        HistoryPoint=ant1.HistoryPoint;
        Main_direct=ant1.Main_direct;
& ~; M6 d( @7 o) [$ h        FoundTimes=ant1.FoundTimes;
- k, t4 p5 X8 h' l9 ~        Max_Pheromone=ant1.Max_Pheromone;
) E2 D( n" T% B+ q. a# F        Pheromone_count=ant1.Pheromone_count;
- s" c7 I! B  C5 _8 U; p( p( w2 I        memory=ant1.memory;
! H7 ]3 p& `* z        Count_distance=ant1.Count_distance;
: E/ v5 [  Y4 e) D        Min_distance=ant1.Min_distance;
    }
6 E# \! u, U& m* i}</P>