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

sybbk

HeatbugModelSwarm中buildActions部分，3个try分别是做什么？查了下refbook-java-2.2，解释太简略，还是不懂，高手指点，谢谢！代码如下：
: }- C/ Q* z) [9 K8 k1 e
public Object buildActions () {
" D2 z1 h7 S) p  B2 @$ g    super.buildActions();
8 J' v# ^. p7 D* c   
    // Create the list of simulation actions. We put these in
" }$ G) h* \4 l    // an action group, because we want these actions to be
    // executed in a specific order, but these steps should
( m" J/ ?. ^- m( G- O    // take no (simulated) time. The M(foo) means "The message
    // called <foo>". You can send a message To a particular
9 g7 T: e% J% P+ W) u: ^" t    // object, or ForEach object in a collection.
2 r" v4 f" N2 L; m        
6 ?* Q- u" E* V) r. D( P    // Note we update the heatspace in two phases: first run
    // diffusion, then run "updateWorld" to actually enact the
/ m. r, f+ @* p1 x0 U1 q    // changes the heatbugs have made. The ordering here is
    // significant!
        
    // 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
    // systematic bias in the iteration throught the heatbug
( v9 u6 J: G3 B% i* E    // list from timestep to timestep
        
  s3 P- X9 J! P/ g) S% N    // By default, all `createActionForEach' modelActions have
- B6 ]: ^3 ^. O6 ~) W    // 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
7 U/ }# ^: W  }3 k4 @; ?    // indirectly by some other process).
8 H9 b( ~$ A* e! }0 [   
) k7 ]6 }# Y5 G; c) U2 R- i+ p    modelActions = new ActionGroupImpl (getZone ());
( t2 [3 X2 U. n" {9 k+ Z6 L
. F9 i* X+ Q/ k( U3 {    try {
  ]& w. U/ o) s- o$ @) X      modelActions.createActionTo$message
: U, y$ r0 e8 b- q3 j        (heat, new Selector (heat.getClass (), "stepRule", false));
+ _5 y5 K; _5 o, t    } catch (Exception e) {
      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
      Selector sel =
' d. `5 q1 ]# X! C0 |        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
6 h: L2 o) n3 m. }! W% }8 ?$ o( l' }( _        (heatbugList,
4 ]  B& C: E; j& P/ D) d! W         new FCallImpl (this, proto, sel,
                        new FArgumentsImpl (this, sel)));
: U$ M. D+ A  U; _( k    } catch (Exception e) {
      e.printStackTrace (System.err);
3 \9 X0 a/ c2 ?" y4 \    }
   
    syncUpdateOrder ();
  h2 N2 g5 L9 C4 w; H4 h7 t/ F2 m% M3 R
    try {
! S! f3 o4 L% p0 n      modelActions.createActionTo$message
1 Q$ D6 c9 s* z" N        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
) V- |& n- j- G" J: I      System.err.println("Exception updateLattice: " + e.getMessage ());
  x$ x1 W$ P6 P1 M2 V    }
4 m( M  ?& Q. X; K  [" t        
: B; d  Q# v7 C1 V    // 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
    // time, we create a Schedule that says to use the
% m  x. c1 z$ R  l    // 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
. _* I. t; C3 l  n1 i, k    // the beginning of the loop.

    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
    // complicated schedules.
  
    modelSchedule = new ScheduleImpl (getZone (), 1);
    modelSchedule.at$createAction (0, modelActions);
. D" F6 b0 n. E& f" U/ w% \        
/ s+ U3 j- d4 o% x/ _    return this;
7 ^0 A% G% S& _6 }6 w  }