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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
7 ]! x+ V9 m3 H( x9 i% ?
7 Q  [5 [& ~- b public Object buildActions () {
    super.buildActions();
( A9 p, L5 y; |2 c   
1 g4 ^8 f- r- e7 H* U0 J; z    // Create the list of simulation actions. We put these in
    // an action group, because we want these actions to be
    // executed in a specific order, but these steps should
& u8 p% a3 S1 D  P    // take no (simulated) time. The M(foo) means "The message
' P9 ~4 U3 @2 }    // called <foo>". You can send a message To a particular
2 ~/ T8 P. w, g; |% I* k    // object, or ForEach object in a collection.
        
    // Note we update the heatspace in two phases: first run
    // diffusion, then run "updateWorld" to actually enact the
$ M9 Y0 ~5 j8 j+ R- M$ G9 S/ Q3 r    // changes the heatbugs have made. The ordering here is
    // significant!
        
7 C8 q3 Z. x4 q) N: j" t  t    // 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
. y7 H( q: h+ e    // systematic bias in the iteration throught the heatbug
% }: o0 _1 z# U    // list from timestep to timestep
        
% |, ?3 l3 E$ G  ^! x) H) n* z    // By default, all `createActionForEach' modelActions have
9 p! S, L/ Q; |' a: L) O    // a default order of `Sequential', which means that the
* n+ u. e7 I/ s( a9 `    // order of iteration through the `heatbugList' will be
0 U# K; Y% ~5 T    // identical (assuming the list order is not changed
6 K6 ^- M& e3 U    // indirectly by some other process).
$ n. N; q) |3 z2 [3 I) K   
    modelActions = new ActionGroupImpl (getZone ());

; X2 p+ }2 Y. V( H; K4 F2 H    try {
      modelActions.createActionTo$message
# `% c6 [; Q7 U3 M, j9 C        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
! v0 S9 \6 H. P  H, V3 [    }

    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
$ T3 c3 ~8 D0 v1 j, E6 ]- D: f% P      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
( Y; @9 X  Z9 S      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
/ z$ G3 {! ^# L0 I/ M2 Z6 V; V         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
2 r- H$ `" A2 ~* R! q" N      e.printStackTrace (System.err);
7 e& l. s7 O) d6 F: G/ w+ Q    }
4 u+ D% P, |5 p1 \# ?0 a* U1 Z   
    syncUpdateOrder ();

* A9 ]7 f0 D% z( U0 }    try {
$ X  i' R! F( o/ F( ~! `      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
, ]( {1 ~+ {: U' L: [9 I    }
2 f; k! s- d& P  q3 F8 D        
    // 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
' x; @" B$ a  F6 \# O/ e5 o" P% W, g& m    // time, we create a Schedule that says to use the
2 Y' e0 d7 O: J    // modelActions ActionGroup at particular times.  This
1 R% X  ]* x; R7 h7 R: g% v7 o0 I    // schedule has a repeat interval of 1, it will loop every
    // time step.  The action is executed at time 0 relative to
2 s$ D2 v) ?; M    // the beginning of the loop.

    // This is a simple schedule, with only one action that is
* k9 K) n2 r8 @8 O    // just repeated every time. See jmousetrap for more
* g$ L3 `& b! @! ?5 |3 `    // complicated schedules.
  w, ^0 ~: Y- s. F- }$ E  
/ b" k7 j- Y) j+ `    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
1 _6 f$ `9 ]' |9 Z3 S9 Q/ ?( M        
2 ^5 z$ m- L6 [0 v$ v    return this;
  }