vector target;
while(llVecDist(llGetPos(), target) > 0.01) llSetPos(target);

warpPos( vector destpos ) 
{   //R&D by Keknehv Psaltery, 05/25/2006
    //with a little pokeing by Strife, and a bit more
    //some more munging by Talarus Luan
    //Final cleanup by Keknehv Psaltery
    // Compute the number of jumps necessary
    integer jumps = (integer)(llVecDist(destpos, llGetPos()) / 10.0) + 1;
    // Try and avoid stack/heap collisions
    if (jumps > 100 )
        jumps = 100;    //  1km should be plenty
    list rules = [ PRIM_POSITION, destpos ];  //The start for the rules list
    integer count = 1;
    while ( ( count = count << 1 ) < jumps)
        rules = (rules=[]) + rules + rules;   //should tighten memory use.
    llSetPrimitiveParams( rules + llList2List( rules, (count - jumps) << 1, count) );
}

//Written by Anorca Calamari on the TG
//This robot moves non-physically. 
//It only turns phantom so that you can walk through it. It does not need to be phantom to go through walls.
//It randomly chooses targets within 50 meters excluding the owner. 
//If noone is within 50 meters or only the owner is within 50 meters it increases the range. It continues
//increasing till it finds a target and moves there,at which point it resets to 50.

integer range=50;

default
{
    touch_start(integer total_number)
    {
        if(llDetectedKey(0) == llGetOwner())
        {
            llSetStatus(STATUS_PHANTOM,TRUE);
            llOwnerSay("ROBOT ON");
            state on;
        }
    }
    
}

state on
{
    state_entry()
    {
        llSensorRepeat("","",AGENT,range,PI,2.5);
    }
    
    sensor(integer num_detected)
    {
        integer target = (integer)llFrand((float)num_detected);
        
        if(llDetectedKey(target) == llGetOwner())
        {
            integer target = (integer)llFrand((float)num_detected);
        }
        
        if(num_detected == 0 | num_detected == 1 && llDetectedKey(0) == llGetOwner())
        {
            integer range=range+10;
        }
        
       
        while(llGetPos() != llDetectedPos(target) + <0,0,2> && llDetectedKey(target) != llGetOwner())
        {
            llSetPos(llDetectedPos(target) + <0,0,2>);
        }
        
        if(llGetPos() == llDetectedPos(target) + <0,0,2>)
        {
            range=50;
        }
        
        
    }
    
    touch_start(integer total_number)
    {
        if(llDetectedKey(0) == llGetOwner())
        {
            llOwnerSay("ROBOT OFF");
            llResetScript();
        }
    }
}

// This is an example, from StormSaber, of a robot which moves non-physically. It uses a llSetPos to fake smooth movement.

float DELAY = 0.0; 
// The script sleeps this amount of time before moving to the next spot in between its current position and its target.
// In practice, theres no need to set this to anything other than 0 as LSL forces the script to sleep 0.2 seconds anyway.

float INCREMENT = 0.1; 
// This defines the amount by which the robot should move, in each iteration of the script. Higher is faster.

float TOLERANCE = 0.1; 
// When the robot is a certain distance from its target, it will give up and find another one. 
// (A metaphor would be that you tend not to measure the distance to your house in centremetres -- after a certain distance, it becomes moot.)
// You can play about for interesting results by finding the relationship between TOLERANCE and INCREMENT. 
// In practice, TOLERANCE probably shouldn't be less than INCREMENT.

vector target;
// Contains the current target we are moving towards

integer moving = FALSE;
// Are we moving? When the robot spawns, it should await commands from a user so the answer is 'no'.

// This function does the main work:
object_move_to(vector targetPos) {
  if (moving) { // Check if we're actually supposed to be moving...

      // We need to find out if we're close enough to the target that we should actually move closer to it.
      if (llVecDist(llGetPos(), targetPos) > TOLERANCE) {

            //If we still need to get closer, start by getting our current position.
            vector position = llGetPos();
            
            // We find where we need to go next by setting our axes one dimension at a time.
            // First we find out if our x position is larger than the targets x position.
            if (targetPos.x > position.x) {
                position.x = position.x + INCREMENT; // If it is, increment (make larger) our x position.
            } else if (targetPos.x < position.x) {
                    position.x = position.x - INCREMENT; // Otherwise, our x position is smaller than the targets. Decrement our x position.
            }
            
           // Now do the same for y.
            if (targetPos.y > position.y) {
                position.y = position.y + INCREMENT;
            } else if (targetPos.y < position.y) {
                    position.y = position.y - INCREMENT;
            }
            
            // Finally for z.
            if (targetPos.z > position.z) {
                position.z = position.z + INCREMENT;
            } else if (targetPos.z < position.z) {
                    position.z = position.z - INCREMENT;
            }
            
            // Teleport to our new position, which we've calculated to be only slightly closer to the target
            // In this context, slightly closer means closer by INCREMENT in all three axes.
            llSetPos(position);
            
            // Sleep for the recommended amount of time, to prevent ourselves going too fast.
            llSleep(DELAY);
            
            // Recursively call this function. We'll look, ending when we're close enough.
            object_move_to(targetPos);    
        } else {
            //Oop,  we've arrived. Time to choose another target...
            llWhisper(0, "... eep..");
            chooseTarget();
      }
    }
}

// FROM RandomVector on the lslwiki.net ScriptLibrary page
// Chooses a random number between min and max.
float randBetween(float min, float max) {
    return llFrand(max - min) + min;
}

// FROM RandomVector on the lslwiki.net ScriptLibrary page
vector randVector() {                         //HERE we use the randBetween we have up on top to 
                           //make a random number from 100 to 500 - on the Z axis. Fun for a trampoline :) 
    return <randBetween(10, 20),randBetween(10, 20),randBetween(20, 30)>;    
}

// Chooses a random position, informs everyone we're moving to it, then moves to it.
chooseTarget() {
    target = randVector();
    llShout(0, "Moving to " + (string) target);
    object_move_to(target);
}

// The script starts here. It informs the user the robot is online, then enters the 'not_moving' state.
default {
    state_entry() {
        llOwnerSay("Robot Online");
         state not_moving;
    }
}

// In the moving state, we choose a target then move to it.
state moving {
    state_entry() {
        moving = TRUE;
        chooseTarget();
    }

   // When touched in the moving state, make a chirp and then enter the 'not moving' state.
    touch_start(integer _i) {
        llOwnerSay("Eep!");
        state not_moving;
    }
}

// In the not moving state, we wait to be touched by a user.
state not_moving {
    state_entry() {
        moving = FALSE;
    }

    // When touched, we should chirp, then enter the moving state.
    touch_start(integer _i) {
        llOwnerSay("Eeeep!");
         state moving;
     }
}

integer current_food_level = 0;
integer maximum_food_level = 2;
key current_target;
float max_food_range = 4;
float min_food_range = 2;
vector kick_up = <0,0,1.5>;
float forward_kick = 3;

default
{
    state_entry()
    {
        llOwnerSay("Script reset:moving to searching state");
        llSetStatus(STATUS_PHYSICS,TRUE);
        llSetStatus(STATUS_ROTATE_X, FALSE);
        llSetStatus(STATUS_ROTATE_Y, FALSE);
        state searching;
    }
}

state searching
{
    state_entry()
    {
        llSensorRepeat("","",AGENT,50, 2 * PI, 3);
    }
    sensor(integer total)
    {
       if(total == 0)
       {    
            current_target = llDetectedKey(0);
        }
        else
        {
            current_target = llDetectedKey(1);
        }
        state moving;
    }
    state_exit()
    {
        llSensorRemove();
    }
}
state moving
{
    //This state moves the robot towards or away from the selected Agent.
    state_entry()
    {
        llSensorRepeat("",current_target,AGENT,50, 2 * PI, 3);
        llSetTimerEvent(30);
    }
    no_sensor()
    {
        state searching;
    }
    state_exit()
    {
        llSensorRemove();
        llSetStatus(STATUS_PHANTOM,FALSE);
    }
    timer()
    {
        //If the target hant been reached after 30 seconds, the robot may be stuck behind something
        //So go phantom to get throught it.
        llSetStatus(STATUS_PHANTOM,TRUE);
    }
    sensor(integer total)
    {
      if(llVecDist(llGetPos(),llDetectedPos(0)) > max_food_range)
        {
           // llWhisper(0,"too far");
            llApplyImpulse((kick_up + <0,0,llFrand(1)>) * llGetMass(), FALSE);
            llApplyImpulse(-llVecNorm(llGetPos() - llDetectedPos(0)) * forward_kick * llGetMass(), FALSE);
        }
        else if(llVecDist(llGetPos(),llDetectedPos(0)) < min_food_range)
        {
            //move away from food
            llApplyImpulse((kick_up + <0,0,llFrand(1)>)  * llGetMass() , FALSE);
            llApplyImpulse(0.5 * llVecNorm(llGetPos() - llDetectedPos(0)) * forward_kick * llGetMass(), FALSE);
        }
        else 
        {
            //Just right, start feeding
            state feeding;
        }
    }
}
state feeding
{
    state_entry()
    {
        llSensorRepeat("",current_target,AGENT,20, 2 * PI, 3);
    }
    no_sensor()
    {
      //  llWhisper(0,"target lost, searching");
        state searching;
    }
    state_exit()
    {
        llSensorRemove();
    }
    sensor(integer total)
    {
  //  llWhisper(0,"pong");
      if(llVecDist(llGetPos(),llDetectedPos(0)) > max_food_range)
        {
      //      llWhisper(0,"too far");
            state moving;
        }
        else if(llVecDist(llGetPos(),llDetectedPos(0)) < min_food_range)
        {
            //move away from food
            state moving;
        }
        current_food_level = current_food_level + 1;
      //  llWhisper(0,"yum");
        if(current_food_level > maximum_food_level)
        {
            current_food_level = 0;
          //  llWhisper(0,"bored");
            state searching;
        }
    }
}

float heartbeat = 0.5;
float z_force = 0.4;
//Go back, left and up if it collides with the land or an object
vector collision_force = <-0.25,0.25,0.75>;
vector target_position;
integer target;

//Start of code from wiki
vector AXIS_UP = <0,0,1>; 
vector AXIS_LEFT = <0,1,0>; 
vector AXIS_FWD = <1,0,0>; 
// getRotToPointAxisAt() 
// Gets the rotation to point the specified axis at the specified position. 
// @param axis The axis to point. Easiest to just use an AXIS_* constant. 
// @param target The target, in region-local coordinates, to point the axis at. 
// @return The rotation necessary to point axis at target. 
// Created by Ope Rand, modifyed by Christopher Omega rotation 

rotation getRotToPointAxisAt(vector axis, vector target)  
{ 
    return  llGetRot() * llRotBetween(axis * llGetRot(), target - llGetPos());  
}
//End of code from wiki

all_stop()
{
    llSetForceAndTorque(<0.0,0.0,0.0>, <0.0,0.0,0.0>, TRUE);
    llApplyImpulse(-llGetVel() * llGetMass(), FALSE);
    llApplyRotationalImpulse(-llGetTorque() * llGetMass(), FALSE);
}

default
{
    state_entry()
    {

        llSetBuoyancy(1);
        llSetStatus(STATUS_PHYSICS,TRUE); 
        llSetStatus(STATUS_ROTATE_X | STATUS_ROTATE_Y, FALSE);
        llSetTimerEvent(heartbeat);
        //llVolumeDetect(TRUE);
        //llSetStatus(STATUS_PHANTOM,TRUE);
        all_stop();
    } 
    link_message(integer sender_num,integer num, string data,key id)
    {
        if(num == 150)
        {
             list data = llParseStringKeepNulls( data, ["-=-"], [] );
             string Cmd = llList2String( data, 0 );
             if( Cmd == "MOVE" )
            {
                  target_position = (vector)llList2String( data, 1 );        
                 float speed = (float)llList2String( data, 2 );
                 float range = (float)llList2String( data, 3 );
                llTargetRemove(target); 
                target = llTarget(target_position,range);
                llSetForce(<speed,0,0> * llGetMass(),TRUE);
            }
            if(Cmd == "STOP" )
            {
                //Received a stop message
                llTargetRemove(target); 
                all_stop();
            }    
        }
     }
    not_at_target()
    {

        llRotLookAt(getRotToPointAxisAt(AXIS_FWD , target_position), 1, 0.5);
        vector currentpos = llGetPos();
        if(currentpos.z > target_position.z + 0.5)
        {
                //little push downwards
             llApplyImpulse(<0,0,-z_force> * llGetMass(),FALSE);
        }
        else
        {
            if(currentpos.z < target_position.z - 0.5)
            {
                //little upwards
                llApplyImpulse(<0,0,z_force> * llGetMass(),FALSE);
            }
        }    
    }
    at_target(integer target_id,vector t_pos,vector o_pos)
    {   
        all_stop();
        llTargetRemove(target);
        llMessageLinked(LINK_SET,150,"ATPOS","");  
    }
    timer()
    {
        //Apply some friction
        llApplyImpulse(-llGetVel() * llGetMass() * 0.6,FALSE);   
    }//end timer
    collision_start(integer num_detected)
    {
        //Hit something?
        //go abit higher
        llApplyImpulse((collision_force) * llGetMass(),TRUE);  
    }
    land_collision_start(vector num_detected)
    {
        //Hit something?
        //go abit higher
        llApplyImpulse((collision_force) * llGetMass(),TRUE);  
    }
    on_rez(integer param)
    {
        llTargetRemove(target); 
        all_stop();
    }
}


state turn_to_target
{
    state_entry()
    {
        llSetStatus(STATUS_ROTATE_X | STATUS_ROTATE_Y, FALSE);
        llRotLookAt(getRotToPointAxisAt(AXIS_FWD , target_position), 0.1, 0.5);
        llSetTimerEvent(1);
    }
    timer()
    {
        state default;
    }
    link_message(integer sender_num,integer num, string data,key id)
    {
        if(num == 150)
        {
             list data = llParseStringKeepNulls( data, ["-=-"], [] );
             string Cmd = llList2String( data, 0 );
             if( Cmd == "MOVE" )
            {
                  target_position = (vector)llList2String( data, 1 );        
                 float speed = (float)llList2String( data, 2 );
                 float range = (float)llList2String( data, 3 );
                llTargetRemove(target); 
                target = llTarget(target_position,range);
                llSetForce(<speed,0,0> * llGetMass(),TRUE);
            }
        }
    }
}

float speed_multi = 3;
float turn_multi = 1;
set_motor(vector speed,vector turn)
{
      //      llOwnerSay("speed = " + (string)(speed * speed_multi * llGetMass()) + " turn = " +(string)turn);
        llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, speed * speed_multi);
        llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, turn* turn_multi);
    }
default
{
    state_entry()
    {

        integer chosen_type = VEHICLE_TYPE_CAR;

        llSetVehicleType(chosen_type);


        llSetVehicleFloatParam(VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE, 10.0);

        llSetVehicleFloatParam(VEHICLE_ANGULAR_MOTOR_TIMESCALE, 0.1); 

        llSetVehicleFloatParam(VEHICLE_LINEAR_MOTOR_TIMESCALE, 0.1); 

        llRemoveVehicleFlags(-1);

        llSetVehicleFlags(VEHICLE_FLAG_NO_DEFLECTION_UP | VEHICLE_FLAG_LIMIT_MOTOR_UP);
        llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, ZERO_VECTOR);
        llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, ZERO_VECTOR);
    }
    on_rez(integer param)
    {
        llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, ZERO_VECTOR);
        llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, ZERO_VECTOR);        
    }
     link_message(integer sender,integer num,string data,key id)
    {
        list Arguments = llParseStringKeepNulls( data, ["-=-"], [] );
        string Command = llList2String( Arguments, 0 );
        if( Command == "FWD" )
        {
            llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <1,0,0>* speed_multi);
        }
        if( Command == "STRT" )
        {
            llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION,ZERO_VECTOR);
        }
        if( Command == "ROT_LFT" )
        {
            llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, <0,0,PI>);
        }
        if( Command == "ROT_RGT" )
        {
            llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, <0,0,PI>);
        }
        if( Command == "LFT" )
        {
            llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, <0,0,PI_BY_TWO>);
        }
        if( Command == "RGT" )
        {
            llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, <0,0,-PI_BY_TWO>);
        }
        if( Command == "STP" )
        {
        llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION,ZERO_VECTOR);
        }

    }
}