2018.2.0版中AGV如何乘升降机？

请教一下，2018.2.0版中AGV模块，路径点逻辑里没有乘升降机的选项，该如何实现这个操作？
5 X+ {$ w! J2 E& e3 ~
. D- N% `; Z6 Z! z( O

办法1：从2016版本里面复制相应的代码
/ J+ o8 G! [- ]7 ^9 P* P0 u
: J4 F. U6 w3 z8 w具体代码如下：
7 H4 V% F# a8 h6 u

1. treenode agv = param(1);
   $ e$ A/ b$ ^  W2 h
2. treenode currentCP = param(2);
   
3. 
   
4. { //************* PickOption Start *************\\
   / H) t* m6 Q, a( z$ I4 Z5 ]; C
5. /***popup:AGV_DivertToElevator*/
   - Q+ e# Z; D0 @$ N, K+ e
6. /***tag:Description*//**Divert to Elevator*/
   
7. 
   ) K' s4 P0 Q( |( v$ q5 E
8. int operation = param(3);
   3 h' n" n0 w1 u4 {
9. 
   
10. #define AGV_LABEL_NAME "fs_AGV_Elev_State"
    
11. if (operation == 0 && !objectexists(label(agv, AGV_LABEL_NAME))
    : t* {' N) u  b$ [
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
    $ e4 [2 D3 N  y/ T- i) g- j
13.         // initial trigger execution
    / ^: t# X1 ~+ [  a- }" W
14.         #define ON_ELEVATOR_START 1
    $ k# D+ P3 T# y, ?  {
15.         #define ON_ELEVATOR_PICKUP_ARRIVAL 2
    
16.         #define ON_ELEVATOR_DROPOFF_ARRIVAL 3
    
17.         #define ON_AGV_AT_CP 4
    
18.         #define ON_BOTH_AT_PICKUP 5
    . q3 d) Q" C: I2 b
19.         #define ON_OPEN_DOOR 6
    6 v0 ~- w3 s: H) A
20.         #define ON_CLOSE_DOOR 7
    5 M, A2 S# @( [% u
21.         #define ON_PICKUP_DOOR_OPENED 8
    
22.         #define ON_PICKUP_DOOR_CLOSED 9
    / X2 N: p# B1 d1 L* J( j# S3 C# x
23.         #define ON_DROPOFF_DOOR_OPENED 10
    
24.         #define ON_DROPOFF_DOOR_CLOSED 11
    
25.        
    " T/ q5 t; g% v7 o
26.         #define AGV_STATE_START 0
    
27.         #define AGV_STATE_AT_ENTRY_CP 1
    
28.         #define AGV_STATE_AT_ELEV_CP 2
    1 T0 M, r) v1 F2 ^) [% y7 `4 W
29.         #define AGV_STATE_AT_EXIT_CP 3
    & ~/ a% e5 x- A+ u  H
30.        
    
31.         #define ELEV_STATE_NONE 0
    
32.         #define ELEV_STATE_AT_PICKUP_FLOOR 1
      c# ?" O* L/ V0 }
33.         #define ELEV_STATE_OPENING_DOOR 2
    
34.         #define ELEV_STATE_DOOR_OPENED 3
    
35. 
    
36. 
    0 s. M; C$ e$ k' f* R
37.         treenode elevDisp = /** \nDispatcher: *//***tag:Dispatcher*//**/cpconnection(currentCP, "Elevators", 1)/**/;
    
38.         #define elevator outobject(elevDisp, $iter(1))
    $ y, b8 H  |+ ]* R! e; U: s$ s
39. 
    6 H% w: U8 K( D
40.         if (!objectexists(elevDisp))
    " d3 t* [* B" x9 m$ {1 O: T$ H3 N
41.                 return 0;
    1 H0 e# z1 s3 Q# D
42. 
    0 k2 X3 J$ }& `" P% {, h
43.         if (/** \nDo Search: *//***tag:DoSearch*//**/1/**/) {
    : L! ~3 z, P# ^, i3 e* h
44.                 query(
    3 w# E- n, x  \: p/ ]% F! y
45.                         /** \nFull Query: */
    
46.                         /***tag:FullQuery*//**/"SELECT $2 AS Elevator FROM $1 Elevators WHERE $3 ORDER BY $4 ASC LIMIT 1"/**/,
    1 h3 @5 u/ a" r- e. S/ u! R. Q% x& f
47.                         nrop(elevDisp),
    
48.                         elevator
    
49.                         /** \nWhere*/
    7 x  J, M$ \) U& E( i$ K9 \
50.                         /***tagex:WhereParams*/,/** \n*/ /**AND*/ /** */ /**/getstatenum(elevator) == STATE_IDLE /**/
    
51.                         /***/
    * u) w% H9 m% x7 E7 a& l
52.                         /** \nOrderBy*/
    7 N4 @, `( Y7 y6 }2 W
53.                         /***tagex:OrderByParams*/,/** \n*/ /**/fabs(zloc(elevator) - zloc(agv))/**/ /**ASC*/
    0 X& L; D$ H1 o7 [7 }) E: h
54.                         /***/);
    
55. 
    ) E* F; D$ C' \2 ]8 v6 u
56.                 if (getquerymatchcount() > 0)
    
57.                         elevDisp = getqueryvalue(1, 1);
    6 ?7 U7 E6 R" `
58.         }
    ) I+ n/ ^1 U1 ?2 Q, X
59.         if (!objectexists(elevDisp))
    8 y$ W& u4 U5 @2 }, X- n
60.                 return 0;
      R/ W6 b- U$ w, Z+ C7 c
61.         treenode destCP = agvinfo(agv, AGV_DEST_CP);
    
62. 
    . M- Z4 p- m0 d5 w
63.         agvredirect(agv, /** \nDivert Point When None Available: *//***tag:WaitDivertPoint*//**/currentCP/**/, REDIRECT_AND_WAIT);
    
64. 
    
65.         // Create the task sequence for the elevator
    * S# I% ^8 X6 J$ Q* [+ Q# ~; T7 q- A
66.         double destZ = zloc(destCP);
    6 E$ v1 M8 x5 q* L
67.         treenode ts = createemptytasksequence(elevDisp, 0, 0);
    * z; U# M0 p" O1 {0 f
68.         inserttask(ts, TASKTYPE_TAG, agv, destCP);
    7 A6 s% V; N. \2 w- s+ B
69.         // immediately when the elevator starts the task sequence, I call ON_ELEVATOR_START
    
70.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_START, destZ);
    ! D& L0 T: W+ ~, X6 z' Y' y
71.         // travel to the z location of the current control point
    
72.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, zloc(currentCP));
    7 Q9 W; Q& W! E
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
    $ P) X; Z9 H2 q2 G& {
76.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
77.         // then travel to the destination z location
    % k0 m0 `/ S- s/ J
78.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, destZ);
    
79.         // then call ON_ELEVATOR_DROPOFF_ARRIVAL
    
80.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_DROPOFF_ARRIVAL);
    
81.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    5 s" g5 r4 K1 K( k* i% M
82.         dispatchtasksequence(ts);
    + {& q& p7 `& Z4 B( Q! ^
83. } else switch (operation) {
    2 v# F+ f; h& r6 j0 l
84.         case ON_ELEVATOR_START: {
    
85.                 // this is fired when I get a valid elevator
    
86.                 treenode elev = param(1);
    
87.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
    5 E* z# J; Z$ G; ?. G4 ?6 o
88. 
    ; B, u8 x' E. h9 ~! b
89.                 // find the closest floor control point
    , L) B) W) p# b6 E4 O" |" l, [
90.                 int floorCPCon = cpconnection(0, /** \nFloor Control Point Connection:*//***tag:FloorCPs*//**/"Destination"/**/, 0);
    ; q2 T$ i3 j- T5 u6 j
91.                 treenode curFloorCP = findmin(cpnumconnections(elev, floorCPCon),
    " @/ n# J$ Y5 n9 [4 i) {
92.                                                         fabs(zloc(agv) - zloc(cpconnection(elev, floorCPCon, count))),
    
93.                                                         cpconnection(elev, floorCPCon, count));
    
94.                 // return if there is none
    5 F/ |3 G9 |' n+ v9 e
95.                 if (!objectexists(curFloorCP))
    7 e9 M7 c, P' a" ]: B
96.                         return 0;
    + Z# C# ?3 S2 y/ d
97. 
    
98.                 // get the entry control point
    + c3 Z* J0 h. w$ |  t
99.                 treenode floorCP = curFloorCP;
    
100.                 treenode curFloorEntryCP = /** \nEntry Control Point: *//***tag:EntryCP*//**/cpconnection(floorCP, "EntryCP", 1)/**/;
     1 p8 F$ I  k  ^: y
101.                 if (!objectexists(curFloorEntryCP))
     6 P2 a& K8 X0 X
102.                         return 0;
     8 b. j/ t* J+ b
103.                 treenode floorEntryCP = curFloorEntryCP;
     
104.                 treenode curFloorElevCP = /** \nElevator Control Point: *//***tag:ElevCP*//**/floorCP/**/;
     
105.                 if (!objectexists(curFloorElevCP))
     5 Z$ p) ]8 Q  w/ t! m8 ?5 g  w
106.                         return 0;
     , d- |7 C4 Y' f" J6 f; F" g
107. 
     " P5 |; y: s- [4 G2 C! |0 a
108.                 double destZ = param(4);
     
109.                 // find the floor control point closest to the destination floor
     
110.                 treenode destFloorCP = findmin(cpnumconnections(elev, floorCPCon),
       c: i& g5 G. i' k/ T
111.                                                         fabs(destZ - zloc(cpconnection(elev, floorCPCon, count))),
     9 U: ]5 f1 G% ~9 {7 E1 ]5 Q9 J
112.                                                         cpconnection(elev, floorCPCon, count));
     " w  Z) n$ A5 b
113.                                                        
     
114.                 floorCP = destFloorCP;
     
115.                 treenode destFloorElevCP = /** \nDest Elevator Control Point: *//***tag:DestElevCP*//**/floorCP/**/;
     : o$ K+ _" J6 o5 Z2 ?. `! ~" A
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)/**/;
     3 d8 Y' R$ i1 m: a' o
120.                 if (!objectexists(destExitCP))
     
121.                         return 0;
     ) p8 Z. F/ |! g; |3 q
122. 
     
123. 
     # p3 |% m; G7 ]! p* }
124.                 // add a listener for the agv. This will call this nodefunction in the ON_AGV_AT_CP section whenever the
     5 q. S% a( q* ]% |9 Y
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.
     1 w  v& x0 m) N! ]& o/ G5 d3 o
127.                 agvaddlistener(agv, c, AGV_LISTEN_ARRIVAL | AGV_LISTEN_INTERMEDIATE_DEST,
     " v9 }5 {, Y# j0 e) k" i
128.                         agv, elev, ON_AGV_AT_CP, AGV_LISTENER_PARAM_NODE);
     3 e' r- \0 }3 v1 |0 D0 k
129.                
     
130.                 // set the data on the state label
     
131.                 treenode stateLabel = assertlabel(agv, AGV_LABEL_NAME, DATATYPE_NUMBER);
     7 k" K3 m$ _$ M; z) e
132.                 switch_destroyonreset(stateLabel, 1);
     
133.                 set(stateLabel, AGV_STATE_START);
     
134.                 set(assertsubnode(stateLabel, "ElevState", DATATYPE_NUMBER), 0);
     
135.                 nodepoint(assertsubnode(stateLabel, "ElevCP", DATATYPE_COUPLING), curFloorElevCP);
     & k; u2 P# H- O$ H8 L
136.                 nodepoint(assertsubnode(stateLabel, "DestElevCP", DATATYPE_COUPLING), destFloorElevCP);
     
137.                 nodepoint(assertsubnode(stateLabel, "ExitCP", DATATYPE_COUPLING), destExitCP);
     7 X5 X8 e! u& L) |8 i9 Q
138.                 agvredirect(agv, curFloorEntryCP, REDIRECT_AND_WAIT);
     
139.                 return 0;
     
140.         }
     
141.         case ON_AGV_AT_CP: {
     5 l. z$ V  Q' E  c
142.                 // this is fired by the agv listener every time the agv arrives at a node.
     
143.                 treenode agv = param(1);
     ! f: \2 A0 T: o4 Q7 a: S+ `7 |# C" O
144.                 treenode elev = param(2);
     ( a& ]0 ]# s# {! u! L6 }/ @% V
145.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     # u" E* s% `, R0 U  ^" h1 w
146.                 // I increment the state label, and then switch on it
     ! W' v: n  n/ Q/ b6 |0 ?
147.                 inc(stateLabel, 1);
     + ?$ `4 J1 m' i# v
148.                 switch (get(stateLabel)) {
     8 M! p( {* |0 u- y0 t. I
149.                         case AGV_STATE_AT_ENTRY_CP: {
     
150.                                 // the agv just arrived at the entry cp
     $ e: K! b9 s3 o+ f8 `; [
151.                                 // so, figure out where the elevator is.
     
152.                                 int elevState = get(node("ElevState", stateLabel));
     
153.                                 // if he's at the pickup floor with his door closed then open the door.
     7 l8 E5 X$ h6 t# |
154.                                 if (elevState == ELEV_STATE_AT_PICKUP_FLOOR)
     , \  G) Q, K2 D) c
155.                                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     
156.                                 else if (elevState == ELEV_STATE_DOOR_OPENED) {
     2 M* J7 G. u3 g. d
157.                                         // if his door is alread opened, then move the agv onto the elevator, i.e. to
     
158.                                         // the elevator cp
     
159.                                         treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     ( Y- \4 @- j" [5 a
160.                                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
161.                                 }
     
162.                                 break;
     
163.                         }
     / j; E1 e/ j5 r" r* U
164.                         case AGV_STATE_AT_ELEV_CP: {
     + I/ l# Y1 l3 f6 n" g! f
165.                                 // once the agv is at the elevator cp, close the door
     : s1 m. l0 O& \6 d4 X: s* E
166.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_PICKUP_DOOR_CLOSED);
     
167.                                 break;
     
168.                         }
     
169.                         case AGV_STATE_AT_EXIT_CP: {
     
170.                                 // the agv is at the exit cp
     , m  X1 w6 `/ z- p
171.                                 // destroy the listener node because I'm finished listening
     9 Z0 J9 ~: M4 m7 p1 a: E
172.                                 treenode listenerNode = param(4);
     
173.                                 destroyobject(listenerNode);
     5 f9 E- K' S# I" @% z: v2 `. l
174.                                 int agvWait = /** \nWait On Door Close: *//***tag:WaitFinalDoorClose*//**/0/**/;
     
175.                                 if (!agvWait) {
     
176.                                         // if the agv is supposed to continue on, then tell him to go to his final destination
     7 Y& |- o* I$ b5 c
177.                                         treenode destCP = gettaskinvolved(gettasksequence(elev, 0), 1, 2);
     
178.                                         agvredirect(agv, destCP, REDIRECT_AS_FINAL);
     / j" p! H8 _* u8 t) G" ^
179.                                 }
     
180.                                 // close the door
     
181.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_DROPOFF_DOOR_CLOSED, agvWait);
     ( \. b3 u" v. w" ^( M" t9 T
182.                                 // and I'm finished with the state label so I can destroy it.
     ) R1 H" ]; t6 {$ x/ w
183.                                 destroyobject(stateLabel);
     
184.                                 break;
     
185.                         }
     + E) M8 V1 G0 ]& B0 a6 ]. S0 h
186.                 }
     
187.                 return 0;
     
188.         }
     
189.         case ON_ELEVATOR_PICKUP_ARRIVAL: {
     4 ]' o+ R2 K* z- r" Y, a: {
190.                 // the elevator has arrived at the pick floor
     
191.                 treenode elev = param(1);
     & F; Z8 n: N& l4 l3 }
192.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
193.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     
194.                 treenode elevState = node("ElevState", stateLabel);
     9 s* a2 {) q) W8 S9 F
195.                 // set the elevator state to at-pickup-floor
     ' B( ~5 ~7 C7 Q1 u- h2 e) a  P
196.                 set(elevState, ELEV_STATE_AT_PICKUP_FLOOR);
     7 {2 A" u1 f! C! K
197.        
     6 [9 B. M. Q) Y3 b& V* X! T
198.                 int openDoorImmediately = /** \nOpen Elevator Door Immediately: *//***tag:OpenDoorImmediate*//**/0/**/;
     ; {& _9 X: g5 u# R% L  p2 e
199.                
     $ M% X; z, P3 k0 [
200.                 // if the agv is at the entry control point or I open the door immediately, then open it
     
201.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP || openDoorImmediately) {
     
202.                         set(elevState, ELEV_STATE_OPENING_DOOR);
     
203.                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     
204.                 }
     # m5 O6 r  t3 ?0 ?% i' k$ f
205.                 return 0;
     
206.         }
     
207.         case ON_OPEN_DOOR: {
     
208.                 treenode agv = param(1);
     
209.                 treenode elev = param(2);
     
210.                 int nextStep = param(4);
     + q7 @2 x' b% O  Q8 a# [
211.                 // open the door based on the time to open the door
     ( k- A# ]0 ?3 J
212.                 double openDoorTime = /** \nDoor Open Delay:*//***tag:DoorOpenTime*//**/5/**/;
     ! \# l! a! y; U& ]* L9 Z  E0 H
213.                 delayednodefunction(c, openDoorTime, elev, agv, nextStep);
     & ~7 S6 y; v# T6 v) I$ `8 d4 h
214.                 return 0;
     * X5 X+ C/ {6 H5 m- u. L
215.         }
     & ]- T- x# c: y% }7 P6 T1 W% z
216.         case ON_CLOSE_DOOR: {
     & Y% \6 c( g+ l) f% E8 Z4 B
217.                 treenode agv = param(1);
     6 `8 Q6 w2 X) f+ X5 \' g. ?% q9 b( {
218.                 treenode elev = param(2);
     4 L# R) o" z. z& N- r6 ^. [
219.                 int nextStep = param(4);
     
220.                 // close the door base on the time to close the door
     ; `1 u3 E. o. Z3 n, G: H3 E
221.                 double delayTime = /** \nDoor Close Delay:*//***tag:DoorCloseTime*//**/5/**/;
     8 ^. J6 n2 @0 I7 R8 h3 {2 d. e
222.                 delayednodefunction(c, delayTime, elev, agv, nextStep, param(5));
     
223.                 return 0;
     
224.         }
     
225.         case ON_PICKUP_DOOR_OPENED: {
     
226.                 // the elevator door has been opened on the pickup floor
     
227.                 treenode elev = param(1);
     ; Z+ z  f/ X; O/ R
228.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
229.                 treenode entryCP = cp(agv);
     * B8 L, Q! u9 D
230.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     / b( _8 R9 Q! F; ?4 p! ?
231.                 treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     1 m' r% s1 q' G7 j- t
232.                 treenode elevState = node("ElevState", stateLabel);
     
233.                 // set the elevator state
     2 y( m6 L: t2 Q8 m; s, R6 \
234.                 set(elevState, ELEV_STATE_DOOR_OPENED);
     
235.                 // if the agv is at the entry control point, move him to the elevator control point
     
236.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP)
     
237.                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
238.                 return 0;
     ! x  y. v2 b$ N. b. P3 y
239.         }
     
240.         case ON_PICKUP_DOOR_CLOSED: {
     * X( t+ e( ]6 G1 b4 r6 i
241.                 treenode elev = param(1);
     
242.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     7 i" Q5 a0 }. g4 q
243.                 // assign the agv to "no control point"
     ; B+ i4 B- m& I0 M! {# O. I9 ?
244.                 agvreassigncp(agv, 0);
     
245.                 // move the agv into the elevator
     
246.                 moveobject(agv, elev);
     0 a  j0 a* k- B3 W7 K% U
247.                 setrot(agv, 0, 0, 0);
     
248.                 // release the elevator to continue to the destination floor
     
249.                 freeoperators(elev, agv);
     4 D9 t2 W( @0 T* k& [9 X# ?
250.                 return 0;
     : q9 F- q5 Z( r+ Z: s5 z
251.         }
     7 ]/ d, l4 k( L, g0 k6 a
252.         case ON_ELEVATOR_DROPOFF_ARRIVAL: {
     , v4 k. a" t" K4 K- q2 @$ l
253.                 treenode elev = param(1);
     
254.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
255.                 // when the elevator arrives at the destination floor
     
256.                 // move the agv back into the model
     
257.                 moveobject(agv, model());
     
258.                 // reassign it to the destination floor control point
     4 j5 t/ V3 \$ g5 S0 m! y
259.                 agvreassigncp(agv, tonode(get(node("DestElevCP", label(agv, AGV_LABEL_NAME)))));
     7 V% ~2 ~( p( E1 M  ^: a$ }
260.                 // open the elevator door
     
261.                 nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_DROPOFF_DOOR_OPENED);
     5 Y; T, t; f; R& X$ h5 F! S
262.                 return 0;
     
263.         }
     ; i; u4 _7 c) u! g: l; D
264.         case ON_DROPOFF_DOOR_OPENED: {
     
265.                 treenode elev = param(1);
     
266.                 treenode agv = param(2);
     
267.                 treenode agvLabel = label(agv, AGV_LABEL_NAME);
     4 L$ E, `. h& ]* j8 a3 r/ u
268.                 // once the elevator door is opened on the destination floor,
     
269.                 // redirect the agv to the exit control point
     
270.                 agvredirect(agv, tonode(get(node("ExitCP", agvLabel))), REDIRECT_AND_WAIT);
     3 I& {- a. w# z
271.                 return 0;
     
272.         }
     
273.         case ON_DROPOFF_DOOR_CLOSED: {
     
274.                 treenode elev = param(1);
     
275.                 treenode agv = param(2);
     
276.                 int isAGVWaiting = param(4);
     
277.                 // once the door is closed at the destination floor,
     
278.                 // if the agv is waiting, then send him to the final destination
     
279.                 if (isAGVWaiting)
     
280.                         agvredirect(agv, gettaskinvolved(gettasksequence(elev, 0), 1, 2), REDIRECT_AS_FINAL);
     $ z' U* Q# H5 _3 A
281.                 // release the elevator to finish his task sequence
     1 I7 ~* l* r) Y9 c  X, y9 q
282.                 freeoperators(elev, agv);
     ( @: V" {9 f. V1 ?6 z3 X- A8 K
283.                 return 0;
     2 s/ T. E& {- m% `) E8 T: k
284.         }
     * H  F; l% s6 q; i
285. }
     
286. } //******* PickOption End *******\\
     5 s9 v6 g9 [2 d; a, k) l( e
287. 
     2 v( K+ d% @( E! J7 a3 p- i5 u

复制代码

办法2：使用工艺流程模块完成

慧娴亚伦 发表于 2018-11-4 19:12
办法1：从2016版本里面复制相应的代码
$ L% e* P" M5 i
5 `- M/ j+ t7 z' a5 y  y. `# u具体代码如下：

好的，非常感谢陈老师的解答~