public static bool IsSkipped(SimObject P, ImportSettings settings)
{
if (P is SimAvatar) return true;
if (P == null) return true;
if (IsIncluded(P.ID, P.LocalID)) return false;
if (P.Parent != null) if (IsIncluded(P.Parent.ID, P.ParentID)) return false;
Primitive pp = P.Prim0;
if (P.IsKilled)
{
if (pp != null)
{
if (P.IsTemporary) return true;
}
}
if (P.IsTemporary) return true;
if (!P.HasPrim) return true;
if (pp == null) return true;
var sp = P.SimPosition;
if (!onlyObjectAt.IsInside(sp.X, sp.Y, sp.Z)) return true;
Primitive.ObjectProperties props = pp.Properties;
if (props != null)
{
if (IsSkippedName(props.Name))
{
return true;
}
}
if (pp.ParentID == 0) return false;
SimObject parent = P.Parent;
// yes SL really does have links two deep! (called attachment linksets)
if (parent == null) return true;
if (parent == P) return false;
if (!IsSkipped(parent, settings)) return false;
return true;
}
private void SnagUsers(SimObject o)
{
var prim = o.Prim;
AddExportUser(prim.OwnerID);
AddExportGroup(prim.GroupID);
Primitive.ObjectProperties primProperties = prim.Properties ?? o.Properties;
if (primProperties != null)
{
AddExportUser(primProperties.CreatorID);
AddExportGroup(primProperties.GroupID);
}
}
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);
}
private void SaveRelatedAssets(string pathStem, SimObject exportPrim, OutputDelegate Failure)
{
string exportFile = pathStem + ".deps";
if (Incremental || showsMissingOnly) lock (fileWriterLock) if (File.Exists(exportFile)) return;
needFiles++;
if (showsMissingOnly)
{
Failure("NEED DEPS for " + named(exportPrim));
return;
}
if (PrimDepsAssets.Count == 0)
{
lock (fileWriterLock) File.WriteAllText(exportFile, "");
return;
}
string content = "";
foreach (UUID assetID in PrimDepsAssets)
{
content += assetTypeOf(assetID) + "," + assetID + "\n";
}
lock (fileWriterLock) File.WriteAllText(exportFile, content);
}
public string GiveAll(BotInventoryEval man, InventoryBase b, SimObject dest, bool moveInsteadOfCopy)
{
string ret = "";
var manager = man.Manager;
if (b is InventoryItem)
{
InventoryItem item = b as InventoryItem;
bool canCopy = (item.Permissions.OwnerMask & PermissionMask.Copy) == PermissionMask.Copy;
ret += item.Name + nl;
if (dest.IsAvatar)
{
manager.GiveItem(item.UUID, item.Name, item.AssetType, dest.ID, true);
}
else
{
throw new NotImplementedException("giving items to objects");
}
}
else if (b is InventoryFolder)
{
InventoryFolder item = b as InventoryFolder;
if (dest.IsAvatar)
{
manager.GiveFolder(item.UUID, item.Name, AssetType.Folder, dest.ID, true);
return item.Name + nl;
}
InventoryFolder folder = b as InventoryFolder;
List<InventoryBase> folderContents = man.FolderContents(folder.UUID);
if (folderContents != null)
foreach (InventoryBase list in folderContents)
{
ret += GiveAll(man, list, dest, moveInsteadOfCopy);
}
}
return ret;
}
public static Dictionary<string, float> ToNamedColors(SimObject av)
{
Primitive p = av.Prim;
if (p==null) return null;
var t = p.Textures;
var tf = t.FaceTextures;
Color4 fnd = Color4.Black;
bool cf = false;
foreach (var entryFace in tf)
{
if (entryFace == null) continue;
var fc = entryFace.TextureID;
var fnd0 = entryFace.RGBA;
if (fnd0 != Color4.White)
{
fnd = fnd0;
cf = true;
break;
}
}
if (!cf)
{
var dc = t.DefaultTexture;
if (dc != null)
{
var fnd0 = dc.RGBA;
if (fnd0 != Color4.White)
{
fnd = fnd0;
}
}
}
Dictionary<string, float> dict = new Dictionary<string, float>();
CatchNamedColors(ToColor(fnd), dict, false);
return dict;
}
private void InvokeThis(SimTypeUsage name, object sender, EventArgs args, SimObject O, object target, Type type)
{
Plugin.TheBot.WorldSystem.TheSimAvatar.Do(name, O ?? GetSimObject(target));
}
public SaveFileDialog(SimObject pObj) : base(pObj)
{
}
/// <summary>
/// Triggers the OnRemovePartSimObject event.
/// </summary>
public virtual void SendOnRemovePartSimObject(SimObject ea, string property, object oldValue, object newValue)
{
if (OnRemovePartSimObject != null)
OnRemovePartSimObject(ea, property, oldValue, newValue);
}
public PermissionMask NonEffectivePermissionsMask(SimObject exportPrim)
{
Permissions perms = exportPrim.Properties.Permissions;
return CogbotHelpers.PermMaskForWho(EffectivePermissionWho(exportPrim), perms);
}
public SaveFileDialog(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
public RenderParticleMgr(SimObject pObj) : base(pObj)
{
}
public StreamObject(SimObject pObj)
: base(pObj)
{
}
public GuiRoadEditorCtrl(SimObject pObj)
: base(pObj)
{
}
public GuiInspectorTypeBitMask32(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
public FlyingVehicleData(SimObject pObj)
: base(pObj)
{
}
public GuiRoadEditorCtrl(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
public GuiInspectorTypeCheckBox(SimObject pObj) : base(pObj)
{
}
public guiAnimBitmapCtrl(SimObject pObj)
: base(pObj)
{
}
public guiAnimBitmapCtrl(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
private void OfferPrimToSimObject(Primitive prim, SimObject obj0, Simulator simulator)
{
if (simulator != null && prim.Properties == null)
{
EnsureSelected(prim, simulator);
}
obj0.ConfirmedObject = true;
obj0.ResetPrim(prim, client, simulator);
}
public GuiInspectorTypeBitMask32(SimObject pObj)
: base(pObj)
{
}
public SimObjectListViewItem(SimObject o)
{
_simObject = o;
this.Tag = o.ID;
this.Text = o.ToString();
}
public VehicleData(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
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 VehicleData(SimObject pObj)
: base(pObj)
{
}
public PermissionWho EffectivePermissionWho(SimObject exportPrim)
{
if (WorldSystem.AssumeOwner) return PermissionWho.Owner;
Primitive.ObjectProperties permProps = exportPrim.Properties;
Primitive prim = exportPrim.Prim;
UUID objectGroupID = UUID.Zero;
UUID ownerID = UUID.Zero;
PrimFlags flag = PrimFlags.None;
if (prim != null)
{
objectGroupID = prim.GroupID;
ownerID = prim.OwnerID;
flag = prim.Flags;
} else if (permProps != null)
{
objectGroupID = permProps.GroupID;
ownerID = permProps.OwnerID;
}
bool groupOwned = (flag & PrimFlags.ObjectGroupOwned) != 0;
// bool groupOwned = (flag & PrimFlags.) != 0;
return EffectivePermissionWho(ownerID, objectGroupID, groupOwned);
}
public afxSpellBookData(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
public void DoBestUse(SimObject someObject)
{
if (someObject == null) return;
SimTypeUsage use = someObject.Affordances.GetBestUse(CurrentNeeds);
if (use == null)
{
double closeness = Actor.Approach(someObject, someObject.GetSizeDistance() + 1);
//AgentManager ClientSelf = client.Self;
Actor.Touch(someObject);
if (closeness < 3)
{
Actor.SitOn(someObject);
}
return;
}
Actor.Do(use, someObject);
return;
}
public afxSpellBookData(SimObject pObj)
: base(pObj)
{
}
public StreamObject(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
public SimDataBlock(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
/// <summary>
/// Triggers the OnRemoveSimObject event.
/// </summary>
public virtual void SendOnRemoveSimObject(SimObject ea)
{
if (OnRemoveSimObject != null)
OnRemoveSimObject(ea);
}
/// <summary>
///
///
///
///
///
///
///
///
///
///
///
///
///
///
/// </summary>
/// <param name="someObject"></param>
/// <returns></returns>
public bool SitOn(SimObject someObject)
{
if (someObject == null) return SitOnGround();
AgentManager ClientSelf = Client.Self;
uint local = someObject.LocalID;
//already sitting on
Avatar theAvatar = this.theAvatar;
if (theAvatar == null) return false;
if (theAvatar.ParentID == local || Client.Self.SittingOn == local)
{
Debug("todo should we stand once first? " + someObject);
return true;
}
AutoResetEvent are = new AutoResetEvent(false);
EventHandler<AvatarSitChangedEventArgs> OnSitChanged =
(s, e) =>
{
if (e.Avatar == theAvatar)
{
are.Set();
}
};
Client.Objects.AvatarSitChanged += OnSitChanged;
try
{
ClientSelf.RequestSit(someObject.Prim.ID, Vector3.Zero);
ClientSelf.Sit();
if (!are.WaitOne(10000))
{
// return false;
}
return local == ClientSelf.SittingOn;
}
finally
{
Client.Objects.AvatarSitChanged -= OnSitChanged;
}
}
//----------- SELECTED OBJECT STUFF.
public void selectObject(SimObject obj) {
if (obj != null) {
//do the generic stuff.
hudView.setObjectName(obj.getName());
hudView.setObjectDescription(obj.getDesc());
hud.setSelectedObject(obj);
}
}
public bool ExportPrim(BotClient Client, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
uint localID = exportPrim.LocalID;
WorldObjects.EnsureRequested(localID + 1, settings.CurSim);
try
{
Client.Objects.SelectObject(settings.CurSim, localID);
WorldObjects.EnsureRequested(localID, settings.CurSim);
return ExportPrim0(Client, exportPrim, Failure, settings);
}
finally
{
Client.Objects.DeselectObject(settings.CurSim, localID);
}
}
public SimObjectUsage(SimTypeUsage use, SimObject target) : base (""+ use.ToString() + " " + target.ToString())
{
TypeUsage = use;
Target = target;
}
void SaveLinksetInfo(BotClient Client, string pathStem, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
string exportFile = pathStem + ".link";
if (Incremental || true) lock (fileWriterLock) if (File.Exists(exportFile)) return;
if (false && exportPrim.Children.Count == 0)
{
// so we dont do it again
if (Incremental) lock (fileWriterLock) File.WriteAllText(exportFile, "");
return;
}
if (Incremental || showsMissingOnly) lock (fileWriterLock) if (File.Exists(exportFile)) return;
needFiles++;
if (showsMissingOnly)
{
Failure("NEED LINK for " + named(exportPrim));
return;
}
SlowlyDo(() => RequestLinksetInfo(Client, pathStem, exportPrim, Failure, settings));
}
public static bool TryGetSimObject(UUID victim, out SimObject victimAv)
{
victimAv = GetSimObjectFromUUID(victim);
return victimAv != null;
}
public afxXM_OscillateZodiacColorData(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
public SimDataBlock(SimObject pObj)
: base(pObj)
{
}
public afxXM_OscillateZodiacColorData(SimObject pObj) : base(pObj)
{
}
/// <summary>
///
/// </summary>
/// <param name="obj"></param>
/// <param name="maxDistance"></param>
/// <returns></returns>
public double Approach(SimObject obj, double maxDistance)
{
OnlyMoveOnThisThread();
/// stand up first
SimObject UnPhantom = StandUp();
/// make sure it not going somewhere
/// set the new target
ApproachDistance = maxDistance;
string str = "Approaching " + obj + " " + DistanceVectorString(obj) + " to get " + ApproachDistance;
Debug(str);
try
{
if (DebugLevel > 1) IndicateTarget(obj, true);
obj.PathFinding.MakeEnterable(this);
/// if (!MoveTo(obj.GlobalPosition(), obj.GetSizeDistance() + 0.5f, 12))
SalientGoto(obj);
TurnToward(obj);
SimpleMoveTo(obj.GlobalPosition, maxDistance, 1, true);
}
finally
{
if (UnPhantom != null)
UnPhantom.PathFinding.RestoreEnterable(this);
if (DebugLevel > 1) IndicateTarget(obj, false);
}
return (double)Distance(obj);
}
public AudioDescription(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
internal bool ExportPrim0(BotClient Client, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
if (IsSkipped(exportPrim, settings)) return false;
Simulator CurSim = exportPrim.GetSimulator();
//settings.CurSim = CurSim;
WorldObjects.EnsureSelected(exportPrim.LocalID, CurSim);
string pathStem = Path.Combine(dumpDir, exportPrim.ID.ToString());
if (settings.Contains("task") || showsMissingOnly)
{
exportPrim.StartGetTaskInventory();
}
if (settings.Contains("wait"))
{
var waitUntil = DateTime.Now.AddSeconds(10);
bool needsLoop = true;
while (needsLoop && waitUntil > DateTime.Now)
{
needsLoop = false;
if (exportPrim.Properties == null || CogbotHelpers.IsNullOrZero(exportPrim.Properties.OwnerID))
{
needsLoop = true;
}
if (settings.Contains("task"))
{
var ti = exportPrim.TaskInventory;
if (ti == null)
{
needsLoop = true;
}
}
}
if (needsLoop)
{
Success("needs loop " + named(exportPrim));
string bissues = exportPrim.MissingData;
if (!string.IsNullOrEmpty(bissues) && !settings.Allows(bissues ,exportPrim))
{
Failure("Cant wait out the Issues " + bissues + ": " + named(exportPrim));
if (LocalFailures == 0) LocalFailures++;
// return;
}
}
}
string issues = exportPrim.MissingData;
if (!string.IsNullOrEmpty(issues) && !settings.Allows(issues, exportPrim))
{
Failure("Issues " + issues + " " + named(exportPrim));
if (LocalFailures == 0) LocalFailures++;
//return false;
}
//ImportCommand.PrimToCreate ptc = ImportCommand.Running.APrimToCreate(exportPrim.ID);
//ptc._prim = exportPrim.Prim;
bool passedOK = true;
if (settings.Contains("llsd"))
{
SaveLLSD(Client, pathStem, exportPrim, Failure, settings);
}
if (exportPrim.IsRoot && (true || exportPrim.Children.Count > 0))
{
if (settings.Contains("link")) SaveLinksetInfo(Client, pathStem, exportPrim, Failure, settings);
string exportFile = pathStem + ".link";
//lock (fileWriterLock) if (File.Exists(exportFile))
{
foreach (var c in exportPrim.Children)
{
var ch = ExportPrim(Client, c, Failure, settings);
if (!ch) passedOK = false;
}
}
}
if (settings.Contains("task"))
{
if (!SaveTaskInv(settings, Client, pathStem, exportPrim, Failure)) passedOK = false;
// ImportCommand.PrimToCreate ptc = ImportCommand.Running.APrimToCreate(exportPrim.ID);
// if (!ptc.EnsureTaskInv()) return false;
}
if (!settings.Contains("dep")) return passedOK;
AddRelatedTextures(exportPrim);
SaveRelatedAssets(pathStem, exportPrim, Failure);
return passedOK;
}
public AudioDescription(SimObject pObj)
: base(pObj)
{
}
public void RequestLinksetInfo(BotClient Client, string pathStem, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
string exportFile = pathStem + ".link";
lock (fileWriterLock) if (File.Exists(exportFile)) return;
bool canScript = checkPerms(Client, exportPrim, SilientFailure, true);
InventoryItem found = GetInvItem(Client, "LinksetSpeaker");
if (!canScript || found == null)
{
ScanForLinksets(exportPrim);
return;
}
lock (PrimWaitingLinkset)
{
if (PrimWaitingLinkset.ContainsKey(exportPrim.ID)) return;
PrimWaitingLinkset.Add(exportPrim.ID, new LinkSetBuffer {S = "", O = exportPrim, F = pathStem});
}
PutItemToTaskInv(Client,exportPrim.LocalID, exportPrim, "LinksetSpeaker");
}
public RenderImposterMgr(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
public static bool checkPerms(BotClient Client, SimObject exportPrim, OutputDelegate Failure, bool mustModify)
{
if (exportPrim != null)
{
var Properties = exportPrim.Properties;
if (Properties == null)
{
Client.Objects.RequestObjectPropertiesFamily(exportPrim.GetSimulator(), exportPrim.ID, true);
Failure("No props yet for " + named(exportPrim));
return false;
}
// Check for export permission first
//GotPermissions = false;
//
//if (!GotPermissions)
// {
// Properties = exportPrim.Properties ?? new Primitive.ObjectProperties();
//}
// GotPermissionsEvent.WaitOne(1000 * 10, false);
if (Properties.OwnerID != Client.Self.AgentID &&
Properties.OwnerID != Client.MasterKey &&
Properties.GroupID != Client.Self.ActiveGroup)
{
Failure("That object is owned by " + Properties.OwnerID + ", we don't have permission " +
"to export " + named(exportPrim));
}
SimAvatarClient theAvatar = Client.TheSimAvatar;
PermissionWho pw = theAvatar.EffectivePermissionWho(exportPrim);
PermissionMask pm = theAvatar.EffectivePermissionsMask(exportPrim);
bool modify = Permissions.HasPermissions(pm, PermissionMask.Modify);
bool cmt = Permissions.HasPermissions(pm, PermissionMask.Copy) ||
Permissions.HasPermissions(pm, PermissionMask.Modify) ||
Permissions.HasPermissions(pm, PermissionMask.Transfer);
if (mustModify)
{
if (!modify)
{
Failure("ObjPerms NOMODIFY " + pm + " for " + pw + " on " + named(exportPrim));
return false;
}
}
if (!cmt)
{
Failure("ObjPerms " + pm + " for " + pw + " on " + named(exportPrim));
return false;
}
//List<SimObject> family = new List<SimObject>();
//family.Add(exportPrim);
//family.AddRange(exportPrim.Children);
/*bool complete = RequestObjectProperties(family, 250, exportPrim.GetSimulator());
exportedPrims.AddRange(family);
if (!complete)
{
Logger.Log("Warning: Unable to retrieve full properties for:", Helpers.LogLevel.Warning, Client);
foreach (UUID uuid in PrimsWaiting.Keys)
Logger.Log(uuid.ToString(), Helpers.LogLevel.Warning, Client);
}
* return true;*/
}
return true;
}
public RenderImposterMgr(SimObject pObj)
: base(pObj)
{
}
public static string named(SimObject prim)
{
string s = ("" + prim);
int start = s.IndexOf("localID");
int fp = s.IndexOf(")", start + 1);
//if (fp < 64) fp = 0;
if (fp > 0) return s.Substring(0, fp + 1);
if (s.Length < 100) return s;
return s.Substring(0, 100);
}
public GuiGameListOptionsProfile(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
public void RemoveObject(SimObject O)
{
KnownSimObjects.Remove(O);
}
public GuiGameListOptionsProfile(SimObject pObj)
: base(pObj)
{
}
public PermissionMask EffectivePermissionsMask(SimObject exportPrim)
{
Permissions perms = exportPrim.Properties.Permissions;
return NonEffectivePermissionsMask(exportPrim) & perms.BaseMask;
}
public GuiStackControl(string pName, SimObject pParent, bool pRegister = false)
: this(pName, pRegister)
{
CopyFrom(pParent);
}
public int CompareObjects(SimObject act1, SimObject act2)
{
if (act1 == act2) return 0;
if (act1 == null) return -1;
if (act2 == null) return 1;
return (int)(act2.Affordances.RateIt(CurrentNeeds) - act1.Affordances.RateIt(CurrentNeeds));
}
public GuiStackControl(SimObject pObj)
: base(pObj)
{
}
//----------- SELECTED OBJECT STUFF.
public void selectObject(SimObject obj) {
if (obj != null) {
//do the generic stuff.
hudView.setObjectName(obj.getName());
hudView.setObjectDescription(obj.getDesc());
hud.setSelectedObject(obj);
//get other object set up stuff.
if (obj.GetType() == typeof(PlugLoadController)) {
PlugLoadController pl = (PlugLoadController)obj;
hudView.plugLoad_setListOfEnergyUsingObjects(pl.getEuoList(), pl);
}
else if (obj.GetType() == typeof(EnergyUsingObject)) {
EnergyUsingObject euo = (EnergyUsingObject)obj;
hudView.setListOfSelectablePlugLoads(euo);
}
}
}
public afxXM_GroundConformData(SimObject pObj) : base(pObj)
{
}
