USARBot.WorldController

/*
    World controller.
    Controller allows to create, destroy and move objects in the world.

    Commands:

    CONTROL {Type Create} {ClassName class} {Name name} {location x,y,z} {rotation x,y,z}
    CONTROL {Type Kill} {Name name}
    CONTROL {Type KillAll}
    CONTROL {Type AbsMove} {Name name} {location x,y,z} {rotation x,y,z}
    CONTROL {Type RelMove} {Name name} {location x,y,z} {rotation x,y,z}

    CONTROL {Type Rotate} {Name name} {Speed x,y,z}

    CONTROL {Type SetWP} {Name name} [{Speed s}|{Time t}] [{Move <true/false>}]
            [{Autoalign <true/false>}] [{Show <true/false>}] [{Loop <true/false>}]
            [{ResetOnClear <true/false>}] [{WP x,y,z;x,y,z;...}]
    CONTROL {Type AddWP} {Name name} {WP x,y,z;x,y,z;...}
    CONTROL {Type ClearWP} {Name name}



    by Marco Zaratti - marco.zaratti@gmail.com
*/
#exec OBJ LOAD FILE=..\Textures\USARSim_Objects_Textures.utx

class WorldController extends Pawn config(USARBot);

var config bool bDebug;
var string wpdelim; //Waypoint list delimiter.
var array<texture> traceTexture;
var config bool cleanOnClose;   // If WC should destroy its objects before exiting.
var int cmdIdx;                 // Used to loop through all WC enqueued commands

// This struct holds all the controlled objects.
struct ControlledObject
{
    var string name;                // Object name. It identifies that instance.
    var Actor actor;                // A reference to the object.
    var vector startLoc;
    var rotator startRot;

    // Animation state is controlles by these 2 bools
    // Rotation and waypoints movement can be activated independently.
    var bool bMoving;
    var bool bRotating;

    var array<vector> aWayPoints;   // Waypoints used to move the object across a path.
    var array<float> aSegLengths;   // aSegLength[i] = distance from point [0] to [i+1]
    var array<Tracing> aTracings;   // Tracing vector.
    var float fSpeed;           // Movement speed.
    var bool bLoop;             // Should waypoints travel be looped.
    var bool bAlign;            // If the object is aligned to the path.
    var bool bShow;             // Show tracings.
    var bool bResetOnClear;     // Resets its start posistion and rotation on clearWaypoints.
    var float fTotalDistance;   // Total path length.
    var float fCurrentDistance;  // Current point in the path.
    var int nCurrentPoint;       // Current waypoint.
    var rotator rRotSpeed;    // A constant angular speed for rotation.
};
var array<ControlledObject> controlledObjects;

var config string ConverterClass;
var USARConverter converter;

////////////////////////////////////////////////////////////////////////////////

simulated event PreBeginPlay()
{
    Super.PreBeginPlay();
    converter = new class<USARConverter>(DynamicLoadObject(ConverterClass, class'Class'));
}

simulated event Destroyed()
{
    local int id, len;

    len = controlledObjects.Length;
    for(id=0; id < len; id++)
    {
        ShowTracesOf(id, false);
        ClearWaypointsOf(id);
        if(cleanOnClose)
            controlledObjects[id].actor.Destroy();
    }
    Super.Destroyed();
}


/*
simulated function PostNetBeginPlay()
{
    Super.PostNetBeginPlay();
}
*/

// Returns the index of the object 'name', -1 if not found.
simulated function int GetObject(string name)
{
    local int i;

    for(i=0; i < controlledObjects.length; i++)
        if(controlledObjects[i].name == name)
            return i;

    return -1;
}

// Returns the reference of the robot 'name', none if not found in the map.
simulated function KRobot GetRobot(string name)
{
    local int i;

    for(i=0; i < USARDeathMatch(Level.Game).Vehicles.length; i++)
        if(USARDeathMatch(Level.Game).Vehicles[i].Controller.PlayerReplicationInfo.PlayerName == name)
            return KRobot(USARDeathMatch(Level.Game).Vehicles[i]);

    return none;
}

simulated function bool IsVectNull(vector v)
{
    if(v.X ~= 0 && v.Y ~= 0 && v.Z ~= 0)
        return true;

    return false;
}

simulated function bool IsRotNull(rotator r)
{
    if(r.Roll ~= 0 && r.Pitch ~= 0 && r.Yaw ~= 0)
        return true;

    return false;
}

simulated function ParseVectorToUU(out vector v, string vec)
{
    local int i;
    local string delim;

    delim = " ";

    if(vec != "")
    {
        if(InStr(vec,delim) == -1)
            delim = ",";
        i = InStr(vec,delim);
        v.X = float(left(vec,i));
        vec = mid(vec,i+1);
        i = InStr(vec,delim);
        v.Y = float(left(vec,i));
        v.Z = float(mid(vec,i+1));
    }
    else
    {
        v = vect(0,0,0);
        return;
    }

    v = converter.LengthVectorToUU(v);
}

simulated function string TrimLeft(coerce string S)
{
    local int size;

    size = Len(S);

    while (Left(S, 1) == " ")
        S = Right(S, --size);
    return S;
}

simulated function string TrimRight(coerce string S)
{
    local int size;

    size = Len(S);

    while (Right(S, 1) == " ")
        S = Left(S, --size);
    return S;
}

simulated function string Trim(coerce string S)
{

    local int size;

    size = Len(S);

    while (Left(S, 1) == " ")
        S = Right(S, --size);
    while (Right(S, 1) == " ")
        S = Left(S, --size);

    return S;
}

// Adds the USARRemoteBot(Controller).WC[cmdIdx].wpList to the 'id' object.
// Returns the number of waypoints added.
simulated function int AddWPListTo(int id)
{
    local int i;
    local int wplen;
    local int points;
    local array<string> tokens;
    local vector wp;

    //WP list is in the form x,y,z;x,y,z;... (also x,y,z ; x,y,z ...)
    points = Split(USARRemoteBot(Controller).WC[cmdIdx].wpList, wpdelim, tokens);

    wplen = controlledObjects[id].aWayPoints.Length;
    controlledObjects[id].aWayPoints.Insert(wplen, points);
    controlledObjects[id].aSegLengths.Insert(wplen, points);

    for(i=0; i < points; i++)
    {
        ParseVectorToUU(wp, Trim(tokens[i]));
        controlledObjects[id].aWayPoints[wplen++] = wp;
    }
    return points;
}

// Shows or hides (deleting) the waypoint trace for the 'id' object.
// This func will always destroy all previous traces, if any. This
// assures that, even if you change waypoints, the traces will be
// correctly drawn.
simulated function ShowTracesOf(int id, bool show)
{
    local int i, len, traceColor;
    local Tracing T;

    // delete all traces
    len = controlledObjects[id].aTracings.Length;
    for(i=0; i < len; i++)
        controlledObjects[id].aTracings[i].Destroy();
    controlledObjects[id].aTracings.Remove(0,len);

    if(show)
    {
        len = controlledObjects[id].aWayPoints.Length;
        if(len > 0)
        {
            controlledObjects[id].aTracings.Insert(0,len);
            traceColor = id % traceTexture.Length;
            for(i=0; i <len; i++)
            {
                T = spawn(class'USARBot.Tracing',,,controlledObjects[id].aWayPoints[i]);
                T.Texture = traceTexture[traceColor];
                controlledObjects[id].aTracings[i] = T;
            }
        }
    }
}

// Clears all waypoints data of object 'id'.
// That means that all arrays are cleared
// (aWayPoints, aSegLengths, ATracings) and
// the objects is moved to its starting position.
simulated function ClearWaypointsOf(int id)
{
    local int numNodes;
    local rotator rRot;
    local vector vLoc;

    numNodes = controlledObjects[id].aWayPoints.Length;
    if(numNodes > 0)
    {
        // Deletes aWayPoints array
        controlledObjects[id].aWayPoints.Remove(0, numNodes);
        // Deletes aSegLength array
        controlledObjects[id].aSegLengths.Remove(0,numNodes);

        controlledObjects[id].fCurrentDistance = 0.0;
        controlledObjects[id].nCurrentPoint = 0;
        controlledObjects[id].fTotalDistance = 0.0;
        controlledObjects[id].bMoving = false;

        // Resets the starting position if requested
        if(controlledObjects[id].bResetOnClear)
        {
            // Resets location
            vLoc = controlledObjects[id].startLoc - controlledObjects[id].actor.Location;
            controlledObjects[id].actor.Move(vLoc);
            // Resets rotation
            rRot = controlledObjects[id].startRot;
            controlledObjects[id].actor.SetRotation(rRot);
        }
    }
}

// Calculates the toal distance of the waypints path of the 'id' object.
// closedLoop specify if the path must be considered closed
// or open. Closed path is always longer than open.
// It also calculates the length of each segment and store it in aSegLengths.
// aSegLength[i] = distance from point [0] to [i+1].
simulated function float CalculateWPDistanceOf(int id, bool closedLoop)
{
    local int i;
    local int numPoints;
    local vector segment;
    local float segLen, dist;

    numPoints = controlledObjects[id].aWayPoints.Length -1;

    if(numPoints >= 0)
    {
        // First find the open path length (points = num of wp -1)
        while(i < numPoints)
        {
            segment = controlledObjects[id].aWayPoints[i + 1] - controlledObjects[id].aWayPoints[i];
            dist += VSize(segment);
            controlledObjects[id].aSegLengths[i] = dist;
            i++;
        }

        segment = controlledObjects[id].aWayPoints[0] - controlledObjects[id].aWayPoints[i];
        segLen = dist + VSize(segment);
        // We always fill completely the segment length array (as if it were looped).
        controlledObjects[id].aSegLengths[i] = segLen;

        if(closedLoop)
            dist = segLen;
    }
    else
        dist = 0;

    return dist;
}

//Returns the vector [node] ->[node +1] of the object 'id'.
simulated function vector GetSegmentVect(int id, int node)
{
    local int maxNode;

    maxNode = controlledObjects[id].aWayPoints.Length -1;
    if(node < maxNode)
        // The object is moving from: [node] -> [node +1]
        return (controlledObjects[id].aWayPoints[node +1] - controlledObjects[id].aWayPoints[node]);
    else// We're closing the loop: [lastNode] -> [0].
        return (controlledObjects[id].aWayPoints[0] - controlledObjects[id].aWayPoints[node]);
}
//Returns:
// segSize: the size of the vector [node] ->[node +1].
// segPos: the position inthe curent segment.
simulated function GetSegmentPos(int id, int node, out float segSize, out float segPos)
{
    // aSegLengths[node] is the distance that the object will cover at the end of the current segment.
    // So, the current segment size can be obtained this way:
    // aSegLengths[node] - aSegLengths[node -1].
    if(node == 0)
    {
        segSize = controlledObjects[id].aSegLengths[0];
        segPos = controlledObjects[id].fCurrentDistance;
    }
    else
    {
        segSize = controlledObjects[id].aSegLengths[node] - controlledObjects[id].aSegLengths[node -1];
        segPos = controlledObjects[id].fCurrentDistance - controlledObjects[id].aSegLengths[node -1];
    }
}

// This function sets the object 'id' at a specified position in the path.
simulated function SetTheObjectTo(int id, float dist)
{
    local int node;
    local vector segVect, newPos;
    local float segSize;    // Current segment size
    local float segPos;     // Relative position in the current segment

    if(dist < 0)
        dist = 0;
    else if (dist > controlledObjects[id].fTotalDistance)
        dist = controlledObjects[id].fTotalDistance;

    controlledObjects[id].fCurrentDistance = dist;
    node = controlledObjects[id].nCurrentPoint;

    // Finds the node where we are (last node we passed).
    // 'node' cannot become bigger than the size of waypoints array
    // because we have limited dist at the beginning of this function.
    while(dist >= controlledObjects[id].aSegLengths[node])
        node++;

    // Updates the current node
    controlledObjects[id].nCurrentPoint = node;

    GetSegmentPos(id, node, segSize, segPos);
    segVect = GetSegmentVect(id, node);

    if(controlledObjects[id].bAlign)
        controlledObjects[id].actor.SetRotation(rotator(segVect));

    // Performs linear interpolation.
    newPos = controlledObjects[id].aWayPoints[node] + segVect*(segPos/segSize);

    // Now calculate the new object position. We must use Move(), that is a
    // relative movement function. We're also reusing segVect var.
    segVect = newPos - controlledObjects[id].actor.Location;
    controlledObjects[id].actor.Move(segVect);
}

/** Here we process the CONTROL commands.
 *  It's done only on server as commands are received only on server. */
function ProcessControls()
{
    local class<Actor> objectClass;
    local ControlledObject objData;
    local WCObject wco;
    local int id;
    local bool showBit, loopBit, alignBit;
    local int i, len;      // General purpose variables
    local float avSpeed;
    local vector vLoc;  // General purpose variable
    local rotator rRot; // General purpose variable
    local KRobot robot;

    for(cmdIdx=0; cmdIdx < USARRemoteBot(Controller).WC.Length; cmdIdx++)
    {
    //All commands require a named object, so we take its reference here.
        id = GetObject(USARRemoteBot(Controller).WC[cmdIdx].objName);

        switch(USARRemoteBot(Controller).WC[cmdIdx].cmd)
    {
    ////////////////////////////////////////////////////////////////////////////
    // CONTROL {Type Create} {ClassName class} {Name name} {location x,y,z} {rotation x,y,z}
    case 1:
        // Check if already exists an object with that name
        if(id != -1) break;

            if(USARRemoteBot(Controller).WC[cmdIdx].isObjLoc)
                vLoc = USARRemoteBot(Controller).WC[cmdIdx].objLoc;
            if(USARRemoteBot(Controller).WC[cmdIdx].isObjRot)
                rRot = USARRemoteBot(Controller).WC[cmdIdx].objRot;

            objectClass = class<Actor>(DynamicLoadObject(USARRemoteBot(Controller).WC[cmdIdx].objClassName, class'Class'));
            objData.name = USARRemoteBot(Controller).WC[cmdIdx].objName;
        objData.actor = Spawn(objectClass,,,vLoc,rRot);
        objData.startLoc = vLoc;
        objData.startRot = rRot;
        objData.bResetOnClear = true;

        if(objData.actor != none)
        {
            id = controlledObjects.length;
            controlledObjects.Insert(id,1);
            controlledObjects[id]=objData;
        }
        break;

    ////////////////////////////////////////////////////////////////////////////
    // CONTROL {Type Kill} {Name name}
    case 2:
        if(id == -1) break;
        ShowTracesOf(id, false);
        ClearWaypointsOf(id);
        controlledObjects[id].actor.Destroy();
        controlledObjects.Remove(id,1);
        break;

    ////////////////////////////////////////////////////////////////////////////
    // CONTROL {Type RelMove} {Name name} {location x,y,z} {rotation x,y,z}
    case 3:
        if(id != -1)
        {
                if(USARRemoteBot(Controller).WC[cmdIdx].isObjLoc)
                   controlledObjects[id].actor.Move(USARRemoteBot(Controller).WC[cmdIdx].objLoc);
                if(USARRemoteBot(Controller).WC[cmdIdx].isObjRot)
            {
                rRot = controlledObjects[id].actor.Rotation;
                    rRot += USARRemoteBot(Controller).WC[cmdIdx].objRot;
                controlledObjects[id].actor.SetRotation(rRot);
            }
        }
        else
        {
                robot = GetRobot(USARRemoteBot(Controller).WC[cmdIdx].objName);
            if(robot != none)
            {
                    vLoc = robot.Location + USARRemoteBot(Controller).WC[cmdIdx].objLoc;
                robot.MoveRobot(vLoc);
            }
        }
        break;

    ////////////////////////////////////////////////////////////////////////////
    // CONTROL {Type AbsMove} {Name name} {location x,y,z} {rotation x,y,z}
    case 4:
        if(id != -1)
        {
                if(USARRemoteBot(Controller).WC[cmdIdx].isObjLoc)
            {
                vLoc = controlledObjects[id].actor.Location;
                    vLoc = USARRemoteBot(Controller).WC[cmdIdx].objLoc - vLoc;
                controlledObjects[id].actor.Move(vLoc);
            }
                if(USARRemoteBot(Controller).WC[cmdIdx].isObjRot)
                    controlledObjects[id].actor.SetRotation(USARRemoteBot(Controller).WC[cmdIdx].objRot);
        }
        else
        {
                robot = GetRobot(USARRemoteBot(Controller).WC[cmdIdx].objName);
            if(robot != none)
                    robot.MoveRobot(USARRemoteBot(Controller).WC[cmdIdx].objLoc);
        }
        break;

    ////////////////////////////////////////////////////////////////////////////
    // CONTROL {Type SetWP} {Name name} [{Speed s}|{Time t}] [{Move <true/false>}] [{Loop <true/false>}]
    //         [{Autoalign <true/false>}] [{Show <true/false>}] [{ResetOnClean <true/false>}]
    //         [{WP x,y,z;x,y,z;...}]
    case 5:
        if(id == -1) break;

            if((USARRemoteBot(Controller).WC[cmdIdx].wpFlags & 2) > 0)
        {
                loopBit = controlledObjects[id].bLoop ^^ USARRemoteBot(Controller).WC[cmdIdx].wpLoop;
                controlledObjects[id].bLoop = USARRemoteBot(Controller).WC[cmdIdx].wpLoop;
        }

            if(USARRemoteBot(Controller).WC[cmdIdx].wpList != "")
        {
            ClearWaypointsOf(id);
            AddWPListTo(id);

            // Always recalculate distance because we have changed waypoints
            controlledObjects[id].fTotalDistance = CalculateWPDistanceOf(id, controlledObjects[id].bLoop);

            // Sets the robot to the first point.
            SetTheObjectTo(id, 0);

            // We process Show command here because what should be done
            // depends on whether waypoints was chenged or not.
                if((USARRemoteBot(Controller).WC[cmdIdx].wpFlags & 8) > 0)
            {
                // Show command was issued.
                    showBit = controlledObjects[id].bShow || USARRemoteBot(Controller).WC[cmdIdx].wpShow;
                if(showBit)
                {
                        controlledObjects[id].bShow = USARRemoteBot(Controller).WC[cmdIdx].wpShow;
                    ShowTracesOf(id, controlledObjects[id].bShow);
                    if(bDebug) log("# SetWP - Tracing new WPs by cmd...");
                }
            }
            else
            {
                // Show command was not issued, so we redraw the new traces or not
                // depending on the state of the bShow flag.
                if(controlledObjects[id].bShow)
                {
                    ShowTracesOf(id, true);
                    if(bDebug) log("# SetWP - Tracing new WPs by state...");
                }
            }
        }
        else //No new waypoints.
        {
            // Recalculate distance if loop flag has changed.
            // Note: we already have distances for open and closed loop. They are
            // stored in the aSegLengths array. So we must only update fTotalDistance
            // with the correct value.
            if(loopBit)
            {
                len = controlledObjects[id].aSegLengths.Length;
                if(len > 1)
                {
                    if(controlledObjects[id].bLoop)
                        controlledObjects[id].fTotalDistance = controlledObjects[id].aSegLengths[len-1];
                    else
                        controlledObjects[id].fTotalDistance = controlledObjects[id].aSegLengths[len-2];
                }
                else
                    controlledObjects[id].fTotalDistance = 0.0;
            }

            // Manages SHOW status when WP have not changed.
                if((USARRemoteBot(Controller).WC[cmdIdx].wpFlags & 8) > 0)
            {
                // As the WP have not changed, we only care about a change in show status.
                    showBit = controlledObjects[id].bShow ^^ USARRemoteBot(Controller).WC[cmdIdx].wpShow;
                if(showBit)
                {
                        controlledObjects[id].bShow = USARRemoteBot(Controller).WC[cmdIdx].wpShow;
                    ShowTracesOf(id, controlledObjects[id].bShow);
                    if(bDebug) log("# SetWP - Tracing old WPs...");
                }
            }
        }

            if((USARRemoteBot(Controller).WC[cmdIdx].wpFlags & 1) > 0)
                controlledObjects[id].bMoving = USARRemoteBot(Controller).WC[cmdIdx].wpMove;

            if((USARRemoteBot(Controller).WC[cmdIdx].wpFlags & 16) > 0)
                controlledObjects[id].bResetOnClear = USARRemoteBot(Controller).WC[cmdIdx].wpResetOnClean;

            if((USARRemoteBot(Controller).WC[cmdIdx].wpFlags & 4) > 0)
        {
                alignBit = controlledObjects[id].bAlign ^^ USARRemoteBot(Controller).WC[cmdIdx].wpAlign;
            if(alignBit)
            {
                    controlledObjects[id].bAlign = USARRemoteBot(Controller).WC[cmdIdx].wpAlign;
                if(controlledObjects[id].bAlign)
                {
                    //We need at least 2 waypoints to define an alignement
                    if(controlledObjects[id].aWayPoints.Length > 1)
                    {
                        vLoc = GetSegmentVect(id, controlledObjects[id].nCurrentPoint);
                        controlledObjects[id].actor.SetRotation(rotator(vLoc));
                    }
                }
                else
                {
                    // If not aligned resets the starting rotation.
                    rRot = controlledObjects[id].startRot;
                    controlledObjects[id].actor.SetRotation(rRot);
                }
            }
        }

        // Now processes time & speed.
        // You can use speed to specify travel speed, or time to specify total
        // travel time. If you use both, then speed is assumed as maximum
        // speed. If fTotalDistance / time > speed then speed will be used.

            if(USARRemoteBot(Controller).WC[cmdIdx].wpSpeed > 0)
        {
                controlledObjects[id].fSpeed = USARRemoteBot(Controller).WC[cmdIdx].wpSpeed;

                if(USARRemoteBot(Controller).WC[cmdIdx].wpTime > 0)
            {
                    avSpeed = controlledObjects[id].fTotalDistance / USARRemoteBot(Controller).WC[cmdIdx].wpTime;
                if(avSpeed < controlledObjects[id].fSpeed)
                    controlledObjects[id].fSpeed = avSpeed;
            }
        }
        else
        {
                if(USARRemoteBot(Controller).WC[cmdIdx].wpTime > 0)
                    controlledObjects[id].fSpeed = controlledObjects[id].fTotalDistance / USARRemoteBot(Controller).WC[cmdIdx].wpTime;
        }

        // Set moving state to false if speed is 0 or there are no waypoints.
        if((controlledObjects[id].fSpeed == 0) || (controlledObjects[id].aWayPoints.Length == 0))
            controlledObjects[id].bMoving = false;

        if(bDebug)
        {
            log("# Moving: "$controlledObjects[id].bMoving);
            log("# Loop: "$controlledObjects[id].bLoop);
            log("# Align: "$controlledObjects[id].bAlign);
            log("# Show: "$controlledObjects[id].bShow);
            log("# Distance: "$controlledObjects[id].fTotalDistance);
            log("# Speed: "$controlledObjects[id].fSpeed);
            log("# ResetOnClear: "$controlledObjects[id].bResetOnClear);
            len = controlledObjects[id].aWayPoints.Length;
            for(i=0; i < len; i++)
                log("# WP["$i$"] - Len : "$controlledObjects[id].aWayPoints[i].X$","$
                                     controlledObjects[id].aWayPoints[i].Y$","$
                                     controlledObjects[id].aWayPoints[i].Z$" - "$
                                     controlledObjects[id].aSegLengths[i]);
        }
        break;

    ////////////////////////////////////////////////////////////////////////////
    // CONTROL {Type AddWP} {Name name} {WP x,y,z;x,y,z;...}
    case 6:
        if(id == -1) break;

            if(USARRemoteBot(Controller).WC[cmdIdx].wpList != "")
        {
            i = controlledObjects[id].aWayPoints.Length;

            // Adds the new WP list.
            AddWPListTo(id);

            // Recalculate distance
            controlledObjects[id].fTotalDistance = CalculateWPDistanceOf(id, controlledObjects[id].bLoop);

            // Positions the robot to the first point if there were no waypoints
            // before the current add.
            if(i == 0)
                SetTheObjectTo(id, 0);

            // Manages SHOW status because WP have changed.
                if((USARRemoteBot(Controller).WC[cmdIdx].wpFlags & 8) > 0)
            {
                    showBit = controlledObjects[id].bShow || USARRemoteBot(Controller).WC[cmdIdx].wpShow;
                if(showBit)
                {
                        controlledObjects[id].bShow = USARRemoteBot(Controller).WC[cmdIdx].wpShow;
                    ShowTracesOf(id, controlledObjects[id].bShow);
                    if(bDebug) log("# AddWP - Tracing new WPs by cmd...");
                }
            }
            else
            {
                // Draw the new traces, if show is on.
                if(controlledObjects[id].bShow)
                {
                    ShowTracesOf(id, true);
                    if(bDebug) log("# AddWP - Tracing new WPs by state...");
                }
            }

            if(bDebug)
            {
                log("# Moving: "$controlledObjects[id].bMoving);
                log("# Loop: "$controlledObjects[id].bLoop);
                log("# Align: "$controlledObjects[id].bAlign);
                log("# Show: "$controlledObjects[id].bShow);
                log("# Distance: "$controlledObjects[id].fTotalDistance);
                log("# Speed: "$controlledObjects[id].fSpeed);
                log("# ResetOnClear: "$controlledObjects[id].bResetOnClear);
                len = controlledObjects[id].aWayPoints.Length;
                for(i=0; i < len; i++)
                    log("# WP["$i$"] - Len : "$controlledObjects[id].aWayPoints[i].X$","$
                                         controlledObjects[id].aWayPoints[i].Y$","$
                                         controlledObjects[id].aWayPoints[i].Z$" - "$
                                         controlledObjects[id].aSegLengths[i]);
            }
        }
        break;

    ////////////////////////////////////////////////////////////////////////////
    // CONTROL {Type ClearWP} {Name name}
    case 7:
        if(id == -1) break;
        ShowTracesOf(id, false);
        ClearWaypointsOf(id);
        break;

    ////////////////////////////////////////////////////////////////////////////
    // CONTROL {Type Rotate} {Name name} {Speed x,y,z}
    case 8:
        if(id == -1) break;

            controlledObjects[id].rRotSpeed = USARRemoteBot(Controller).WC[cmdIdx].rotSpeed;
        // Turn off rotation if rotation speed is zero.
        if(IsRotNull(controlledObjects[id].rRotSpeed))
            controlledObjects[id].bRotating = false;
        else
            controlledObjects[id].bRotating = true;

        break;

    ////////////////////////////////////////////////////////////////////////////
    // CONTROL {Type KillAll}
    case 9:
        // First destroy all the objects controlled by this WorldController (if any).
        len = controlledObjects.Length;
        if(len > 0)
        {
            for(id=0; id < len; id++)
            {
                ShowTracesOf(id, false);
                ClearWaypointsOf(id);
                controlledObjects[id].actor.Destroy();
            }
            controlledObjects.Remove(0,len);
        }
        // Then cycle through all the other WC objects in the map, if any. You can
        // find these objects when a previous WorldController created them and
        // then quitted without removing them. You can for example create a WC, then
        // use it to populate the map and quit the WC leaving all the objects in the map.
        // When you want to remove these objects you create another WC and issue a KillAll.
        foreach AllActors(class'WCObject',wco)
            wco.Destroy();

        break;
       }//ends switch
    }//ends for loop

    //Empty command queue
    USARRemoteBot(Controller).WC.Remove(0,cmdIdx);
}

simulated function Tick(float Delta)
{
    local int i;
    local rotator rRot;

    if(Role == ROLE_Authority)
        ProcessControls();

    // Animate all the objects
    for(i=0; i < controlledObjects.length; i++)
    {
        // Waypoint animation
        if(controlledObjects[i].bMoving)
        {
            // Moves the objec along the path.
            controlledObjects[i].fCurrentDistance += controlledObjects[i].fSpeed*Delta;

            //See if we have reached the end of the path.
            if(controlledObjects[i].fCurrentDistance >= controlledObjects[i].fTotalDistance)
            {
                if(controlledObjects[i].bLoop)
                    controlledObjects[i].fCurrentDistance -= controlledObjects[i].fTotalDistance;
                else
                {
                    controlledObjects[i].fCurrentDistance = 0;
                    controlledObjects[i].bMoving = false;
                }
                controlledObjects[i].nCurrentPoint = 0;
            }

            if(controlledObjects[i].bMoving)
                SetTheObjectTo(i, controlledObjects[i].fCurrentDistance);
        }
        // Rotation animation
        if(controlledObjects[i].bRotating)
        {
            rRot = controlledObjects[i].actor.Rotation;
            rRot += controlledObjects[i].rRotSpeed * Delta;
            controlledObjects[i].actor.SetRotation(rRot);
        }
    }
}

defaultproperties
{
    bDebug=true         // Activates debug logs.
    cleanOnClose=true   // Tells if the objects must be removed when the controller is destroyed.
    wpdelim=";"         // Delimiter for waypoints coordinates.
    traceTexture(0)=Texture'USARSim_Objects_Textures.Trace.Red'
    traceTexture(1)=Texture'USARSim_Objects_Textures.Trace.Yellow'
    traceTexture(2)=Texture'USARSim_Objects_Textures.Trace.Green'
    traceTexture(3)=Texture'USARSim_Objects_Textures.Trace.Cyan'
    traceTexture(4)=Texture'USARSim_Objects_Textures.Trace.White'
    traceTexture(5)=Texture'USARSim_Objects_Textures.Trace.Blue'
    traceTexture(6)=Texture'USARSim_Objects_Textures.Trace.Purple'
    DrawScale=1
    bNoDelete=false
    bStatic=false
    bStasis=false
    bBlockActors=false
    bCollideActors=false
    bAlwaysRelevant=true
    ConverterClass="USARBot.USARConverter"
    DrawType=DT_StaticMesh
    StaticMesh=StaticMesh'USARSim_Objects_Meshes.WorldController.WC'
}