void DrawMenuInstall(String packageName, String title, String description, PackageFlags packageFlags = default(PackageFlags))
{
if (PackageExists(packageName))
{
DrawMenuOption(_samplesIcon, new GUIContent(title), new GUIContent(description), InstallPackage(packageName, packageFlags));
}
}
void Install(BoltPackage package)
{
string packageName = package.name;
PackageFlags flags = package.packageFlags;
if ((flags & PackageFlags.WarnForProjectOverwrite) == PackageFlags.WarnForProjectOverwrite)
{
if (ProjectExists())
{
if (EditorUtility.DisplayDialog("Warning",
"Importing this package will overwrite the existing bolt project file that contains all your states, events, etc. Are you sure?",
"Yes", "No") == false)
{
return;
}
}
}
if ((flags & PackageFlags.RunInitialSetup) == PackageFlags.RunInitialSetup)
{
InitialSetup();
}
AssetDatabase.ImportPackage(PackagePath(packageName), false);
currentStage = BoltSetupStage.Bolt;
}
internal static PackageFlags ParsePackageFlags(List <String> Args)
{
PackageFlags Result = PackageFlags.Package;
List <String> ToBeRemoved = new List <String>();
foreach (String Arg in Args)
{
switch (Arg.ToUpper())
{
case "--HELP":
Result |= PackageFlags.Help;
break;
case "--INFO":
Result |= PackageFlags.Info;
break;
case "--VALIDATE":
Result |= PackageFlags.Validate;
break;
default:
break;
}
if (Arg.StartsWith("--"))
{
ToBeRemoved.Add(Arg);
}
}
foreach (String Arg in ToBeRemoved)
{
Args.Remove(Arg);
}
return(Result);
}
public PackageData(
string name,
string group,
string description,
IClientData clientData,
string indexFileName,
string provideFileName,
PackageFlags flags,
Version loaded,
VersionStringDictionary ifNeeded,
long token
)
{
this.kind = IdentifierKind.PackageData;
this.id = AttributeOps.GetObjectId(this);
this.name = name;
this.group = group;
this.description = description;
this.indexFileName = indexFileName;
this.provideFileName = provideFileName;
this.flags = flags;
this.clientData = clientData;
this.loaded = loaded;
this.ifNeeded = ifNeeded;
this.token = token;
}
public PackageData(PackageFlags Flags, PackageType Type, Byte[] Unused1, FalloutBehaviorFlags FalloutBehaviorFlags, dynamic TypeFlags, Byte[] Unused2)
{
this.Flags = Flags;
this.Type = Type;
this.Unused1 = Unused1;
this.FalloutBehaviorFlags = FalloutBehaviorFlags;
this.TypeFlags = TypeFlags;
this.Unused2 = Unused2;
}
public PackageData(string Tag = null)
: base(Tag)
{
Flags = new PackageFlags();
Type = new PackageType();
Unused1 = new byte[1];
FalloutBehaviorFlags = new FalloutBehaviorFlags();
TypeFlags = 0;
Unused2 = new byte[2];
}
///////////////////////////////////////////////////////////////////////
public static bool HasFlags(
PackageFlags flags,
PackageFlags hasFlags,
bool all
)
{
if (all)
{
return((flags & hasFlags) == hasFlags);
}
else
{
return((flags & hasFlags) != PackageFlags.None);
}
}
/// <summary>
/// Create from a package full name.
/// </summary>
/// <param name="package_full_name">The package full name.</param>
/// <param name="full_information">Query for full information (needs to be installed for the current user).</param>
/// <param name="throw_on_error">True to throw on error.</param>
/// <returns>The package identity.</returns>
public static NtResult <PackageIdentity> CreateFromFullName(string package_full_name, bool full_information, bool throw_on_error)
{
PackageFlags flags = full_information ? PackageFlags.Full : PackageFlags.Basic;
int length = 0;
var result = Win32NativeMethods.GetStagedPackagePathByFullName(package_full_name, ref length, null);
if (result != Win32Error.ERROR_INSUFFICIENT_BUFFER)
{
return(result.CreateResultFromDosError <PackageIdentity>(throw_on_error));
}
var builder = new StringBuilder(length);
result = Win32NativeMethods.GetStagedPackagePathByFullName(package_full_name, ref length, builder);
if (result != Win32Error.SUCCESS)
{
return(result.CreateResultFromDosError <PackageIdentity>(throw_on_error));
}
result = _get_staged_package_origin(package_full_name, out PackageOrigin origin);
if (result != Win32Error.SUCCESS)
{
return(result.CreateResultFromDosError <PackageIdentity>(throw_on_error));
}
length = 0;
result = Win32NativeMethods.PackageIdFromFullName(package_full_name, flags, ref length, SafeHGlobalBuffer.Null);
if (result != Win32Error.ERROR_INSUFFICIENT_BUFFER)
{
return(result.CreateResultFromDosError <PackageIdentity>(throw_on_error));
}
using (var buffer = new SafeStructureInOutBuffer <PACKAGE_ID>(length, false))
{
result = Win32NativeMethods.PackageIdFromFullName(package_full_name, flags, ref length, buffer);
if (result != Win32Error.SUCCESS)
{
return(result.CreateResultFromDosError <PackageIdentity>(throw_on_error));
}
return(new PackageIdentity(package_full_name, buffer.Result, origin, builder.ToString()).CreateResult());
}
}
///////////////////////////////////////////////////////////////////////
#region Public Methods
public ReturnCode PackageFallback(
Interpreter interpreter,
string name,
Version version,
string text,
PackageFlags flags,
bool exact,
ref Result result
)
{
if (callback == null)
{
result = "invalid package callback";
return(ReturnCode.Error);
}
return(callback.PackageFallback(
interpreter, name, version, text, flags, exact, ref result));
}
public FPackageFileSummary(FArchive Ar)
{
Tag = Ar.Read <uint>();
LegacyFileVersion = Ar.Read <int>();
LegacyUE3Version = Ar.Read <int>();
FileVersionUE4 = Ar.Read <int>();
FileVersionLicenseUE4 = Ar.Read <int>();
CustomContainerVersion = Ar.ReadArray <FCustomVersion>();
TotalHeaderSize = Ar.Read <int>();
FolderName = Ar.ReadFString();
PackageFlags = Ar.Read <PackageFlags>();
NameCount = Ar.Read <int>();
NameOffset = Ar.Read <int>();
GatherableTextDataCount = Ar.Read <int>();
GatherableTextDataOffset = Ar.Read <int>();
ExportCount = Ar.Read <int>();
ExportOffset = Ar.Read <int>();
ImportCount = Ar.Read <int>();
ImportOffset = Ar.Read <int>();
DependsOffset = Ar.Read <int>();
SoftPackageReferencesCount = Ar.Read <int>();
SoftPackageReferencesOffset = Ar.Read <int>();
SearchableNamesOffset = Ar.Read <int>();
ThumbnailTableOffset = Ar.Read <int>();
if (Ar.Game == EGame.GAME_VALORANT)
{
Ar.Position += 8;
}
Guid = Ar.Read <FGuid>();
Generations = Ar.ReadArray <FGenerationInfo>();
SavedByEngineVersion = new FEngineVersion(Ar);
CompatibleWithEngineVersion = new FEngineVersion(Ar);
CompressionFlags = Ar.Read <uint>();
CompressedChunks = Ar.ReadArray <FCompressedChunk>();
PackageSource = Ar.Read <uint>();
AdditionalPackagesToCook = Ar.ReadArray(Ar.ReadFString);
AssetRegistryDataOffset = Ar.Read <int>();
BulkDataStartOffset = Ar.Read <int>();
WorldTileInfoDataOffset = Ar.Read <int>();
ChunkIds = Ar.ReadArray <int>();
PreloadDependencyCount = Ar.Read <int>();
PreloadDependencyOffset = Ar.Read <int>();
}
Action InstallPackage(String packageName, PackageFlags packageFlags)
{
return(() =>
{
if ((packageFlags & PackageFlags.WarnForProjectOverwrite) == PackageFlags.WarnForProjectOverwrite)
{
if (ProjectExists())
{
if (EditorUtility.DisplayDialog("Warning", "Importing this package will overwrite the existing bolt project file that contains all your states, events, etc. Are you sure?", "Yes", "No") == false)
{
return;
}
}
}
if ((packageFlags & PackageFlags.RunInitialSetup) == PackageFlags.RunInitialSetup)
{
InitialSetup();
}
AssetDatabase.ImportPackage(PackagePath(packageName), false);
});
}
public Package(PackageElement[] elements, PackageFlags flags = PackageFlags.None) : this(null, elements, flags)
{
}
protected void DrawMenuInstall(String packageName, String title, String description, PackageFlags packageFlags = default(PackageFlags))
{
bool packageExists = PackageExists(packageName);
Action ignoredAction;
if (packageExists == true)
{
ignoredAction = () => { ShowNotification(new GUIContent("One of the dependencies is missing")); };
}
else
{
ignoredAction = () => { ShowNotification(new GUIContent("Please contact us at [email protected]")); };
EditorGUI.BeginDisabledGroup(true);
}
DrawMenuOption(_samplesIcon, new GUIContent(title), new GUIContent(description), InstallPackage(packageName, packageFlags), ignoredAction);
if (packageExists == false)
{
EditorGUI.EndDisabledGroup();
}
}
public void SetFlag(PackageFlags flag)
{
SetFlag((ushort)flag);
}
private bool DeserializeHeader(ObjectReader header)
{
// Not a PCC file.
if (header.ReadUInt32() != 0x9E2A83C1)
{
return(false);
}
// Unsupported unreal engine version
if (header.ReadUInt16() != 0x02AC || header.ReadUInt16() != 0xC2)
{
return(false);
}
_unkn1 = header.ReadUInt32();
_folderName = header.ReadString();
PackageFlags = (PackageFlags)header.ReadUInt32();
_unknDummy = header.ReadUInt32();
_nameCount = header.ReadInt32();
_nameOffset = header.ReadUInt32();
_exportCount = header.ReadInt32();
_exportOffset = header.ReadUInt32();
_importCount = header.ReadInt32();
_importOffset = header.ReadUInt32();
_unkn2 = header.ReadUInt32(); // Both of these often match _unkn1.
_unkn3 = header.ReadUInt32(); // UnHood references "first export offset", cant see that working here?
header.ReadRawData(12); // seemingly 0's
_GUID_A = header.ReadUInt32();
_GUID_B = header.ReadUInt32();
_GUID_C = header.ReadUInt32();
_GUID_D = header.ReadUInt32();
_generations = header.ReadUInt32();
header.ReadRawData(4); // Copy of export count?
header.ReadRawData(4); // Copy of name count?
header.ReadRawData(4); // Another 0
// Engine version mis-match
if (header.ReadUInt32() != 0x18EF)
{
return(false);
}
// Cooker version mis-match
if (header.ReadUInt32() != 0x3006B)
{
return(false);
}
_unkn4 = header.ReadUInt32(); // Seems to be the same for all files.
_unkn5 = header.ReadUInt32(); // Same as above, UnHood possibly refers to this as package flags, old remnants?
_compressionFlag = (FileCompressionFlags)header.ReadUInt32();
_chunkCount = header.ReadUInt32();
// TODO: support compressed files..
return(true);
}
public Package(string name, PackageElement[] elements, PackageFlags flags = PackageFlags.None)
{
this.Name = name;
this.Elements = elements;
this.Flags = flags;
}
internal static extern Win32Error PackageIdFromFullName(
string packageFullName,
PackageFlags flags,
ref int bufferLength,
SafeBuffer buffer
);
public bool HasFlag(PackageFlags flag)
{
return(HasFlag((ushort)flag));
}
[System.Diagnostics.Contracts.Pure]public bool HasPackageFlag( PackageFlags flag )
{
return (PackageFlags & (uint)flag) != 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region IExecute Members
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Result result
)
{
ReturnCode code = ReturnCode.Ok;
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count >= 2)
{
string subCommand = arguments[1];
bool tried = false;
code = ScriptOps.TryExecuteSubCommandFromEnsemble(
interpreter, this, clientData, arguments, true,
false, ref subCommand, ref tried, ref result);
if ((code == ReturnCode.Ok) && !tried)
{
switch (subCommand)
{
case "forget":
{
if (arguments.Count >= 2)
{
code = interpreter.PkgForget(
new StringList(arguments, 2), ref result);
}
else
{
result = "wrong # args: should be \"package forget ?package package ...?\"";
code = ReturnCode.Error;
}
break;
}
case "ifneeded":
{
if ((arguments.Count == 4) || (arguments.Count == 5))
{
Version version = null;
code = Value.GetVersion(
arguments[3], interpreter.CultureInfo,
ref version, ref result);
if (code == ReturnCode.Ok)
{
string text = null;
if (arguments.Count == 5)
{
text = arguments[4];
}
code = interpreter.PkgIfNeeded(
arguments[2], version, text, interpreter.PackageFlags,
ref result);
}
}
else
{
result = "wrong # args: should be \"package ifneeded package version ?script?\"";
code = ReturnCode.Error;
}
break;
}
case "indexes":
{
if ((arguments.Count == 2) || (arguments.Count == 3))
{
string pattern = null;
if (arguments.Count == 3)
{
pattern = arguments[2];
}
code = interpreter.PkgIndexes(
pattern, false, ref result);
}
else
{
result = "wrong # args: should be \"package indexes ?pattern?\"";
code = ReturnCode.Error;
}
break;
}
case "info":
{
if (arguments.Count == 3)
{
IPackage package = null;
code = interpreter.GetPackage(
arguments[2], LookupFlags.Default,
ref package, ref result);
if (code == ReturnCode.Ok)
{
bool scrub = interpreter.IsSafe();
PackageFlags flags = package.Flags;
Guid id = AttributeOps.GetObjectId(package);
result = StringList.MakeList(
"kind", package.Kind,
"id", package.Id.Equals(Guid.Empty) ? id : package.Id,
"name", package.Name,
"description", package.Description,
"indexFileName", scrub ? PathOps.ScrubPath(
GlobalState.GetBasePath(), package.IndexFileName) :
package.IndexFileName,
"provideFileName", scrub ? PathOps.ScrubPath(
GlobalState.GetBasePath(), package.ProvideFileName) :
package.ProvideFileName,
"flags", flags,
"loaded", (package.Loaded != null) ? package.Loaded : null,
"ifNeeded", (!scrub && (package.IfNeeded != null)) ?
package.IfNeeded.KeysAndValuesToString(null, false) :
null);
}
}
else
{
result = "wrong # args: should be \"package info name\"";
code = ReturnCode.Error;
}
break;
}
case "loaded":
{
if ((arguments.Count == 2) || (arguments.Count == 3))
{
string pattern = null;
if (arguments.Count == 3)
{
pattern = arguments[2];
}
code = interpreter.PkgLoaded(
pattern, false, false, ref result);
}
else
{
result = "wrong # args: should be \"package loaded ?pattern?\"";
code = ReturnCode.Error;
}
break;
}
case "names":
{
if ((arguments.Count == 2) || (arguments.Count == 3))
{
string pattern = null;
if (arguments.Count == 3)
{
pattern = arguments[2];
}
code = interpreter.PkgNames(
pattern, false, ref result);
}
else
{
result = "wrong # args: should be \"package names ?pattern?\"";
code = ReturnCode.Error;
}
break;
}
case "present":
{
if (arguments.Count >= 3)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-exact", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null)
});
int argumentIndex = Index.Invalid;
code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, false, ref argumentIndex, ref result);
if (code == ReturnCode.Ok)
{
if ((argumentIndex != Index.Invalid) &&
((argumentIndex + 2) >= arguments.Count))
{
bool exact = false;
if (options.IsPresent("-exact"))
{
exact = true;
}
Version version = null;
if ((argumentIndex + 1) < arguments.Count)
{
code = Value.GetVersion(
arguments[argumentIndex + 1], interpreter.CultureInfo,
ref version, ref result);
}
if (code == ReturnCode.Ok)
{
code = interpreter.PresentPackage(
arguments[argumentIndex], version, exact, ref result);
}
}
else
{
if ((argumentIndex != Index.Invalid) &&
Option.LooksLikeOption(arguments[argumentIndex]))
{
result = OptionDictionary.BadOption(options, arguments[argumentIndex]);
}
else
{
result = "wrong # args: should be \"package present ?-exact? package ?version?\"";
}
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"package present ?-exact? package ?version?\"";
code = ReturnCode.Error;
}
break;
}
case "provide":
{
if ((arguments.Count == 3) || (arguments.Count == 4))
{
PackageFlags flags = interpreter.PackageFlags;
if (!FlagOps.HasFlags(flags, PackageFlags.NoProvide, true))
{
Version version = null;
if (arguments.Count == 4)
{
code = Value.GetVersion(arguments[3], interpreter.CultureInfo, ref version, ref result);
}
if (code == ReturnCode.Ok)
{
code = interpreter.PkgProvide(arguments[2], version, flags, ref result);
}
}
else
{
//
// HACK: Do nothing, provide no package, and return nothing.
//
result = String.Empty;
code = ReturnCode.Ok;
}
}
else
{
result = "wrong # args: should be \"package provide package ?version?\"";
code = ReturnCode.Error;
}
break;
}
case "relativefilename":
{
if ((arguments.Count == 3) || (arguments.Count == 4))
{
PathComparisonType pathComparisonType = PathComparisonType.Default;
if (arguments.Count == 4)
{
object enumValue = EnumOps.TryParseFlagsEnum(
interpreter, typeof(PathComparisonType),
pathComparisonType.ToString(), arguments[3],
interpreter.CultureInfo, true, true, true,
ref result);
if (enumValue is EventFlags)
{
pathComparisonType = (PathComparisonType)enumValue;
}
else
{
code = ReturnCode.Error;
}
}
if (code == ReturnCode.Ok)
{
string fileName = null;
code = PackageOps.GetRelativeFileName(
interpreter, arguments[2], pathComparisonType,
ref fileName, ref result);
if (code == ReturnCode.Ok)
{
result = fileName;
}
}
}
else
{
result = "wrong # args: should be \"package relativefilename fileName ?type?\"";
code = ReturnCode.Error;
}
break;
}
case "require":
{
if (arguments.Count >= 3)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-exact", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null)
});
int argumentIndex = Index.Invalid;
code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, false, ref argumentIndex, ref result);
if (code == ReturnCode.Ok)
{
if ((argumentIndex != Index.Invalid) && ((argumentIndex + 2) >= arguments.Count))
{
bool exact = false;
if (options.IsPresent("-exact"))
{
exact = true;
}
Version version = null;
if ((argumentIndex + 1) < arguments.Count)
{
code = Value.GetVersion(
arguments[argumentIndex + 1], interpreter.CultureInfo,
ref version, ref result);
}
if (code == ReturnCode.Ok)
{
code = interpreter.RequirePackage(
arguments[argumentIndex], version, exact, ref result);
}
//
// NOTE: This is a new feature. If the initial attempt to
// require a package fails, call the package fallback
// delegate for the interpreter and then try requiring
// the package again.
//
if ((code != ReturnCode.Ok) && !ScriptOps.HasFlags(
interpreter, InterpreterFlags.NoPackageFallback, true))
{
PackageCallback packageFallback = interpreter.PackageFallback;
if (packageFallback != null)
{
code = packageFallback(
interpreter, arguments[argumentIndex], version, null,
interpreter.PackageFlags, exact, ref result);
if (code == ReturnCode.Ok)
{
code = interpreter.RequirePackage(
arguments[argumentIndex], version, exact, ref result);
}
}
}
//
// BUGFIX: This is really a new feature. In the event of a failure
// here, we now fallback to the "unknown package handler",
// just like Tcl does.
//
if ((code != ReturnCode.Ok) && !ScriptOps.HasFlags(
interpreter, InterpreterFlags.NoPackageUnknown, true))
{
string text = interpreter.PackageUnknown + Characters.Space +
Parser.Quote(arguments[argumentIndex]);
if (version != null)
{
text += Characters.Space + Parser.Quote(version.ToString());
}
code = interpreter.EvaluateScript(text, ref result); /* EXEMPT */
if (code == ReturnCode.Ok)
{
code = interpreter.RequirePackage(
arguments[argumentIndex], version, exact, ref result);
}
}
}
else
{
if ((argumentIndex != Index.Invalid) &&
Option.LooksLikeOption(arguments[argumentIndex]))
{
result = OptionDictionary.BadOption(options, arguments[argumentIndex]);
}
else
{
result = "wrong # args: should be \"package require ?-exact? package ?version?\"";
}
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"package require ?-exact? package ?version?\"";
code = ReturnCode.Error;
}
break;
}
case "reset":
{
if (arguments.Count == 2)
{
code = interpreter.ResetPkgIndexes(ref result);
if (code == ReturnCode.Ok)
{
result = String.Empty;
}
}
else
{
result = "wrong # args: should be \"package reset\"";
code = ReturnCode.Error;
}
break;
}
case "scan":
{
if (arguments.Count >= 2)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-interpreter", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-preferfilesystem", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-preferhost", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-host", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-normal", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-nonormal", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-recursive", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-resolve", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-refresh", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-autopath", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null)
});
int argumentIndex = Index.Invalid;
if (arguments.Count > 2)
{
code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, true, ref argumentIndex, ref result);
}
else
{
code = ReturnCode.Ok;
}
if (code == ReturnCode.Ok)
{
lock (interpreter.SyncRoot) /* TRANSACTIONAL */
{
PackageIndexFlags flags;
if (options.IsPresent("-interpreter"))
{
flags = interpreter.PackageIndexFlags;
}
else
{
flags = PackageIndexFlags.Default;
}
if (options.IsPresent("-preferfilesystem"))
{
flags |= PackageIndexFlags.PreferFileSystem;
}
if (options.IsPresent("-preferhost"))
{
flags |= PackageIndexFlags.PreferHost;
}
if (options.IsPresent("-host"))
{
flags |= PackageIndexFlags.Host;
}
if (options.IsPresent("-normal"))
{
flags |= PackageIndexFlags.Normal;
}
if (options.IsPresent("-nonormal"))
{
flags |= PackageIndexFlags.NoNormal;
}
if (options.IsPresent("-recursive"))
{
flags |= PackageIndexFlags.Recursive;
}
if (options.IsPresent("-refresh"))
{
flags |= PackageIndexFlags.Refresh;
}
if (options.IsPresent("-resolve"))
{
flags |= PackageIndexFlags.Resolve;
}
bool autoPath = false;
if (options.IsPresent("-autopath"))
{
autoPath = true;
}
StringList paths;
if (argumentIndex != Index.Invalid)
{
//
// NOTE: Refresh the specified path list.
//
paths = new StringList(arguments, argumentIndex);
}
else
{
//
// NOTE: Refresh the default path list.
//
paths = GlobalState.GetAutoPathList(interpreter, autoPath);
//
// NOTE: Did they request the auto-path be rebuilt?
//
if (autoPath)
{
//
// NOTE: Since the actual auto-path may have changed,
// update the variable now. We disable traces
// here because we manually rescan, if necessary,
// below.
//
code = interpreter.SetLibraryVariableValue(
VariableFlags.SkipTrace, TclVars.AutoPath,
(paths != null) ? paths.ToString() : null,
ref result);
}
}
if (code == ReturnCode.Ok)
{
PackageIndexDictionary packageIndexes = interpreter.CopyPackageIndexes();
if (code == ReturnCode.Ok)
{
code = PackageOps.FindAll(
interpreter, paths, flags, ref packageIndexes,
ref result);
}
if (code == ReturnCode.Ok)
{
interpreter.PackageIndexes = packageIndexes;
result = String.Empty;
}
}
}
}
}
else
{
result = "wrong # args: should be \"package scan ?options? ?dir dir ...?\"";
code = ReturnCode.Error;
}
break;
}
case "unknown":
{
if ((arguments.Count == 2) || (arguments.Count == 3))
{
if (arguments.Count == 3)
{
interpreter.PackageUnknown = arguments[2];
result = String.Empty;
}
else
{
result = interpreter.PackageUnknown;
}
code = ReturnCode.Ok;
}
else
{
result = "wrong # args: should be \"package unknown ?command?\"";
code = ReturnCode.Error;
}
break;
}
case "vcompare":
{
if (arguments.Count == 4)
{
Version version1 = null;
code = Value.GetVersion(
arguments[2], interpreter.CultureInfo,
ref version1, ref result);
Version version2 = null;
if (code == ReturnCode.Ok)
{
code = Value.GetVersion(
arguments[3], interpreter.CultureInfo,
ref version2, ref result);
}
if (code == ReturnCode.Ok)
{
result = PackageOps.VersionCompare(version1, version2);
}
}
else
{
result = "wrong # args: should be \"package vcompare version1 version2\"";
code = ReturnCode.Error;
}
break;
}
case "versions":
{
if (arguments.Count == 3)
{
code = interpreter.PkgVersions(
arguments[2], ref result);
}
else
{
result = "wrong # args: should be \"package versions package\"";
code = ReturnCode.Error;
}
break;
}
case "vloaded":
{
if ((arguments.Count == 2) || (arguments.Count == 3))
{
string pattern = null;
if (arguments.Count == 3)
{
pattern = arguments[2];
}
code = interpreter.PkgLoaded(
pattern, false, true, ref result);
}
else
{
result = "wrong # args: should be \"package vloaded ?pattern?\"";
code = ReturnCode.Error;
}
break;
}
case "vsatisfies":
{
if (arguments.Count == 4)
{
PackageFlags flags = interpreter.PackageFlags;
if (!FlagOps.HasFlags(flags, PackageFlags.AlwaysSatisfy, true))
{
Version version1 = null;
code = Value.GetVersion(arguments[2], interpreter.CultureInfo, ref version1, ref result);
Version version2 = null;
if (code == ReturnCode.Ok)
{
code = Value.GetVersion(
arguments[3], interpreter.CultureInfo,
ref version2, ref result);
}
if (code == ReturnCode.Ok)
{
result = PackageOps.VersionSatisfies(
version1, version2, false);
}
}
else
{
//
// HACK: Always fake that this was a satisfied package request.
//
result = true;
code = ReturnCode.Ok;
}
}
else
{
result = "wrong # args: should be \"package vsatisfies version1 version2\"";
code = ReturnCode.Error;
}
break;
}
case "withdraw":
{
if ((arguments.Count == 3) || (arguments.Count == 4))
{
Version version = null;
if (arguments.Count == 4)
{
code = Value.GetVersion(
arguments[3], interpreter.CultureInfo,
ref version, ref result);
}
if (code == ReturnCode.Ok)
{
code = interpreter.WithdrawPackage(
arguments[2], version, ref result);
}
}
else
{
result = "wrong # args: should be \"package withdraw package ?version?\"";
code = ReturnCode.Error;
}
break;
}
default:
{
result = ScriptOps.BadSubCommand(
interpreter, null, null, subCommand, this, null, null);
code = ReturnCode.Error;
break;
}
}
}
}
else
{
result = "wrong # args: should be \"package arg ?arg ...?\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
public bool HasFlags(PackageFlags flags) => Summary.PackageFlags.HasFlag(flags);
public override string ToString()
{
return($"Version={Version}/{LicenseeVersion}, Group={PackageGroup}, Flags={PackageFlags.ToString().Replace(", ", "|")}");
}
private bool DeserializeHeader(ObjectReader header)
{
// Not a PCC file.
if (header.ReadUInt32() != 0x9E2A83C1)
return false;
// Unsupported unreal engine version
if (header.ReadUInt16() != 0x02AC || header.ReadUInt16() != 0xC2)
return false;
_unkn1 = header.ReadUInt32();
_folderName = header.ReadString();
PackageFlags = (PackageFlags)header.ReadUInt32();
_unknDummy = header.ReadUInt32();
_nameCount = header.ReadInt32();
_nameOffset = header.ReadUInt32();
_exportCount = header.ReadInt32();
_exportOffset = header.ReadUInt32();
_importCount = header.ReadInt32();
_importOffset = header.ReadUInt32();
_unkn2 = header.ReadUInt32(); // Both of these often match _unkn1.
_unkn3 = header.ReadUInt32(); // UnHood references "first export offset", cant see that working here?
header.ReadRawData(12); // seemingly 0's
_GUID_A = header.ReadUInt32();
_GUID_B = header.ReadUInt32();
_GUID_C = header.ReadUInt32();
_GUID_D = header.ReadUInt32();
_generations = header.ReadUInt32();
header.ReadRawData(4); // Copy of export count?
header.ReadRawData(4); // Copy of name count?
header.ReadRawData(4); // Another 0
// Engine version mis-match
if (header.ReadUInt32() != 0x18EF)
return false;
// Cooker version mis-match
if (header.ReadUInt32() != 0x3006B)
return false;
_unkn4 = header.ReadUInt32(); // Seems to be the same for all files.
_unkn5 = header.ReadUInt32(); // Same as above, UnHood possibly refers to this as package flags, old remnants?
_compressionFlag = (FileCompressionFlags)header.ReadUInt32();
_chunkCount = header.ReadUInt32();
// TODO: support compressed files..
return true;
}
