Jenna Huntsman

You should have a read through of the wiki page for llGetNotecardLine - specifically, there's an example on there which you could adapt to your needs. http://wiki.secondlife.com/wiki/LSL_llGetNotecardLine#Examples

Okay, I've made some modifications to get that working: TLDR; you were overcomplicating things with a lot of functions which weren't really needed - I've stripped most of them out so you can see how everything is being calculated. integer Find(vector baseline, vector target, rotation rot) { //Returns whether the target vector is to the left or right of the baseline vector //returns 0 //straight ahead = 0 (baseline == target) //left = 1 //right = -1 //directly behind = 2 integer deadzone = 10; //How many degrees we consider as a deadzone (the 2 vectors provided are close enough to be considered directly in front or behind) rotation r2 = llRotBetween(llRot2Fwd(rot),llVecNorm(target-baseline)); vector test = llRot2Euler(r2)*RAD_TO_DEG; float ang = test.z; //Angle in degrees target is relative to base if (llFabs(ang) < deadzone) //object is within the deadzone. { return 0; } else if (llFabs(ang) > (180-deadzone)) //object within deadzone, behind { return 2; } else if (ang > 0) { return 1; } else { return -1; } } Test() { list data = llGetObjectDetails(llGetOwner(), [OBJECT_POS]); vector target_pos = llList2Vector(data, 0); integer Place = Find(llGetPos(),target_pos,llGetRot()); llOwnerSay((string)Place); } default { state_entry() { //Test(); llOwnerSay("Left or Right example"); } touch_start(integer total_number) { llWhisper(0,"You touched me!"); Test(); } } I made some modifications to the Find function to make it a little easier to use (namely, be able to supply the rotation of the baseline object in the event it's not the object containing the script) Also: llRotBetween calculates direction relative to <0,0,0> - so don't feed it 2 position vectors, feed it 2 normalized vectors and you're all good.

I see that your baseline vector is defined but no rotation is given - is it intended that the baseline never has a rotation? I can see that causing issues down the line if the object is placed on an angle and needs to determine the position of the avatar relative to itself. (I'll look at your script in depth a little later, need to finish some other things first!)

First: The viewer deliberately resets to the region preset as EEP is meant to hand power of the user's environment settings to the parcel owner. This is intended behaviour - as setting and forgetting a personal preset makes the region settings obsolete, which can break content if it depends on certain environment settings - this isn't going to change. Firestorm's behaviour is non-standard. There's a debug setting - 'EnvironmentPersistAcrossLogin' which, when enabled, will do what you want. I wouldn't recommend it though, as it breaks more than it fixes.

http://wiki.secondlife.com/wiki/LSL_Protocol/RestrainedLoveAPI#Movement That is probably the easiest way to set the rotation of a given avatar. Of course, that would depend on the 'NPC' being able to accept RLV commands. LSL doesn't have any functions to manipulate avatar position and rotation directly. You can apply forces and impulses, but you can't take control away from the user entirely (with exception to taking control of their keyboard inputs).

Not with EEP, no - you can make water static with EEP, and strip it of it's texture (to create a completely smooth surface), then you might be able to get a large mesh plane and use a texture animation to add the effect you describe. EEP allows you to control the direction that Linden water travels, but it will only ever travel in a single direction, not to a given point.

You should post the source code (or where to locate the source code). We can't help with closed-source products - for that, you'll need to contact the creator.

Are you trying to generate a random SLURL (i.e. a map location) or just a random URL (like in your example)? While llLoadURL calls stack, doing so will silently minimize the previous request in most viewers (so, it's often better to use a different approach).

Hey all, Spent a little time porting over the HSLuv colour space code to LSL, and knocked up a quick colour interpolation script. This could be useful for anyone who wants to handle interpolating colours, but hate interpolating through RGB space. integer time = 90; //1.5 seconds. vector origin = <120,133,139>; //Enter a colour value in 8-bit RGB (this will be converted to LSL) vector dest = <146,43,62>; //Enter a colour value in 8-bit RGB (this will be converted to LSL) integer col; //What colour am I? //What colour space to use: integer ColSpace = 1; // 0 = LSL (native), 1 = XYZ colour space, 2 = Lch (CIELAB) colour space, 3 = HSLuv colour space, 4 = HPLuv colour space //Colour interpolation info: // https://colorjs.io/docs/interpolation.htm // https://michael-m.medium.com/true-color-interpolation-a1a17352ebf0 /* HSLUV-LSL v1 HSLUV is a human-friendly alternative to HSL. ( http://www.hsluv.org ) LSL port by Jenna Huntsman; Based on the GLSL port by William Malo ( https://github.com/williammalo ). Note that due to rounding errors the values returned are often not an exact match to the input value when going round trip, however is usually close enough not to cause a visual difference. RGB doesn't mean RGB in the classic sense, it means LSL colour (range is 0-1, NOT 0-255), e.g. Red in classic RGB is <255,0,0>, and in LSL it's <1,0,0> */ float min(float x, float y) { return ( ( llAbs( x >= y ) ) * y ) + ( ( llAbs( x<y ) ) * x ); } float length (vector x) { return llSqrt(llPow(x.x,2)+llPow(x.y,2)+llPow(x.z,2)); } vector hsluv_intersectLineLine(vector line1x, vector line1y, vector line2x, vector line2y) { vector x = line1y - line2y; vector y = line2x - line1x; return <x.x/y.x, x.y/y.y, x.z/y.z>; } vector hsluv_distanceFromPole(vector pointx,vector pointy) { vector x = <pointx.x*pointx.x, pointx.y*pointx.y, pointx.z*pointx.z> + <pointy.x*pointy.x, pointy.y*pointy.y, pointy.z*pointy.z>; return <llSqrt(x.x),llSqrt(x.y),llSqrt(x.z)>; } vector hsluv_lengthOfRayUntilIntersect(float theta, vector x, vector y) { vector t = <x.x - llSin(theta), x.y-llSin(theta), x.z-llSin(theta)> * llCos(theta); vector len = <y.x/t.x,y.y/t.y,y.z/t.z>; if (len.x < 0.0) {len.x=1000.0;} if (len.y < 0.0) {len.y=1000.0;} if (len.z < 0.0) {len.z=1000.0;} return len; } float hsluv_maxSafeChromaForL(float L){ list m2 = [<3.2409699419045214,-1.5373831775700935,-0.49861076029300328>,<-0.96924363628087983,1.8759675015077207,0.041555057407175613>,<0.055630079696993609,-0.20397695888897657,1.0569715142428786>]; float sub0 = L + 16.0; float sub1 = sub0 * sub0 * sub0 * .000000641; float sub2 = L / 903.2962962962963; if(sub1 > 0.0088564516790356308) { sub2 = sub1; } vector top1 = (284517.0 * llList2Vector(m2,0) - 94839.0 * llList2Vector(m2,2)) * sub2; vector bottom = (632260.0 * llList2Vector(m2,2) - 126452.0 * llList2Vector(m2,1)) * sub2; vector top2 = (838422.0 * llList2Vector(m2,2) + 769860.0 * llList2Vector(m2,1) + 731718.0 * llList2Vector(m2,0)) * L * sub2; vector bounds0x = <top1.x / bottom.x, top1.y / bottom.y, top1.z / bottom.z>; vector bounds0y = <top2.x / bottom.x, top2.y / bottom.y, top2.z / bottom.z>; vector bottomADD = <bottom.x+126452.0, bottom.y+126452.0, bottom.z+126452.0>; vector bounds1x = <top1.x/bottomADD.x, top1.y/bottomADD.y, top1.z/bottomADD.z>; vector top2MIN = <top2.x-769860.0, top2.y*769860.0, top2.z*769860.0>*L; vector bounds1y = <top2MIN.x/bottomADD.x, top2MIN.y/bottomADD.y, top2MIN.z/bottomADD.z>; vector xs0 = hsluv_intersectLineLine(bounds0x, bounds0y, <-1.0/bounds0x.x, -1.0/bounds0x.y, -1.0/bounds0x.z>, ZERO_VECTOR ); //vec3(0.0) vector xs1 = hsluv_intersectLineLine(bounds1x, bounds1y, <-1.0/bounds1x.x, -1.0/bounds1x.y, -1.0/bounds1x.z>, ZERO_VECTOR ); //vec3(0.0) vector leng0t1 = <bounds0y.x + xs0.x,bounds0y.y + xs0.y, bounds0y.z + xs0.z>; vector leng0t2 = <leng0t1.x * bounds0x.x, leng0t1.y * bounds0x.y, leng0t1.z * bounds0x.z>; vector lengths0 = hsluv_distanceFromPole( xs0, leng0t2); vector leng1t1 = <bounds1y.x + xs1.x,bounds1y.y + xs1.y, bounds1y.z + xs1.z>; vector leng1t2 = <leng1t1.x * bounds1x.x, leng1t1.y * bounds1x.y, leng1t1.z * bounds1x.z>; vector lengths1 = hsluv_distanceFromPole( xs1, leng1t2); return min(lengths0.x,min(lengths1.x,min(lengths0.y,min(lengths1.y,min(lengths0.z,lengths1.z))))); } float hsluv_maxChromaForLH(float L, float H) { float hrad = H*DEG_TO_RAD; list m2 = [<3.2409699419045214,-1.5373831775700935,-0.49861076029300328>,<-0.96924363628087983,1.8759675015077207,0.041555057407175613>,<0.055630079696993609,-0.20397695888897657,1.0569715142428786>]; float sub1 = llPow(L + 16.0, 3.0) / 1560896.0; float sub2 = L / 903.2962962962963; if(sub1 > 0.0088564516790356308) { sub2 = sub1; } vector top1 = (284517.0 * llList2Vector(m2,0) - 94839.0 * llList2Vector(m2,2)) * sub2; vector bottom = (632260.0 * llList2Vector(m2,2) - 126452.0 * llList2Vector(m2,1)) * sub2; vector top2 = (838422.0 * llList2Vector(m2,2) + 769860.0 * llList2Vector(m2,1) + 731718.0 * llList2Vector(m2,0)) * L * sub2; vector bound0x = <top1.x / bottom.x, top1.y / bottom.y, top1.z / bottom.z>; vector bound0y = <top2.x / bottom.x, top2.y / bottom.y, top2.z / bottom.z>; vector bottomADD = <bottom.x+126452.0, bottom.y+126452.0, bottom.z+126452.0>; vector bound1x = <top1.x/bottomADD.x, top1.y/bottomADD.y, top1.z/bottomADD.z>; vector top2MIN = <top2.x-769860.0, top2.y*769860.0, top2.z*769860.0>*L; vector bound1y = <top2MIN.x/bottomADD.x, top2MIN.y/bottomADD.y, top2MIN.z/bottomADD.z>; vector lengths0 = hsluv_lengthOfRayUntilIntersect(hrad, bound0x, bound0y ); vector lengths1 = hsluv_lengthOfRayUntilIntersect(hrad, bound1x, bound1y ); return min(lengths0.x, min(lengths1.x, min(lengths0.y, min(lengths1.y, min(lengths0.z, lengths1.z))))); } float FLOhsluv_fromLinear(float c) { float x = llPow(c, 1.0 / 2.4) - 0.055; if(c <= 0.0031308) { x = 12.92 * c; } return x; } vector hsluv_fromLinear(vector c) { return <FLOhsluv_fromLinear(c.x), FLOhsluv_fromLinear(c.y), FLOhsluv_fromLinear(c.z)>; } float FLOhsluv_toLinear(float c) { float x; if(c > 0.04045) { x = llPow((c + 0.055) / (1.0 + 0.055), 2.4); } else { x = c / 19.92; } return x; } vector hsluv_toLinear(vector c) { return <FLOhsluv_toLinear(c.x), FLOhsluv_toLinear(c.y), FLOhsluv_toLinear(c.z)>; } float hsluv_yToL(float Y){ float x = 116.0 * llPow(Y, 1.0 / 3.0) - 16.0; if(Y <= 0.0088564516790356308) { x = Y * 903.2962962962963; } return x; } float hsluv_lToY(float L) { float x = llPow((L + 16.0) / 116.0, 3.0); if(L <= 8.0) { x = L / 903.2962962962963; } return x; } vector xyzToRgb(vector tuple) { vector x; x.x = tuple.x*3.2409699419045214 + tuple.y*-1.5373831775700935 + tuple.z*-0.49861076029300328; //Matrix math x.y = tuple.x*-0.96924363628087983 + tuple.y*1.8759675015077207 + tuple.z*0.041555057407175613; x.z = tuple.x*0.055630079696993609 + tuple.y*-0.20397695888897657 + tuple.z*1.0569715142428786; return hsluv_fromLinear(x); } vector rgbToXyz(vector tuple) { vector x = hsluv_toLinear(tuple); vector y; y.x = x.x*0.41239079926595948 + x.y*0.35758433938387796 + x.z*0.18048078840183429; y.y = x.x*0.21263900587151036 + x.y*0.71516867876775593 + x.z*0.072192315360733715; y.z = x.x*0.019330818715591851 + x.y*0.11919477979462599 + x.z*0.95053215224966058; return y; } vector xyzToLuv(vector tuple){ float X = tuple.x; float Y = tuple.y; float Z = tuple.z; float L = hsluv_yToL(Y); float div = 1 / (tuple*<1,15,3>); return <1,(52. * (X*div) - 2.57179),(117.* (Y*div) - 6.08816)>*L; } vector luvToXyz(vector tuple) { float L = tuple.x; float U = tuple.y / (13.0 * L) + 0.19783000664283681; float V = tuple.z / (13.0 * L) + 0.468319994938791; float Y = hsluv_lToY(L); float X = 2.25 * U * Y / V; float Z = (3./V - 5.)*Y - (X/3.); return <X, Y, Z>; } vector luvToLch(vector tuple) { float L = tuple.x; float U = tuple.y; float V = tuple.z; float C = length(<0, tuple.y, tuple.z>); float H = llAtan2(V,U)*RAD_TO_DEG; if (H < 0.0) { H = 360.0 + H; } return <L, C, H>; } vector lchToLuv(vector tuple) { float hrad = tuple.z*DEG_TO_RAD; return <tuple.x, llCos(hrad)*tuple.y, llSin(hrad)*tuple.y>; } vector hsluvToLch(vector tuple) { tuple.y *= hsluv_maxChromaForLH(tuple.z, tuple.x) * .01; return <tuple.z,tuple.y,tuple.x>; } vector lchToHsluv(vector tuple) { tuple.y /= hsluv_maxChromaForLH(tuple.x, tuple.z) * .01; return <tuple.z,tuple.y,tuple.x>; } vector hpluvToLch(vector tuple) { tuple.y *= hsluv_maxSafeChromaForL(tuple.z) * .01; return <tuple.z, tuple.y, tuple.x>; } vector lchToHpluv(vector tuple) { tuple.y /= hsluv_maxSafeChromaForL(tuple.x) * .01; return <tuple.z, tuple.y, tuple.x>; } vector lchToRgb(vector tuple) { return xyzToRgb(luvToXyz(lchToLuv(tuple))); } vector rgbToLch(vector tuple) { return luvToLch(xyzToLuv(rgbToXyz(tuple))); } vector hsluvToRgb(vector tuple) { return lchToRgb(hsluvToLch(tuple)); } vector rgbToHsluv(vector tuple) { return lchToHsluv(rgbToLch(tuple)); } vector hpluvToRgb(vector tuple) { return lchToRgb(hpluvToLch(tuple)); } vector rgbToHpluv(vector tuple) { return lchToHpluv(rgbToLch(tuple)); } vector luvToRgb(vector tuple){ return xyzToRgb(luvToXyz(tuple)); } /* END HSLUV-LSL */ //Linear interpolator. Credit: Nexii Malthus vector vLin(vector x, vector y, float t) { return x*(1-t) + y*t; } //Colour interpolator controller - Jenna Huntsman vColCtrl(vector O, vector D, float locTime, integer type) { vector fOrigin; //origin in a foreign colour space vector fDest; //dest in a foreign colour space. if(!type) { //Native LSL colour space fOrigin = O; fDest = D; } else if(type == 1) { //XYZ colour space fOrigin = rgbToXyz(O); fDest = rgbToXyz(D); } else if(type == 2) { //LCH (CIELAB) colour space fOrigin = rgbToLch(O); fDest = rgbToLch(D); } else if(type == 3) { //HSLuv colour space fOrigin = rgbToHsluv(O); fDest = rgbToHsluv(D); } else if(type == 4) { //HPLuv colour space fOrigin = rgbToHpluv(O); fDest = rgbToHpluv(D); } //Interpolate the colour! float i; for(; i <= locTime; ++i) { vector curCol; if(!type){ curCol = vLin(fOrigin, fDest, i/time); } else if(type == 1){ curCol = xyzToRgb(vLin(fOrigin,fDest,i/time)); } else if(type == 2){ curCol = lchToRgb(vLin(fOrigin,fDest,i/time)); } else if(type == 3){ curCol = hsluvToRgb(vLin(fOrigin,fDest,i/time)); } else if(type == 4){ curCol = hpluvToRgb(vLin(fOrigin,fDest,i/time)); } llSetLinkPrimitiveParamsFast(LINK_THIS,[PRIM_COLOR,ALL_SIDES,curCol,1]); llSleep(0.033333); //30 fps. } } default { state_entry() { origin = origin/255; dest = dest/255; //convert to LSL colour. vector HSLuv = rgbToHsluv(origin); llSay(0,"Touch me to change my colour!"); } touch_start(integer total_number) { integer type = ColSpace; vector originHSLuv = rgbToXyz(origin); vector destHSLuv = rgbToXyz(dest); float i = 0.0; if(col) { vColCtrl(origin, dest, time, type); } else { vColCtrl(dest, origin, time, type); } col = !col; } }

No worries - the solution I came to was based on a formula I found elsewhere which (presumably) couldn't multiply vectors directly; hence writing it out long form - my brain isn't working very well today

Hey all, My math knowledge has failed me and I need some advice: I need to find a point on a line, with vector A being the line's origin and vector B being it's direction (the line is of infinite length). I need to find the closest point to vector P on the line. How can I do this? I've been looking at these functions (from the LSL wiki) but they're producing garbage numbers: Pulled from :http://wiki.secondlife.com/wiki/Geometric vector gLXdV(vector O,vector D,vector A){ return (O-A)-((O-A)*D)*D;} vector gLXnX(vector O,vector D,vector A){ return gLXdV(O,D,A) + A;} //O = Origin, D = Direction, A = abitrary point. Thanks! In the above example, I need to find C EDIT: Solved it, just needed to take a break vector LinePoint(vector origin, vector dir, vector point) { //This made Jenna sad :C vector dirNorm = (dir-origin)/llVecDist(dir,origin); vector x = point-origin; vector Lp = dirNorm*((x.x*dirNorm.x)+(x.y*dirNorm.y)+(x.z*dirNorm.z)); //offset relative to the origin return Lp+origin; }

Can't speak for any others, but LeLutka has their API on their website: https://lelutkasl.com/cc-manual/

Short answer: No. Rigged mesh items are 'fixed' to their associated bone. You can move the root of the object, but it won't visually move.

I think the crux of the issue is that the question being asked here is too large of a scope to be, in Quistess' words, actionable. I think VirtualKitten needs to go back, look at the script, and come back to us with what is specifically broken. (i.e. My spline generator isn't working at all / isn't producing the expected result; My spline generator needs more data to create a spline; My spline data is garbage when fed to KFM, etc.)

It takes time to create code for things like this - while we're able to help with some issues, others would require a lot more time to solve and thus is unlikely to be solved for free by someone else in it's entirety. The others have linked various resources which might help create the code you're looking for, but if you're wanting someone to code it for you, you may need to create a post in the Wanted forum.

To auto-start something on attach, you'll want to use the attach event. You'll want to verify that the item is being attached, not detached (as the event will fire for both), so you'll need to verify if the key given with the event is valid - so, for example: attach(key id) { if(id) //is id a valid key (object is being attached) { test(); //start running the 'animation' } else { //object is being detached - do something else. } } You can also do a little optimization to that script by combining some of those llSetLinkPrimitiveParamsFast into a single line using PRIM_LINK_TARGET, like so: llSetLinkPrimitiveParamsFast(2, [PRIM_POSITION, <0.00000, -0.00011, -0.02649>*scaleby, PRIM_ROTATION,calcChildRot(<0.00000, 0.00000, -0.44621, 0.89493>), PRIM_SIZE, <0.06172, 0.06172, 0.09056>*scaleby, PRIM_LINK_TARGET, 3, PRIM_POSITION, <0.00030, 0.00020, 0.01624>*scaleby, PRIM_ROTATION,calcChildRot(<0.00000, 0.00000, -0.16505, 0.98629>), PRIM_SIZE, <0.05943, 0.05554, 0.01968>*scaleby]);

Because I'm weird, I actually like using JSON for this, for example: string ColoursJson = "{\"black\":\"<0,0,0>\",\"white\":\"<1,1,1>\",\"violet\":\"<1,1,0.5>\"}"; //Colours in JSON format (key:value), with the key being the colour's name and value being the LSL colour. You can then use the following for you llSetLinkPrimitiveParamsFast string ColourVal = llJsonGetValue(ColoursJson,[llToLower(msg)]); //converts msg to lower case, then tries to search for it in the Json if(ColourVal != JSON_INVALID) //if the colour was found in the Json { llSetLinkPrimitiveParamsFast(LINK_THIS, [ PRIM_SPECULAR, ALL_SIDES, texture, repeats, offsets,rotation_in_radians, (vector)llJsonGetValue(ColoursJson,[llToLower(msg)]) , glossiness,environment ]); } else { llSay(0, "I don't know that colour, " + msg + "!"); //colour wasn't found in the Json }

You're declaring your variables as 'local' variables; i.e. they will only persist and be usable within the same state. You can declare the variables as 'global' by placing them at the top of the script, like so: integer glossiness; //Store the glossiness in a way it's accessible later. list params; //Store this for later. default { state_entry() { llListen(-16135,"",NULL_KEY,""); ///////////////// // [VARIABLES] // ///////////////// //Making a list getting the prim's paramaters params = llGetPrimitiveParams([PRIM_SPECULAR]); //Fetching the glossiness parameter in the list (params, index number) glossiness = llList2Integer(params, 5); } ///////////// // [LOGIC] // ///////////// listen(integer channel, string name, key id, string msg){ if (llGetOwner() == llGetOwnerKey(id)) if (msg == "10%"){ } else if (msg == "20%"){ } } } You can then use llSetLinkPrimitiveParamsFast to change the glossiness of the prim, for example: params = llListReplaceList(params, [255], 5, 5); //Set params to a new glossiness value before feeding it back. llSetLinkPrimitiveParamsFast(LINK_THIS,([PRIM_SPECULAR,ALL_SIDES] + params)); //Set the prim which contains this script to the max specular value. Substitute 255 for the glossiness variable to return to the default. I recycle params in the above example so that I don't need to write out the other required items that we're not changing - I just change the glossiness value.

From what I gather the problem here isn't actually the formula itself; but instead obtaining control points to feed to the formula (as; if the start and end point is random, the control points need to be generated dynamically). Dora's script is a little on the hard-to-read side of things when it comes to this as it seems to be randomized and I can't quite figure out how it's consistently generating the correct control point(s) to create a smooth convex curve - I have my own method; however it unfortunately can generate undesired concave curves (albeit, the math works out but doesn't provide the expected 'natural' curve). I need to sit down at some point to figure out exactly what Dora's script is doing.

Something has gone wrong in this block of code for that to happen: // Check for a valid token integer i; integer found = FALSE; for ( i=0; i<numOverrides; i++ ) { string token = llList2String( tokens, i ); // We have some blank entries in 'tokens' to get it to line up with animState... make // sure we don't match on a blank. if (( token != EMPTY ) && ( llGetSubString( _data, 0, llStringLength(token) - 1 ) == token )) { // We found a token on this line, so we don't have to throw an error or keep // trying to match tokens found = TRUE; You should probably post a copy of the notecard(s) you're trying to read to help debug further.

Those are global coordinates, not region ones (The max values for the X and Y axis of regions is 256), hence why your landing point is unexpected (it's out-of-bounds)

Because you're trying to tell llTeleportAgent to use a landmark asset (inventory item; in your case you're giving gRegionName ) which overrides the region coords you're giving it. Replace the command with something like: llTeleportAgent(teleportee,"",destpos, lookAt); As Qie says, there's another command to send someone to another region entirely (without needing to use an LM)

llSetRegionPos isn't going to help much there. It can go slightly out-of-bounds in order to transfer an object into an adjacent region, but it can't specify an exact location in that region (only somewhere along it's border). You'd need to use llTeleportAgent to specify an exact location to teleport to.

Have a look at the caveats of llSetRegionPos and see if any of these match your object: Teleporting an agent would have to be done either using llMapDestination (which doesn't seem ideal for your use), through a permanent attachment to the avatar via llTeleportAgent (You may find RLV functions useful for this, as RLV can handle receiving the object in inventory and equipping it to the avatar), or via an Experience (again, via llTeleportAgent)

@Monty Linden would be the best person to CC into this topic as he has all the knowledge about how the Scripts Run metric is calculated; but to quote from something he said in the thread that @Odaks linked to: We also know that some pretty major backend work has / is being undertaken recently, including (but not limited to) an OS upgrade serverside, along with some updates to the Mono engine (?), which could be having an affect on the scripts run metric