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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
# p; b0 j0 m5 p& K; G: }
# h) W" O# p0 Y( k) |1 F public Object buildActions () {
    super.buildActions();
   
    // Create the list of simulation actions. We put these in
    // an action group, because we want these actions to be
  A- [' x9 n  P# d/ ]# x, N& f6 o" j    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
6 H, l7 P/ S: i4 N! s    // called <foo>". You can send a message To a particular
    // object, or ForEach object in a collection.
$ d8 H. s; \- K6 J5 a/ T        
, r; \% A/ a0 Q8 B    // Note we update the heatspace in two phases: first run
# e& i+ O, [  _* a    // diffusion, then run "updateWorld" to actually enact the
) m* J! x3 v. J$ Y    // changes the heatbugs have made. The ordering here is
7 H7 y# J* G1 e: K, d    // significant!
        
6 S! W: R7 r, D# a4 T$ @8 m    // Note also, that with the additional
( x9 c/ L% g* `6 a; G& y4 K2 D2 ~    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
    // their step rule.  This has the effect of removing any
; ~- E1 G3 B- ^    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
# O7 x. v. Q% ]8 w, y  e2 {; ~        
    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
    // indirectly by some other process).
   
6 y2 ~- y1 e5 x( k    modelActions = new ActionGroupImpl (getZone ());

    try {
      modelActions.createActionTo$message
0 q( G- c2 g. S: @) I. u& _5 Y0 b9 N        (heat, new Selector (heat.getClass (), "stepRule", false));
/ z0 p1 R8 e4 H( T1 V    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
* g1 Z. V/ S; l$ P% v4 Y% ]8 v    }

( E( D! V( U. v/ q; Z+ E; i    try {
2 [5 u. y6 L9 r/ Y4 b      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
: {; Z6 G$ j& V3 i        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
; Z/ [- B3 a- Y$ w% l        modelActions.createFActionForEachHomogeneous$call
9 o, Y* |0 ?$ K$ \$ f1 M        (heatbugList,
         new FCallImpl (this, proto, sel,
  h9 n  ]9 i4 P                        new FArgumentsImpl (this, sel)));
' a8 v$ j! r( e* k6 h  c3 B" q$ X    } catch (Exception e) {
+ x' l! c: @" i/ J* @3 |! i/ z      e.printStackTrace (System.err);
3 ?1 ^/ ~( J) `$ v    }
   
    syncUpdateOrder ();

2 z' S- v/ {5 f6 X    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
( v* Q6 ]. `6 I      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
& o2 b) o! d) v* p4 e3 G# I        
7 N: J4 T3 R! v. X) D, S5 S2 p    // Then we create a schedule that executes the
    // modelActions. modelActions is an ActionGroup, by itself it
    // has no notion of time. In order to have it executed in
    // time, we create a Schedule that says to use the
+ S7 H6 t: O- x+ w2 Q    // modelActions ActionGroup at particular times.  This
, s# @9 m6 ]3 r5 }% z9 G    // schedule has a repeat interval of 1, it will loop every
+ t! B- z/ i5 h5 h; \/ S; [    // time step.  The action is executed at time 0 relative to
! I- R6 i- ?4 k- z4 \2 W" m7 _2 X    // the beginning of the loop.

& `% m3 G7 w# u4 h    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
3 t2 {& s. {  ^& C0 k    // complicated schedules.
  
8 ]1 o! e8 e9 b+ v    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
        
    return this;
0 p$ N/ L5 z$ B  k7 E6 ]# _8 r  }