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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
# N3 p. j! S( T
public Object buildActions () {
9 o) z- W, r/ K8 F4 z% r% {; Q8 s; l    super.buildActions();
, K" p# B$ a" l1 U   
    // 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
    // take no (simulated) time. The M(foo) means "The message
" N; `4 v) ^& C( e5 j7 }* Z    // called <foo>". You can send a message To a particular
0 [" K/ q( f$ W5 ~, b/ `    // object, or ForEach object in a collection.
2 f6 H  k. l. k        
/ J2 y/ p9 m0 j1 i8 H* _) l" C( S    // Note we update the heatspace in two phases: first run
    // diffusion, then run "updateWorld" to actually enact the
# e! Y9 P: F. K    // changes the heatbugs have made. The ordering here is
; P* u- P2 y. l5 |0 k    // significant!
) Y  x/ _1 [. {9 p5 i2 P1 [, [5 d8 X        
2 M9 U3 j: c8 i2 B    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
    // their step rule.  This has the effect of removing any
; X! U3 I( c3 ?    // systematic bias in the iteration throught the heatbug
; Q4 I# n: w- S9 l0 {    // list from timestep to timestep
1 A3 `  R, w" `: _% Y' P        
    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
% E2 o1 b2 z5 S5 f) M    // order of iteration through the `heatbugList' will be
+ B2 a! w$ n' v/ |1 A! W3 M    // identical (assuming the list order is not changed
3 }3 j# h+ w7 ~4 d% t/ Z    // indirectly by some other process).
   
, L% W  o' I: e) N/ A6 P. z    modelActions = new ActionGroupImpl (getZone ());

  C8 z: X  n7 C3 K" O6 G    try {
2 s, n: f+ ]* t8 r7 o5 m      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);
# N! a" J0 X# l4 _; \. F3 n& y9 l6 J      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
0 H0 t# }, V/ A! H# v+ K& c      actionForEach =
# T3 }) Z9 U, t% c+ s# E        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
8 J9 r/ d7 H& R+ E9 R8 Q* _8 F         new FCallImpl (this, proto, sel,
1 Q4 P$ [$ E4 y                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
( E2 W; r/ a" x3 g8 o      e.printStackTrace (System.err);
    }
/ M+ s& ]& H* W  ?7 k   
6 s* A8 f+ M; t$ Y0 {  e    syncUpdateOrder ();
7 \1 j7 ?# s/ p& i- h  c: D8 [
5 b% }: L0 M- }: U5 a    try {
" a: h+ b& |7 O5 P9 h      modelActions.createActionTo$message
        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
& J1 G6 z, @3 }' ^8 _) p      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
- H  u  [& P1 [: R0 B+ n  n        
2 z+ p; ~$ Q9 \, [0 U) r+ E7 n8 o" M# }    // 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
8 ^% q9 p# H# Q    // time, we create a Schedule that says to use the
    // modelActions ActionGroup at particular times.  This
; r) y* |( v( U% b8 Z# f# E    // schedule has a repeat interval of 1, it will loop every
    // time step.  The action is executed at time 0 relative to
" S3 I1 O6 D/ W1 h0 `9 S: R4 s    // the beginning of the loop.
+ o9 T, A/ g+ ^" U! u
' W# n% e. k& T% r! F  k& O9 U    // This is a simple schedule, with only one action that is
- c4 w1 q  o* q5 ?0 |    // just repeated every time. See jmousetrap for more
6 a, ?) I% }% [4 o  @    // complicated schedules.
  
    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
        
    return this;
  }