问jheatbugs-2001-03-28中某些代码

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
( {6 m1 n; ^, T$ u' l0 h
public Object buildActions () {
    super.buildActions();
7 \/ A6 s, n9 @/ L: P   
, l3 T, F7 t4 j2 w    // Create the list of simulation actions. We put these in
! T9 |: U/ K5 w, ?1 Q4 j9 v    // an action group, because we want these actions to be
4 j  {! F6 S, }    // executed in a specific order, but these steps should
$ b: y& ^8 P) ~2 {- {1 s. `; g    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
, y$ {+ n# Z5 n6 h    // object, or ForEach object in a collection.
        
    // Note we update the heatspace in two phases: first run
    // diffusion, then run "updateWorld" to actually enact the
; u4 z$ `1 i8 b7 h2 x* N    // changes the heatbugs have made. The ordering here is
    // significant!
: X8 t& N+ R& ]+ Y2 d3 ^/ f        
    // Note also, that with the additional
: Z' B' N' z" R: a* N3 F8 I    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
6 r9 t: t' p! p, K    // their step rule.  This has the effect of removing any
4 _' d# n9 ]) }) ^& ?  N    // systematic bias in the iteration throught the heatbug
- E! P5 D1 m7 c2 U5 Z! G. U9 D$ H    // list from timestep to timestep
        
/ k& T- k, M7 T  y    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
    // order of iteration through the `heatbugList' will be
' n" y" q' l- f! m" ?    // identical (assuming the list order is not changed
    // indirectly by some other process).
   
5 {3 y; q% w8 b    modelActions = new ActionGroupImpl (getZone ());
" E, Y0 ?8 y) M! [
    try {
8 N4 c# a# S+ _" J7 D  L      modelActions.createActionTo$message
1 `$ `/ c' L7 Y3 N  g6 f( f        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
* ?# O- N7 \) w- _    }

9 y+ B- A+ E" `& M4 H- _2 t    try {
. z  B5 R/ X# C/ R      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
4 k' q. G. N$ P: }4 L/ j        new Selector (proto.getClass (), "heatbugStep", false);
$ w7 E2 c$ \( A) Y) i" i      actionForEach =
* q0 i* Q, a3 J' k' [        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
2 c' W& A: n3 H# ]$ ]  b         new FCallImpl (this, proto, sel,
' S" h9 |" J9 B/ z                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
# a  L4 z& X; P7 u) k0 D: k$ x   
    syncUpdateOrder ();

    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
" i' C! E+ x0 I* K2 K% {( j2 K    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
        
    // Then we create a schedule that executes the
    // modelActions. modelActions is an ActionGroup, by itself it
, K9 k, I' ^  b) K1 r% m1 V    // has no notion of time. In order to have it executed in
9 D6 _( ]# v/ u+ W: F+ P* }7 J    // time, we create a Schedule that says to use the
    // modelActions ActionGroup at particular times.  This
    // schedule has a repeat interval of 1, it will loop every
$ r0 M1 D  h, N( r9 W  }4 r- i% H    // time step.  The action is executed at time 0 relative to
5 ]* p& v& @, a5 Q2 P* l    // the beginning of the loop.

    // This is a simple schedule, with only one action that is
- W0 B/ l' c. N  Z    // just repeated every time. See jmousetrap for more
9 X4 }  y9 M6 ?( E    // complicated schedules.
0 }/ V! Q" S! J- q3 ~7 e  
    modelSchedule = new ScheduleImpl (getZone (), 1);
+ L0 Q9 c/ o; I, A    modelSchedule.at$createAction (0, modelActions);
        
/ D( t# _: M" H) M  f6 E/ ]    return this;
  }