public string llAvatarOnSitTarget(IScriptInstance script)
{
if (script.Host is LLPrimitive)
{
LLPrimitive prim = (LLPrimitive)script.Host;
if (prim.SitPosition != Vector3.Zero)
{
ILinkable[] children = ((ILinkable)script.Host).GetChildren();
for (int i = 0, len = children.Length; i < len; i++)
{
if (children[i] is LLAgent)
{
LLAgent childAgent = (LLAgent)children[i];
if (childAgent.RelativePosition == LLUtil.GetSitTarget(prim.SitPosition, childAgent.Scale))
return childAgent.ID.ToString();
}
}
}
}
else
{
// TODO: Warning
}
return UUID.Zero.ToString();
}
private void OffsetTexture(IScriptInstance script, LLPrimitive obj, float u, float v, int side)
{
int sides = GetNumberOfSides(obj);
if (side >= 0 && side < sides)
{
// Change one face
Primitive.TextureEntryFace face = obj.Prim.Textures.CreateFace((uint)side);
face.OffsetU = u;
face.OffsetV = v;
obj.Scene.EntityAddOrUpdate(this, obj, 0, (uint)LLUpdateFlags.Textures);
}
else if (side == LSLConstants.ALL_SIDES)
{
// Change all of the faces
for (uint i = 0; i < sides; i++)
{
Primitive.TextureEntryFace face = obj.Prim.Textures.GetFace(i);
if (face != null)
{
face.OffsetU = u;
face.OffsetV = v;
}
}
obj.Scene.EntityAddOrUpdate(this, obj, 0, (uint)LLUpdateFlags.Textures);
}
}
public Vector3 llGetAccel(IScriptInstance script)
{
if (script.Host is IPhysical)
return ((IPhysical)script.Host).Acceleration;
else
return Vector3.Zero;
}
public int llGetInventoryPermMask(IScriptInstance script, string name, int mask)
{
LLPrimitive prim = script.Host as LLPrimitive;
if (prim == null)
return 0;
LLInventoryTaskItem found = prim.Inventory.FindItem(item => item.Name == name);
if (found != null)
{
switch (mask)
{
case LSLConstants.MASK_BASE:
return (int)found.Permissions.BaseMask;
case LSLConstants.MASK_OWNER:
return (int)found.Permissions.OwnerMask;
case LSLConstants.MASK_GROUP:
return (int)found.Permissions.GroupMask;
case LSLConstants.MASK_EVERYONE:
return (int)found.Permissions.EveryoneMask;
case LSLConstants.MASK_NEXT:
return (int)found.Permissions.NextOwnerMask;
}
}
return 0;
}
public int llGetInventoryNumber(IScriptInstance script, int type)
{
LLPrimitive prim = script.Host as LLPrimitive;
if (prim == null)
return 0;
AssetType assetType = (AssetType)type;
return prim.Inventory.FindAllItems(item => assetType == AssetType.Unknown || item.AssetType == assetType).Count;
}
public int llGetPermissions(IScriptInstance script)
{
if (script is LSLScriptInstance)
{
LSLScriptInstance lsl = (LSLScriptInstance)script;
return (int)lsl.Permissions;
}
return 0; // TODO: Warning message
}
public UUID llGetPermissionsKey(IScriptInstance script)
{
if (script is LSLScriptInstance)
{
LSLScriptInstance lsl = (LSLScriptInstance)script;
return lsl.PermissionsKey;
}
return UUID.Zero; // TODO: Warning message
}
public string llGetSubString(IScriptInstance script, string src, int start, int end)
{
if (start < 0)
start = src.Length + start;
if (end < 0)
end = src.Length + end;
// Conventional substring
if (start <= end)
{
// Implies both bounds are out-of-range.
if (end < 0 || start >= src.Length)
return String.Empty;
// If end is positive, then it directly corresponds to the length of the substring needed (plus one of course).
if (end >= src.Length)
end = src.Length - 1;
if (start < 0)
return src.Substring(0, end + 1);
// Both indices are positive
return src.Substring(start, (end + 1) - start);
}
// Inverted substring (end < start)
else
{
// Implies both indices are below the lower bound.
// In the inverted case, that means the entire string will be returned unchanged.
if (start < 0)
return src;
// If both indices are greater than the upper bound the result may seem initially counter intuitive.
if (end >= src.Length)
return src;
if (end < 0)
{
if (start < src.Length)
return src.Substring(start);
return String.Empty;
}
else
{
if (start < src.Length)
return src.Substring(0, end + 1) + src.Substring(start);
return src.Substring(0, end + 1);
}
}
}
public string llDumpList2String(IScriptInstance script, lsl_list src, string separator)
{
int len = src.Length;
string[] arr = new string[len];
for (int i = 0; i < len; i++)
arr[i] = src.Data[i].ToString();
return String.Join(separator, arr);
}
public Quaternion llAxes2Rot(IScriptInstance script, Vector3 fwd, Vector3 left, Vector3 up)
{
float s;
float tr = fwd.X + left.Y + up.Z + 1.0f;
if (tr >= 1.0)
{
s = 0.5f / (float)Math.Sqrt(tr);
return new Quaternion(
(float)((left.Z - up.Y) * s),
(float)((up.X - fwd.Z) * s),
(float)((fwd.Y - left.X) * s),
(float)(0.25 / s));
}
else
{
float max = (left.Y > up.Z) ? left.Y : up.Z;
if (max < fwd.X)
{
s = (float)Math.Sqrt(fwd.X - (left.Y + up.Z) + 1.0f);
float x = s * 0.5f;
s = 0.5f / s;
return new Quaternion(
(float)x,
(float)((fwd.Y + left.X) * s),
(float)((up.X + fwd.Z) * s),
(float)((left.Z - up.Y) * s));
}
else if (max == left.Y)
{
s = (float)Math.Sqrt(left.Y - (up.Z + fwd.X) + 1.0);
float y = s * 0.5f;
s = 0.5f / s;
return new Quaternion(
(float)((fwd.Y + left.X) * s),
(float)y,
(float)((left.Z + up.Y) * s),
(float)((up.X - fwd.Z) * s));
}
else
{
s = (float)Math.Sqrt(up.Z - (fwd.X + left.Y) + 1.0);
float z = s * 0.5f;
s = 0.5f / s;
return new Quaternion(
(float)((up.X + fwd.Z) * s),
(float)((left.Z + up.Y) * s),
(float)z,
(float)((fwd.Y - left.X) * s));
}
}
}
public Quaternion llAxes2Rot(IScriptInstance script, Vector3 fwd, Vector3 left, Vector3 up)
{
double s;
double tr = fwd.X + left.Y + up.Z + 1.0;
if (tr >= 1.0)
{
s = 0.5 / Math.Sqrt(tr);
return new lsl_rotation(
(left.Z - up.Y) * s,
(up.X - fwd.Z) * s,
(fwd.Y - left.X) * s,
0.25 / s);
}
else
{
double max = (left.Y > up.Z) ? left.Y : up.Z;
if (max < fwd.X)
{
s = Math.Sqrt(fwd.X - (left.Y + up.Z) + 1.0);
double x = s * 0.5;
s = 0.5 / s;
return new lsl_rotation(
x,
(fwd.Y + left.X) * s,
(up.X + fwd.Z) * s,
(left.Z - up.Y) * s);
}
else if (max == left.Y)
{
s = Math.Sqrt(left.Y - (up.Z + fwd.X) + 1.0);
double y = s * 0.5;
s = 0.5 / s;
return new lsl_rotation(
(fwd.Y + left.X) * s,
y,
(left.Z + up.Y) * s,
(up.X - fwd.Z) * s);
}
else
{
s = Math.Sqrt(up.Z - (fwd.X + left.Y) + 1.0);
double z = s * 0.5;
s = 0.5 / s;
return new lsl_rotation(
(up.X + fwd.Z) * s,
(left.Z + up.Y) * s,
z,
(fwd.Y - left.X) * s);
}
}
}
public void llPreloadSound(IScriptInstance script, string sound)
{
UUID soundID = KeyOrName(script, sound, AssetType.Sound);
if (soundID == UUID.Zero)
{
script.Host.Scene.EntityChat(this, script.Host, 0f, "Cannot find sound " + sound, Int32.MaxValue, EntityChatType.Debug);
return;
}
if (m_sounds != null)
m_sounds.PreloadSound(script.Host, soundID, DEFAULT_SOUND_RADIUS);
script.AddSleepMS(1000);
}
public string llGetInventoryName(IScriptInstance script, int type, int number)
{
LLPrimitive prim = script.Host as LLPrimitive;
if (prim == null)
return String.Empty;
AssetType assetType = (AssetType)type;
IList<LLInventoryTaskItem> items = prim.Inventory.FindAllItems(item => assetType == AssetType.Unknown || item.AssetType == assetType);
if (items.Count >= number)
return String.Empty;
SortedList<string, LLInventoryTaskItem> sortedItems = new SortedList<string, LLInventoryTaskItem>(items.Count);
for (int i = 0; i < items.Count; i++)
sortedItems.Add(items[i].Name, items[i]);
return sortedItems.Values[number].Name;
}
public void llRequestPermissions(IScriptInstance script, UUID agentID, int perms)
{
if (script is LSLScriptInstance)
{
LSLScriptInstance lsl = (LSLScriptInstance)script;
if (agentID != lsl.PermissionsKey)
lsl.Permissions = ScriptPermission.None;
// TODO: Send script permission dialog to the user
//script.Host.Scene.RequestScriptPermissions(this, script.Host, agentID, perms);
// HACK: Automatically grant permissions and fire event, since we don't have a permission dialog yet
lsl.PermissionsKey = agentID;
lsl.Permissions = (ScriptPermission)perms;
m_lslScriptEngine.PostObjectEvent(script.Host.ID, "run_time_permissions", new object[] { perms }, new DetectParams[0]);
}
}
public string llBase64ToString(IScriptInstance script, string str)
{
try
{
Decoder utf8Decode = UTF8Encoding.UTF8.GetDecoder();
byte[] data = Convert.FromBase64String(str);
int charCount = utf8Decode.GetCharCount(data, 0, data.Length);
char[] chars = new char[charCount];
utf8Decode.GetChars(data, 0, data.Length, chars, 0);
return new String(chars);
}
catch (Exception e)
{
throw new Exception("Error in base64Decode" + e.Message);
}
}
public string llDeleteSubString(IScriptInstance script, string src, int start, int end)
{
if (start < 0)
start = src.Length + start;
if (end < 0)
end = src.Length + end;
if (start <= end)
{
if (end < 0 || start >= src.Length)
return src;
if (start < 0)
start = 0;
if (end >= src.Length)
end = src.Length - 1;
return src.Remove(start, end - start + 1);
}
else
{
if (start < 0 || end >= src.Length)
return String.Empty;
if (end > 0)
{
if (start < src.Length)
return src.Remove(start).Remove(0, end + 1);
else
return src.Remove(0, end + 1);
}
else
{
if (start < src.Length)
return src.Remove(start);
else
return src;
}
}
}
public void llLoopSound(IScriptInstance script, string sound, float volume)
{
LLPrimitive prim = script.Host as LLPrimitive;
if (prim == null)
return;
if (prim.Prim.Sound != UUID.Zero)
llStopSound(script);
UUID soundID = KeyOrName(script, sound, AssetType.Sound);
if (soundID != UUID.Zero)
{
prim.Prim.Sound = soundID;
prim.Prim.SoundGain = Utils.Clamp(volume, 0f, 1f);
prim.Prim.SoundFlags = SoundFlags.Loop;
prim.Prim.SoundRadius = DEFAULT_SOUND_RADIUS;
prim.Scene.EntityAddOrUpdate(this, prim, 0, (uint)LLUpdateFlags.Sound);
}
}
public object[] llCSV2List(IScriptInstance script, string csv)
{
List<object> result = new List<object>();
int parens = 0;
int start = 0;
int length = 0;
for (int i = 0; i < csv.Length; i++)
{
switch (csv[i])
{
case '<':
parens++;
length++;
break;
case '>':
if (parens > 0)
parens--;
length++;
break;
case ',':
if (parens == 0)
{
result.Add(csv.Substring(start, length).Trim());
start += length + 1;
length = 0;
}
else
{
length++;
}
break;
default:
length++;
break;
}
}
result.Add(csv.Substring(start, length).Trim());
return result.ToArray();
}
public string llBase64ToString(IScriptInstance script, string str)
{
System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding();
System.Text.Decoder utf8Decode = encoder.GetDecoder();
string result = String.Empty;
try
{
byte[] todecode_byte = Convert.FromBase64String(str);
int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
char[] decoded_char = new char[charCount];
utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
result = new String(decoded_char);
}
catch (Exception e)
{
throw new Exception("Error in base64Decode" + e.Message);
}
return result;
}
public double llGround(IScriptInstance script, Vector3 offset)
{
Vector3 pos = script.Host.ScenePosition + offset;
// Clamp to valid position
pos.X = Utils.Clamp(pos.X, 0f, 255f);
pos.Y = Utils.Clamp(pos.Y, 0f, 255f);
//Get the slope normal. This gives us the equation of the plane tangent to the slope.
Vector3 normal = llGroundNormal(script, offset);
// Get the height for the integer coordinates from the Heightmap
float baseheight = (m_terrain != null)
? m_terrain.GetHeightmap()[(int)pos.Y * 256 + (int)pos.X]
: 0f;
// Calculate the difference between the actual coordinates and the integer coordinates
double xdiff = pos.X - Math.Floor(pos.X);
double ydiff = pos.Y - Math.Floor(pos.Y);
// Use the equation of the tangent plane to adjust the height to account for slope
return (((normal.X * xdiff) + (normal.Y * ydiff)) / (normal.Z * -1f)) + baseheight;
}
public double llVecDist(IScriptInstance script, Vector3 vec_a, Vector3 vec_b)
{
return Vector3.Distance(vec_a, vec_b);
}
public Quaternion llRotBetween(IScriptInstance script, Vector3 start, Vector3 end)
{
start = lsl_vector.Norm(start);
end = lsl_vector.Norm(end);
double dotProduct = lsl_vector.Dot(start, end);
lsl_vector crossProduct = lsl_vector.Cross(start, end);
double magProduct = lsl_vector.Mag(start) * lsl_vector.Mag(end);
double angle = Math.Acos(dotProduct / magProduct);
lsl_vector axis = lsl_vector.Norm(crossProduct);
double s = Math.Sin(angle / 2);
double x = axis.x * s;
double y = axis.y * s;
double z = axis.z * s;
double w = Math.Cos(angle / 2);
if (Double.IsNaN(x) || Double.IsNaN(y) || Double.IsNaN(z) || Double.IsNaN(w))
return Quaternion.Identity;
return new lsl_rotation(x, y, z, w);
}
public double llSqrt(IScriptInstance script, double val)
{
return Math.Sqrt(val);
}
public Vector3 llRot2Up(IScriptInstance script, Quaternion q)
{
return(llVecNorm(script, Vector3.UnitZ * q));
}
public float llVecDist(IScriptInstance script, Vector3 vec_a, Vector3 vec_b)
{
return(Vector3.Distance(vec_a, vec_b));
}
public float llVecMag(IScriptInstance script, Vector3 vec)
{
return(vec.Length());
}
private void SetPrimType(IScriptInstance script, object[] rules, ref int i)
{
LLPrimitive prim = script.Host as LLPrimitive;
if (prim == null)
{
return;
}
int code = llList2Integer(script, rules, i++);
switch (code)
{
case LSLConstants.PRIM_TYPE_BOX:
{
int holeShape = llList2Integer(script, rules, i++);
Vector3 cut = llList2Vector(script, rules, i++);
float hollow = llList2Float(script, rules, i++);
Vector3 twist = llList2Vector(script, rules, i++);
Vector3 topSize = llList2Vector(script, rules, i++);
Vector3 topShear = llList2Vector(script, rules, i++);
Primitive.ConstructionData primData = ObjectManager.BuildBasicShape(PrimType.Box);
primData.Material = prim.Prim.PrimData.Material;
primData.State = prim.Prim.PrimData.State;
prim.Prim.PrimData = primData;
prim.Prim.Sculpt = null;
SetPrimShapeParams(prim, holeShape, cut, hollow, twist, topSize, topShear);
break;
}
case LSLConstants.PRIM_TYPE_CYLINDER:
{
int holeShape = llList2Integer(script, rules, i++);
Vector3 cut = llList2Vector(script, rules, i++);
float hollow = llList2Float(script, rules, i++);
Vector3 twist = llList2Vector(script, rules, i++);
Vector3 topSize = llList2Vector(script, rules, i++);
Vector3 topShear = llList2Vector(script, rules, i++);
Primitive.ConstructionData primData = ObjectManager.BuildBasicShape(PrimType.Cylinder);
primData.Material = prim.Prim.PrimData.Material;
primData.State = prim.Prim.PrimData.State;
prim.Prim.PrimData = primData;
prim.Prim.Sculpt = null;
SetPrimShapeParams(prim, holeShape, cut, hollow, twist, topSize, topShear);
break;
}
case LSLConstants.PRIM_TYPE_PRISM:
{
int holeShape = llList2Integer(script, rules, i++);
Vector3 cut = llList2Vector(script, rules, i++);
float hollow = llList2Float(script, rules, i++);
Vector3 twist = llList2Vector(script, rules, i++);
Vector3 topSize = llList2Vector(script, rules, i++);
Vector3 topShear = llList2Vector(script, rules, i++);
Primitive.ConstructionData primData = ObjectManager.BuildBasicShape(PrimType.Prism);
primData.Material = prim.Prim.PrimData.Material;
primData.State = prim.Prim.PrimData.State;
prim.Prim.PrimData = primData;
prim.Prim.Sculpt = null;
SetPrimShapeParams(prim, holeShape, cut, hollow, twist, topSize, topShear);
break;
}
case LSLConstants.PRIM_TYPE_SPHERE:
{
int holeShape = llList2Integer(script, rules, i++);
Vector3 cut = llList2Vector(script, rules, i++);
float hollow = llList2Float(script, rules, i++);
Vector3 twist = llList2Vector(script, rules, i++);
Vector3 dimple = llList2Vector(script, rules, i++);
Primitive.ConstructionData primData = ObjectManager.BuildBasicShape(PrimType.Sphere);
primData.Material = prim.Prim.PrimData.Material;
primData.State = prim.Prim.PrimData.State;
prim.Prim.PrimData = primData;
prim.Prim.Sculpt = null;
SetPrimShapeParams(prim, holeShape, cut, hollow, twist, dimple);
break;
}
case LSLConstants.PRIM_TYPE_TORUS:
{
int holeShape = llList2Integer(script, rules, i++);
Vector3 cut = llList2Vector(script, rules, i++);
float hollow = llList2Float(script, rules, i++);
Vector3 twist = llList2Vector(script, rules, i++);
Vector3 topSize = llList2Vector(script, rules, i++);
Vector3 topShear = llList2Vector(script, rules, i++);
Vector3 advCut = llList2Vector(script, rules, i++);
Vector3 taper = llList2Vector(script, rules, i++);
float revolutions = llList2Float(script, rules, i++);
float radiusOffset = llList2Float(script, rules, i++);
float skew = llList2Float(script, rules, i++);
Primitive.ConstructionData primData = ObjectManager.BuildBasicShape(PrimType.Torus);
primData.Material = prim.Prim.PrimData.Material;
primData.State = prim.Prim.PrimData.State;
prim.Prim.PrimData = primData;
prim.Prim.Sculpt = null;
SetPrimShapeParams(prim, holeShape, cut, hollow, twist, topSize, topShear, advCut, taper, revolutions, radiusOffset, skew);
break;
}
case LSLConstants.PRIM_TYPE_TUBE:
{
int holeShape = llList2Integer(script, rules, i++);
Vector3 cut = llList2Vector(script, rules, i++);
float hollow = llList2Float(script, rules, i++);
Vector3 twist = llList2Vector(script, rules, i++);
Vector3 topSize = llList2Vector(script, rules, i++);
Vector3 topShear = llList2Vector(script, rules, i++);
Vector3 advCut = llList2Vector(script, rules, i++);
Vector3 taper = llList2Vector(script, rules, i++);
float revolutions = llList2Float(script, rules, i++);
float radiusOffset = llList2Float(script, rules, i++);
float skew = llList2Float(script, rules, i++);
Primitive.ConstructionData primData = ObjectManager.BuildBasicShape(PrimType.Tube);
primData.Material = prim.Prim.PrimData.Material;
primData.State = prim.Prim.PrimData.State;
prim.Prim.PrimData = primData;
prim.Prim.Sculpt = null;
SetPrimShapeParams(prim, holeShape, cut, hollow, twist, topSize, topShear, advCut, taper, revolutions, radiusOffset, skew);
break;
}
case LSLConstants.PRIM_TYPE_RING:
{
int holeShape = llList2Integer(script, rules, i++);
Vector3 cut = llList2Vector(script, rules, i++);
float hollow = llList2Float(script, rules, i++);
Vector3 twist = llList2Vector(script, rules, i++);
Vector3 topSize = llList2Vector(script, rules, i++);
Vector3 topShear = llList2Vector(script, rules, i++);
Vector3 advCut = llList2Vector(script, rules, i++);
Vector3 taper = llList2Vector(script, rules, i++);
float revolutions = llList2Float(script, rules, i++);
float radiusOffset = llList2Float(script, rules, i++);
float skew = llList2Float(script, rules, i++);
Primitive.ConstructionData primData = ObjectManager.BuildBasicShape(PrimType.Ring);
primData.Material = prim.Prim.PrimData.Material;
primData.State = prim.Prim.PrimData.State;
prim.Prim.PrimData = primData;
prim.Prim.Sculpt = null;
SetPrimShapeParams(prim, holeShape, cut, hollow, twist, topSize, topShear, advCut, taper, revolutions, radiusOffset, skew);
break;
}
case LSLConstants.PRIM_TYPE_SCULPT:
{
string sculptMap = llList2String(script, rules, i++);
SculptType type = (SculptType)llList2Integer(script, rules, i++);
UUID textureID = InventoryKey(script, sculptMap, AssetType.Texture);
if (textureID == UUID.Zero)
{
return;
}
Primitive.ConstructionData primData = ObjectManager.BuildBasicShape(PrimType.Sculpt);
primData.Material = prim.Prim.PrimData.Material;
primData.State = prim.Prim.PrimData.State;
Primitive.SculptData sculpt = new Primitive.SculptData();
sculpt.Type = type;
sculpt.SculptTexture = textureID;
prim.Prim.PrimData = primData;
prim.Prim.Sculpt = sculpt;
break;
}
}
}
public int llAbs(IScriptInstance script, int val)
{
return(Math.Abs(val));
}
public float llFabs(IScriptInstance script, float val)
{
return(Math.Abs(val));
}
public float llSqrt(IScriptInstance script, float val)
{
return((float)Math.Sqrt(val));
}
public float llPow(IScriptInstance script, float base_, float exponent)
{
return((float)Math.Pow(base_, exponent));
}
public float llAtan2(IScriptInstance script, float y, float x)
{
return((float)Math.Atan2(y, x));
}
public float llTan(IScriptInstance script, float theta)
{
return((float)Math.Tan(theta));
}
public float llCos(IScriptInstance script, float theta)
{
return((float)Math.Cos(theta));
}
public Vector3 llVecNorm(IScriptInstance script, Vector3 vec)
{
// NOTE: Emulates behavior reported in https://jira.secondlife.com/browse/SVC-4711
double mag = vec.Length();
return (mag != 0.0d) ? vec / (float)mag : Vector3.Zero;
}
public void llRezObject(IScriptInstance script, string inventory, Vector3 position, Vector3 vel, Quaternion rot, int param)
{
RezObject(script, inventory, position, vel, rot, param, false);
}
public double llAtan2(IScriptInstance script, double y, double x)
{
return Math.Atan2(y, x);
}
public void llSetStatus(IScriptInstance script, int flags, int enabledInt)
{
SetStatus(script.Host, flags, enabledInt);
}
public void llSetPrimitiveParams(IScriptInstance script, object[] rules)
{
script.AddSleepMS(200);
SetPrimParams(script, script.Host, rules);
}
public void llSetLocalRot(IScriptInstance script, Quaternion rot)
{
script.Host.RelativeRotation = rot;
script.Host.Scene.EntityAddOrUpdate(this, script.Host, UpdateFlags.Rotation, 0);
script.AddSleepMS(200);
}
public float llCeil(IScriptInstance script, float val)
{
return((float)Math.Ceiling(val));
}
public Quaternion llEuler2Rot(IScriptInstance script, Vector3 v)
{
return(Quaternion.CreateFromEulers(v));
}
public void llSetText(IScriptInstance script, string text, Vector3 color, float alpha)
{
SetText(script.Host, text, color, alpha);
script.AddSleepMS(200);
}
public void llOwnerSay(IScriptInstance script, string text)
{
Say(script, 0f, text, 0, EntityChatType.Owner);
}
public UUID llGetKey(IScriptInstance script)
{
return(script.Host.ID);
}
public Vector3 llWind(IScriptInstance script, Vector3 offset)
{
return(Vector3.Zero); // TODO: Wind?
}
public void llSetScale(IScriptInstance script, Vector3 scale)
{
SetScale(script.Host, scale);
script.AddSleepMS(200);
}
public Vector3 llGroundContour(IScriptInstance script, Vector3 offset)
{
Vector3 slope = llGroundSlope(script, offset);
return(new Vector3(-slope.Y, slope.X, 0f));
}
public Vector3 llRot2Up(IScriptInstance script, Quaternion q)
{
return llVecNorm(script, Vector3.UnitZ * q);
}
public string llGetDate(IScriptInstance script)
{
DateTime now = DateTime.Now;
return(String.Format("{0}-{1}-{2}", now.Year, now.Month, now.Date));
}
public double llRound(IScriptInstance script, double val)
{
return Math.Round(val);
}
public float llFloor(IScriptInstance script, float val)
{
return((float)Math.Floor(val));
}
public double llTan(IScriptInstance script, double theta)
{
return Math.Tan(theta);
}
public float llFrand(IScriptInstance script, float mag)
{
return((float)Utils.RandomDouble() * (mag - Single.Epsilon));
}
public double llVecMag(IScriptInstance script, Vector3 vec)
{
return vec.Length();
}
public void OnRemoveScript(uint localID, UUID itemID)
{
lock (m_Scripts)
{
// Do we even have it?
if (!m_Scripts.ContainsKey(itemID))
{
return;
}
IScriptInstance instance = m_Scripts[itemID];
m_Scripts.Remove(itemID);
instance.ClearQueue();
instance.Stop(0);
SceneObjectPart part =
m_Scene.GetSceneObjectPart(localID);
if (part != null)
{
part.RemoveScriptEvents(itemID);
}
// bool objectRemoved = false;
lock (m_PrimObjects)
{
// Remove the script from it's prim
if (m_PrimObjects.ContainsKey(localID))
{
// Remove inventory item record
if (m_PrimObjects[localID].Contains(itemID))
{
m_PrimObjects[localID].Remove(itemID);
}
// If there are no more scripts, remove prim
if (m_PrimObjects[localID].Count == 0)
{
m_PrimObjects.Remove(localID);
// objectRemoved = true;
}
}
}
m_DomainScripts[instance.AppDomain].Remove(instance.ItemID);
if (m_DomainScripts[instance.AppDomain].Count == 0)
{
m_DomainScripts.Remove(instance.AppDomain);
UnloadAppDomain(instance.AppDomain);
}
instance.RemoveState();
instance.DestroyScriptInstance();
instance = null;
ObjectRemoved handlerObjectRemoved = OnObjectRemoved;
if (handlerObjectRemoved != null)
{
handlerObjectRemoved(part.UUID);
}
CleanAssemblies();
}
ScriptRemoved handlerScriptRemoved = OnScriptRemoved;
if (handlerScriptRemoved != null)
{
handlerScriptRemoved(itemID);
}
}
public int llAbs(IScriptInstance script, int val)
{
return Math.Abs(val);
}
private void SetPrimParams(IScriptInstance script, ISceneEntity entity, object[] rules)
{
LLPrimitive prim = entity as LLPrimitive;
if (prim == null)
{
return;
}
bool changedShape = false, changedColor = false, changedTexture = false;
int i = 0;
while (i < rules.Length)
{
int code = llList2Integer(script, rules, i++);
switch (code)
{
case LSLConstants.PRIM_NAME:
{
SetObjectName(prim, llList2String(script, rules, i++));
break;
}
case LSLConstants.PRIM_DESC:
{
SetObjectDesc(prim, llList2String(script, rules, i++));
break;
}
case LSLConstants.PRIM_TYPE:
{
SetPrimType(script, rules, ref i);
prim.Scene.EntityAddOrUpdate(this, prim, UpdateFlags.Shape, 0);
changedShape = true;
break;
}
case LSLConstants.PRIM_MATERIAL:
{
prim.Prim.PrimData.Material = (Material)llList2Integer(script, rules, i++);
prim.Scene.EntityAddOrUpdate(this, prim, 0, (uint)LLUpdateFlags.Material);
break;
}
case LSLConstants.PRIM_PHYSICS:
{
SetStatus(prim, LSLConstants.STATUS_PHYSICS, llList2Integer(script, rules, i++));
break;
}
case LSLConstants.PRIM_TEMP_ON_REZ:
{
bool tempOnRez = (llList2Integer(script, rules, i++) != 0);
LLPrimitive parent = GetRootEntity(prim) as LLPrimitive;
if (parent != null)
{
if (tempOnRez)
{
parent.Prim.Flags |= PrimFlags.TemporaryOnRez;
}
else
{
parent.Prim.Flags &= ~PrimFlags.TemporaryOnRez;
}
parent.Scene.EntityAddOrUpdate(this, parent, 0, (uint)LLUpdateFlags.PrimFlags);
}
break;
}
case LSLConstants.PRIM_PHANTOM:
{
SetStatus(prim, LSLConstants.STATUS_PHANTOM, llList2Integer(script, rules, i++));
break;
}
case LSLConstants.PRIM_POSITION:
{
SetPos(prim, llList2Vector(script, rules, i++));
break;
}
case LSLConstants.PRIM_ROTATION:
{
SetRot(prim, llList2Rot(script, rules, i++));
break;
}
case LSLConstants.PRIM_SIZE:
{
SetScale(prim, llList2Vector(script, rules, i++));
break;
}
case LSLConstants.PRIM_TEXTURE:
{
int face = llList2Integer(script, rules, i++);
string texture = llList2String(script, rules, i++);
Vector3 repeats = llList2Vector(script, rules, i++);
Vector3 offsets = llList2Vector(script, rules, i++);
float rotRadians = llList2Float(script, rules, i++);
SetTexture(script, prim, texture, face);
ScaleTexture(script, prim, repeats.X, repeats.Y, face);
OffsetTexture(script, prim, offsets.X, offsets.Y, face);
RotateTexture(script, prim, rotRadians, face);
changedTexture = true;
break;
}
case LSLConstants.PRIM_TEXT:
{
string text = llList2String(script, rules, i++);
Vector3 color = llList2Vector(script, rules, i++);
float alpha = llList2Float(script, rules, i++);
SetText(prim, text, color, alpha);
break;
}
case LSLConstants.PRIM_COLOR:
{
int face = llList2Integer(script, rules, i++);
Vector3 color = llList2Vector(script, rules, i++);
float alpha = llList2Float(script, rules, i++);
SetColor(prim, color, face);
SetAlpha(prim, alpha, face);
changedColor = true;
break;
}
case LSLConstants.PRIM_BUMP_SHINY:
{
int face = llList2Integer(script, rules, i++);
Shininess shiny = (Shininess)llList2Integer(script, rules, i++);
Bumpiness bump = (Bumpiness)llList2Integer(script, rules, i++);
SetShinyBump(prim, shiny, bump, face);
changedTexture = true;
break;
}
case LSLConstants.PRIM_POINT_LIGHT:
{
bool enabled = (llList2Integer(script, rules, i++) != 0);
Vector3 color = llList2Vector(script, rules, i++);
float intensity = llList2Float(script, rules, i++);
float radius = llList2Float(script, rules, i++);
float falloff = llList2Float(script, rules, i++);
if (enabled)
{
Primitive.LightData light = new Primitive.LightData();
light.Color = new Color4(
Utils.Clamp(color.X, 0f, 1f),
Utils.Clamp(color.Y, 0f, 1f),
Utils.Clamp(color.Z, 0f, 1f),
1f);
light.Intensity = intensity;
light.Radius = radius;
light.Falloff = falloff;
prim.Prim.Light = light;
}
else
{
prim.Prim.Light = null;
}
prim.Scene.EntityAddOrUpdate(this, prim, 0, (uint)LLUpdateFlags.ExtraData);
break;
}
case LSLConstants.PRIM_FULLBRIGHT:
{
int face = llList2Integer(script, rules, i++);
bool fullbright = (llList2Integer(script, rules, i++) != 0);
SetFullbright(prim, fullbright, face);
changedTexture = true;
break;
}
case LSLConstants.PRIM_FLEXIBLE:
{
bool enabled = (llList2Integer(script, rules, i++) != 0);
int softness = llList2Integer(script, rules, i++);
float gravity = llList2Float(script, rules, i++);
float friction = llList2Float(script, rules, i++);
float wind = llList2Float(script, rules, i++);
float tension = llList2Float(script, rules, i++);
Vector3 force = llList2Vector(script, rules, i++);
if (enabled)
{
Primitive.FlexibleData flex = new Primitive.FlexibleData();
flex.Softness = softness;
flex.Gravity = gravity;
flex.Drag = friction;
flex.Wind = wind;
flex.Tension = tension;
flex.Force = force;
prim.Prim.Flexible = flex;
}
else
{
prim.Prim.Flexible = null;
}
prim.Scene.EntityAddOrUpdate(this, prim, 0, (uint)LLUpdateFlags.ExtraData);
break;
}
case LSLConstants.PRIM_TEXGEN:
{
int face = llList2Integer(script, rules, i++);
MappingType texgen = (MappingType)llList2Integer(script, rules, i++);
SetTexgen(prim, texgen, face);
changedTexture = true;
break;
}
case LSLConstants.PRIM_GLOW:
{
int face = llList2Integer(script, rules, i++);
float intensity = llList2Float(script, rules, i++);
SetGlow(prim, intensity, face);
changedTexture = true;
break;
}
}
}
if (m_lslScriptEngine != null)
{
if (changedShape)
{
m_lslScriptEngine.PostObjectEvent(prim.ID, "changed", new object[] { LSLConstants.CHANGED_SHAPE }, null);
}
if (changedTexture)
{
m_lslScriptEngine.PostObjectEvent(prim.ID, "changed", new object[] { LSLConstants.CHANGED_TEXTURE }, null);
}
if (changedColor)
{
m_lslScriptEngine.PostObjectEvent(prim.ID, "changed", new object[] { LSLConstants.CHANGED_COLOR }, null);
}
}
}
public void llShout(IScriptInstance script, int channelID, string text)
{
Say(script, Chat.SHOUT_DIST, text, channelID, EntityChatType.Normal);
}
public float llRound(IScriptInstance script, float val)
{
return((float)Math.Round(val));
}