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.ObjectsPrimitives.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]); }
public override string Execute(string[] args, LLUUID fromAgentID) { if (args.Length < 1) { return("Usage: goto_landmark [UUID]"); } LLUUID landmark = new LLUUID(); if (!LLUUID.TryParse(args[0], out landmark)) { return("Invalid LLUID"); } else { Console.WriteLine("Teleporting to " + landmark.ToString()); } if (Client.Self.Teleport(landmark)) { return("Teleport Succesful"); } else { return("Teleport 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.Objects.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]); }
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.Objects.ForEach( delegate(Primitive prim) { if (prim.Textures != null && prim.Textures.FaceTextures[faceIndex] != null) { if (prim.Textures.FaceTextures[faceIndex].TextureID == textureID) { Client.Log(String.Format("Primitive {0} ({1}) has face index {2} set to {3}", prim.ID.ToString(), prim.LocalID, faceIndex, textureID.ToString()), Helpers.LogLevel.Info); } } } ); return("Done searching"); } else { return("Usage: findtexture [face-index] [texture-uuid]"); } }
private void processLandmark(string temp) { Console.Write(temp + "\n"); string[] parts = temp.Split('\n'); int.TryParse(parts[0].Substring(17, 1), out _Version); LLUUID.TryParse(parts[1].Substring(10, 36), out _Region); LLVector3.TryParse(parts[2].Substring(11, parts[2].Length - 11), out _Pos); }
public override string Execute(string[] args, LLUUID fromAgentID) { LLUUID primID; if (args.Length != 1) { return("Usage: priminfo [prim-uuid]"); } if (LLUUID.TryParse(args[0], out primID)) { Primitive target = Client.Network.CurrentSim.ObjectsPrimitives.Find( delegate(Primitive prim) { return(prim.ID == primID); } ); if (target != null) { Logger.Log("Light: " + target.Light.ToString(), Helpers.LogLevel.Info, Client); if (target.ParticleSys.CRC != 0) { Logger.Log("Particles: " + target.ParticleSys.ToString(), Helpers.LogLevel.Info, Client); } Logger.Log("TextureEntry:", Helpers.LogLevel.Info, Client); if (target.Textures != null) { Logger.Log(String.Format("Default texure: {0}", target.Textures.DefaultTexture.TextureID.ToString()), Helpers.LogLevel.Info); for (int i = 0; i < target.Textures.FaceTextures.Length; i++) { if (target.Textures.FaceTextures[i] != null) { Logger.Log(String.Format("Face {0}: {1}", i, target.Textures.FaceTextures[i].TextureID.ToString()), Helpers.LogLevel.Info, Client); } } } else { Logger.Log("null", Helpers.LogLevel.Info, Client); } return("Done."); } else { return("Could not find prim " + primID.ToString()); } } else { return("Usage: priminfo [prim-uuid]"); } }
public override string Execute(string[] args, LLUUID fromAgentID) { if (args.Length != 1) { return("Usage: objectinventory [objectID]"); } uint objectLocalID; LLUUID objectID; if (!LLUUID.TryParse(args[0], out objectID)) { return("Usage: objectinventory [objectID]"); } Primitive found = Client.Network.CurrentSim.ObjectsPrimitives.Find(delegate(Primitive prim) { return(prim.ID == objectID); }); if (found != null) { objectLocalID = found.LocalID; } else { return("Couldn't find prim " + objectID.ToString()); } List <InventoryBase> items = Client.Inventory.GetTaskInventory(objectID, objectLocalID, 1000 * 30); if (items != null) { string result = String.Empty; for (int i = 0; i < items.Count; i++) { if (items[i] is InventoryFolder) { result += String.Format("[Folder] Name: {0}", items[i].Name) + Environment.NewLine; } else { InventoryItem item = (InventoryItem)items[i]; result += String.Format("[Item] Name: {0} Desc: {1} Type: {2}", item.Name, item.Description, item.AssetType) + Environment.NewLine; } } return(result); } else { return("Failed to download task inventory for " + objectLocalID); } }
public override LLUUID AsUUID() { LLUUID uuid; if (LLUUID.TryParse(value, out uuid)) { return(uuid); } else { return(LLUUID.Zero); } }
public override string Execute(string[] args, LLUUID fromAgentID) { if (args.Length != 1) { return("Usage: downloadtexture [texture-uuid]"); } TextureID = LLUUID.Zero; DownloadHandle.Reset(); Image = null; Asset = null; if (LLUUID.TryParse(args[0], out TextureID)) { Client.Assets.RequestImage(TextureID, ImageType.Normal); if (DownloadHandle.WaitOne(120 * 1000, false)) { if (Image != null && Image.Success) { if (Asset != null && Asset.Decode()) { try { File.WriteAllBytes(Image.ID.ToString() + ".jp2", Asset.AssetData); } catch (Exception ex) { Logger.Log(ex.Message, Helpers.LogLevel.Error, Client, ex); } return(String.Format("Saved {0}.jp2 ({1}x{2})", Image.ID, Asset.Image.Width, Asset.Image.Height)); } else { return("Failed to decode texture " + TextureID.ToString()); } } else if (Image != null && Image.NotFound) { return("Simulator reported texture not found: " + TextureID.ToString()); } else { return("Download failed for texture " + TextureID.ToString()); } } else { return("Timed out waiting for texture download"); } } else { return("Usage: downloadtexture [texture-uuid]"); } }
public override string Execute(string[] args, LLUUID fromAgentID) { if (args.Length < 2) { return("Usage: imgroup [group_uuid] [message]"); } if (LLUUID.TryParse(args[0], out ToGroupID)) { string message = String.Empty; for (int ct = 1; ct < args.Length; ct++) { message += args[ct] + " "; } message = message.TrimEnd(); if (message.Length > 1023) { message = message.Remove(1023); } Client.Self.OnGroupChatJoin += new AgentManager.GroupChatJoined(Self_OnGroupChatJoin); if (!Client.Self.GroupChatSessions.ContainsKey(ToGroupID)) { WaitForSessionStart.Reset(); Client.Self.RequestJoinGroupChat(ToGroupID); } else { WaitForSessionStart.Set(); } if (WaitForSessionStart.WaitOne(10000, false)) { Client.Self.InstantMessageGroup(ToGroupID, message); } else { return("Timeout waiting for group session start"); } Client.Self.OnGroupChatJoin -= new AgentManager.GroupChatJoined(Self_OnGroupChatJoin); return("Instant Messaged group " + ToGroupID.ToString() + " with message: " + message); } else { return("failed to instant message group"); } }
public override string Execute(string[] args, LLUUID fromAgentID) { if (args.Length < 2) { return("Usage: give <agent uuid> <item1> [item2] [item3] [...]"); } LLUUID dest; if (!LLUUID.TryParse(args[0], out dest)) { return("First argument expected agent UUID."); } Manager = Client.Inventory; Inventory = Manager.Store; string ret = ""; string nl = "\n"; for (int i = 1; i < args.Length; ++i) { string inventoryName = args[i]; // WARNING: Uses local copy of inventory contents, need to download them first. List <InventoryBase> contents = Inventory.GetContents(Client.CurrentDirectory); bool found = false; foreach (InventoryBase b in contents) { if (inventoryName == b.Name || inventoryName == b.UUID.ToString()) { found = true; if (b is InventoryItem) { InventoryItem item = b as InventoryItem; Manager.GiveItem(item.UUID, item.Name, item.AssetType, dest, true); ret += "Gave " + item.Name + nl; } else { ret += "Unable to give folder " + b.Name + nl; } } } if (!found) { ret += "No inventory item named " + inventoryName + " found." + nl; } } return(ret); }
public override string Execute(string[] args, LLUUID fromAgentID) { LLUUID id; string path; if (args.Length == 1) { id = Client.Self.AgentID; path = args[0]; } else if (args.Length == 2) { if (!LLUUID.TryParse(args[0], out id)) { return("Usage: exportoutfit [avataruuid] outputfile.xml"); } path = args[1]; } else { return("Usage: exportoutfit [avataruuid] outputfile.xml"); } lock (Client.Appearances) { if (Client.Appearances.ContainsKey(id)) { try { File.WriteAllText(path, Packet.ToXmlString(Client.Appearances[id])); } catch (Exception e) { return(e.ToString()); } return("Exported appearance for avatar " + id.ToString() + " to " + args[1]); } else { return("Couldn't find an appearance for avatar " + id.ToString()); } } }
private string AddTestScript(string request, string path, string param) { int index = path.LastIndexOf('/'); string lluidStr = path.Substring(index + 1); LLUUID id; if (LLUUID.TryParse(lluidStr, out id)) { // This is just here for concept purposes... Remove! m_world.AddScript(m_world.Entities[id], new FollowRandomAvatar()); return(String.Format("Added new script to object [{0}]", id)); } else { return(String.Format("Couldn't parse [{0}]", lluidStr)); } }
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()); }
static void Main(string[] args) { if (args.Length < 4) { Console.WriteLine("Usage: Key2Name [loginfirstname] [loginlastname] [password] [key]"); return; } SecondLife client = new SecondLife(); client.Avatars.OnAvatarNames += new AvatarManager.AvatarNamesCallback(Avatars_OnAvatarNames); 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; } LLUUID lookup = new LLUUID(); LLUUID.TryParse(args[3], out lookup); Console.WriteLine("Looking up name for " + lookup.ToString()); client.Avatars.RequestAvatarName(lookup); if (!NameEvent.WaitOne(15 * 1000, false)) { Console.WriteLine("Name lookup timed out."); } Console.WriteLine("Press enter to logout."); Console.ReadLine(); client.Network.Logout(); }
// synchronous // Only works with non-LUUID-recipients if these recipients are logged in!! // if recipientLastName == "LLUUID", recipientFirstName is expected to contain a valid LLUUID // for instant messagin while avatar isn't online public bool sendIM(string message, string recipientFirstName, string recipientLastName) { LLUUID id = LLUUID.Zero; // passed LLUUID directly if (recipientLastName.Equals("LLUUID")) { if (!LLUUID.TryParse(recipientFirstName, out id)) { #if DEBUG Console.Out.WriteLine("LLUUID parsing for {0} failed", recipientFirstName); #endif return(false); } } // get LLUUID by friedship list lookup else if (Friends.FriendList.Count > 0) { Friends.FriendList.ForEach(delegate(FriendInfo friend) { #if DEBUG Console.Out.WriteLine(friend.Name); #endif String tmpAvatarName = recipientFirstName + " " + recipientLastName; if (friend.Name.ToLower() == tmpAvatarName.ToLower()) { id = friend.UUID; } }); } // lookup LLUUID through system, only works if recipients are logged in!! if (id == LLUUID.Zero) { lock (toAvatarName) { toAvatarName = recipientFirstName + " " + recipientLastName; if (!name2Key.ContainsKey(toAvatarName.ToLower())) { // Send the Query Avatars.RequestAvatarNameSearch(toAvatarName, LLUUID.Random()); nameSearchEvent.WaitOne(6000, false); } if (name2Key.ContainsKey(toAvatarName.ToLower())) { id = name2Key[toAvatarName.ToLower()]; } else { #if DEBUG Console.Out.WriteLine("Name lookup for {0} failed", toAvatarName); #endif return(false); } } } // Build the message message = message.TrimEnd(); if (message.Length > 1023) { message = message.Remove(1023); } Self.InstantMessage(id, message); #if DEBUG Console.Out.WriteLine("Instant Messaged {0} with message: {1}", id.ToString(), message); #endif return(true); }
public override string Execute(string[] args, LLUUID fromAgentID) { if (args.Length != 1) { return("Usage: exportparticles [prim-uuid]"); } LLUUID id; if (!LLUUID.TryParse(args[0], out id)) { return("Usage: exportparticles [prim-uuid]"); } lock (Client.Network.Simulators) { for (int i = 0; i < Client.Network.Simulators.Count; i++) { Primitive exportPrim = Client.Network.Simulators[i].Objects.Find( delegate(Primitive prim) { return(prim.ID == id); } ); if (exportPrim != null) { if (exportPrim.ParticleSys.CRC != 0) { StringBuilder lsl = new StringBuilder(); #region Particle System to LSL lsl.Append("default" + Environment.NewLine); lsl.Append("{" + Environment.NewLine); lsl.Append(" state_entry()" + Environment.NewLine); lsl.Append(" {" + Environment.NewLine); lsl.Append(" llParticleSystem([" + Environment.NewLine); lsl.Append(" PSYS_PART_FLAGS, 0"); if ((exportPrim.ParticleSys.PartDataFlags & Primitive.ParticleSystem.ParticleDataFlags.InterpColor) != 0) { lsl.Append(" | PSYS_PART_INTERP_COLOR_MASK"); } if ((exportPrim.ParticleSys.PartDataFlags & Primitive.ParticleSystem.ParticleDataFlags.InterpScale) != 0) { lsl.Append(" | PSYS_PART_INTERP_SCALE_MASK"); } if ((exportPrim.ParticleSys.PartDataFlags & Primitive.ParticleSystem.ParticleDataFlags.Bounce) != 0) { lsl.Append(" | PSYS_PART_BOUNCE_MASK"); } if ((exportPrim.ParticleSys.PartDataFlags & Primitive.ParticleSystem.ParticleDataFlags.Wind) != 0) { lsl.Append(" | PSYS_PART_WIND_MASK"); } if ((exportPrim.ParticleSys.PartDataFlags & Primitive.ParticleSystem.ParticleDataFlags.FollowSrc) != 0) { lsl.Append(" | PSYS_PART_FOLLOW_SRC_MASK"); } if ((exportPrim.ParticleSys.PartDataFlags & Primitive.ParticleSystem.ParticleDataFlags.FollowVelocity) != 0) { lsl.Append(" | PSYS_PART_FOLLOW_VELOCITY_MASK"); } if ((exportPrim.ParticleSys.PartDataFlags & Primitive.ParticleSystem.ParticleDataFlags.TargetPos) != 0) { lsl.Append(" | PSYS_PART_TARGET_POS_MASK"); } if ((exportPrim.ParticleSys.PartDataFlags & Primitive.ParticleSystem.ParticleDataFlags.TargetLinear) != 0) { lsl.Append(" | PSYS_PART_TARGET_LINEAR_MASK"); } if ((exportPrim.ParticleSys.PartDataFlags & Primitive.ParticleSystem.ParticleDataFlags.Emissive) != 0) { lsl.Append(" | PSYS_PART_EMISSIVE_MASK"); } lsl.Append(","); lsl.Append(Environment.NewLine); lsl.Append(" PSYS_SRC_PATTERN, 0"); if ((exportPrim.ParticleSys.Pattern & Primitive.ParticleSystem.SourcePattern.Drop) != 0) { lsl.Append(" | PSYS_SRC_PATTERN_DROP"); } if ((exportPrim.ParticleSys.Pattern & Primitive.ParticleSystem.SourcePattern.Explode) != 0) { lsl.Append(" | PSYS_SRC_PATTERN_EXPLODE"); } if ((exportPrim.ParticleSys.Pattern & Primitive.ParticleSystem.SourcePattern.Angle) != 0) { lsl.Append(" | PSYS_SRC_PATTERN_ANGLE"); } if ((exportPrim.ParticleSys.Pattern & Primitive.ParticleSystem.SourcePattern.AngleCone) != 0) { lsl.Append(" | PSYS_SRC_PATTERN_ANGLE_CONE"); } if ((exportPrim.ParticleSys.Pattern & Primitive.ParticleSystem.SourcePattern.AngleConeEmpty) != 0) { lsl.Append(" | PSYS_SRC_PATTERN_ANGLE_CONE_EMPTY"); } lsl.Append("," + Environment.NewLine); lsl.Append(" PSYS_PART_START_ALPHA, " + String.Format("{0:0.00000}", exportPrim.ParticleSys.PartStartColor.A) + "," + Environment.NewLine); lsl.Append(" PSYS_PART_END_ALPHA, " + String.Format("{0:0.00000}", exportPrim.ParticleSys.PartEndColor.A) + "," + Environment.NewLine); lsl.Append(" PSYS_PART_START_COLOR, " + exportPrim.ParticleSys.PartStartColor.ToStringRGB() + "," + Environment.NewLine); lsl.Append(" PSYS_PART_END_COLOR, " + exportPrim.ParticleSys.PartEndColor.ToStringRGB() + "," + Environment.NewLine); lsl.Append(" PSYS_PART_START_SCALE, <" + String.Format("{0:0.00000}", exportPrim.ParticleSys.PartStartScaleX) + ", " + String.Format("{0:0.00000}", exportPrim.ParticleSys.PartStartScaleY) + ", 0>, " + Environment.NewLine); lsl.Append(" PSYS_PART_END_SCALE, <" + String.Format("{0:0.00000}", exportPrim.ParticleSys.PartEndScaleX) + ", " + String.Format("{0:0.00000}", exportPrim.ParticleSys.PartEndScaleY) + ", 0>, " + Environment.NewLine); lsl.Append(" PSYS_PART_MAX_AGE, " + String.Format("{0:0.00000}", exportPrim.ParticleSys.PartMaxAge) + "," + Environment.NewLine); lsl.Append(" PSYS_SRC_MAX_AGE, " + String.Format("{0:0.00000}", exportPrim.ParticleSys.MaxAge) + "," + Environment.NewLine); lsl.Append(" PSYS_SRC_ACCEL, " + exportPrim.ParticleSys.PartAcceleration.ToString() + "," + Environment.NewLine); lsl.Append(" PSYS_SRC_BURST_PART_COUNT, " + String.Format("{0:0}", exportPrim.ParticleSys.BurstPartCount) + "," + Environment.NewLine); lsl.Append(" PSYS_SRC_BURST_RADIUS, " + String.Format("{0:0.00000}", exportPrim.ParticleSys.BurstRadius) + "," + Environment.NewLine); lsl.Append(" PSYS_SRC_BURST_RATE, " + String.Format("{0:0.00000}", exportPrim.ParticleSys.BurstRate) + "," + Environment.NewLine); lsl.Append(" PSYS_SRC_BURST_SPEED_MIN, " + String.Format("{0:0.00000}", exportPrim.ParticleSys.BurstSpeedMin) + "," + Environment.NewLine); lsl.Append(" PSYS_SRC_BURST_SPEED_MAX, " + String.Format("{0:0.00000}", exportPrim.ParticleSys.BurstSpeedMax) + "," + Environment.NewLine); lsl.Append(" PSYS_SRC_INNERANGLE, " + String.Format("{0:0.00000}", exportPrim.ParticleSys.InnerAngle) + "," + Environment.NewLine); lsl.Append(" PSYS_SRC_OUTERANGLE, " + String.Format("{0:0.00000}", exportPrim.ParticleSys.OuterAngle) + "," + Environment.NewLine); lsl.Append(" PSYS_SRC_OMEGA, " + exportPrim.ParticleSys.AngularVelocity.ToString() + "," + Environment.NewLine); lsl.Append(" PSYS_SRC_TEXTURE, (key)\"" + exportPrim.ParticleSys.Texture.ToString() + "\"," + Environment.NewLine); lsl.Append(" PSYS_SRC_TARGET_KEY, (key)\"" + exportPrim.ParticleSys.Target.ToString() + "\"" + Environment.NewLine); lsl.Append(" ]);" + Environment.NewLine); lsl.Append(" }" + Environment.NewLine); lsl.Append("}" + Environment.NewLine); #endregion Particle System to LSL return(lsl.ToString()); } else { return("Prim " + exportPrim.LocalID + " does not have a particle system"); } } } } return("Couldn't find prim " + id.ToString()); }
public override string Execute(string[] args, LLUUID fromAgentID) { if (args.Length != 2 && !(args.Length == 1 && SelectedObject != LLUUID.Zero)) { return("Usage: export uuid outputfile.xml"); } LLUUID id; uint localid; string file; if (args.Length == 2) { file = args[1]; if (!LLUUID.TryParse(args[0], out id)) { return("Usage: export uuid outputfile.xml"); } } else { file = args[0]; id = SelectedObject; } Primitive exportPrim; exportPrim = Client.Network.CurrentSim.ObjectsPrimitives.Find( delegate(Primitive prim) { return(prim.ID == id); } ); if (exportPrim != null) { if (exportPrim.ParentID != 0) { localid = exportPrim.ParentID; } else { localid = exportPrim.LocalID; } // Check for export permission first Client.Objects.RequestObjectPropertiesFamily(Client.Network.CurrentSim, id); GotPermissionsEvent.WaitOne(1000 * 10, false); if (!GotPermissions) { return("Couldn't fetch permissions for the requested object, try again"); } else { GotPermissions = false; if (Properties.OwnerID != Client.Self.AgentID && Properties.OwnerID != Client.MasterKey && Client.Self.AgentID != Client.Self.AgentID) { return("That object is owned by " + Properties.OwnerID + ", we don't have permission " + "to export it"); } } List <Primitive> prims = Client.Network.CurrentSim.ObjectsPrimitives.FindAll( delegate(Primitive prim) { return(prim.LocalID == localid || prim.ParentID == localid); } ); bool complete = RequestObjectProperties(prims, 250); if (!complete) { Logger.Log("Warning: Unable to retrieve full properties for:", Helpers.LogLevel.Warning, Client); foreach (LLUUID uuid in PrimsWaiting.Keys) { Logger.Log(uuid.ToString(), Helpers.LogLevel.Warning, Client); } } string output = LLSDParser.SerializeXmlString(Helpers.PrimListToLLSD(prims)); try { File.WriteAllText(file, output); } catch (Exception e) { return(e.Message); } Logger.Log("Exported " + prims.Count + " prims to " + file, Helpers.LogLevel.Info, Client); // Create a list of all of the textures to download List <ImageRequest> textureRequests = new List <ImageRequest>(); lock (Textures) { for (int i = 0; i < prims.Count; i++) { Primitive prim = prims[i]; if (prim.Textures.DefaultTexture.TextureID != LLObject.TextureEntry.WHITE_TEXTURE && !Textures.Contains(prim.Textures.DefaultTexture.TextureID)) { Textures.Add(prim.Textures.DefaultTexture.TextureID); } for (int j = 0; j < prim.Textures.FaceTextures.Length; j++) { if (prim.Textures.FaceTextures[j] != null && prim.Textures.FaceTextures[j].TextureID != LLObject.TextureEntry.WHITE_TEXTURE && !Textures.Contains(prim.Textures.FaceTextures[j].TextureID)) { Textures.Add(prim.Textures.FaceTextures[j].TextureID); } } if (prim.Sculpt.SculptTexture != LLUUID.Zero && !Textures.Contains(prim.Sculpt.SculptTexture)) { Textures.Add(prim.Sculpt.SculptTexture); } } // Create a request list from all of the images for (int i = 0; i < Textures.Count; i++) { textureRequests.Add(new ImageRequest(Textures[i], ImageType.Normal, 1013000.0f, 0)); } } // Download all of the textures in the export list Client.Assets.RequestImages(textureRequests); return("XML exported, began downloading " + Textures.Count + " textures"); } else { return("Couldn't find UUID " + id.ToString() + " in the " + Client.Network.CurrentSim.ObjectsPrimitives.Count + "objects currently indexed in the current simulator"); } }
public override string Execute(string[] args, LLUUID fromAgentID) { if (args.Length != 1) { return("Usage: dumpoutfit [avatar-uuid]"); } LLUUID target; if (!LLUUID.TryParse(args[0], out target)) { return("Usage: dumpoutfit [avatar-uuid]"); } lock (Client.Network.Simulators) { for (int i = 0; i < Client.Network.Simulators.Count; i++) { Avatar targetAv; targetAv = Client.Network.Simulators[i].Objects.Find( delegate(Avatar avatar) { return(avatar.ID == target); } ); if (targetAv != null) { StringBuilder output = new StringBuilder("Downloading "); lock (OutfitAssets) OutfitAssets.Clear(); Client.Assets.OnImageReceived += ImageReceivedHandler; for (int j = 0; j < targetAv.Textures.FaceTextures.Length; j++) { LLObject.TextureEntryFace face = targetAv.Textures.FaceTextures[j]; if (face != null) { ImageType type = ImageType.Normal; switch ((AppearanceManager.TextureIndex)j) { case AppearanceManager.TextureIndex.HeadBaked: case AppearanceManager.TextureIndex.EyesBaked: case AppearanceManager.TextureIndex.UpperBaked: case AppearanceManager.TextureIndex.LowerBaked: case AppearanceManager.TextureIndex.SkirtBaked: type = ImageType.Baked; break; } OutfitAssets.Add(face.TextureID); Client.Assets.RequestImage(face.TextureID, type, 100000.0f, 0); output.Append(((AppearanceManager.TextureIndex)j).ToString()); output.Append(" "); } } return(output.ToString()); } } } return("Couldn't find avatar " + target.ToString()); }
/// <summary> /// Converts byte[] data from a data transfer into a bodypart class /// </summary> /// <returns></returns> internal void UpdateFromAssetData() { if (AssetData == null || AssetData.Length == 0) { return; } string wearableData = Helpers.FieldToUTF8String(this._AssetData); int version = -1; int n = -1; try { n = wearableData.IndexOf('\n'); version = Int32.Parse(wearableData.Substring(19, n - 18)); wearableData = wearableData.Remove(0, n); if (version != 22) { Console.WriteLine("** WARNING ** : Wearable asset has unrecognized version " + version); return; } n = wearableData.IndexOf('\n'); Name = wearableData.Substring(0, n); wearableData = wearableData.Remove(0, n); n = wearableData.IndexOf('\n'); Description = wearableData.Substring(0, n); wearableData = wearableData.Remove(0, n); // Split in to an upper and lower half string[] parts = wearableData.Split(new string[] { "parameters" }, StringSplitOptions.None); parts[1] = "parameters" + parts[1]; // Parse the upper half string[] lines = parts[0].Split('\n'); foreach (string thisline in lines) { string line = thisline.Trim(); string[] fields = line.Split('\t'); if (fields.Length == 2) { if (fields[0] == "creator_mask") { // Deprecated, apply this as the base mask _Permission_Base_Mask = UInt32.Parse(fields[1], System.Globalization.NumberStyles.HexNumber); } else if (fields[0] == "base_mask") { _Permission_Base_Mask = UInt32.Parse(fields[1], System.Globalization.NumberStyles.HexNumber); } else if (fields[0] == "owner_mask") { _Permission_Owner_Mask = UInt32.Parse(fields[1], System.Globalization.NumberStyles.HexNumber); } else if (fields[0] == "group_mask") { _Permission_Group_Mask = UInt32.Parse(fields[1], System.Globalization.NumberStyles.HexNumber); } else if (fields[0] == "everyone_mask") { _Permission_Everyone_Mask = UInt32.Parse(fields[1], System.Globalization.NumberStyles.HexNumber); } else if (fields[0] == "next_owner_mask") { _Permission_Next_Owner_Mask = UInt32.Parse(fields[1], System.Globalization.NumberStyles.HexNumber); } else if (fields[0] == "creator_id") { _Creator_ID = new LLUUID(fields[1]); } else if (fields[0] == "owner_id") { _Owner_ID = new LLUUID(fields[1]); } else if (fields[0] == "last_owner_id") { _Last_Owner_ID = new LLUUID(fields[1]); } else if (fields[0] == "group_id") { _Group_ID = new LLUUID(fields[1]); } else if (fields[0] == "group_owned") { _Group_Owned = (Int32.Parse(fields[1]) != 0); } else if (fields[0] == "sale_type") { for (int i = 0; i < _ForSaleNames.Length; i++) { if (fields[1] == _ForSaleNames[i]) { _Sale = (_ForSale)i; break; } } } else if (fields[0] == "sale_price") { _Sale_Price = UInt32.Parse(fields[1]); } else if (fields[0] == "perm_mask") { Console.WriteLine("** WARNING ** : Wearable asset has deprecated perm_mask field, ignoring"); } } else if (line.StartsWith("type ")) { AppearanceLayer = (AppearanceLayerType)Int32.Parse(line.Substring(5)); break; } } // Break up the lower half in to parameters and textures string[] lowerparts = parts[1].Split(new string[] { "textures" }, StringSplitOptions.None); lowerparts[1] = "textures" + lowerparts[1]; // Parse the parameters lines = lowerparts[0].Split('\n'); foreach (string line in lines) { string[] fields = line.Split(' '); int id; if (Int32.TryParse(fields[0], out id) == false) { continue; // Not interested in this line } float weight = 0.0f; Single.TryParse(fields[1], System.Globalization.NumberStyles.Float, Helpers.EnUsCulture.NumberFormat, out weight); _Parameters[id] = weight; } // Parse the textures lines = lowerparts[1].Split('\n'); foreach (string line in lines) { string[] fields = line.Split(' '); uint id; if (UInt32.TryParse(fields[0], out id) == false) { continue; // Not interested in this line } LLUUID texture; if (LLUUID.TryParse(fields[1], out texture) == false) { continue; // if it won't parse, ignore and continue } _Textures[id] = texture; } return; } catch (Exception e) { Console.WriteLine("** WARNING **", "Failed to parse wearable asset: " + e.ToString()); } return; }
public override string Execute(string[] args, LLUUID fromAgentID) { if (args.Length != 2 && !(args.Length == 1 && SelectedObject != LLUUID.Zero)) { return("Usage: export uuid outputfile.xml"); } LLUUID id; uint localid; string file; if (args.Length == 2) { file = args[1]; if (!LLUUID.TryParse(args[0], out id)) { return("Usage: export uuid outputfile.xml"); } } else { file = args[0]; id = SelectedObject; } Primitive exportPrim; exportPrim = Client.Network.CurrentSim.Objects.Find( delegate(Primitive prim) { return(prim.ID == id); } ); if (exportPrim != null) { if (exportPrim.ParentID != 0) { localid = exportPrim.ParentID; } else { localid = exportPrim.LocalID; } // Check for export permission first Client.Objects.RequestObjectPropertiesFamily(Client.Network.CurrentSim, id); GotPermissionsEvent.WaitOne(1000 * 10, false); if (!GotPermissions) { return("Couldn't fetch permissions for the requested object, try again"); } else { GotPermissions = false; if (Properties.OwnerID != Client.Self.AgentID && Properties.OwnerID != Client.MasterKey && Client.Self.AgentID != Client.Self.AgentID) { return("That object is owned by " + Properties.OwnerID + ", we don't have permission " + "to export it"); } } List <Primitive> prims = Client.Network.CurrentSim.Objects.FindAll( delegate(Primitive prim) { return(prim.LocalID == localid || prim.ParentID == localid); } ); bool complete = RequestObjectProperties(prims, 250); if (!complete) { Console.WriteLine("Warning: Unable to retrieve full properties for:"); foreach (LLUUID uuid in PrimsWaiting.Keys) { Console.WriteLine(uuid); } } string output = LLSDParser.SerializeXmlString(Helpers.PrimListToLLSD(prims)); try { File.WriteAllText(file, output); } catch (Exception e) { return(e.Message); } return("Exported " + prims.Count + " prims to " + file); } else { return("Couldn't find UUID " + id.ToString() + " in the " + Client.Network.CurrentSim.Objects.PrimCount + "objects currently indexed in the current simulator"); } }
/// <summary> /// /// </summary> /// <param name="reader"></param> /// <returns></returns> private static LLSD DeserializeNotationElement(StringReader reader) { int character = ReadAndSkipWhitespace(reader); if (character < 0) { return(new LLSD()); // server returned an empty file, so we're going to pass along a null LLSD object } LLSD llsd; int matching; switch ((char)character) { case undefNotationValue: llsd = new LLSD(); break; case trueNotationValueOne: llsd = LLSD.FromBoolean(true); break; case trueNotationValueTwo: matching = BufferCharactersEqual(reader, trueNotationValueTwoFull, 1); if (matching > 1 && matching < trueNotationValueTwoFull.Length) { throw new LLSDException("Notation LLSD parsing: True value parsing error:"); } llsd = LLSD.FromBoolean(true); break; case trueNotationValueThree: matching = BufferCharactersEqual(reader, trueNotationValueThreeFull, 1); if (matching > 1 && matching < trueNotationValueThreeFull.Length) { throw new LLSDException("Notation LLSD parsing: True value parsing error:"); } llsd = LLSD.FromBoolean(true); break; case falseNotationValueOne: llsd = LLSD.FromBoolean(false); break; case falseNotationValueTwo: matching = BufferCharactersEqual(reader, falseNotationValueTwoFull, 1); if (matching > 1 && matching < falseNotationValueTwoFull.Length) { throw new LLSDException("Notation LLSD parsing: True value parsing error:"); } llsd = LLSD.FromBoolean(false); break; case falseNotationValueThree: matching = BufferCharactersEqual(reader, falseNotationValueThreeFull, 1); if (matching > 1 && matching < falseNotationValueThreeFull.Length) { throw new LLSDException("Notation LLSD parsing: True value parsing error:"); } llsd = LLSD.FromBoolean(false); break; case integerNotationMarker: llsd = DeserializeNotationInteger(reader); break; case realNotationMarker: llsd = DeserializeNotationReal(reader); break; case uuidNotationMarker: char[] uuidBuf = new char[36]; if (reader.Read(uuidBuf, 0, 36) < 36) { throw new LLSDException("Notation LLSD parsing: Unexpected end of stream in UUID."); } LLUUID lluuid; if (!LLUUID.TryParse(new String(uuidBuf), out lluuid)) { throw new LLSDException("Notation LLSD parsing: Invalid UUID discovered."); } llsd = LLSD.FromUUID(lluuid); break; case binaryNotationMarker: byte[] bytes = new byte[0]; int bChar = reader.Peek(); if (bChar < 0) { throw new LLSDException("Notation LLSD parsing: Unexpected end of stream in binary."); } if ((char)bChar == sizeBeginNotationMarker) { throw new LLSDException("Notation LLSD parsing: Raw binary encoding not supported."); } else if (Char.IsDigit((char)bChar)) { char[] charsBaseEncoding = new char[2]; if (reader.Read(charsBaseEncoding, 0, 2) < 2) { throw new LLSDException("Notation LLSD parsing: Unexpected end of stream in binary."); } int baseEncoding; if (!Int32.TryParse(new String(charsBaseEncoding), out baseEncoding)) { throw new LLSDException("Notation LLSD parsing: Invalid binary encoding base."); } if (baseEncoding == 64) { if (reader.Read() < 0) { throw new LLSDException("Notation LLSD parsing: Unexpected end of stream in binary."); } string bytes64 = GetStringDelimitedBy(reader, doubleQuotesNotationMarker); bytes = Convert.FromBase64String(bytes64); } else { throw new LLSDException("Notation LLSD parsing: Encoding base" + baseEncoding + " + not supported."); } } llsd = LLSD.FromBinary(bytes); break; case stringNotationMarker: int numChars = GetLengthInBrackets(reader); if (reader.Read() < 0) { throw new LLSDException("Notation LLSD parsing: Unexpected end of stream in string."); } char[] chars = new char[numChars]; if (reader.Read(chars, 0, numChars) < numChars) { throw new LLSDException("Notation LLSD parsing: Unexpected end of stream in string."); } if (reader.Read() < 0) { throw new LLSDException("Notation LLSD parsing: Unexpected end of stream in string."); } llsd = LLSD.FromString(new String(chars)); break; case singleQuotesNotationMarker: string sOne = GetStringDelimitedBy(reader, singleQuotesNotationMarker); llsd = LLSD.FromString(sOne); break; case doubleQuotesNotationMarker: string sTwo = GetStringDelimitedBy(reader, doubleQuotesNotationMarker); llsd = LLSD.FromString(sTwo); break; case uriNotationMarker: if (reader.Read() < 0) { throw new LLSDException("Notation LLSD parsing: Unexpected end of stream in string."); } string sUri = GetStringDelimitedBy(reader, doubleQuotesNotationMarker); Uri uri; try { uri = new Uri(sUri, UriKind.RelativeOrAbsolute); } catch { throw new LLSDException("Notation LLSD parsing: Invalid Uri format detected."); } llsd = LLSD.FromUri(uri); break; case dateNotationMarker: if (reader.Read() < 0) { throw new LLSDException("Notation LLSD parsing: Unexpected end of stream in date."); } string date = GetStringDelimitedBy(reader, doubleQuotesNotationMarker); DateTime dt; if (!Helpers.TryParse(date, out dt)) { throw new LLSDException("Notation LLSD parsing: Invalid date discovered."); } llsd = LLSD.FromDate(dt); break; case arrayBeginNotationMarker: llsd = DeserializeNotationArray(reader); break; case mapBeginNotationMarker: llsd = DeserializeNotationMap(reader); break; default: throw new LLSDException("Notation LLSD parsing: Unknown type marker '" + (char)character + "'."); } return(llsd); }
private static LLSD ParseXmlElement(XmlTextReader reader) { SkipWhitespace(reader); if (reader.NodeType != XmlNodeType.Element) { throw new LLSDException("Expected an element"); } string type = reader.LocalName; LLSD ret; switch (type) { case "undef": if (reader.IsEmptyElement) { reader.Read(); return(new LLSD()); } reader.Read(); SkipWhitespace(reader); ret = new LLSD(); break; case "boolean": if (reader.IsEmptyElement) { reader.Read(); return(LLSD.FromBoolean(false)); } if (reader.Read()) { string s = reader.ReadString().Trim(); if (!String.IsNullOrEmpty(s) && (s == "true" || s == "1")) { ret = LLSD.FromBoolean(true); break; } } ret = LLSD.FromBoolean(false); break; case "integer": if (reader.IsEmptyElement) { reader.Read(); return(LLSD.FromInteger(0)); } if (reader.Read()) { int value = 0; Helpers.TryParse(reader.ReadString().Trim(), out value); ret = LLSD.FromInteger(value); break; } ret = LLSD.FromInteger(0); break; case "real": if (reader.IsEmptyElement) { reader.Read(); return(LLSD.FromReal(0d)); } if (reader.Read()) { double value = 0d; string str = reader.ReadString().Trim().ToLower(); if (str == "nan") { value = Double.NaN; } else { Helpers.TryParse(str, out value); } ret = LLSD.FromReal(value); break; } ret = LLSD.FromReal(0d); break; case "uuid": if (reader.IsEmptyElement) { reader.Read(); return(LLSD.FromUUID(LLUUID.Zero)); } if (reader.Read()) { LLUUID value = LLUUID.Zero; LLUUID.TryParse(reader.ReadString().Trim(), out value); ret = LLSD.FromUUID(value); break; } ret = LLSD.FromUUID(LLUUID.Zero); break; case "date": if (reader.IsEmptyElement) { reader.Read(); return(LLSD.FromDate(Helpers.Epoch)); } if (reader.Read()) { DateTime value = Helpers.Epoch; Helpers.TryParse(reader.ReadString().Trim(), out value); ret = LLSD.FromDate(value); break; } ret = LLSD.FromDate(Helpers.Epoch); break; case "string": if (reader.IsEmptyElement) { reader.Read(); return(LLSD.FromString(String.Empty)); } if (reader.Read()) { ret = LLSD.FromString(reader.ReadString()); break; } ret = LLSD.FromString(String.Empty); break; case "binary": if (reader.IsEmptyElement) { reader.Read(); return(LLSD.FromBinary(new byte[0])); } if (reader.GetAttribute("encoding") != null && reader.GetAttribute("encoding") != "base64") { throw new LLSDException("Unsupported binary encoding: " + reader.GetAttribute("encoding")); } if (reader.Read()) { try { ret = LLSD.FromBinary(Convert.FromBase64String(reader.ReadString().Trim())); break; } catch (FormatException ex) { throw new LLSDException("Binary decoding exception: " + ex.Message); } } ret = LLSD.FromBinary(new byte[0]); break; case "uri": if (reader.IsEmptyElement) { reader.Read(); return(LLSD.FromUri(new Uri(String.Empty, UriKind.RelativeOrAbsolute))); } if (reader.Read()) { ret = LLSD.FromUri(new Uri(reader.ReadString(), UriKind.RelativeOrAbsolute)); break; } ret = LLSD.FromUri(new Uri(String.Empty, UriKind.RelativeOrAbsolute)); break; case "map": return(ParseXmlMap(reader)); case "array": return(ParseXmlArray(reader)); default: reader.Read(); ret = null; break; } if (reader.NodeType != XmlNodeType.EndElement || reader.LocalName != type) { throw new LLSDException("Expected </" + type + ">"); } else { reader.Read(); return(ret); } }
public override string Execute(string[] args, LLUUID fromAgentID) { LLUUID rootID; Primitive rootPrim; List <Primitive> childPrims; List <uint> localIDs = new List <uint>(); // Reset class-wide variables PermsSent = false; Objects.Clear(); Perms = PermissionMask.None; PermCount = 0; if (args.Length < 1 || args.Length > 4) { return("Usage prim-uuid [copy] [mod] [xfer]"); } if (!LLUUID.TryParse(args[0], out rootID)) { return("Usage prim-uuid [copy] [mod] [xfer]"); } for (int i = 1; i < args.Length; i++) { switch (args[i].ToLower()) { case "copy": Perms |= PermissionMask.Copy; break; case "mod": Perms |= PermissionMask.Modify; break; case "xfer": Perms |= PermissionMask.Transfer; break; default: return("Usage prim-uuid [copy] [mod] [xfer]"); } } Client.DebugLog("Using PermissionMask: " + Perms.ToString()); // Find the requested prim rootPrim = Client.Network.CurrentSim.Objects.Find(delegate(Primitive prim) { return(prim.ID == rootID); }); if (rootPrim == null) { return("Cannot find requested prim " + rootID.ToString()); } else { Client.DebugLog("Found requested prim " + rootPrim.ID.ToString()); } if (rootPrim.ParentID != 0) { // This is not actually a root prim, find the root if (!Client.Network.CurrentSim.Objects.TryGetPrimitive(rootPrim.ParentID, out rootPrim)) { return("Cannot find root prim for requested object"); } else { Client.DebugLog("Set root prim to " + rootPrim.ID.ToString()); } } // Find all of the child objects linked to this root childPrims = Client.Network.CurrentSim.Objects.FindAll(delegate(Primitive prim) { return(prim.ParentID == rootPrim.LocalID); }); // Build a dictionary of primitives for referencing later Objects[rootPrim.ID] = rootPrim; for (int i = 0; i < childPrims.Count; i++) { Objects[childPrims[i].ID] = childPrims[i]; } // Build a list of all the localIDs to set permissions for localIDs.Add(rootPrim.LocalID); for (int i = 0; i < childPrims.Count; i++) { localIDs.Add(childPrims[i].LocalID); } // Go through each of the three main permissions and enable or disable them #region Set Linkset Permissions PermCount = 0; if ((Perms & PermissionMask.Modify) == PermissionMask.Modify) { Client.Objects.SetPermissions(Client.Network.CurrentSim, localIDs, PermissionWho.NextOwner, PermissionMask.Modify, true); } else { Client.Objects.SetPermissions(Client.Network.CurrentSim, localIDs, PermissionWho.NextOwner, PermissionMask.Modify, false); } PermsSent = true; if (!GotPermissionsEvent.WaitOne(1000 * 30, false)) { return("Failed to set the modify bit, permissions in an unknown state"); } PermCount = 0; if ((Perms & PermissionMask.Copy) == PermissionMask.Copy) { Client.Objects.SetPermissions(Client.Network.CurrentSim, localIDs, PermissionWho.NextOwner, PermissionMask.Copy, true); } else { Client.Objects.SetPermissions(Client.Network.CurrentSim, localIDs, PermissionWho.NextOwner, PermissionMask.Copy, false); } PermsSent = true; if (!GotPermissionsEvent.WaitOne(1000 * 30, false)) { return("Failed to set the copy bit, permissions in an unknown state"); } PermCount = 0; if ((Perms & PermissionMask.Transfer) == PermissionMask.Transfer) { Client.Objects.SetPermissions(Client.Network.CurrentSim, localIDs, PermissionWho.NextOwner, PermissionMask.Transfer, true); } else { Client.Objects.SetPermissions(Client.Network.CurrentSim, localIDs, PermissionWho.NextOwner, PermissionMask.Transfer, false); } PermsSent = true; if (!GotPermissionsEvent.WaitOne(1000 * 30, false)) { return("Failed to set the transfer bit, permissions in an unknown state"); } #endregion Set Linkset Permissions // Check each prim for task inventory and set permissions on the task inventory int taskItems = 0; foreach (Primitive prim in Objects.Values) { if ((prim.Flags & LLObject.ObjectFlags.InventoryEmpty) == 0) { List <InventoryBase> items = Client.Inventory.GetTaskInventory(prim.ID, prim.LocalID, 1000 * 30); if (items != null) { for (int i = 0; i < items.Count; i++) { if (!(items[i] is InventoryFolder)) { InventoryItem item = (InventoryItem)items[i]; item.Permissions.NextOwnerMask = Perms; Client.Inventory.UpdateTaskInventory(prim.LocalID, item); ++taskItems; } } } } } return("Set permissions to " + Perms.ToString() + " on " + localIDs.Count + " objects and " + taskItems + " inventory items"); }
public override string Execute(string[] args, LLUUID fromAgentID) { if (args.Length < 1) { return(Description); } groupName = String.Empty; resolvedGroupID = LLUUID.Zero; resolvedGroupName = String.Empty; if (args[0].ToLower() == "uuid") { if (args.Length < 2) { return(Description); } if (!LLUUID.TryParse((resolvedGroupName = groupName = args[1]), out resolvedGroupID)) { return(resolvedGroupName + " doesn't seem a valid UUID"); } } else { for (int i = 0; i < args.Length; i++) { groupName += args[i] + " "; } groupName = groupName.Trim(); DirectoryManager.DirGroupsReplyCallback callback = new DirectoryManager.DirGroupsReplyCallback(Directory_OnDirGroupsReply); Client.Directory.OnDirGroupsReply += callback; queryID = Client.Directory.StartGroupSearch(DirectoryManager.DirFindFlags.Groups, groupName, 0); GetGroupsSearchEvent.WaitOne(60000, false); Client.Directory.OnDirGroupsReply -= callback; GetGroupsSearchEvent.Reset(); } if (resolvedGroupID == LLUUID.Zero) { if (string.IsNullOrEmpty(resolvedGroupName)) { return("Unable to obtain UUID for group " + groupName); } else { return(resolvedGroupName); } } GroupManager.GroupJoinedCallback gcallback = new GroupManager.GroupJoinedCallback(Groups_OnGroupJoined); Client.Groups.OnGroupJoined += gcallback; Client.Groups.RequestJoinGroup(resolvedGroupID); /* A.Biondi * TODO: implement the pay to join procedure. */ GetGroupsSearchEvent.WaitOne(60000, false); Client.Groups.OnGroupJoined -= gcallback; GetGroupsSearchEvent.Reset(); if (joinedGroup) { return("Joined the group " + resolvedGroupName); } return("Unable to join the group " + resolvedGroupName); }