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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
" b% V: `/ F, y
2 a- P% P2 p6 X1 ?/ l$ ~3 D* m public Object buildActions () {
1 {, k! x' w& [# K; D    super.buildActions();
   
4 t5 k4 F$ w" O% n+ f    // 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
3 h/ i8 t* x( M" J    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
    // object, or ForEach object in a collection.
        
! _/ S" Q" G' n    // Note we update the heatspace in two phases: first run
/ ^2 L% B! k9 J! b) E    // diffusion, then run "updateWorld" to actually enact the
' |1 Z7 z& r5 U! U* ?% ^    // changes the heatbugs have made. The ordering here is
    // significant!
  g9 S6 r1 F7 z. [8 O# ^* }4 h        
1 R2 t0 W! M$ v: A# x$ o    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
; C9 s+ n) L9 `. u" o, C& F- `    // randomize the order in which the bugs actually run
$ T3 B  p7 X$ g( l- z    // their step rule.  This has the effect of removing any
    // systematic bias in the iteration throught the heatbug
: p( J. ~+ ~0 [9 t    // list from timestep to timestep
        
    // By default, all `createActionForEach' modelActions have
% X% d! F) \% F4 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
    // indirectly by some other process).
7 _! p8 i2 Q3 j4 n$ f   
    modelActions = new ActionGroupImpl (getZone ());
9 c8 [! n3 k; Z, k" u, r
6 r2 \0 N! T) M    try {
      modelActions.createActionTo$message
- I3 O' X+ [4 h6 x6 E        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
1 `# m5 s' z# v: O  Z$ `      System.err.println ("Exception stepRule: " + e.getMessage ());
    }
8 q4 [; x6 Q% y  M
: l- A5 O# A$ m3 s3 d    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
* A0 s0 w+ s% M        modelActions.createFActionForEachHomogeneous$call
% J4 ]0 i  _$ x9 y. I: C+ u; Q% G        (heatbugList,
# @) X7 b% E( A: y8 ~: {         new FCallImpl (this, proto, sel,
* H1 b; o. H. L2 N  c7 X$ \                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
   
    syncUpdateOrder ();

    try {
+ ?8 ]  i6 `+ k$ }" \- Q      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
' |2 g+ r$ ^0 r      System.err.println("Exception updateLattice: " + e.getMessage ());
5 r6 k+ p" Q+ j7 [- T) P; F8 P$ P    }
        
    // Then we create a schedule that executes the
    // modelActions. modelActions is an ActionGroup, by itself it
! ]% s1 c1 x( l, g0 A% a  J    // has no notion of time. In order to have it executed in
    // 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
    // the beginning of the loop.
: Y. x) d' ^# \( G0 X" [
    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
  c; g* }! s3 |2 [" {8 p" [    // complicated schedules.
% L  s0 T; U+ B) U) W0 O+ O' u  
4 ~  v) J& X; F    modelSchedule = new ScheduleImpl (getZone (), 1);
+ h+ n) N2 L6 n% n8 [) k    modelSchedule.at$createAction (0, modelActions);
; z0 `( N1 P5 J, E& m' C        
    return this;
8 {1 z0 d0 N( I2 k! `5 [- Z  }