private static RantPackage LoadOldPackage(EasyReader reader)
{
int numPatterns = reader.ReadInt32();
int numTables = reader.ReadInt32();
if (numPatterns < 0 || numTables < 0)
{
throw new InvalidDataException("File is corrupt.");
}
var pkg = new RantPackage();
// Patterns
for (int i = 0; i < numPatterns; i++)
{
var name = reader.ReadString();
var code = reader.ReadString();
pkg.AddPattern(new RantPattern(name, RantPatternOrigin.String, code));
}
// Tables
for (int i = 0; i < numTables; i++)
{
var name = reader.ReadString();
var subs = reader.ReadStringArray();
int numEntries = reader.ReadInt32();
var hiddenClasses = reader.ReadStringArray();
var entries = new RantDictionaryEntry[numEntries];
for (int j = 0; j < numEntries; j++)
{
int weight = reader.ReadInt32();
bool flags = reader.ReadBoolean(); // unused
int numTerms = reader.ReadInt32();
var terms = new RantDictionaryTerm[numTerms];
for (int k = 0; k < numTerms; k++)
{
var value = reader.ReadString();
var pron = reader.ReadString();
terms[k] = new RantDictionaryTerm(value, pron);
}
var classes = reader.ReadStringArray();
entries[j] = new RantDictionaryEntry(terms, classes, weight);
}
pkg.AddTable(new RantDictionaryTable(name, subs, entries, hiddenClasses));
}
return(pkg);
}
/// <summary>
/// Attempts to resolve a depdendency to the appropriate package.
/// </summary>
/// <param name="depdendency">The depdendency to resolve.</param>
/// <param name="package">The package loaded from the depdendency.</param>
/// <returns></returns>
public virtual bool TryResolvePackage(RantPackageDependency depdendency, out RantPackage package)
{
package = null;
string path = Path.Combine(Environment.CurrentDirectory, $"{depdendency.ID}.rantpkg");
if (!File.Exists(path))
{
RantPackageVersion version;
// Fallback to name with version appended
#if UNITY
path = Directory.GetFiles(Environment.CurrentDirectory, $"{depdendency.ID}*.rantpkg", SearchOption.AllDirectories).FirstOrDefault(p =>
#else
path =
Directory.EnumerateFiles(Environment.CurrentDirectory, "*.rantpkg", SearchOption.AllDirectories)
.FirstOrDefault(p =>
#endif
{
var match = FallbackRegex.Match(Path.GetFileNameWithoutExtension(p));
if (!match.Success)
{
return(false);
}
version = RantPackageVersion.Parse(match.Groups["version"].Value);
return(depdendency.AllowNewer && version >= depdendency.Version || depdendency.Version == version);
});
if (path == null)
{
return(false);
}
}
try
{
var pkg = RantPackage.Load(path);
if (pkg.ID != depdendency.ID)
{
return(false);
}
if (depdendency.AllowNewer && pkg.Version >= depdendency.Version || pkg.Version == depdendency.Version)
{
package = pkg;
return(true);
}
return(false);
}
catch
{
return(false);
}
}
/// <summary>
/// Loads a package from the specified stream and returns it as a RantPackage object.
/// </summary>
/// <param name="source">The stream to load the package data from.</param>
/// <returns></returns>
public static RantPackage Load(Stream source)
{
using (var reader = new EasyReader(source))
{
string magic = Encoding.ASCII.GetString(reader.ReadBytes(4));
if (magic != MAGIC)
{
throw new InvalidDataException(GetString("err-file-corrupt"));
}
ushort version = reader.ReadUInt16();
if (version != PACKAGE_FORMAT_VERSION)
{
throw new InvalidDataException(GetString("err-invalid-package-version", version));
}
bool compress = reader.ReadBoolean();
var package = new RantPackage();
package.Title = reader.ReadString();
package.ID = reader.ReadString();
package.Description = reader.ReadString();
package.Tags = reader.ReadStringArray();
package.Authors = reader.ReadStringArray();
int vmaj = reader.ReadInt32();
int vmin = reader.ReadInt32();
int vrev = reader.ReadInt32();
package.Version = new RantPackageVersion(vmaj, vmin, vrev);
int depCount = reader.ReadInt32();
for (int i = 0; i < depCount; i++)
{
var depId = reader.ReadString();
int depVerMaj = reader.ReadInt32();
int depVerMin = reader.ReadInt32();
int depVerRev = reader.ReadInt32();
bool depAllowNewer = reader.ReadBoolean();
package.AddDependency(new RantPackageDependency(depId, new RantPackageVersion(depVerMaj, depVerMin, depVerRev))
{
AllowNewer = depAllowNewer
});
}
int resCount = reader.ReadInt32();
if (compress)
{
using (var decompressStream = new DeflateStream(reader.BaseStream, CompressionMode.Decompress, true))
{
for (int i = 0; i < resCount; i++)
{
package._resources.Add(RantResource.DeserializeResource(new EasyReader(decompressStream, true)));
}
}
}
else
{
for (int i = 0; i < resCount; i++)
{
package._resources.Add(RantResource.DeserializeResource(reader));
}
}
return(package);
}
}
/// <summary>
/// Loads a package from the specified stream and returns it as a RantPackage object.
/// </summary>
/// <param name="source">The stream to load the package data from.</param>
/// <returns></returns>
public static RantPackage Load(Stream source)
{
using (var reader = new EasyReader(source))
{
var magic = Encoding.ASCII.GetString(reader.ReadBytes(4));
if (magic == OLD_MAGIC)
{
return(LoadOldPackage(reader));
}
if (magic != MAGIC)
{
throw new InvalidDataException("File is corrupt.");
}
var package = new RantPackage();
var version = reader.ReadUInt32();
if (version != PACKAGE_VERSION)
{
throw new InvalidDataException("Invalid package version: " + version);
}
var compress = reader.ReadBoolean();
var size = reader.ReadInt32();
var data = reader.ReadBytes(size);
if (compress)
{
data = EasyCompressor.Decompress(data);
}
var doc = BsonDocument.Read(data);
var info = doc["info"];
if (info == null)
{
throw new InvalidDataException("Metadata is missing from package.");
}
package.Title = info["title"];
package.ID = info["id"];
package.Version = RantPackageVersion.Parse(info["version"]);
package.Description = info["description"];
package.Authors = (string[])info["authors"];
package.Tags = (string[])info["tags"];
var deps = info["dependencies"];
if (deps != null && deps.IsArray)
{
for (int i = 0; i < deps.Count; i++)
{
var dep = deps[i];
var depId = dep["id"].Value;
var depVersion = dep["version"].Value;
bool depAllowNewer = (bool)dep["allow-newer"].Value;
package.AddDependency(new RantPackageDependency(depId.ToString(), depVersion.ToString())
{
AllowNewer = depAllowNewer
});
}
}
var patterns = doc["patterns"];
if (patterns != null)
{
var names = patterns.Keys;
foreach (string name in names)
{
package.AddPattern(new RantPattern(name, RantPatternOrigin.File, patterns[name]));
}
}
var tables = doc["tables"];
if (tables != null)
{
var names = tables.Keys;
foreach (string name in names)
{
var table = tables[name];
string tableName = table["name"];
string[] tableSubs = (string[])table["subs"];
string[] hiddenClasses = (string[])table["hidden"];
var entries = new List <RantDictionaryEntry>();
var entryList = table["entries"];
for (var i = 0; i < entryList.Count; i++)
{
var loadedEntry = entryList[i];
int weight = 1;
if (loadedEntry.HasKey("weight"))
{
weight = (int)loadedEntry["weight"].Value;
}
string[] requiredClasses = (string[])loadedEntry["classes"];
string[] optionalClasses = (string[])loadedEntry["optional_classes"];
var terms = new List <RantDictionaryTerm>();
var termList = loadedEntry["terms"];
for (var j = 0; j < termList.Count; j++)
{
var t = new RantDictionaryTerm(termList[j]["value"], termList[j]["pron"]);
terms.Add(t);
}
var entry = new RantDictionaryEntry(
terms.ToArray(),
requiredClasses.Concat(optionalClasses.Select(x => x + "?")),
weight
);
entries.Add(entry);
}
var rantTable = new RantDictionaryTable(
tableName,
tableSubs,
entries,
hiddenClasses
);
package.AddTable(rantTable);
}
}
return(package);
}
}
