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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
4 T1 j6 w8 Y+ Y* V
public Object buildActions () {
9 Z# b! h& _! I$ d) }) z4 |    super.buildActions();
3 a& v6 G. j8 R; d% ^   
    // 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
2 ]9 Z0 h. I( ]' \, |    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
' W% Y/ b. c" \3 m; F    // object, or ForEach object in a collection.
        
9 J7 P) r( u5 z! A    // Note we update the heatspace in two phases: first run
3 l) K) J# @/ E) ~+ s' e. {    // diffusion, then run "updateWorld" to actually enact the
    // changes the heatbugs have made. The ordering here is
    // significant!
2 y# E7 K4 B- l+ _# g        
' ?" X, p. `. W5 ~    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
5 o2 U3 N* F" t/ S; d$ ~1 ]& e    // randomize the order in which the bugs actually run
    // their step rule.  This has the effect of removing any
5 p& B) ~# X0 [9 ]0 i    // systematic bias in the iteration throught the heatbug
. g, A- b; b! N1 [* r3 k5 R; R    // list from timestep to timestep
        
    // By default, all `createActionForEach' modelActions have
' s9 H- M& f. h9 ?) M  Q" s1 ?    // a default order of `Sequential', which means that the
5 y# }9 V& A7 ~% A. S    // order of iteration through the `heatbugList' will be
    // identical (assuming the list order is not changed
5 }& c, h& g9 l' E, u9 S* M    // indirectly by some other process).
   
: M% I, `7 Q4 ^* T5 p8 n9 x5 Q    modelActions = new ActionGroupImpl (getZone ());
$ L3 n, I! s$ k- R) H0 D
) ?: Z  W6 U) U' [* K    try {
      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
, s* a" u5 Z9 \      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
, t( U* d" D9 O, F      Selector sel =
! ]% k8 c- `, t' C  w3 t        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
3 d9 j) [; A: L% c4 l6 |* h1 U        (heatbugList,
) t6 D* y! W" K3 C$ f2 `3 Z         new FCallImpl (this, proto, sel,
/ w3 p$ e+ J* U. L$ {                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
   
    syncUpdateOrder ();

    try {
      modelActions.createActionTo$message
2 b3 [0 d: |3 o) w/ D+ p  m; a  A  o        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
6 k* }9 t: ]# `" w" d: ?      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
6 k2 J; Y, }2 }* g) }4 [9 i$ \* [        
    // Then we create a schedule that executes the
    // modelActions. modelActions is an ActionGroup, by itself it
' ]: W# X( G2 }1 J. X    // 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
/ s! |; `% C. \" s    // schedule has a repeat interval of 1, it will loop every
. B7 Q" S: m: e% S6 J; R: r    // time step.  The action is executed at time 0 relative to
    // the beginning of the loop.
7 F5 B+ `' ?  t9 T
( Y' C1 n4 l) K& z0 x6 }    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
) [' T6 n7 q. Q( L! h. p% o    // complicated schedules.
8 J0 ]3 t( u7 ^/ W: u* P: B  
+ d' y9 G2 t8 V* u" g, [    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
        
0 T, y- G; @. t  G7 Z" F& U; S    return this;
  }