public override string Execute(string[] args, LLUUID fromAgentID)
{
if (args.Length < 1)
return "Usage: findsim [Simulator Name]";
// Build the simulator name from the args list
string simName = string.Empty;
for (int i = 0; i < args.Length; i++)
simName += args[i] + " ";
simName = simName.TrimEnd().ToLower();
//if (!GridDataCached[Client])
//{
// Client.Grid.RequestAllSims(GridManager.MapLayerType.Objects);
// System.Threading.Thread.Sleep(5000);
// GridDataCached[Client] = true;
//}
GridRegion region;
if (Client.Grid.GetGridRegion(simName, GridLayerType.Objects, out region))
return String.Format("{0}: handle={1} ({2},{3})", region.Name, region.RegionHandle, region.X, region.Y);
else
return "Lookup of " + simName + " failed";
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
Primitive closest = null;
double closestDistance = Double.MaxValue;
lock (Client.SimPrims)
{
if (Client.SimPrims.ContainsKey(Client.Network.CurrentSim))
{
foreach (Primitive p in Client.SimPrims[Client.Network.CurrentSim].Values)
{
float distance = Helpers.VecDist(Client.Self.Position, p.Position);
if (closest == null || distance < closestDistance)
{
closest = p;
closestDistance = distance;
}
}
}
}
if (closest != null)
{
Client.Self.RequestSit(closest.ID, LLVector3.Zero);
Client.Self.Sit();
return "Sat on " + closest.ID + ". Distance: " + closestDistance;
}
else
{
return "Couldn't find a nearby prim to sit on";
}
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
if (args.Length != 1)
return "Usage: debug [level] where level is one of None, Debug, Error, Info, Warn";
if (args[0].ToLower() == "debug")
{
Settings.LOG_LEVEL = Helpers.LogLevel.Debug;
return "Logging is set to Debug";
}
else if (args[0].ToLower() == "none")
{
Settings.LOG_LEVEL = Helpers.LogLevel.None;
return "Logging is set to None";
}
else if (args[0].ToLower() == "warn")
{
Settings.LOG_LEVEL = Helpers.LogLevel.Warning;
return "Logging is set to level Warning";
}
else if (args[0].ToLower() == "info")
{
Settings.LOG_LEVEL = Helpers.LogLevel.Info;
return "Logging is set to level Info";
}
else if (args[0].ToLower() == "error")
{
Settings.LOG_LEVEL = Helpers.LogLevel.Error;
return "Logging is set to level Error";
}
else
{
return "Usage: debug [level] where level is one of None, Debug, Error, Info, Warn";
}
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
if (args.Length != 1)
return "Usage: siton UUID";
LLUUID target;
if (LLUUID.TryParse(args[0], out target))
{
Primitive targetPrim = Client.Network.CurrentSim.Objects.Find(
delegate(Primitive prim)
{
return prim.ID == target;
}
);
if (targetPrim != null)
{
Client.Self.RequestSit(targetPrim.ID, LLVector3.Zero);
Client.Self.Sit();
return "Requested to sit on prim " + targetPrim.ID.ToString() +
" (" + targetPrim.LocalID + ")";
}
}
return "Couldn't find a prim to sit on with UUID " + args[0];
}
void Groups_OnGroupLeft(LLUUID groupID, bool success)
{
Console.WriteLine(Client.ToString() + (success ? " has left group " : " failed to left group ") + groupID.ToString());
leftGroup = success;
GroupsEvent.Set();
}
public SimProfile LoadFromGrid(LLUUID UUID, string GridURL, string SendKey, string RecvKey)
{
try
{
Hashtable GridReqParams = new Hashtable();
GridReqParams["UUID"] = UUID.ToString();
GridReqParams["authkey"] = SendKey;
ArrayList SendParams = new ArrayList();
SendParams.Add(GridReqParams);
XmlRpcRequest GridReq = new XmlRpcRequest("simulator_login", SendParams);
XmlRpcResponse GridResp = GridReq.Send(GridURL, 3000);
Hashtable RespData = (Hashtable)GridResp.Value;
this.UUID = new LLUUID((string)RespData["UUID"]);
this.regionhandle = Helpers.UIntsToLong(((uint)Convert.ToUInt32(RespData["region_locx"]) * 256), ((uint)Convert.ToUInt32(RespData["region_locy"]) * 256));
this.regionname = (string)RespData["regionname"];
this.sim_ip = (string)RespData["sim_ip"];
this.sim_port = (uint)Convert.ToUInt16(RespData["sim_port"]);
this.caps_url = "http://" + ((string)RespData["sim_ip"]) + ":" + (string)RespData["sim_port"] + "/";
this.RegionLocX = (uint)Convert.ToUInt32(RespData["region_locx"]);
this.RegionLocY = (uint)Convert.ToUInt32(RespData["region_locy"]);
this.sendkey = SendKey;
this.recvkey = RecvKey;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
return this;
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
ulong regionHandle;
if (args.Length == 0)
regionHandle = Client.Network.CurrentSim.Handle;
else if (!(args.Length == 1 && UInt64.TryParse(args[0], out regionHandle)))
return "Usage: agentlocations [regionhandle]";
List<GridItem> items = Client.Grid.MapItems(regionHandle, GridItemType.AgentLocations,
GridLayerType.Objects, 1000 * 20);
if (items != null)
{
StringBuilder ret = new StringBuilder();
ret.AppendLine("Agent locations:");
for (int i = 0; i < items.Count; i++)
{
GridAgentLocation location = (GridAgentLocation)items[i];
ret.AppendLine(String.Format("{0} avatar(s) at {1},{2}", location.AvatarCount, location.LocalX,
location.LocalY));
}
return ret.ToString();
}
else
{
return "Failed to fetch agent locations";
}
}
private void DoUpload(byte[] UploadData, string FileName)
{
if (UploadData != null)
{
string name = System.IO.Path.GetFileNameWithoutExtension(FileName);
Client.Inventory.RequestCreateItemFromAsset(UploadData, name, "Uploaded with TestClient",
AssetType.Texture, InventoryType.Texture, Client.Inventory.FindFolderForType(AssetType.Texture),
delegate(CapsClient client, long bytesReceived, long bytesSent, long totalBytesToReceive, long totalBytesToSend)
{
if (bytesSent > 0)
Console.WriteLine(String.Format("Texture upload: {0} / {1}", bytesSent, totalBytesToSend));
},
delegate(bool success, string status, LLUUID itemID, LLUUID assetID)
{
Console.WriteLine(String.Format(
"RequestCreateItemFromAsset() returned: Success={0}, Status={1}, ItemID={2}, AssetID={3}",
success, status, itemID, assetID));
TextureID = assetID;
Console.WriteLine(String.Format("Upload took {0}", DateTime.Now.Subtract(start)));
UploadCompleteEvent.Set();
}
);
}
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
// parse the command line
string target = String.Empty;
for (int ct = 0; ct < args.Length; ct++)
target = target + args[ct] + " ";
target = target.TrimEnd();
// initialize results list
List<InventoryBase> found = new List<InventoryBase>();
try
{
// find the folder
found = Client.Inventory.LocalFind(Client.Inventory.Store.RootFolder.UUID, target.Split('/'), 0, true);
if (found.Count.Equals(1))
{
// move the folder to the trash folder
Client.Inventory.MoveFolder(found[0].UUID, Client.Inventory.FindFolderForType(AssetType.TrashFolder));
return String.Format("Moved folder {0} to Trash", found[0].Name);
}
}
catch (InvalidOutfitException ex)
{
return "Folder Not Found: (" + ex.Message + ")";
}
return string.Empty;
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
if (args.Length < 1)
return "Usage: parceldetails parcelID (use parcelinfo to get ID)";
int parcelID;
Parcel parcel;
// test argument that is is a valid integer, then verify we have that parcel data stored in the dictionary
if (Int32.TryParse(args[0], out parcelID) && Client.Network.CurrentSim.Parcels.TryGetValue(parcelID, out parcel))
{
// this request will update the parcels dictionary
Client.Parcels.PropertiesRequest(Client.Network.CurrentSim, parcelID, 0);
// Use reflection to dynamically get the fields from the Parcel struct
Type t = parcel.GetType();
System.Reflection.FieldInfo[] fields = t.GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
StringBuilder sb = new StringBuilder();
foreach (System.Reflection.FieldInfo field in fields)
{
sb.AppendFormat("{0} = {1}" + System.Environment.NewLine, field.Name, field.GetValue(parcel));
}
return sb.ToString();
}
else
{
return String.Format("Unable to find Parcel {0} in Parcels Dictionary, Did you run parcelinfo to populate the dictionary first?", args[0]);
}
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
bool success = false;
// Register a handler for the appearance event
AutoResetEvent appearanceEvent = new AutoResetEvent(false);
AppearanceManager.AppearanceUpdatedCallback callback =
delegate(LLObject.TextureEntry te) { appearanceEvent.Set(); };
Client.Appearance.OnAppearanceUpdated += callback;
// Start the appearance setting process (with baking enabled or disabled)
Client.Appearance.SetPreviousAppearance(!(args.Length > 0 && args[0].Equals("nobake")));
// Wait for the process to complete or time out
if (appearanceEvent.WaitOne(1000 * 120, false))
success = true;
// Unregister the handler
Client.Appearance.OnAppearanceUpdated -= callback;
// Return success or failure message
if (success)
return "Successfully set appearance";
else
return "Timed out while setting appearance";
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
Client.MasterKey = LLUUID.Parse(args[0]);
lock (Client.Network.Simulators)
{
for (int i = 0; i < Client.Network.Simulators.Count; i++)
{
Avatar master = Client.Network.Simulators[i].ObjectsAvatars.Find(
delegate(Avatar avatar)
{
return avatar.ID == Client.MasterKey;
}
);
if (master != null)
{
Client.Self.InstantMessage(master.ID,
"You are now my master. IM me with \"help\" for a command list.");
break;
}
}
}
return "Master set to " + Client.MasterKey.ToString();
}
static void Main(string[] args)
{
SecondLife client = new SecondLife();
if (args.Length < 4)
{
Console.WriteLine("Usage: Key2Name [loginfirstname] [loginlastname] [password] [key]");
return;
}
Console.WriteLine("Attempting to connect and login to Second Life.");
// Setup Login to Second Life
Dictionary<string, object> loginParams = client.Network.DefaultLoginValues(args[0],
args[1], args[2], "00:00:00:00:00:00", "last", "Win", "0", "key2name",
"*****@*****.**");
Dictionary<string, object> loginReply = new Dictionary<string, object>();
if (!client.Network.Login(loginParams))
{
// Login failed
Console.WriteLine("Error logging in: " + client.Network.LoginError);
return;
}
AvatarTracker avatarTracker = new AvatarTracker(client);
LLUUID lookup = new LLUUID(args[3]);
Console.WriteLine("Looking up name for " + lookup.ToStringHyphenated());
string name = avatarTracker.GetAvatarName(lookup);
Console.WriteLine("Name: " + name + ". Press enter to logout.");
Console.ReadLine();
client.Network.Logout();
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
int faceIndex;
LLUUID textureID;
if (args.Length != 2)
return "Usage: findtexture [face-index] [texture-uuid]";
if (Int32.TryParse(args[0], out faceIndex) &&
LLUUID.TryParse(args[1], out textureID))
{
Client.Network.CurrentSim.ObjectsPrimitives.ForEach(
delegate(Primitive prim)
{
if (prim.Textures != null && prim.Textures.FaceTextures[faceIndex] != null)
{
if (prim.Textures.FaceTextures[faceIndex].TextureID == textureID)
{
Logger.Log(String.Format("Primitive {0} ({1}) has face index {2} set to {3}",
prim.ID.ToString(), prim.LocalID, faceIndex, textureID.ToString()),
Helpers.LogLevel.Info, Client);
}
}
}
);
return "Done searching";
}
else
{
return "Usage: findtexture [face-index] [texture-uuid]";
}
}
public void AddUpload(LLUUID transactionID, AssetBase asset)
{
AssetTransaction upload = new AssetTransaction();
lock (this.transactions)
{
upload.Asset = asset;
upload.TransactionID = transactionID;
this.transactions.Add(transactionID, upload);
}
if (upload.Asset.Data.Length > 2)
{
//is complete
upload.UploadComplete = true;
AssetUploadCompletePacket response = new AssetUploadCompletePacket();
response.AssetBlock.Type = asset.Type;
response.AssetBlock.Success = true;
response.AssetBlock.UUID = transactionID.Combine(this.ourClient.SecureSessionID);
this.ourClient.OutPacket(response);
m_assetCache.AddAsset(asset);
}
else
{
upload.UploadComplete = false;
upload.XferID = Util.GetNextXferID();
RequestXferPacket xfer = new RequestXferPacket();
xfer.XferID.ID = upload.XferID;
xfer.XferID.VFileType = upload.Asset.Type;
xfer.XferID.VFileID = transactionID.Combine(this.ourClient.SecureSessionID);
xfer.XferID.FilePath = 0;
xfer.XferID.Filename = new byte[0];
this.ourClient.OutPacket(xfer);
}
}
static void Main(string[] args)
{
if (args.Length < 4)
{
Console.WriteLine("Usage: Key2Name [loginfirstname] [loginlastname] [password] [key]");
return;
}
SecondLife client = new SecondLife();
Console.WriteLine("Attempting to connect and login to Second Life.");
// Login to Second Life
if (!client.Network.Login(args[0], args[1], args[2], "key2name", "*****@*****.**"))
{
// Login failed
Console.WriteLine("Error logging in: " + client.Network.LoginMessage);
return;
}
AvatarTracker avatarTracker = new AvatarTracker(client);
LLUUID lookup = new LLUUID();
LLUUID.TryParse(args[3], out lookup);
Console.WriteLine("Looking up name for " + lookup.ToStringHyphenated());
string name = avatarTracker.GetAvatarName(lookup);
Console.WriteLine("Name: " + name + Environment.NewLine + "Press enter to logout.");
Console.ReadLine();
client.Network.Logout();
}
public IMTabWindow AddIMTab(LLUUID target, LLUUID session, string targetName, InstantMessageEventArgs e)
{
IMTabWindow imTab = this.AddIMTab(target, session, targetName);
imTab.TextManager.PassIMEvent(e);
return imTab;
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
string inventoryName;
uint timeout;
string fileName;
if (args.Length != 3)
return "Usage: uploadimage [inventoryname] [timeout] [filename]";
TextureID = LLUUID.Zero;
inventoryName = args[0];
fileName = args[2];
if (!UInt32.TryParse(args[1], out timeout))
return "Usage: uploadimage [inventoryname] [timeout] [filename]";
Console.WriteLine("Loading image " + fileName);
byte[] jpeg2k = LoadImage(fileName);
if (jpeg2k == null)
return "Failed to compress image to JPEG2000";
Console.WriteLine("Finished compressing image to JPEG2000, uploading...");
start = DateTime.Now;
DoUpload(jpeg2k, inventoryName);
if (UploadCompleteEvent.WaitOne((int)timeout, false))
{
return String.Format("Texture upload {0}: {1}", (TextureID != LLUUID.Zero) ? "succeeded" : "failed",
TextureID);
}
else
{
return "Texture upload timed out";
}
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
if (args.Length == 1)
{
try
{
string treeName = args[0].Trim(new char[] { ' ' });
Tree tree = (Tree)Enum.Parse(typeof(Tree), treeName);
LLVector3 treePosition = Client.Self.SimPosition;
treePosition.Z += 3.0f;
Client.Objects.AddTree(Client.Network.CurrentSim, new LLVector3(0.5f, 0.5f, 0.5f),
LLQuaternion.Identity, treePosition, tree, Client.GroupID, false);
return "Attempted to rez a " + treeName + " tree";
}
catch (Exception)
{
return "Type !tree for usage";
}
}
string usage = "Usage: !tree [";
foreach (string value in Enum.GetNames(typeof(Tree)))
{
usage += value + ",";
}
usage = usage.TrimEnd(new char[] { ',' });
usage += "]";
return usage;
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
if (args.Length < 1)
return "Usage: findsim [Simulator Name]";
string simName = string.Empty;
for (int i = 0; i < args.Length; i++)
simName += args[i] + " ";
simName = simName.TrimEnd().ToLower();
if (!GridDataCached.ContainsKey(Client))
{
GridDataCached[Client] = false;
}
if (!GridDataCached[Client])
{
Client.Grid.AddAllSims();
System.Threading.Thread.Sleep(5000);
GridDataCached[Client] = true;
}
int attempts = 0;
GridRegion region = null;
while (region == null && attempts++ < 5)
{
region = Client.Grid.GetGridRegion(simName);
}
if (region != null)
return "Found " + region.Name + ": handle=" + region.RegionHandle +
"(" + region.X + "," + region.Y + ")";
else
return "Lookup of " + simName + " failed";
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
if (args.Length < 1)
return "Usage: wear [outfit name] eg: 'wear /My Outfit/Dance Party";
string target = String.Empty;
bool bake = true;
for (int ct = 0; ct < args.Length; ct++)
{
if (args[ct].Equals("nobake"))
bake = false;
else
target = target + args[ct] + " ";
}
target = target.TrimEnd();
try
{
Client.Appearance.WearOutfit(target.Split('/'), bake);
}
catch (InvalidOutfitException ex)
{
return "Invalid outfit (" + ex.Message + ")";
}
return String.Empty;
}
/// <summary>
///
/// </summary>
/// <param name="cmd"></param>
/// <param name="fromAgentID"></param>
/// <param name="imSessionID"></param>
public void DoCommandAll(string cmd, LLUUID fromAgentID, LLUUID imSessionID)
{
string[] tokens = cmd.Trim().Split(new char[] { ' ', '\t' });
string firstToken = tokens[0].ToLower();
if (tokens.Length == 0)
return;
if (firstToken == "login")
{
// Special login case: Only call it once, and allow it with
// no logged in avatars
string[] args = new string[tokens.Length - 1];
Array.Copy(tokens, 1, args, 0, args.Length);
Login(args);
}
else if (firstToken == "quit")
{
Quit();
Console.WriteLine("All clients logged out and program finished running.");
}
else
{
// make a copy of the clients list so that it can be iterated without fear of being changed during iteration
Dictionary<LLUUID, SecondLife> clientsCopy = new Dictionary<LLUUID, SecondLife>(Clients);
foreach (TestClient client in clientsCopy.Values)
client.DoCommand(cmd, fromAgentID, imSessionID);
}
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
if (args.Length < 1)
return "usage: Destination should be specified as sim/x/y/z";
string destination = String.Empty;
// Handle multi-word sim names by combining the arguments
foreach (string arg in args)
{
destination += arg + " ";
}
destination = destination.Trim();
string[] tokens = destination.Split(new char[] { '/' });
if (tokens.Length != 4)
return "usage: Destination should be specified as sim/x/y/z";
string sim = tokens[0];
float x = Client.Self.Position.X;
float y = Client.Self.Position.Y;
float z = Client.Self.Position.Z;
float.TryParse(tokens[1], out x);
float.TryParse(tokens[2], out y);
float.TryParse(tokens[3], out z);
if (Client.Self.Teleport(sim, new LLVector3(x, y, z)))
{
return "Teleported to " + Client.Network.CurrentSim;
}
else
{
return "Teleport failed: " + Client.Self.TeleportMessage;
}
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
if (args.Length == 0)
{
ShowEffects = true;
return "Viewer effects will be shown on the console";
}
else if (args.Length == 1)
{
if (args[0] == "on")
{
ShowEffects = true;
return "Viewer effects will be shown on the console";
}
else
{
ShowEffects = false;
return "Viewer effects will not be shown";
}
}
else
{
return "Usage: showeffects [on/off]";
}
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
StringBuilder output = new StringBuilder();
output.AppendLine(Client.Network.CurrentSim.ToString());
output.Append("UUID: ");
output.AppendLine(Client.Network.CurrentSim.ID.ToStringHyphenated());
uint x, y;
Helpers.LongToUInts(Client.Network.CurrentSim.Handle, out x, out y);
output.AppendLine(String.Format("Handle: {0} (X: {1} Y: {2})", Client.Network.CurrentSim.Handle, x, y));
output.Append("Access: ");
output.AppendLine(Client.Network.CurrentSim.Access.ToString());
output.Append("Flags: ");
output.AppendLine(Client.Network.CurrentSim.Flags.ToString());
output.Append("TerrainBase0: ");
output.AppendLine(Client.Network.CurrentSim.TerrainBase0.ToStringHyphenated());
output.Append("TerrainBase1: ");
output.AppendLine(Client.Network.CurrentSim.TerrainBase1.ToStringHyphenated());
output.Append("TerrainBase2: ");
output.AppendLine(Client.Network.CurrentSim.TerrainBase2.ToStringHyphenated());
output.Append("TerrainBase3: ");
output.AppendLine(Client.Network.CurrentSim.TerrainBase3.ToStringHyphenated());
output.Append("TerrainDetail0: ");
output.AppendLine(Client.Network.CurrentSim.TerrainDetail0.ToStringHyphenated());
output.Append("TerrainDetail1: ");
output.AppendLine(Client.Network.CurrentSim.TerrainDetail1.ToStringHyphenated());
output.Append("TerrainDetail2: ");
output.AppendLine(Client.Network.CurrentSim.TerrainDetail2.ToStringHyphenated());
output.Append("TerrainDetail3: ");
output.AppendLine(Client.Network.CurrentSim.TerrainDetail3.ToStringHyphenated());
output.Append("Water Height: ");
output.AppendLine(Client.Network.CurrentSim.WaterHeight.ToString());
return output.ToString();
}
/// <summary>
/// Get a list of current friends
/// </summary>
/// <param name="args">optional testClient command arguments</param>
/// <param name="fromAgentID">The <seealso cref="libsecondlife.LLUUID"/>
/// of the agent making the request</param>
/// <returns></returns>
public override string Execute(string[] args, LLUUID fromAgentID)
{
// initialize a StringBuilder object used to return the results
StringBuilder sb = new StringBuilder();
// Only iterate the Friends dictionary if we actually have friends!
if (Client.Friends.FriendList.Count > 0)
{
// iterate over the InternalDictionary using a delegate to populate
// our StringBuilder output string
Client.Friends.FriendList.ForEach(delegate(FriendInfo friend)
{
// append the name of the friend to our output
sb.AppendLine(friend.Name);
});
}
else
{
// we have no friends :(
sb.AppendLine("No Friends");
}
// return the result
return sb.ToString();
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
int channel = 0;
int startIndex = 0;
if (args.Length < 1)
{
return "usage: say (optional channel) whatever";
}
else if (args.Length > 1)
{
if (Int32.TryParse(args[0], out channel))
startIndex = 1;
}
StringBuilder message = new StringBuilder();
for (int i = startIndex; i < args.Length; i++)
{
message.Append(args[i]);
if (i != args.Length - 1) message.Append(" ");
}
libsecondlife.Utilities.Realism.Chat(Client, message.ToString(), ChatType.Normal, 5);
return "Said " + message.ToString();
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
if (args.Length != 1)
return Description;
LLUUID targetID;
if (!LLUUID.TryParse(args[0], out targetID))
return Description;
StringBuilder sb = new StringBuilder();
FriendsManager.FriendFoundEvent del =
delegate(LLUUID agentID, ulong regionHandle, LLVector3 location)
{
if (!regionHandle.Equals(0))
sb.AppendFormat("Found Friend {0} in {1} at {2}/{3}", agentID, regionHandle, location.X, location.Y);
else
sb.AppendFormat("Found Friend {0}, But they appear to be offline", agentID);
WaitforFriend.Set();
};
Client.Friends.OnFriendFound += del;
WaitforFriend.Reset();
Client.Friends.MapFriend(targetID);
if (!WaitforFriend.WaitOne(10000, false))
{
sb.AppendFormat("Timeout waiting for reply, Do you have mapping rights on {0}?", targetID);
}
Client.Friends.OnFriendFound -= del;
return sb.ToString();
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
if (args.Length < 3)
return "Usage: im [firstname] [lastname] [message]";
ToAvatarName = args[0] + " " + args[1];
// Build the message
string message = String.Empty;
for (int ct = 2; ct < args.Length; ct++)
message += args[ct] + " ";
message = message.TrimEnd();
if (message.Length > 1023) message = message.Remove(1023);
if (!Name2Key.ContainsKey(ToAvatarName.ToLower()))
{
// Send the Query
Client.Avatars.RequestAvatarNameSearch(ToAvatarName, LLUUID.Random());
NameSearchEvent.WaitOne(6000, false);
}
if (Name2Key.ContainsKey(ToAvatarName.ToLower()))
{
LLUUID id = Name2Key[ToAvatarName.ToLower()];
Client.Self.InstantMessage(id, message, id);
return "Instant Messaged " + id.ToStringHyphenated() + " with message: " + message;
}
else
{
return "Name lookup for " + ToAvatarName + " failed";
}
}
public override string Execute(string[] args, LLUUID fromAgentID)
{
LLUUID target;
if (args.Length != 1)
return "Usage: touch UUID";
if (LLUUID.TryParse(args[0], out target))
{
Primitive targetPrim = Client.Network.CurrentSim.ObjectsPrimitives.Find(
delegate(Primitive prim)
{
return prim.ID == target;
}
);
if (targetPrim != null)
{
Client.Self.Touch(targetPrim.LocalID);
return "Touched prim " + targetPrim.LocalID;
}
}
return "Couldn't find a prim to touch with UUID " + args[0];
}
/// <summary>
/// Send an avatar back to their home location
/// </summary>
/// <param name="pest">Key of avatar to send home</param>
public void TeleportHomeUser(LLUUID pest)
{
List <string> listParams = new List <string>();
listParams.Add(Client.Self.AgentID.ToString());
listParams.Add(pest.ToString());
EstateOwnerMessage("teleporthomeuser", listParams);
}
public InventoryNode this[LLUUID key]
{
get { return((InventoryNode)this.Dictionary[key]); }
set
{
value.Parent = parent;
lock (syncRoot) this.Dictionary[key] = value;
}
}
/// <summary>
/// Use to map a friends location on the grid.
/// </summary>
/// <param name="friendID">Friends UUID to find</param>
/// <remarks><seealso cref="E:OnFriendFound"/></remarks>
public void MapFriend(LLUUID friendID)
{
FindAgentPacket stalk = new FindAgentPacket();
stalk.AgentBlock.Hunter = Client.Self.AgentID;
stalk.AgentBlock.Prey = friendID;
Client.Network.SendPacket(stalk);
}
/// <summary>Tracks the specified avatar on your map</summary>
/// <param name="preyID">Avatar ID to track</param>
public void TrackAvatar(LLUUID preyID)
{
TrackAgentPacket p = new TrackAgentPacket();
p.AgentData.AgentID = Client.Self.AgentID;
p.AgentData.SessionID = Client.Self.SessionID;
p.TargetData.PreyID = preyID;
Client.Network.SendPacket(p);
}
/// <summary>
/// Use to track a friends movement on the grid
/// </summary>
/// <param name="friendID">Friends Key</param>
public void TrackFriend(LLUUID friendID)
{
TrackAgentPacket stalk = new TrackAgentPacket();
stalk.AgentData.AgentID = Client.Self.AgentID;
stalk.AgentData.SessionID = Client.Self.SessionID;
stalk.TargetData.PreyID = friendID;
Client.Network.SendPacket(stalk);
}
/// <summary>
/// Start a request for Avatar Properties
/// </summary>
/// <param name="avatarid"></param>
public void RequestAvatarProperties(LLUUID avatarid)
{
AvatarPropertiesRequestPacket aprp = new AvatarPropertiesRequestPacket();
aprp.AgentData.AgentID = Client.Self.AgentID;
aprp.AgentData.SessionID = Client.Self.SessionID;
aprp.AgentData.AvatarID = avatarid;
Client.Network.SendPacket(aprp);
}
/// <summary>
/// Request a single avatar name
/// </summary>
/// <param name="id">The avatar key to retrieve a name for</param>
public void RequestAvatarName(LLUUID id)
{
UUIDNameRequestPacket request = new UUIDNameRequestPacket();
request.UUIDNameBlock = new UUIDNameRequestPacket.UUIDNameBlockBlock[1];
request.UUIDNameBlock[0] = new UUIDNameRequestPacket.UUIDNameBlockBlock();
request.UUIDNameBlock[0].ID = id;
Client.Network.SendPacket(request);
}
/// <summary>
/// Creates a new Entity (should not occur on it's own)
/// </summary>
public Entity()
{
uuid = new libsecondlife.LLUUID();
localid = 0;
m_pos = new LLVector3();
velocity = new LLVector3();
rotation = new Quaternion();
m_name = "(basic entity)";
children = new List <Entity>();
}
/// <summary>Unban an avatar from an estate</summary>
/// <param name="userID">Key of Agent to remove</param>
public void UnbanUser(LLUUID userID)
{
List <string> listParams = new List <string>();
uint flag = (uint)EstateAccessDelta.UnbanUser;
listParams.Add(Client.Self.AgentID.ToString());
listParams.Add(flag.ToString());
listParams.Add(userID.ToString());
EstateOwnerMessage("estateaccessdelta", listParams);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
public void BeginGetAvatarName(LLUUID id, AgentNamesCallback anc)
{
// TODO: BeginGetAvatarNames is pretty bulky, rewrite a simple version here
List <LLUUID> ids = new List <LLUUID>();
ids.Add(id);
BeginGetAvatarNames(ids, anc);
}
/// <summary>
/// Used by the libsecondlife framework when building the initial list of friends
/// at login time. This constructor should not be called by consummer of this class.
/// </summary>
/// <param name="id">System ID of the avatar being prepesented</param>
/// <param name="theirRights">Rights the friend has to see you online and to modify your objects</param>
/// <param name="myRights">Rights you have to see your friend online and to modify their objects</param>
public FriendInfo(LLUUID id, FriendRights theirRights, FriendRights myRights)
{
m_id = id;
m_canSeeMeOnline = (theirRights & FriendRights.CanSeeOnline) != 0;
m_canSeeMeOnMap = (theirRights & FriendRights.CanSeeOnMap) != 0;
m_canModifyMyObjects = (theirRights & FriendRights.CanModifyObjects) != 0;
m_canSeeThemOnline = (myRights & FriendRights.CanSeeOnline) != 0;
m_canSeeThemOnMap = (myRights & FriendRights.CanSeeOnMap) != 0;
m_canModifyTheirObjects = (myRights & FriendRights.CanModifyObjects) != 0;
}
public Inventory(SecondLife client, InventoryManager manager, LLUUID owner)
{
Client = client;
Manager = manager;
_Owner = owner;
if (owner == LLUUID.Zero)
{
Logger.Log("Inventory owned by nobody!", Helpers.LogLevel.Warning, Client);
}
Items = new Dictionary <LLUUID, InventoryNode>();
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
public void PackUUID(LLUUID data)
{
byte[] bytes = data.GetBytes();
// Not sure if our PackBitArray function can handle 128-bit byte
//arrays, so using this for now
for (int i = 0; i < 16; i++)
{
PackBits(bytes[i], 8);
}
}
/// <summary>
/// Search for an avatar (first name, last name, and uuid)
/// </summary>
/// <param name="name">The name to search for</param>
/// <param name="queryID">An ID to associate with this query</param>
public void RequestAvatarNameSearch(string name, LLUUID queryID)
{
AvatarPickerRequestPacket aprp = new AvatarPickerRequestPacket();
aprp.AgentData.AgentID = Client.Self.AgentID;
aprp.AgentData.SessionID = Client.Self.SessionID;
aprp.AgentData.QueryID = queryID;
aprp.Data.Name = Helpers.StringToField(name);
Client.Network.SendPacket(aprp);
}
/// <summary>
/// XOR operator
/// </summary>
/// <param name="lhs">First LLUUID</param>
/// <param name="rhs">Second LLUUID</param>
/// <returns>A UUID that is a XOR combination of the two input UUIDs</returns>
public static LLUUID operator ^(LLUUID lhs, LLUUID rhs)
{
LLUUID returnUUID = new LLUUID();
for (int count = 0; count < returnUUID.Data.Length; count++)
{
returnUUID.Data[count] = (byte)(lhs.Data[count] ^ rhs.Data[count]);
}
return(returnUUID);
}
public LLUUID UnpackUUID()
{
if (bitPos != 0)
{
throw new IndexOutOfRangeException();
}
LLUUID val = new LLUUID(Data, bytePos);
bytePos += 16;
return(val);
}
/// <summary>
///
/// </summary>
/// <param name="group"></param>
/// <param name="gpc"></param>
public void BeginGetGroupProfile(LLUUID group, GroupProfileCallback gpc)
{
GroupProfileCallbacks[group] = gpc;
GroupProfileRequestPacket request = new GroupProfileRequestPacket();
request.AgentData.AgentID = Client.Network.AgentID;
request.AgentData.SessionID = Client.Network.SessionID;
request.GroupData.GroupID = group;
Client.Network.SendPacket(request);
}
public LLUUID UnpackUUID()
{
if (bitPos != 0)
{
return(LLUUID.Zero);
}
LLUUID val = new LLUUID(Data, bytePos);
bytePos += 16;
return(val);
}
private void init()
{
OwnerID = LLUUID.Zero;
AABBMin = LLVector3.Zero;
AABBMax = LLVector3.Zero;
Bitmap = new byte[512];
MediaID = LLUUID.Zero;
GroupID = LLUUID.Zero;
AuthBuyerID = LLUUID.Zero;
SnapshotID = LLUUID.Zero;
UserLocation = LLVector3.Zero;
UserLookAt = LLVector3.Zero;
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
/// <param name="groupID"></param>
/// <returns></returns>
public bool Deed(SecondLife client, LLUUID groupID)
{
ParcelDeedToGroupPacket request = new ParcelDeedToGroupPacket();
request.AgentData.AgentID = client.Network.AgentID;
request.AgentData.SessionID = client.Network.SessionID;
request.Data.LocalID = this.LocalID;
request.Data.GroupID = groupID;
client.Network.SendPacket((Packet)request, Sim);
return(true);
}
/// <summary>
/// Change the rights of a friend avatar.
/// </summary>
/// <param name="friendID">the <seealso cref="LLUUID"/> of the friend</param>
/// <param name="rights">the new rights to give the friend</param>
/// <remarks>This method will implicitly set the rights to those passed in the rights parameter.</remarks>
public void GrantRights(LLUUID friendID, FriendRights rights)
{
GrantUserRightsPacket request = new GrantUserRightsPacket();
request.AgentData.AgentID = Client.Self.AgentID;
request.AgentData.SessionID = Client.Self.SessionID;
request.Rights = new GrantUserRightsPacket.RightsBlock[1];
request.Rights[0] = new GrantUserRightsPacket.RightsBlock();
request.Rights[0].AgentRelated = friendID;
request.Rights[0].RelatedRights = (int)rights;
Client.Network.SendPacket(request);
}
/// <summary>
/// Change the rights of a friend avatar. To use this routine, first change the right of the
/// avatar stored in the item property.
/// </summary>
/// <param name="agentID">System ID of the avatar you are changing the rights of</param>
public void GrantRights(LLUUID agentID)
{
GrantUserRightsPacket request = new GrantUserRightsPacket();
request.AgentData.AgentID = Client.Self.AgentID;
request.AgentData.SessionID = Client.Self.SessionID;
request.Rights = new GrantUserRightsPacket.RightsBlock[1];
request.Rights[0] = new GrantUserRightsPacket.RightsBlock();
request.Rights[0].AgentRelated = agentID;
request.Rights[0].RelatedRights = (int)(_Friends[agentID].TheirFriendRights);
Client.Network.SendPacket(request);
}
public LLUUID RequestUpload(Asset asset, bool tempFile, bool storeLocal, bool isPriority)
{
if (asset.AssetData == null)
{
throw new ArgumentException("Can't upload an asset with no data (did you forget to call Encode?)");
}
LLUUID assetID;
LLUUID transferID = RequestUpload(out assetID, asset.AssetType, asset.AssetData, tempFile, storeLocal, isPriority);
asset.AssetID = assetID;
return(transferID);
}
private void init()
{
OwnerID = new LLUUID();
AABBMin = new LLVector3();
AABBMax = new LLVector3();
Bitmap = new byte[512];
MediaID = new LLUUID();
GroupID = new LLUUID();
AuthBuyerID = new LLUUID();
SnapshotID = new LLUUID();
UserLocation = new LLVector3();
UserLookAt = new LLVector3();
}
public SculptData(byte[] data, int pos)
{
if (data.Length >= 17)
{
SculptTexture = new LLUUID(data, pos);
Type = (SculptType)data[pos + 16];
}
else
{
SculptTexture = LLUUID.Zero;
Type = SculptType.None;
}
}
/// <summary>
///
/// </summary>
/// <param name="prey"></param>
public void KickUser(LLUUID prey)
{
EstateOwnerMessagePacket estate = new EstateOwnerMessagePacket();
estate.AgentData.AgentID = Client.Network.AgentID;
estate.AgentData.SessionID = Client.Network.SessionID;
estate.MethodData.Invoice = LLUUID.GenerateUUID();
estate.MethodData.Method = Helpers.StringToField("kick");
estate.ParamList = new EstateOwnerMessagePacket.ParamListBlock[2];
estate.ParamList[0].Parameter = Helpers.StringToField(Client.Network.AgentID.ToStringHyphenated());
estate.ParamList[1].Parameter = Helpers.StringToField(prey.ToStringHyphenated());
Client.Network.SendPacket((Packet)estate);
}
public InventoryFolder[] ParseSkeleton(NetworkManager.InventorySkeletonEntry[] skeleton, LLUUID owner)
{
Dictionary <LLUUID, InventoryFolder> Folders = new Dictionary <LLUUID, InventoryFolder>();
Dictionary <LLUUID, List <InventoryFolder> > FoldersChildren = new Dictionary <LLUUID, List <InventoryFolder> >(skeleton.Length);
foreach (NetworkManager.InventorySkeletonEntry entry in skeleton)
{
InventoryFolder folder = new InventoryFolder(entry.folder_id);
if (entry.type_default != -1)
{
folder.PreferredType = (AssetType)entry.type_default;
}
folder.Version = entry.version;
folder.OwnerID = owner;
folder.ParentUUID = LLUUID.Parse(entry.parent_id);
folder.Name = entry.name;
Folders.Add(entry.folder_id, folder);
if (entry.parent_id != LLUUID.Zero)
{
List <InventoryFolder> parentChildren;
if (!FoldersChildren.TryGetValue(entry.parent_id, out parentChildren))
{
parentChildren = new List <InventoryFolder>();
FoldersChildren.Add(entry.parent_id, parentChildren);
}
parentChildren.Add(folder);
}
}
foreach (KeyValuePair <LLUUID, List <InventoryFolder> > pair in FoldersChildren)
{
if (Folders.ContainsKey(pair.Key))
{
InventoryFolder parentFolder = Folders[pair.Key];
parentFolder.DescendentCount = pair.Value.Count; // Should we set this here? it's just the folders, not the items!
}
}
// Should we do this or just return an IEnumerable?
InventoryFolder[] ret = new InventoryFolder[Folders.Count];
int index = 0;
foreach (InventoryFolder folder in Folders.Values)
{
ret[index] = folder;
++index;
}
return(ret);
}
/// <summary>
/// This function will only check if the avatar name exists locally,
/// it will not do any networking calls to fetch the name
/// </summary>
/// <returns>The avatar name, or an empty string if it's not found</returns>
public string LocalAvatarNameLookup(LLUUID id)
{
string name = "";
lock (Avatars)
{
if (Avatars.ContainsKey(id))
{
name = Avatars[id].Name;
}
}
return(name);
}
/// <summary>
/// Plays a sound
/// </summary>
/// <param name="soundID">UUID of the sound to be played.</param>
/// <param name="handle">handle id for the sim to be played in.</param>
/// <param name="position">position for the sound to be played at. Normally the avatar.</param>
/// <param name="gain">volume of the sound, from 0.0 to 1.0</param>
public void SoundTrigger(LLUUID soundID, ulong handle, LLVector3 position, float gain)
{
SoundTriggerPacket soundtrigger = new SoundTriggerPacket();
soundtrigger.SoundData = new SoundTriggerPacket.SoundDataBlock();
soundtrigger.SoundData.SoundID = soundID;
soundtrigger.SoundData.ObjectID = LLUUID.Zero;
soundtrigger.SoundData.OwnerID = LLUUID.Zero;
soundtrigger.SoundData.ParentID = LLUUID.Zero;
soundtrigger.SoundData.Handle = handle;
soundtrigger.SoundData.Position = position;
soundtrigger.SoundData.Gain = gain;
Client.Network.SendPacket(soundtrigger);
}
/// <summary>
///
/// </summary>
/// <param name="prim"></param>
/// <param name="position"></param>
/// <param name="avatarPosition"></param>
public void RezObject(PrimObject prim, LLVector3 position, LLVector3 rayStart,
LLUUID groupID)
{
ObjectAddPacket add = new ObjectAddPacket();
add.AgentData.AgentID = Client.Network.AgentID;
add.AgentData.SessionID = Client.Network.SessionID;
add.AgentData.GroupID = groupID;
// TODO: Why 2?
add.ObjectData.AddFlags = 2;
add.ObjectData.BypassRaycast = 1;
add.ObjectData.Material = (byte)prim.Material;
add.ObjectData.PathBegin = PrimObject.PathBeginByte(prim.PathBegin);
add.ObjectData.PathCurve = (byte)prim.PathCurve;
add.ObjectData.PathEnd = PrimObject.PathEndByte(prim.PathEnd);
add.ObjectData.PathRadiusOffset = PrimObject.PathRadiusOffsetByte(prim.PathRadiusOffset);
add.ObjectData.PathRevolutions = PrimObject.PathRevolutionsByte(prim.PathRevolutions);
add.ObjectData.PathScaleX = PrimObject.PathScaleByte(prim.PathScaleX);
add.ObjectData.PathScaleY = PrimObject.PathScaleByte(prim.PathScaleY);
add.ObjectData.PathShearX = PrimObject.PathShearByte(prim.PathShearX);
add.ObjectData.PathShearY = PrimObject.PathShearByte(prim.PathShearY);
add.ObjectData.PathSkew = PrimObject.PathSkewByte(prim.PathSkew);
add.ObjectData.PathTaperX = PrimObject.PathTaperByte(prim.PathTaperX);
add.ObjectData.PathTaperY = PrimObject.PathTaperByte(prim.PathTaperY);
add.ObjectData.PathTwist = PrimObject.PathTwistByte(prim.PathTwist);
add.ObjectData.PathTwistBegin = PrimObject.PathTwistByte(prim.PathTwistBegin);
add.ObjectData.PCode = (byte)prim.PCode;
add.ObjectData.ProfileBegin = PrimObject.ProfileBeginByte(prim.ProfileBegin);
add.ObjectData.ProfileCurve = (byte)prim.ProfileCurve;
add.ObjectData.ProfileEnd = PrimObject.ProfileEndByte(prim.ProfileEnd);
add.ObjectData.ProfileHollow = (byte)prim.ProfileHollow;
add.ObjectData.RayEnd = position;
add.ObjectData.RayEndIsIntersection = 0;
add.ObjectData.RayStart = rayStart;
add.ObjectData.RayTargetID = LLUUID.GenerateUUID();
add.ObjectData.Rotation = prim.Rotation;
add.ObjectData.Scale = prim.Scale;
add.ObjectData.State = (byte)prim.State;
if (prim.Textures != null)
{
add.ObjectData.TextureEntry = prim.Textures.ToBytes();
}
else
{
add.ObjectData.TextureEntry = new byte[0];
}
Client.Network.SendPacket(add);
}