Nico,
I've built a sample model that I think does the operation that you are looking for.
CoordinatedCartSharing.zip
There are two lines next to each other. The first line shows the case with no network travel. This one is pretty simple. The insertproxytask command allows you to pass in the allocation key (instead of a direct object reference) as either involved1 or involved2 of the task. This lets you use certain tasks such as TRAVEL or PICKOFFSET or LOAD to travel to the cart. In this case, I just use a travel. Once the operator finishes traveling to the cart, I have both cart and operator travel to the different locations in conjunction.
The second line adds a travel network to the equation. This complicates the situation because, in the first example, since there was no travel network, the operators just traveled directly to the location of the cart. If you are using a travel network and want the operators to travel to the cart via the network, then you'll have to do some extra logic to update the "blue line" destination network node of the cart each time the cart moves, so that the operators will travel to the right location. Unfortunately there's no task type that will do this for you, so you have to add some delayed execution logic that fires once the cart has been allocated, so you can get access to the cart as a pointer. You could use a sendmessage to do this, but I decided to do a "trick" with the request transport from field. The trick allows me to put all of the code in the same field, the request transport from. I use a nodefunction task, and I pass in c as involved1, and cartkey as involved2. c is actually the node that is being fired, the request transport from node. That task causes the request transport from to fire again once the operator finishes unloading the item, and a pointer to the cart (since I specified cartkey as involved2) will be passed as parnode(1) into the field. The key is to have some way of distinguishing decisively whether the nodefunction is being fired in the default case or because of my task. I test to see if up(p1) == current. If so, then it's a flowitem, and this is the default case, otherwise, p1 is the cart, and it's the specific case. In the specific case I move the cart into the model, then disconnect it from its previous location and reconnect it to the operator's network node.
Here's the code:
Code:
treenode p1 = parnode(1);
treenode current = ownerobject(c);
int port = parval(2);
/**Coordinated Task Sequence Example 2*/
/** \nCreates a coordinated tasksequence manually.*/
/** \nIf this "Request Transport From" field returns a 0 rather than a valid pointer to either a dispatcher or taskexecuter, then no call is made, and it is assumed that the user will dispatch their own tasksequence. This example shows the code that is required to create a coordinated tasksequence that calls for two operators to transport the same flowitem together.*/
if(up(p1) == current) { // if parnode(1) is in me, then this is the normal case
treenode item = p1;
treenode destination = outobject(current,port); //the destination is determined by the previous evaluation of the "Send To Port" field.
treenode operatorteam = centerobject(current,1); //assumes a dispatcher is connected to center port 1 (the dispatcher should be connected to two or more taskexecuters).
treenode cartteam = centerobject(current,2);
treenode ts = createcoordinatedtasksequence(operatorteam); //the coordinated tasksequence can be created on any dispatcher in the model (the operatorteam is used for convenience).
int operatorkey = insertallocatetask(ts, operatorteam, 0, 0); //allocate the first availabe operator connected to the dispatcher and record a numeric key pointing to the chosen operator
int cartkey = insertallocatetask(ts, cartteam, 0, 0); //allocate the first availabe operator connected to the dispatcher and record a numeric key pointing to the chosen operator
insertproxytask(ts, operatorkey, TASKTYPE_TRAVEL, cartkey);
insertproxytask(ts, operatorkey, TASKTYPE_LOAD, cartkey, cartkey);
insertproxytask(ts, operatorkey, TASKTYPE_TRAVEL, current);
insertproxytask(ts, operatorkey, TASKTYPE_FRLOAD, item, current, port,0,0,0); //create an frload task for op1 and record a numeric key pointing to this task in order to sync with it later (only one operator needs to actually "load" the flowitem).
insertproxytask(ts, operatorkey, TASKTYPE_TRAVEL, destination, NULL, 0,0,0,0); //create a travel task for op1 to travel to the destination.
insertproxytask(ts, operatorkey, TASKTYPE_FRUNLOAD, item, destination, opipno(current,port),0,0,0); //create an frunload task for op1 to unload the flowitem to the destination object.
insertproxytask(ts, operatorkey, TASKTYPE_NODEFUNCTION, c, cartkey, 0,0,0,0); //create a
insertdeallocatetask(ts, operatorkey); //de-allocate op1
insertdeallocatetask(ts, cartkey); //de-allocate cart
dispatchcoordinatedtasksequence(ts); //dispatch the coordinated tasksequence
return 0; //return a 0 so this object will know that you made your own tasksequence and it doesn't need to make the standard tasksequence automatically
}
else { // if up(p1) is not current, then it is the cart itself and this nodefunction is being executed specifically due to the task that I added to call a nodefunction here
// Here I need to move the cart back into the model, then reconnect his blue connection line to the current networknode that the operator is on.
// This makes it so that the operator will travel to the right location as part of his travel.
treenode cart = p1;
treenode op = up(cart);
treenode lastnetnode = getnetnode(cart, 1);
if(objectexists(lastnetnode))
contextdragconnection(cart, lastnetnode, 'E');
treenode newnetnode = gettenetnode(op);
if(objectexists(newnetnode))
contextdragconnection(cart, newnetnode, 'D');
moveobject(cart, model());
setloc(cart, xloc(op), yloc(op), zloc(op));
return 0;
}
Queuing coordinated task sequences?
