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

sybbk

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

public Object buildActions () {
$ y# I) F1 b: a6 R# n    super.buildActions();
   
& a' z. F, l+ F$ K% r0 U    // Create the list of simulation actions. We put these in
    // an action group, because we want these actions to be
5 ]3 r$ o+ o1 m+ B1 _    // executed in a specific order, but these steps should
* g9 n$ p4 W& b2 ^! @    // take no (simulated) time. The M(foo) means "The message
) o0 s; p9 \7 S3 \    // called <foo>". You can send a message To a particular
8 x* ~$ P" t9 _7 U% K    // object, or ForEach object in a collection.
1 m4 U! X. }9 v; L$ D        
    // 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!
5 a1 q% v7 u6 P' E2 Y- {9 W! @        
, F* I( q" C8 L: _6 a2 K    // Note also, that with the additional
& g6 e! }4 J; @4 w6 I% f$ o    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
    // their step rule.  This has the effect of removing any
6 _8 M. p& A$ Z1 u# |    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
        
, v  i7 l' a2 A: x* B    // By default, all `createActionForEach' modelActions have
    // 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
( J$ p+ X. U& ]2 b. N& k2 ~    // indirectly by some other process).
$ x# d  X2 q: E   
    modelActions = new ActionGroupImpl (getZone ());
1 F! r4 `5 X1 y6 I. E7 D
' N7 H2 j. |1 U* o8 Z9 ?    try {
      modelActions.createActionTo$message
( Z3 y* j' N! h! l) Q2 `4 A        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }
3 |+ b( I+ r7 p* U, C
    try {
8 k8 l# b2 c) m      Heatbug proto = (Heatbug) heatbugList.get (0);
7 S! Z" e; i  o% {      Selector sel =
% X+ J" V8 ]" n        new Selector (proto.getClass (), "heatbugStep", false);
# F' K0 @  r1 X* M1 l! L6 h8 r" X      actionForEach =
0 S+ j# \8 o. _4 R4 W) _5 ?4 A) q0 p        modelActions.createFActionForEachHomogeneous$call
6 Z% t! ~1 j0 L        (heatbugList,
         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
) `; D8 S% j1 w* u. I5 E5 L    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
# i6 o$ K" ~' v0 x2 r   
    syncUpdateOrder ();

    try {
6 ]2 M* k( s) y: e* N$ q/ ^      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
! m$ H/ n6 `0 c( h: K7 ]    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
" o- V' H8 C% o- t5 z        
+ A2 _+ M; j# l2 }5 I: W    // 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
, L. R/ I" a; L  P; R" r( O" B    // time, we create a Schedule that says to use the
    // 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
. x9 f6 s- j6 d) }0 H8 Q    // the beginning of the loop.

2 v0 l( W+ q/ r" N    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
    // complicated schedules.
; ?$ Q6 I# O, e  \8 T( y+ y* t& i  
  d0 X- L- U! r2 e6 H2 ]    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
        
1 a2 S  v" r( |$ H7 L    return this;
  }