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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：

public Object buildActions () {
2 v( z1 d6 U' d0 s* j. j% L: ]    super.buildActions();
2 |* o: o' z" |- q7 h   
    // Create the list of simulation actions. We put these in
6 a/ G; X* g' Z. y$ H    // an action group, because we want these actions to be
* k: Z4 J# B  s- T# @, d+ ?" h/ Z    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
0 S- n6 J  V, s/ |    // called <foo>". You can send a message To a particular
    // object, or ForEach object in a collection.
  Q6 m" |2 J, Q, T) F        
    // Note we update the heatspace in two phases: first run
( A( c3 y/ v4 U" \    // diffusion, then run "updateWorld" to actually enact the
7 R0 J" I  P/ e9 h, r- z8 F5 O, I' e! C    // changes the heatbugs have made. The ordering here is
0 _; g* h9 T$ ?/ z, p; @  f    // significant!
        
0 `+ x' k) M6 m  @    // Note also, that with the additional
6 k- e3 x5 S1 i1 x4 c5 i    // `randomizeHeatbugUpdateOrder' Boolean flag we can
# u; Y5 [& I: k$ N& [: U0 J: B    // randomize the order in which the bugs actually run
    // their step rule.  This has the effect of removing any
- X; Y# s# ]+ A: |  V    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
        
6 Q  s) x6 V" ~6 X3 Y    // By default, all `createActionForEach' modelActions have
3 h+ v3 z5 S/ Z: O) W2 Y' T    // a default order of `Sequential', which means that the
4 k' i" l: p- a. ^- r! J0 [    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
* P. G2 G" G7 f. T9 F, p1 B    // indirectly by some other process).
   
    modelActions = new ActionGroupImpl (getZone ());
) q2 ]- i: f4 s, n
    try {
$ f% k  X5 R9 q      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }
2 k: G* b; H% p; Q1 _9 i9 d$ X
    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
3 ~& I9 Y  f8 y! p1 t8 N      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
! E3 @+ f) {& j+ c) y7 K3 x        (heatbugList,
         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
' s4 z3 a& k' L* m, {# B      e.printStackTrace (System.err);
4 y( R' y0 l/ l, N    }
   
    syncUpdateOrder ();
* `- R) P! l0 g: F
$ ~. K1 V6 ~# O- b. j) _    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
        
    // Then we create a schedule that executes the
9 \. @+ z9 j" I! h6 f+ x    // 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
/ a/ a0 c3 h6 L: ^5 z7 J    // modelActions ActionGroup at particular times.  This
2 d( i/ L  Y2 i* k    // schedule has a repeat interval of 1, it will loop every
6 Y% B7 q: C9 x    // time step.  The action is executed at time 0 relative to
    // the beginning of the loop.
8 g' H1 A' J7 e% s1 s
- G1 C& B8 J* [    // This is a simple schedule, with only one action that is
% k; k9 T" x' x. Z    // just repeated every time. See jmousetrap for more
    // complicated schedules.
  
    modelSchedule = new ScheduleImpl (getZone (), 1);
% C" x% E0 U  a! U8 f: p, e$ z    modelSchedule.at$createAction (0, modelActions);
6 t. u2 e( ~9 f+ a$ }        
( c4 ~' j( A+ G    return this;
9 T+ d/ W8 V! x7 `1 H0 h  }