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

sybbk

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

! h7 y! b) A8 X& ]- |, g% y: H public Object buildActions () {
    super.buildActions();
, M; ?) s3 H; m   
    // Create the list of simulation actions. We put these in
    // an action group, because we want these actions to be
/ ?! Q4 `" ~4 l- r, Z    // executed in a specific order, but these steps should
    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
7 h& W5 G' e7 p    // object, or ForEach object in a collection.
        
. |) T* V! M6 Y' \8 k. b    // 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!
0 s) X! \' g+ J        
! H. J4 Z8 L8 I9 o7 n3 E    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
. e5 S) R% q' j- D1 i3 F0 N6 J    // randomize the order in which the bugs actually run
    // their step rule.  This has the effect of removing any
# t" I  j' {' o, O    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
& ]: S. [# C" J7 `        
    // By default, all `createActionForEach' modelActions have
' J3 |) b! H4 y6 f    // a default order of `Sequential', which means that the
1 {/ Z5 k, ]* j: {, W6 q4 G    // order of iteration through the `heatbugList' will be
2 D6 w9 i% Q4 T2 M% D8 W    // identical (assuming the list order is not changed
    // indirectly by some other process).
0 i* a2 b3 J4 c   
& _: W" C. {/ t1 k( ~0 F/ M0 k    modelActions = new ActionGroupImpl (getZone ());

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

/ |, j$ _* h4 T    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
% }$ }3 I& F+ T( w/ h$ s3 }      actionForEach =
. @0 O, b- d, N7 P; e" d        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
* l2 i: l1 |& @& b0 U3 ^# @5 }: z      e.printStackTrace (System.err);
  g7 W" B: ^7 i  L0 x    }
   
, w5 r$ P% u) A6 o    syncUpdateOrder ();
+ ]. U% n+ T+ e
    try {
+ u. ]2 X: h$ E      modelActions.createActionTo$message
. v) v  d+ f  A9 U        (heat, new Selector (heat.getClass (), "updateLattice", false));
. ~- h7 N2 s% p    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
+ s5 T5 M4 p# t: B$ o    }
4 w$ i* o% b2 W1 V) Z) z        
    // Then we create a schedule that executes the
$ s+ _: C* `2 [. f    // 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
    // modelActions ActionGroup at particular times.  This
    // schedule has a repeat interval of 1, it will loop every
3 {0 A+ _7 ?! v- `; `" W) ?    // time step.  The action is executed at time 0 relative to
    // the beginning of the loop.
6 q0 g/ @/ ~( H4 U& i: N1 B( |2 o
6 D5 U6 i, r4 I    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
    // complicated schedules.
% c* n' E6 F/ G! ^" j1 ]' A2 y# C4 Q2 q  
" \- K( h4 M. c3 G4 m# C    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
3 Q* u. t6 Z; N( g" m" A        
) D4 c; x, D5 e! ~+ O    return this;
  }