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

sybbk

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

/ \6 j5 c- ^5 C3 B9 s. e: O$ q7 T0 O& ? public Object buildActions () {
" w9 m" n; H5 I0 W  F    super.buildActions();
1 O% C; t$ t8 T; N, {   
* Q( R+ P+ v/ _+ Q+ K( [! n    // Create the list of simulation actions. We put these in
" h/ Z8 a: t" v    // an action group, because we want these actions to be
    // executed in a specific order, but these steps should
: v# c! h$ w+ ?: U1 m    // take no (simulated) time. The M(foo) means "The message
/ C' r5 z1 `/ G% k3 C4 y    // called <foo>". You can send a message To a particular
2 c3 ^* U5 d! P# f! M: |7 P/ N) r    // object, or ForEach object in a collection.
        
    // Note we update the heatspace in two phases: first run
. }) P8 t$ e5 W. W% k    // diffusion, then run "updateWorld" to actually enact the
    // changes the heatbugs have made. The ordering here is
. {8 x6 Q0 k' a6 v    // significant!
        
    // Note also, that with the additional
    // `randomizeHeatbugUpdateOrder' Boolean flag we can
/ \, i) E% m1 i) A) n) U  K    // randomize the order in which the bugs actually run
& @$ Q( V" B7 U    // their step rule.  This has the effect of removing any
' O) T) I- I1 J4 u) @& s) T    // systematic bias in the iteration throught the heatbug
    // list from timestep to timestep
- |% g- x1 M, h: ^        
    // By default, all `createActionForEach' modelActions have
    // 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
" z3 G& |! f8 x9 j+ O' e! A6 O    // indirectly by some other process).
   
. z5 j, t! ?3 b/ Y. b- A; {    modelActions = new ActionGroupImpl (getZone ());

    try {
2 k$ R8 Y) Q6 z2 D+ F      modelActions.createActionTo$message
9 D( g4 _! e+ W' I5 i# b        (heat, new Selector (heat.getClass (), "stepRule", false));
$ }& Q: s# k! B" k- Y    } catch (Exception e) {
2 M0 X  t3 ?) O' f7 i+ q      System.err.println ("Exception stepRule: " + e.getMessage ());
    }

    try {
      Heatbug proto = (Heatbug) heatbugList.get (0);
' }; T5 l! A" V" v& |& B' d      Selector sel =
9 n, y/ k' Y5 N& }3 B; t        new Selector (proto.getClass (), "heatbugStep", false);
      actionForEach =
        modelActions.createFActionForEachHomogeneous$call
        (heatbugList,
         new FCallImpl (this, proto, sel,
1 }+ R, G$ d9 P9 ~7 o& M1 R, \/ W* O                        new FArgumentsImpl (this, sel)));
    } catch (Exception e) {
      e.printStackTrace (System.err);
    }
' \2 e6 m# Y% z- Y* q% G   
: A- E- H- |2 T* j, j6 `* Q    syncUpdateOrder ();

& k2 J7 @, Y5 H# [    try {
7 S- e9 q& E: l' E4 s      modelActions.createActionTo$message
# j: n) `! v+ u3 ]! x8 Z        (heat, new Selector (heat.getClass (), "updateLattice", false));
    } catch (Exception e) {
* p3 L* j  e, B0 r      System.err.println("Exception updateLattice: " + e.getMessage ());
    }
        
! h1 ^7 x" L/ g+ @3 }% K* e3 D    // 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
    // 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
, d! x# N% E4 R5 `8 ^    // the beginning of the loop.

- S9 I+ J/ K: h0 r    // This is a simple schedule, with only one action that is
    // just repeated every time. See jmousetrap for more
    // complicated schedules.
7 c2 Z4 P8 s( V  
; S' n# l1 X5 g/ P$ _6 K    modelSchedule = new ScheduleImpl (getZone (), 1);
+ O2 U  |: G! N& d# B9 E* r9 A8 ]/ ^    modelSchedule.at$createAction (0, modelActions);
9 r: }, R/ J9 n, _* ?  G        
    return this;
  }