Teleporing Range

Apologies in advance for clueless question...

According to the wiki, "fake" teleporting using llsittarget has a range of 512m but no axis may be greater then 300m. Translation please? I'm investigating ways of doing an in-sim teleport system and need to send customers to 450m up in the air from ground level. All the teleporters I have now have a 300m restriction on teleporting.

Much thanks for explanations.

Think of a square on the ground (2D). Each side is 300m. You start at one corner. So the distance to either of the adjacent corners is 300m. What's the distance to the far corner (across the diagonal)? That's more than 300m, it's about 424m.

B___C
|  /|
| / |
|/  |
A---D

Pretend like that's a square So the distance from A to B is 300, A to D is 300, but A to C is 424. If you now do this in 3D, the distance along a cube's diagonal will be higher, about 519m if I got my math right. So basically what the Wiki is saying is that you can teleport to almost anywhere in a 600m cube (600 cause it's +/- 300) with the object's position as the center of the cube. You won't be able to get to the end of the far diagonals, because that exceeds the 512 limit.

In your case, you can't move someone 450m up, because that's along the Z axis, and you're limited to 300m along any given axis.

I'm not sure if that made any more sense than what's in the Wiki

Argent Stonecutter has a free sit-target teleport script that will let you go about 700 meters I believe.

Basically he figured out the math needed to rotate the object to get the max distance from your position to the point you wish to teleport to.

Oh right, the sit target is local. That's a neat trick But how do you get to 700m?

Sorry.. memory was failing on that one. . The limit in his script is 511.5 meters.

Just use warpPos

http://www.lslwiki.com/lslwiki/wakka.php?wakka=LibraryWarpPos

Not directly linked... but someone asked me yesterday about going flying (as in flung away rather than ending up flying rather than standing) after a tp. I've never really experimented with it, but it's my impression that:

1) You get kicked more the further you go with the sit hack
2) You'd have to do some fancy pushing to stop the flying.

Anyone have any hard data or good ideas about stopping it?

when u sit on the object the client accelerated your avatar towards the object position , when you get up the server still remembers the avatar speed and direction this is why u get flung off (not sure if this only happens after a short time when unsitting , like a tp object)

this is a simple liniar acceleration , it would be useful to use a short range snesor to remember avatar the speed and direction just before the avatar sits , then directly after unsit , apply a reverse impulse push on them I=MV (in sl at least )
mieang (push forc)e = (avie mass)*-(speed vector) , to get over push decay , multiply by distance factor if i wish but (1/r^2) but for small distance it doesn't matter so much , this should do the trick , let me know if i was helpful
another small idea is to rez a physical cage around them after they unsit , that might a cheaper solution

I had a .5 sec sleep before the unsit and it worked fine.

Now I use the warpos units and adding a .5 sec delay works there too.

My main problem with long-range sit TP was a problem with sometimes things not rezzing at the destination, or more odd, not rezzing the TP system when you returned to the original position. Seems to be related to packet loss, perhaps, combined with instant movement.

I now use a kind of 'vehicle' system hidden behind a special effect of some kind. It slows it down, but I never have the invisible object problem afterward anymore.

A good way to stop from getting kicked on sit-tp is to put in a llSleep(.01); before the unsit command.

Cubey Terra Teleporter Mark IV - Free

It uses a temporary "beam" prim, and a "base". You "sit" on the beam, select your destination from a list of previously configured destinations, and woosh you're off. Not quite as elegant as a "sit offset teleporter".. but quite practical if you can spare a few seconds for transfer from point A to point B.

Anywhere in the same sim.

I've modified Cubey's TP to use WarpPos which makes it pretty much instantaneous and increases the range to around 2000m ( I think thats the new limit)

Newgate.. I've been working on an effects package for a cubey terra MK 4.. any chance you might wanna share your modified code?

OK. Here are the direct changes to the TP beam code that you need.

////////////////////////////////////////////////////////////////// 
// Function for instant intra-sim movement 
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) );
}
////////////////////////////////////////////////////////////////// 
energize() // teleport sequence
{
    // dematerialization effect...
    //llTriggerSound(transport, 1);
    //llWhisper(0,"Dematerializing "+llKey2Name(agent)+" to pattern buffer...");
    llSetAlpha(alphaActive,ALL_SIDES);
    llSetPrimitiveParams([PRIM_SIZE, sizeActive]);
    llSleep(1);
    llSetAlpha(1,ALL_SIDES);
    llSetTexture(invisible, ALL_SIDES);    
    llStopAnimation(standAnim);
    llStartAnimation(tpAnim);
    //llWhisper(0,"Transporting...");
    
     // move to destination...
   WarpPos(currDestPos);
	   
    // arrive and materialize...
    //llWhisper(0,"Materializing "+llKey2Name(agent)+" from pattern buffer...");
    //llTriggerSound(transport, 1);
    llUnSit(agent);
    llSetAlpha(alphaActive, ALL_SIDES);
    llSetTexture(snow,ALL_SIDES);
    llSleep(2);
    //llWhisper(0,"Transport successful.");
    llDie(); // delete beam
}

If any one is interested here is teh fuill code for my version. Changes made include making the TP beam as simpl,e and dumb as possible. It passes all data handling reequests back to the pad.

I was working on an email driven server version. A central server that the pad's connected to on rez. the server would then issue updates to the pads as and when required. However I had no real use for it and lost interest once I was pretty sure it was going to work.

Newgy's version of Cubey's TP PAD

// TERRA TELEPORTER PAD
// April 21 2006 - by Cubey Terra with help from CrystalShard Foo.
// This is one half of the teleporter system -- the teleporter pad. It reads destinations 
// from the notecard, rezzes a new beam, then sends the list of destinations to the beam
// via a chat channel.

// Because the beam is temp-on-rez, it checks regularly for the presence of the last-rezzed
// beam. If it's gone, it rezzes a new one, and loads it with the destinations.

// The teleporter owner can click the pad (not the beam) to open an admin menu,
// in which the teleporter can be set to public use or group-only use.

// This script is public domain. Do whatever you like with it.

// Thanks to CrystalShard Foo for her help with this.
// -Cubey Terra
//
// Newgates adaption of Cubey's transporter
// the beam is now as dumb as it can be and passes all requests for comms back up to the pad for handling
// This is to reduce the amount of data being passed around
// The eventual aim is to farm out all data handling to a remote server
// and communicate via email when ever an update is required'
// but that is still in the future!!!
//
//
integer line;
integer list_len;
integer PadChannel;
integer UserDlgChannel;
integer AdminDlgChannel;

integer groupLock = FALSE; // locked to group-use only?
integer timerInterval = 1; // don't change... needs to be 1 second
integer PadListening;
integer UserListening;
integer AdminListening;

string notecard = "destinations"; // name of data notecard
string beamName = "Teleporter Beam";

key agent;
key user;
key beamId; // key of the last beam to be rezzed

list destNamesList;
list destPosList;
list allowedUsers;

integer maxDestinations = 0;
integer first = 0;
integer pagesize = 10;

vector clrInactive = <0.2,0.2,0.2>;
vector clrActive = <1,1,1>;


integer timeOut = 60;
integer timeOutCurr;

integer len;

// Functions
integer isNameOnList( string name )
{
     string lower = llToLower(name);
    integer iIndex = llListFindList(allowedUsers, [ lower ]);
    // Always allow the owner
    key owner = llGetOwner();
    string ownerName = llKey2Name(owner);
    if(name == ownerName)
        iIndex = 999;
    return iIndex + 1;
}

Reset()
{
    llWhisper(0,"RESET Received.");
    llWhisper(PadChannel, "delete");
    init();
}

init()
{
    line = 0;
    agent = NULL_KEY;
    user = NULL_KEY;
    llSetColor(clrInactive, 0);
    destNamesList = [];
    destPosList = [];
    AdminDlgChannel = (integer)(llFrand(1000)+10000); // a random dialog channel avoids conflicts with other nearby teleporters
    UserDlgChannel = (integer)(llFrand(1000)+11000); // a random dialog channel avoids conflicts with other nearby teleporters
    PadChannel = (integer)(llFrand(1000)+12000); // a random dialog channel avoids conflicts with other nearby teleporters
    llSetText("Loading destination list...\n\ \n\ ",<1,0,0>,0.5);
    llGetNotecardLine( notecard, line ); // start reading the destinations notecard
    list_len = llGetListLength(destNamesList);
}

integer UpdateListen(key id, integer Channel,integer Listening)
{
    CancelListen(Listening);
    Listening = llListen(Channel,"",id,"");
    llSetTimerEvent(timerInterval);
    return Listening;
}

CancelListen(integer id)
{
    if(id > 0) llListenRemove(id);
}

SayList()
{
    llOwnerSay("You" );
    len = llGetListLength( allowedUsers );
    integer i;
    for( i = 0; i < len; i++ )
    {
        llOwnerSay(llList2String(allowedUsers, i) );
    }
}

adminMenu()
{
    string dText = "TELEPORTER SETUP\n\nThis teleporter has two modes:\n* PUBLIC - Anyone can use it.\n* GROUP - Only group members can use it (Be sure to set the teleporter beam's group).";
    llDialog(agent,dText,["PUBLIC", "LOCKED", "SAY LIST","NEW USER","DELETE","RESET"],AdminDlgChannel);
    UpdateListen(agent,AdminDlgChannel,AdminListening);
}

OwnerControls(string name, key id, string message)
{
    // The Public/Group-only status is stored in the pad and passed
    // to the beam only when a new beam is rezzed.
    //llOwnerSay("OwnerControls - " + message);
    //string temp = llGetSubString(message, 0, 4);
    //llOwnerSay("OwnerControls - [" + temp + "]");
    if (message == "public") 
    {
        groupLock = FALSE;
        llDialog(agent,"TELEPORTER SETUP:\n\n\tTeleporter is now set to PUBLIC mode. Anyone can use it.\n\nPlease delete the teleport beam for change to take effect.",[],AdminDlgChannel);
    }
    else if (message == "locked") 
    {
        groupLock = TRUE;
        llDialog(agent,"TELEPORTER SETUP:\n\n\tTeleporter is now set to LOCKED mode. Only People on the allowed list may use it",[],AdminDlgChannel);
    }
    else if (message == "reset")
    {
        Reset();
    }
    else if (message == "say list")
    {
        SayList();
    }
    else if (message == "new user")
    {
        // Show a dialog and ask the user to type ADD blah
        string dText = "ALLOWED USERS SETUP\n\ntype /"+(string)AdminDlgChannel+"ADD name to add a new user";
        llDialog(agent,dText,[],AdminDlgChannel);
        UpdateListen(agent,AdminDlgChannel,AdminListening);
    }
    else if (message == "delete")
    {
        // Display the full list and allow the user to delete by selection
        first = 0;
        DeleteUser(id);
    }
    if("prev users" == message)
    {
        first -= pagesize;
        DeleteUser(id);
    }
    else if("more users" == message)
    {
        if((first + pagesize) < maxDestinations)
            first += pagesize;
        DeleteUser(id);
    }
    else if(llSubStringIndex(message, "add ") == 0)
    {
        string strName = llGetSubString(message, 4, llStringLength(message));
         llOwnerSay("Checking " + strName);
        if(!isNameOnList(strName))
        {
            allowedUsers += strName;
            llWhisper(0, "Added " + strName);
        }
    }
    else
    {
        // Must be a choice of user
        integer selection = llListFindList(allowedUsers, [ message ]);
        if(selection >= 0)
        {
            // Found a destination
            string str = llList2String(allowedUsers, selection);
            llWhisper(PadChannel, "deleting "+str);
        }
    }
}

rezBeam()
{
    // rez a new temp-on-rez teleporter beam over the pad.
    llSetTimerEvent(0.0);
    rotation rot = llGetRot();
    llRezAtRoot(beamName,llGetPos() +<0,0,0.01>,ZERO_VECTOR,rot,PadChannel);
    llSleep(2); // give the beam enough time to start its listen after rezzing
    llSetText("",ZERO_VECTOR,1); // turn off the status hovertext
    llSetColor(clrActive, 0);
    CancelListen(PadListening);
    llSetTimerEvent(timerInterval);
    //llWhisper(0,"Communication with beam on channel " + (string)PadChannel);
    PadListening = llListen(PadChannel,"","","");
    
}


SelectDestination(key id)
{    
    list choices;
    string text = "Destinations Menu\n\nPlease select an option";
    // Now add the destinations
    if(first > 0)
        choices += "Prev";
    if((first+ pagesize) < maxDestinations )
        choices += "Next";
        
    integer i;
    for(i = 0;i < pagesize;i++)
    {
        string str = llList2String(destNamesList,(i+first));
        if( llStringLength(str) > 0)
            choices += str;
    }
    // finally show the dialog
    llDialog(id,text,choices,UserDlgChannel);
    UpdateListen(id,UserDlgChannel,UserListening);

}


DeleteUser(key id)
{    
    list choices;
    string text = "Delete Allowed User Menu\n\nPlease select an option";
    // Now add the pictures
    integer max = llGetListLength(allowedUsers);
    if(first > 0)
        choices += "PREV USERS";
    if((first + pagesize) < max)
        choices += "MORE USERS";
        
	integer i;
    for(i = 0;i < pagesize;i++)
    {
        string str = llList2String(allowedUsers,(i+first));
        if( llStringLength(str) > 0)
            choices += str;
    }
    // finally show the dialog
    llDialog(id,text,choices,AdminDlgChannel);
    UpdateListen(id,AdminDlgChannel,AdminListening);

}



default
{
    state_entry()
    {
        // avatars are not supposed to sit on the pad itself,
        // so try to discourage it by removing the "Sit" option.
        llSetSitText(".");
        llSitTarget(<0,0,0.25>,ZERO_ROTATION);
        init();
    }
    on_rez(integer foo)
    {
        llResetScript();
    }
    
    changed(integer change)
    {
        if (change & CHANGED_LINK)
        {
            // if someone does sit on the pad itself, unsit them
            key sitter = llAvatarOnSitTarget();
            if (sitter != NULL_KEY)
            {
                llUnSit(sitter);
                llWhisper(0,"Oops! You sat on the wrong part. To use the teleporter, right-click the top part (the beam) and choose Teleport.");
            }
        }
    }

    touch_start(integer total_number)
    {
        integer i;
        agent = llDetectedKey(i);

        // only the owner can access the admin menu
        // If you want, you can make it so group members can access the admin menu.
        // Replace the if statement below with this:
        // if (llSameGroup(agent)) adminMenu();
        if (agent == llGetOwner()) adminMenu();
    }
    
    listen(integer channel, string name, key id, string message)
    {
        
        string lower = llToLower(message);
        //llWhisper(0,"Received [" + message + "] on " + (string)channel);
        if (channel == AdminDlgChannel)
        {
            OwnerControls(name,id,lower);
        }
        else if(channel == PadChannel)
        {
            // Message from the pad - id of user requesting tp
            user = (key)message;
            string username = llKey2Name(user);
            integer allowed = TRUE;
            if(groupLock)
            {
                if(isNameOnList( username ) == 0)
                    allowed = FALSE;
            }
            if(allowed)
            {
                llWhisper(PadChannel, "allowed");
                SelectDestination(user);
            }
            else
            {
                llWhisper(PadChannel, "not allowed");
            }
        }
        else if(channel == UserDlgChannel)
        {
            if("prev" == lower)
            {
                first -= pagesize;
                SelectDestination(id);
            }
            else if("next" == lower)
            {
                if((first + pagesize) < maxDestinations)
                    first += pagesize;
                SelectDestination(id);
            }
            else
            {
                // Must be a choice of destination
                integer selection = llListFindList(destNamesList, [ message ]);
                if(selection >= 0)
                {
                    // Found a destination
                    string str = llList2String(destPosList, selection);
                    llWhisper(PadChannel, "dest"+str);
                }
            }
        }
    }
    
    dataserver( key query_id, string data ) // read from the notecard 
    {
        if (data != EOF) 
        {
            if (line%2 == 0) 
            {
                destNamesList += data;
                llOwnerSay("name"+data);
            }
            else if (line%2 != 0) 
            {
                destPosList += data;
                llOwnerSay("dest"+data);
            }
            line++;
            llGetNotecardLine( notecard, line );
        }
        else 
        {
            llSetText("Destinations loaded.\n\ \n\ ",<0,1,0>,1);
            maxDestinations = llGetListLength(destNamesList);
			rezBeam();
        }
    }
    
    object_rez(key ident) 
    {
        // This gets the key of the last rezzed beam
        // so that the pad knows what to look for.
        beamId=ident;
    }     
    
    timer() 
    {
        // Check if previously rezzed beam still exists.
        if (llKey2Name(beamId) == "")
        {
            rezBeam();
        }
        // stop the Listen after timeOut seconds have past
        if (timeOutCurr < timeOut) 
        {
            timeOutCurr += 1;
        }
        else
        {
            CancelListen(AdminListening); // stop the listen
        }
        
    }
    
   
}

Newgy's version of Cubey's TP beam

// TELEPORTER BEAM
// APRIL 21 2006 - CUBEY TERRA
// This is one of a two part teleporter. This part is the beam. The other part is the teleporter pad.
// The pad rezzes new beams, then loads the beam with destinations via chat messages.

// The beam use llSetPos to move the seated avatar to another location, then unsits the
// avatar and deletes itself. The pad rezzes a fresh beam once this beam has left the pad.


key agent;

integer sit;
integer padChannel = 20060420; // listen channel for pad
integer listening;
integer timeOut = 60;
integer timeOutCurr;


float alphaIdle = 0.25; // transparency when the transport beam is idle
float alphaActive = 0.5; // transparency when the transport beam is energized

string standAnim = "turn_180"; // name of standing animation
string tpAnim = "ball"; // name of the teleporting animation

string transport = "47117bd7-41e8-530d-439c-94bee925fbb7"; // UUID of transporter sound
string invisible = "38b86f85-2575-52a9-a531-23108d8da837"; // UUID of the nifty invisi texture
string snow = "00af7673-fe50-9c99-53c9-470a48461c0c"; // UUID of the tv snow texture

string unAuthorizedMsg = "You are not authorized to use this teleporter."; 

vector currDestPos;
vector pos;
vector sizeActive = <0.95,0.95,5.5>; // size of beam while travelling
vector sizeIdle = <0.95,0.95, 0.06>; // size of beam while idle on the pad

////////////////////////////////////////////////////////////////// 
// Function for instant intra-sim movement 
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) );
}
////////////////////////////////////////////////////////////////// 
energize() // teleport sequence
{
    // dematerialization effect...
    //llTriggerSound(transport, 1);
    //llWhisper(0,"Dematerializing "+llKey2Name(agent)+" to pattern buffer...");
    llSetAlpha(alphaActive,ALL_SIDES);
    llSetPrimitiveParams([PRIM_SIZE, sizeActive]);
    llSleep(1);
    llSetAlpha(1,ALL_SIDES);
    llSetTexture(invisible, ALL_SIDES);    
    llStopAnimation(standAnim);
    llStartAnimation(tpAnim);
    //llWhisper(0,"Transporting...");
    
    WarpPos(currDestPos);
	
    // move to destination...
    //pos = llGetPos();
    //while (pos != currDestPos)
    //{
    //    llSetPos(currDestPos);
    //    pos = llGetPos();
    //}
    
    // arrive and materialize...
    //llWhisper(0,"Materializing "+llKey2Name(agent)+" from pattern buffer...");
    //llTriggerSound(transport, 1);
    llUnSit(agent);
    llSetAlpha(alphaActive, ALL_SIDES);
    llSetTexture(snow,ALL_SIDES);
    llSleep(2);
    //llWhisper(0,"Transport successful.");
    llDie(); // delete beam
}

init()
{
    //llSetText("RECHARGHING\nPlease wait...",<1,0,0>,0.1);
    listenStatus(TRUE); // start the listen
    llSetPrimitiveParams([PRIM_TEMP_ON_REZ, TRUE, PRIM_SIZE, sizeIdle]);
    llSetColor(<0,1,1>,ALL_SIDES);
    llSetAlpha(alphaIdle, ALL_SIDES);
}

listenStatus(integer onOff)
{
    // remove existing listens (if any)
    if (listening)
    {
        llListenRemove(listening);
        listening = 0;
    } 
    
    // start new listen if told to
    if (onOff == TRUE) 
    {
        listening = llListen(padChannel, "","",""); // for the pad
    }
    // To reduce lag, both listens are shut off after a short time.
    llSetTimerEvent(1.0); // Start timer to shut off Listen
}

default
{
    state_entry()
    {
        init();
        llSitTarget(<0,0,1.0>,ZERO_ROTATION);
        llSetSitText("Teleport");
        llSetTextureAnim (ANIM_ON | LOOP, ALL_SIDES, 4, 4, 0, 0, 15.0);
    }
    
    on_rez(integer num)
    {
        padChannel = num;
        init();
        llSitTarget(<0,0,1.0>,ZERO_ROTATION);
        llSetSitText("Teleport");
        llSetTextureAnim (ANIM_ON | LOOP, ALL_SIDES, 4, 4, 0, 0, 15.0);
		//llWhisper(0,"Communication with pad on channel " + (string)padChannel);
   }
    
    listen(integer channel, string name, key id, string message)
    {
        message = llToLower(message);
        
        if (channel == padChannel) // check for messages from the teleporter pad
        {
            if (llSubStringIndex(message, "dest") == 0) 
            {
                currDestPos = (vector)llGetSubString(message, 4, llStringLength(message));
				//llWhisper(0, "dest"+(string)currDestPos);
                energize();
            }
            else if (message == "allowed")
            {
				sit = TRUE;
				//llStopAnimation("sit");
				//llStartAnimation(standAnim); // assume the position
            }
            else if (message == "not allowed") 
            {
				llWhisper(0,unAuthorizedMsg);
				llUnSit(agent);
            }
            else if (message == "delete") 
            {
				llDie();
            }
        }
    }


    changed(integer change)
    {
        
        if (change & CHANGED_LINK)
        {
            agent = llAvatarOnSitTarget();
            if ((agent != NULL_KEY) && (!sit))
            {
				//llWhisper(0,llKey2Name(agent) + " is requesting a TP");
				llWhisper(padChannel,(string)agent);
				llRequestPermissions(agent, PERMISSION_TRIGGER_ANIMATION);
 				llStopAnimation("sit");
				llStartAnimation(standAnim); // assume the position
           }
            else if (agent == NULL_KEY && sit)  // avatar stands (manually or unseated at end of trip)
            {
                llStopAnimation(standAnim);
                llStopAnimation(tpAnim);
                sit = FALSE;
            }
        }
    }
   
    timer()
    {
        // stop the Listen after timeOut seconds have past
        if (timeOutCurr < timeOut) 
        {
            timeOutCurr += 1;
        }
        else
        {
            listenStatus(FALSE); // stop the listen
            timeOutCurr = 0;
            llSetTimerEvent(0.0); // stop the timer
        }
        
    }
}

Found it!

(the one you gave me in world seemed to reference a third.. SERVER via emails.