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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
8 L% m$ S8 g# m+ N  z
6 L0 b5 b- y& w; _! s) L public Object buildActions () {
    super.buildActions();
   
    // Create the list of simulation actions. We put these in
1 n2 k' q7 Q5 `. p6 f    // an action group, because we want these actions to be
& I9 V  y% S( V: A5 y0 h    // 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
; D6 V. e8 L* G# S. [    // object, or ForEach object in a collection.
' r& K8 ^% O: y4 P        
. F! ^. p2 E1 S# i) [+ Y    // Note we update the heatspace in two phases: first run
  ^) b. R5 K# K4 ]" f: o    // diffusion, then run "updateWorld" to actually enact the
    // changes the heatbugs have made. The ordering here is
    // significant!
        
/ Z8 R8 I* d& m6 [/ B    // Note also, that with the additional
- E% U- g* N! s0 t& X    // `randomizeHeatbugUpdateOrder' Boolean flag we can
    // randomize the order in which the bugs actually run
    // their step rule.  This has the effect of removing any
    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
        
6 j2 u1 ~7 Z6 G; O4 k+ a( @    // By default, all `createActionForEach' modelActions have
0 k) r. {+ @+ H    // 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
& Z5 {, Z9 x. L: D, i    // indirectly by some other process).
( m$ x0 ~7 [, G6 m$ Z% K   
3 `: n/ o; R/ [: }: i    modelActions = new ActionGroupImpl (getZone ());
/ }3 V4 y9 b# e) _- I
    try {
) v/ i) p* I0 @8 \( s& b; `      modelActions.createActionTo$message
: q6 X& R9 n0 ~; s4 U        (heat, new Selector (heat.getClass (), "stepRule", false));
4 n! {1 H* _5 O/ @1 Y- {3 j    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }
% m! V4 M( H8 }
0 |0 U, a6 f- |4 d; U* s    try {
2 v& [0 Y$ S, f  x) o8 n$ J      Heatbug proto = (Heatbug) heatbugList.get (0);
( u/ D7 R# C2 ~1 F- M      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
8 D3 S: w! C/ M1 c2 S      actionForEach =
. r7 N% `) `$ a2 v' b/ M, |/ l        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
         new FCallImpl (this, proto, sel,
9 F% K. e6 `9 N* S1 J                        new FArgumentsImpl (this, sel)));
5 j6 K# q3 x( ~% D    } catch (Exception e) {
+ d" o3 P' v0 e- O. b$ }      e.printStackTrace (System.err);
% f( U2 B) K4 w( y    }
   
    syncUpdateOrder ();
+ e' f1 k1 X" x( s% V: P, x2 m/ I1 Q
    try {
      modelActions.createActionTo$message
8 P4 _; p: I0 v* f3 n# I# x5 R        (heat, new Selector (heat.getClass (), "updateLattice", false));
8 e9 W) ~1 _% m" O9 M0 b    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
: {) C% n  u( h5 v    }
        
    // Then we create a schedule that executes the
$ I$ V, B' N- O3 q; S: v    // modelActions. modelActions is an ActionGroup, by itself it
    // has no notion of time. In order to have it executed in
% w, p! ?: E* W2 }; a4 }    // time, we create a Schedule that says to use the
    // modelActions ActionGroup at particular times.  This
5 a; B& e2 A8 s    // schedule has a repeat interval of 1, it will loop every
. F# s. I: N9 Y# {    // time step.  The action is executed at time 0 relative to
    // the beginning of the loop.
& A* q- A3 L* S' W2 D: _" o1 I
    // This is a simple schedule, with only one action that is
6 h! l/ c8 c' S9 Y+ F" M% G    // just repeated every time. See jmousetrap for more
    // complicated schedules.
  
    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
        
, f. i/ b0 E; H& D" e    return this;
2 S3 J, `: `  L, [+ x$ O  }