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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
* U- Z, ^$ }& k" M/ [
& S+ k0 p7 _* J7 @1 h public Object buildActions () {
    super.buildActions();
, H) f1 D* A3 ?+ E   
    // Create the list of simulation actions. We put these in
    // an action group, because we want these actions to be
9 Z+ g8 j( V" V1 b; \* y" i1 T    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
6 H, y: k5 h" z" L2 g    // called <foo>". You can send a message To a particular
    // object, or ForEach object in a collection.
        
    // Note we update the heatspace in two phases: first run
2 o/ b, Z1 L) K9 E    // diffusion, then run "updateWorld" to actually enact the
- a6 Q; {3 Z2 }& j# ~    // changes the heatbugs have made. The ordering here is
    // significant!
. ?% D/ h; o5 A: t' b: O        
3 b9 V7 U; k% ~/ E' H    // Note also, that with the additional
% j$ q$ r& c8 S$ G& ~    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
/ V* o* k) Q: N  ~, U0 f% H' l    // their step rule.  This has the effect of removing any
* D3 i# {2 V& t4 g    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
        
: F7 Z" N* A  f- r    // By default, all `createActionForEach' modelActions have
0 E/ Y3 K& Y* ^, u! W/ @* c4 ]    // a default order of `Sequential', which means that the
2 h3 c2 d: w% e5 o) i% C7 P    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
    // indirectly by some other process).
# o( F& n6 ^2 W- G& ~   
& x2 U, x( _+ `  j& g- Q    modelActions = new ActionGroupImpl (getZone ());
$ V( l' H1 z- {
2 U6 M7 D! e0 `1 o    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

1 S9 T* D, e- x- g+ s9 t    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
( l* @' P) l2 B1 L      Selector sel =
! ?3 U4 M: G  ^% M' B! j8 S3 e        new Selector (proto.getClass (), "heatbugStep", false);
, ?: o4 Q+ _+ |5 n$ P. n+ ]' U      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
* H8 y6 ?' p5 }        (heatbugList,
& l8 _1 F2 }' b/ Q0 K8 p1 _         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
) X. X) E# A9 z& m   
& H6 C2 z# x3 K' J* v0 y, M& E    syncUpdateOrder ();

% J+ f! w2 v) h# {    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
, h% J& n0 s0 S  i- a    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
. G/ {( t  k5 G& v* ?        
    // Then we create a schedule that executes the
, d) E+ d" L, V  g( q    // modelActions. modelActions is an ActionGroup, by itself it
    // has no notion of time. In order to have it executed in
0 s8 J5 I, j+ N+ P0 e    // time, we create a Schedule that says to use the
3 j' n( x4 \* l) t    // modelActions ActionGroup at particular times.  This
. W" |& l" q& w; t* u1 W    // schedule has a repeat interval of 1, it will loop every
3 Y* w" |5 x; ~+ [2 ?    // time step.  The action is executed at time 0 relative to
; a1 G* L; B3 T  Y& s    // the beginning of the loop.
, q' u, c$ C) W+ V, ?  u
    // This is a simple schedule, with only one action that is
+ U4 w6 P) Z3 i    // just repeated every time. See jmousetrap for more
    // complicated schedules.
  
    modelSchedule = new ScheduleImpl (getZone (), 1);
  Y) D  c: `' X/ _  O  L" s4 ?    modelSchedule.at$createAction (0, modelActions);
% @3 o/ a# B0 j/ d5 E$ W* P+ d        
' {, q* q+ ^- N! X1 t2 S, n    return this;
  }