6475 lines
220 KiB
C#
6475 lines
220 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSim Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.Remoting.Lifetime;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using Axiom.Math;
|
|
using libsecondlife;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Region.Environment;
|
|
using OpenSim.Region.Environment.Interfaces;
|
|
using OpenSim.Region.Environment.Modules.Avatar.Currency.SampleMoney;
|
|
using OpenSim.Region.Environment.Modules.World.Land;
|
|
using OpenSim.Region.Environment.Scenes;
|
|
using OpenSim.Region.ScriptEngine.XEngine;
|
|
using OpenSim.Region.ScriptEngine.XEngine.Script;
|
|
|
|
|
|
namespace OpenSim.Region.ScriptEngine.XEngine
|
|
{
|
|
/// <summary>
|
|
/// Contains all LSL ll-functions. This class will be in Default AppDomain.
|
|
/// </summary>
|
|
public class LSL_ScriptCommands : MarshalByRefObject, ILSL_ScriptCommands
|
|
{
|
|
// private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
internal XEngine m_ScriptEngine;
|
|
internal XScriptInstance m_Instance;
|
|
internal SceneObjectPart m_host;
|
|
internal uint m_localID;
|
|
internal LLUUID m_itemID;
|
|
internal bool throwErrorOnNotImplemented = true;
|
|
|
|
public LSL_ScriptCommands(XEngine ScriptEngine, XScriptInstance instance, SceneObjectPart host, uint localID, LLUUID itemID)
|
|
{
|
|
m_ScriptEngine = ScriptEngine;
|
|
m_Instance = instance;
|
|
m_host = host;
|
|
m_localID = localID;
|
|
m_itemID = itemID;
|
|
|
|
//m_log.Info(ScriptEngineName, "LSL_BaseClass.Start() called. Hosted by [" + m_host.Name + ":" + m_host.UUID + "@" + m_host.AbsolutePosition + "]");
|
|
}
|
|
|
|
private DateTime m_timer = DateTime.Now;
|
|
private string m_state = "default";
|
|
private bool m_waitingForScriptAnswer=false;
|
|
|
|
|
|
public string State
|
|
{
|
|
get { return m_Instance.State; }
|
|
set { m_Instance.State = value; }
|
|
}
|
|
|
|
public void state(string newState)
|
|
{
|
|
m_Instance.SetState(newState);
|
|
}
|
|
|
|
// Object never expires
|
|
public override Object InitializeLifetimeService()
|
|
{
|
|
//Console.WriteLine("LSL_BuiltIn_Commands: InitializeLifetimeService()");
|
|
// return null;
|
|
ILease lease = (ILease)base.InitializeLifetimeService();
|
|
|
|
if (lease.CurrentState == LeaseState.Initial)
|
|
{
|
|
lease.InitialLeaseTime = TimeSpan.Zero; // TimeSpan.FromMinutes(1);
|
|
// lease.SponsorshipTimeout = TimeSpan.FromMinutes(2);
|
|
// lease.RenewOnCallTime = TimeSpan.FromSeconds(2);
|
|
}
|
|
return lease;
|
|
}
|
|
|
|
public Scene World
|
|
{
|
|
get { return m_ScriptEngine.World; }
|
|
}
|
|
|
|
public void llSay(int channelID, string text)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if(text.Length > 1023)
|
|
text=text.Substring(0, 1023);
|
|
|
|
World.SimChat(Helpers.StringToField(text),
|
|
ChatTypeEnum.Say, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false);
|
|
|
|
IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
|
|
wComm.DeliverMessage(ChatTypeEnum.Say, channelID, m_host.Name, m_host.UUID, text);
|
|
}
|
|
|
|
// Extension commands use this:
|
|
public ICommander GetCommander(string name)
|
|
{
|
|
return World.GetCommander(name);
|
|
}
|
|
|
|
private LLUUID InventorySelf()
|
|
{
|
|
LLUUID invItemID=new LLUUID();
|
|
|
|
foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
|
|
{
|
|
if (inv.Value.Type == 10 && inv.Value.ItemID == m_itemID)
|
|
{
|
|
invItemID=inv.Key;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return invItemID;
|
|
}
|
|
|
|
private LLUUID InventoryKey(string name, int type)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
|
|
{
|
|
if (inv.Value.Name == name)
|
|
{
|
|
if (inv.Value.Type != type)
|
|
return LLUUID.Zero;
|
|
|
|
return inv.Value.AssetID.ToString();
|
|
}
|
|
}
|
|
return LLUUID.Zero;
|
|
}
|
|
|
|
private LLUUID InventoryKey(string name)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
|
|
{
|
|
if (inv.Value.Name == name)
|
|
{
|
|
return inv.Value.AssetID.ToString();
|
|
}
|
|
}
|
|
return LLUUID.Zero;
|
|
}
|
|
|
|
public void osSetRegionWaterHeight(double height)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
//Check to make sure that the script's owner is the estate manager/master
|
|
//World.Permissions.GenericEstatePermission(
|
|
if (World.ExternalChecks.ExternalChecksCanBeGodLike(m_host.OwnerID))
|
|
{
|
|
World.EventManager.TriggerRequestChangeWaterHeight((float)height);
|
|
}
|
|
}
|
|
|
|
//These are the implementations of the various ll-functions used by the LSL scripts.
|
|
//starting out, we use the System.Math library for trig functions. - ckrinke 8-14-07
|
|
public double llSin(double f)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (double)Math.Sin(f);
|
|
}
|
|
|
|
public double llCos(double f)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (double)Math.Cos(f);
|
|
}
|
|
|
|
public double llTan(double f)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (double)Math.Tan(f);
|
|
}
|
|
|
|
public double llAtan2(double x, double y)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (double)Math.Atan2(y, x);
|
|
}
|
|
|
|
public double llSqrt(double f)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (double)Math.Sqrt(f);
|
|
}
|
|
|
|
public double llPow(double fbase, double fexponent)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (double)Math.Pow(fbase, fexponent);
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llAbs(int i)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (int)Math.Abs(i);
|
|
}
|
|
|
|
public double llFabs(double f)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (double)Math.Abs(f);
|
|
}
|
|
|
|
public double llFrand(double mag)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
lock (Util.RandomClass)
|
|
{
|
|
return Util.RandomClass.NextDouble() * mag;
|
|
}
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llFloor(double f)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (int)Math.Floor(f);
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llCeil(double f)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (int)Math.Ceiling(f);
|
|
}
|
|
|
|
// Xantor 01/May/2008 fixed midpointrounding (2.5 becomes 3.0 instead of 2.0, default = ToEven)
|
|
public LSL_Types.LSLInteger llRound(double f)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (int)Math.Round(f, MidpointRounding.AwayFromZero);
|
|
}
|
|
|
|
//This next group are vector operations involving squaring and square root. ckrinke
|
|
public double llVecMag(LSL_Types.Vector3 v)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return LSL_Types.Vector3.Mag(v);
|
|
}
|
|
|
|
public LSL_Types.Vector3 llVecNorm(LSL_Types.Vector3 v)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
double mag = LSL_Types.Vector3.Mag(v);
|
|
LSL_Types.Vector3 nor = new LSL_Types.Vector3();
|
|
nor.x = v.x / mag;
|
|
nor.y = v.y / mag;
|
|
nor.z = v.z / mag;
|
|
return nor;
|
|
}
|
|
|
|
public double llVecDist(LSL_Types.Vector3 a, LSL_Types.Vector3 b)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
double dx = a.x - b.x;
|
|
double dy = a.y - b.y;
|
|
double dz = a.z - b.z;
|
|
return Math.Sqrt(dx * dx + dy * dy + dz * dz);
|
|
}
|
|
|
|
//Now we start getting into quaternions which means sin/cos, matrices and vectors. ckrinke
|
|
|
|
// Utility function for llRot2Euler
|
|
|
|
// normalize an angle between 0 - 2*PI (0 and 360 degrees)
|
|
private double NormalizeAngle(double angle)
|
|
{
|
|
angle = angle % (Math.PI * 2);
|
|
if (angle < 0) angle = angle + Math.PI * 2;
|
|
return angle;
|
|
}
|
|
|
|
|
|
// Old implementation of llRot2Euler, now normalized
|
|
|
|
public LSL_Types.Vector3 llRot2Euler(LSL_Types.Quaternion r)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
//This implementation is from http://lslwiki.net/lslwiki/wakka.php?wakka=LibraryRotationFunctions. ckrinke
|
|
LSL_Types.Quaternion t = new LSL_Types.Quaternion(r.x * r.x, r.y * r.y, r.z * r.z, r.s * r.s);
|
|
double m = (t.x + t.y + t.z + t.s);
|
|
if (m == 0) return new LSL_Types.Vector3();
|
|
double n = 2 * (r.y * r.s + r.x * r.z);
|
|
double p = m * m - n * n;
|
|
if (p > 0)
|
|
return new LSL_Types.Vector3(NormalizeAngle(Math.Atan2(2.0 * (r.x * r.s - r.y * r.z), (-t.x - t.y + t.z + t.s))),
|
|
NormalizeAngle(Math.Atan2(n, Math.Sqrt(p))),
|
|
NormalizeAngle(Math.Atan2(2.0 * (r.z * r.s - r.x * r.y), (t.x - t.y - t.z + t.s))));
|
|
else if (n > 0)
|
|
return new LSL_Types.Vector3(0.0, Math.PI / 2, NormalizeAngle(Math.Atan2((r.z * r.s + r.x * r.y), 0.5 - t.x - t.z)));
|
|
else
|
|
return new LSL_Types.Vector3(0.0, -Math.PI / 2, NormalizeAngle(Math.Atan2((r.z * r.s + r.x * r.y), 0.5 - t.x - t.z)));
|
|
}
|
|
|
|
|
|
// Xantor's newer llEuler2Rot() *try the second* inverted quaternions (-x,-y,-z,w) as LL seems to like
|
|
// New and improved, now actually works as described. Prim rotates as expected as does llRot2Euler.
|
|
|
|
/* From wiki:
|
|
The Euler angle vector (in radians) is converted to a rotation by doing the rotations around the 3 axes
|
|
in Z, Y, X order. So llEuler2Rot(<1.0, 2.0, 3.0> * DEG_TO_RAD) generates a rotation by taking the zero rotation,
|
|
a vector pointing along the X axis, first rotating it 3 degrees around the global Z axis, then rotating the resulting
|
|
vector 2 degrees around the global Y axis, and finally rotating that 1 degree around the global X axis.
|
|
*/
|
|
|
|
public LSL_Types.Quaternion llEuler2Rot(LSL_Types.Vector3 v)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
double x,y,z,s,s_i;
|
|
|
|
double cosX = Math.Cos(v.x);
|
|
double cosY = Math.Cos(v.y);
|
|
double cosZ = Math.Cos(v.z);
|
|
double sinX = Math.Sin(v.x);
|
|
double sinY = Math.Sin(v.y);
|
|
double sinZ = Math.Sin(v.z);
|
|
|
|
s = Math.Sqrt(cosY * cosZ - sinX * sinY * sinZ + cosX * cosZ + cosX * cosY + 1.0f) * 0.5f;
|
|
if (Math.Abs(s) < 0.00001) // null rotation
|
|
{
|
|
x = 0.0f;
|
|
y = 1.0f;
|
|
z = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
s_i = 1.0f / (4.0f * s);
|
|
x = - (-sinX * cosY - cosX * sinY * sinZ - sinX * cosZ) * s_i;
|
|
y = - (-cosX * sinY * cosZ + sinX * sinZ - sinY) * s_i;
|
|
z = - (-cosY * sinZ - sinX * sinY * cosZ - cosX * sinZ) * s_i;
|
|
}
|
|
return new LSL_Types.Quaternion(x, y, z, s);
|
|
}
|
|
|
|
|
|
public LSL_Types.Quaternion llAxes2Rot(LSL_Types.Vector3 fwd, LSL_Types.Vector3 left, LSL_Types.Vector3 up)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llAxes2Rot");
|
|
return new LSL_Types.Quaternion();
|
|
}
|
|
|
|
public LSL_Types.Vector3 llRot2Fwd(LSL_Types.Quaternion r)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (new LSL_Types.Vector3(1,0,0) * r);
|
|
}
|
|
|
|
public LSL_Types.Vector3 llRot2Left(LSL_Types.Quaternion r)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (new LSL_Types.Vector3(0, 1, 0) * r);
|
|
}
|
|
|
|
public LSL_Types.Vector3 llRot2Up(LSL_Types.Quaternion r)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (new LSL_Types.Vector3(0, 0, 1) * r);
|
|
}
|
|
public LSL_Types.Quaternion llRotBetween(LSL_Types.Vector3 a, LSL_Types.Vector3 b)
|
|
{
|
|
//A and B should both be normalized
|
|
m_host.AddScriptLPS(1);
|
|
double dotProduct = LSL_Types.Vector3.Dot(a, b);
|
|
LSL_Types.Vector3 crossProduct = LSL_Types.Vector3.Cross(a, b);
|
|
double magProduct = LSL_Types.Vector3.Mag(a) * LSL_Types.Vector3.Mag(b);
|
|
double angle = Math.Acos(dotProduct / magProduct);
|
|
LSL_Types.Vector3 axis = LSL_Types.Vector3.Norm(crossProduct);
|
|
double s = Math.Sin(angle / 2);
|
|
|
|
return new LSL_Types.Quaternion(axis.x * s, axis.y * s, axis.z * s, (float)Math.Cos(angle / 2));
|
|
}
|
|
public void llWhisper(int channelID, string text)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if(text.Length > 1023)
|
|
text=text.Substring(0, 1023);
|
|
|
|
World.SimChat(Helpers.StringToField(text),
|
|
ChatTypeEnum.Whisper, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false);
|
|
|
|
IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
|
|
wComm.DeliverMessage(ChatTypeEnum.Whisper, channelID, m_host.Name, m_host.UUID, text);
|
|
}
|
|
|
|
public void llShout(int channelID, string text)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if(text.Length > 1023)
|
|
text=text.Substring(0, 1023);
|
|
|
|
World.SimChat(Helpers.StringToField(text),
|
|
ChatTypeEnum.Shout, channelID, m_host.AbsolutePosition, m_host.Name, m_host.UUID, true);
|
|
|
|
IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
|
|
wComm.DeliverMessage(ChatTypeEnum.Shout, channelID, m_host.Name, m_host.UUID, text);
|
|
}
|
|
|
|
public void llRegionSay(int channelID, string text)
|
|
{
|
|
if (channelID == 0)
|
|
{
|
|
LSLError("Cannot use llRegionSay() on channel 0");
|
|
return;
|
|
}
|
|
|
|
|
|
if(text.Length > 1023)
|
|
text=text.Substring(0, 1023);
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
|
|
wComm.DeliverMessage(ChatTypeEnum.Region, channelID, m_host.Name, m_host.UUID, text);
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llListen(int channelID, string name, string ID, string msg)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID keyID;
|
|
LLUUID.TryParse(ID, out keyID);
|
|
IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
|
|
return wComm.Listen(m_localID, m_itemID, m_host.UUID, channelID, name, keyID, msg);
|
|
}
|
|
|
|
public void llListenControl(int number, int active)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
|
|
wComm.ListenControl(m_itemID, number, active);
|
|
}
|
|
|
|
public void llListenRemove(int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
|
|
wComm.ListenRemove(m_itemID, number);
|
|
}
|
|
|
|
public void llSensor(string name, string id, int type, double range, double arc)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID keyID = LLUUID.Zero;
|
|
LLUUID.TryParse(id, out keyID);
|
|
|
|
m_ScriptEngine.m_ASYNCLSLCommandManager.m_SensorRepeat.SenseOnce(m_localID, m_itemID, name, keyID, type, range, arc, m_host);
|
|
}
|
|
|
|
public void llSensorRepeat(string name, string id, int type, double range, double arc, double rate)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID keyID = LLUUID.Zero;
|
|
LLUUID.TryParse(id, out keyID);
|
|
|
|
m_ScriptEngine.m_ASYNCLSLCommandManager.m_SensorRepeat.SetSenseRepeatEvent(m_localID, m_itemID, name, keyID, type, range, arc, rate, m_host);
|
|
}
|
|
|
|
public void llSensorRemove()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_ScriptEngine.m_ASYNCLSLCommandManager.m_SensorRepeat.UnSetSenseRepeaterEvents(m_localID, m_itemID);
|
|
}
|
|
|
|
public string resolveName(LLUUID objecUUID)
|
|
{
|
|
// try avatar username surname
|
|
UserProfileData profile = World.CommsManager.UserService.GetUserProfile(objecUUID);
|
|
if (profile != null)
|
|
{
|
|
string avatarname = profile.FirstName + " " + profile.SurName;
|
|
return avatarname;
|
|
}
|
|
// try an scene object
|
|
SceneObjectPart SOP = World.GetSceneObjectPart(objecUUID);
|
|
if (SOP != null)
|
|
{
|
|
string objectname = SOP.Name;
|
|
return objectname;
|
|
}
|
|
|
|
EntityBase SensedObject;
|
|
lock (World.Entities)
|
|
{
|
|
World.Entities.TryGetValue(objecUUID, out SensedObject);
|
|
}
|
|
|
|
if (SensedObject == null)
|
|
return String.Empty;
|
|
return SensedObject.Name;
|
|
|
|
}
|
|
|
|
public string llDetectedName(int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID sensedUUID = m_ScriptEngine.GetDetectID(m_itemID, number);
|
|
if(sensedUUID != null)
|
|
return resolveName(sensedUUID);
|
|
return String.Empty;
|
|
}
|
|
|
|
public LLUUID uuidDetectedKey(int number)
|
|
{
|
|
return m_ScriptEngine.GetDetectID(m_itemID, number);
|
|
}
|
|
|
|
public EntityBase entityDetectedKey(int number)
|
|
{
|
|
LLUUID sensedUUID = m_ScriptEngine.GetDetectID(m_itemID, number);
|
|
if(sensedUUID != null)
|
|
{
|
|
EntityBase SensedObject = null;
|
|
lock (World.Entities)
|
|
{
|
|
World.Entities.TryGetValue(sensedUUID, out SensedObject);
|
|
}
|
|
return SensedObject;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public string llDetectedKey(int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID SensedUUID = uuidDetectedKey(number);
|
|
if (SensedUUID == LLUUID.Zero)
|
|
return String.Empty;
|
|
|
|
return SensedUUID.ToString();
|
|
}
|
|
|
|
public string llDetectedOwner(int number)
|
|
{
|
|
// returns UUID of owner of object detected
|
|
m_host.AddScriptLPS(1);
|
|
EntityBase SensedObject = entityDetectedKey(number);
|
|
if (SensedObject ==null)
|
|
return String.Empty;
|
|
LLUUID SensedUUID = uuidDetectedKey(number);
|
|
if (World.GetScenePresence(SensedUUID) == null)
|
|
{
|
|
// sensed object is not an avatar
|
|
// so get the owner of the sensed object
|
|
SceneObjectPart SOP = World.GetSceneObjectPart(SensedUUID);
|
|
if (SOP != null) { return SOP.ObjectOwner.ToString(); }
|
|
}
|
|
else
|
|
{
|
|
// sensed object is an avatar, and so must be its own owner
|
|
return SensedUUID.ToString();
|
|
}
|
|
|
|
|
|
return String.Empty;
|
|
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llDetectedType(int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
EntityBase SensedObject = entityDetectedKey(number);
|
|
if (SensedObject == null)
|
|
return 0;
|
|
int mask = 0;
|
|
|
|
LLUUID SensedUUID = uuidDetectedKey(number);
|
|
LSL_Types.Vector3 ZeroVector = new LSL_Types.Vector3(0, 0, 0);
|
|
|
|
if (World.GetScenePresence(SensedUUID) != null) mask |= 0x01; // actor
|
|
if (SensedObject.Velocity.Equals(ZeroVector))
|
|
mask |= 0x04; // passive non-moving
|
|
else
|
|
mask |= 0x02; // active moving
|
|
if (SensedObject is IScript) mask |= 0x08; // Scripted. It COULD have one hidden ...
|
|
return mask;
|
|
|
|
}
|
|
|
|
public LSL_Types.Vector3 llDetectedPos(int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
EntityBase SensedObject = entityDetectedKey(number);
|
|
if (SensedObject == null)
|
|
return new LSL_Types.Vector3(0, 0, 0);
|
|
|
|
return new LSL_Types.Vector3(SensedObject.AbsolutePosition.X,SensedObject.AbsolutePosition.Y,SensedObject.AbsolutePosition.Z);
|
|
}
|
|
|
|
public LSL_Types.Vector3 llDetectedVel(int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
EntityBase SensedObject = entityDetectedKey(number);
|
|
if (SensedObject == null)
|
|
return new LSL_Types.Vector3(0, 0, 0);
|
|
|
|
return new LSL_Types.Vector3(SensedObject.Velocity.X, SensedObject.Velocity.Y, SensedObject.Velocity.Z);
|
|
// return new LSL_Types.Vector3();
|
|
}
|
|
|
|
public LSL_Types.Vector3 llDetectedGrab(int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
XDetectParams parms = m_ScriptEngine.GetDetectParams(m_itemID, number);
|
|
|
|
return parms.OffsetPos;
|
|
}
|
|
|
|
public LSL_Types.Quaternion llDetectedRot(int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
EntityBase SensedObject = entityDetectedKey(number);
|
|
if (SensedObject == null)
|
|
return new LSL_Types.Quaternion();
|
|
|
|
return new LSL_Types.Quaternion(SensedObject.Rotation.x, SensedObject.Rotation.y, SensedObject.Rotation.z, SensedObject.Rotation.w);
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llDetectedGroup(int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llDetectedGroup");
|
|
return 0;
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llDetectedLinkNumber(int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llDetectedLinkNumber");
|
|
return 0;
|
|
}
|
|
|
|
public void llDie()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
World.DeleteSceneObject(m_host.ParentGroup);
|
|
}
|
|
|
|
public double llGround(LSL_Types.Vector3 offset)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
int x = (int)(m_host.AbsolutePosition.X + offset.x);
|
|
int y = (int)(m_host.AbsolutePosition.Y + offset.y);
|
|
return World.GetLandHeight(x, y);
|
|
}
|
|
|
|
public double llCloud(LSL_Types.Vector3 offset)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llCloud");
|
|
return 0;
|
|
}
|
|
|
|
public LSL_Types.Vector3 llWind(LSL_Types.Vector3 offset)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llWind");
|
|
return new LSL_Types.Vector3();
|
|
}
|
|
|
|
public void llSetStatus(int status, int value)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
int statusrotationaxis = 0;
|
|
|
|
if ((status & BuiltIn_Commands_BaseClass.STATUS_PHYSICS) == BuiltIn_Commands_BaseClass.STATUS_PHYSICS)
|
|
{
|
|
if (value == 1)
|
|
m_host.ScriptSetPhysicsStatus(true);
|
|
else
|
|
m_host.ScriptSetPhysicsStatus(false);
|
|
|
|
}
|
|
if ((status & BuiltIn_Commands_BaseClass.STATUS_PHANTOM) == BuiltIn_Commands_BaseClass.STATUS_PHANTOM)
|
|
{
|
|
if (value == 1)
|
|
m_host.ScriptSetPhantomStatus(true);
|
|
else
|
|
m_host.ScriptSetPhantomStatus(false);
|
|
}
|
|
if ((status & BuiltIn_Commands_BaseClass.STATUS_CAST_SHADOWS) == BuiltIn_Commands_BaseClass.STATUS_CAST_SHADOWS)
|
|
{
|
|
m_host.AddFlag(LLObject.ObjectFlags.CastShadows);
|
|
}
|
|
if ((status & BuiltIn_Commands_BaseClass.STATUS_ROTATE_X) == BuiltIn_Commands_BaseClass.STATUS_ROTATE_X)
|
|
{
|
|
statusrotationaxis |= BuiltIn_Commands_BaseClass.STATUS_ROTATE_X;
|
|
|
|
}
|
|
if ((status & BuiltIn_Commands_BaseClass.STATUS_ROTATE_Y) == BuiltIn_Commands_BaseClass.STATUS_ROTATE_Y)
|
|
{
|
|
statusrotationaxis |= BuiltIn_Commands_BaseClass.STATUS_ROTATE_Y;
|
|
}
|
|
if ((status & BuiltIn_Commands_BaseClass.STATUS_ROTATE_Z) == BuiltIn_Commands_BaseClass.STATUS_ROTATE_Z)
|
|
{
|
|
statusrotationaxis |= BuiltIn_Commands_BaseClass.STATUS_ROTATE_Z;
|
|
}
|
|
if ((status & BuiltIn_Commands_BaseClass.STATUS_BLOCK_GRAB) == BuiltIn_Commands_BaseClass.STATUS_BLOCK_GRAB)
|
|
{
|
|
NotImplemented("llSetStatus - STATUS_BLOCK_GRAB");
|
|
}
|
|
if ((status & BuiltIn_Commands_BaseClass.STATUS_DIE_AT_EDGE) == BuiltIn_Commands_BaseClass.STATUS_DIE_AT_EDGE)
|
|
{
|
|
if (value == 1)
|
|
m_host.SetDieAtEdge(true);
|
|
else
|
|
m_host.SetDieAtEdge(false);
|
|
}
|
|
if ((status & BuiltIn_Commands_BaseClass.STATUS_RETURN_AT_EDGE) == BuiltIn_Commands_BaseClass.STATUS_RETURN_AT_EDGE)
|
|
{
|
|
NotImplemented("llSetStatus - STATUS_RETURN_AT_EDGE");
|
|
}
|
|
if ((status & BuiltIn_Commands_BaseClass.STATUS_SANDBOX) == BuiltIn_Commands_BaseClass.STATUS_SANDBOX)
|
|
{
|
|
NotImplemented("llSetStatus - STATUS_SANDBOX");
|
|
}
|
|
if (statusrotationaxis != 0)
|
|
{
|
|
m_host.SetAxisRotation(statusrotationaxis, value);
|
|
|
|
}
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetStatus(int status)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
// Console.WriteLine(m_host.UUID.ToString() + " status is " + m_host.GetEffectiveObjectFlags().ToString());
|
|
switch (status)
|
|
{
|
|
case BuiltIn_Commands_BaseClass.STATUS_PHYSICS:
|
|
if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Physics) == (uint)LLObject.ObjectFlags.Physics)
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
case BuiltIn_Commands_BaseClass.STATUS_PHANTOM:
|
|
if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Phantom) == (uint)LLObject.ObjectFlags.Phantom)
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
case BuiltIn_Commands_BaseClass.STATUS_CAST_SHADOWS:
|
|
if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.CastShadows) == (uint)LLObject.ObjectFlags.CastShadows)
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
case BuiltIn_Commands_BaseClass.STATUS_BLOCK_GRAB:
|
|
NotImplemented("llGetStatus - STATUS_BLOCK_GRAB");
|
|
return 0;
|
|
case BuiltIn_Commands_BaseClass.STATUS_DIE_AT_EDGE:
|
|
|
|
if (m_host.GetDieAtEdge())
|
|
return 1;
|
|
else
|
|
return 0;
|
|
|
|
case BuiltIn_Commands_BaseClass.STATUS_RETURN_AT_EDGE:
|
|
NotImplemented("llGetStatus - STATUS_RETURN_AT_EDGE");
|
|
return 0;
|
|
case BuiltIn_Commands_BaseClass.STATUS_ROTATE_X:
|
|
NotImplemented("llGetStatus - STATUS_ROTATE_X");
|
|
return 0;
|
|
case BuiltIn_Commands_BaseClass.STATUS_ROTATE_Y:
|
|
NotImplemented("llGetStatus - STATUS_ROTATE_Y");
|
|
return 0;
|
|
case BuiltIn_Commands_BaseClass.STATUS_ROTATE_Z:
|
|
NotImplemented("llGetStatus - STATUS_ROTATE_Z");
|
|
return 0;
|
|
case BuiltIn_Commands_BaseClass.STATUS_SANDBOX:
|
|
NotImplemented("llGetStatus - STATUS_SANDBOX");
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public void llSetScale(LSL_Types.Vector3 scale)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
SetScale(m_host, scale);
|
|
}
|
|
|
|
private void SetScale(SceneObjectPart part, LSL_Types.Vector3 scale)
|
|
{
|
|
// TODO: this needs to trigger a persistance save as well
|
|
LLVector3 tmp = part.Scale;
|
|
tmp.X = (float)scale.x;
|
|
tmp.Y = (float)scale.y;
|
|
tmp.Z = (float)scale.z;
|
|
part.Scale = tmp;
|
|
part.SendFullUpdateToAllClients();
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetScale()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return new LSL_Types.Vector3(m_host.Scale.X, m_host.Scale.Y, m_host.Scale.Z);
|
|
}
|
|
|
|
public void llSetColor(LSL_Types.Vector3 color, int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
SetColor(m_host, color, face);
|
|
}
|
|
|
|
private void SetColor(SceneObjectPart part, LSL_Types.Vector3 color, int face)
|
|
{
|
|
LLObject.TextureEntry tex = part.Shape.Textures;
|
|
LLColor texcolor;
|
|
if (face > -1)
|
|
{
|
|
texcolor = tex.CreateFace((uint)face).RGBA;
|
|
texcolor.R = (float)Math.Abs(color.x - 1);
|
|
texcolor.G = (float)Math.Abs(color.y - 1);
|
|
texcolor.B = (float)Math.Abs(color.z - 1);
|
|
tex.FaceTextures[face].RGBA = texcolor;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
else if (face == -1)
|
|
{
|
|
for (uint i = 0; i < 32; i++)
|
|
{
|
|
if (tex.FaceTextures[i] != null)
|
|
{
|
|
texcolor = tex.FaceTextures[i].RGBA;
|
|
texcolor.R = (float)Math.Abs(color.x - 1);
|
|
texcolor.G = (float)Math.Abs(color.y - 1);
|
|
texcolor.B = (float)Math.Abs(color.z - 1);
|
|
tex.FaceTextures[i].RGBA = texcolor;
|
|
}
|
|
texcolor = tex.DefaultTexture.RGBA;
|
|
texcolor.R = (float)Math.Abs(color.x - 1);
|
|
texcolor.G = (float)Math.Abs(color.y - 1);
|
|
texcolor.B = (float)Math.Abs(color.z - 1);
|
|
tex.DefaultTexture.RGBA = texcolor;
|
|
}
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public double llGetAlpha(int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLObject.TextureEntry tex = m_host.Shape.Textures;
|
|
if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color
|
|
{
|
|
return (double)((tex.DefaultTexture.RGBA.A * 255) / 255);
|
|
}
|
|
if (face > -1)
|
|
{
|
|
return (double)((tex.GetFace((uint)face).RGBA.A * 255) / 255);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public void llSetAlpha(double alpha, int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
SetAlpha(m_host, alpha, face);
|
|
}
|
|
|
|
private void SetAlpha(SceneObjectPart part, double alpha, int face)
|
|
{
|
|
LLObject.TextureEntry tex = part.Shape.Textures;
|
|
LLColor texcolor;
|
|
if (face > -1)
|
|
{
|
|
texcolor = tex.CreateFace((uint)face).RGBA;
|
|
texcolor.A = (float)Math.Abs(alpha - 1);
|
|
tex.FaceTextures[face].RGBA = texcolor;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
else if (face == -1)
|
|
{
|
|
for (int i = 0; i < 32; i++)
|
|
{
|
|
if (tex.FaceTextures[i] != null)
|
|
{
|
|
texcolor = tex.FaceTextures[i].RGBA;
|
|
texcolor.A = (float)Math.Abs(alpha - 1);
|
|
tex.FaceTextures[i].RGBA = texcolor;
|
|
}
|
|
}
|
|
texcolor = tex.DefaultTexture.RGBA;
|
|
texcolor.A = (float)Math.Abs(alpha - 1);
|
|
tex.DefaultTexture.RGBA = texcolor;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetColor(int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLObject.TextureEntry tex = m_host.Shape.Textures;
|
|
LLColor texcolor;
|
|
LSL_Types.Vector3 rgb;
|
|
if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color
|
|
{
|
|
texcolor = tex.DefaultTexture.RGBA;
|
|
rgb.x = (255 - (texcolor.R * 255)) / 255;
|
|
rgb.y = (255 - (texcolor.G * 255)) / 255;
|
|
rgb.z = (255 - (texcolor.B * 255)) / 255;
|
|
return rgb;
|
|
}
|
|
if (face > -1)
|
|
{
|
|
texcolor = tex.GetFace((uint)face).RGBA;
|
|
rgb.x = (255 - (texcolor.R * 255)) / 255;
|
|
rgb.y = (255 - (texcolor.G * 255)) / 255;
|
|
rgb.z = (255 - (texcolor.B * 255)) / 255;
|
|
return rgb;
|
|
}
|
|
else
|
|
{
|
|
return new LSL_Types.Vector3();
|
|
}
|
|
}
|
|
|
|
public void llSetTexture(string texture, int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
SetTexture(m_host, texture, face);
|
|
}
|
|
|
|
private void SetTexture(SceneObjectPart part, string texture, int face)
|
|
{
|
|
LLUUID textureID=new LLUUID();
|
|
|
|
if (!LLUUID.TryParse(texture, out textureID))
|
|
{
|
|
textureID=InventoryKey(texture, (int)AssetType.Texture);
|
|
}
|
|
|
|
if (textureID == LLUUID.Zero)
|
|
return;
|
|
|
|
LLObject.TextureEntry tex = part.Shape.Textures;
|
|
|
|
if (face > -1)
|
|
{
|
|
LLObject.TextureEntryFace texface = tex.CreateFace((uint)face);
|
|
texface.TextureID = textureID;
|
|
tex.FaceTextures[face] = texface;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
else if (face == -1)
|
|
{
|
|
for (uint i = 0; i < 32; i++)
|
|
{
|
|
if (tex.FaceTextures[i] != null)
|
|
{
|
|
tex.FaceTextures[i].TextureID = textureID;
|
|
}
|
|
}
|
|
tex.DefaultTexture.TextureID = textureID;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void llScaleTexture(double u, double v, int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
ScaleTexture(m_host, u, v, face);
|
|
}
|
|
|
|
private void ScaleTexture(SceneObjectPart part, double u, double v, int face)
|
|
{
|
|
LLObject.TextureEntry tex = part.Shape.Textures;
|
|
if (face > -1)
|
|
{
|
|
LLObject.TextureEntryFace texface = tex.CreateFace((uint)face);
|
|
texface.RepeatU = (float)u;
|
|
texface.RepeatV = (float)v;
|
|
tex.FaceTextures[face] = texface;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
if (face == -1)
|
|
{
|
|
for (int i = 0; i < 32; i++)
|
|
{
|
|
if (tex.FaceTextures[i] != null)
|
|
{
|
|
tex.FaceTextures[i].RepeatU = (float)u;
|
|
tex.FaceTextures[i].RepeatV = (float)v;
|
|
}
|
|
}
|
|
tex.DefaultTexture.RepeatU = (float)u;
|
|
tex.DefaultTexture.RepeatV = (float)v;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void llOffsetTexture(double u, double v, int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
OffsetTexture(m_host, u, v, face);
|
|
}
|
|
|
|
private void OffsetTexture(SceneObjectPart part, double u, double v, int face)
|
|
{
|
|
LLObject.TextureEntry tex = part.Shape.Textures;
|
|
if (face > -1)
|
|
{
|
|
LLObject.TextureEntryFace texface = tex.CreateFace((uint)face);
|
|
texface.OffsetU = (float)u;
|
|
texface.OffsetV = (float)v;
|
|
tex.FaceTextures[face] = texface;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
if (face == -1)
|
|
{
|
|
for (int i = 0; i < 32; i++)
|
|
{
|
|
if (tex.FaceTextures[i] != null)
|
|
{
|
|
tex.FaceTextures[i].OffsetU = (float)u;
|
|
tex.FaceTextures[i].OffsetV = (float)v;
|
|
}
|
|
}
|
|
tex.DefaultTexture.OffsetU = (float)u;
|
|
tex.DefaultTexture.OffsetV = (float)v;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void llRotateTexture(double rotation, int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
RotateTexture(m_host, rotation, face);
|
|
}
|
|
|
|
private void RotateTexture(SceneObjectPart part, double rotation, int face)
|
|
{
|
|
LLObject.TextureEntry tex = part.Shape.Textures;
|
|
if (face > -1)
|
|
{
|
|
LLObject.TextureEntryFace texface = tex.CreateFace((uint)face);
|
|
texface.Rotation = (float)rotation;
|
|
tex.FaceTextures[face] = texface;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
if (face == -1)
|
|
{
|
|
for (int i = 0; i < 32; i++)
|
|
{
|
|
if (tex.FaceTextures[i] != null)
|
|
{
|
|
tex.FaceTextures[i].Rotation = (float)rotation;
|
|
}
|
|
}
|
|
tex.DefaultTexture.Rotation = (float)rotation;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public string llGetTexture(int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLObject.TextureEntry tex = m_host.Shape.Textures;
|
|
if (face == -1)
|
|
{
|
|
face = 0;
|
|
}
|
|
if (face > -1)
|
|
{
|
|
LLObject.TextureEntryFace texface;
|
|
texface = tex.GetFace((uint)face);
|
|
return texface.TextureID.ToString();
|
|
}
|
|
else
|
|
{
|
|
return String.Empty;
|
|
}
|
|
}
|
|
|
|
public void llSetPos(LSL_Types.Vector3 pos)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
SetPos(m_host, pos);
|
|
}
|
|
|
|
private void SetPos(SceneObjectPart part, LSL_Types.Vector3 pos)
|
|
{
|
|
if (part.ParentID != 0)
|
|
{
|
|
part.UpdateOffSet(new LLVector3((float)pos.x, (float)pos.y, (float)pos.z));
|
|
}
|
|
else
|
|
{
|
|
part.UpdateGroupPosition(new LLVector3((float)pos.x, (float)pos.y, (float)pos.z));
|
|
}
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetPos()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return new LSL_Types.Vector3(m_host.AbsolutePosition.X,
|
|
m_host.AbsolutePosition.Y,
|
|
m_host.AbsolutePosition.Z);
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetLocalPos()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (m_host.ParentID != 0)
|
|
{
|
|
return new LSL_Types.Vector3(m_host.OffsetPosition.X,
|
|
m_host.OffsetPosition.Y,
|
|
m_host.OffsetPosition.Z);
|
|
}
|
|
else
|
|
{
|
|
return new LSL_Types.Vector3(m_host.AbsolutePosition.X,
|
|
m_host.AbsolutePosition.Y,
|
|
m_host.AbsolutePosition.Z);
|
|
}
|
|
}
|
|
|
|
public void llSetRot(LSL_Types.Quaternion rot)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
SetRot(m_host, rot);
|
|
}
|
|
|
|
private void SetRot(SceneObjectPart part, LSL_Types.Quaternion rot)
|
|
{
|
|
part.UpdateRotation(new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s));
|
|
// Update rotation does not move the object in the physics scene if it's a linkset.
|
|
part.ParentGroup.AbsolutePosition = part.ParentGroup.AbsolutePosition;
|
|
}
|
|
|
|
public LSL_Types.Quaternion llGetRot()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLQuaternion q = m_host.RotationOffset;
|
|
return new LSL_Types.Quaternion(q.X, q.Y, q.Z, q.W);
|
|
}
|
|
|
|
public LSL_Types.Quaternion llGetLocalRot()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return new LSL_Types.Quaternion(m_host.RotationOffset.X, m_host.RotationOffset.Y, m_host.RotationOffset.Z, m_host.RotationOffset.W);
|
|
}
|
|
|
|
public void llSetForce(LSL_Types.Vector3 force, int local)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetForce");
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetForce()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetForce");
|
|
return new LSL_Types.Vector3();
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llTarget(LSL_Types.Vector3 position, double range)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return m_host.registerTargetWaypoint(new LLVector3((float)position.x, (float)position.y, (float)position.z), (float)range);
|
|
|
|
}
|
|
|
|
public void llTargetRemove(int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.unregisterTargetWaypoint(number);
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llRotTarget(LSL_Types.Quaternion rot, double error)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llRotTarget");
|
|
return 0;
|
|
}
|
|
|
|
public void llRotTargetRemove(int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llRotTargetRemove");
|
|
}
|
|
|
|
public void llMoveToTarget(LSL_Types.Vector3 target, double tau)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.MoveToTarget(new LLVector3((float)target.x, (float)target.y, (float)target.z), (float)tau);
|
|
}
|
|
|
|
public void llStopMoveToTarget()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.StopMoveToTarget();
|
|
}
|
|
|
|
public void llApplyImpulse(LSL_Types.Vector3 force, int local)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
//No energy force yet
|
|
|
|
if (force.x > 20000)
|
|
force.x = 20000;
|
|
if (force.y > 20000)
|
|
force.y = 20000;
|
|
if (force.z > 20000)
|
|
force.z = 20000;
|
|
|
|
if (local == 1)
|
|
{
|
|
m_host.ApplyImpulse(new LLVector3((float)force.x, (float)force.y, (float)force.z), true);
|
|
}
|
|
else
|
|
{
|
|
|
|
m_host.ApplyImpulse(new LLVector3((float)force.x,(float)force.y,(float)force.z), false);
|
|
}
|
|
}
|
|
|
|
public void llApplyRotationalImpulse(LSL_Types.Vector3 force, int local)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llApplyRotationalImpulse");
|
|
}
|
|
|
|
public void llSetTorque(LSL_Types.Vector3 torque, int local)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetTorque");
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetTorque()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetTorque");
|
|
return new LSL_Types.Vector3();
|
|
}
|
|
|
|
public void llSetForceAndTorque(LSL_Types.Vector3 force, LSL_Types.Vector3 torque, int local)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetForceAndTorque");
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetVel()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return new LSL_Types.Vector3(m_host.Velocity.X, m_host.Velocity.Y, m_host.Velocity.Z);
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetAccel()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return new LSL_Types.Vector3(m_host.Acceleration.X, m_host.Acceleration.Y, m_host.Acceleration.Z);
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetOmega()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return new LSL_Types.Vector3(m_host.RotationalVelocity.X, m_host.RotationalVelocity.Y, m_host.RotationalVelocity.Z);
|
|
}
|
|
|
|
public double llGetTimeOfDay()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetTimeOfDay");
|
|
return 0;
|
|
}
|
|
|
|
public double llGetWallclock()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return DateTime.Now.TimeOfDay.TotalSeconds;
|
|
}
|
|
|
|
public double llGetTime()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
TimeSpan ScriptTime = DateTime.Now - m_timer;
|
|
return (double)((ScriptTime.TotalMilliseconds / 1000)*World.TimeDilation);
|
|
}
|
|
|
|
public void llResetTime()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_timer = DateTime.Now;
|
|
}
|
|
|
|
public double llGetAndResetTime()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
TimeSpan ScriptTime = DateTime.Now - m_timer;
|
|
m_timer = DateTime.Now;
|
|
return (double)((ScriptTime.TotalMilliseconds / 1000)*World.TimeDilation);
|
|
}
|
|
|
|
public void llSound()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
// This function has been deprecated
|
|
// see http://www.lslwiki.net/lslwiki/wakka.php?wakka=llSound
|
|
Deprecated("llSound");
|
|
}
|
|
|
|
public void llPlaySound(string sound, double volume)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.SendSound(sound, volume, false, 0);
|
|
}
|
|
|
|
public void llLoopSound(string sound, double volume)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.SendSound(sound, volume, false, 1);
|
|
}
|
|
|
|
public void llLoopSoundMaster(string sound, double volume)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llLoopSoundMaster");
|
|
}
|
|
|
|
public void llLoopSoundSlave(string sound, double volume)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llLoopSoundSlave");
|
|
}
|
|
|
|
public void llPlaySoundSlave(string sound, double volume)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llPlaySoundSlave");
|
|
}
|
|
|
|
public void llTriggerSound(string sound, double volume)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.SendSound(sound, volume, true, 0);
|
|
}
|
|
|
|
public void llStopSound()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.SendSound(LLUUID.Zero.ToString(), 1.0, false, 2);
|
|
}
|
|
|
|
public void llPreloadSound(string sound)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.PreloadSound(sound);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return a portion of the designated string bounded by
|
|
/// inclusive indices (start and end). As usual, the negative
|
|
/// indices, and the tolerance for out-of-bound values, makes
|
|
/// this more complicated than it might otherwise seem.
|
|
/// </summary>
|
|
|
|
public string llGetSubString(string src, int start, int end)
|
|
{
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
// Normalize indices (if negative).
|
|
// After normlaization they may still be
|
|
// negative, but that is now relative to
|
|
// the start, rather than the end, of the
|
|
// sequence.
|
|
|
|
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 lengt of the substring
|
|
// needed (plus one of course). BUT, it
|
|
// must be within bounds.
|
|
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);
|
|
}
|
|
else
|
|
{
|
|
return String.Empty;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (start < src.Length)
|
|
{
|
|
return src.Substring(0,end+1) + src.Substring(start);
|
|
}
|
|
else
|
|
{
|
|
return src.Substring(0,end+1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete substring removes the specified substring bounded
|
|
/// by the inclusive indices start and end. Indices may be
|
|
/// negative (indicating end-relative) and may be inverted,
|
|
/// i.e. end < start.
|
|
/// </summary>
|
|
|
|
public string llDeleteSubString(string src, int start, int end)
|
|
{
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
// Normalize indices (if negative).
|
|
// After normlaization they may still be
|
|
// negative, but that is now relative to
|
|
// the start, rather than the end, of the
|
|
// sequence.
|
|
if (start < 0)
|
|
{
|
|
start = src.Length+start;
|
|
}
|
|
if (end < 0)
|
|
{
|
|
end = src.Length+end;
|
|
}
|
|
// Conventionally delimited substring
|
|
if (start <= end)
|
|
{
|
|
// If both bounds are outside of the existing
|
|
// string, then return unchanges.
|
|
if (end < 0 || start >= src.Length)
|
|
{
|
|
return src;
|
|
}
|
|
// At least one bound is in-range, so we
|
|
// need to clip the out-of-bound argument.
|
|
if (start < 0)
|
|
{
|
|
start = 0;
|
|
}
|
|
|
|
if (end >= src.Length)
|
|
{
|
|
end = src.Length-1;
|
|
}
|
|
|
|
return src.Remove(start,end-start+1);
|
|
}
|
|
// Inverted substring
|
|
else
|
|
{
|
|
// In this case, out of bounds means that
|
|
// the existing string is part of the cut.
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Insert string inserts the specified string identified by src
|
|
/// at the index indicated by index. Index may be negative, in
|
|
/// which case it is end-relative. The index may exceed either
|
|
/// string bound, with the result being a concatenation.
|
|
/// </summary>
|
|
|
|
public string llInsertString(string dest, int index, string src)
|
|
{
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
// Normalize indices (if negative).
|
|
// After normlaization they may still be
|
|
// negative, but that is now relative to
|
|
// the start, rather than the end, of the
|
|
// sequence.
|
|
if (index < 0)
|
|
{
|
|
index = dest.Length+index;
|
|
|
|
// Negative now means it is less than the lower
|
|
// bound of the string.
|
|
|
|
if (index < 0)
|
|
{
|
|
return src+dest;
|
|
}
|
|
|
|
}
|
|
|
|
if (index >= dest.Length)
|
|
{
|
|
return dest+src;
|
|
}
|
|
|
|
// The index is in bounds.
|
|
// In this case the index refers to the index that will
|
|
// be assigned to the first character of the inserted string.
|
|
// So unlike the other string operations, we do not add one
|
|
// to get the correct string length.
|
|
return dest.Substring(0,index)+src+dest.Substring(index);
|
|
|
|
}
|
|
|
|
public string llToUpper(string src)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return src.ToUpper();
|
|
}
|
|
|
|
public string llToLower(string src)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return src.ToLower();
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGiveMoney(string destination, int amount)
|
|
{
|
|
LLUUID invItemID=InventorySelf();
|
|
if (invItemID == LLUUID.Zero)
|
|
return 0;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if (m_host.TaskInventory[invItemID].PermsGranter == LLUUID.Zero)
|
|
return 0;
|
|
|
|
if ((m_host.TaskInventory[invItemID].PermsMask & BuiltIn_Commands_BaseClass.PERMISSION_DEBIT) == 0)
|
|
{
|
|
LSLError("No permissions to give money");
|
|
return 0;
|
|
}
|
|
|
|
LLUUID toID=new LLUUID();
|
|
|
|
if (!LLUUID.TryParse(destination, out toID))
|
|
{
|
|
LSLError("Bad key in llGiveMoney");
|
|
return 0;
|
|
}
|
|
|
|
IMoneyModule money=World.RequestModuleInterface<IMoneyModule>();
|
|
|
|
if (money == null)
|
|
{
|
|
NotImplemented("llGiveMoney");
|
|
return 0;
|
|
}
|
|
|
|
bool result=money.ObjectGiveMoney(m_host.ParentGroup.RootPart.UUID, m_host.ParentGroup.RootPart.OwnerID, toID, amount);
|
|
|
|
if (result)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
public void llMakeExplosion()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llMakeExplosion");
|
|
}
|
|
|
|
public void llMakeFountain()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llMakeFountain");
|
|
}
|
|
|
|
public void llMakeSmoke()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llMakeSmoke");
|
|
}
|
|
|
|
public void llMakeFire()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llMakeFire");
|
|
}
|
|
|
|
public void llRezObject(string inventory, LSL_Types.Vector3 pos, LSL_Types.Vector3 vel, LSL_Types.Quaternion rot, int param)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
//NotImplemented("llRezObject");
|
|
bool found = false;
|
|
|
|
// Instead of using return;, I'm using continue; because in our TaskInventory implementation
|
|
// it's possible to have two items with the same task inventory name.
|
|
// this is an easter egg of sorts.
|
|
|
|
foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
|
|
{
|
|
if (inv.Value.Name == inventory)
|
|
{
|
|
// make sure we're an object.
|
|
if (inv.Value.InvType != (int)InventoryType.Object)
|
|
{
|
|
llSay(0, "Unable to create requested object. Object is missing from database.");
|
|
continue;
|
|
}
|
|
|
|
LLVector3 llpos = new LLVector3((float)pos.x, (float)pos.y, (float)pos.z);
|
|
|
|
// test if we're further away then 10m
|
|
if (Util.GetDistanceTo(llpos, m_host.AbsolutePosition) > 10)
|
|
return; // wiki says, if it's further away then 10m, silently fail.
|
|
|
|
LLVector3 llvel = new LLVector3((float)vel.x, (float)vel.y, (float)vel.z);
|
|
|
|
// need the magnitude later
|
|
float velmag = (float)Util.GetMagnitude(llvel);
|
|
|
|
SceneObjectGroup new_group = World.RezObject(inv.Value, llpos, new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s), llvel, param);
|
|
|
|
// If either of these are null, then there was an unknown error.
|
|
if (new_group == null)
|
|
continue;
|
|
if (new_group.RootPart == null)
|
|
continue;
|
|
|
|
// objects rezzed with this method are die_at_edge by default.
|
|
new_group.RootPart.SetDieAtEdge(true);
|
|
|
|
m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams(
|
|
"object_rez", new Object[] {
|
|
new LSL_Types.LSLString(
|
|
new_group.RootPart.UUID.ToString()) },
|
|
new XDetectParams[0]));
|
|
|
|
float groupmass = new_group.GetMass();
|
|
|
|
//Recoil.
|
|
llApplyImpulse(new LSL_Types.Vector3(llvel.X * groupmass, llvel.Y * groupmass, llvel.Z * groupmass), 0);
|
|
found = true;
|
|
//script delay
|
|
System.Threading.Thread.Sleep((int)((groupmass * velmag) / 10));
|
|
break;
|
|
}
|
|
}
|
|
if (!found)
|
|
llSay(0, "Could not find object " + inventory);
|
|
}
|
|
|
|
public void llLookAt(LSL_Types.Vector3 target, double strength, double damping)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llLookAt");
|
|
}
|
|
|
|
public void llStopLookAt()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llStopLookAt");
|
|
}
|
|
|
|
public void llSetTimerEvent(double sec)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
// Setting timer repeat
|
|
m_ScriptEngine.m_ASYNCLSLCommandManager.m_Timer.SetTimerEvent(m_localID, m_itemID, sec);
|
|
}
|
|
|
|
public void llSleep(double sec)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
Thread.Sleep((int)(sec * 1000));
|
|
}
|
|
|
|
public double llGetMass()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return m_host.GetMass();
|
|
}
|
|
|
|
public void llCollisionFilter(string name, string id, int accept)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llCollisionFilter");
|
|
}
|
|
|
|
public void llTakeControls(int controls, int accept, int pass_on)
|
|
{
|
|
if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (m_host.TaskInventory[InventorySelf()].PermsGranter != LLUUID.Zero)
|
|
{
|
|
ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[InventorySelf()].PermsGranter);
|
|
|
|
if (presence != null)
|
|
{
|
|
if ((m_host.TaskInventory[InventorySelf()].PermsMask & BuiltIn_Commands_BaseClass.PERMISSION_TAKE_CONTROLS) != 0)
|
|
{
|
|
presence.RegisterControlEventsToScript(controls, accept, pass_on, m_localID, m_itemID);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
m_host.AddScriptLPS(1);
|
|
//NotImplemented("llTakeControls");
|
|
}
|
|
|
|
public void llReleaseControls()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if (!m_host.TaskInventory.ContainsKey(InventorySelf()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (m_host.TaskInventory[InventorySelf()].PermsGranter != LLUUID.Zero)
|
|
{
|
|
ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[InventorySelf()].PermsGranter);
|
|
|
|
if (presence != null)
|
|
{
|
|
if ((m_host.TaskInventory[InventorySelf()].PermsMask & BuiltIn_Commands_BaseClass.PERMISSION_TAKE_CONTROLS) != 0)
|
|
{
|
|
// Unregister controls from Presence
|
|
presence.UnRegisterControlEventsToScript(m_localID, m_itemID);
|
|
// Remove Take Control permission.
|
|
m_host.TaskInventory[InventorySelf()].PermsMask &= ~BuiltIn_Commands_BaseClass.PERMISSION_TAKE_CONTROLS;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void llAttachToAvatar(int attachment)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llAttachToAvatar");
|
|
}
|
|
|
|
public void llDetachFromAvatar()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llDetachFromAvatar");
|
|
}
|
|
|
|
public void llTakeCamera()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llTakeCamera");
|
|
}
|
|
|
|
public void llReleaseCamera()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llReleaseCamera");
|
|
}
|
|
|
|
public string llGetOwner()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
return m_host.ObjectOwner.ToString();
|
|
}
|
|
|
|
public void llInstantMessage(string user, string message)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
// We may be able to use ClientView.SendInstantMessage here, but we need a client instance.
|
|
// InstantMessageModule.OnInstantMessage searches through a list of scenes for a client matching the toAgent,
|
|
// but I don't think we have a list of scenes available from here.
|
|
// (We also don't want to duplicate the code in OnInstantMessage if we can avoid it.)
|
|
|
|
// user is a UUID
|
|
|
|
// TODO: figure out values for client, fromSession, and imSessionID
|
|
// client.SendInstantMessage(m_host.UUID, fromSession, message, user, imSessionID, m_host.Name, AgentManager.InstantMessageDialog.MessageFromAgent, (uint)Util.UnixTimeSinceEpoch());
|
|
LLUUID friendTransactionID = LLUUID.Random();
|
|
|
|
//m_pendingFriendRequests.Add(friendTransactionID, fromAgentID);
|
|
|
|
GridInstantMessage msg = new GridInstantMessage();
|
|
msg.fromAgentID = new Guid(m_host.UUID.ToString()); // fromAgentID.UUID;
|
|
msg.fromAgentSession = new Guid(friendTransactionID.ToString());// fromAgentSession.UUID;
|
|
msg.toAgentID = new Guid(user); // toAgentID.UUID;
|
|
msg.imSessionID = new Guid(friendTransactionID.ToString()); // This is the item we're mucking with here
|
|
Console.WriteLine("[Scripting IM]: From:" + msg.fromAgentID.ToString() + " To: " + msg.toAgentID.ToString() + " Session:" + msg.imSessionID.ToString() + " Message:" + message);
|
|
Console.WriteLine("[Scripting IM]: Filling Session: " + msg.imSessionID.ToString());
|
|
msg.timestamp = (uint)Util.UnixTimeSinceEpoch();// timestamp;
|
|
//if (client != null)
|
|
//{
|
|
msg.fromAgentName = m_host.Name;//client.FirstName + " " + client.LastName;// fromAgentName;
|
|
//}
|
|
//else
|
|
//{
|
|
// msg.fromAgentName = "(hippos)";// Added for posterity. This means that we can't figure out who sent it
|
|
//}
|
|
msg.message = message;
|
|
msg.dialog = (byte)19; // messgage from script ??? // dialog;
|
|
msg.fromGroup = false;// fromGroup;
|
|
msg.offline = (byte)0; //offline;
|
|
msg.ParentEstateID = 0; //ParentEstateID;
|
|
msg.Position = new sLLVector3();// new sLLVector3(m_host.AbsolutePosition);
|
|
msg.RegionID = World.RegionInfo.RegionID.UUID;//RegionID.UUID;
|
|
msg.binaryBucket = new byte[0];// binaryBucket;
|
|
World.TriggerGridInstantMessage(msg, InstantMessageReceiver.IMModule);
|
|
// NotImplemented("llInstantMessage");
|
|
}
|
|
|
|
public void llEmail(string address, string subject, string message)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llEmail");
|
|
}
|
|
|
|
public void llGetNextEmail(string address, string subject)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetNextEmail");
|
|
}
|
|
|
|
public string llGetKey()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return m_host.UUID.ToString();
|
|
}
|
|
|
|
public void llSetBuoyancy(double buoyancy)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (m_host.ParentGroup != null)
|
|
{
|
|
if (m_host.ParentGroup.RootPart != null)
|
|
{
|
|
m_host.ParentGroup.RootPart.SetBuoyancy((float)buoyancy);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public void llSetHoverHeight(double height, int water, double tau)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetHoverHeight");
|
|
}
|
|
|
|
public void llStopHover()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llStopHover");
|
|
}
|
|
|
|
public void llMinEventDelay(double delay)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llMinEventDelay");
|
|
}
|
|
|
|
public void llSoundPreload()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSoundPreload");
|
|
}
|
|
|
|
public void llRotLookAt(LSL_Types.Quaternion target, double strength, double damping)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llRotLookAt");
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llStringLength(string str)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (str.Length > 0)
|
|
{
|
|
return str.Length;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public void llStartAnimation(string anim)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
LLUUID invItemID=InventorySelf();
|
|
if (invItemID == LLUUID.Zero)
|
|
return;
|
|
|
|
if (m_host.TaskInventory[invItemID].PermsGranter == LLUUID.Zero)
|
|
return;
|
|
|
|
if ((m_host.TaskInventory[invItemID].PermsMask & BuiltIn_Commands_BaseClass.PERMISSION_TRIGGER_ANIMATION) != 0)
|
|
{
|
|
ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[invItemID].PermsGranter);
|
|
|
|
if (presence != null)
|
|
{
|
|
// Do NOT try to parse LLUUID, animations cannot be triggered by ID
|
|
LLUUID animID=InventoryKey(anim, (int)AssetType.Animation);
|
|
if (animID == LLUUID.Zero)
|
|
presence.AddAnimation(anim);
|
|
else
|
|
presence.AddAnimation(animID);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void llStopAnimation(string anim)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
LLUUID invItemID=InventorySelf();
|
|
if (invItemID == LLUUID.Zero)
|
|
return;
|
|
|
|
if (m_host.TaskInventory[invItemID].PermsGranter == LLUUID.Zero)
|
|
return;
|
|
|
|
if ((m_host.TaskInventory[invItemID].PermsMask & BuiltIn_Commands_BaseClass.PERMISSION_TRIGGER_ANIMATION) != 0)
|
|
{
|
|
LLUUID animID = new LLUUID();
|
|
|
|
if (!LLUUID.TryParse(anim, out animID))
|
|
{
|
|
animID=InventoryKey(anim);
|
|
}
|
|
|
|
if (animID == LLUUID.Zero)
|
|
return;
|
|
|
|
ScenePresence presence = World.GetScenePresence(m_host.TaskInventory[invItemID].PermsGranter);
|
|
|
|
if (presence != null)
|
|
{
|
|
if (animID == LLUUID.Zero)
|
|
presence.RemoveAnimation(anim);
|
|
else
|
|
presence.RemoveAnimation(animID);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void llPointAt()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llPointAt");
|
|
}
|
|
|
|
public void llStopPointAt()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llStopPointAt");
|
|
}
|
|
|
|
public void llTargetOmega(LSL_Types.Vector3 axis, double spinrate, double gain)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.RotationalVelocity = new LLVector3((float)(axis.x * spinrate), (float)(axis.y * spinrate), (float)(axis.z * spinrate));
|
|
m_host.AngularVelocity = new LLVector3((float)(axis.x * spinrate), (float)(axis.y * spinrate), (float)(axis.z * spinrate));
|
|
m_host.ScheduleTerseUpdate();
|
|
m_host.SendTerseUpdateToAllClients();
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetStartParameter()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
// NotImplemented("llGetStartParameter");
|
|
return m_host.ParentGroup.StartParameter;
|
|
}
|
|
|
|
public void llGodLikeRezObject(string inventory, LSL_Types.Vector3 pos)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGodLikeRezObject");
|
|
}
|
|
|
|
public void llRequestPermissions(string agent, int perm)
|
|
{
|
|
LLUUID agentID=new LLUUID();
|
|
|
|
if (!LLUUID.TryParse(agent, out agentID))
|
|
return;
|
|
|
|
LLUUID invItemID=InventorySelf();
|
|
|
|
if (invItemID == LLUUID.Zero)
|
|
return; // Not in a prim? How??
|
|
|
|
if (agentID == LLUUID.Zero || perm == 0) // Releasing permissions
|
|
{
|
|
m_host.TaskInventory[invItemID].PermsGranter=LLUUID.Zero;
|
|
m_host.TaskInventory[invItemID].PermsMask=0;
|
|
|
|
m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams(
|
|
"run_time_permissions", new Object[] {
|
|
new LSL_Types.LSLInteger(0) },
|
|
new XDetectParams[0]));
|
|
|
|
return;
|
|
}
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if (m_host.ParentGroup.RootPart.m_IsAttachment && agent == m_host.ParentGroup.RootPart.m_attachedAvatar)
|
|
{
|
|
// When attached, certain permissions are implicit if requested from owner
|
|
int implicitPerms = BuiltIn_Commands_BaseClass.PERMISSION_TAKE_CONTROLS |
|
|
BuiltIn_Commands_BaseClass.PERMISSION_TRIGGER_ANIMATION |
|
|
BuiltIn_Commands_BaseClass.PERMISSION_ATTACH;
|
|
|
|
if ((perm & (~implicitPerms)) == 0) // Requested only implicit perms
|
|
{
|
|
m_host.TaskInventory[invItemID].PermsGranter=agentID;
|
|
m_host.TaskInventory[invItemID].PermsMask=perm;
|
|
|
|
m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams(
|
|
"run_time_permissions", new Object[] {
|
|
new LSL_Types.LSLInteger(perm) },
|
|
new XDetectParams[0]));
|
|
|
|
return;
|
|
}
|
|
}
|
|
else if (m_host.m_sitTargetAvatar == agentID) // Sitting avatar
|
|
{
|
|
// When agent is sitting, certain permissions are implicit if requested from sitting agent
|
|
int implicitPerms = BuiltIn_Commands_BaseClass.PERMISSION_TRIGGER_ANIMATION |
|
|
BuiltIn_Commands_BaseClass.PERMISSION_TRACK_CAMERA;
|
|
|
|
if ((perm & (~implicitPerms)) == 0) // Requested only implicit perms
|
|
{
|
|
m_host.TaskInventory[invItemID].PermsGranter=agentID;
|
|
m_host.TaskInventory[invItemID].PermsMask=perm;
|
|
|
|
m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams(
|
|
"run_time_permissions", new Object[] {
|
|
new LSL_Types.LSLInteger(perm) },
|
|
new XDetectParams[0]));
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
ScenePresence presence = World.GetScenePresence(agentID);
|
|
|
|
if (presence != null)
|
|
{
|
|
string ownerName=resolveName(m_host.ParentGroup.RootPart.OwnerID);
|
|
if (ownerName == String.Empty)
|
|
ownerName="(hippos)";
|
|
|
|
if (!m_waitingForScriptAnswer)
|
|
{
|
|
m_host.TaskInventory[invItemID].PermsGranter=agentID;
|
|
m_host.TaskInventory[invItemID].PermsMask=0;
|
|
presence.ControllingClient.OnScriptAnswer+=handleScriptAnswer;
|
|
m_waitingForScriptAnswer=true;
|
|
}
|
|
|
|
presence.ControllingClient.SendScriptQuestion(m_host.UUID, m_host.ParentGroup.RootPart.Name, ownerName, invItemID, perm);
|
|
return;
|
|
}
|
|
|
|
// Requested agent is not in range, refuse perms
|
|
m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams(
|
|
"run_time_permissions", new Object[] {
|
|
new LSL_Types.LSLInteger(0) },
|
|
new XDetectParams[0]));
|
|
}
|
|
|
|
void handleScriptAnswer(IClientAPI client, LLUUID taskID, LLUUID itemID, int answer)
|
|
{
|
|
if (taskID != m_host.UUID)
|
|
return;
|
|
|
|
LLUUID invItemID=InventorySelf();
|
|
|
|
if (invItemID == LLUUID.Zero)
|
|
return;
|
|
|
|
client.OnScriptAnswer-=handleScriptAnswer;
|
|
m_waitingForScriptAnswer=false;
|
|
|
|
m_host.TaskInventory[invItemID].PermsMask=answer;
|
|
m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams(
|
|
"run_time_permissions", new Object[] {
|
|
new LSL_Types.LSLInteger(answer) },
|
|
new XDetectParams[0]));
|
|
}
|
|
|
|
public string llGetPermissionsKey()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 10 && item.ItemID == m_itemID)
|
|
{
|
|
return item.PermsGranter.ToString();
|
|
}
|
|
}
|
|
|
|
return LLUUID.Zero.ToString();
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetPermissions()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 10 && item.ItemID == m_itemID)
|
|
{
|
|
return item.PermsMask;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetLinkNumber()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if (m_host.ParentGroup.Children.Count > 0)
|
|
{
|
|
return m_host.LinkNum + 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public void llSetLinkColor(int linknumber, LSL_Types.Vector3 color, int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknumber);
|
|
if (linknumber > -1)
|
|
{
|
|
LLObject.TextureEntry tex = part.Shape.Textures;
|
|
LLColor texcolor;
|
|
if (face > -1)
|
|
{
|
|
texcolor = tex.CreateFace((uint)face).RGBA;
|
|
texcolor.R = (float)Math.Abs(color.x - 1);
|
|
texcolor.G = (float)Math.Abs(color.y - 1);
|
|
texcolor.B = (float)Math.Abs(color.z - 1);
|
|
tex.FaceTextures[face].RGBA = texcolor;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
else if (face == -1)
|
|
{
|
|
texcolor = tex.DefaultTexture.RGBA;
|
|
texcolor.R = (float)Math.Abs(color.x - 1);
|
|
texcolor.G = (float)Math.Abs(color.y - 1);
|
|
texcolor.B = (float)Math.Abs(color.z - 1);
|
|
tex.DefaultTexture.RGBA = texcolor;
|
|
for (uint i = 0; i < 32; i++)
|
|
{
|
|
if (tex.FaceTextures[i] != null)
|
|
{
|
|
texcolor = tex.FaceTextures[i].RGBA;
|
|
texcolor.R = (float)Math.Abs(color.x - 1);
|
|
texcolor.G = (float)Math.Abs(color.y - 1);
|
|
texcolor.B = (float)Math.Abs(color.z - 1);
|
|
tex.FaceTextures[i].RGBA = texcolor;
|
|
}
|
|
}
|
|
texcolor = tex.DefaultTexture.RGBA;
|
|
texcolor.R = (float)Math.Abs(color.x - 1);
|
|
texcolor.G = (float)Math.Abs(color.y - 1);
|
|
texcolor.B = (float)Math.Abs(color.z - 1);
|
|
tex.DefaultTexture.RGBA = texcolor;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
else if (linknumber == -1)
|
|
{
|
|
int num = m_host.ParentGroup.PrimCount;
|
|
for (int w = 0; w < num; w++)
|
|
{
|
|
linknumber = w;
|
|
part = m_host.ParentGroup.GetLinkNumPart(linknumber);
|
|
LLObject.TextureEntry tex = part.Shape.Textures;
|
|
LLColor texcolor;
|
|
if (face > -1)
|
|
{
|
|
texcolor = tex.CreateFace((uint)face).RGBA;
|
|
texcolor.R = (float)Math.Abs(color.x - 1);
|
|
texcolor.G = (float)Math.Abs(color.y - 1);
|
|
texcolor.B = (float)Math.Abs(color.z - 1);
|
|
tex.FaceTextures[face].RGBA = texcolor;
|
|
part.UpdateTexture(tex);
|
|
}
|
|
else if (face == -1)
|
|
{
|
|
texcolor = tex.DefaultTexture.RGBA;
|
|
texcolor.R = (float)Math.Abs(color.x - 1);
|
|
texcolor.G = (float)Math.Abs(color.y - 1);
|
|
texcolor.B = (float)Math.Abs(color.z - 1);
|
|
tex.DefaultTexture.RGBA = texcolor;
|
|
for (uint i = 0; i < 32; i++)
|
|
{
|
|
if (tex.FaceTextures[i] != null)
|
|
{
|
|
texcolor = tex.FaceTextures[i].RGBA;
|
|
texcolor.R = (float)Math.Abs(color.x - 1);
|
|
texcolor.G = (float)Math.Abs(color.y - 1);
|
|
texcolor.B = (float)Math.Abs(color.z - 1);
|
|
tex.FaceTextures[i].RGBA = texcolor;
|
|
}
|
|
}
|
|
texcolor = tex.DefaultTexture.RGBA;
|
|
texcolor.R = (float)Math.Abs(color.x - 1);
|
|
texcolor.G = (float)Math.Abs(color.y - 1);
|
|
texcolor.B = (float)Math.Abs(color.z - 1);
|
|
tex.DefaultTexture.RGBA = texcolor;
|
|
part.UpdateTexture(tex);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void llCreateLink(string target, int parent)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llCreateLink");
|
|
}
|
|
|
|
public void llBreakLink(int linknum)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llBreakLink");
|
|
}
|
|
|
|
public void llBreakAllLinks()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llBreakAllLinks");
|
|
}
|
|
|
|
public string llGetLinkKey(int linknum)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknum);
|
|
if (part != null)
|
|
{
|
|
return part.UUID.ToString();
|
|
}
|
|
else
|
|
{
|
|
return LLUUID.Zero.ToString();
|
|
}
|
|
}
|
|
|
|
public string llGetLinkName(int linknum)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknum);
|
|
if (part != null)
|
|
{
|
|
return part.Name;
|
|
}
|
|
else
|
|
{
|
|
return LLUUID.Zero.ToString();
|
|
}
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetInventoryNumber(int type)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
int count = 0;
|
|
foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
|
|
{
|
|
if (inv.Value.Type == type || type == -1)
|
|
{
|
|
count = count + 1;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
public string llGetInventoryName(int type, int number)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
ArrayList keys = new ArrayList();
|
|
foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
|
|
{
|
|
if (inv.Value.Type == type || type == -1)
|
|
{
|
|
keys.Add(inv.Value.Name);
|
|
}
|
|
}
|
|
if (keys.Count == 0)
|
|
{
|
|
return String.Empty;
|
|
}
|
|
keys.Sort();
|
|
if (keys.Count > number)
|
|
{
|
|
return (string)keys[number];
|
|
}
|
|
return String.Empty;
|
|
}
|
|
|
|
public void llSetScriptState(string name, int run)
|
|
{
|
|
LLUUID item;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
// These functions are supposed to be robust,
|
|
// so get the state one step at a time.
|
|
|
|
if ((item = ScriptByName(name)) != LLUUID.Zero)
|
|
{
|
|
m_ScriptEngine.SetScriptState(item, run == 0 ? false : true);
|
|
}
|
|
else
|
|
{
|
|
ShoutError("llSetScriptState: script "+name+" not found");
|
|
}
|
|
}
|
|
|
|
public double llGetEnergy()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
// TODO: figure out real energy value
|
|
return 1.0f;
|
|
}
|
|
|
|
public void llGiveInventory(string destination, string inventory)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGiveInventory");
|
|
}
|
|
|
|
public void llRemoveInventory(string item)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llRemoveInventory");
|
|
}
|
|
|
|
public void llSetText(string text, LSL_Types.Vector3 color, double alpha)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
Vector3 av3 = new Vector3((float)color.x, (float)color.y, (float)color.z);
|
|
m_host.SetText(text, av3, alpha);
|
|
}
|
|
|
|
public double llWater(LSL_Types.Vector3 offset)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return World.RegionInfo.EstateSettings.waterHeight;
|
|
}
|
|
|
|
public void llPassTouches(int pass)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llPassTouches");
|
|
}
|
|
|
|
public string llRequestAgentData(string id, int data)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
UserProfileData userProfile =
|
|
World.CommsManager.UserService.GetUserProfile(id);
|
|
|
|
string reply = String.Empty;
|
|
|
|
switch(data)
|
|
{
|
|
case 1: // DATA_ONLINE (0|1)
|
|
// TODO: implement fetching of this information
|
|
// if(userProfile.CurrentAgent.AgentOnline)
|
|
// reply = "1";
|
|
// else
|
|
reply = "0";
|
|
break;
|
|
case 2: // DATA_NAME (First Last)
|
|
reply = userProfile.FirstName+" "+userProfile.SurName;
|
|
break;
|
|
case 3: // DATA_BORN (YYYY-MM-DD)
|
|
DateTime born = new DateTime(1970, 1, 1, 0, 0, 0, 0);
|
|
born = born.AddSeconds(userProfile.Created);
|
|
reply = born.ToString("yyyy-MM-dd");
|
|
break;
|
|
case 4: // DATA_RATING (0,0,0,0,0,0)
|
|
reply = "0,0,0,0,0,0";
|
|
break;
|
|
case 8: // DATA_PAYINFO (0|1|2|3)
|
|
reply = "0";
|
|
break;
|
|
default:
|
|
return LLUUID.Zero.ToString(); // Raise no event
|
|
}
|
|
|
|
LLUUID rq = LLUUID.Random();
|
|
|
|
LLUUID tid = m_ScriptEngine.m_ASYNCLSLCommandManager.
|
|
m_Dataserver.RegisterRequest(m_localID,
|
|
m_itemID, rq.ToString());
|
|
|
|
m_ScriptEngine.m_ASYNCLSLCommandManager.
|
|
m_Dataserver.DataserverReply(rq.ToString(), reply);
|
|
|
|
return tid.ToString();
|
|
}
|
|
|
|
public string llRequestInventoryData(string name)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 3 && item.Name == name)
|
|
{
|
|
LLUUID tid = m_ScriptEngine.m_ASYNCLSLCommandManager.
|
|
m_Dataserver.RegisterRequest(m_localID,
|
|
m_itemID, item.AssetID.ToString());
|
|
|
|
LLVector3 region = new LLVector3(
|
|
World.RegionInfo.RegionLocX * Constants.RegionSize,
|
|
World.RegionInfo.RegionLocY * Constants.RegionSize,
|
|
0);
|
|
|
|
World.AssetCache.GetAsset(item.AssetID,
|
|
delegate(LLUUID i, AssetBase a)
|
|
{
|
|
AssetLandmark lm = new AssetLandmark(a);
|
|
|
|
region += lm.Position;
|
|
|
|
string reply = region.ToString();
|
|
|
|
m_ScriptEngine.m_ASYNCLSLCommandManager.
|
|
m_Dataserver.DataserverReply(i.ToString(),
|
|
reply);
|
|
}, false);
|
|
|
|
return tid.ToString();
|
|
}
|
|
}
|
|
|
|
return String.Empty;
|
|
}
|
|
|
|
public void llSetDamage(double damage)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetDamage");
|
|
}
|
|
|
|
public void llTeleportAgentHome(string agent)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llTeleportAgentHome");
|
|
}
|
|
|
|
public void llModifyLand(int action, int brush)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
World.ExternalChecks.ExternalChecksCanTerraformLand(m_host.OwnerID, new LLVector3(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, 0));
|
|
}
|
|
|
|
public void llCollisionSound(string impact_sound, double impact_volume)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llCollisionSound");
|
|
}
|
|
|
|
public void llCollisionSprite(string impact_sprite)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llCollisionSprite");
|
|
}
|
|
|
|
public string llGetAnimation(string id)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetAnimation");
|
|
return String.Empty;
|
|
}
|
|
|
|
public void llResetScript()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_ScriptEngine.ResetScript(m_itemID);
|
|
}
|
|
|
|
public void llMessageLinked(int linknum, int num, string msg, string id)
|
|
{
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
uint partLocalID;
|
|
LLUUID partItemID;
|
|
|
|
switch ((int)linknum)
|
|
{
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.LINK_ROOT:
|
|
|
|
SceneObjectPart part = m_host.ParentGroup.RootPart;
|
|
|
|
foreach (TaskInventoryItem item in part.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 10)
|
|
{
|
|
partLocalID = part.LocalId;
|
|
partItemID = item.ItemID;
|
|
|
|
object[] resobj = new object[]
|
|
{
|
|
new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id)
|
|
};
|
|
|
|
m_ScriptEngine.PostScriptEvent(partItemID,
|
|
new XEventParams("link_message",
|
|
resobj, new XDetectParams[0]));
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.LINK_SET:
|
|
|
|
Console.WriteLine("LINK_SET");
|
|
|
|
foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts())
|
|
{
|
|
|
|
foreach (TaskInventoryItem item in partInst.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 10)
|
|
{
|
|
partLocalID = partInst.LocalId;
|
|
partItemID = item.ItemID;
|
|
Object[] resobj = new object[]
|
|
{
|
|
new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id)
|
|
};
|
|
|
|
m_ScriptEngine.PostScriptEvent(partItemID,
|
|
new XEventParams("link_message",
|
|
resobj, new XDetectParams[0]));
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.LINK_ALL_OTHERS:
|
|
|
|
foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts())
|
|
{
|
|
|
|
if (partInst.LocalId != m_host.LocalId)
|
|
{
|
|
|
|
foreach (TaskInventoryItem item in partInst.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 10)
|
|
{
|
|
partLocalID = partInst.LocalId;
|
|
partItemID = item.ItemID;
|
|
Object[] resobj = new object[]
|
|
{
|
|
new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id)
|
|
};
|
|
|
|
m_ScriptEngine.PostScriptEvent(partItemID,
|
|
new XEventParams("link_message",
|
|
resobj, new XDetectParams[0]));
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.LINK_ALL_CHILDREN:
|
|
|
|
foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts())
|
|
{
|
|
|
|
if (partInst.LocalId != m_host.ParentGroup.RootPart.LocalId)
|
|
{
|
|
|
|
foreach (TaskInventoryItem item in partInst.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 10)
|
|
{
|
|
partLocalID = partInst.LocalId;
|
|
partItemID = item.ItemID;
|
|
Object[] resobj = new object[]
|
|
{
|
|
new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id)
|
|
};
|
|
|
|
m_ScriptEngine.PostScriptEvent(partItemID,
|
|
new XEventParams("link_message",
|
|
resobj, new XDetectParams[0]));
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.LINK_THIS:
|
|
|
|
foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 10)
|
|
{
|
|
partItemID = item.ItemID;
|
|
|
|
object[] resobj = new object[]
|
|
{
|
|
new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id)
|
|
};
|
|
|
|
m_ScriptEngine.PostScriptEvent(partItemID,
|
|
new XEventParams("link_message",
|
|
resobj, new XDetectParams[0]));
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts())
|
|
{
|
|
|
|
if ((partInst.LinkNum + 1) == linknum)
|
|
{
|
|
|
|
foreach (TaskInventoryItem item in partInst.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 10)
|
|
{
|
|
partLocalID = partInst.LocalId;
|
|
partItemID = item.ItemID;
|
|
Object[] resObjDef = new object[]
|
|
{
|
|
new LSL_Types.LSLInteger(m_host.LinkNum + 1), new LSL_Types.LSLInteger(num), new LSL_Types.LSLString(msg), new LSL_Types.LSLString(id)
|
|
};
|
|
|
|
m_ScriptEngine.PostScriptEvent(partItemID,
|
|
new XEventParams("link_message",
|
|
resObjDef, new XDetectParams[0]));
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public void llPushObject(string target, LSL_Types.Vector3 impulse, LSL_Types.Vector3 ang_impulse, int local)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llPushObject");
|
|
}
|
|
|
|
public void llPassCollisions(int pass)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llPassCollisions");
|
|
}
|
|
|
|
public string llGetScriptName()
|
|
{
|
|
|
|
string result = String.Empty;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 10 && item.ItemID == m_itemID)
|
|
{
|
|
result = item.Name!=null?item.Name:String.Empty;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetNumberOfSides()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetNumberOfSides");
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* The new / changed functions were tested with the following LSL script:
|
|
|
|
default
|
|
{
|
|
state_entry()
|
|
{
|
|
rotation rot = llEuler2Rot(<0,70,0> * DEG_TO_RAD);
|
|
|
|
llOwnerSay("to get here, we rotate over: "+ (string) llRot2Axis(rot));
|
|
llOwnerSay("and we rotate for: "+ (llRot2Angle(rot) * RAD_TO_DEG));
|
|
|
|
// convert back and forth between quaternion <-> vector and angle
|
|
|
|
rotation newrot = llAxisAngle2Rot(llRot2Axis(rot),llRot2Angle(rot));
|
|
|
|
llOwnerSay("Old rotation was: "+(string) rot);
|
|
llOwnerSay("re-converted rotation is: "+(string) newrot);
|
|
|
|
llSetRot(rot); // to check the parameters in the prim
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
// Xantor 29/apr/2008
|
|
// Returns rotation described by rotating angle radians about axis.
|
|
// q = cos(a/2) + i (x * sin(a/2)) + j (y * sin(a/2)) + k (z * sin(a/2))
|
|
public LSL_Types.Quaternion llAxisAngle2Rot(LSL_Types.Vector3 axis, double angle)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
double x, y, z, s, t;
|
|
|
|
s = Math.Cos(angle / 2);
|
|
t = Math.Sin(angle / 2); // temp value to avoid 2 more sin() calcs
|
|
x = axis.x * t;
|
|
y = axis.y * t;
|
|
z = axis.z * t;
|
|
|
|
return new LSL_Types.Quaternion(x,y,z,s);
|
|
// NotImplemented("llAxisAngle2Rot");
|
|
}
|
|
|
|
|
|
// Xantor 29/apr/2008
|
|
// converts a Quaternion to X,Y,Z axis rotations
|
|
public LSL_Types.Vector3 llRot2Axis(LSL_Types.Quaternion rot)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
double x,y,z;
|
|
|
|
if (rot.s > 1) // normalization needed
|
|
{
|
|
double length = Math.Sqrt(rot.x * rot.x + rot.y * rot.y +
|
|
rot.z * rot.z + rot.s * rot.s);
|
|
|
|
rot.x /= length;
|
|
rot.y /= length;
|
|
rot.z /= length;
|
|
rot.s /= length;
|
|
|
|
}
|
|
|
|
double angle = 2 * Math.Acos(rot.s);
|
|
double s = Math.Sqrt(1 - rot.s * rot.s);
|
|
if (s < 0.001)
|
|
{
|
|
x = 1;
|
|
y = z = 0;
|
|
}
|
|
else
|
|
{
|
|
x = rot.x / s; // normalise axis
|
|
y = rot.y / s;
|
|
z = rot.z / s;
|
|
}
|
|
|
|
|
|
return new LSL_Types.Vector3(x,y,z);
|
|
|
|
|
|
// NotImplemented("llRot2Axis");
|
|
}
|
|
|
|
|
|
// Returns the angle of a quaternion (see llRot2Axis for the axis)
|
|
public double llRot2Angle(LSL_Types.Quaternion rot)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if (rot.s > 1) // normalization needed
|
|
{
|
|
double length = Math.Sqrt(rot.x * rot.x + rot.y * rot.y +
|
|
rot.z * rot.z + rot.s * rot.s);
|
|
|
|
rot.x /= length;
|
|
rot.y /= length;
|
|
rot.z /= length;
|
|
rot.s /= length;
|
|
|
|
}
|
|
|
|
double angle = 2 * Math.Acos(rot.s);
|
|
|
|
return angle;
|
|
|
|
// NotImplemented("llRot2Angle");
|
|
}
|
|
|
|
public double llAcos(double val)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (double)Math.Acos(val);
|
|
}
|
|
|
|
public double llAsin(double val)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (double)Math.Asin(val);
|
|
}
|
|
|
|
// Xantor 30/apr/2008
|
|
public double llAngleBetween(LSL_Types.Quaternion a, LSL_Types.Quaternion b)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
return (double) Math.Acos(a.x * b.x + a.y * b.y + a.z * b.z + a.s * b.s) * 2;
|
|
// NotImplemented("llAngleBetween");
|
|
}
|
|
|
|
public string llGetInventoryKey(string name)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
|
|
{
|
|
if (inv.Value.Name == name)
|
|
{
|
|
if ((inv.Value.OwnerMask & (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify)) == (uint)(PermissionMask.Copy | PermissionMask.Transfer | PermissionMask.Modify))
|
|
{
|
|
return inv.Value.AssetID.ToString();
|
|
}
|
|
else
|
|
{
|
|
return LLUUID.Zero.ToString();
|
|
}
|
|
}
|
|
}
|
|
return LLUUID.Zero.ToString();
|
|
}
|
|
|
|
public void llAllowInventoryDrop(int add)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llAllowInventoryDrop");
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetSunDirection()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
LSL_Types.Vector3 SunDoubleVector3;
|
|
LLVector3 SunFloatVector3;
|
|
|
|
// sunPosition estate setting is set in OpenSim.Region.Environment.Modules.SunModule
|
|
// have to convert from LLVector3 (float) to LSL_Types.Vector3 (double)
|
|
SunFloatVector3 = World.RegionInfo.EstateSettings.sunPosition;
|
|
SunDoubleVector3.x = (double)SunFloatVector3.X;
|
|
SunDoubleVector3.y = (double)SunFloatVector3.Y;
|
|
SunDoubleVector3.z = (double)SunFloatVector3.Z;
|
|
|
|
return SunDoubleVector3;
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetTextureOffset(int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLObject.TextureEntry tex = m_host.Shape.Textures;
|
|
LSL_Types.Vector3 offset;
|
|
if (face == -1)
|
|
{
|
|
face = 0;
|
|
}
|
|
offset.x = tex.GetFace((uint)face).OffsetU;
|
|
offset.y = tex.GetFace((uint)face).OffsetV;
|
|
offset.z = 0.0;
|
|
return offset;
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetTextureScale(int side)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLObject.TextureEntry tex = m_host.Shape.Textures;
|
|
LSL_Types.Vector3 scale;
|
|
if (side == -1)
|
|
{
|
|
side = 0;
|
|
}
|
|
scale.x = tex.GetFace((uint)side).RepeatU;
|
|
scale.y = tex.GetFace((uint)side).RepeatV;
|
|
scale.z = 0.0;
|
|
return scale;
|
|
}
|
|
|
|
public double llGetTextureRot(int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLObject.TextureEntry tex = m_host.Shape.Textures;
|
|
if (face == -1)
|
|
{
|
|
face = 0;
|
|
}
|
|
return tex.GetFace((uint)face).Rotation;
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llSubStringIndex(string source, string pattern)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return source.IndexOf(pattern);
|
|
}
|
|
|
|
public string llGetOwnerKey(string id)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID key = new LLUUID();
|
|
if (LLUUID.TryParse(id, out key))
|
|
{
|
|
return World.GetSceneObjectPart(World.Entities[key].LocalId).OwnerID.ToString();
|
|
}
|
|
else
|
|
{
|
|
return LLUUID.Zero.ToString();
|
|
}
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetCenterOfMass()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetCenterOfMass");
|
|
return new LSL_Types.Vector3();
|
|
}
|
|
|
|
public LSL_Types.list llListSort(LSL_Types.list src, int stride, int ascending)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return src.Sort(stride, ascending);
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetListLength(LSL_Types.list src)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return src.Length;
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llList2Integer(LSL_Types.list src, int index)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (index < 0)
|
|
{
|
|
index = src.Length + index;
|
|
}
|
|
if (index >= src.Length)
|
|
{
|
|
return 0;
|
|
}
|
|
try
|
|
{
|
|
return Convert.ToInt32(src.Data[index]);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public double osList2Double(LSL_Types.list src, int index)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (index < 0)
|
|
{
|
|
index = src.Length + index;
|
|
}
|
|
if (index >= src.Length)
|
|
{
|
|
return 0.0;
|
|
}
|
|
return Convert.ToDouble(src.Data[index]);
|
|
}
|
|
|
|
public double llList2Float(LSL_Types.list src, int index)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (index < 0)
|
|
{
|
|
index = src.Length + index;
|
|
}
|
|
if (index >= src.Length)
|
|
{
|
|
return 0.0;
|
|
}
|
|
try
|
|
{
|
|
return Convert.ToDouble(src.Data[index]);
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
return 0.0;
|
|
}
|
|
}
|
|
|
|
public string llList2String(LSL_Types.list src, int index)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (index < 0)
|
|
{
|
|
index = src.Length + index;
|
|
}
|
|
if (index >= src.Length)
|
|
{
|
|
return String.Empty;
|
|
}
|
|
return src.Data[index].ToString();
|
|
}
|
|
|
|
public string llList2Key(LSL_Types.list src, int index)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (index < 0)
|
|
{
|
|
index = src.Length + index;
|
|
}
|
|
if (index >= src.Length)
|
|
{
|
|
return "";
|
|
}
|
|
return src.Data[index].ToString();
|
|
}
|
|
|
|
public LSL_Types.Vector3 llList2Vector(LSL_Types.list src, int index)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (index < 0)
|
|
{
|
|
index = src.Length + index;
|
|
}
|
|
if (index >= src.Length)
|
|
{
|
|
return new LSL_Types.Vector3(0, 0, 0);
|
|
}
|
|
if (src.Data[index].GetType() == typeof(LSL_Types.Vector3))
|
|
{
|
|
return (LSL_Types.Vector3)src.Data[index];
|
|
}
|
|
else
|
|
{
|
|
return new LSL_Types.Vector3(src.Data[index].ToString());
|
|
}
|
|
}
|
|
|
|
public LSL_Types.Quaternion llList2Rot(LSL_Types.list src, int index)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (index < 0)
|
|
{
|
|
index = src.Length + index;
|
|
}
|
|
if (index >= src.Length)
|
|
{
|
|
return new LSL_Types.Quaternion(0, 0, 0, 1);
|
|
}
|
|
if (src.Data[index].GetType() == typeof(LSL_Types.Quaternion))
|
|
{
|
|
return (LSL_Types.Quaternion)src.Data[index];
|
|
}
|
|
else
|
|
{
|
|
return new LSL_Types.Quaternion(src.Data[index].ToString());
|
|
}
|
|
}
|
|
|
|
public LSL_Types.list llList2List(LSL_Types.list src, int start, int end)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return src.GetSublist(start, end);
|
|
}
|
|
|
|
public LSL_Types.list llDeleteSubList(LSL_Types.list src, int start, int end)
|
|
{
|
|
return src.DeleteSublist(end, start);
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetListEntryType(LSL_Types.list src, int index)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (index < 0)
|
|
{
|
|
index = src.Length + index;
|
|
}
|
|
if (index >= src.Length)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (src.Data[index] is Int32)
|
|
return 1;
|
|
if (src.Data[index] is Double)
|
|
return 2;
|
|
if (src.Data[index] is String)
|
|
{
|
|
LLUUID tuuid;
|
|
if (LLUUID.TryParse(src.Data[index].ToString(), out tuuid))
|
|
{
|
|
return 3;
|
|
}
|
|
else
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
if (src.Data[index] is LSL_Types.Vector3)
|
|
return 5;
|
|
if (src.Data[index] is LSL_Types.Quaternion)
|
|
return 6;
|
|
if (src.Data[index] is LSL_Types.list)
|
|
return 7;
|
|
return 0;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Process the supplied list and return the
|
|
/// content of the list formatted as a comma
|
|
/// separated list. There is a space after
|
|
/// each comma.
|
|
/// </summary>
|
|
|
|
public string llList2CSV(LSL_Types.list src)
|
|
{
|
|
|
|
string ret = String.Empty;
|
|
int x = 0;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if (src.Data.Length > 0)
|
|
{
|
|
ret = src.Data[x++].ToString();
|
|
for (; x < src.Data.Length; x++)
|
|
{
|
|
ret += ", "+src.Data[x].ToString();
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The supplied string is scanned for commas
|
|
/// and converted into a list. Commas are only
|
|
/// effective if they are encountered outside
|
|
/// of '<' '>' delimiters. Any whitespace
|
|
/// before or after an element is trimmed.
|
|
/// </summary>
|
|
|
|
public LSL_Types.list llCSV2List(string src)
|
|
{
|
|
|
|
LSL_Types.list result = new LSL_Types.list();
|
|
int parens = 0;
|
|
int start = 0;
|
|
int length = 0;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
for (int i = 0; i < src.Length; i++)
|
|
{
|
|
switch (src[i])
|
|
{
|
|
case '<' :
|
|
parens++;
|
|
length++;
|
|
break;
|
|
case '>' :
|
|
if (parens > 0)
|
|
parens--;
|
|
length++;
|
|
break;
|
|
case ',' :
|
|
if (parens == 0)
|
|
{
|
|
result.Add(src.Substring(start,length).Trim());
|
|
start += length+1;
|
|
length = 0;
|
|
} else
|
|
length++;
|
|
break;
|
|
default :
|
|
length++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
result.Add(src.Substring(start,length).Trim());
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Randomizes the list, be arbitrarily reordering
|
|
/// sublists of stride elements. As the stride approaches
|
|
/// the size of the list, the options become very
|
|
/// limited.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This could take a while for very large list
|
|
/// sizes.
|
|
/// </remarks>
|
|
|
|
public LSL_Types.list llListRandomize(LSL_Types.list src, int stride)
|
|
{
|
|
|
|
LSL_Types.list result;
|
|
Random rand = new Random();
|
|
|
|
int chunkk;
|
|
int[] chunks;
|
|
int index1;
|
|
int index2;
|
|
int tmp;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if (stride == 0)
|
|
stride = 1;
|
|
|
|
// Stride MUST be a factor of the list length
|
|
// If not, then return the src list. This also
|
|
// traps those cases where stride > length.
|
|
|
|
if (src.Length != stride && src.Length%stride == 0)
|
|
{
|
|
chunkk = src.Length/stride;
|
|
|
|
chunks = new int[chunkk];
|
|
|
|
for (int i = 0; i < chunkk; i++)
|
|
chunks[i] = i;
|
|
|
|
for (int i = 0; i < chunkk - 1; i++)
|
|
{
|
|
// randomly select 2 chunks
|
|
index1 = rand.Next(rand.Next(65536));
|
|
index1 = index1%chunkk;
|
|
index2 = rand.Next(rand.Next(65536));
|
|
index2 = index2%chunkk;
|
|
|
|
// and swap their relative positions
|
|
tmp = chunks[index1];
|
|
chunks[index1] = chunks[index2];
|
|
chunks[index2] = tmp;
|
|
}
|
|
|
|
// Construct the randomized list
|
|
|
|
result = new LSL_Types.list();
|
|
|
|
for (int i = 0; i < chunkk; i++)
|
|
{
|
|
for (int j = 0; j < stride; j++)
|
|
{
|
|
result.Add(src.Data[chunks[i]*stride+j]);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
object[] array = new object[src.Length];
|
|
Array.Copy(src.Data, 0, array, 0, src.Length);
|
|
result = new LSL_Types.list(array);
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elements in the source list starting with 0 and then
|
|
/// every i+stride. If the stride is negative then the scan
|
|
/// is backwards producing an inverted result.
|
|
/// Only those elements that are also in the specified
|
|
/// range are included in the result.
|
|
/// </summary>
|
|
|
|
public LSL_Types.list llList2ListStrided(LSL_Types.list src, int start, int end, int stride)
|
|
{
|
|
|
|
LSL_Types.list result = new LSL_Types.list();
|
|
int[] si = new int[2];
|
|
int[] ei = new int[2];
|
|
bool twopass = false;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
// First step is always to deal with negative indices
|
|
|
|
if (start < 0)
|
|
start = src.Length+start;
|
|
if (end < 0)
|
|
end = src.Length+end;
|
|
|
|
// Out of bounds indices are OK, just trim them
|
|
// accordingly
|
|
|
|
if (start > src.Length)
|
|
start = src.Length;
|
|
|
|
if (end > src.Length)
|
|
end = src.Length;
|
|
|
|
// There may be one or two ranges to be considered
|
|
|
|
if (start != end)
|
|
{
|
|
|
|
if (start <= end)
|
|
{
|
|
si[0] = start;
|
|
ei[0] = end;
|
|
}
|
|
else
|
|
{
|
|
si[1] = start;
|
|
ei[1] = src.Length;
|
|
si[0] = 0;
|
|
ei[0] = end;
|
|
twopass = true;
|
|
}
|
|
|
|
// The scan always starts from the beginning of the
|
|
// source list, but members are only selected if they
|
|
// fall within the specified sub-range. The specified
|
|
// range values are inclusive.
|
|
// A negative stride reverses the direction of the
|
|
// scan producing an inverted list as a result.
|
|
|
|
if (stride == 0)
|
|
stride = 1;
|
|
|
|
if (stride > 0)
|
|
{
|
|
for (int i = 0; i < src.Length; i += stride)
|
|
{
|
|
if (i<=ei[0] && i>=si[0])
|
|
result.Add(src.Data[i]);
|
|
if (twopass && i>=si[1] && i<=ei[1])
|
|
result.Add(src.Data[i]);
|
|
}
|
|
}
|
|
else if (stride < 0)
|
|
{
|
|
for (int i = src.Length - 1; i >= 0; i += stride)
|
|
{
|
|
if (i <= ei[0] && i >= si[0])
|
|
result.Add(src.Data[i]);
|
|
if (twopass && i >= si[1] && i <= ei[1])
|
|
result.Add(src.Data[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetRegionCorner()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return new LSL_Types.Vector3(World.RegionInfo.RegionLocX * Constants.RegionSize, World.RegionInfo.RegionLocY * Constants.RegionSize, 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Insert the list identified by <src> into the
|
|
/// list designated by <dest> such that the first
|
|
/// new element has the index specified by <index>
|
|
/// </summary>
|
|
|
|
public LSL_Types.list llListInsertList(LSL_Types.list dest, LSL_Types.list src, int index)
|
|
{
|
|
|
|
LSL_Types.list pref = null;
|
|
LSL_Types.list suff = null;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if (index < 0)
|
|
{
|
|
index = index+dest.Length;
|
|
if (index < 0)
|
|
{
|
|
index = 0;
|
|
}
|
|
}
|
|
|
|
if (index != 0)
|
|
{
|
|
pref = dest.GetSublist(0,index-1);
|
|
if (index < dest.Length)
|
|
{
|
|
suff = dest.GetSublist(index,-1);
|
|
return pref + src + suff;
|
|
}
|
|
else
|
|
{
|
|
return pref + src;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (index < dest.Length)
|
|
{
|
|
suff = dest.GetSublist(index,-1);
|
|
return src + suff;
|
|
}
|
|
else
|
|
{
|
|
return src;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the index of the first occurrence of test
|
|
/// in src.
|
|
/// </summary>
|
|
|
|
public LSL_Types.LSLInteger llListFindList(LSL_Types.list src, LSL_Types.list test)
|
|
{
|
|
|
|
int index = -1;
|
|
int length = src.Length - test.Length + 1;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
// If either list is empty, do not match
|
|
|
|
if (src.Length != 0 && test.Length != 0)
|
|
{
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
if (src.Data[i].Equals(test.Data[0]))
|
|
{
|
|
int j;
|
|
for (j = 1; j < test.Length; j++)
|
|
if (!src.Data[i+j].Equals(test.Data[j]))
|
|
break;
|
|
if (j == test.Length)
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
public string llGetObjectName()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return m_host.Name!=null?m_host.Name:String.Empty;
|
|
}
|
|
|
|
public void llSetObjectName(string name)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.Name = name!=null?name:String.Empty;
|
|
}
|
|
|
|
public string llGetDate()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
DateTime date = DateTime.Now.ToUniversalTime();
|
|
string result = date.ToString("yyyy-MM-dd");
|
|
return result;
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llEdgeOfWorld(LSL_Types.Vector3 pos, LSL_Types.Vector3 dir)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llEdgeOfWorld");
|
|
return 0;
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetAgentInfo(string id)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetAgentInfo");
|
|
return 0;
|
|
}
|
|
|
|
public void llAdjustSoundVolume(double volume)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.AdjustSoundGain(volume);
|
|
}
|
|
|
|
public void llSetSoundQueueing(int queue)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetSoundQueueing");
|
|
}
|
|
|
|
public void llSetSoundRadius(double radius)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetSoundRadius");
|
|
}
|
|
|
|
public string llKey2Name(string id)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID key = new LLUUID();
|
|
if (LLUUID.TryParse(id,out key))
|
|
{
|
|
ScenePresence presence = World.GetScenePresence(key);
|
|
|
|
if (presence != null)
|
|
{
|
|
return presence.Name;
|
|
}
|
|
|
|
if (World.GetSceneObjectPart(key) != null)
|
|
{
|
|
return World.GetSceneObjectPart(key).Name;
|
|
}
|
|
}
|
|
return String.Empty;
|
|
}
|
|
|
|
|
|
|
|
public void llSetTextureAnim(int mode, int face, int sizex, int sizey, double start, double length, double rate)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
Primitive.TextureAnimation pTexAnim = new Primitive.TextureAnimation();
|
|
pTexAnim.Flags =(uint) mode;
|
|
|
|
//ALL_SIDES
|
|
if (face == -1)
|
|
face = 255;
|
|
|
|
pTexAnim.Face = (uint)face;
|
|
pTexAnim.Length = (float)length;
|
|
pTexAnim.Rate = (float)rate;
|
|
pTexAnim.SizeX = (uint)sizex;
|
|
pTexAnim.SizeY = (uint)sizey;
|
|
pTexAnim.Start = (float)start;
|
|
|
|
m_host.AddTextureAnimation(pTexAnim);
|
|
m_host.SendFullUpdateToAllClients();
|
|
}
|
|
|
|
public void llTriggerSoundLimited(string sound, double volume, LSL_Types.Vector3 top_north_east,
|
|
LSL_Types.Vector3 bottom_south_west)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llTriggerSoundLimited");
|
|
}
|
|
|
|
public void llEjectFromLand(string pest)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llEjectFromLand");
|
|
}
|
|
|
|
public LSL_Types.list llParseString2List(string str, LSL_Types.list separators, LSL_Types.list spacers)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LSL_Types.list ret = new LSL_Types.list();
|
|
object[] delimiters = new object[separators.Length + spacers.Length];
|
|
separators.Data.CopyTo(delimiters, 0);
|
|
spacers.Data.CopyTo(delimiters, separators.Length);
|
|
bool dfound = false;
|
|
do
|
|
{
|
|
dfound = false;
|
|
int cindex = -1;
|
|
string cdeli = "";
|
|
for (int i = 0; i < delimiters.Length; i++)
|
|
{
|
|
int index = str.IndexOf(delimiters[i].ToString());
|
|
bool found = index != -1;
|
|
if (found)
|
|
{
|
|
if ((cindex > index) || (cindex == -1))
|
|
{
|
|
cindex = index;
|
|
cdeli = (string)delimiters[i];
|
|
}
|
|
dfound = dfound || found;
|
|
}
|
|
}
|
|
if (cindex != -1)
|
|
{
|
|
if (cindex > 0)
|
|
{
|
|
ret.Add(str.Substring(0, cindex));
|
|
if (spacers.Contains(cdeli))
|
|
{
|
|
ret.Add(cdeli);
|
|
}
|
|
}
|
|
if (cindex == 0 && spacers.Contains(cdeli))
|
|
{
|
|
ret.Add(cdeli);
|
|
}
|
|
str = str.Substring(cindex + cdeli.Length);
|
|
}
|
|
} while (dfound);
|
|
if (str != "")
|
|
{
|
|
ret.Add(str);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llOverMyLand(string id)
|
|
{
|
|
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID key = new LLUUID();
|
|
if (LLUUID.TryParse(id,out key))
|
|
{
|
|
SceneObjectPart obj = new SceneObjectPart();
|
|
obj = World.GetSceneObjectPart(World.Entities[key].LocalId);
|
|
if (obj.OwnerID == World.GetLandOwner(obj.AbsolutePosition.X, obj.AbsolutePosition.Y))
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public string llGetLandOwnerAt(LSL_Types.Vector3 pos)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return World.GetLandOwner((float)pos.x, (float)pos.y).ToString();
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetAgentSize(string id)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetAgentSize");
|
|
return new LSL_Types.Vector3();
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llSameGroup(string agent)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSameGroup");
|
|
return 0;
|
|
}
|
|
|
|
public void llUnSit(string id)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
LLUUID key = new LLUUID();
|
|
if (LLUUID.TryParse(id, out key))
|
|
{
|
|
ScenePresence av = World.GetScenePresence(key);
|
|
|
|
if (av != null)
|
|
{
|
|
if (llAvatarOnSitTarget() == id)
|
|
{
|
|
// if the avatar is sitting on this object, then
|
|
// we can unsit them. We don't want random scripts unsitting random people
|
|
// Lets avoid the popcorn avatar scenario.
|
|
av.StandUp();
|
|
}
|
|
else
|
|
{
|
|
// If the object owner also owns the parcel
|
|
// or
|
|
// if the land is group owned and the object is group owned by the same group
|
|
// or
|
|
// if the object is owned by a person with estate access.
|
|
|
|
ILandObject parcel = World.LandChannel.GetLandObject(av.AbsolutePosition.X, av.AbsolutePosition.Y);
|
|
if (parcel != null)
|
|
{
|
|
if (m_host.ObjectOwner == parcel.landData.ownerID ||
|
|
(m_host.OwnerID == m_host.GroupID && m_host.GroupID == parcel.landData.groupID
|
|
&& parcel.landData.isGroupOwned) || World.ExternalChecks.ExternalChecksCanBeGodLike(m_host.OwnerID))
|
|
{
|
|
av.StandUp();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGroundSlope(LSL_Types.Vector3 offset)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGroundSlope");
|
|
return new LSL_Types.Vector3();
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGroundNormal(LSL_Types.Vector3 offset)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGroundNormal");
|
|
return new LSL_Types.Vector3();
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGroundContour(LSL_Types.Vector3 offset)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGroundContour");
|
|
return new LSL_Types.Vector3();
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetAttached()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetAttached");
|
|
return 0;
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetFreeMemory()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetFreeMemory");
|
|
return 0;
|
|
}
|
|
|
|
public string llGetRegionName()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return World.RegionInfo.RegionName;
|
|
}
|
|
|
|
public double llGetRegionTimeDilation()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (double)World.TimeDilation;
|
|
}
|
|
|
|
public double llGetRegionFPS()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
//TODO: return actual FPS
|
|
return 10.0f;
|
|
}
|
|
|
|
/* particle system rules should be coming into this routine as doubles, that is
|
|
rule[0] should be an integer from this list and rule[1] should be the arg
|
|
for the same integer. wiki.secondlife.com has most of this mapping, but some
|
|
came from http://www.caligari-designs.com/p4u2
|
|
|
|
We iterate through the list for 'Count' elements, incrementing by two for each
|
|
iteration and set the members of Primitive.ParticleSystem, one at a time.
|
|
*/
|
|
|
|
public enum PrimitiveRule : int
|
|
{
|
|
PSYS_PART_FLAGS = 0,
|
|
PSYS_PART_START_COLOR = 1,
|
|
PSYS_PART_START_ALPHA = 2,
|
|
PSYS_PART_END_COLOR = 3,
|
|
PSYS_PART_END_ALPHA = 4,
|
|
PSYS_PART_START_SCALE = 5,
|
|
PSYS_PART_END_SCALE = 6,
|
|
PSYS_PART_MAX_AGE = 7,
|
|
PSYS_SRC_ACCEL = 8,
|
|
PSYS_SRC_PATTERN = 9,
|
|
PSYS_SRC_TEXTURE = 12,
|
|
PSYS_SRC_BURST_RATE = 13,
|
|
PSYS_SRC_BURST_PART_COUNT = 15,
|
|
PSYS_SRC_BURST_RADIUS = 16,
|
|
PSYS_SRC_BURST_SPEED_MIN = 17,
|
|
PSYS_SRC_BURST_SPEED_MAX = 18,
|
|
PSYS_SRC_MAX_AGE = 19,
|
|
PSYS_SRC_TARGET_KEY = 20,
|
|
PSYS_SRC_OMEGA = 21,
|
|
PSYS_SRC_ANGLE_BEGIN = 22,
|
|
PSYS_SRC_ANGLE_END = 23
|
|
}
|
|
|
|
internal Primitive.ParticleSystem.ParticleDataFlags ConvertUINTtoFlags(uint flags)
|
|
{
|
|
Primitive.ParticleSystem.ParticleDataFlags returnval = Primitive.ParticleSystem.ParticleDataFlags.None;
|
|
|
|
return returnval;
|
|
}
|
|
|
|
|
|
public void llParticleSystem(LSL_Types.list rules)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
Primitive.ParticleSystem prules = new Primitive.ParticleSystem();
|
|
LSL_Types.Vector3 tempv = new LSL_Types.Vector3();
|
|
|
|
float tempf = 0;
|
|
|
|
for (int i = 0; i < rules.Length; i += 2)
|
|
{
|
|
switch ((int)rules.Data[i])
|
|
{
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_PART_FLAGS:
|
|
prules.PartDataFlags = (Primitive.ParticleSystem.ParticleDataFlags)((uint)Convert.ToInt32(rules.Data[i + 1].ToString()));
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_PART_START_COLOR:
|
|
tempv = (LSL_Types.Vector3)rules.Data[i + 1];
|
|
prules.PartStartColor.R = (float)tempv.x;
|
|
prules.PartStartColor.G = (float)tempv.y;
|
|
prules.PartStartColor.B = (float)tempv.z;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_PART_START_ALPHA:
|
|
tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
|
|
prules.PartStartColor.A = (float)tempf;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_PART_END_COLOR:
|
|
tempv = (LSL_Types.Vector3)rules.Data[i + 1];
|
|
//prules.PartEndColor = new LLColor(tempv.x,tempv.y,tempv.z,1);
|
|
|
|
prules.PartEndColor.R = (float)tempv.x;
|
|
prules.PartEndColor.G = (float)tempv.y;
|
|
prules.PartEndColor.B = (float)tempv.z;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_PART_END_ALPHA:
|
|
tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
|
|
prules.PartEndColor.A = (float)tempf;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_PART_START_SCALE:
|
|
tempv = (LSL_Types.Vector3)rules.Data[i + 1];
|
|
prules.PartStartScaleX = (float)tempv.x;
|
|
prules.PartStartScaleY = (float)tempv.y;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_PART_END_SCALE:
|
|
tempv = (LSL_Types.Vector3)rules.Data[i + 1];
|
|
prules.PartEndScaleX = (float)tempv.x;
|
|
prules.PartEndScaleY = (float)tempv.y;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_PART_MAX_AGE:
|
|
tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
|
|
prules.PartMaxAge = (float)tempf;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_ACCEL:
|
|
tempv = (LSL_Types.Vector3)rules.Data[i + 1];
|
|
prules.PartAcceleration.X = (float)tempv.x;
|
|
prules.PartAcceleration.Y = (float)tempv.y;
|
|
prules.PartAcceleration.Z = (float)tempv.z;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_PATTERN:
|
|
int tmpi = int.Parse(rules.Data[i + 1].ToString());
|
|
prules.Pattern = (Primitive.ParticleSystem.SourcePattern)tmpi;
|
|
break;
|
|
|
|
// Xantor 03-May-2008
|
|
// Wiki: PSYS_SRC_TEXTURE string inventory item name or key of the particle texture
|
|
// "" = default texture.
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_TEXTURE:
|
|
LLUUID tkey = LLUUID.Zero;
|
|
|
|
// if we can parse the string as a key, use it.
|
|
if (LLUUID.TryParse(rules.Data[i + 1].ToString(), out tkey))
|
|
{
|
|
prules.Texture = tkey;
|
|
}
|
|
// else try to locate the name in inventory of object. found returns key,
|
|
// not found returns LLUUID.Zero which will translate to the default particle texture
|
|
else
|
|
{
|
|
prules.Texture = InventoryKey(rules.Data[i+1].ToString());
|
|
}
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_BURST_RATE:
|
|
tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
|
|
prules.BurstRate = (float)tempf;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_BURST_PART_COUNT:
|
|
prules.BurstPartCount = (byte)Convert.ToByte(rules.Data[i + 1].ToString());
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_BURST_RADIUS:
|
|
tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
|
|
prules.BurstRadius = (float)tempf;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_BURST_SPEED_MIN:
|
|
tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
|
|
prules.BurstSpeedMin = (float)tempf;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_BURST_SPEED_MAX:
|
|
tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
|
|
prules.BurstSpeedMax = (float)tempf;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_MAX_AGE:
|
|
tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
|
|
prules.MaxAge = (float)tempf;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_TARGET_KEY:
|
|
LLUUID key = LLUUID.Zero;
|
|
if (LLUUID.TryParse(rules.Data[i + 1].ToString(), out key))
|
|
{
|
|
prules.Target = key;
|
|
}
|
|
else
|
|
{
|
|
prules.Target = m_host.UUID;
|
|
}
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_OMEGA:
|
|
// AL: This is an assumption, since it is the only thing that would match.
|
|
tempv = (LSL_Types.Vector3)rules.Data[i + 1];
|
|
prules.AngularVelocity.X = (float)tempv.x;
|
|
prules.AngularVelocity.Y = (float)tempv.y;
|
|
prules.AngularVelocity.Z = (float)tempv.z;
|
|
//cast?? prules.MaxAge = (float)rules[i + 1];
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_ANGLE_BEGIN:
|
|
tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
|
|
prules.InnerAngle = (float)tempf;
|
|
break;
|
|
|
|
case (int)BuiltIn_Commands_BaseClass.PSYS_SRC_ANGLE_END:
|
|
tempf = Convert.ToSingle(rules.Data[i + 1].ToString());
|
|
prules.OuterAngle = (float)tempf;
|
|
break;
|
|
}
|
|
|
|
}
|
|
prules.CRC = 1;
|
|
|
|
m_host.AddNewParticleSystem(prules);
|
|
m_host.SendFullUpdateToAllClients();
|
|
}
|
|
|
|
public void llGroundRepel(double height, int water, double tau)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGroundRepel");
|
|
}
|
|
|
|
public void llGiveInventoryList(string destination, string category, LSL_Types.list inventory)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGiveInventoryList");
|
|
}
|
|
|
|
public void llSetVehicleType(int type)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetVehicleType");
|
|
}
|
|
|
|
public void llSetVehicledoubleParam(int param, double value)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetVehicledoubleParam");
|
|
}
|
|
|
|
public void llSetVehicleFloatParam(int param, float value)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetVehicleFloatParam");
|
|
}
|
|
|
|
public void llSetVehicleVectorParam(int param, LSL_Types.Vector3 vec)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetVehicleVectorParam");
|
|
}
|
|
|
|
public void llSetVehicleRotationParam(int param, LSL_Types.Quaternion rot)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetVehicleRotationParam");
|
|
}
|
|
|
|
public void llSetVehicleFlags(int flags)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetVehicleFlags");
|
|
}
|
|
|
|
public void llRemoveVehicleFlags(int flags)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llRemoveVehicleFlags");
|
|
}
|
|
|
|
public void llSitTarget(LSL_Types.Vector3 offset, LSL_Types.Quaternion rot)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
// LSL quaternions can normalize to 0, normal Quaternions can't.
|
|
if (rot.s == 0 && rot.x == 0 && rot.y == 0 && rot.z == 0)
|
|
rot.z = 1; // ZERO_ROTATION = 0,0,0,1
|
|
|
|
m_host.SetSitTarget(new Vector3((float)offset.x, (float)offset.y, (float)offset.z), new Quaternion((float)rot.s, (float)rot.x, (float)rot.y, (float)rot.z));
|
|
}
|
|
|
|
public string llAvatarOnSitTarget()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return m_host.GetAvatarOnSitTarget().ToString();
|
|
//LLUUID AVID = m_host.GetAvatarOnSitTarget();
|
|
|
|
//if (AVID != LLUUID.Zero)
|
|
// return AVID.ToString();
|
|
//else
|
|
// return String.Empty;
|
|
}
|
|
|
|
public void llAddToLandPassList(string avatar, double hours)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID key;
|
|
LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData;
|
|
if (land.ownerID == m_host.OwnerID)
|
|
{
|
|
ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry();
|
|
if (LLUUID.TryParse(avatar, out key))
|
|
{
|
|
entry.AgentID = key;
|
|
entry.Flags = ParcelManager.AccessList.Access;
|
|
entry.Time = DateTime.Now.AddHours(hours);
|
|
land.parcelAccessList.Add(entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void llSetTouchText(string text)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.TouchName = text;
|
|
}
|
|
|
|
public void llSetSitText(string text)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.SitName = text;
|
|
}
|
|
|
|
public void llSetCameraEyeOffset(LSL_Types.Vector3 offset)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetCameraEyeOffset");
|
|
}
|
|
|
|
public void llSetCameraAtOffset(LSL_Types.Vector3 offset)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetCameraAtOffset");
|
|
}
|
|
|
|
public string llDumpList2String(LSL_Types.list src, string seperator)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (src.Length == 0)
|
|
{
|
|
return String.Empty;
|
|
}
|
|
string ret = String.Empty;
|
|
foreach (object o in src.Data)
|
|
{
|
|
ret = ret + o.ToString() + seperator;
|
|
}
|
|
ret = ret.Substring(0, ret.Length - seperator.Length);
|
|
return ret;
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llScriptDanger(LSL_Types.Vector3 pos)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
bool result = World.scriptDanger(m_host.LocalId, new LLVector3((float)pos.x, (float)pos.y, (float)pos.z));
|
|
if (result)
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
public void llDialog(string avatar, string message, LSL_Types.list buttons, int chat_channel)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID av = new LLUUID();
|
|
if (!LLUUID.TryParse(avatar,out av))
|
|
{
|
|
LSLError("First parameter to llDialog needs to be a key");
|
|
return;
|
|
}
|
|
if (buttons.Length > 12)
|
|
{
|
|
LSLError("No more than 12 buttons can be shown");
|
|
return;
|
|
}
|
|
string[] buts = new string[buttons.Length];
|
|
for (int i = 0; i < buttons.Length; i++)
|
|
{
|
|
if (buttons.Data[i].ToString() == String.Empty)
|
|
{
|
|
LSLError("button label cannot be blank");
|
|
return;
|
|
}
|
|
if (buttons.Data[i].ToString().Length > 24)
|
|
{
|
|
LSLError("button label cannot be longer than 24 characters");
|
|
return;
|
|
}
|
|
buts[i] = buttons.Data[i].ToString();
|
|
}
|
|
World.SendDialogToUser(av, m_host.Name, m_host.UUID, m_host.OwnerID, message, new LLUUID("00000000-0000-2222-3333-100000001000"), chat_channel, buts);
|
|
}
|
|
|
|
public void llVolumeDetect(int detect)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llVolumeDetect");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reset the named script. The script must be present
|
|
/// in the same prim.
|
|
/// </summary>
|
|
|
|
public void llResetOtherScript(string name)
|
|
{
|
|
LLUUID item;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if ((item = ScriptByName(name)) != LLUUID.Zero)
|
|
m_ScriptEngine.ResetScript(item);
|
|
else
|
|
ShoutError("llResetOtherScript: script "+name+" not found");
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetScriptState(string name)
|
|
{
|
|
LLUUID item;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if ((item = ScriptByName(name)) != LLUUID.Zero)
|
|
{
|
|
return m_ScriptEngine.GetScriptState(item) ?1:0;
|
|
}
|
|
|
|
ShoutError("llGetScriptState: script "+name+" not found");
|
|
|
|
// If we didn't find it, then it's safe to
|
|
// assume it is not running.
|
|
|
|
return 0;
|
|
}
|
|
|
|
public void llRemoteLoadScript()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
Deprecated("llRemoteLoadScript");
|
|
}
|
|
|
|
public void llSetRemoteScriptAccessPin(int pin)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetRemoteScriptAccessPin");
|
|
}
|
|
|
|
public void llRemoteLoadScriptPin(string target, string name, int pin, int running, int start_param)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llRemoteLoadScriptPin");
|
|
}
|
|
|
|
// remote_data(integer type, key channel, key message_id, string sender, integer ival, string sval)
|
|
// Not sure where these constants should live:
|
|
// REMOTE_DATA_CHANNEL = 1
|
|
// REMOTE_DATA_REQUEST = 2
|
|
// REMOTE_DATA_REPLY = 3
|
|
public void llOpenRemoteDataChannel()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
|
|
if (xmlrpcMod.IsEnabled())
|
|
{
|
|
LLUUID channelID = xmlrpcMod.OpenXMLRPCChannel(m_localID, m_itemID, LLUUID.Zero);
|
|
object[] resobj = new object[] { new LSL_Types.LSLInteger(1), new LSL_Types.LSLString(channelID.ToString()), new LSL_Types.LSLString(LLUUID.Zero.ToString()), new LSL_Types.LSLString(String.Empty), new LSL_Types.LSLInteger(0), new LSL_Types.LSLString(String.Empty) };
|
|
m_ScriptEngine.PostScriptEvent(m_itemID, new XEventParams(
|
|
"remote_data", resobj,
|
|
new XDetectParams[0]));
|
|
}
|
|
}
|
|
|
|
public string llSendRemoteData(string channel, string dest, int idata, string sdata)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
|
|
return (xmlrpcMod.SendRemoteData(m_localID, m_itemID, channel, dest, idata, sdata)).ToString();
|
|
}
|
|
|
|
public void llRemoteDataReply(string channel, string message_id, string sdata, int idata)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
|
|
xmlrpcMod.RemoteDataReply(channel, message_id, sdata, idata);
|
|
}
|
|
|
|
public void llCloseRemoteDataChannel(string channel)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
IXMLRPC xmlrpcMod = m_ScriptEngine.World.RequestModuleInterface<IXMLRPC>();
|
|
xmlrpcMod.CloseXMLRPCChannel(channel);
|
|
}
|
|
|
|
public string llMD5String(string src, int nonce)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return Util.Md5Hash(src + ":" + nonce.ToString());
|
|
}
|
|
|
|
public void llSetPrimitiveParams(LSL_Types.list rules)
|
|
{
|
|
llSetLinkPrimitiveParams(m_host.LinkNum+1, rules);
|
|
}
|
|
|
|
public void llSetLinkPrimitiveParams(int linknumber, LSL_Types.list rules)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
SceneObjectPart part=null;
|
|
|
|
if (m_host.LinkNum+1 != linknumber)
|
|
{
|
|
foreach (SceneObjectPart partInst in m_host.ParentGroup.GetParts())
|
|
{
|
|
if ((partInst.LinkNum + 1) == linknumber)
|
|
{
|
|
part = partInst;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
part = m_host;
|
|
}
|
|
|
|
if (part == null)
|
|
return;
|
|
|
|
int idx = 0;
|
|
|
|
while (idx < rules.Length)
|
|
{
|
|
int code = Convert.ToInt32(rules.Data[idx++]);
|
|
|
|
int remain = rules.Length - idx;
|
|
|
|
int face;
|
|
LSL_Types.Vector3 v;
|
|
|
|
switch (code)
|
|
{
|
|
case 6: // PRIM_POSITION
|
|
if (remain < 1)
|
|
return;
|
|
|
|
v=new LSL_Types.Vector3(rules.Data[idx++].ToString());
|
|
SetPos(part, v);
|
|
|
|
break;
|
|
|
|
case 8: // PRIM_ROTATION
|
|
if (remain < 1)
|
|
return;
|
|
|
|
LSL_Types.Quaternion q = new LSL_Types.Quaternion(rules.Data[idx++].ToString());
|
|
SetRot(part, q);
|
|
|
|
break;
|
|
|
|
case 17: // PRIM_TEXTURE
|
|
if (remain < 5)
|
|
return;
|
|
|
|
face=Convert.ToInt32(rules.Data[idx++]);
|
|
string tex=rules.Data[idx++].ToString();
|
|
LSL_Types.Vector3 repeats=new LSL_Types.Vector3(rules.Data[idx++].ToString());
|
|
LSL_Types.Vector3 offsets=new LSL_Types.Vector3(rules.Data[idx++].ToString());
|
|
double rotation=Convert.ToDouble(rules.Data[idx++]);
|
|
|
|
SetTexture(part, tex, face);
|
|
ScaleTexture(part, repeats.x, repeats.y, face);
|
|
OffsetTexture(part, offsets.x, offsets.y, face);
|
|
RotateTexture(part, rotation, face);
|
|
|
|
break;
|
|
|
|
case 18: // PRIM_COLOR
|
|
if (remain < 3)
|
|
return;
|
|
|
|
face=Convert.ToInt32(rules.Data[idx++]);
|
|
LSL_Types.Vector3 color=new LSL_Types.Vector3(rules.Data[idx++].ToString());
|
|
double alpha=Convert.ToDouble(rules.Data[idx++]);
|
|
|
|
SetColor(part, color, face);
|
|
SetAlpha(part, alpha, face);
|
|
|
|
break;
|
|
|
|
case 7: // PRIM_SIZE
|
|
if (remain < 1)
|
|
return;
|
|
|
|
v=new LSL_Types.Vector3(rules.Data[idx++].ToString());
|
|
SetScale(part, v);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public string llStringToBase64(string str)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
try
|
|
{
|
|
byte[] encData_byte = new byte[str.Length];
|
|
encData_byte = Encoding.UTF8.GetBytes(str);
|
|
string encodedData = Convert.ToBase64String(encData_byte);
|
|
return encodedData;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new Exception("Error in base64Encode" + e.Message);
|
|
}
|
|
}
|
|
|
|
public string llBase64ToString(string str)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
UTF8Encoding encoder = new UTF8Encoding();
|
|
Decoder utf8Decode = encoder.GetDecoder();
|
|
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);
|
|
string result = new String(decoded_char);
|
|
return result;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new Exception("Error in base64Decode" + e.Message);
|
|
}
|
|
}
|
|
|
|
public void llXorBase64Strings()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
Deprecated("llXorBase64Strings");
|
|
}
|
|
|
|
public void llRemoteDataSetRegion()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llRemoteDataSetRegion");
|
|
}
|
|
|
|
public double llLog10(double val)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (double)Math.Log10(val);
|
|
}
|
|
|
|
public double llLog(double val)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (double)Math.Log(val);
|
|
}
|
|
|
|
public LSL_Types.list llGetAnimationList(string id)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetAnimationList");
|
|
return new LSL_Types.list();
|
|
}
|
|
|
|
public void llSetParcelMusicURL(string url)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID landowner = World.GetLandOwner(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y);
|
|
if (landowner == LLUUID.Zero)
|
|
{
|
|
return;
|
|
}
|
|
if (landowner != m_host.ObjectOwner)
|
|
{
|
|
return;
|
|
}
|
|
World.SetLandMusicURL(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, url);
|
|
}
|
|
|
|
public void osSetParcelMediaURL(string url)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID landowner = World.GetLandOwner(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y);
|
|
|
|
if (landowner == LLUUID.Zero)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (landowner != m_host.ObjectOwner)
|
|
{
|
|
return;
|
|
}
|
|
|
|
World.SetLandMediaURL(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y, url);
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetRootPosition()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return new LSL_Types.Vector3(m_host.ParentGroup.AbsolutePosition.X, m_host.ParentGroup.AbsolutePosition.Y, m_host.ParentGroup.AbsolutePosition.Z);
|
|
}
|
|
|
|
public LSL_Types.Quaternion llGetRootRotation()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return new LSL_Types.Quaternion(m_host.ParentGroup.GroupRotation.X, m_host.ParentGroup.GroupRotation.Y, m_host.ParentGroup.GroupRotation.Z, m_host.ParentGroup.GroupRotation.W);
|
|
}
|
|
|
|
public string llGetObjectDesc()
|
|
{
|
|
return m_host.Description!=null?m_host.Description:String.Empty;
|
|
}
|
|
|
|
public void llSetObjectDesc(string desc)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.Description = desc!=null?desc:String.Empty;
|
|
}
|
|
|
|
public string llGetCreator()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return m_host.ObjectCreator.ToString();
|
|
}
|
|
|
|
public string llGetTimestamp()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return DateTime.Now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.fffffffZ");
|
|
}
|
|
|
|
public void llSetLinkAlpha(int linknumber, double alpha, int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
SceneObjectPart part = m_host.ParentGroup.GetLinkNumPart(linknumber);
|
|
if (linknumber > -1)
|
|
{
|
|
LLObject.TextureEntry tex = part.Shape.Textures;
|
|
LLColor texcolor;
|
|
if (face > -1)
|
|
{
|
|
texcolor = tex.CreateFace((uint)face).RGBA;
|
|
texcolor.A = (float)Math.Abs(alpha - 1);
|
|
tex.FaceTextures[face].RGBA = texcolor;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
else if (face == -1)
|
|
{
|
|
texcolor = tex.DefaultTexture.RGBA;
|
|
texcolor.A = (float)Math.Abs(alpha - 1);
|
|
tex.DefaultTexture.RGBA = texcolor;
|
|
for (uint i = 0; i < 32; i++)
|
|
{
|
|
if (tex.FaceTextures[i] != null)
|
|
{
|
|
texcolor = tex.FaceTextures[i].RGBA;
|
|
texcolor.A = (float)Math.Abs(alpha - 1);
|
|
tex.FaceTextures[i].RGBA = texcolor;
|
|
}
|
|
}
|
|
texcolor = tex.DefaultTexture.RGBA;
|
|
texcolor.A = (float)Math.Abs(alpha - 1);
|
|
tex.DefaultTexture.RGBA = texcolor;
|
|
part.UpdateTexture(tex);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
else if (linknumber == -1)
|
|
{
|
|
int num = m_host.ParentGroup.PrimCount;
|
|
for (int w = 0; w < num; w++)
|
|
{
|
|
linknumber = w;
|
|
part = m_host.ParentGroup.GetLinkNumPart(linknumber);
|
|
LLObject.TextureEntry tex = part.Shape.Textures;
|
|
LLColor texcolor;
|
|
if (face > -1)
|
|
{
|
|
texcolor = tex.CreateFace((uint)face).RGBA;
|
|
texcolor.A = (float)Math.Abs(alpha - 1);
|
|
tex.FaceTextures[face].RGBA = texcolor;
|
|
part.UpdateTexture(tex);
|
|
}
|
|
else if (face == -1)
|
|
{
|
|
texcolor = tex.DefaultTexture.RGBA;
|
|
texcolor.A = (float)Math.Abs(alpha - 1);
|
|
tex.DefaultTexture.RGBA = texcolor;
|
|
for (uint i = 0; i < 32; i++)
|
|
{
|
|
if (tex.FaceTextures[i] != null)
|
|
{
|
|
texcolor = tex.FaceTextures[i].RGBA;
|
|
texcolor.A = (float)Math.Abs(alpha - 1);
|
|
tex.FaceTextures[i].RGBA = texcolor;
|
|
}
|
|
}
|
|
texcolor = tex.DefaultTexture.RGBA;
|
|
texcolor.A = (float)Math.Abs(alpha - 1);
|
|
tex.DefaultTexture.RGBA = texcolor;
|
|
part.UpdateTexture(tex);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetNumberOfPrims()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return m_host.ParentGroup.PrimCount;
|
|
}
|
|
|
|
public LSL_Types.list llGetBoundingBox(string obj)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetBoundingBox");
|
|
return new LSL_Types.list();
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetGeometricCenter()
|
|
{
|
|
return new LSL_Types.Vector3(m_host.GetGeometricCenter().X, m_host.GetGeometricCenter().Y, m_host.GetGeometricCenter().Z);
|
|
}
|
|
|
|
public LSL_Types.list llGetPrimitiveParams(LSL_Types.list rules)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
LSL_Types.list res = new LSL_Types.list();
|
|
int idx=0;
|
|
while (idx < rules.Length)
|
|
{
|
|
int code=Convert.ToInt32(rules.Data[idx++]);
|
|
int remain=rules.Length-idx;
|
|
|
|
switch (code)
|
|
{
|
|
case 2: // PRIM_MATERIAL
|
|
res.Add(new LSL_Types.LSLInteger(m_host.Material));
|
|
break;
|
|
|
|
case 3: // PRIM_PHYSICS
|
|
if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Physics) != 0)
|
|
res.Add(new LSL_Types.LSLInteger(1));
|
|
else
|
|
res.Add(new LSL_Types.LSLInteger(0));
|
|
break;
|
|
|
|
case 4: // PRIM_TEMP_ON_REZ
|
|
if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.TemporaryOnRez) != 0)
|
|
res.Add(new LSL_Types.LSLInteger(1));
|
|
else
|
|
res.Add(new LSL_Types.LSLInteger(0));
|
|
break;
|
|
|
|
case 5: // PRIM_PHANTOM
|
|
if ((m_host.GetEffectiveObjectFlags() & (uint)LLObject.ObjectFlags.Phantom) != 0)
|
|
res.Add(new LSL_Types.LSLInteger(1));
|
|
else
|
|
res.Add(new LSL_Types.LSLInteger(0));
|
|
break;
|
|
|
|
case 6: // PRIM_POSITION
|
|
res.Add(new LSL_Types.Vector3(m_host.AbsolutePosition.X,
|
|
m_host.AbsolutePosition.Y,
|
|
m_host.AbsolutePosition.Z));
|
|
break;
|
|
|
|
case 7: // PRIM_SIZE
|
|
res.Add(new LSL_Types.Vector3(m_host.Scale.X,
|
|
m_host.Scale.Y,
|
|
m_host.Scale.Z));
|
|
break;
|
|
|
|
case 8: // PRIM_ROTATION
|
|
res.Add(new LSL_Types.Quaternion(m_host.RotationOffset.X,
|
|
m_host.RotationOffset.Y,
|
|
m_host.RotationOffset.Z,
|
|
m_host.RotationOffset.W));
|
|
break;
|
|
|
|
case 9: // PRIM_TYPE
|
|
// TODO--------------
|
|
res.Add(new LSL_Types.LSLInteger(0));
|
|
break;
|
|
|
|
case 17: // PRIM_TEXTURE
|
|
if (remain < 1)
|
|
return res;
|
|
|
|
int face=Convert.ToInt32(rules.Data[idx++]);
|
|
if (face == -1)
|
|
face = 0;
|
|
|
|
LLObject.TextureEntry tex = m_host.Shape.Textures;
|
|
LLObject.TextureEntryFace texface = tex.GetFace((uint)face);
|
|
|
|
res.Add(new LSL_Types.LSLString(texface.TextureID.ToString()));
|
|
res.Add(new LSL_Types.Vector3(texface.RepeatU,
|
|
texface.RepeatV,
|
|
0));
|
|
res.Add(new LSL_Types.Vector3(texface.OffsetU,
|
|
texface.OffsetV,
|
|
0));
|
|
res.Add(new LSL_Types.LSLFloat(texface.Rotation));
|
|
break;
|
|
|
|
case 18: // PRIM_COLOR
|
|
if (remain < 1)
|
|
return res;
|
|
|
|
face=Convert.ToInt32(rules.Data[idx++]);
|
|
|
|
tex = m_host.Shape.Textures;
|
|
LLColor texcolor;
|
|
if (face == -1) // TMP: Until we can determine number of sides, ALL_SIDES (-1) will return default color
|
|
texcolor = tex.DefaultTexture.RGBA;
|
|
else
|
|
texcolor = tex.GetFace((uint)face).RGBA;
|
|
res.Add(new LSL_Types.Vector3((255 - (texcolor.R * 255)) / 255,
|
|
(255 - (texcolor.G * 255)) / 255,
|
|
(255 - (texcolor.B * 255)) / 255));
|
|
res.Add(new LSL_Types.LSLFloat((texcolor.A * 255) / 255));
|
|
break;
|
|
|
|
case 19: // PRIM_BUMP_SHINY
|
|
// TODO--------------
|
|
if (remain < 1)
|
|
return res;
|
|
|
|
face=Convert.ToInt32(rules.Data[idx++]);
|
|
|
|
res.Add(new LSL_Types.LSLInteger(0));
|
|
res.Add(new LSL_Types.LSLInteger(0));
|
|
break;
|
|
|
|
case 20: // PRIM_FULLBRIGHT
|
|
// TODO--------------
|
|
if (remain < 1)
|
|
return res;
|
|
|
|
face=Convert.ToInt32(rules.Data[idx++]);
|
|
|
|
res.Add(new LSL_Types.LSLInteger(0));
|
|
break;
|
|
|
|
case 21: // PRIM_FLEXIBLE
|
|
PrimitiveBaseShape shape = m_host.Shape;
|
|
|
|
if (shape.FlexiEntry)
|
|
res.Add(new LSL_Types.LSLInteger(1)); // active
|
|
else
|
|
res.Add(new LSL_Types.LSLInteger(0));
|
|
res.Add(new LSL_Types.LSLInteger(shape.FlexiSoftness));// softness
|
|
res.Add(new LSL_Types.LSLFloat(shape.FlexiGravity)); // gravity
|
|
res.Add(new LSL_Types.LSLFloat(shape.FlexiDrag)); // friction
|
|
res.Add(new LSL_Types.LSLFloat(shape.FlexiWind)); // wind
|
|
res.Add(new LSL_Types.LSLFloat(shape.FlexiTension)); // tension
|
|
res.Add(new LSL_Types.Vector3(shape.FlexiForceX, // force
|
|
shape.FlexiForceY,
|
|
shape.FlexiForceZ));
|
|
break;
|
|
|
|
case 22: // PRIM_TEXGEN
|
|
// TODO--------------
|
|
// (PRIM_TEXGEN_DEFAULT, PRIM_TEXGEN_PLANAR)
|
|
if (remain < 1)
|
|
return res;
|
|
|
|
face=Convert.ToInt32(rules.Data[idx++]);
|
|
|
|
res.Add(new LSL_Types.LSLInteger(0));
|
|
break;
|
|
|
|
case 23: // PRIM_POINT_LIGHT:
|
|
shape = m_host.Shape;
|
|
|
|
if (shape.LightEntry)
|
|
res.Add(new LSL_Types.LSLInteger(1)); // active
|
|
else
|
|
res.Add(new LSL_Types.LSLInteger(0));
|
|
res.Add(new LSL_Types.Vector3(shape.LightColorR, // color
|
|
shape.LightColorG,
|
|
shape.LightColorB));
|
|
res.Add(new LSL_Types.LSLFloat(shape.LightIntensity)); // intensity
|
|
res.Add(new LSL_Types.LSLFloat(shape.LightRadius)); // radius
|
|
res.Add(new LSL_Types.LSLFloat(shape.LightFalloff)); // falloff
|
|
break;
|
|
|
|
case 24: // PRIM_GLOW
|
|
// TODO--------------
|
|
if (remain < 1)
|
|
return res;
|
|
|
|
face=Convert.ToInt32(rules.Data[idx++]);
|
|
|
|
res.Add(new LSL_Types.LSLFloat(0));
|
|
break;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// <remarks>
|
|
// <para>
|
|
// The .NET definition of base 64 is:
|
|
// <list>
|
|
// <item>
|
|
// Significant: A-Z a-z 0-9 + -
|
|
// </item>
|
|
// <item>
|
|
// Whitespace: \t \n \r ' '
|
|
// </item>
|
|
// <item>
|
|
// Valueless: =
|
|
// </item>
|
|
// <item>
|
|
// End-of-string: \0 or '=='
|
|
// </item>
|
|
// </list>
|
|
// </para>
|
|
// <para>
|
|
// Each point in a base-64 string represents
|
|
// a 6 bit value. A 32-bit integer can be
|
|
// represented using 6 characters (with some
|
|
// redundancy).
|
|
// </para>
|
|
// <para>
|
|
// LSL requires a base64 string to be 8
|
|
// characters in length. LSL also uses '/'
|
|
// rather than '-' (MIME compliant).
|
|
// </para>
|
|
// <para>
|
|
// RFC 1341 used as a reference (as specified
|
|
// by the SecondLife Wiki).
|
|
// </para>
|
|
// <para>
|
|
// SL do not record any kind of exception for
|
|
// these functions, so the string to integer
|
|
// conversion returns '0' if an invalid
|
|
// character is encountered during conversion.
|
|
// </para>
|
|
// <para>
|
|
// References
|
|
// <list>
|
|
// <item>
|
|
// http://lslwiki.net/lslwiki/wakka.php?wakka=Base64
|
|
// </item>
|
|
// <item>
|
|
// </item>
|
|
// </list>
|
|
// </para>
|
|
// </remarks>
|
|
|
|
// <summary>
|
|
// Table for converting 6-bit integers into
|
|
// base-64 characters
|
|
// </summary>
|
|
|
|
private static readonly char[] i2ctable =
|
|
{
|
|
'A','B','C','D','E','F','G','H',
|
|
'I','J','K','L','M','N','O','P',
|
|
'Q','R','S','T','U','V','W','X',
|
|
'Y','Z',
|
|
'a','b','c','d','e','f','g','h',
|
|
'i','j','k','l','m','n','o','p',
|
|
'q','r','s','t','u','v','w','x',
|
|
'y','z',
|
|
'0','1','2','3','4','5','6','7',
|
|
'8','9',
|
|
'+','/'
|
|
};
|
|
|
|
// <summary>
|
|
// Table for converting base-64 characters
|
|
// into 6-bit integers.
|
|
// </summary>
|
|
|
|
private static readonly int[] c2itable =
|
|
{
|
|
-1,-1,-1,-1,-1,-1,-1,-1, // 0x
|
|
-1,-1,-1,-1,-1,-1,-1,-1,
|
|
-1,-1,-1,-1,-1,-1,-1,-1, // 1x
|
|
-1,-1,-1,-1,-1,-1,-1,-1,
|
|
-1,-1,-1,-1,-1,-1,-1,-1, // 2x
|
|
-1,-1,-1,63,-1,-1,-1,64,
|
|
53,54,55,56,57,58,59,60, // 3x
|
|
61,62,-1,-1,-1,0,-1,-1,
|
|
-1,1,2,3,4,5,6,7, // 4x
|
|
8,9,10,11,12,13,14,15,
|
|
16,17,18,19,20,21,22,23, // 5x
|
|
24,25,26,-1,-1,-1,-1,-1,
|
|
-1,27,28,29,30,31,32,33, // 6x
|
|
34,35,36,37,38,39,40,41,
|
|
42,43,44,45,46,47,48,49, // 7x
|
|
50,51,52,-1,-1,-1,-1,-1,
|
|
-1,-1,-1,-1,-1,-1,-1,-1, // 8x
|
|
-1,-1,-1,-1,-1,-1,-1,-1,
|
|
-1,-1,-1,-1,-1,-1,-1,-1, // 9x
|
|
-1,-1,-1,-1,-1,-1,-1,-1,
|
|
-1,-1,-1,-1,-1,-1,-1,-1, // Ax
|
|
-1,-1,-1,-1,-1,-1,-1,-1,
|
|
-1,-1,-1,-1,-1,-1,-1,-1, // Bx
|
|
-1,-1,-1,-1,-1,-1,-1,-1,
|
|
-1,-1,-1,-1,-1,-1,-1,-1, // Cx
|
|
-1,-1,-1,-1,-1,-1,-1,-1,
|
|
-1,-1,-1,-1,-1,-1,-1,-1, // Dx
|
|
-1,-1,-1,-1,-1,-1,-1,-1,
|
|
-1,-1,-1,-1,-1,-1,-1,-1, // Ex
|
|
-1,-1,-1,-1,-1,-1,-1,-1,
|
|
-1,-1,-1,-1,-1,-1,-1,-1, // Fx
|
|
-1,-1,-1,-1,-1,-1,-1,-1
|
|
};
|
|
|
|
// <summary>
|
|
// Converts a 32-bit integer into a Base64
|
|
// character string. Base64 character strings
|
|
// are always 8 characters long. All iinteger
|
|
// values are acceptable.
|
|
// </summary>
|
|
// <param name="number">
|
|
// 32-bit integer to be converted.
|
|
// </param>
|
|
// <returns>
|
|
// 8 character string. The 1st six characters
|
|
// contain the encoded number, the last two
|
|
// characters are padded with "=".
|
|
// </returns>
|
|
|
|
public string llIntegerToBase64(int number)
|
|
{
|
|
// uninitialized string
|
|
|
|
char[] imdt = new char[8];
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
// Manually unroll the loop
|
|
|
|
imdt[7] = '=';
|
|
imdt[6] = '=';
|
|
imdt[5] = i2ctable[number<<4 & 0x3F];
|
|
imdt[4] = i2ctable[number>>2 & 0x3F];
|
|
imdt[3] = i2ctable[number>>8 & 0x3F];
|
|
imdt[2] = i2ctable[number>>14 & 0x3F];
|
|
imdt[1] = i2ctable[number>>20 & 0x3F];
|
|
imdt[0] = i2ctable[number>>26 & 0x3F];
|
|
|
|
return new string(imdt);
|
|
}
|
|
|
|
// <summary>
|
|
// Converts an eight character base-64 string
|
|
// into a 32-bit integer.
|
|
// </summary>
|
|
// <param name="str">
|
|
// 8 characters string to be converted. Other
|
|
// length strings return zero.
|
|
// </param>
|
|
// <returns>
|
|
// Returns an integer representing the
|
|
// encoded value providedint he 1st 6
|
|
// characters of the string.
|
|
// </returns>
|
|
// <remarks>
|
|
// This is coded to behave like LSL's
|
|
// implementation (I think), based upon the
|
|
// information available at the Wiki.
|
|
// If more than 8 characters are supplied,
|
|
// zero is returned.
|
|
// If a NULL string is supplied, zero will
|
|
// be returned.
|
|
// If fewer than 6 characters are supplied, then
|
|
// the answer will reflect a partial
|
|
// accumulation.
|
|
// <para>
|
|
// The 6-bit segments are
|
|
// extracted left-to-right in big-endian mode,
|
|
// which means that segment 6 only contains the
|
|
// two low-order bits of the 32 bit integer as
|
|
// its high order 2 bits. A short string therefore
|
|
// means loss of low-order information. E.g.
|
|
//
|
|
// |<---------------------- 32-bit integer ----------------------->|<-Pad->|
|
|
// |<--Byte 0----->|<--Byte 1----->|<--Byte 2----->|<--Byte 3----->|<-Pad->|
|
|
// |3|3|2|2|2|2|2|2|2|2|2|2|1|1|1|1|1|1|1|1|1|1| | | | | | | | | | |P|P|P|P|
|
|
// |1|0|9|8|7|6|5|4|3|2|1|0|9|8|7|6|5|4|3|2|1|0|9|8|7|6|5|4|3|2|1|0|P|P|P|P|
|
|
// | str[0] | str[1] | str[2] | str[3] | str[4] | str[6] |
|
|
//
|
|
// </para>
|
|
// </remarks>
|
|
|
|
public LSL_Types.LSLInteger llBase64ToInteger(string str)
|
|
{
|
|
int number = 0;
|
|
int digit;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
// Require a well-fromed base64 string
|
|
|
|
if (str.Length > 8)
|
|
return 0;
|
|
|
|
// The loop is unrolled in the interests
|
|
// of performance and simple necessity.
|
|
//
|
|
// MUST find 6 digits to be well formed
|
|
// -1 == invalid
|
|
// 0 == padding
|
|
|
|
if ((digit=c2itable[str[0]])<=0)
|
|
{
|
|
return digit<0?(int)0:number;
|
|
}
|
|
number += --digit<<26;
|
|
|
|
if ((digit=c2itable[str[1]])<=0)
|
|
{
|
|
return digit<0?(int)0:number;
|
|
}
|
|
number += --digit<<20;
|
|
|
|
if ((digit=c2itable[str[2]])<=0)
|
|
{
|
|
return digit<0?(int)0:number;
|
|
}
|
|
number += --digit<<14;
|
|
|
|
if ((digit=c2itable[str[3]])<=0)
|
|
{
|
|
return digit<0?(int)0:number;
|
|
}
|
|
number += --digit<<8;
|
|
|
|
if ((digit=c2itable[str[4]])<=0)
|
|
{
|
|
return digit<0?(int)0:number;
|
|
}
|
|
number += --digit<<2;
|
|
|
|
if ((digit=c2itable[str[5]])<=0)
|
|
{
|
|
return digit<0?(int)0:number;
|
|
}
|
|
number += --digit>>4;
|
|
|
|
// ignore trailing padding
|
|
|
|
return number;
|
|
}
|
|
|
|
public double llGetGMTclock()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return DateTime.UtcNow.TimeOfDay.TotalSeconds;
|
|
}
|
|
|
|
public string llGetSimulatorHostname()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return System.Environment.MachineName;
|
|
}
|
|
|
|
public void llSetLocalRot(LSL_Types.Quaternion rot)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
m_host.RotationOffset = new LLQuaternion((float)rot.x, (float)rot.y, (float)rot.z, (float)rot.s);
|
|
}
|
|
|
|
// <summary>
|
|
// Scan the string supplied in 'src' and
|
|
// tokenize it based upon two sets of
|
|
// tokenizers provided in two lists,
|
|
// separators and spacers.
|
|
// </summary>
|
|
//
|
|
// <remarks>
|
|
// Separators demarcate tokens and are
|
|
// elided as they are encountered. Spacers
|
|
// also demarcate tokens, but are themselves
|
|
// retained as tokens.
|
|
//
|
|
// Both separators and spacers may be arbitrarily
|
|
// long strings. i.e. ":::".
|
|
//
|
|
// The function returns an ordered list
|
|
// representing the tokens found in the supplied
|
|
// sources string. If two successive tokenizers
|
|
// are encountered, then a NULL entry is added
|
|
// to the list.
|
|
//
|
|
// It is a precondition that the source and
|
|
// toekizer lisst are non-null. If they are null,
|
|
// then a null pointer exception will be thrown
|
|
// while their lengths are being determined.
|
|
//
|
|
// A small amount of working memoryis required
|
|
// of approximately 8*#tokenizers.
|
|
//
|
|
// There are many ways in which this function
|
|
// can be implemented, this implementation is
|
|
// fairly naive and assumes that when the
|
|
// function is invooked with a short source
|
|
// string and/or short lists of tokenizers, then
|
|
// performance will not be an issue.
|
|
//
|
|
// In order to minimize the perofrmance
|
|
// effects of long strings, or large numbers
|
|
// of tokeizers, the function skips as far as
|
|
// possible whenever a toekenizer is found,
|
|
// and eliminates redundant tokenizers as soon
|
|
// as is possible.
|
|
//
|
|
// The implementation tries to avoid any copying
|
|
// of arrays or other objects.
|
|
// </remarks>
|
|
|
|
public LSL_Types.list llParseStringKeepNulls(string src, LSL_Types.list separators, LSL_Types.list spacers)
|
|
{
|
|
int beginning = 0;
|
|
int srclen = src.Length;
|
|
int seplen = separators.Length;
|
|
object[] separray = separators.Data;
|
|
int spclen = spacers.Length;
|
|
object[] spcarray = spacers.Data;
|
|
int mlen = seplen+spclen;
|
|
|
|
int[] offset = new int[mlen+1];
|
|
bool[] active = new bool[mlen];
|
|
|
|
int best;
|
|
int j;
|
|
|
|
// Initial capacity reduces resize cost
|
|
|
|
LSL_Types.list tokens = new LSL_Types.list();
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
// All entries are initially valid
|
|
|
|
for (int i = 0; i < mlen; i++)
|
|
active[i] = true;
|
|
|
|
offset[mlen] = srclen;
|
|
|
|
while (beginning < srclen)
|
|
{
|
|
|
|
best = mlen; // as bad as it gets
|
|
|
|
// Scan for separators
|
|
|
|
for (j = 0; j < seplen; j++)
|
|
{
|
|
if (active[j])
|
|
{
|
|
// scan all of the markers
|
|
if ((offset[j] = src.IndexOf((string)separray[j],beginning)) == -1)
|
|
{
|
|
// not present at all
|
|
active[j] = false;
|
|
}
|
|
else
|
|
{
|
|
// present and correct
|
|
if (offset[j] < offset[best])
|
|
{
|
|
// closest so far
|
|
best = j;
|
|
if (offset[best] == beginning)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Scan for spacers
|
|
|
|
if (offset[best] != beginning)
|
|
{
|
|
for (j = seplen; (j < mlen) && (offset[best] > beginning); j++)
|
|
{
|
|
if (active[j])
|
|
{
|
|
// scan all of the markers
|
|
if ((offset[j] = src.IndexOf((string)spcarray[j-seplen],beginning)) == -1)
|
|
{
|
|
// not present at all
|
|
active[j] = false;
|
|
} else
|
|
{
|
|
// present and correct
|
|
if (offset[j] < offset[best])
|
|
{
|
|
// closest so far
|
|
best = j;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// This is the normal exit from the scanning loop
|
|
|
|
if (best == mlen)
|
|
{
|
|
// no markers were found on this pass
|
|
// so we're pretty much done
|
|
tokens.Add(src.Substring(beginning, srclen-beginning));
|
|
break;
|
|
}
|
|
|
|
// Otherwise we just add the newly delimited token
|
|
// and recalculate where the search should continue.
|
|
|
|
tokens.Add(src.Substring(beginning,offset[best]-beginning));
|
|
|
|
if (best<seplen)
|
|
{
|
|
beginning = offset[best]+((string)separray[best]).Length;
|
|
} else
|
|
{
|
|
beginning = offset[best]+((string)spcarray[best-seplen]).Length;
|
|
tokens.Add(spcarray[best-seplen]);
|
|
}
|
|
|
|
}
|
|
|
|
// This an awkward an not very intuitive boundary case. If the
|
|
// last substring is a tokenizer, then there is an implied trailing
|
|
// null list entry. Hopefully the single comparison will not be too
|
|
// arduous. Alternatively the 'break' could be replced with a return
|
|
// but that's shabby programming.
|
|
|
|
if (beginning == srclen)
|
|
{
|
|
if (srclen != 0)
|
|
tokens.Add("");
|
|
}
|
|
|
|
return tokens;
|
|
}
|
|
|
|
public void llRezAtRoot(string inventory, LSL_Types.Vector3 position, LSL_Types.Vector3 velocity,
|
|
LSL_Types.Quaternion rot, int param)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llRezAtRoot");
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetObjectPermMask(int mask)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
int permmask = 0;
|
|
|
|
if (mask == BuiltIn_Commands_BaseClass.MASK_BASE)//0
|
|
{
|
|
permmask = (int)m_host.BaseMask;
|
|
}
|
|
|
|
else if (mask == BuiltIn_Commands_BaseClass.MASK_OWNER)//1
|
|
{
|
|
permmask = (int)m_host.OwnerMask;
|
|
}
|
|
|
|
else if (mask == BuiltIn_Commands_BaseClass.MASK_GROUP)//2
|
|
{
|
|
permmask = (int)m_host.GroupMask;
|
|
}
|
|
|
|
else if (mask == BuiltIn_Commands_BaseClass.MASK_EVERYONE)//3
|
|
{
|
|
permmask = (int)m_host.EveryoneMask;
|
|
}
|
|
|
|
else if (mask == BuiltIn_Commands_BaseClass.MASK_NEXT)//4
|
|
{
|
|
permmask = (int)m_host.NextOwnerMask;
|
|
}
|
|
|
|
return permmask;
|
|
}
|
|
|
|
public void llSetObjectPermMask(int mask, int value)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if (mask == BuiltIn_Commands_BaseClass.MASK_BASE)//0
|
|
{
|
|
m_host.BaseMask = (uint)value;
|
|
}
|
|
|
|
else if (mask == BuiltIn_Commands_BaseClass.MASK_OWNER)//1
|
|
{
|
|
m_host.OwnerMask = (uint)value;
|
|
}
|
|
|
|
else if (mask == BuiltIn_Commands_BaseClass.MASK_GROUP)//2
|
|
{
|
|
m_host.GroupMask = (uint)value;
|
|
}
|
|
|
|
else if (mask == BuiltIn_Commands_BaseClass.MASK_EVERYONE)//3
|
|
{
|
|
m_host.EveryoneMask = (uint)value;
|
|
}
|
|
|
|
else if (mask == BuiltIn_Commands_BaseClass.MASK_NEXT)//4
|
|
{
|
|
m_host.NextOwnerMask = (uint)value;
|
|
}
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetInventoryPermMask(string item, int mask)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
|
|
{
|
|
if (inv.Value.Name == item)
|
|
{
|
|
switch (mask)
|
|
{
|
|
case 0:
|
|
return (int)inv.Value.BaseMask;
|
|
case 1:
|
|
return (int)inv.Value.OwnerMask;
|
|
case 2:
|
|
return (int)inv.Value.GroupMask;
|
|
case 3:
|
|
return (int)inv.Value.EveryoneMask;
|
|
case 4:
|
|
return (int)inv.Value.NextOwnerMask;
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public void llSetInventoryPermMask(string item, int mask, int value)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetInventoryPermMask");
|
|
}
|
|
|
|
public string llGetInventoryCreator(string item)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
|
|
{
|
|
if (inv.Value.Name == item)
|
|
{
|
|
return inv.Value.CreatorID.ToString();
|
|
}
|
|
}
|
|
llSay(0, "No item name '" + item + "'");
|
|
return String.Empty;
|
|
}
|
|
|
|
public void llOwnerSay(string msg)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
World.SimChatBroadcast(Helpers.StringToField(msg), ChatTypeEnum.Owner, 0, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false);
|
|
// IWorldComm wComm = m_ScriptEngine.World.RequestModuleInterface<IWorldComm>();
|
|
// wComm.DeliverMessage(ChatTypeEnum.Owner, 0, m_host.Name, m_host.UUID, msg);
|
|
}
|
|
|
|
public string llRequestSimulatorData(string simulator, int data)
|
|
{
|
|
try
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
string reply = String.Empty;
|
|
|
|
RegionInfo info = m_ScriptEngine.World.RequestClosestRegion(simulator);
|
|
|
|
switch(data)
|
|
{
|
|
case 5: // DATA_SIM_POS
|
|
if(info == null)
|
|
return LLUUID.Zero.ToString();
|
|
reply = new LSL_Types.Vector3(
|
|
info.RegionLocX * Constants.RegionSize,
|
|
info.RegionLocY * Constants.RegionSize,
|
|
0).ToString();
|
|
break;
|
|
case 6: // DATA_SIM_STATUS
|
|
if(info != null)
|
|
reply = "up"; // Duh!
|
|
else
|
|
reply = "unknown";
|
|
break;
|
|
case 7: // DATA_SIM_RATING
|
|
if(info == null)
|
|
return LLUUID.Zero.ToString();
|
|
int access = (int)info.EstateSettings.simAccess;
|
|
if(access == 21)
|
|
reply = "MATURE";
|
|
else if(access == 13)
|
|
reply = "MATURE";
|
|
else
|
|
reply = "UNKNOWN";
|
|
break;
|
|
default:
|
|
return LLUUID.Zero.ToString(); // Raise no event
|
|
}
|
|
LLUUID rq = LLUUID.Random();
|
|
|
|
LLUUID tid = m_ScriptEngine.m_ASYNCLSLCommandManager.
|
|
m_Dataserver.RegisterRequest(m_localID,
|
|
m_itemID, rq.ToString());
|
|
|
|
m_ScriptEngine.m_ASYNCLSLCommandManager.
|
|
m_Dataserver.DataserverReply(rq.ToString(), reply);
|
|
|
|
return tid.ToString();
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
Console.WriteLine(e.ToString());
|
|
return LLUUID.Zero.ToString();
|
|
}
|
|
}
|
|
|
|
public void llForceMouselook(int mouselook)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llForceMouselook");
|
|
}
|
|
|
|
public double llGetObjectMass(string id)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID key = new LLUUID();
|
|
if (LLUUID.TryParse(id,out key))
|
|
{
|
|
return (double)World.GetSceneObjectPart(World.Entities[key].LocalId).GetMass();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// illListReplaceList removes the sub-list defined by the inclusive indices
|
|
/// start and end and inserts the src list in its place. The inclusive
|
|
/// nature of the indices means that at least one element must be deleted
|
|
/// if the indices are within the bounds of the existing list. I.e. 2,2
|
|
/// will remove the element at index 2 and replace it with the source
|
|
/// list. Both indices may be negative, with the usual interpretation. An
|
|
/// interesting case is where end is lower than start. As these indices
|
|
/// bound the list to be removed, then 0->end, and start->lim are removed
|
|
/// and the source list is added as a suffix.
|
|
/// </summary>
|
|
|
|
public LSL_Types.list llListReplaceList(LSL_Types.list dest, LSL_Types.list src, int start, int end)
|
|
{
|
|
|
|
LSL_Types.list pref = null;
|
|
|
|
m_host.AddScriptLPS(1);
|
|
|
|
// Note that although we have normalized, both
|
|
// indices could still be negative.
|
|
if (start < 0)
|
|
{
|
|
start = start+dest.Length;
|
|
}
|
|
|
|
if (end < 0)
|
|
{
|
|
end = end+dest.Length;
|
|
}
|
|
// The comventional case, remove a sequence starting with
|
|
// start and ending with end. And then insert the source
|
|
// list.
|
|
if (start <= end)
|
|
{
|
|
// If greater than zero, then there is going to be a
|
|
// surviving prefix. Otherwise the inclusive nature
|
|
// of the indices mean that we're going to add the
|
|
// source list as a prefix.
|
|
if (start > 0)
|
|
{
|
|
pref = dest.GetSublist(0,start-1);
|
|
// Only add a suffix if there is something
|
|
// beyond the end index (it's inclusive too).
|
|
if (end+1 < dest.Length)
|
|
{
|
|
return pref + src + dest.GetSublist(end+1,-1);
|
|
}
|
|
else
|
|
{
|
|
return pref + src;
|
|
}
|
|
}
|
|
// If start is less than or equal to zero, then
|
|
// the new list is simply a prefix. We still need to
|
|
// figure out any necessary surgery to the destination
|
|
// based upon end. Note that if end exceeds the upper
|
|
// bound in this case, the entire destination list
|
|
// is removed.
|
|
else
|
|
{
|
|
if (end+1 < dest.Length)
|
|
{
|
|
return src + dest.GetSublist(end+1,-1);
|
|
}
|
|
else
|
|
{
|
|
return src;
|
|
}
|
|
}
|
|
}
|
|
// Finally, if start > end, we strip away a prefix and
|
|
// a suffix, to leave the list that sits <between> ens
|
|
// and start, and then tag on the src list. AT least
|
|
// that's my interpretation. We can get sublist to do
|
|
// this for us. Note that one, or both of the indices
|
|
// might have been negative.
|
|
else
|
|
{
|
|
return dest.GetSublist(end+1,start-1)+src;
|
|
}
|
|
}
|
|
|
|
public void llLoadURL(string avatar_id, string message, string url)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID avatarId = new LLUUID(avatar_id);
|
|
m_ScriptEngine.World.SendUrlToUser(avatarId, m_host.Name, m_host.UUID, m_host.ObjectOwner, false, message,
|
|
url);
|
|
}
|
|
|
|
public void llParcelMediaCommandList(LSL_Types.list commandList)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llParcelMediaCommandList");
|
|
}
|
|
|
|
public void llParcelMediaQuery()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llParcelMediaQuery");
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llModPow(int a, int b, int c)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
Int64 tmp = 0;
|
|
Math.DivRem(Convert.ToInt64(Math.Pow(a, b)), c, out tmp);
|
|
return Convert.ToInt32(tmp);
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetInventoryType(string name)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
foreach (KeyValuePair<LLUUID, TaskInventoryItem> inv in m_host.TaskInventory)
|
|
{
|
|
if (inv.Value.Name == name)
|
|
{
|
|
return inv.Value.InvType;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public void llSetPayPrice(int price, LSL_Types.list quick_pay_buttons)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
if (quick_pay_buttons.Data.Length != 4)
|
|
{
|
|
LSLError("List must have 4 elements");
|
|
return;
|
|
}
|
|
m_host.ParentGroup.RootPart.PayPrice[0]=price;
|
|
m_host.ParentGroup.RootPart.PayPrice[1]=(int)quick_pay_buttons.Data[0];
|
|
m_host.ParentGroup.RootPart.PayPrice[2]=(int)quick_pay_buttons.Data[1];
|
|
m_host.ParentGroup.RootPart.PayPrice[3]=(int)quick_pay_buttons.Data[2];
|
|
m_host.ParentGroup.RootPart.PayPrice[4]=(int)quick_pay_buttons.Data[3];
|
|
}
|
|
|
|
public LSL_Types.Vector3 llGetCameraPos()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetCameraPos");
|
|
return new LSL_Types.Vector3();
|
|
}
|
|
|
|
public LSL_Types.Quaternion llGetCameraRot()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llGetCameraRot");
|
|
return new LSL_Types.Quaternion();
|
|
}
|
|
|
|
public void llSetPrimURL()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetPrimURL");
|
|
}
|
|
|
|
public void llRefreshPrimURL()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llRefreshPrimURL");
|
|
}
|
|
|
|
public string llEscapeURL(string url)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
try
|
|
{
|
|
return Uri.EscapeUriString(url);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return "llEscapeURL: " + ex.ToString();
|
|
}
|
|
}
|
|
|
|
public string llUnescapeURL(string url)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
try
|
|
{
|
|
return Uri.UnescapeDataString(url);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return "llUnescapeURL: " + ex.ToString();
|
|
}
|
|
}
|
|
|
|
public void llMapDestination(string simname, LSL_Types.Vector3 pos, LSL_Types.Vector3 look_at)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llMapDestination");
|
|
}
|
|
|
|
public void llAddToLandBanList(string avatar, double hours)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID key;
|
|
LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData;
|
|
if (land.ownerID == m_host.OwnerID)
|
|
{
|
|
ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry();
|
|
if (LLUUID.TryParse(avatar, out key))
|
|
{
|
|
entry.AgentID = key;
|
|
entry.Flags = ParcelManager.AccessList.Ban;
|
|
entry.Time = DateTime.Now.AddHours(hours);
|
|
land.parcelAccessList.Add(entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void llRemoveFromLandPassList(string avatar)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID key;
|
|
LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData;
|
|
if (land.ownerID == m_host.OwnerID)
|
|
{
|
|
if (LLUUID.TryParse(avatar, out key))
|
|
{
|
|
foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList)
|
|
{
|
|
if (entry.AgentID == key && entry.Flags == ParcelManager.AccessList.Access)
|
|
{
|
|
land.parcelAccessList.Remove(entry);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void llRemoveFromLandBanList(string avatar)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LLUUID key;
|
|
LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData;
|
|
if (land.ownerID == m_host.OwnerID)
|
|
{
|
|
if (LLUUID.TryParse(avatar, out key))
|
|
{
|
|
foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList)
|
|
{
|
|
if (entry.AgentID == key && entry.Flags == ParcelManager.AccessList.Ban)
|
|
{
|
|
land.parcelAccessList.Remove(entry);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void llSetCameraParams(LSL_Types.list rules)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetCameraParams");
|
|
}
|
|
|
|
public void llClearCameraParams()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llClearCameraParams");
|
|
}
|
|
|
|
public double llListStatistics(int operation, LSL_Types.list src)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LSL_Types.list nums = LSL_Types.list.ToDoubleList(src);
|
|
switch (operation)
|
|
{
|
|
case BuiltIn_Commands_BaseClass.LIST_STAT_RANGE:
|
|
return nums.Range();
|
|
case BuiltIn_Commands_BaseClass.LIST_STAT_MIN:
|
|
return nums.Min();
|
|
case BuiltIn_Commands_BaseClass.LIST_STAT_MAX:
|
|
return nums.Max();
|
|
case BuiltIn_Commands_BaseClass.LIST_STAT_MEAN:
|
|
return nums.Mean();
|
|
case BuiltIn_Commands_BaseClass.LIST_STAT_MEDIAN:
|
|
return nums.Median();
|
|
case BuiltIn_Commands_BaseClass.LIST_STAT_NUM_COUNT:
|
|
return nums.NumericLength();
|
|
case BuiltIn_Commands_BaseClass.LIST_STAT_STD_DEV:
|
|
return nums.StdDev();
|
|
case BuiltIn_Commands_BaseClass.LIST_STAT_SUM:
|
|
return nums.Sum();
|
|
case BuiltIn_Commands_BaseClass.LIST_STAT_SUM_SQUARES:
|
|
return nums.SumSqrs();
|
|
case BuiltIn_Commands_BaseClass.LIST_STAT_GEOMETRIC_MEAN:
|
|
return nums.GeometricMean();
|
|
case BuiltIn_Commands_BaseClass.LIST_STAT_HARMONIC_MEAN:
|
|
return nums.HarmonicMean();
|
|
default:
|
|
return 0.0;
|
|
}
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetUnixTime()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return Util.UnixTimeSinceEpoch();
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetParcelFlags(LSL_Types.Vector3 pos)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (int)World.LandChannel.GetLandObject((float)pos.x, (float)pos.y).landData.landFlags;
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetRegionFlags()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
return (int)World.RegionInfo.EstateSettings.regionFlags;
|
|
}
|
|
|
|
public string llXorBase64StringsCorrect(string str1, string str2)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
string ret = String.Empty;
|
|
string src1 = llBase64ToString(str1);
|
|
string src2 = llBase64ToString(str2);
|
|
int c = 0;
|
|
for (int i = 0; i < src1.Length; i++)
|
|
{
|
|
ret += src1[i] ^ src2[c];
|
|
|
|
c++;
|
|
if (c > src2.Length)
|
|
c = 0;
|
|
}
|
|
return llStringToBase64(ret);
|
|
}
|
|
|
|
public string llHTTPRequest(string url, LSL_Types.list parameters, string body)
|
|
{
|
|
// Partial implementation: support for parameter flags needed
|
|
// see http://wiki.secondlife.com/wiki/LlHTTPRequest
|
|
// parameter flags support are implemented in ScriptsHttpRequests.cs
|
|
// in StartHttpRequest
|
|
|
|
m_host.AddScriptLPS(1);
|
|
IHttpRequests httpScriptMod =
|
|
m_ScriptEngine.World.RequestModuleInterface<IHttpRequests>();
|
|
List<string> param = new List<string>();
|
|
foreach (object o in parameters.Data)
|
|
{
|
|
param.Add(o.ToString());
|
|
}
|
|
LLUUID reqID = httpScriptMod.
|
|
StartHttpRequest(m_localID, m_itemID, url, param, body);
|
|
|
|
if (reqID != LLUUID.Zero)
|
|
return reqID.ToString();
|
|
else
|
|
return null;
|
|
}
|
|
|
|
public void llResetLandBanList()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData;
|
|
if (land.ownerID == m_host.OwnerID)
|
|
{
|
|
foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList)
|
|
{
|
|
if (entry.Flags == ParcelManager.AccessList.Ban)
|
|
{
|
|
land.parcelAccessList.Remove(entry);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void llResetLandPassList()
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LandData land = World.LandChannel.GetLandObject(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).landData;
|
|
if (land.ownerID == m_host.OwnerID)
|
|
{
|
|
foreach (ParcelManager.ParcelAccessEntry entry in land.parcelAccessList)
|
|
{
|
|
if (entry.Flags == ParcelManager.AccessList.Access)
|
|
{
|
|
land.parcelAccessList.Remove(entry);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetParcelPrimCount(LSL_Types.Vector3 pos, int category, int sim_wide)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
LandData land = World.GetLandData((float)pos.x, (float)pos.y);
|
|
|
|
if (land == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
else
|
|
{
|
|
if (sim_wide == 1)
|
|
{
|
|
if (category == 0)
|
|
{
|
|
return land.simwidePrims;
|
|
}
|
|
|
|
else
|
|
{
|
|
//public int simwideArea = 0;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
if (category == 0)//Total Prims
|
|
{
|
|
return 0;//land.
|
|
}
|
|
|
|
else if (category == 1)//Owner Prims
|
|
{
|
|
return land.ownerPrims;
|
|
}
|
|
|
|
else if (category == 2)//Group Prims
|
|
{
|
|
return land.groupPrims;
|
|
}
|
|
|
|
else if (category == 3)//Other Prims
|
|
{
|
|
return land.otherPrims;
|
|
}
|
|
|
|
else if (category == 4)//Selected
|
|
{
|
|
return land.selectedPrims;
|
|
}
|
|
|
|
else if (category == 5)//Temp
|
|
{
|
|
return 0;//land.
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public LSL_Types.list llGetParcelPrimOwners(LSL_Types.Vector3 pos)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LandObject land = (LandObject)World.LandChannel.GetLandObject((float)pos.x, (float)pos.y);
|
|
LSL_Types.list ret = new LSL_Types.list();
|
|
if (land != null)
|
|
{
|
|
foreach (KeyValuePair<LLUUID, int> d in land.getLandObjectOwners())
|
|
{
|
|
ret.Add(d.Key.ToString());
|
|
ret.Add(d.Value);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetObjectPrimCount(string object_id)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
SceneObjectPart part = World.GetSceneObjectPart(new LLUUID(object_id));
|
|
if (part == null)
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return part.ParentGroup.Children.Count;
|
|
}
|
|
}
|
|
|
|
public LSL_Types.LSLInteger llGetParcelMaxPrims(LSL_Types.Vector3 pos, int sim_wide)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
// Alondria: This currently just is utilizing the normal grid's 0.22 prims/m2 calculation
|
|
// Which probably will be irrelevent in OpenSim....
|
|
LandData land = World.GetLandData((float)pos.x, (float)pos.y);
|
|
|
|
float bonusfactor = World.RegionInfo.EstateSettings.objectBonusFactor;
|
|
|
|
if (land == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (sim_wide == 1)
|
|
{
|
|
decimal v = land.simwideArea * (decimal)(0.22) * (decimal)bonusfactor;
|
|
|
|
return (int)v;
|
|
}
|
|
|
|
else
|
|
{
|
|
decimal v = land.area * (decimal)(0.22) * (decimal)bonusfactor;
|
|
|
|
return (int)v;
|
|
}
|
|
|
|
}
|
|
|
|
public LSL_Types.list llGetParcelDetails(LSL_Types.Vector3 pos, LSL_Types.list param)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LandData land = World.GetLandData((float)pos.x, (float)pos.y);
|
|
if (land == null)
|
|
{
|
|
return new LSL_Types.list(0);
|
|
}
|
|
LSL_Types.list ret = new LSL_Types.list();
|
|
foreach (object o in param.Data)
|
|
{
|
|
switch (o.ToString())
|
|
{
|
|
case "0":
|
|
ret = ret + new LSL_Types.list(land.landName);
|
|
break;
|
|
case "1":
|
|
ret = ret + new LSL_Types.list(land.landDesc);
|
|
break;
|
|
case "2":
|
|
ret = ret + new LSL_Types.list(land.ownerID.ToString());
|
|
break;
|
|
case "3":
|
|
ret = ret + new LSL_Types.list(land.groupID.ToString());
|
|
break;
|
|
case "4":
|
|
ret = ret + new LSL_Types.list(land.area);
|
|
break;
|
|
default:
|
|
ret = ret + new LSL_Types.list(0);
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public void llSetLinkTexture(int linknumber, string texture, int face)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
NotImplemented("llSetLinkTexture");
|
|
}
|
|
|
|
public string llStringTrim(string src, int type)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
if (type == (int)BuiltIn_Commands_BaseClass.STRING_TRIM_HEAD) { return src.TrimStart(); }
|
|
if (type == (int)BuiltIn_Commands_BaseClass.STRING_TRIM_TAIL) { return src.TrimEnd(); }
|
|
if (type == (int)BuiltIn_Commands_BaseClass.STRING_TRIM) { return src.Trim(); }
|
|
return src;
|
|
}
|
|
|
|
public LSL_Types.list llGetObjectDetails(string id, LSL_Types.list args)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
LSL_Types.list ret = new LSL_Types.list();
|
|
LLUUID key = new LLUUID();
|
|
if (LLUUID.TryParse(id, out key))
|
|
{
|
|
ScenePresence av = World.GetScenePresence(key);
|
|
|
|
if (av != null)
|
|
{
|
|
foreach (object o in args.Data)
|
|
{
|
|
switch (o.ToString())
|
|
{
|
|
case "1":
|
|
ret.Add(av.Firstname + " " + av.Lastname);
|
|
break;
|
|
case "2":
|
|
ret.Add("");
|
|
break;
|
|
case "3":
|
|
ret.Add(new LSL_Types.Vector3((double)av.AbsolutePosition.X, (double)av.AbsolutePosition.Y, (double)av.AbsolutePosition.Z));
|
|
break;
|
|
case "4":
|
|
ret.Add(new LSL_Types.Quaternion((double)av.Rotation.x, (double)av.Rotation.y, (double)av.Rotation.z, (double)av.Rotation.w));
|
|
break;
|
|
case "5":
|
|
ret.Add(new LSL_Types.Vector3(av.Velocity.X,av.Velocity.Y,av.Velocity.Z));
|
|
break;
|
|
case "6":
|
|
ret.Add(id);
|
|
break;
|
|
case "7":
|
|
ret.Add(LLUUID.Zero.ToString());
|
|
break;
|
|
case "8":
|
|
ret.Add(LLUUID.Zero.ToString());
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
SceneObjectPart obj = World.GetSceneObjectPart(key);
|
|
if (obj != null)
|
|
{
|
|
foreach (object o in args.Data)
|
|
{
|
|
switch (o.ToString())
|
|
{
|
|
case "1":
|
|
ret.Add(obj.Name);
|
|
break;
|
|
case "2":
|
|
ret.Add(obj.Description);
|
|
break;
|
|
case "3":
|
|
ret.Add(new LSL_Types.Vector3(obj.AbsolutePosition.X,obj.AbsolutePosition.Y,obj.AbsolutePosition.Z));
|
|
break;
|
|
case "4":
|
|
ret.Add(new LSL_Types.Quaternion(obj.RotationOffset.X, obj.RotationOffset.Y, obj.RotationOffset.Z, obj.RotationOffset.W));
|
|
break;
|
|
case "5":
|
|
ret.Add(new LSL_Types.Vector3(obj.Velocity.X, obj.Velocity.Y, obj.Velocity.Z));
|
|
break;
|
|
case "6":
|
|
ret.Add(obj.OwnerID.ToString());
|
|
break;
|
|
case "7":
|
|
ret.Add(obj.GroupID.ToString());
|
|
break;
|
|
case "8":
|
|
ret.Add(obj.CreatorID.ToString());
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
return new LSL_Types.list();
|
|
}
|
|
|
|
|
|
internal LLUUID ScriptByName(string name)
|
|
{
|
|
foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 10 && item.Name == name)
|
|
return item.ItemID;
|
|
}
|
|
return LLUUID.Zero;
|
|
}
|
|
|
|
internal void ShoutError(string msg)
|
|
{
|
|
llShout(BuiltIn_Commands_BaseClass.DEBUG_CHANNEL, msg);
|
|
}
|
|
|
|
|
|
|
|
internal void NotImplemented(string command)
|
|
{
|
|
if (throwErrorOnNotImplemented)
|
|
throw new NotImplementedException("Command not implemented: " + command);
|
|
}
|
|
|
|
internal void Deprecated(string command)
|
|
{
|
|
throw new Exception("Command deprecated: " + command);
|
|
}
|
|
|
|
internal void LSLError(string msg)
|
|
{
|
|
throw new Exception("LSL Runtime Error: " + msg);
|
|
}
|
|
|
|
public delegate void AssetRequestCallback(LLUUID assetID, AssetBase asset);
|
|
private void WithNotecard(LLUUID assetID, AssetRequestCallback cb)
|
|
{
|
|
World.AssetCache.GetAsset(assetID, delegate(LLUUID i, AssetBase a) { cb(i, a); }, false);
|
|
}
|
|
|
|
public string llGetNumberOfNotecardLines(string name)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 7 && item.Name == name)
|
|
{
|
|
LLUUID tid = m_ScriptEngine.m_ASYNCLSLCommandManager.
|
|
m_Dataserver.RegisterRequest(m_localID,
|
|
m_itemID, item.AssetID.ToString());
|
|
if(NotecardCache.IsCached(item.AssetID))
|
|
{
|
|
m_ScriptEngine.m_ASYNCLSLCommandManager.
|
|
m_Dataserver.DataserverReply(item.AssetID.ToString(),
|
|
NotecardCache.GetLines(item.AssetID).ToString());
|
|
return tid.ToString();
|
|
}
|
|
WithNotecard(item.AssetID, delegate (LLUUID id, AssetBase a)
|
|
{
|
|
System.Text.ASCIIEncoding enc =
|
|
new System.Text.ASCIIEncoding();
|
|
string data = enc.GetString(a.Data);
|
|
Console.WriteLine(data);
|
|
NotecardCache.Cache(id, data);
|
|
m_ScriptEngine.m_ASYNCLSLCommandManager.
|
|
m_Dataserver.DataserverReply(id.ToString(),
|
|
NotecardCache.GetLines(id).ToString());
|
|
});
|
|
|
|
return tid.ToString();
|
|
}
|
|
}
|
|
return LLUUID.Zero.ToString();
|
|
}
|
|
|
|
public string llGetNotecardLine(string name, int line)
|
|
{
|
|
m_host.AddScriptLPS(1);
|
|
|
|
foreach (TaskInventoryItem item in m_host.TaskInventory.Values)
|
|
{
|
|
if (item.Type == 7 && item.Name == name)
|
|
{
|
|
LLUUID tid = m_ScriptEngine.m_ASYNCLSLCommandManager.
|
|
m_Dataserver.RegisterRequest(m_localID,
|
|
m_itemID, item.AssetID.ToString());
|
|
if(NotecardCache.IsCached(item.AssetID))
|
|
{
|
|
m_ScriptEngine.m_ASYNCLSLCommandManager.
|
|
m_Dataserver.DataserverReply(item.AssetID.ToString(),
|
|
NotecardCache.GetLine(item.AssetID, line));
|
|
return tid.ToString();
|
|
}
|
|
WithNotecard(item.AssetID, delegate (LLUUID id, AssetBase a)
|
|
{
|
|
System.Text.ASCIIEncoding enc =
|
|
new System.Text.ASCIIEncoding();
|
|
string data = enc.GetString(a.Data);
|
|
Console.WriteLine(data);
|
|
NotecardCache.Cache(id, data);
|
|
m_ScriptEngine.m_ASYNCLSLCommandManager.
|
|
m_Dataserver.DataserverReply(id.ToString(),
|
|
NotecardCache.GetLine(id, line));
|
|
});
|
|
|
|
return tid.ToString();
|
|
}
|
|
}
|
|
|
|
return String.Empty;
|
|
}
|
|
|
|
}
|
|
|
|
public class NotecardCache
|
|
{
|
|
private class Notecard
|
|
{
|
|
public string[] text;
|
|
public DateTime lastRef;
|
|
}
|
|
|
|
private static Dictionary<LLUUID, Notecard> m_Notecards =
|
|
new Dictionary<LLUUID, Notecard>();
|
|
|
|
public static void Cache(LLUUID assetID, string text)
|
|
{
|
|
CacheCheck();
|
|
|
|
lock(m_Notecards)
|
|
{
|
|
if(m_Notecards.ContainsKey(assetID))
|
|
return;
|
|
|
|
Notecard nc = new Notecard();
|
|
nc.lastRef=DateTime.Now;
|
|
nc.text = ParseText(text.Replace("\r", "").Split('\n'));
|
|
m_Notecards[assetID] = nc;
|
|
}
|
|
}
|
|
|
|
private static string[] ParseText(string[] input)
|
|
{
|
|
int idx=0;
|
|
int level=0;
|
|
List<string> output = new List<string>();
|
|
string[] words;
|
|
|
|
while(idx < input.Length)
|
|
{
|
|
if(input[idx] == "{")
|
|
{
|
|
level++;
|
|
idx++;
|
|
continue;
|
|
}
|
|
if(input[idx]== "}")
|
|
{
|
|
level--;
|
|
idx++;
|
|
continue;
|
|
}
|
|
|
|
switch(level)
|
|
{
|
|
case 0:
|
|
words = input[idx].Split(' '); // Linden text ver
|
|
int version = int.Parse(words[3]);
|
|
if(version != 2)
|
|
return new String[0];
|
|
break;
|
|
case 1:
|
|
words = input[idx].Split(' ');
|
|
if(words[0] == "LLEmbeddedItems")
|
|
break;
|
|
if(words[0] == "Text")
|
|
{
|
|
int len = int.Parse(words[2]);
|
|
idx++;
|
|
|
|
int count=-1;
|
|
|
|
while(count < len)
|
|
{
|
|
int l = input[idx].Length;
|
|
string ln = input[idx];
|
|
|
|
int need = len-count-1;
|
|
if(ln.Length > need)
|
|
ln=ln.Substring(0, need);
|
|
|
|
output.Add(ln);
|
|
count+=ln.Length+1;
|
|
idx++;
|
|
}
|
|
|
|
return output.ToArray();
|
|
}
|
|
break;
|
|
case 2:
|
|
words = input[idx].Split(' '); // count
|
|
if(words[0] == "count")
|
|
{
|
|
int c = int.Parse(words[1]);
|
|
if(c > 0)
|
|
return new String[0];
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
idx++;
|
|
}
|
|
return output.ToArray();
|
|
}
|
|
|
|
public static bool IsCached(LLUUID assetID)
|
|
{
|
|
lock(m_Notecards)
|
|
{
|
|
return m_Notecards.ContainsKey(assetID);
|
|
}
|
|
}
|
|
|
|
public static int GetLines(LLUUID assetID)
|
|
{
|
|
if(!IsCached(assetID))
|
|
return -1;
|
|
|
|
lock(m_Notecards)
|
|
{
|
|
m_Notecards[assetID].lastRef = DateTime.Now;
|
|
return m_Notecards[assetID].text.Length;
|
|
}
|
|
}
|
|
|
|
public static string GetLine(LLUUID assetID, int line)
|
|
{
|
|
if(line < 0)
|
|
return "";
|
|
|
|
string data;
|
|
|
|
if(!IsCached(assetID))
|
|
return "";
|
|
|
|
lock(m_Notecards)
|
|
{
|
|
m_Notecards[assetID].lastRef = DateTime.Now;
|
|
|
|
if(line >= m_Notecards[assetID].text.Length)
|
|
return "\n\n\n";
|
|
|
|
data=m_Notecards[assetID].text[line];
|
|
if(data.Length > 255)
|
|
data = data.Substring(0, 255);
|
|
|
|
return data;
|
|
}
|
|
}
|
|
|
|
public static void CacheCheck()
|
|
{
|
|
foreach (LLUUID key in new List<LLUUID>(m_Notecards.Keys))
|
|
{
|
|
Notecard nc = m_Notecards[key];
|
|
if(nc.lastRef.AddSeconds(30) < DateTime.Now)
|
|
m_Notecards.Remove(key);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|