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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
( u0 h( j' y* C8 W) r7 W3 `8 v
public Object buildActions () {
    super.buildActions();
' k- N" o7 O" g   
8 ^1 |  ~3 M2 N/ C# f4 ?1 T    // Create the list of simulation actions. We put these in
3 G( I, Z' p0 ?6 {7 U! i: x    // an action group, because we want these actions to be
: P  Y3 K0 f5 h, J    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
    // object, or ForEach object in a collection.
- R* O. z2 |4 \0 w        
0 Q. \2 |1 U" H3 D1 I    // Note we update the heatspace in two phases: first run
) O! [& o7 ^: z" R8 ~  U    // diffusion, then run "updateWorld" to actually enact the
    // changes the heatbugs have made. The ordering here is
    // significant!
        
1 t9 P, u' r0 ?; p; A7 }5 m1 k    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
9 f; C( D, I2 H6 }) ?! E9 W5 e, t$ R    // randomize the order in which the bugs actually run
. x8 y7 b% ~+ I  [$ ?" h) l, \& i    // their step rule.  This has the effect of removing any
8 ]2 V# I) g/ R+ k# u) X    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
$ M0 Z; k4 h7 X9 u( U        
    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
% }0 x: p& f. Y% m    // order of iteration through the `heatbugList' will be
9 H4 ]: g$ c' H$ ]: f  h% H    // identical (assuming the list order is not changed
$ Z% d+ G, z4 ^    // indirectly by some other process).
   
) j% d. Q) Q  n, n6 N# ?) H    modelActions = new ActionGroupImpl (getZone ());

! b0 j. C) ]7 y) k    try {
      modelActions.createActionTo$message
8 u- f) H6 a0 H6 y        (heat, new Selector (heat.getClass (), "stepRule", false));
0 C9 [) `+ Z8 S, a% ?+ |4 F    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
( X2 x0 y. C8 N4 ?6 Z        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
' H3 a# o& ~8 e        modelActions.createFActionForEachHomogeneous$call
! K* }) F8 |- ]        (heatbugList,
         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
+ T9 ?! c: `8 \% I% {6 M. S    } catch (Exception e) {
# t( f- g& ?  g# T5 {# J      e.printStackTrace (System.err);
    }
   
5 t0 Y& K/ _4 n' e& O" m    syncUpdateOrder ();

    try {
6 e: @$ t3 A' X6 b1 e+ x      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
! |" R& \' E; e( ]      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
        
9 R% R$ ]& T. L, i% g" k0 M: N    // 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
! F! \+ v* Y; t0 t) ^# S    // time, we create a Schedule that says to use the
% m) E& q6 P. b$ {% i    // modelActions ActionGroup at particular times.  This
    // schedule has a repeat interval of 1, it will loop every
/ d4 p7 e, P9 R6 m9 `    // time step.  The action is executed at time 0 relative to
    // the beginning of the loop.
  f- E. V+ r# b% B) L: N
    // This is a simple schedule, with only one action that is
( w  s7 c6 Q% v4 y4 |    // just repeated every time. See jmousetrap for more
    // complicated schedules.
( ]+ H8 w- m+ M/ B5 ^" D7 b& ^  
    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
        
6 p9 r" T# F7 V! x8 c: A    return this;
& I, x! u0 W$ D; n6 `  }