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)));
}
