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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
' L1 t+ j" c5 Q$ J6 F, k7 q+ S# G
public Object buildActions () {
! d$ j0 M% I5 F4 p& f; l6 x    super.buildActions();
   
    // Create the list of simulation actions. We put these in
    // an action group, because we want these actions to be
. J; v6 b9 z1 |2 Q  W  `$ l    // 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
% n. z* z$ v+ d9 R7 `/ O    // object, or ForEach object in a collection.
        
' E' A7 r& B8 y0 M    // Note we update the heatspace in two phases: first run
% U+ B- l+ n, G- M, I/ k6 T2 J' o    // diffusion, then run "updateWorld" to actually enact the
    // changes the heatbugs have made. The ordering here is
6 U8 z% J7 E% [! r    // significant!
        
    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
    // their step rule.  This has the effect of removing any
+ @  g+ E9 A+ J# ]$ \& U; _* ?$ m: Q    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
        
2 x. r) [- p$ ]0 X3 I) }: v    // By default, all `createActionForEach' modelActions have
* y! T; r2 L6 f    // 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
+ ]$ A- a0 G: `    // indirectly by some other process).
6 v+ r9 d+ F0 T   
    modelActions = new ActionGroupImpl (getZone ());

2 T/ p" P+ V7 R3 r    try {
. I/ [9 Z/ f  p. a! N4 |! d      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
+ X: h5 r+ S$ A+ d3 a  V. d3 u    } catch (Exception e) {
( I6 u* Q6 U8 E6 ]  q8 T      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

    try {
4 r: i# d5 `. @& i/ J  k4 C/ Y      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
% m+ V. I+ k- Q      actionForEach =
' u0 s1 `$ T( }$ K2 p9 L7 n. ^        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
& w6 W  U; {. [/ `% ], _    } catch (Exception e) {
; X+ j- \6 b! H* f      e.printStackTrace (System.err);
    }
+ x% Y& O- f9 p1 M" C   
    syncUpdateOrder ();
5 w2 u$ z8 k# r0 p1 c
5 B* I) b# l. j    try {
! B; I. O2 b3 ]: K0 ?; |0 w      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
" G9 z. K6 k2 l) @* T' k    }
: o$ S& e5 Y# c4 |) I7 _7 U; h) t        
- P! G3 k# @8 C/ k" |    // 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
  z. \; Y- l; l5 D4 a    // modelActions ActionGroup at particular times.  This
    // schedule has a repeat interval of 1, it will loop every
9 I/ u: S% l; y  [    // time step.  The action is executed at time 0 relative to
, z' K: W6 \! x$ u( k- q    // the beginning of the loop.

# y/ }5 L  J( c1 r4 q7 y' d( R    // This is a simple schedule, with only one action that is
& U2 `/ y! w- b) U) _" n    // just repeated every time. See jmousetrap for more
) f& J! R+ {+ y$ `0 s    // complicated schedules.
; j) M: F& b. B7 l$ i  
    modelSchedule = new ScheduleImpl (getZone (), 1);
5 L$ G4 F  n7 I: k. z$ }; n  r    modelSchedule.at$createAction (0, modelActions);
        
! p% }$ R3 r  h    return this;
  }