2018.2.0版中AGV如何乘升降机？

请教一下，2018.2.0版中AGV模块，路径点逻辑里没有乘升降机的选项，该如何实现这个操作？

9 R* h+ v9 h4 a  _

办法1：从2016版本里面复制相应的代码

具体代码如下：
* U" A% D4 L7 h: b% Z" L9 T$ w

1. treenode agv = param(1);
   
2. treenode currentCP = param(2);
   
3. 
   
4. { //************* PickOption Start *************\\
   ! c& p" p; D: m! S2 V0 c
5. /***popup:AGV_DivertToElevator*/
   8 d6 v/ M4 @  C4 |& V9 N: v2 Z1 v
6. /***tag:Description*//**Divert to Elevator*/
   
7. 
   
8. int operation = param(3);
   
9. 
   7 a! S  ?" |5 f# k! t! v& ]
10. #define AGV_LABEL_NAME "fs_AGV_Elev_State"
    9 c. t4 M; g  D$ A
11. if (operation == 0 && !objectexists(label(agv, AGV_LABEL_NAME))
    - s3 B' s$ u! Y% L6 I
12.                 && (/** \nCondition: *//***tag:Condition*//**/fabs(zloc(currentCP) - zloc(agvinfo(agv, AGV_DEST_CP))) > zsize(agv)/**/)) { // if it's a pointer, then do the initial case
    7 F2 C% w9 }4 K$ r
13.         // initial trigger execution
    3 `& [/ G/ D0 J9 a& w9 U3 n* N: }
14.         #define ON_ELEVATOR_START 1
    # S9 L4 K/ z# \# J
15.         #define ON_ELEVATOR_PICKUP_ARRIVAL 2
    & ?2 `0 }' i6 F. u5 L! N* ^
16.         #define ON_ELEVATOR_DROPOFF_ARRIVAL 3
    
17.         #define ON_AGV_AT_CP 4
    
18.         #define ON_BOTH_AT_PICKUP 5
    ! j7 D5 @: v6 p( B
19.         #define ON_OPEN_DOOR 6
    
20.         #define ON_CLOSE_DOOR 7
    # `* c( k. @" @) x+ ]/ m# O7 |
21.         #define ON_PICKUP_DOOR_OPENED 8
    
22.         #define ON_PICKUP_DOOR_CLOSED 9
    
23.         #define ON_DROPOFF_DOOR_OPENED 10
    
24.         #define ON_DROPOFF_DOOR_CLOSED 11
    8 }  e4 Q( d* M+ E
25.        
    6 U$ ^  R7 |$ P7 j; F
26.         #define AGV_STATE_START 0
    
27.         #define AGV_STATE_AT_ENTRY_CP 1
    
28.         #define AGV_STATE_AT_ELEV_CP 2
    
29.         #define AGV_STATE_AT_EXIT_CP 3
    
30.        
    : [% m# ]1 |" c0 T. I( l( p! s" a
31.         #define ELEV_STATE_NONE 0
    # u+ ^/ T: k0 ~. w1 _$ X9 m: A
32.         #define ELEV_STATE_AT_PICKUP_FLOOR 1
    
33.         #define ELEV_STATE_OPENING_DOOR 2
    
34.         #define ELEV_STATE_DOOR_OPENED 3
    / J8 w) [. F) \$ q) D
35. 
    
36. 
    ) d; a2 m" i! ~: o) ~: t
37.         treenode elevDisp = /** \nDispatcher: *//***tag:Dispatcher*//**/cpconnection(currentCP, "Elevators", 1)/**/;
    
38.         #define elevator outobject(elevDisp, $iter(1))
    " W1 W9 p% w) Y5 j  e
39. 
    % \: ?: N. g: |: R0 `: p
40.         if (!objectexists(elevDisp))
    " G# O& j" M  q5 L
41.                 return 0;
    , j* f; k/ e- E
42. 
    2 p" i, z: u9 x4 G6 I
43.         if (/** \nDo Search: *//***tag:DoSearch*//**/1/**/) {
    # x. R9 g8 r4 m" q6 \
44.                 query(
    
45.                         /** \nFull Query: */
    
46.                         /***tag:FullQuery*//**/"SELECT $2 AS Elevator FROM $1 Elevators WHERE $3 ORDER BY $4 ASC LIMIT 1"/**/,
    / A2 {% u" u# o& J7 ?! V9 _* Z3 z
47.                         nrop(elevDisp),
    9 M# T5 l9 X8 ~
48.                         elevator
    8 q  d2 p) c1 N8 n. L. @. z  d
49.                         /** \nWhere*/
    
50.                         /***tagex:WhereParams*/,/** \n*/ /**AND*/ /** */ /**/getstatenum(elevator) == STATE_IDLE /**/
    ( d: O7 ^9 L# r: d( K. P
51.                         /***/
    ! P& l* x! B( a' b
52.                         /** \nOrderBy*/
    : x- r7 q1 n! ?' X4 N
53.                         /***tagex:OrderByParams*/,/** \n*/ /**/fabs(zloc(elevator) - zloc(agv))/**/ /**ASC*/
    
54.                         /***/);
    
55. 
    & U- e/ h' P/ T" `+ s5 u/ R
56.                 if (getquerymatchcount() > 0)
    
57.                         elevDisp = getqueryvalue(1, 1);
    
58.         }
    % v# A) T" @  H$ V
59.         if (!objectexists(elevDisp))
    6 ^4 W* f9 k& F' V6 p% I
60.                 return 0;
    + h- z$ n) f2 e% X
61.         treenode destCP = agvinfo(agv, AGV_DEST_CP);
    & I& `( e6 S( s- z9 }$ I. d
62. 
    
63.         agvredirect(agv, /** \nDivert Point When None Available: *//***tag:WaitDivertPoint*//**/currentCP/**/, REDIRECT_AND_WAIT);
    3 h/ Q0 s+ w# w1 h
64. 
    
65.         // Create the task sequence for the elevator
    
66.         double destZ = zloc(destCP);
    
67.         treenode ts = createemptytasksequence(elevDisp, 0, 0);
    
68.         inserttask(ts, TASKTYPE_TAG, agv, destCP);
    
69.         // immediately when the elevator starts the task sequence, I call ON_ELEVATOR_START
    & a+ O' c+ D+ y/ U& W; i& ]5 j
70.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_START, destZ);
    9 S+ k6 k9 c% o& e8 I
71.         // travel to the z location of the current control point
    
72.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, zloc(currentCP));
    
73.         // then call ON_ELEVATOR_PICKUP_ARRIVAL
    
74.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_PICKUP_ARRIVAL);
    
75.         // then wait for the agv to get on
    
76.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
77.         // then travel to the destination z location
    
78.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, destZ);
    % W" _& i1 h6 Q) x& O
79.         // then call ON_ELEVATOR_DROPOFF_ARRIVAL
    + ^6 m+ W! ?& G0 f
80.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_DROPOFF_ARRIVAL);
    + n6 }* f" ^0 H" T8 z& y
81.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
82.         dispatchtasksequence(ts);
    
83. } else switch (operation) {
    
84.         case ON_ELEVATOR_START: {
    9 y2 L& ~! b2 h7 ]; E$ x
85.                 // this is fired when I get a valid elevator
    
86.                 treenode elev = param(1);
    0 v3 j/ [/ G- `0 J  g% }- G
87.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
    
88. 
    1 _3 Z* X5 }. ?) C
89.                 // find the closest floor control point
    ) \$ U1 p. l3 S0 [! A* P2 j' m3 f
90.                 int floorCPCon = cpconnection(0, /** \nFloor Control Point Connection:*//***tag:FloorCPs*//**/"Destination"/**/, 0);
    6 g" o8 k  b. G0 ~4 D
91.                 treenode curFloorCP = findmin(cpnumconnections(elev, floorCPCon),
    
92.                                                         fabs(zloc(agv) - zloc(cpconnection(elev, floorCPCon, count))),
    
93.                                                         cpconnection(elev, floorCPCon, count));
    $ Z; M( F7 W/ [. Y3 {1 b3 e8 _
94.                 // return if there is none
    
95.                 if (!objectexists(curFloorCP))
    - f/ A- `& F9 @' F8 ^6 v
96.                         return 0;
    * X* v- v+ k2 v$ g! ]
97. 
    6 Q. N) f  b, W: T
98.                 // get the entry control point
    2 o7 m" u6 j% l9 R3 l( v% M/ x. y
99.                 treenode floorCP = curFloorCP;
    
100.                 treenode curFloorEntryCP = /** \nEntry Control Point: *//***tag:EntryCP*//**/cpconnection(floorCP, "EntryCP", 1)/**/;
     , R4 l+ C; {+ c+ w+ N( Q
101.                 if (!objectexists(curFloorEntryCP))
     . t) Y/ M% v/ [3 \( P# t
102.                         return 0;
     1 p4 V# X& h" Q. D4 K, i" v
103.                 treenode floorEntryCP = curFloorEntryCP;
     
104.                 treenode curFloorElevCP = /** \nElevator Control Point: *//***tag:ElevCP*//**/floorCP/**/;
     
105.                 if (!objectexists(curFloorElevCP))
     ) A0 B5 h/ j. e
106.                         return 0;
     
107. 
     ! v1 u- }' e/ d9 Y. x
108.                 double destZ = param(4);
     
109.                 // find the floor control point closest to the destination floor
     * G4 x0 f' I; P2 p8 U
110.                 treenode destFloorCP = findmin(cpnumconnections(elev, floorCPCon),
     - i& C- l# ?1 j
111.                                                         fabs(destZ - zloc(cpconnection(elev, floorCPCon, count))),
     1 d! `! D/ W3 s4 s
112.                                                         cpconnection(elev, floorCPCon, count));
     - _4 V4 M% G" Y' N$ w' h( A1 L
113.                                                        
     ) ?6 m! V$ D3 M! D* z! @
114.                 floorCP = destFloorCP;
     " ^4 R8 z# L4 L  P3 j
115.                 treenode destFloorElevCP = /** \nDest Elevator Control Point: *//***tag:DestElevCP*//**/floorCP/**/;
     
116.                 if (!objectexists(destFloorElevCP))
     
117.                         return 0;
     
118.                 // get the destination exit control point
     
119.                 treenode destExitCP = /** \nExit Control Point: *//***tag:ExitCP*//**/cpconnection(floorCP, "ExitCP", 1)/**/;
     8 W) [/ c  M& u
120.                 if (!objectexists(destExitCP))
     
121.                         return 0;
     0 \/ C: i) p2 Y" Q8 C
122. 
     
123. 
     
124.                 // add a listener for the agv. This will call this nodefunction in the ON_AGV_AT_CP section whenever the
     ( W( E5 j# S8 F7 |
125.                 // agv arrives at a node. I keep a state on the agv's state label, and then increment it each time
     
126.                 // the listener is called so I know which control point he's at, i.e. entry, elev, or exit.
     8 C1 U7 F( ]! X- g0 q
127.                 agvaddlistener(agv, c, AGV_LISTEN_ARRIVAL | AGV_LISTEN_INTERMEDIATE_DEST,
     
128.                         agv, elev, ON_AGV_AT_CP, AGV_LISTENER_PARAM_NODE);
     9 r$ `  N: T& \( e0 L
129.                
     0 e5 `- }. @; v- t: r
130.                 // set the data on the state label
     # U" E+ t# M0 r; W# c
131.                 treenode stateLabel = assertlabel(agv, AGV_LABEL_NAME, DATATYPE_NUMBER);
     
132.                 switch_destroyonreset(stateLabel, 1);
     0 W6 A( m" ^+ k+ ~& R
133.                 set(stateLabel, AGV_STATE_START);
     
134.                 set(assertsubnode(stateLabel, "ElevState", DATATYPE_NUMBER), 0);
     
135.                 nodepoint(assertsubnode(stateLabel, "ElevCP", DATATYPE_COUPLING), curFloorElevCP);
     
136.                 nodepoint(assertsubnode(stateLabel, "DestElevCP", DATATYPE_COUPLING), destFloorElevCP);
     
137.                 nodepoint(assertsubnode(stateLabel, "ExitCP", DATATYPE_COUPLING), destExitCP);
     7 R! g/ F- X) [; ^8 a" q
138.                 agvredirect(agv, curFloorEntryCP, REDIRECT_AND_WAIT);
     , a, z; }8 I9 F2 I
139.                 return 0;
     
140.         }
     
141.         case ON_AGV_AT_CP: {
     
142.                 // this is fired by the agv listener every time the agv arrives at a node.
     , j# I5 g8 m& Y* C7 B; V
143.                 treenode agv = param(1);
     ! H9 ?5 `/ K* a% w0 n
144.                 treenode elev = param(2);
     0 i! T+ r% Q. O0 f" |! W7 k5 U) k
145.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     2 ]) J* _/ w* y# T6 }0 r
146.                 // I increment the state label, and then switch on it
     " O  G; s0 N  k/ ^& r
147.                 inc(stateLabel, 1);
     0 e# G, {) M. ~! v8 C) V: A
148.                 switch (get(stateLabel)) {
     
149.                         case AGV_STATE_AT_ENTRY_CP: {
     3 r- _: V2 J7 Z/ I
150.                                 // the agv just arrived at the entry cp
     
151.                                 // so, figure out where the elevator is.
     - R- r/ ^, J  T( v7 k
152.                                 int elevState = get(node("ElevState", stateLabel));
     
153.                                 // if he's at the pickup floor with his door closed then open the door.
     ! Q7 s; ?  {( ?% m4 {/ H
154.                                 if (elevState == ELEV_STATE_AT_PICKUP_FLOOR)
     % i1 I6 M1 e' f) L
155.                                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     7 F8 E$ \9 k. O7 x  I1 V
156.                                 else if (elevState == ELEV_STATE_DOOR_OPENED) {
     
157.                                         // if his door is alread opened, then move the agv onto the elevator, i.e. to
     
158.                                         // the elevator cp
     ) a; v* \# J7 n# N& Y
159.                                         treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     ) e# t8 y. Q" m3 J9 w
160.                                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
161.                                 }
     
162.                                 break;
     ' z/ T. R  x5 g' V/ C1 Q
163.                         }
     
164.                         case AGV_STATE_AT_ELEV_CP: {
       b& ?& R  e( \
165.                                 // once the agv is at the elevator cp, close the door
     
166.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_PICKUP_DOOR_CLOSED);
     
167.                                 break;
     / s9 T& q* g. x' t9 o, b  m1 k
168.                         }
     : p0 ~# a3 b3 \" l& e7 [
169.                         case AGV_STATE_AT_EXIT_CP: {
       X6 @# g# L6 Q6 m  a
170.                                 // the agv is at the exit cp
     
171.                                 // destroy the listener node because I'm finished listening
     1 o6 b& o2 K& h! k& H
172.                                 treenode listenerNode = param(4);
     & V+ Y' b3 b: k* A8 u1 l( e  D
173.                                 destroyobject(listenerNode);
     
174.                                 int agvWait = /** \nWait On Door Close: *//***tag:WaitFinalDoorClose*//**/0/**/;
     , W/ k# f8 r- q4 N) A' C$ H
175.                                 if (!agvWait) {
     7 }/ F/ H) \) F6 L1 T: T
176.                                         // if the agv is supposed to continue on, then tell him to go to his final destination
     
177.                                         treenode destCP = gettaskinvolved(gettasksequence(elev, 0), 1, 2);
     1 h0 q0 J4 w+ |
178.                                         agvredirect(agv, destCP, REDIRECT_AS_FINAL);
     
179.                                 }
     - J# F9 l, M1 Q# Y
180.                                 // close the door
       L5 G6 D/ N, i0 z
181.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_DROPOFF_DOOR_CLOSED, agvWait);
     - G' p$ F$ }& @) o  p( ]
182.                                 // and I'm finished with the state label so I can destroy it.
     
183.                                 destroyobject(stateLabel);
     5 W1 l, s/ t) \6 Y* V
184.                                 break;
     
185.                         }
       n: }. V9 R( a% k' u6 ]' v) ?9 j3 ]
186.                 }
     
187.                 return 0;
     
188.         }
     
189.         case ON_ELEVATOR_PICKUP_ARRIVAL: {
     
190.                 // the elevator has arrived at the pick floor
     8 R8 @+ f/ H  A8 U
191.                 treenode elev = param(1);
     
192.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
193.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
194.                 treenode elevState = node("ElevState", stateLabel);
     
195.                 // set the elevator state to at-pickup-floor
     7 B3 n0 R; G# w+ {. |8 |
196.                 set(elevState, ELEV_STATE_AT_PICKUP_FLOOR);
     - ~: M' N0 @5 {9 _
197.        
     7 H  @  o: ]5 S4 U
198.                 int openDoorImmediately = /** \nOpen Elevator Door Immediately: *//***tag:OpenDoorImmediate*//**/0/**/;
       F# \( t* D9 M3 X0 n* K, g
199.                
     
200.                 // if the agv is at the entry control point or I open the door immediately, then open it
     5 }) s! Q% U4 l/ ]+ B7 T$ D. X9 h* e
201.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP || openDoorImmediately) {
     / o2 w/ d1 B& b( W3 J8 r
202.                         set(elevState, ELEV_STATE_OPENING_DOOR);
     
203.                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     % t2 K- {0 M+ e) B  {+ Q
204.                 }
     
205.                 return 0;
     + v9 k: k1 c+ ?# @7 @  b" ~$ U
206.         }
     4 U: U2 D) u9 G) i
207.         case ON_OPEN_DOOR: {
     
208.                 treenode agv = param(1);
     5 _- a# G" G3 B  ], y# p( X2 U
209.                 treenode elev = param(2);
     7 N$ e0 `. x' N; f7 z
210.                 int nextStep = param(4);
     
211.                 // open the door based on the time to open the door
     
212.                 double openDoorTime = /** \nDoor Open Delay:*//***tag:DoorOpenTime*//**/5/**/;
     
213.                 delayednodefunction(c, openDoorTime, elev, agv, nextStep);
     * q% A9 _, F$ D: v6 T* k5 z$ h0 k/ m
214.                 return 0;
     8 f1 V4 x. D# s2 p
215.         }
     * i5 G  R3 w+ B- D  H
216.         case ON_CLOSE_DOOR: {
     
217.                 treenode agv = param(1);
     * c8 M1 m' W. O2 Y$ g! @
218.                 treenode elev = param(2);
     # @  r! i9 D. L' e" g7 S
219.                 int nextStep = param(4);
     3 t# X1 h# K/ ~
220.                 // close the door base on the time to close the door
     
221.                 double delayTime = /** \nDoor Close Delay:*//***tag:DoorCloseTime*//**/5/**/;
     
222.                 delayednodefunction(c, delayTime, elev, agv, nextStep, param(5));
     ! `6 p+ s. R# \2 G  j; a
223.                 return 0;
     : ?1 t5 P6 o! F; P+ o1 ?
224.         }
     / E/ p4 Z! V: k; a( P) K
225.         case ON_PICKUP_DOOR_OPENED: {
     
226.                 // the elevator door has been opened on the pickup floor
     
227.                 treenode elev = param(1);
     % B! z" U3 S" Z! N8 F# A
228.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     4 u; T6 j9 h' e
229.                 treenode entryCP = cp(agv);
     / ~: o, v' x# Z2 v4 h
230.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     # {( s% j0 K4 n6 e0 ?
231.                 treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     
232.                 treenode elevState = node("ElevState", stateLabel);
     ! N2 m8 D. z1 O0 V. |. w$ x2 I  v' ~
233.                 // set the elevator state
     & b* d  I9 B) |" C6 b2 @
234.                 set(elevState, ELEV_STATE_DOOR_OPENED);
     
235.                 // if the agv is at the entry control point, move him to the elevator control point
     6 O8 y/ @* Z1 r2 T7 H" w' R8 r8 K
236.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP)
     , g  Y4 {! E/ S5 b) c
237.                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
238.                 return 0;
     . w2 X. T: \$ Z, p/ D% j
239.         }
     ! ^- Z0 Q' X( X0 T5 V
240.         case ON_PICKUP_DOOR_CLOSED: {
     
241.                 treenode elev = param(1);
     ' t) Q$ d/ ^& J6 l  `( Y  u( _! I
242.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
243.                 // assign the agv to "no control point"
     
244.                 agvreassigncp(agv, 0);
     
245.                 // move the agv into the elevator
     + E3 ]/ K1 S0 q0 C% Z, l8 q% [
246.                 moveobject(agv, elev);
     
247.                 setrot(agv, 0, 0, 0);
     
248.                 // release the elevator to continue to the destination floor
     4 F: c9 J' O0 m
249.                 freeoperators(elev, agv);
     ( K* P8 X" p: J  @& D9 L4 H
250.                 return 0;
     ) J3 p8 n1 u; G; [9 y$ X
251.         }
     ' N- y3 n7 S/ w4 W1 f, K0 m
252.         case ON_ELEVATOR_DROPOFF_ARRIVAL: {
     
253.                 treenode elev = param(1);
     ! W3 F) x" f. ~
254.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     : F( e7 \! d5 S% ^$ t& ?+ m
255.                 // when the elevator arrives at the destination floor
     
256.                 // move the agv back into the model
     
257.                 moveobject(agv, model());
     . }8 S& l- w" b1 }0 @! N
258.                 // reassign it to the destination floor control point
     
259.                 agvreassigncp(agv, tonode(get(node("DestElevCP", label(agv, AGV_LABEL_NAME)))));
     5 b1 R6 x3 p; ?) `) j
260.                 // open the elevator door
     1 ?6 I+ Q5 |) c# T
261.                 nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_DROPOFF_DOOR_OPENED);
     4 E/ _" S% W8 f# A4 m5 L
262.                 return 0;
     3 f  o& \' J; f1 a
263.         }
     : @. Q. P9 P& w* X( J- i" X
264.         case ON_DROPOFF_DOOR_OPENED: {
     3 d; C! s4 W8 m$ j) w& i
265.                 treenode elev = param(1);
     7 `+ H! T! Y7 u; |
266.                 treenode agv = param(2);
     0 U+ D& f# \* m' k1 h. K: ^  r# q2 l
267.                 treenode agvLabel = label(agv, AGV_LABEL_NAME);
     $ K: k+ g2 V4 ~5 o. Q! _) _) N
268.                 // once the elevator door is opened on the destination floor,
     
269.                 // redirect the agv to the exit control point
     6 J& |. a/ a: p
270.                 agvredirect(agv, tonode(get(node("ExitCP", agvLabel))), REDIRECT_AND_WAIT);
     6 R. q2 e1 k5 z3 j) F1 ~' j
271.                 return 0;
     2 S" e6 F& A/ u, W; N
272.         }
     
273.         case ON_DROPOFF_DOOR_CLOSED: {
     / D0 N2 C0 v( k9 q4 }5 O
274.                 treenode elev = param(1);
     $ u! s  q* {* f. ^" ~2 A
275.                 treenode agv = param(2);
     ' D7 b+ d5 C7 I% J
276.                 int isAGVWaiting = param(4);
     
277.                 // once the door is closed at the destination floor,
     ! a6 ]- h9 \9 T1 P! d
278.                 // if the agv is waiting, then send him to the final destination
     / l* Z" z# r% X5 C
279.                 if (isAGVWaiting)
     " A7 n: q: x" D. y) Z# P) _
280.                         agvredirect(agv, gettaskinvolved(gettasksequence(elev, 0), 1, 2), REDIRECT_AS_FINAL);
     / W! p, R+ }5 n" s! R
281.                 // release the elevator to finish his task sequence
     
282.                 freeoperators(elev, agv);
     : S8 `* b# k; e2 @+ M+ \
283.                 return 0;
     
284.         }
     
285. }
     
286. } //******* PickOption End *******\\
     3 U2 Z  i1 b- a
287. 
     

复制代码

% g8 M7 Y4 [" V" z* f( O
2 N) A& I4 n% G, B" z; r* d
办法2：使用工艺流程模块完成

慧娴亚伦 发表于 2018-11-4 19:12
办法1：从2016版本里面复制相应的代码

具体代码如下：

% B. k: w' y  h. }" P. A; |好的，非常感谢陈老师的解答~