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

sybbk

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

public Object buildActions () {
) Q( {" s/ [3 Q8 G    super.buildActions();
   
! r) h$ l7 Y( S- r# D: G    // Create the list of simulation actions. We put these in
    // an action group, because we want these actions to be
7 ^" b' G3 G& T# I7 I( }! V& ]- C    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
& [5 X" |% J9 m1 v; P/ ?/ P7 }! C    // called <foo>". You can send a message To a particular
    // object, or ForEach object in a collection.
) f6 f/ O7 G9 ~5 j. p        
    // Note we update the heatspace in two phases: first run
    // diffusion, then run "updateWorld" to actually enact the
* r0 D/ D6 J7 g9 ?    // changes the heatbugs have made. The ordering here is
    // significant!
        
+ k2 B4 [4 e. K) A9 w    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
/ S- x- i2 y* ]3 ]: z3 b3 z8 ]    // randomize the order in which the bugs actually run
$ X8 q6 |+ v4 n8 M' z, u2 q' G; {    // their step rule.  This has the effect of removing any
7 f$ R7 i0 Q$ E    // systematic bias in the iteration throught the heatbug
7 q4 w" h/ p1 H( c# J    // 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
' Z0 f; T0 K4 b/ ?1 S    // identical (assuming the list order is not changed
    // indirectly by some other process).
   
4 z1 ?+ _5 D1 m5 m8 s0 `    modelActions = new ActionGroupImpl (getZone ());

    try {
( L% M3 z9 l) t, q      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
( L! Z' Z+ I/ J6 h" ?8 a# q( _      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
$ T3 @5 @/ @8 c  j      actionForEach =
* {$ _6 A& @' Q# t, m" K( E( C: z' q        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
   
. ^+ K6 n- l( _5 [1 ?8 H    syncUpdateOrder ();

  b1 J) e. g& d$ v, y3 h    try {
      modelActions.createActionTo$message
, J( n, s$ ]1 H        (heat, new Selector (heat.getClass (), "updateLattice", false));
# r$ r8 i# D9 N  Y! y    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
; _9 ?" }2 w2 X2 D2 s4 v4 ^5 k( |    }
( b" }' C4 D( }        
    // 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
    // time, we create a Schedule that says to use the
( J% E* o- `+ K# a9 }/ T# t    // modelActions ActionGroup at particular times.  This
0 l# F+ U3 d( E4 d. w1 G, j    // schedule has a repeat interval of 1, it will loop every
" }3 M5 b9 @1 t# g* o' u* a+ s    // time step.  The action is executed at time 0 relative to
    // the beginning of the loop.

    // This is a simple schedule, with only one action that is
# x6 w& Y3 u5 _+ Z    // just repeated every time. See jmousetrap for more
* [) [1 w3 n6 f% y" G* C0 A" C" E3 O0 T    // complicated schedules.
$ g; J9 L' l9 w; l6 }  
    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
6 m! T# v6 O: q1 G. x' u        
1 f$ B# Y' A2 i$ V- p" ]  O8 b( k) @    return this;
0 x6 t- j. v; Y6 j* r  }