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

sybbk

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

6 e3 l$ L, V, k; `% p public Object buildActions () {
' ^3 O' ]/ e3 u) ~2 j& s    super.buildActions();
7 n: \( O* I' j! }, M0 T   
; ]6 u' W$ z& `; B! m$ A: |    // 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
5 L( _" h7 G2 V1 I' ]0 N# ]    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
    // object, or ForEach object in a collection.
, W" O4 B& T+ v  K9 U        
: h& J3 A3 ~* ?* K, _1 ]    // 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!
9 G) ?- F: |0 b  c) y. G        
    // Note also, that with the additional
4 \! Z. @& A- e9 J    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
  a, F; o3 [% a# H  L) U& D1 E    // their step rule.  This has the effect of removing any
    // systematic bias in the iteration throught the heatbug
( x- L7 \; t; l7 E' `. f  O    // list from timestep to timestep
. u: G/ D# B) Q1 n$ {        
: h! H% h( I6 f+ [6 ~% u6 ?    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
5 x7 L0 M. r+ `* r% }# T    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
    // indirectly by some other process).
   
    modelActions = new ActionGroupImpl (getZone ());
% `4 }' S7 U" z4 I
    try {
% h9 x3 D% x, @      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
/ x3 @8 c, U( A5 [, Q      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
3 m: W3 C# {% i$ V4 p      Selector sel =
/ Z( f# V6 Q) o5 d! d        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
         new FCallImpl (this, proto, sel,
3 H2 P/ n0 y) W1 W. A5 z/ N  {                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
( f" S+ R; c5 t3 N) J    }
1 U% O9 N- E/ k% M& B   
1 I4 i! w: C3 ]: X- f; [/ O    syncUpdateOrder ();
; y! s) Q$ F  c5 V1 o3 \
- j, }' W3 ]# i  ]; H1 O8 c    try {
      modelActions.createActionTo$message
2 F" S9 X* @6 Q        (heat, new Selector (heat.getClass (), "updateLattice", false));
' ], x3 i( F' Q0 I    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
        
7 U0 j5 ^1 Z8 W  @: Y    // Then we create a schedule that executes the
: b5 p" m+ x& O5 ?8 Z    // modelActions. modelActions is an ActionGroup, by itself it
1 e- ?- O: U3 h) g% A* I    // has no notion of time. In order to have it executed in
    // time, we create a Schedule that says to use the
+ K$ u' S$ }; ]! F' ^    // modelActions ActionGroup at particular times.  This
    // schedule has a repeat interval of 1, it will loop every
    // time step.  The action is executed at time 0 relative to
3 C) I& F1 d" Y    // the beginning of the loop.
9 v. b% l) S3 b. a/ I
& L- ?9 a, Z0 r/ }5 b    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
    // complicated schedules.
% {' a6 g8 \  ?9 _  
    modelSchedule = new ScheduleImpl (getZone (), 1);
2 ]" N4 {: o8 Z4 p    modelSchedule.at$createAction (0, modelActions);
$ p4 ~$ r8 q/ I- ^% I        
+ X& w# o5 }" q    return this;
  }