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

sybbk

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

. M* k) s' g0 b1 V2 O7 }7 ` public Object buildActions () {
    super.buildActions();
, ]  S, E- R" o$ J   
    // Create the list of simulation actions. We put these in
% p1 ]6 m, I7 O4 g; w    // an action group, because we want these actions to be
5 L' A) j& f, \3 p- m/ X5 v    // executed in a specific order, but these steps should
% Q0 x- |) ?- |# {    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
% u# x& D8 [9 K, \; }    // object, or ForEach object in a collection.
8 E: d; J3 s& U% j        
, e3 ^  {8 P* P/ O    // Note we update the heatspace in two phases: first run
    // diffusion, then run "updateWorld" to actually enact the
+ A6 r7 g. E  o6 z    // changes the heatbugs have made. The ordering here is
    // significant!
+ q1 _# U4 Z8 @" w: f1 C6 C        
    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
+ V. o  `' I* z  H" ~    // their step rule.  This has the effect of removing any
    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
        
    // By default, all `createActionForEach' modelActions have
0 p! e/ ?* @/ K    // 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
- V. o' u" Y% h. W% Q+ q* l( c# H0 _5 y    // indirectly by some other process).
0 S, @" t  Z) c% {7 b. T9 |   
    modelActions = new ActionGroupImpl (getZone ());
' u) T0 a! z. i/ O/ H* c, z0 y
' ]2 }! S/ r4 @, i1 j7 b, w# F    try {
& F$ ~0 f, v: h      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
' r2 d7 v$ D" p      Selector sel =
* D% _7 h; k0 O& @2 D: n/ V% D        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
! }% Q7 u$ u( ~# {' r& B( I3 o! q        modelActions.createFActionForEachHomogeneous$call
3 V3 I/ v( ?8 J: p0 ^: h        (heatbugList,
         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
  V6 t  ~0 a" x( V$ }    }
. Z; w# b# k/ p, p' Y( G   
    syncUpdateOrder ();
; z: M1 ~! @4 N
    try {
2 n+ e& [" n' G5 j. p$ J      modelActions.createActionTo$message
$ F; L  d8 ?3 }6 b% T9 v) o3 v        (heat, new Selector (heat.getClass (), "updateLattice", false));
$ X& w3 \: G# S    } catch (Exception e) {
) Z: u+ s  V. E8 v      System.err.println("Exception updateLattice: " + e.getMessage ());
+ j- m* _8 d8 p" Q- P) O3 A    }
        
    // Then we create a schedule that executes the
    // modelActions. modelActions is an ActionGroup, by itself it
, I- P# z6 t, {    // has no notion of time. In order to have it executed in
    // time, we create a Schedule that says to use the
9 \4 a( X  S6 l    // modelActions ActionGroup at particular times.  This
0 o9 j) S; \  G# z* Q# _- Q    // schedule has a repeat interval of 1, it will loop every
    // time step.  The action is executed at time 0 relative to
+ T/ S3 u# u' q3 F% Q1 _! Q( c4 Z    // the beginning of the loop.

    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
    // complicated schedules.
3 U# j5 k* e3 l% q8 S/ d9 Y  
    modelSchedule = new ScheduleImpl (getZone (), 1);
! R- Y6 a1 D0 d    modelSchedule.at$createAction (0, modelActions);
        
8 o$ C; H$ |3 W7 t9 S$ n    return this;
  }