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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
1 q# S4 ]+ i4 P9 E( b+ e4 |
public Object buildActions () {
    super.buildActions();
4 w9 t9 T! Z  n8 M   
! D. z5 A% R* }) U: l    // 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
0 ?, n% K  ?6 J$ `, J    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
% E  b0 N/ n& _, I# U9 |7 E    // 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!
; X5 l( Y0 C9 }2 Z7 t2 J        
) s$ \1 ^9 A0 Q3 K' v3 P    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
5 j" o5 m8 [' {- ~* Y( w( d    // 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
2 ^7 C2 L. E& i+ \. E3 @    // list from timestep to timestep
        
9 R9 C- ^1 x* Q) t7 ^; @    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
2 M, C3 l$ {4 q    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
' S! G2 G, A7 ~1 V1 U    // indirectly by some other process).
   
    modelActions = new ActionGroupImpl (getZone ());
: O# ^/ O- h% ]* X+ f
    try {
! X9 n9 x8 p! n2 h+ _5 G      modelActions.createActionTo$message
/ q. J; h/ W4 Z+ o        (heat, new Selector (heat.getClass (), "stepRule", false));
! s6 z3 E3 u$ S+ T6 d' O    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
/ A# g1 w- g3 L5 O4 k( _    }
5 Z0 c2 [1 j, |4 i& S# L) b* q" N
    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
: q- d2 w+ l  C2 V, `      actionForEach =
1 _# |! B" d+ Z2 ~7 S- g        modelActions.createFActionForEachHomogeneous$call
/ T+ N& X" k# {* x0 J        (heatbugList,
         new FCallImpl (this, proto, sel,
: w. c/ o  b" K6 J                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
- ~& _: n/ E. }4 F4 W/ p2 r# R    }
" G! y" U2 w. L3 Y   
6 D3 e9 B3 v8 c8 j$ V- }    syncUpdateOrder ();

, r3 Y/ n* P* W9 v( {0 z    try {
/ w" D# S" F* f$ w3 r0 I      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
  h% c- F) B* P- Z0 u3 R8 F1 ]      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
        
    // Then we create a schedule that executes the
2 B9 P" u5 q6 Z    // modelActions. modelActions is an ActionGroup, by itself it
    // has no notion of time. In order to have it executed in
& l6 A! W/ [) M    // time, we create a Schedule that says to use the
! p; a: d  H% V- r; W    // modelActions ActionGroup at particular times.  This
    // schedule has a repeat interval of 1, it will loop every
; ]& G! [0 C/ t: b* B7 k. J' C! x    // time step.  The action is executed at time 0 relative to
9 S# V9 Q  `& H7 T# R" |+ u1 G1 L4 c* S    // the beginning of the loop.
* R: V; H4 _) h/ j' R* ]
    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
    // complicated schedules.
  
' V1 ^) F$ N: ~2 m) N. F% F    modelSchedule = new ScheduleImpl (getZone (), 1);
3 l+ W7 _4 |7 u    modelSchedule.at$createAction (0, modelActions);
        
% D" X$ @6 Z) F% i    return this;
  }