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

sybbk

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

) v! Q; @" \& v public Object buildActions () {
4 I/ A% j' A3 Y% w$ c3 Y9 b$ J    super.buildActions();
   
: a' w) S1 g5 J    // Create the list of simulation actions. We put these in
8 ?3 d' S3 _, T$ H6 Z* i2 {    // 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
3 k. o0 `+ X# B& w+ |0 t    // called <foo>". You can send a message To a particular
    // object, or ForEach object in a collection.
9 Z; U' m2 C4 U5 x; h" S/ c        
# S' {" x" w8 d8 j    // Note we update the heatspace in two phases: first run
; k! B) y" [" D7 T' W/ p: Z    // diffusion, then run "updateWorld" to actually enact the
  l* h$ `" ^/ z    // changes the heatbugs have made. The ordering here is
/ j0 o* p4 j/ A7 F    // significant!
9 K: q8 N- M* `- p9 n# {        
    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
# d2 d2 X, Z4 a1 b    // 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
        
, |; v1 U  y  @# w. a8 J( W    // By default, all `createActionForEach' modelActions have
    // a default order of `Sequential', which means that the
    // order of iteration through the `heatbugList' will be
2 ~1 D, X1 t4 r2 D$ j. R    // identical (assuming the list order is not changed
5 J5 N1 m+ V" o5 V    // indirectly by some other process).
   
8 k$ _  [$ X) L    modelActions = new ActionGroupImpl (getZone ());
1 |! T& T9 o! x* p3 K
  G( V$ V6 ?( J# t, X& R    try {
6 H) G: \3 p. k9 p      modelActions.createActionTo$message
! ?1 g( D, |, ^0 @2 ?$ ?        (heat, new Selector (heat.getClass (), "stepRule", false));
    } catch (Exception e) {
6 F% S1 G+ L/ d3 l0 e" \      System.err.println ("Exception stepRule: " + e.getMessage ());
! r6 B# a4 \/ e    }
1 V1 w9 M( l5 a$ i& I' w4 U7 q
. A" `2 m! }  u    try {
1 M% X4 b6 I: Q, X      Heatbug proto = (Heatbug) heatbugList.get (0);
' P- E5 E% d8 X. C: f+ {      Selector sel =
        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
: M! ^* }+ S  i. P; m9 C8 E        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
6 t% A4 \4 h  Q- X* f: v' Y         new FCallImpl (this, proto, sel,
) a: o, \1 D0 x, [1 `0 r                        new FArgumentsImpl (this, sel)));
8 K9 w# c8 Y3 z/ b5 c5 y. n    } catch (Exception e) {
0 g8 \% r9 P; v3 I* k  W& B: {      e.printStackTrace (System.err);
# U0 |3 p- i( x$ A- k9 k, x    }
   
    syncUpdateOrder ();

    try {
      modelActions.createActionTo$message
4 E( {1 ^: u" k        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
      System.err.println("Exception updateLattice: " + e.getMessage ());
8 k) B1 A4 x6 k2 \    }
% @# g0 @: z1 g; ]6 T% ^        
% {, ]9 h/ Q7 h: B    // Then we create a schedule that executes the
    // modelActions. modelActions is an ActionGroup, by itself it
/ W* c2 h* }" w5 @! O" P1 O! x  a    // has no notion of time. In order to have it executed in
2 K: x8 I" E. v    // time, we create a Schedule that says to use the
: [# T: z5 j4 @; e5 P( 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
    // the beginning of the loop.

    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
2 _0 u- O7 n  \) R: o3 k    // complicated schedules.
5 ?4 J- O7 o" M, l7 i" i/ I  
    modelSchedule = new ScheduleImpl (getZone (), 1);
/ t$ t: d6 _4 U  o0 p2 J6 k! q  e& O    modelSchedule.at$createAction (0, modelActions);
7 _, ]: t8 O& `        
    return this;
  }