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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
& U. g/ y$ a( ]
" e. q4 ^6 Z8 V public Object buildActions () {
) y6 @7 d5 V0 b; f  ^    super.buildActions();
  h3 P# \$ P/ n' z: o   
    // Create the list of simulation actions. We put these in
+ ?  s! _9 }' f# o: h    // an action group, because we want these actions to be
    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
( r- a# o% X$ W2 R4 x* K    // called <foo>". You can send a message To a particular
7 \' R0 g8 r8 a" y: R! b3 \    // object, or ForEach object in a collection.
. O% V- o2 ^1 x( P6 X  {& m        
    // 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
' D* ]' _% m, W  V/ B0 @1 }3 v  H    // significant!
. g. W7 q$ ^) `# r  S( [/ x3 A        
6 k% U* ^) Q8 ]. ^    // Note also, that with the additional
9 q6 q& u7 `- Y' m' }    // `randomizeHeatbugUpdateOrder' Boolean flag we can
3 W  ?8 H) Q- P9 g0 h# l3 `; A    // randomize the order in which the bugs actually run
0 n& ?6 B  K+ t2 G* X1 |$ _    // 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
    // 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
) U. Z; z, ~, L0 |4 m  }" h0 T    // indirectly by some other process).
   
    modelActions = new ActionGroupImpl (getZone ());
8 a4 ^* B. f& C/ j) \# i7 u
3 I" I$ ?3 W$ v9 \    try {
8 L" J" w. V$ K4 ^! s3 b      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
0 Z5 |! F8 h, j$ m! M$ ?      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
% b# N" d9 B3 X: N0 u/ d$ D- m. O        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
' X+ f+ S1 S8 T9 M7 v$ Y4 _        modelActions.createFActionForEachHomogeneous$call
) K1 M' ]4 h( u. t8 e        (heatbugList,
         new FCallImpl (this, proto, sel,
! e* d, h* o6 m6 h0 Q; Q                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
   
    syncUpdateOrder ();

    try {
( h- F6 p' T+ H0 f      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
) i0 Y4 b, a2 x. _% N/ p    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
/ \: a$ E3 p. |- q8 w        
: W' a  L( |$ B8 i    // Then we create a schedule that executes the
% G; z4 T  x7 |+ c/ F! g2 Q* U    // modelActions. modelActions is an ActionGroup, by itself it
/ u' e% v9 ]" d4 ~4 t( V    // 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
- y& \; x: D/ g. ?2 L    // schedule has a repeat interval of 1, it will loop every
    // time step.  The action is executed at time 0 relative to
: f' f; C% t7 R+ ^7 z    // the beginning of the loop.
! u% l( Y# B- A
    // This is a simple schedule, with only one action that is
3 R( L$ x  G+ s3 w5 s7 @5 m    // just repeated every time. See jmousetrap for more
' Z& C8 `& j9 c  D# d    // complicated schedules.
  
    modelSchedule = new ScheduleImpl (getZone (), 1);
6 D, K9 f# s1 f    modelSchedule.at$createAction (0, modelActions);
" k# M: `% j7 S. K6 r: ~1 v' ~        
    return this;
  }