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

sybbk

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

* F: y( P9 d8 G' U" D public Object buildActions () {
2 V4 n2 I7 V2 L/ G  X; [    super.buildActions();
   
    // 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
& l8 S# X( d3 l( H% G$ x    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
9 x: E; L4 h! \+ d& p    // object, or ForEach object in a collection.
        
    // Note we update the heatspace in two phases: first run
( U8 f1 j5 @, ~( a, A    // diffusion, then run "updateWorld" to actually enact the
    // changes the heatbugs have made. The ordering here is
: Y5 c" O- ]" C' L  ~( i& G% t5 j    // significant!
- Q3 J& {* ^$ \2 B; s" a5 H8 ?        
# J: R" f1 z. G: K9 u+ a' \% G" T4 \    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
9 j+ ]8 R5 e* r    // randomize the order in which the bugs actually run
. u4 R0 k' V2 {# D    // their step rule.  This has the effect of removing any
    // systematic bias in the iteration throught the heatbug
) o" U$ W- @# |5 g1 I4 A' b' m    // list from timestep to timestep
        
% n& X0 b  S9 A# l' y    // 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
    // indirectly by some other process).
" b' \' _  G/ @+ \   
    modelActions = new ActionGroupImpl (getZone ());

    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
" L$ k0 G; Q+ ^1 ], E) x$ g      System.err.println ("Exception stepRule: " + e.getMessage ());
* A! {7 u; _& y7 b" U: l8 V    }

    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
4 G$ @: m8 ]9 `      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
$ i3 E6 i* K% b) D6 ]3 l6 O      actionForEach =
" l5 x( B% [( A1 [; }5 O/ F        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
8 f9 |( s# m/ B7 E! q9 Y$ G* p    } catch (Exception e) {
: Z9 h, T7 A* b8 ^8 {- b  N      e.printStackTrace (System.err);
    }
   
    syncUpdateOrder ();

    try {
      modelActions.createActionTo$message
% B. A) T# W% |9 \0 R3 d        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
        
& o3 @. k8 G5 A8 v6 B- q    // 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
9 @6 {7 a" m# @$ |- S8 u( c    // time, we create a Schedule that says to use the
1 }  n* ?8 ~7 V- w0 D    // modelActions ActionGroup at particular times.  This
. }0 h3 X" k8 r5 P    // schedule has a repeat interval of 1, it will loop every
    // time step.  The action is executed at time 0 relative to
" }: s% u0 \+ o% S! T! `    // the beginning of the loop.

    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
- N) N# i; Z3 b' y- N2 ^    // complicated schedules.
! @& w& |: M" G0 ?) m  W  
    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
        
    return this;
  }