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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
( r/ \  m# Y3 Z* J! |6 x0 }
public Object buildActions () {
    super.buildActions();
( J: u0 \; k# e. R& s   
    // Create the list of simulation actions. We put these in
1 A' Y' \2 M1 A$ V    // an action group, because we want these actions to be
) E4 X9 P- I4 c5 _' m  m# Z    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
/ z( F4 k% S) ]. H8 R    // called <foo>". You can send a message To a particular
9 k7 B' J9 C  s. i2 k1 W  z: q4 ~8 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
    // changes the heatbugs have made. The ordering here is
    // significant!
        
1 j/ J! m7 B- W    // Note also, that with the additional
8 |% ^6 ]+ e% M! o9 C* P$ J    // `randomizeHeatbugUpdateOrder' Boolean flag we can
, B) d- [7 I) W* e. @+ k- I4 H- o9 A/ [    // randomize the order in which the bugs actually run
    // their step rule.  This has the effect of removing any
    // systematic bias in the iteration throught the heatbug
9 a7 v; p5 k: A    // list from timestep to timestep
        
; ?: L2 R+ T3 x2 O6 O) i! V& ?+ \    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
2 F3 g5 E, F$ o! A1 ~  e    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
    // indirectly by some other process).
   
3 _. \- [! T  A+ E/ @    modelActions = new ActionGroupImpl (getZone ());

: I, p% O3 o: w. _3 S0 y& O    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
. \7 N+ V" K- h( }    }
) v, {$ m! [( i2 ]) y
    try {
1 O* D+ i) m0 d9 r9 d      Heatbug proto = (Heatbug) heatbugList.get (0);
+ }# F0 a4 [7 x9 j7 x8 M, O      Selector sel =
6 u. X* y; T$ t! c. }# Y        new Selector (proto.getClass (), "heatbugStep", false);
7 U5 [  V3 F7 r# K$ }% x3 I  X3 J      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
  M) X: p6 c& P5 ]5 ]  v         new FCallImpl (this, proto, sel,
, Z) X, e7 z) f+ [                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
  ~: T- }) s% S4 o' a   
    syncUpdateOrder ();

    try {
" a4 H+ Y- h% d, a. a4 ]      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
, h' R. \! P3 t, p8 ^" `3 V( B! k    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
, z5 C8 I. Z& d2 Z" H# y2 h- \6 r        
& \$ g4 J& f- I8 N, q! A0 K    // Then we create a schedule that executes the
    // modelActions. modelActions is an ActionGroup, by itself it
4 D# ^  j# L9 `6 m    // has no notion of time. In order to have it executed in
    // time, we create a Schedule that says to use the
, G9 Z! Z; K# r& u- R0 O. ]    // modelActions ActionGroup at particular times.  This
    // schedule has a repeat interval of 1, it will loop every
    // time step.  The action is executed at time 0 relative to
    // the beginning of the loop.

! q0 F9 f) q' j* h0 n. K: L    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
    // complicated schedules.
+ u4 z0 _: g/ J- F4 E9 c7 }5 i  
    modelSchedule = new ScheduleImpl (getZone (), 1);
% T( w1 s4 a/ L- W- C2 e, f8 R- {    modelSchedule.at$createAction (0, modelActions);
5 x  _: a# @- J/ L+ m. ~( N        
8 Z- D; h! b1 {( r' N" K    return this;
$ H9 q6 J* Y, t0 A9 o  }