public void KillInWorldAndDisk(UUID oldobjid)
{
if (CogbotHelpers.IsNullOrZero(oldobjid))
{
return;
}
Importing.KillID(oldobjid);
KillInWorld(oldobjid);
}
public void Start()
{
dir = Application.dataPath + @"\" + fileName + ".txt";
if (File.Exists(dir))
{
pointManager.GetComponent <PointManager>().boot(Importing.readFile(dir)[0]);
gameObject.SetActive(false);
}
}
private void InvItemCreated(bool success1, string status, UUID itemid, UUID assetid)
{
if (!success1)
{
Importing.Failure("!SUCCESS " + status + " ON " + this);
return;
}
NewID = assetid;
this.NewItemID = itemid;
this.NewTaskID = UUID.Zero;
NewUUID2OBJECT[NewID] = this;
ConfirmDLable();
}
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);
}
}
public static void ReplaceLSLText(string dir, string before, string after, ImportSettings arglist)
{
int changed = 0;
int seenAsset = 0;
HashSet <ItemToCreate> ItemsToCreate = LocalScene.Assets;
bool alwayReupload = arglist.Contains("reup");
foreach (var file in Directory.GetFiles(dir, "*.lsl"))
{
seenAsset++;
string readfile = File.ReadAllText(file);
if (!readfile.Contains(before))
{
continue;
}
readfile = readfile.Replace(before, after);
changed++;
File.WriteAllText(file, readfile);
}
Importing.Success("ReplaceLSLText seenAssets=" + seenAsset + " changed=" + changed);
}
public void OnDownloaded(AssetDownload transfer, Asset asset)
{
if (transfer.AssetID != NewID)
{
return;
}
if (assetType == AssetType.Texture && !asset.Decode())
{
Difference(asset.AssetData, AssetData);
asset.AssetData = AssetData;
if (false)
{
Inventory.RemoveItem(NewItemID);
NewItemID = UUID.Zero;
NewID = UUID.Zero;
UploadAssetData(false);
/*Inventory.RequestCreateItemFromAsset(AssetData, "" + OldID, ProgressString,
* assetType, inventoryType,
* GetAssetUploadsFolder(),
* Permissions.FullPermissions,
* InvItemCreated);*/
//UpdateAsset(AssetData);
return;
}
}
if (!transfer.Success)
{
Importing.Error(ExportCommand.Exporting.LocalFailure, "bad transfer on " + this);
}
else
{
WriteProgress();
}
_NewItem = asset;
NewUUID2OBJECT[NewID] = this;
UUID2OBJECT[OldID] = this;
AssetUploaded.Set();
}
public void reImport() //Import/re-import the points from all sources
{
//Google sheet ops
locationCache.Clear();
if (URL != null) //Make sure we CAN load it...
{
List <string> sheet = Importing.downloadTSV(URL);
foreach (string gps in sheet)
{
if (gps.Contains("GPS:"))
{
locationCache.Add(new GPSDefinition.GPSPoint(gps, scaleDivisor));
}
}
redisplay();
}
else
{
//SHOW AN ERROR MESSAGE PLS
Debug.Log("No URL file");
}
}
public void setURL(string URL)
{
File.WriteAllText(dir, URL);
pointManager.GetComponent <PointManager>().boot(Importing.readFile(dir)[0]);
gameObject.SetActive(false);
}
public void KillAllUnpacked(OutputDelegate Failures, bool artifacts)
{
UUID into = UUID.Zero;
if (!settings.Contains("info"))
{
into = CogbotHelpers.NonZero(FolderCalled("TaskInvKilled"),
Client.Inventory.FindFolderForType(AssetType.TrashFolder));
}
int count = 0;
lock (fileWriterLock) foreach (string ext in new[] { "*.repack", /* "*.objectAsset"*/ })
{
foreach (var file in Directory.GetFiles(dumpDir, ext))
{
count++;
if (count > 1)
{
if (settings.Contains("once"))
{
return;
}
}
string filetext = File.ReadAllText(file);
string[] csv = filetext.Split(new[] { ',' });
UUID assetID = new UUID(csv[2]);
uint localID = uint.Parse(csv[0]);
var O1 = WorldObjects.GetSimObjectFromUUID(assetID);
if (O1 == null)
{
Client.Objects.RequestObject(Client.Network.CurrentSim, localID);
}
var O = GetSimObjectFromUUID(assetID);
if (O == null)
{
Failure("Cant find object for file: " + file + " " + filetext);
if (settings.Contains("info"))
{
Success("INFO: " + localID + " " + assetID);
continue;
}
Client.Inventory.RequestDeRezToInventory(localID, DeRezDestination.TrashFolder, into,
UUID.Random());
File.Delete(file);
if (artifacts)
{
Importing.KillID(assetID);
}
if (settings.Contains("once"))
{
return;
}
}
else
{
if (!settings.Contains("info"))
{
Success("INFO: " + localID + " " + assetID + " text=" + filetext);
continue;
}
Client.Inventory.RequestDeRezToInventory(O.LocalID, DeRezDestination.TrashFolder, into,
UUID.Random());
File.Delete(file);
if (artifacts)
{
Importing.KillID(assetID);
}
if (settings.Contains("once"))
{
return;
}
}
}
if (artifacts)
{
foreach (var file in Directory.GetFiles(dumpDir, "*.taskobj"))
{
string filetext = File.ReadAllText(file);
string[] csv = filetext.Split(new[] { ',' });
UUID assetID = new UUID(csv[2]);
Importing.KillID(assetID);
UUID holderID = new UUID(csv[3]);
string exportFile = dumpDir + "" + holderID + ".task";
if (File.Exists(exportFile))
{
File.Delete(exportFile);
}
File.Delete(file);
}
}
}
}
internal bool SaveTaskInv(ImportSettings arglist, BotClient Client, string pathStem, SimObject exportPrim, OutputDelegate Failure)
{
string exportFile = pathStem + ".task";
if (Incremental || showsMissingOnly)
{
lock (fileWriterLock) if (File.Exists(exportFile))
{
return(true);
}
}
needFiles++;
exportPrim.StartGetTaskInventory();
bool mightHaveTaskInv = exportPrim.TaskInventoryLikely;
var ib = exportPrim.TaskInventory;
if (ib == null || ib == SimObjectImpl.ERROR_TASK_INV)
{
bool canSee = checkPerms(Client, exportPrim, SilientFailure, false);
bool canScript = checkPerms(Client, exportPrim, SilientFailure, true);
if (!canSee)
{
if (!mightHaveTaskInv)
{
LogError(exportPrim, "!canSee TaskInv");
lock (fileWriterLock) File.WriteAllText(exportFile, "!canSee");
return(true);
}
Failure("Cant get/check TaskInv of " + named(exportPrim));
}
Failure("NULL TaskInv for " + named(exportPrim));
if (!canScript)
{
LogError(exportPrim, "!canScript to get TaskInv");
lock (fileWriterLock) File.WriteAllText(exportFile, "!canScript");
return(true);
}
if (ib == SimObjectImpl.ERROR_TASK_INV)
{
LogError(exportPrim, "TaskInv Null once");
lock (fileWriterLock) File.WriteAllText(exportFile, "!error");
}
return(true);
}
if (ib.Count == 0)
{
if (!exportPrim.InventoryEmpty)
{
if (verbosely)
{
Failure("ZEROITEM TaskInv for " + named(exportPrim));
}
//return;
}
lock (fileWriterLock) File.WriteAllText(exportFile, "");
return(true);
}
if (ib.Count == 1)
{
if (ib[0].Name == "Contents" && ib[0] is InventoryFolder)
{
lock (fileWriterLock) File.WriteAllText(exportFile, "");
return(true);
}
}
SaveTaskOSD(exportPrim.ID, ib);
return(true);
OSDArray contents = new OSDArray();
string TaskInvFailures = "";
bool hasObjects = false;
foreach (InventoryBase b in ib)
{
if (b is InventoryObject)
{
hasObjects = true;
break;
}
}
bool wasShouldBeMoving = shouldBeMoving;
shouldBeMoving = false;
if (hasObjects && taskobj)
{
MoveCloseTo(exportPrim);
}
foreach (InventoryBase b in ib)
{
bool missing;
OSDMap was = SaveEachTaskItem(arglist, Client, exportPrim, b, Failure, out missing);
if (was != null)
{
contents.Add(was);
}
if (missing)
{
if (forced && false)
{
Failure("Missing but forced: " + was);
}
else
{
TaskInvFailures += was;
}
}
}
shouldBeMoving = wasShouldBeMoving;
// TaskInvFailures = GetTaskInvFailures(Failure, exportPrim, Client, folderObject, contents, TaskInvFailures);
if (showsMissingOnly)
{
Failure("NEED TASK for " + named(exportPrim));
return(false);
}
if (string.IsNullOrEmpty(TaskInvFailures))
{
lock (fileWriterLock) File.WriteAllText(exportFile, OSDParser.SerializeLLSDXmlString(contents));
}
else
{
Failure(string.Format("Skipping writting contents unil Items/Objects can be resolved: for {0}\n{1}",
named(exportPrim), TaskInvFailures));
}
var ptc = Importing.APrimToCreate(exportPrim.ID);
return(ptc.EnsureTaskInv(false));
}
public void SaveLLSD(BotClient Client, string pathStem, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
if (exportPrim != null)
{
string exportFile = pathStem + ".llsd";
if (Incremental || showsMissingOnly)
{
lock (fileWriterLock) if (File.Exists(exportFile))
{
return;
}
}
needFiles++;
if (showsMissingOnly)
{
Failure("NEED LLSD for " + named(exportPrim));
AddMoveTo(exportPrim.SimPosition);
return;
}
try
{
List <string> skipTag = new List <string>()
{
"Tag"
};
Primitive prim = exportPrim.Prim;
Vector3 pp = prim.Position;
Quaternion pr = prim.Rotation;
//prim = prim.Clone();
OSDMap primOSD = (OSDMap)prim.GetOSD();
if (prim.ParentID != 0)
{
var parent = WorldSystem.GetLibOMVHostedPrim(prim.ParentID, settings.CurSim, false);
if (parent == null)
{
pp += new Vector3(128, 128, Client.Self.SimPosition.Z + 20);
Failure("YET FAILED: Cant GET parent of " + prim);
return;
}
else
{
pp = prim.Position * Matrix4.CreateFromQuaternion(parent.Rotation) + parent.Position;
pr = parent.Rotation * pr;
primOSD["ParentUUID"] = parent.ID;
}
}
primOSD["RegionPosition"] = pp;
primOSD["RegionRotation"] = pr;
if (exportPrim.PathFinding.MadeNonPhysical)
{
primOSD["physical"] = true;
primOSD["use_physics"] = true;
}
if (exportPrim.PathFinding.MadeNonTemp)
{
primOSD["temporary"] = true;
}
AddExportUser(primOSD["CreatorID"]);
AddExportGroup(primOSD["GroupID"]);
AddExportUser(primOSD["OwnerID"]);
AddExportUser(primOSD["LastOwnerID"]);
string output = OSDParser.SerializeLLSDXmlString(primOSD);
{
lock (fileWriterLock) File.WriteAllText(exportFile, output);
}
var ptc = Importing.APrimToCreate(prim);
ptc.Rezed = exportPrim;
if (forced && !verbosely)
{
return;
}
return;
Primitive prim2 = FromFile(exportFile, ExportCommand.UseBinarySerialization) as Primitive;
string memberwiseCompare = MemberwiseCompare(prim, prim2, skipTag);
if (!string.IsNullOrEmpty(memberwiseCompare))
{
string failre = "Error in LLSD: " + memberwiseCompare;
Failure(failre);
if (!forced)
{
File.Delete(exportFile);
return;
Error(failre);
}
}
}
catch (Exception e)
{
File.Delete(exportFile);
Failure("Writing file " + exportFile + " caused " + e);
}
}
}
public void redisplay()
{ //Display cache contents
foreach (GameObject obj in pointObjects)
{ //*flush*
Destroy(obj);
}
List <GPSDefinition.GPSPoint> tempCache = new List <GPSDefinition.GPSPoint>();
tempCache.Clear();
tempCache = Importing.filterGPSEntries(locationCache, filters);
pointObjects.Clear();
buttonContentPanel.GetComponent <ButtonManager>().populate(tempCache);
foreach (GPSDefinition.GPSPoint point in tempCache)
{
if (point.name.Contains("VL|"))
{ //It's a volume
string[] substrings = point.name.Split('|');
float size;
if (float.TryParse(substrings[2], out size) && showTerritory)
{
size = size / scaleDivisor;
switch (substrings[1])
{
case "FreindlyTerritory": //Us
CreateVolume(point.unityPosition, size, friendlyTerritoryPrefab);
break;
case "EnemyTerritory": //Enemy
CreateVolume(point.unityPosition, size, hostileTerritoryPrefab);
break;
case "Planet": //Planet
CreateVolume(point.unityPosition, size + 10, planetMarkerPrefab); //Add 10 to height to offset mountains
break;
default:
CreateVolume(point.unityPosition, size, planetMarkerPrefab);
break;
}
}
}
else
{ //Its a roid or somethin
bool isAsteroid = false;
foreach (string flag in asteroidFlags)
{ //Check to see if it is an asteroid
if (point.name.Contains(flag))
{
isAsteroid = true;
break; //No need to keep checking
}
}
if (isAsteroid)
{
CreateMarker(point.name, point.unityPosition, asteroidMarkerPrefab);
}
else
{
CreateMarker(point.name, point.unityPosition, otherMarkerPrefab);
}
}
}
}
private void CountReady(ImportSettings settings)
{
Exporting.GiveStatus();
int readyObjects = 0;
int readyObjectsForDelete = 0;
int unreadyObjs = 0;
int unreadyObjsMustReRez = 0;
int requestedShort = 0;
foreach (var file in Directory.GetFiles(ExportCommand.dumpDir, "*.*.rti"))
{
if (!file.EndsWith("rti"))
{
//rti_status
continue;
}
string rtiData = File.ReadAllText(file);
var contents = rtiData.Split(',');
if (contents.Length < 2)
{
requestedShort++;
continue;
}
UUID objID, holderID;
if (!UUID.TryParse(contents[0], out objID) || !UUID.TryParse(contents[1], out holderID))
{
Failure("SHORT: " + file + " " + rtiData);
requestedShort++;
continue;
}
// var uuidstr = Path.GetFileName(file).Split('.');
// var objNum = int.Parse(uuidstr[1]);
string completeStr = ExportCommand.IsComplete(objID, false, true, settings);
Vector3 where;
bool inWorld = Exporting.IsExisting(objID, out where);
if (string.IsNullOrEmpty(completeStr))
{
readyObjects++;
if (inWorld)
{
Exporting.AttemptMoveTo(where);
Thread.Sleep(3000);
Exporting.KillInWorld(objID);
Importing.APrimToCreate(holderID);
readyObjectsForDelete++;
}
else
{
Importing.APrimToCreate(holderID);
Importing.APrimToCreate(objID);
}
}
else
{
unreadyObjs++;
if (!inWorld)
{
unreadyObjsMustReRez++;
Failure("REREZ: " + completeStr + " " + rtiData);
Importing.APrimToCreate(holderID).MustUseAgentCopy = true;
File.Delete(ExportCommand.dumpDir + holderID + ".rti_status");
File.Delete(file);
}
else
{
MustExport.Add(objID);
MustExport.Add(holderID);
Importing.APrimToCreate(holderID);
Failure("RTIDATA: " + completeStr + " " + rtiData);
Exporting.AddMoveTo(where);
}
}
}
Success("readyObjects = " + readyObjects);
Success("readyObjectsForDelete = " + readyObjectsForDelete);
Success("unreadyObjs = " + unreadyObjs);
Success("unreadyObjsMustReRez = " + unreadyObjsMustReRez);
Success("requestedShort = " + requestedShort);
}
