2018.2.0版中AGV如何乘升降机？

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

办法1：从2016版本里面复制相应的代码
, P- j3 u  a; H: b  W! W, K7 [0 R. s
具体代码如下：
, B) ^5 B7 i/ g

1. treenode agv = param(1);
   
2. treenode currentCP = param(2);
   / r7 Q/ h$ q% A8 ^$ t. I0 o' p& b3 E
3. 
   ; m8 i1 A* m8 N
4. { //************* PickOption Start *************\\
   
5. /***popup:AGV_DivertToElevator*/
   7 n3 n: A* m' @5 C  E6 A
6. /***tag:Description*//**Divert to Elevator*/
   
7. 
   
8. int operation = param(3);
   0 D( M3 k8 f# A: F! A
9. 
   
10. #define AGV_LABEL_NAME "fs_AGV_Elev_State"
    1 U4 v# C8 }. b! N- g/ q
11. if (operation == 0 && !objectexists(label(agv, AGV_LABEL_NAME))
    4 m7 [3 @1 W& J- B7 \
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
    
13.         // initial trigger execution
    
14.         #define ON_ELEVATOR_START 1
    
15.         #define ON_ELEVATOR_PICKUP_ARRIVAL 2
    9 H) X' E5 j7 X  U1 G: p
16.         #define ON_ELEVATOR_DROPOFF_ARRIVAL 3
    + G3 m6 n  B2 e
17.         #define ON_AGV_AT_CP 4
    : @. N2 ?3 K/ k
18.         #define ON_BOTH_AT_PICKUP 5
    
19.         #define ON_OPEN_DOOR 6
    " H5 o/ Q& g# k+ P2 G
20.         #define ON_CLOSE_DOOR 7
    1 `! ~! J8 H  o2 C5 h$ I
21.         #define ON_PICKUP_DOOR_OPENED 8
    ; L' J) k" w# }, k" b% N. T- f
22.         #define ON_PICKUP_DOOR_CLOSED 9
    6 y/ R! G3 p6 b+ y9 r& C
23.         #define ON_DROPOFF_DOOR_OPENED 10
    
24.         #define ON_DROPOFF_DOOR_CLOSED 11
    6 ?& F0 E6 z7 |! _: r# q
25.        
    
26.         #define AGV_STATE_START 0
    * H0 O: @( F) N/ R% O* B
27.         #define AGV_STATE_AT_ENTRY_CP 1
    0 p  w  f  s, [' \
28.         #define AGV_STATE_AT_ELEV_CP 2
    
29.         #define AGV_STATE_AT_EXIT_CP 3
    
30.        
    2 g; Z3 \* X6 V7 ^9 c% Q
31.         #define ELEV_STATE_NONE 0
    
32.         #define ELEV_STATE_AT_PICKUP_FLOOR 1
    / A2 d7 }$ h  f( ~7 \, o
33.         #define ELEV_STATE_OPENING_DOOR 2
    / I' e" a$ f' R
34.         #define ELEV_STATE_DOOR_OPENED 3
    ' O* P+ }; K2 U5 [
35. 
    0 z. a  R; H! G9 a8 H- G3 l5 d
36. 
    7 u) U( z6 z+ F: `, ?5 D" c
37.         treenode elevDisp = /** \nDispatcher: *//***tag:Dispatcher*//**/cpconnection(currentCP, "Elevators", 1)/**/;
    * N, {, U# O1 S; w
38.         #define elevator outobject(elevDisp, $iter(1))
      y0 @1 l7 d2 E' j
39. 
    , x- J0 R' z% Y2 [( ~& u$ j
40.         if (!objectexists(elevDisp))
    
41.                 return 0;
    - h0 V. j: i* y3 R/ C/ ~) x) c
42. 
    2 N& U1 O7 G0 ~# q2 Q7 v
43.         if (/** \nDo Search: *//***tag:DoSearch*//**/1/**/) {
    
44.                 query(
    
45.                         /** \nFull Query: */
    
46.                         /***tag:FullQuery*//**/"SELECT $2 AS Elevator FROM $1 Elevators WHERE $3 ORDER BY $4 ASC LIMIT 1"/**/,
    2 K1 b0 g# e7 X( J
47.                         nrop(elevDisp),
    & [/ w! M2 [* x. s* l% G
48.                         elevator
    7 c' K9 K* r  H9 i3 F& S
49.                         /** \nWhere*/
    + Q0 e( Z$ e1 u- d+ F5 H
50.                         /***tagex:WhereParams*/,/** \n*/ /**AND*/ /** */ /**/getstatenum(elevator) == STATE_IDLE /**/
    
51.                         /***/
    , E6 }7 Z$ a! B% |( }
52.                         /** \nOrderBy*/
    , l8 ^1 G8 Q. Y6 m) }8 L/ K0 e
53.                         /***tagex:OrderByParams*/,/** \n*/ /**/fabs(zloc(elevator) - zloc(agv))/**/ /**ASC*/
    , z1 i$ T$ b5 U1 [( v
54.                         /***/);
    
55. 
    , t4 C- O* c' ^  x8 d
56.                 if (getquerymatchcount() > 0)
    ; m- p, G6 P0 ]
57.                         elevDisp = getqueryvalue(1, 1);
    
58.         }
    5 G0 g$ V" N7 B* h! x, I8 q
59.         if (!objectexists(elevDisp))
    
60.                 return 0;
    
61.         treenode destCP = agvinfo(agv, AGV_DEST_CP);
    - }  i1 c9 t5 y: w; i3 Q
62. 
    0 M: @7 }+ \7 ]# F8 F: P
63.         agvredirect(agv, /** \nDivert Point When None Available: *//***tag:WaitDivertPoint*//**/currentCP/**/, REDIRECT_AND_WAIT);
    4 F# I. t+ p) J- F
64. 
    
65.         // Create the task sequence for the elevator
    
66.         double destZ = zloc(destCP);
    4 ]9 m9 D* [; `& X* d! s+ n
67.         treenode ts = createemptytasksequence(elevDisp, 0, 0);
    ; Q1 O4 S/ L, d6 i
68.         inserttask(ts, TASKTYPE_TAG, agv, destCP);
    
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);
    , c, |% K; \- O$ j$ b( O* v1 H
71.         // travel to the z location of the current control point
    ; B2 Q7 Y$ U9 x2 Z5 W* U. T
72.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, zloc(currentCP));
    - D: Z0 L- m4 v2 }  f% w4 Y1 g
73.         // then call ON_ELEVATOR_PICKUP_ARRIVAL
    , s0 W# F; v% R" h$ ]: S
74.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_PICKUP_ARRIVAL);
    
75.         // then wait for the agv to get on
    & l7 l' I0 I3 D4 V/ T
76.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    
77.         // then travel to the destination z location
    
78.         inserttask(ts, TASKTYPE_TRAVELTOLOC, 0, 0, 0, 0, destZ);
    
79.         // then call ON_ELEVATOR_DROPOFF_ARRIVAL
    / w4 ?2 W$ A* \
80.         inserttask(ts, TASKTYPE_NODEFUNCTION, c, 0, 0, ON_ELEVATOR_DROPOFF_ARRIVAL);
    9 |- R% m+ z$ D+ S% i7 K
81.         inserttask(ts, TASKTYPE_UTILIZE, agv);
    3 ]" }: f& B7 D- h; O8 F$ R
82.         dispatchtasksequence(ts);
    
83. } else switch (operation) {
    7 ~* u/ h* Y$ H; |; w) {% W' E5 i
84.         case ON_ELEVATOR_START: {
    8 I0 l1 a. I4 b6 W
85.                 // this is fired when I get a valid elevator
    
86.                 treenode elev = param(1);
    $ r$ }: X" a3 g- W7 a# k; f
87.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
    
88. 
    
89.                 // find the closest floor control point
    
90.                 int floorCPCon = cpconnection(0, /** \nFloor Control Point Connection:*//***tag:FloorCPs*//**/"Destination"/**/, 0);
      W5 h8 }) x. K9 p1 L
91.                 treenode curFloorCP = findmin(cpnumconnections(elev, floorCPCon),
    
92.                                                         fabs(zloc(agv) - zloc(cpconnection(elev, floorCPCon, count))),
    
93.                                                         cpconnection(elev, floorCPCon, count));
    
94.                 // return if there is none
    3 R; z' O# I* w* U1 l7 {% `' S" z
95.                 if (!objectexists(curFloorCP))
    7 K  P  _2 F- P6 a3 K
96.                         return 0;
    1 \% ]4 A+ t+ a' _
97. 
    ) u  z7 m( z% G1 v
98.                 // get the entry control point
    ; w% Q& b, i8 t/ u
99.                 treenode floorCP = curFloorCP;
    5 W" G! ]: o5 f6 a/ B) o* N0 `/ G
100.                 treenode curFloorEntryCP = /** \nEntry Control Point: *//***tag:EntryCP*//**/cpconnection(floorCP, "EntryCP", 1)/**/;
     & H, E! `: G0 {6 [+ A" F
101.                 if (!objectexists(curFloorEntryCP))
     
102.                         return 0;
     : G0 o/ f: i5 D* E/ w
103.                 treenode floorEntryCP = curFloorEntryCP;
     
104.                 treenode curFloorElevCP = /** \nElevator Control Point: *//***tag:ElevCP*//**/floorCP/**/;
     * t  K: y1 K  J
105.                 if (!objectexists(curFloorElevCP))
     1 _9 s. G5 Z8 [. ^) A7 k
106.                         return 0;
       r7 u2 k- g/ u, `- P. U& m( I
107. 
     ! B- w5 `; w' m6 A
108.                 double destZ = param(4);
     2 D: C& P' T# s$ b0 q+ e
109.                 // find the floor control point closest to the destination floor
     * w& {& ?/ k4 O/ ~$ Z
110.                 treenode destFloorCP = findmin(cpnumconnections(elev, floorCPCon),
     6 V- C+ _9 z, @9 W
111.                                                         fabs(destZ - zloc(cpconnection(elev, floorCPCon, count))),
     & }$ a' k) w% V0 L$ x; V8 M
112.                                                         cpconnection(elev, floorCPCon, count));
     
113.                                                        
     2 r/ U; G* a; H( |) M
114.                 floorCP = destFloorCP;
     
115.                 treenode destFloorElevCP = /** \nDest Elevator Control Point: *//***tag:DestElevCP*//**/floorCP/**/;
     - I- |! s5 N- ^' F' K# g
116.                 if (!objectexists(destFloorElevCP))
     
117.                         return 0;
     6 A# u5 r9 I; g$ C* g- w
118.                 // get the destination exit control point
     % _5 G$ {' i$ }2 p. u4 q/ }0 \
119.                 treenode destExitCP = /** \nExit Control Point: *//***tag:ExitCP*//**/cpconnection(floorCP, "ExitCP", 1)/**/;
     8 U: b* Q) y  S5 \& z4 }) l" p+ c
120.                 if (!objectexists(destExitCP))
     
121.                         return 0;
     
122. 
     0 w# B) {) I, R, u8 [! Q% @
123. 
     " v/ V$ q. m4 \4 L3 C- P
124.                 // add a listener for the agv. This will call this nodefunction in the ON_AGV_AT_CP section whenever the
     
125.                 // agv arrives at a node. I keep a state on the agv's state label, and then increment it each time
     0 a# z( X! Y6 T  A4 c0 b
126.                 // the listener is called so I know which control point he's at, i.e. entry, elev, or exit.
     
127.                 agvaddlistener(agv, c, AGV_LISTEN_ARRIVAL | AGV_LISTEN_INTERMEDIATE_DEST,
     
128.                         agv, elev, ON_AGV_AT_CP, AGV_LISTENER_PARAM_NODE);
     & m* ^) B. J& s8 O- I) E
129.                
     ' u7 s$ M1 Y- e. L7 R
130.                 // set the data on the state label
     - j- C4 z- R. S
131.                 treenode stateLabel = assertlabel(agv, AGV_LABEL_NAME, DATATYPE_NUMBER);
     
132.                 switch_destroyonreset(stateLabel, 1);
     
133.                 set(stateLabel, AGV_STATE_START);
     , m# L3 Z3 c+ S3 \4 _- s$ K
134.                 set(assertsubnode(stateLabel, "ElevState", DATATYPE_NUMBER), 0);
     
135.                 nodepoint(assertsubnode(stateLabel, "ElevCP", DATATYPE_COUPLING), curFloorElevCP);
     0 R' S" Y$ D& Z9 [5 U5 D" E% R
136.                 nodepoint(assertsubnode(stateLabel, "DestElevCP", DATATYPE_COUPLING), destFloorElevCP);
     * w3 K# k0 V& `2 @; N, E
137.                 nodepoint(assertsubnode(stateLabel, "ExitCP", DATATYPE_COUPLING), destExitCP);
     
138.                 agvredirect(agv, curFloorEntryCP, REDIRECT_AND_WAIT);
     * S( ?9 K9 S' n7 d3 |* Q
139.                 return 0;
     $ ?# }2 N8 h% U
140.         }
     # L) o2 Q$ _% O
141.         case ON_AGV_AT_CP: {
     ! ]7 g5 d: o5 @) v
142.                 // this is fired by the agv listener every time the agv arrives at a node.
     ( F: g3 G& x* {* b- |' h
143.                 treenode agv = param(1);
     
144.                 treenode elev = param(2);
     
145.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
       p4 W- e4 Z9 e. S, a9 m' H9 a* o
146.                 // I increment the state label, and then switch on it
     
147.                 inc(stateLabel, 1);
     
148.                 switch (get(stateLabel)) {
     ( O3 Z7 ~3 B. ~: V1 E
149.                         case AGV_STATE_AT_ENTRY_CP: {
     
150.                                 // the agv just arrived at the entry cp
     5 R3 u! \7 [, o% F
151.                                 // so, figure out where the elevator is.
     7 B% x/ P7 k( V. v1 i
152.                                 int elevState = get(node("ElevState", stateLabel));
     ; N4 l) w2 A( A7 d& ^6 o
153.                                 // if he's at the pickup floor with his door closed then open the door.
     
154.                                 if (elevState == ELEV_STATE_AT_PICKUP_FLOOR)
     , I( Z8 I1 Y! q4 Z) M! B
155.                                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     ! t; U' @( k" z2 E2 u" y
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
     - f1 j# _, i3 X$ S7 E
158.                                         // the elevator cp
     # R0 z% Y! E% M9 K
159.                                         treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     
160.                                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     & m1 p5 q7 i0 \; u) E
161.                                 }
     
162.                                 break;
     
163.                         }
     ) m: K7 w2 T, f" g5 w: b
164.                         case AGV_STATE_AT_ELEV_CP: {
       [: b2 c' I5 t& l+ _2 M6 w
165.                                 // once the agv is at the elevator cp, close the door
     
166.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_PICKUP_DOOR_CLOSED);
     ; C1 U2 r2 L- l; [1 d: G' S
167.                                 break;
     : g0 z0 ?$ W7 e( s' z! v' u
168.                         }
     " n, {4 p& P& ^8 T' q# |' Z( L
169.                         case AGV_STATE_AT_EXIT_CP: {
     
170.                                 // the agv is at the exit cp
     
171.                                 // destroy the listener node because I'm finished listening
     
172.                                 treenode listenerNode = param(4);
     
173.                                 destroyobject(listenerNode);
     
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
     ; u/ _) S" e5 b. J9 V
177.                                         treenode destCP = gettaskinvolved(gettasksequence(elev, 0), 1, 2);
     
178.                                         agvredirect(agv, destCP, REDIRECT_AS_FINAL);
     1 T4 a3 |2 Z8 H% m% r  M' r
179.                                 }
     
180.                                 // close the door
     
181.                                 nodefunction(c, agv, elev, ON_CLOSE_DOOR, ON_DROPOFF_DOOR_CLOSED, agvWait);
     
182.                                 // and I'm finished with the state label so I can destroy it.
     
183.                                 destroyobject(stateLabel);
     3 F$ c! L0 \, l; D* ^$ {
184.                                 break;
     
185.                         }
     % h. k1 U( z1 Z
186.                 }
     
187.                 return 0;
     : Z: o4 R* d6 n# S9 c+ @$ b, x
188.         }
     
189.         case ON_ELEVATOR_PICKUP_ARRIVAL: {
     
190.                 // the elevator has arrived at the pick floor
     2 c2 ?5 o# f/ e; \6 o
191.                 treenode elev = param(1);
     
192.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
193.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     5 z$ S! g* i' s# u0 g
194.                 treenode elevState = node("ElevState", stateLabel);
     
195.                 // set the elevator state to at-pickup-floor
     / M% p4 Z( d0 H5 q
196.                 set(elevState, ELEV_STATE_AT_PICKUP_FLOOR);
     
197.        
     ) N/ @$ I2 Z, ~& X
198.                 int openDoorImmediately = /** \nOpen Elevator Door Immediately: *//***tag:OpenDoorImmediate*//**/0/**/;
     
199.                
     
200.                 // if the agv is at the entry control point or I open the door immediately, then open it
     * V8 d4 `5 g% D/ l6 J$ [; A
201.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP || openDoorImmediately) {
     % ?2 T) j( [+ {& R7 \! b
202.                         set(elevState, ELEV_STATE_OPENING_DOOR);
     " O; A2 C" Z, r3 n% C( ?( j9 O
203.                         nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_PICKUP_DOOR_OPENED);
     # `( \# x, p4 p* r6 Q
204.                 }
     
205.                 return 0;
     + o$ k4 y/ [+ l' U3 C( J" ]4 k
206.         }
     4 b+ k2 w8 J: n- ]; x
207.         case ON_OPEN_DOOR: {
     
208.                 treenode agv = param(1);
     2 v$ E  R0 c  B9 j2 V
209.                 treenode elev = param(2);
     
210.                 int nextStep = param(4);
     / M2 K8 X% C% j2 o) E; e( Y
211.                 // open the door based on the time to open the door
     * Z5 O" q$ N+ c; z
212.                 double openDoorTime = /** \nDoor Open Delay:*//***tag:DoorOpenTime*//**/5/**/;
     
213.                 delayednodefunction(c, openDoorTime, elev, agv, nextStep);
     . i+ f! v) l* m8 C7 Z
214.                 return 0;
     * [$ [% a* \, `" V# j5 R
215.         }
     3 K( i2 P# O3 J$ O
216.         case ON_CLOSE_DOOR: {
     ) H) g$ x) X- Q' Q- r- C
217.                 treenode agv = param(1);
     
218.                 treenode elev = param(2);
     
219.                 int nextStep = param(4);
     & @* o4 }( G5 H
220.                 // close the door base on the time to close the door
     
221.                 double delayTime = /** \nDoor Close Delay:*//***tag:DoorCloseTime*//**/5/**/;
     0 J4 s% a1 a; m/ T. V
222.                 delayednodefunction(c, delayTime, elev, agv, nextStep, param(5));
     
223.                 return 0;
     
224.         }
     $ y  L% ~) ^( K/ H5 M7 R
225.         case ON_PICKUP_DOOR_OPENED: {
     . d& U! [* z; T' X( Q8 I) _; m
226.                 // the elevator door has been opened on the pickup floor
     
227.                 treenode elev = param(1);
     5 r5 U# e# H. \9 a+ y& L4 P
228.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
229.                 treenode entryCP = cp(agv);
     6 r2 X7 g( g4 S# p( q( j
230.                 treenode stateLabel = label(agv, AGV_LABEL_NAME);
     ; u5 q' Y5 n. z, t9 g% c
231.                 treenode elevatorCP = tonode(get(node("ElevCP", stateLabel)));
     , a$ E- a3 d* c7 H7 ]
232.                 treenode elevState = node("ElevState", stateLabel);
     % r, h% X1 w- H6 }
233.                 // set the elevator state
     ( m8 B$ v1 S# L3 A! F5 ^" ]
234.                 set(elevState, ELEV_STATE_DOOR_OPENED);
     5 z% m  c8 R) s% B, K" c3 a
235.                 // if the agv is at the entry control point, move him to the elevator control point
     " Q( Z0 Y9 a8 R: V2 Z, F
236.                 if (get(stateLabel) == AGV_STATE_AT_ENTRY_CP)
     
237.                         agvredirect(agv, elevatorCP, REDIRECT_AND_WAIT);
     
238.                 return 0;
     0 @+ v# l5 d; ?
239.         }
     ! J5 V  K) O. l
240.         case ON_PICKUP_DOOR_CLOSED: {
     - k; D( J2 \5 {& \. Z( l
241.                 treenode elev = param(1);
       m+ G8 k% C& l
242.                 treenode agv = gettaskinvolved(gettasksequence(elev, 0), 1, 1);
     
243.                 // assign the agv to "no control point"
     * v* V! ?5 U! Q/ O
244.                 agvreassigncp(agv, 0);
     & D. l! i& C+ P! {
245.                 // move the agv into the elevator
     
246.                 moveobject(agv, elev);
     . U" R. @/ L+ e7 [1 g
247.                 setrot(agv, 0, 0, 0);
     
248.                 // release the elevator to continue to the destination floor
     ( L( @" H! N$ H4 c3 S; F
249.                 freeoperators(elev, agv);
     
250.                 return 0;
     
251.         }
     3 K4 V9 }* h0 W! ]; [; B9 h
252.         case ON_ELEVATOR_DROPOFF_ARRIVAL: {
     0 \, F) J6 u( @' P6 t. \7 _) T
253.                 treenode elev = param(1);
     7 [( u; Q! P5 ?& h& i  B8 D
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
     6 l/ Z% L# \! f
257.                 moveobject(agv, model());
     
258.                 // reassign it to the destination floor control point
     
259.                 agvreassigncp(agv, tonode(get(node("DestElevCP", label(agv, AGV_LABEL_NAME)))));
     $ Q" a* k6 V3 V! `) T1 N9 q- L) F0 j
260.                 // open the elevator door
     
261.                 nodefunction(c, agv, elev, ON_OPEN_DOOR, ON_DROPOFF_DOOR_OPENED);
     
262.                 return 0;
     : Z7 `9 x% v+ ^2 b% e7 g
263.         }
     
264.         case ON_DROPOFF_DOOR_OPENED: {
     - V' {8 ?" h/ D/ o
265.                 treenode elev = param(1);
     % A: R& b6 c6 @& Z9 O. u, B
266.                 treenode agv = param(2);
     ! S7 Y  K' O4 d$ \
267.                 treenode agvLabel = label(agv, AGV_LABEL_NAME);
     
268.                 // once the elevator door is opened on the destination floor,
     
269.                 // redirect the agv to the exit control point
     9 z& }% W- R  @4 o1 L4 \0 ^
270.                 agvredirect(agv, tonode(get(node("ExitCP", agvLabel))), REDIRECT_AND_WAIT);
     
271.                 return 0;
     
272.         }
     , ~  \1 [; @$ ]2 c
273.         case ON_DROPOFF_DOOR_CLOSED: {
     
274.                 treenode elev = param(1);
       U# ^& w/ h2 l/ }& d
275.                 treenode agv = param(2);
     
276.                 int isAGVWaiting = param(4);
     ) q  M! C1 J: W" V3 C& P  |* _
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)
     % f9 p! H4 a& e/ x# n
280.                         agvredirect(agv, gettaskinvolved(gettasksequence(elev, 0), 1, 2), REDIRECT_AS_FINAL);
     
281.                 // release the elevator to finish his task sequence
     
282.                 freeoperators(elev, agv);
     
283.                 return 0;
     + L& L% w- h4 ^% b
284.         }
     
285. }
     
286. } //******* PickOption End *******\\
     
287. 
     ; a% m& B% c) Z$ o$ X$ C

复制代码

* q$ V  Y4 A5 t: s. V4 D
7 @3 f0 `* m5 p0 T/ M4 A  b办法2：使用工艺流程模块完成

慧娴亚伦 发表于 2018-11-4 19:12
& K1 _* }; J4 j* K办法1：从2016版本里面复制相应的代码
1 I7 u/ i! |0 H7 V
; O) K/ y. @5 V2 R7 s. Z7 y# D具体代码如下：

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