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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
# q& p, v" O. O
public Object buildActions () {
    super.buildActions();
1 A' X. h# P' g! C* I   
! k5 I# E3 b4 O" m7 B: _! y3 R    // Create the list of simulation actions. We put these in
6 m) w+ w4 O, T* |    // an action group, because we want these actions to be
2 s% r# ~8 @, o& o$ |" c    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
% x( h6 R+ u- l- ~* [# ]6 T3 n    // called <foo>". You can send a message To a particular
    // object, or ForEach object in a collection.
        
) S9 j. ~, R6 ?. m7 f2 Z% J& ]    // Note we update the heatspace in two phases: first run
    // diffusion, then run "updateWorld" to actually enact the
    // changes the heatbugs have made. The ordering here is
  f  c0 W; z1 w& a    // significant!
, H) T- r- |1 q6 H) {        
& q9 t$ y) r7 Z' z) |5 ?$ j    // Note also, that with the additional
' @7 W5 k& o( n! r    // `randomizeHeatbugUpdateOrder' Boolean flag we can
" e2 I* r) f& ~) A    // randomize the order in which the bugs actually run
* q7 a! X+ q! p( `+ U& L! [7 L3 `    // their step rule.  This has the effect of removing any
* n. R8 o) \& Q% ~    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
        
    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
, o% ]% S8 D3 ^% [3 O3 {8 U    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
" H! j$ u- o0 S" U+ {9 x    // indirectly by some other process).
   
    modelActions = new ActionGroupImpl (getZone ());

8 u0 p- w# Z1 c  X' `6 Q    try {
6 W2 o6 g! ]5 C      modelActions.createActionTo$message
: u3 {; }6 F. p        (heat, new Selector (heat.getClass (), "stepRule", false));
) f" k9 r1 S3 k! j. p    } catch (Exception e) {
+ r0 S5 z- j: P. }* p      System.err.println ("Exception stepRule: " + e.getMessage ());
3 r$ u. z/ W0 @9 ~8 s    }
: y' j8 D/ X7 Z3 ?
" x( |: M# B$ n! h+ w! ]    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
2 ]+ |/ r% N! y1 w* R9 k        new Selector (proto.getClass (), "heatbugStep", false);
+ v' N, @( }$ C1 Z; k      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
         new FCallImpl (this, proto, sel,
8 y$ _5 f* T: L8 D2 c7 y2 W: `                        new FArgumentsImpl (this, sel)));
6 {( J3 C# ^- U+ I2 B2 Z  J    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
   
    syncUpdateOrder ();

1 }. E% e/ L) I/ a# v+ x    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
8 _% u( f1 W. N% D" ^      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
' B# a3 K  D( T% X        
    // 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
) W/ F/ r6 N- j5 v& H" y    // modelActions ActionGroup at particular times.  This
/ h  g* T. `* S# t/ J/ ]    // schedule has a repeat interval of 1, it will loop every
    // time step.  The action is executed at time 0 relative to
    // the beginning of the loop.
+ l" L1 A/ X5 Q7 c! \& f* p* b
  R& y  x! ^. O9 V2 ~0 j    // This is a simple schedule, with only one action that is
( e5 o7 d  B, s/ }% F4 S    // just repeated every time. See jmousetrap for more
    // complicated schedules.
  
    modelSchedule = new ScheduleImpl (getZone (), 1);
" T% z8 e1 Z& F, H3 \    modelSchedule.at$createAction (0, modelActions);
' L+ r, X  J) D1 S% a) }        
  S& E6 `7 `! {+ t  K. S0 k$ b    return this;
  }