# llSitTarget

*LSL function*

```lsl
void llSitTarget(vector offset, rotation rot);
```

- `vector offset`: Target position vector in local prim coordinates.
- `rotation rot`: Target rotation relative to the prim's rotation.

- Energy: 10

Sets the sit target position (offset) and rotation (rot) relative to the prim's position and orientation. Clears the sit target if offset is ZERO_VECTOR.

Set the sit location for the prim. The sit location is relative to the prim's position and rotation.

If **offset** == [`<0.0, 0.0, 0.0>`](/constants/ZERO_VECTOR/) then the sit target is removed.

```lsl title="How to use" frame="terminal"
llSitTarget(ZERO_VECTOR, ZERO_ROTATION);
```

## Specification

`llSitTarget` sets the position for the Agent Target (Advanced -> Character -> View Agent Target). The position of the target is based on **rot** and the **offset**[^wiki-6405c7].

[^wiki-6405c7]: It is widely considered that the **rot** should not affect the position, unfortunately the sit target code is a [lava-flow](https://en.wikipedia.org/wiki/Lava_flow_%28programming%29). ~ [SVC-2277](https://jira.secondlife.com/browse/SVC-2277)

## Caveats

- Once a sit target is removed [llAvatarOnSitTarget](/functions/llAvatarOnSitTarget/) will only return [NULL_KEY](/constants/NULL_KEY/).
- Removing or deactivating the script that sets the sit target will not remove the prim's sit target.
  - Sit target is a prim property and not dependent on a script for its continued existence.
- To remove sit target, use the following:

```lsl
llSitTarget(ZERO_VECTOR, ZERO_ROTATION);
```

- Shift-copying a prim with a sit target, without a script that will set the sit target again, will not keep the sit target on the copy. (The copy is in the original location when shift-copying.)
- There is no way to remove the Sit option from the menu.
  - It will appear to be removed if the [llSetSitText](/functions/llSetSitText/) is set to a space " " or similar transparent string.
- Attachments cannot be sat upon (see [SVC-6100](https://jira.secondlife.com/browse/SVC-6100) to vote for such a feature).
- **rot** affects the position of the sit target in a buggy way.
  - To correct for the **rot** bug, simply subtract `<0,0,0.4>` from the position when **rot** is zero. See example below.
  - [llSetLinkPrimitiveParams](https://wiki.secondlife.com/wiki/LlSetPrimitiveParams#llSetLinkPrimitiveParams) is a more difficult work-around.
  - Animations are relative to the Agent Target, but the Agent Target isn't described by the animation.
- [llSitTarget](/functions/llSitTarget/) does not update position of an already seated avatar.
  - [UpdateSitTarget](#updatesittarget) described below works around this problem. It works by converting the sit target information into a link position that is passed along to [llSetLinkPrimitiveParams](https://wiki.secondlife.com/wiki/LlSetPrimitiveParams#llSetLinkPrimitiveParams).
- **offset** is limited to 300.0 meters on each axis. The *x*, *y* and *z* components must be in the range \[-300, 300.0\].
  - If they are outside the acceptable range they are rounded to the closest limit.
- If an object has multiple seats (each seat has a script that sets a sit target, or the [linkset](https://wiki.secondlife.com/wiki/Link_Messages) has a script that assigns several [llLinkSitTarget](/functions/llLinkSitTarget/)s), the following method determines which sit target an avatar ends up at:
  - If the prim that is clicked on *has* a sit target and that sit target is not full, that sit target is used.
  - If the prim that is clicked on *has no sit target*, and one or more other linked prims have sit targets that are not full, the sit target of the prim with the lowest link number will be used.

## Examples

<details open>
<summary>Example 1</summary>

```lsl
default
{
    state_entry()
    {
        llSitTarget(<0.0, 0.0, 1.0>, ZERO_ROTATION); //The vector's components must not all be set to 0 for effect to take place.
    }
}
```

</details>

<details>
<summary>Example 2</summary>

```lsl collapse={1-11, 17-22}
default     //example with work-around for llSetTarget rot bug
{           //place in any prim large enough to sit on at any angle
            //click once to choose a place to sit, a second time to sit there
    touch_start(integer num)
    {
        vector pos   = llDetectedTouchPos(0);        //use touch to set sit target
        vector lft   = llDetectedTouchBinormal(0);   //use normals to rotate avatar to
        vector up    = llDetectedTouchNormal(0);     //sit upright
        rotation rot = llAxes2Rot(lft % up, lft, up) / llGetRot();  //rotate avatar to stand there
        vector siz   = llGetAgentSize(llDetectedKey(0));
        pos += 0.65 * siz.z * up;       //this places MY avatars feet close to the surface
        pos = (pos - llGetPos()) / llGetRot();  //llSetTarget expects local co-ordinates
        if (rot != ZERO_ROTATION) pos -=<0.0, 0.0, 0.4>;  //here is the workaround
        llSitTarget(pos, rot);
        llSetClickAction(CLICK_ACTION_SIT);   //switch to sit for second click
    }
    changed(integer change)
    {
        if (llAvatarOnSitTarget() == NULL_KEY)      //if they unsit,
            llSetClickAction(CLICK_ACTION_TOUCH);   //go back to click mode
    }
}
```

</details>

## Helper functions

### UpdateSitTarget

This function is primarily for use in objects that need to move seated avatars. It is most useful in poseballs, furniture and vehicles (just not while they are moving). There is also a `UpdateLinkSitTarget()` version of the function that can be found at: [User:Strife_Onizuka/UpdateLinkSitTarget](https://wiki.secondlife.com/wiki/User:Strife_Onizuka/UpdateLinkSitTarget).

```lsl collapse={7-39}
//Sets / Updates the sit target moving the avatar on it if necessary.
UpdateSitTarget(vector pos, rotation rot)
{//Using this while the object is moving may give unpredictable results.
    llSitTarget(pos, rot);//Set the sit target
    key user = llAvatarOnSitTarget();
    if (user)//true if there is a user seated on the sit target; if so, update their position
    {
        vector size = llGetAgentSize(user);
        if (size)//This tests to make sure the user really exists.
        {
            //We need to make the position and rotation local to the current prim
            rotation localrot = ZERO_ROTATION;
            vector   localpos = ZERO_VECTOR;
            if (llGetLinkNumber() > 1)//only need the local rot if it's not the root.
            {
                localrot = llGetLocalRot();
                localpos = llGetLocalPos();
            }
            integer linkNum = llGetNumberOfPrims();
            do
			{
                if (user == llGetLinkKey(linkNum))//just checking to make sure the index is valid.
                {
                    //<0.008906, -0.049831, 0.088967> are the coefficients for a parabolic curve that best fits real avatars. It is not a perfect fit.
                    float fAdjust = ((((0.008906 * size.z) + -0.049831) * size.z) + 0.088967) * size.z;
                    llSetLinkPrimitiveParamsFast(linkNum,
                        [PRIM_POS_LOCAL, (pos + <0.0, 0.0, 0.4> - (llRot2Up(rot) * fAdjust)) * localrot + localpos,
                         PRIM_ROT_LOCAL, rot * localrot]);
                    jump end;//cheaper but a tad slower than return
                }
            } while(--linkNum);
        }
        else
        {//It is rare that the sit target will bork, but if it does happen, this can help to fix it.
            llUnSit(user);
        }
    }
    @end;
}//Written by Strife Onizuka, size adjustment and improvements provided by Talarus Luan
```

### GetSitTarget

This function is primarily for configuring sittargets for furniture. Sit an avatar on a box, position the box where you want them and use this function to read the sittarget so that it can be coded into the furniture. See [/GetSitTarget](https://wiki.secondlife.com/wiki//GetSitTarget) for an example.

```lsl
list GetSitTarget(integer prim, key av)
{//WARNING: This function is very good but not perfect. Do not repeatedly pass GetSitTarget to llSitTarget or UpdateSitTarget.
 //Do not use this on moving avatars or objects, the results will very likely be wrong.
    vector tp = llGetAgentSize(av);
    if (tp)
    {//llGetObjectDetails is used so the av is not required to be seated on the object with the sit target.
        list details = llGetLinkPrimitiveParams(prim, [PRIM_POSITION, PRIM_ROTATION]) + llGetObjectDetails(av, [OBJECT_POS, OBJECT_ROT]);
        rotation f = llList2Rot(details, 1);
        rotation r = llList2Rot(details, 3) / f;
        float fAdjust = ((((0.008906 * tp.z) + -0.049831) * tp.z) + 0.088967) * tp.z;
        return [((llList2Vector(details, 2) - llList2Vector(details, 0)) / f) + (llRot2Up(r) * fAdjust) - <0.0, 0.0, 0.4>, r];
    }
    return [];
}//Written by Strife Onizuka, size adjustment provided by Talarus Luan
```

## Known issues

From the issue templates included by the wiki article:

- SVC-924 (nf): **llSit**() - scriptable ability to force an avatar to sit on an object
- SVC-6100 (nf): Ability to sit on prims attached to avatars

## See also

### Functions

- [llLinkSitTarget](/functions/llLinkSitTarget/)
- [llSetSitText](/functions/llSetSitText/)
- [llAvatarOnSitTarget](/functions/llAvatarOnSitTarget/)
- [llAvatarOnLinkSitTarget](/functions/llAvatarOnLinkSitTarget/)
- [llUnSit](/functions/llUnSit/)

### Events

- [changed](/events/changed/)

---

*Source: [LlSitTarget](https://wiki.secondlife.com/wiki/LlSitTarget) on the Second Life Wiki. Content from the Second Life Wiki articles LlSitTarget (revision 1210693, 2022-04-23), Template:LSL Constant/NULL KEY (revision 59847, 2008-03-24), Template:Issues/SVC-924 (revision 1057493, 2010-10-08), Template:Issues/SVC-6100 (revision 1057523, 2010-10-08) and Template:LSL Function/offset (revision 1169422, 2012-06-18), CC BY-SA 3.0.*

---

From lsl.dev: https://lsl.dev/functions/llSitTarget/