void ScanForLinksets(SimObject O) { if (O.Children == null) { return; } if (O.Children.Count == 0) { lock (fileWriterLock) File.WriteAllText(dumpDir + O.ID + ".link", ""); } var lst = new SortedList <uint, UUID>(); foreach (var o in LockInfo.CopyOf(O.Children)) { lst.Add(o.LocalID, o.ID); } string contents = "" + O.ID; foreach (KeyValuePair <uint, UUID> uuid in lst) { contents += "," + uuid.Value; } lock (fileWriterLock) File.WriteAllText(dumpDir + O.ID + ".link", contents); }
public override CmdResult ExecuteRequest(CmdRequest args) { StringBuilder output = new StringBuilder(); { foreach (Simulator sim in LockInfo.CopyOf(Client.Network.Simulators)) { output.AppendLine(String.Format( "[{0}] Dilation: {1} InBPS: {2} OutBPS: {3} ResentOut: {4} ResentIn: {5}", sim.ToString(), sim.Stats.Dilation, sim.Stats.IncomingBPS, sim.Stats.OutgoingBPS, sim.Stats.ResentPackets, sim.Stats.ReceivedResends)); output.Append("Packets in the queue: " + Client.Network.InboxCount); Simulator csim = sim; output.AppendLine( String.Format( "FPS : {0} PhysicsFPS : {1} AgentUpdates : {2} Objects : {3} Scripted Objects : {4}", csim.Stats.FPS, csim.Stats.PhysicsFPS, csim.Stats.AgentUpdates, csim.Stats.Objects, csim.Stats.ScriptedObjects)); output.AppendLine( String.Format( "Frame Time : {0} Net Time : {1} Image Time : {2} Physics Time : {3} Script Time : {4} Other Time : {5}", csim.Stats.FrameTime, csim.Stats.NetTime, csim.Stats.ImageTime, csim.Stats.PhysicsTime, csim.Stats.ScriptTime, csim.Stats.OtherTime)); output.AppendLine(String.Format("Agents : {0} Child Agents : {1} Active Scripts : {2}", csim.Stats.Agents, csim.Stats.ChildAgents, csim.Stats.ActiveScripts)); } } return(Success(output.ToString())); }
private bool Follow(string name) { foreach (Simulator sim in LockInfo.CopyOf(Client.Network.Simulators)) { Avatar target = sim.ObjectsAvatars.Find( delegate(Avatar avatar) { return(avatar.Name == name); } ); if (target != null) { targetLocalID = target.LocalID; Active = true; EnsureRunning(); return(true); } } if (Active) { Client.Self.AutoPilotCancel(); Active = false; } return(false); }
private void DiscoverMoreSysvars() { foreach (var ms in LockInfo.CopyOf(Plugins).Values) { ConfigSettingAttribute.AddSingletonClass(ms.GetType()); } }
internal Simulator GetSimulator(ulong handle) { if (handle == 0) { return(client.Network.CurrentSim); } // lock (AllSimulators) { foreach (Simulator sim in AllSimulators) { if (sim.Handle == handle && sim.Connected) { return(sim); } } } // lock (client.Network.Simulators) { foreach (Simulator sim in LockInfo.CopyOf(client.Network.Simulators)) { if (sim.Handle == handle && sim.Connected) { return(sim); } } } return(GetRegion(handle).TheSimulator); }
private void CreateOARFile(ImportSettings settings, string filename) { string rootDir = ExportCommand.dumpDir + "../oarfile/"; OarFile.PrepareDir(rootDir); // Objects foreach (PrimToCreate parent in parents) { var ls = new Linkset() { Parent = parent }; parent.Link = ls; LocalScene.Links.Add(ls); } foreach (PrimToCreate ch in childs) { var pp = ch.ParentPrim; if (pp == null) { continue; } pp.Link.ChildAdd(ch); } foreach (var ls in LockInfo.CopyOf(LocalScene.Links)) { ls.Children.Sort(compareLocalIDs); if (ls.Parent.IsAsset) { LocalScene.AssetLinks.Add(ls); LocalScene.Links.Remove(ls); } } foreach (var ls in LocalScene.Links) { OarFile.SaveLinkset(ls, rootDir + "objects/" + ls.Parent.NewID + ArchiveConstants.ASSET_TYPE_TO_EXTENSION[AssetType.Object], false, settings); } // Assets foreach (ItemToCreate asset in LocalScene.Assets) { File.WriteAllBytes(rootDir + "assets/" + asset.OldID + ArchiveConstants.ASSET_TYPE_TO_EXTENSION[asset.AssetType], asset.AssetData); } foreach (var ls in LocalScene.AssetLinks) { OarFile.SaveLinkset(ls, rootDir + "assets/" + ls.Parent.NewID + ArchiveConstants.ASSET_TYPE_TO_EXTENSION[AssetType.Object], true, settings); } // Terrain if (settings.ContainsKey("terrain")) { ExportCommand.Exporting.SaveTerrainRaw32(rootDir + "terrains/heightmap.raw"); } string parcelDirs = rootDir + "landdata/"; Directory.CreateDirectory(parcelDirs); OarFile.PackageArchive(rootDir, filename, settings.ContainsKey("terrain"), settings.ContainsKey("land")); }
public override CmdResult ExecuteRequest(CmdRequest args) { bool writeInfo = !args.IsFFI; int count = 0; if (args.ContainsFlag("--presence")) { foreach (var A in WorldObjects.SimAccounts) { count++; AppendItem("agents", A); if (writeInfo) { WriteLine(A + " local=" + A.IsLocal); } } } else { int[] count0 = { 0 }; foreach (Simulator sim in LockInfo.CopyOf(Client.Network.Simulators)) { if (sim.ObjectsAvatars.Count == 0) { continue; } if (writeInfo) { WriteLine(""); } if (writeInfo) { WriteLine("Region: " + sim); } Simulator simulator = sim; sim.ObjectsAvatars.ForEach( delegate(Avatar av) { count0[0]++; SimObject A = WorldSystem.GetSimObject(av, simulator); AppendItem("avatars", A); if (string.IsNullOrEmpty(av.Name)) { Client.Objects.SelectObjects(simulator, new uint[] { av.LocalID }, true); } if (writeInfo) { WriteLine(" {0} (Group: {1}, Location: {2}, UUID: {3})", av.Name, av.GroupName, av.Position, av.ID.ToString()); } } ); } count = count0[0]; } SetResult("count", count); return(SuccessOrFailure()); }
public override CmdResult ExecuteRequest(CmdRequest args) { int len = args.Length; int argsUsed; Simulator CurSim = TryGetSim(args, out argsUsed) ?? Client.Network.CurrentSim; Simulator sim = CurSim; Dictionary <uint, Primitive> primitives = sim.ObjectsPrimitives.Copy(); if (len == 0) { //prep List <uint> prep = new List <uint>(); lock (primitives) { prep.AddRange(primitives.Keys); } foreach (var u in prep) { Client.Objects.RequestObject(sim, u); Client.Objects.SelectObject(sim, u, true); } return(ShowUsage()); } if (len > 1) { string simName = string.Join(" ", args, 0, len - 1); foreach (Simulator list in LockInfo.CopyOf(Client.Network.Simulators)) { if (simName == list.Name) { sim = list; } } } WriteLine("about to lower sim: " + sim.Name + " with " + sim.ObjectsPrimitives.Count); List <Primitive> prims = new List <Primitive>(); lock (primitives) { prims.AddRange(primitives.Values); } Vector3 offset = new Vector3(0, 0, float.Parse(args[len - 1])); int moved = 0; foreach (Primitive prim in prims) { if (prim.ParentID == 0) { moved++; Vector3 primPosition = prim.Position; Client.Objects.SetPosition(sim, prim.LocalID, primPosition - offset); } } return(Success("moved " + moved + " on sim " + sim)); }
public override CmdResult ExecuteRequest(CmdRequest args) { { foreach (Simulator sim in LockInfo.CopyOf(Client.Network.Simulators)) { WorldSystem.CatchUp(sim); } } return(Success("Ran " + Name)); }
private void BeenTo(Vector3 at3d) { haveBeenTo.AddPoint(at3d); lock (moveToPoints) foreach (Vector3 point in LockInfo.CopyOf(moveToPoints)) { if (Vector3.Distance(point, at3d) < 8) { moveToPoints.Remove(point); } } }
public override CmdResult ExecuteRequest(CmdRequest args) { MakeGridRequest(); var regions = LockInfo.CopyOf(Regions); AddSuccess("Testing " + regions.Count); int passes = 0, failures = 0, tested = 0; var skipRegions = new[] { "sttc_0013" }; foreach (var r in regions.Values) { AddSuccess("Region: " + r.Name + ": (" + r.X + "," + r.Y + ") " + r.Access); Client.Grid.RequestMapRegion(r.Name, GridLayerType.Terrain); DownloadRegionImage(r); continue; bool skipRegion = false; string rn = r.Name; foreach (var named in skipRegions) { if (rn.Contains(named)) { skipRegion = true; break; } } if (skipRegion) { continue; } Simulator sim = Client.Network.CurrentSim; if (r.X == 0 || r.Y == 0 || (sim != null && sim.Name.ToLower() == r.Name.ToLower())) { AddSuccess("Skipping: " + r.Name + ": (" + r.X + "," + r.Y + ") " + r.Access); continue; } tested++; if (RegionTest(r)) { AddSuccess("PASS: "******": (" + r.X + "," + r.Y + ") " + r.Access); passes++; } else { AddSuccess("FAIL: " + r.Name + ": (" + r.X + "," + r.Y + ") " + r.Access); failures++; // break; } } return (Success("Found passes=" + passes + " falures=" + failures + " on " + tested + "/" + regions.Count + " total")); }
public void Think() { if (Active) { // Find the target position { foreach (Simulator sim in LockInfo.CopyOf(Client.Network.Simulators)) { Avatar targetAv; if (sim.ObjectsAvatars.TryGetValue(targetLocalID, out targetAv)) { float distance = 0.0f; if (sim == Client.Network.CurrentSim) { distance = Vector3.Distance(targetAv.Position, Client.Self.SimPosition); } else { // FIXME: Calculate global distances } if (distance > DISTANCE_BUFFER) { uint regionX, regionY; Utils.LongToUInts(sim.Handle, out regionX, out regionY); double xTarget = (double)targetAv.Position.X + (double)regionX; double yTarget = (double)targetAv.Position.Y + (double)regionY; double zTarget = targetAv.Position.Z - 2f; Logger.DebugLog( String.Format( "[Autopilot] {0} meters away from the target, starting autopilot to <{1},{2},{3}>", distance, xTarget, yTarget, zTarget), Client); Client.Self.AutoPilot(xTarget, yTarget, zTarget); } else { // We are in range of the target and moving, stop moving Client.Self.AutoPilotCancel(); } } } } } }
public List <InventoryBase> SourceTaskInventory(bool useCache) { // get { List <InventoryBase> regenObjInv = useCache ? this.sourceObjectinventory : null; bool improve = !useCache; if (regenObjInv == null) { if (IsLocalScene) { if (TaskItemsToCreate == null) { return(null); } bool improvementM = false; if (sourceObjectinventory != null) { //return objectinventory; } regenObjInv = new List <InventoryBase>(); lock (TaskItemsToCreate) { foreach (var toCreate in LockInfo.CopyOf(TaskItemsToCreate)) { bool improvement; var item = toCreate.ToInventoryBase(out improvement, improve); if (improvement) { improvementM = true; } regenObjInv.Add(item); } AssignObjectNums(); } if (improvementM) { Exporting.SaveTaskOSD(OldID, regenObjInv); } return(sourceObjectinventory = regenObjInv); } if (!RequestNewTaskInventory().WaitOne(TimeSpan.FromSeconds(10))) { Importing.WriteLine("Unable to retrieve TaskInv for " + ToString()); } } return(sourceObjectinventory = regenObjInv); } }
private static void Release(INode tripleInst, RdfRules ruleCache, Rule r) { if (tripleInst.NodeType != NodeType.Blank) { Warn("Removing non Bnode " + r); } //ConsoleWriteLine("Remove Rule: " + r); IGraph graph = ruleCache.ContainingGraph ?? tripleInst.Graph; IEnumerable <Triple> found = LockInfo.CopyOf(graph.GetTriples(tripleInst)); int fnd = 0; foreach (Triple triple in found) { // ConsoleWriteLine("Remove triple: " + triple); triple.Graph.Retract(triple); fnd++; } //ConsoleWriteLine("Removed triples: " + fnd); }
private static Assembly CurrentDomain_AssemblyResolveType1(AppDomain domain, string assemblyName) { if (domain != null) { foreach (var assembly in LockInfo.CopyOf(domain.GetAssemblies())) { if (AssemblyMatches(assembly, assemblyName)) { return(assembly); } } } foreach (Assembly assembly in LockInfo.CopyOf(AssembliesLoaded)) { if (AssemblyMatches(assembly, assemblyName)) { return(assembly); } } var objExecutingAssemblies = Assembly.GetExecutingAssembly(); if (objExecutingAssemblies != null) { AssemblyName[] arrReferencedAssmbNames = objExecutingAssemblies.GetReferencedAssemblies(); foreach (var assemblyN in arrReferencedAssmbNames) { if (AssemblyMatches(assemblyN, assemblyName)) { Assembly load = Assembly.Load(assemblyN); } } } int comma = assemblyName.IndexOf(","); if (comma > 0) { assemblyName = assemblyName.Substring(0, comma); } return(LoadAssemblyByFile(assemblyName)); }
private void GleanUUIDsFrom(UUID uuid) { if (CogbotHelpers.IsNullOrZero(uuid)) { return; } var clientInventoryStore = Client.Inventory.Store; if (clientInventoryStore == null) { return; } foreach (var item0 in clientInventoryStore.GetContents(uuid)) { UUID oldID; if (UUID.TryParse(item0.Name, out oldID)) { var item = item0 as InventoryItem; if (item == null) { continue; } ItemToCreate itc = FindItemToCreate(oldID, item.AssetType, true); if (itc.RezRequested) { } } } lock (UUID2OBJECT) lock (MissingFromExport) { foreach (MissingItemInfo ur in LockInfo.CopyOf(MissingFromExport)) { if (UUID2OBJECT.ContainsKey(ur.MissingID)) { Success("Not Missing anymore: " + ur); MissingFromExport.Remove(ur); } } } }
public override CmdResult ExecuteRequest(CmdRequest args) { int count = 0; { foreach (Simulator sim in LockInfo.CopyOf(Client.Network.Simulators)) { int avcount = sim.ObjectsAvatars.Count; int primcount = sim.ObjectsPrimitives.Count; WriteLine("{0} (Avatars: {1} Primitives: {2})", sim.Name, avcount, primcount); count += avcount; count += primcount; } } WriteLine("{0} (Avatars: {1} Primitives: {2})", "WorldSystem", WorldObjects.SimAvatars.Count, WorldObjects.SimObjects.Count); return(Success("Tracking a total of " + count + " objects")); }
public void runPreProverHooks() { IList <Action> hooksTodo = null; lock (OnPreUseHooks) { if (OnPreUseHooks.Count == 0) { return; } hooksTodo = LockInfo.CopyOf(OnPreUseHooks); OnPreUseHooks.Clear(); } int completed = 0; foreach (Action list in hooksTodo) { try { list(); completed++; } catch (Exception e) { lock (OnPreUseHooks) { for (int i = completed + 1; completed < hooksTodo.Count; i++) { OnPreUseHooks.Add(hooksTodo[i]); } } throw ErrorBadOp("Prologs OnPreUseHooks ERROR: " + list + " " + e); } } // once more incase more hooks got added runPreProverHooks(); }
private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args) { var domain = (AppDomain)sender; foreach (var assembly in LockInfo.CopyOf(domain.GetAssemblies())) { if (assembly.FullName == args.Name) { return(assembly); } if (assembly.ManifestModule.Name == args.Name) { return(assembly); } } foreach (Assembly assembly in LockInfo.CopyOf(AssembliesLoaded)) { if (assembly.FullName == args.Name) { return(assembly); } if (assembly.ManifestModule.Name == args.Name) { return(assembly); } } string assemblyName = args.Name; int comma = assemblyName.IndexOf(","); if (comma > 0) { assemblyName = assemblyName.Substring(0, comma); } return(LoadAssemblyByFile(assemblyName)); }
private void SaveParcelInfo(ImportSettings settings) { var CurSim = settings.CurSim; Client.Parcels.RequestAllSimParcels(CurSim); if (CurSim.IsParcelMapFull()) { ParcelsDownloaded.Set(); } if (ParcelsDownloaded.WaitOne(30000, false) && Client.Network.Connected) { Success(string.Format("Downloaded {0} Parcels in {1} " + Environment.NewLine, CurSim.Parcels.Count, CurSim.Name)); IDictionary <int, Parcel> curSimParcels = null; lock (CurSim.Parcels.Dictionary) { curSimParcels = LockInfo.CopyOf(CurSim.Parcels.Dictionary); } List <UUID> ParcelPrimOwners = new List <UUID>(); List <uint> ParcelObjectIDS = new List <uint>(); foreach (KeyValuePair <int, Parcel> simParcel in curSimParcels) { var parcel = simParcel.Value; int parcelID = parcel.LocalID; Success(string.Format( "Parcel[{0}]: Name: \"{1}\", Description: \"{2}\" ACLBlacklist Count: {3}, ACLWhiteList Count: {5} Traffic: {4}" + Environment.NewLine, parcel.LocalID, parcel.Name, parcel.Desc, parcel.AccessBlackList.Count, parcel.Dwell, parcel.AccessWhiteList.Count)); AddExportUser(parcel.OwnerID); AddExportGroup(parcel.GroupID); Success(Helpers.StructToString(parcel)); foreach ( ParcelManager.ParcelAccessEntry white in parcel.AccessWhiteList) { if (white.AgentID != UUID.Zero) { Success(string.Format( "\tAllowed Avatar {0}" + Environment.NewLine, white.AgentID)); } } foreach ( ParcelManager.ParcelAccessEntry black in parcel.AccessBlackList) { // if(black.AgentID != UUID.Zero) Success(string.Format("\t Banned Avatar {0}" + Environment.NewLine, black.AgentID)); } { AutoResetEvent parcelOwnerWait = new AutoResetEvent(false); EventHandler <ParcelObjectOwnersReplyEventArgs> callback = delegate(object sender, ParcelObjectOwnersReplyEventArgs e) { for (int i = 0; i < e.PrimOwners.Count; i++) { ParcelManager.ParcelPrimOwners ownerse = e.PrimOwners[i]; if (ownerse.IsGroupOwned) { AddExportGroup(ownerse.OwnerID); } else { AddExportUser(ownerse.OwnerID); } Success(string.Format("Owner: {0} Count: {1}" + Environment.NewLine, ownerse.OwnerID, ownerse.Count)); if (!CogbotHelpers.IsNullOrZero(ownerse.OwnerID)) { ParcelPrimOwners.Add(ownerse.OwnerID); } } parcelOwnerWait.Set(); }; Client.Parcels.ParcelObjectOwnersReply += callback; try { Client.Parcels.RequestObjectOwners(CurSim, parcelID); if (!parcelOwnerWait.WaitOne(10000, false)) { Failure("Timed out waiting for packet."); } } finally { Client.Parcels.ParcelObjectOwnersReply -= callback; } } foreach (UUID ownerUUID in ParcelPrimOwners) { AutoResetEvent wait = new AutoResetEvent(false); EventHandler <ForceSelectObjectsReplyEventArgs> callback = delegate(object sender, ForceSelectObjectsReplyEventArgs e) { ParcelObjectIDS.AddRange(e.ObjectIDs); for (int i = 0; i < e.ObjectIDs.Count; i++) { // Success(string.Format(e.ObjectIDs[i].ToString() + " ")); // counter++; } if (e.ObjectIDs.Count < 251) { wait.Set(); } }; Client.Parcels.ForceSelectObjectsReply += callback; Client.Parcels.RequestSelectObjects(parcelID, (ObjectReturnType)16, ownerUUID); wait.WaitOne(10000); } } foreach (uint u in ParcelObjectIDS) { RequiredForExportLocalIDs.Add(u); } Success("Parcel LocalIDs=" + ParcelObjectIDS.Count + " ParcelOwners=" + ParcelPrimOwners.Count); } else { Failure("Failed to retrieve information on all the simulator parcels"); } string parcelDirs = settings.OarDir + "landdata/"; Directory.CreateDirectory(parcelDirs); SimRegion r = SimRegion.GetRegion(CurSim); foreach (var p in r.ParcelMap) { Parcel parcel = p.Value; if (CogbotHelpers.IsNullOrZero(parcel.GlobalID)) { parcel.GlobalID = UUID.Random(); } File.WriteAllText(parcelDirs + "" + parcel.GlobalID + ".xml", OarFile.Serialize(parcel)); } }
private void CheckTasks(ImportSettings settings) { foreach (PrimToCreate parent in LockInfo.CopyOf(parents)) { var ls = new Linkset() { Parent = parent }; parent.Link = ls; LocalScene.Links.Add(ls); } foreach (PrimToCreate ch in childs) { var pp = ch.ParentPrim; if (pp == null) { continue; } pp.Link.ChildAdd(ch); } foreach (var ls in LockInfo.CopyOf(LocalScene.Links)) { ls.Children.Sort(compareLocalIDs); if (ls.Parent.IsAsset) { LocalScene.AssetLinks.Add(ls); LocalScene.Links.Remove(ls); } } int found = 0; Dictionary <UUID, TaskFileInfo> item2TO = new Dictionary <UUID, TaskFileInfo>(); List <TaskFileInfo> mssingTO = new List <TaskFileInfo>(); List <TaskFileInfo> duped = new List <TaskFileInfo>(); foreach (var file in Directory.GetFiles(ExportCommand.dumpDir, "*.objectAsset")) { break; found++; string fileString = File.ReadAllText(file); string[] c = fileString.Split(','); try { TaskFileInfo to = new TaskFileInfo() { OldLid = uint.Parse(c[0]), RezzedID = UUID.Parse(c[2]), OldTaskHolder = UUID.Parse(c[3]), AssetUUID = UUID.Parse(c[4]), TaskItemID = UUID.Parse(c[5]) }; bool missing = false; if (MissingLLSD(to.RezzedID)) { Failure("Need LLSD: " + fileString); to.missingLLSD = true; mssingTO.Add(to); } TaskFileInfo old; if (item2TO.TryGetValue(to.TaskItemID, out old)) { if (old.missingLLSD) { item2TO[to.TaskItemID] = to; duped.Add(old); } else { duped.Add(to); } } else { if (to.missingLLSD) { continue; } item2TO[to.TaskItemID] = to; } } catch (Exception ee) { Failure("fileIssue: " + file + " = " + fileString); } } Success("t=" + found + " m=" + mssingTO.Count + " td=" + item2TO.Count + " duped=" + duped.Count); }
private static Assembly LoadAssemblyByFile(string assemblyName) { if (File.Exists(assemblyName)) { try { var fi = new FileInfo(assemblyName); if (fi.Exists) { return(Assembly.LoadFile(fi.FullName)); } } catch (Exception) { throw; } } IList <string> sp = LockInfo.CopyOf((IEnumerable <string>)null); foreach ( var dir in new[] { AppDomain.CurrentDomain.BaseDirectory, new DirectoryInfo(".").FullName, Path.GetDirectoryName(typeof(BotClient).Assembly.CodeBase), Environment.CurrentDirectory }) { if (!sp.Contains(dir)) { sp.Add(dir); } } string lastTested = ""; foreach (Assembly s in LockInfo.CopyOf(AppDomain.CurrentDomain.GetAssemblies())) { var ss = "" + s; try { if (s is _AssemblyBuilder) { continue; } var ro = s.ReflectionOnly; if (ro) { continue; } lock (SkippedAssemblies) if (SkippedAssemblies.Contains(ss)) { continue; } var loc = s.Location; string dir = Path.GetDirectoryName(loc ?? s.CodeBase); dir = NormalizePath(dir); if (dir == lastTested) { continue; } lastTested = dir; if (!sp.Contains(dir)) { sp.Add(dir); } } catch (NotSupportedException) { lock (SkippedAssemblies) SkippedAssemblies.Add(ss); // Reflected Assemblies do this } } foreach (string pathname in sp) { var assemj = FindAssemblyByPath(assemblyName, pathname); if (assemj != null) { return(assemj); } } return(null); }
public CmdResult Execute(string[] args, UUID fromAgentID, OutputDelegate WriteLine) { Client.Self.Movement.Camera.Far = 1023; Client.Self.Movement.SendUpdate(true); Exporting = this; IsExporting = true; var CurSim = Client.Network.CurrentSim; RegionHandle = CurSim.Handle; haveBeenTo.AddPoint(TheSimAvatar.SimPosition); AttemptSitMover(); WorldObjects.MaintainSimObjectInfoMap = false; SimObjectImpl.AffordinancesGuessSimObjectTypes = false; WorldSystem.IgnoreKillObjects = true; inventoryHolder.Clear(); lslScripts.Clear(); successfullyExportedPrims.Clear(); const string hlp = @" Toplevel Directives // todo = shows what must be done for export to be complete (suggest adding verbose) // perms = shows what perms are going to be a problem (suggest adding verbose) // clear - clear the export dir // reset - reset the exporter state // cache - blow away asset cache // move - begin moving arround // nomove - stop moving arround // spec [spec] - do only prims meeting spec (default is 'spec $region') // incr - do only do what is 'todo' // nonincr - do things 'todo' but also 'redo' things already done // noperms = dont skip things when perms might be a problem // quietly = terser output // verbose = more verbose // request = will rerequest missing things like textures // force = will allow unequal LLSD files - this should only be used as last resort // users - users files // groups - groups files // terrain - terrain files // parcels - parcels files // estate - estate files (TODO) // siminfo - estate files (TODO) // llsd - llsd files // links - operate on linset // deps - operate on dependant assets // dl - operate on dependant downloads // tasks - save task files // taskobj - task objects // all = llsd tasks deps links (dl and taskobj not included) "; if (args == null || args.Length == 0) { return(Failure(hlp)); } string[] nargs = { "$region" }; ImportSettings arglist = new ImportSettings { CurSim = Client.Network.CurrentSim, GroupID = Client.Self.ActiveGroup }; settings = arglist; if (args[0] == "hhp") { args = new string[] { "taskobjs", "nobuf", "all", "spec", "f0a89a9f-3f33-b2aa-2829-eaeec3d08b82" }; } foreach (string s in args) { arglist.Add(s); } if (arglist.Contains("error")) { return(WriteErrors(args)); } if (arglist.Contains("help")) { return(Success(hlp)); } if (args.Length > 1) { int specIndex = Array.IndexOf(args, "spec"); if (specIndex > 0) { nargs = Parser.SplitOff(args, specIndex + 1); } int fnd = Array.IndexOf(args, "move"); if (fnd > -1 && (fnd + 1 < args.Length)) { int mv; if (int.TryParse(args[fnd + 1], out mv)) { moveSleep = mv; if ((fnd + 2 < args.Length) && int.TryParse(args[fnd + 2], out mv)) { maxHeigth = mv; } } } } if (arglist.Contains("move")) { if (arglist.Contains("wps")) { AddRegionWaypoints(); } BeginMoving(); GiveStatus(); return(Success("Began moving")); } if (arglist.Contains("nomove")) { StopMoving(); GiveStatus(); return(Success("Stopped moving")); } quietly = arglist.Contains("quietly"); if (arglist.Contains("prim")) { arglist.Add("llsd"); arglist.Add("dep"); arglist.Add("link"); } if (arglist.Contains("all")) { arglist.Add("llsd"); arglist.Add("task"); arglist.Add("dep"); arglist.Add("link"); } needFiles = 0; taskobj = arglist.Contains("taskobj"); forced = arglist.Contains("force") || arglist.Contains("forced"); if (arglist.Contains("nonincr")) { Incremental = false; } if (arglist.Contains("incr")) { Incremental = true; } bool fileOnly = false; lock (fileWriterLock) { if (arglist.Contains("clear")) { KillAllUnpacked(WriteLine, true); PurgeExport(); arglist.Add("reset"); } if (!Directory.Exists(dumpDir)) { Directory.CreateDirectory(dumpDir); } if (!Directory.Exists(assetDumpDir)) { Directory.CreateDirectory(assetDumpDir); } if (!Directory.Exists(terrainDir)) { Directory.CreateDirectory(terrainDir); } if (!Directory.Exists(siminfoDir)) { Directory.CreateDirectory(siminfoDir); } if (arglist.Contains("cache")) { fileOnly = true; PurgeCache(); } } if (arglist.Contains("reset")) { slowlyExport.Clear(); lock (ToDownloadAssets) ToDownloadAssets.Clear(); lock (CompletedAssets) CompletedAssets.Clear(); lock (PrimWaitingLinkset) PrimWaitingLinkset.Clear(); lock (AllRelatedAssets) AllRelatedAssets.Clear(); lock (PrimDepsAssets) PrimDepsAssets.Clear(); lock (TaskAssetWaiting) TaskAssetWaiting.Clear(); lock (CompletedTaskItem) CompletedTaskItem.Clear(); #if OBJECTUNPACKER lock (TasksRezed) TasksRezed.Clear(); #endif GiveStatus(); return(Success("Reset SimExport State")); } if (fileOnly) { GiveStatus(); return(Success("Manipulated filesystem")); } if (arglist.Contains("cleanup")) { return(CleanupAfterExport(fromAgentID, WriteLine)); } if (arglist.Contains("killtasks")) { KillAllUnpacked(WriteLine, true); return(SuccessOrFailure()); } IsExporting = true; FolderCalled("TaskInvHolder"); //string file = args[args.Length - 1]; int used; List <SimObject> PS = WorldSystem.GetPrimitives(nargs, out used); if (IsEmpty(PS)) { return(Failure("Cannot find objects from " + string.Join(" ", args))); } showsStatus = arglist.Contains("statu"); showPermsOnly = arglist.Contains("perm"); skipPerms = !arglist.Contains("obeyperm"); showsMissingOnly = arglist.Contains("todo"); if (showsMissingOnly) { quietly = true; } verbosely = arglist.Contains("verbose"); if (verbosely && !arglist.Contains("quietly")) { quietly = false; } int missing = 0; var canExport = new List <SimObject>(); int objects = 0; if (arglist.Contains("terrain")) { SaveTerrainHeight(arglist); StartTerrainDownload(arglist); } if (arglist.Contains("parcel")) { SaveParcelInfoCommand(arglist); } bool primsAtAll = arglist.Contains("link") || arglist.Contains("task") || arglist.Contains("llsd") || arglist.Contains("taskobj") || arglist.Contains("all"); bool wasShouldBeMoving = shouldBeMoving; if (primsAtAll) { shouldBeMoving = false; } if (arglist.Contains("nobuf")) { PSBuf.Clear(); } PSBuf.AddRange(PS); lock (Importing.MustExport) { foreach (UUID id in LockInfo.CopyOf(Importing.MustExport)) { var o = WorldObjects.GetSimObjectFromUUID(id); if (o != null) { PSBuf.Add(o); } } } foreach (var P in PSBuf) { if (!primsAtAll) { break; } if (string.IsNullOrEmpty(IsComplete(P.ID, false, false, arglist))) { continue; } // skip attachments and avatars if (IsSkipped(P, arglist)) { continue; } if (!P.HasPrim) { if (!quietly) { Failure("Missing Prim: " + named(P)); } continue; } if (P.RegionHandle != RegionHandle) { continue; } Vector3 sp; if (!P.TryGetSimPosition(out sp)) { continue; } objects++; string issues = P.MissingData; if (!string.IsNullOrEmpty(issues) && !arglist.Allows(issues, P)) { missing++; if (!quietly) { Failure("Issues " + issues + " " + named(P)); } continue; } bool exportPossible = checkPerms(Client, P, showPermsOnly ? (OutputDelegate)LocalFailure : SilientFailure, false) || skipPerms; if (exportPossible) { SnagUsers(P); canExport.Add(P); } } Success("Can export " + canExport.Count + " of " + objects); if (showPermsOnly) { return(Success("Shown perms")); } foreach (var P in canExport) { if (!primsAtAll) { break; } if (P is SimAvatar) { continue; } // skip attachments if (P.Parent is SimAvatar) { continue; } string issues = P.MissingData; if (!string.IsNullOrEmpty(issues) && !arglist.Allows(issues, P)) { continue; } //if (exportedPrims.Contains(P)) continue; LocalFailures = 0; PrimDepsAssets.Clear(); ExportPrim(Client, P, LocalFailure, arglist); if (P.IsRoot) { float pSimPositionZ = P.SimPosition.Z; if (pSimPositionZ > maxHeigth) { maxHeigth = pSimPositionZ + 10; } seenObjectsAt.AddPoint(P.SimPosition); } if (LocalFailures == 0) { if (!successfullyExportedPrims.Contains(P)) { successfullyExportedPrims.Add(P); } } } ExportRelatedAssets(); if (showsStatus) { arglist.Add("link"); arglist.Add("task"); arglist.Add("llsd"); } if (arglist.Contains("link")) { // lock (PrimWaitingLinkset) { foreach (var pa in LockInfo.CopyOf(PrimWaitingLinkset)) { var exportPrim = pa.Value.O; if (verbosely) { Failure("Awaiting Linkset " + named(exportPrim)); } if (arglist.Contains("request")) { RequestLinksetInfo(Client, Path.Combine(dumpDir, exportPrim.ID.ToString()), exportPrim, WriteLine, arglist); } } } } if (arglist.Contains("task")) { lock (TaskAssetWaiting) { foreach (var pa in LockInfo.CopyOf(TaskAssetWaiting)) { UUID assetID = pa.Value.SourceItem.AssetUUID; if (!CogbotHelpers.IsNullOrZero(assetID)) { if (CompletedAssets.Contains(assetID)) { int count = TaskAssetWaiting.Count; TaskAssetWaiting.Remove(pa.Key); if (TaskAssetWaiting.Count != count - 1) { Failure("VERY BAD!"); } } } if (verbosely) { Failure("Awaiting TaskAsset " + pa.Value); } if (arglist.Contains("request")) { pa.Value.Request(); } } } } ExportRelatedAssets(); foreach (var assetID in LockInfo.CopyOf(ToDownloadAssets)) { PingAssetCache(assetID); } if (arglist.Contains("dl")) { foreach (var assetID in LockInfo.CopyOf(ToDownloadAssets)) { AssetType assetType = assetTypeOf(assetID); if (verbosely) { Failure("Awaiting DL " + assetID + " " + assetType); } if (arglist.Contains("request")) { StartAssetDownload(null, assetID, assetType); } } } if (arglist.Contains("user")) { RequestUsersAndGroups(); } if (arglist.Contains("siprim")) { foreach (SimObject o in LockInfo.CopyOf(SIPrims)) { if (o.Prim.ParentID == 0) { Client.Inventory.RequestDeRezToInventory(o.LocalID, DeRezDestination.AgentInventoryCopy, FolderCalled("UseSIForCompleteness"), UUID.Random()); } else { Failure("Child SIPrim " + o); } } } Success("Missing PrimData: " + missing); Success("Started XFERS " + ToDownloadCalledAssets.Count + " assets"); shouldBeMoving = wasShouldBeMoving; GiveStatus(); if (primsAtAll) { shouldBeMoving = wasShouldBeMoving; } return(Success("Done")); }
public static object ReplaceAllMembers(object from, Type ofType, MemberInfo name, ObjectMemberReplacer replacerFunc, HashSet <object> exceptFor, HashSet <MissingItemInfo> missing) { if (from == null) { return(from); } var fromType = from.GetType(); if (fromType == ofType) { var oo = replacerFunc(name, from, missing); return(oo); } Type fromType0 = fromType; while (fromType0.IsArray) { fromType0 = fromType0.GetElementType(); } if (fromType0 == typeof(string) || fromType0 == typeof(byte[]) || typeof(IConvertible).IsAssignableFrom(fromType0)) { return(from); } if (from is IDictionary) { var ic = from as IDictionary; foreach (var k0 in LockInfo.CopyOf <object>(ic.Keys)) { var k = k0; var ko = ReplaceAllMembers(k, ofType, k == null ? null : k.GetType(), replacerFunc, exceptFor, missing); object o = ic[k]; var oo = ReplaceAllMembers(o, ofType, o == null ? null : o.GetType(), replacerFunc, exceptFor, missing); bool keyChanged = false; if (!ReferenceEquals(k, ko)) { keyChanged = true; ic.Remove(k); k = ko; } if (ReferenceEquals(oo, o) && !keyChanged) { continue; } ic[k] = oo; } return(from); } if (from is IList) { var ic = from as IList; lock (ic) for (int i = 0; i < ic.Count; i++) { object o = ic[i]; var oo = ReplaceAllMembers(o, ofType, name, replacerFunc, exceptFor, missing); if (ReferenceEquals(oo, o)) { continue; } ic[i] = oo; } return(from); } if (exceptFor.Contains(from)) { return(from); } exceptFor.Add(from); const BindingFlags bf = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public; foreach (var info in fromType.GetFields(bf)) { object o = info.GetValue(from); var oo = ReplaceAllMembers(o, ofType, info, replacerFunc, exceptFor, missing); if (ReferenceEquals(oo, o)) { continue; } info.SetValue(from, oo); } foreach (var info in fromType.GetProperties(bf)) { object o = info.GetValue(from, null); var oo = ReplaceAllMembers(o, ofType, info, replacerFunc, exceptFor, missing); if (ReferenceEquals(oo, o)) { continue; } info.SetValue(from, oo, null); } return(from); }
private static IEnumerable <ICollectionProvider> GetCollectionProviders(ICollectionRequester requester) { requester.SessionMananger = new RequesterSession(requester); return(LockInfo.CopyOf(FOCCollectionProviders(requester))); }
private static Assembly LoadAssemblyByFile(string assemblyName) { if (File.Exists(assemblyName)) { try { var fi = new FileInfo(assemblyName); if (fi.Exists) { return(Assembly.LoadFile(fi.FullName)); } } catch (Exception) { throw; } } IList <string> sp = LockInfo.CopyOf((IEnumerable <string>)AssemblySearchPaths); foreach ( var dir in new[] { AppDomain.CurrentDomain.BaseDirectory, new DirectoryInfo(".").FullName, Path.GetDirectoryName(typeof(ScriptInterpreter).Assembly.CodeBase), Environment.CurrentDirectory }) { if (!sp.Contains(dir)) { sp.Add(dir); } } string lastTested = ""; foreach (var s in LockInfo.CopyOf(AppDomain.CurrentDomain.GetAssemblies())) { try { if (s is AssemblyBuilder) { continue; } string dir = Path.GetDirectoryName(s.CodeBase); if (dir.StartsWith("file:\\")) { dir = dir.Substring(6); } if (dir == lastTested) { continue; } lastTested = dir; if (!sp.Contains(dir)) { sp.Add(dir); } } catch (NotSupportedException) { // Reflected Assemblies do this } } foreach (string pathname in sp) { var assemj = FindAssemblyByPath(assemblyName, pathname); if (assemj != null) { return(assemj); } } return(null); }
public void ImportTaskObjects(ImportSettings importSettings) { DateTime lastProgressNotice = DateTime.Now; int incomplete = 0; var agentSyncFolderHolder = Exporting.FolderCalled("TaskInvHolder"); int created = 0; var tos = LocalScene.TaskObjects; foreach (var file in Directory.GetFiles(ExportCommand.dumpDir, "*.taskobj")) { string[] c = File.ReadAllText(file).Split(','); TaskFileInfo to = new TaskFileInfo() { OldLid = uint.Parse(c[0]), RezzedID = UUID.Parse(c[2]), OldTaskHolder = UUID.Parse(c[3]), AssetUUID = UUID.Parse(c[4]), TaskItemID = UUID.Parse(c[5]) }; tos.Add(to); created++; } foreach (TaskFileInfo o in tos) { var r = o.Rezzed; if (r != null) { r.SetIsAsset(); } } foreach (TaskFileInfo o in tos) { PrimToCreate oInsideOf = o.InsideOf; if (oInsideOf == null) { continue; } List <InventoryBase> taskInv = oInsideOf.SourceTaskInventory(true); if (taskInv == null) { continue; } foreach (var b in taskInv) { InventoryItem i = b as InventoryItem; if (i == null) { continue; } if (CogbotHelpers.IsNullOrZero(i.AssetUUID)) { if (i.UUID == o.TaskItemID) { i.RezzID = o.RezzedID; o.IsPlaced = true; break; } } } } foreach (TaskFileInfo o in tos) { if (!o.IsPlaced) { Failure("UNPLACED: " + o); } } // this makes sure we know that late found childs are assets foreach (PrimToCreate parent in LockInfo.CopyOf(parents)) { if (parent.IsAsset) { parent.SetIsAsset(); } } }
public void performAction(TextWriter writer, string action, string query, string behaviorName, BCTX bctx) { var multiBehaviorName = GatherTaskNames(behaviorName); if (multiBehaviorName != null) { if (multiBehaviorName.Count == 0) { writer.WriteLine("Zero tasks or behaviors from :" + behaviorName); return; } foreach (string behavorT in multiBehaviorName) { performAction(writer, action, query, behavorT, bctx); } return; } if (action != null && action.Contains(",")) { foreach (var a in action.Split(' ', ',')) { if (string.IsNullOrEmpty(a)) { continue; } performAction(writer, a, query, behaviorName, bctx); } } string ids = ""; string tsk = ""; TaskList.TaskEnumerator en = null; switch (action) { case "info": ids = idStatus(behaviorName); tsk = taskStatus(behaviorName); writer.WriteLine("<status id=\"{0}\" idStatus=\"{1}\" taskStatus=\"{2}\" />", behaviorName, ids, tsk); bool v01 = myBehaviors.visibleBehavior(behaviorName); bool v03 = myBehaviors.definedBehavior(behaviorName); string eh = myBehaviors.getEventHandler(behaviorName); if (!string.IsNullOrEmpty(eh) && !KeyCase.DefaultFN.SameKey(eh, behaviorName)) { writer.WriteLine("<eventHandler name=\"{0}\" value=\"{1}\">", behaviorName, eh); performAction(writer, action, query, eh, bctx); writer.WriteLine("</eventHandler>"); } if (v03) { var treeByTreeName = myBehaviors.GetTreeByName(behaviorName); writer.WriteLine(treeByTreeName.treeDoc.OuterXml); } writer.WriteLine("<visible name=\"{0}\" value=\"{1}\"/>", behaviorName, v01); writer.WriteLine("<defined name=\"{0}\" value=\"{1}\"/>", behaviorName, v03); break; case "source": string behaviorFile = myBehaviors.behaviorDiskName(behaviorName); string fileReadAllText = ""; lock (BehaviorTree.FileLock) { if (File.Exists(behaviorFile)) { fileReadAllText = File.ReadAllText(behaviorFile); } } writer.WriteLine("{0}", fileReadAllText); break; case "activate": ActivateBehaviorTask(behaviorName, bctx); WriteNewStatus(writer, behaviorName); break; case "deactivate": RemoveBehaviorTask(behaviorName); WriteNewStatus(writer, behaviorName); break; case "sleep": SleepBehaviorTask(behaviorName); WriteNewStatus(writer, behaviorName); break; case "sleepall": SleepAllTasks(); WriteNewStatus(writer, behaviorName); break; case "reviveall": ReviveAllTasks(); WriteNewStatus(writer, behaviorName); break; case "status": WriteNewStatus(writer, behaviorName); break; case "liststatus": en = sleeping.GetEnumerator(); while (en.MoveNext()) { writer.WriteLine("<status id=\"{0}\" taskStatus=\"{1}\" />", en.Current.name, "sleeping"); } en = active.GetEnumerator(); while (en.MoveNext()) { writer.WriteLine("<status id=\"{0}\" taskStatus=\"{1}\" />", en.Current.name, "active"); } break; case "listidstatus": var runState = LockInfo.CopyOf(myBehaviors.runState); foreach (string key in runState.Keys) { string status = runState[key].ToString(); writer.WriteLine("<status id=\"{0}\" idStatus=\"{1}\" />", key, status); } break; case "stopall": en = sleeping.GetEnumerator(); while (en.MoveNext()) { writer.WriteLine("<status id=\"{0}\" taskStatus=\"{1}\" />", en.Current.name, "terminating"); en.RemoveCurrent(); } en = active.GetEnumerator(); while (en.MoveNext()) { writer.WriteLine("<status id=\"{0}\" taskStatus=\"{1}\" />", en.Current.name, "terminating"); en.RemoveCurrent(); } break; case "block": myBehaviors.makeInvisible(query); myBehaviors.makeInvisible(behaviorName); RemoveBehaviorTask(behaviorName); WriteNewStatus(writer, behaviorName); break; case "unblock": myBehaviors.makeVisible(query); WriteNewStatus(writer, behaviorName); break; case "unblockall": myBehaviors.invisiblePatterns.Clear(); WriteNewStatus(writer, behaviorName); break; case "listblocks": foreach (string p in myBehaviors.invisiblePatterns.Keys) { writer.WriteLine("<blockBehaviorPattern pattern=\"{0}\" />", p); } break; case "checkblock": bool v1 = myBehaviors.visibleBehavior(behaviorName); bool v2 = myBehaviors.visibleBehavior(query); bool v3 = myBehaviors.definedBehavior(behaviorName); bool v4 = myBehaviors.definedBehavior(query); writer.WriteLine("<visible name=\"{0}\" value=\"{1}\"/>", behaviorName, v1); writer.WriteLine("<visible name=\"{0}\" value=\"{1}\"/>", query, v2); writer.WriteLine("<defined name=\"{0}\" value=\"{1}\"/>", behaviorName, v3); writer.WriteLine("<defined name=\"{0}\" value=\"{1}\"/>", query, v4); break; case "blockcron": bctx.blockCron = true; break; case "unblockcron": bctx.blockCron = false; break; default: writer.WriteLine("<error action=\"{0}\" query=\"{1}\" behaviorName=\"{2}\" />", action, query, behaviorName); break; } writer.WriteLine("<fin/>"); writer.Close(); }
public static object ChangeType(object value, Type type) { if (type.IsInstanceOfType(value)) { return(value); } if (type.IsEnum) { if (value is String) { string vs = (String)value; try { var e = Enum.Parse(type, vs, false); if (e != null) { return(e); } e = Enum.Parse(type, vs, true); if (e != null) { return(e); } } catch (ArgumentException) { } } } foreach (TypeChanger tc in LockInfo.CopyOf(TypeChangers)) { bool didit; object o = tc(value, type, out didit); if (didit) { return(o); } } if (value is IConvertible) { if (typeof(IConvertible).IsAssignableFrom(type)) { try { return(Convert.ChangeType(value, type)); } catch { } } } if (value == null) { return(null); } if (type == typeof(string)) { if (value is string[]) { return(Parser.Rejoin((string[])value, 0)); } } return(null);// Convert.ChangeType(value, type); }
private IList <IKeyValuePair <string, object> > GetSysVars() { return(LockInfo.CopyOf(ScriptManager.GetSysVars(TheBotClient))); }