/// <summary>
/// Loads provided data file
/// </summary>
/// <param name="filename"></param>
private void _LoadXmb(string filename)
{
_Data = new Xmb {
Name = filename
};
_Data.Read();
}
public void PackageDeserialization()
{
XDocument doc;
using (var stream = File.OpenRead("ocean.exml"))
{
doc = new Xmb(new BinaryReader(stream)).Document;
}
var pkg = PackageService.Open(doc.Root);
Assert.Equal("ocean", pkg.Name);
Assert.NotNull(pkg.Objects);
Assert.True(pkg.Objects.Count() == 6);
Assert.IsType <SQEX.Ebony.Object>(pkg.Objects.First());
if (pkg.Objects.First() is SQEX.Ebony.Object obj)
{
Assert.Equal(0, obj.ObjectIndex);
Assert.Equal("ocean", obj.Name);
Assert.Equal("SQEX.Ebony.Framework.Entity.EntityPackageReference", obj.Type);
Assert.Equal("", obj.Path);
Assert.True(obj.Checked);
Assert.NotNull(obj.Item);
Assert.IsType <SQEX.Ebony.Framework.Entity.EntityPackageReference>(obj.Item);
if (obj.Item is SQEX.Ebony.Framework.Entity.EntityPackageReference entityPackage)
{
Assert.Equal("environment/world/ebex/ocean.ebex", entityPackage.SourcePath);
Assert.Equal(0.0f, entityPackage.Position.x);
Assert.Equal(1.0f, entityPackage.Position.w);
Assert.Equal(5, entityPackage.Entities.Count);
}
}
Assert.IsType <SQEX.Ebony.Object>(pkg.Objects.Skip(1).First());
if (pkg.Objects.Skip(1).First() is SQEX.Ebony.Object obj2)
{
Assert.Equal(1, obj2.ObjectIndex);
Assert.Equal("sea00", obj2.Name);
Assert.Equal("entities_", obj2.OwnerPath);
Assert.Equal("entities_.sea00", obj2.Path);
Assert.Equal("Black.Entity.StaticModelEntity", obj2.Type);
Assert.NotNull(obj2.Item);
Assert.IsType <Black.Entity.StaticModelEntity>(obj2.Item);
if (obj2.Item is Black.Entity.StaticModelEntity staticModelEntity)
{
Assert.Equal(-2416.375, staticModelEntity.Position.x, 3);
Assert.Equal(0, staticModelEntity.Position.y, 3);
Assert.Equal(-3046.105, staticModelEntity.Position.z, 3);
Assert.Equal(1, staticModelEntity.Position.w, 3);
Assert.Equal("environment/world/props/pond_water01/models/pond_water01_A.gmdl", staticModelEntity.SourcePath);
Assert.True(staticModelEntity.Visible);
}
}
}
public async Task SongInfoWriteTest(string binName, string xmlName)
{
using FileStream outStream = new FileStream(binName, FileMode.Create, FileAccess.Write);
Xmb xmb = new Xmb();
using FileStream stream = new FileStream(xmlName, FileMode.Open, FileAccess.Read);
xmb.ReadXml(stream);
await xmb.WriteXmb(outStream);
}
public void SongInfoReadTest(string binName, string xmlName)
{
using FileStream outStream = new FileStream(xmlName, FileMode.Create, FileAccess.Write);
Xmb xmb = new Xmb();
using FileStream stream = new FileStream(binName, FileMode.Open, FileAccess.Read);
xmb.ReadXmb(stream);
xmb.WriteXml(outStream);
}
private void Compare(Xmb expected, Xmb actual)
{
AssertEqual(expected.Elements, actual.Elements, AssertEqual);
AssertEqual(expected.Attributes, actual.Attributes, AssertEqual);
AssertEqual(expected.Variants, actual.Variants, AssertEqual);
AssertEqual(expected.ElementIndexTable, actual.ElementIndexTable, AssertEqual);
AssertEqual(expected.AttributeIndexTable, actual.AttributeIndexTable, AssertEqual);
AssertEqual(expected.StringData, actual.StringData, AssertEqual);
}
public void XmbPerformanceTest(string fileName)
{
Xmb xmbOrigin;
using (var stream = File.OpenRead(fileName))
{
xmbOrigin = new Xmb(new BinaryReader(stream));
}
Compare(xmbOrigin, new Xmb(xmbOrigin.Document));
}
public void XmbEqualityTest(string fileName)
{
XDocument doc;
using (var stream = File.OpenRead(fileName))
{
doc = new Xmb(new BinaryReader(stream)).Document;
}
Compare(doc.Root, new Xmb(doc).Document.Root);
}
private void LoadXmb(string fileName)
{
Xmb xmb;
using (var stream = File.Open(fileName, FileMode.Open))
{
xmb = new Xmb(new BinaryReader(stream));
}
Open(xmb);
}
public void PackageCheckTypesOnDeserialization(string fileName)
{
XDocument doc;
using (var stream = File.OpenRead(fileName))
{
doc = new Xmb(new BinaryReader(stream)).Document;
}
var pkg = PackageService.Open(doc.Root);
}
private void Export(string input, string output)
{
if (IsVerbose)
{
Console.WriteLine(input);
}
XDocument doc;
using (var stream = File.OpenRead(input))
{
doc = new Xmb(new BinaryReader(stream)).Document;
}
using (var stream = File.Create(output))
{
doc.Save(stream);
}
}
public void XmbOptimizationTest()
{
XDocument document;
using (var stream = File.OpenRead("xmb/performance-test1.xml"))
{
document = XDocument.Load(stream);
}
var xmb = new Xmb(document);
Assert.Equal(2, xmb.Elements.Count());
Assert.Equal(2, xmb.Attributes.Count());
Assert.Equal(3, xmb.Variants.Count());
Assert.Equal(2, xmb.ElementIndexTable.Count());
Assert.Equal(2, xmb.AttributeIndexTable.Count());
At(xmb.ElementIndexTable, 0, x => Assert.Equal(0, x));
At(xmb.ElementIndexTable, 1, x => Assert.Equal(0, x));
At(xmb.AttributeIndexTable, 0, x => Assert.Equal(0, x));
At(xmb.AttributeIndexTable, 1, x => Assert.Equal(1, x));
At(xmb.Elements, 0, e =>
{
Assert.Equal("entry", e.Name);
Assert.Equal(0, e.ElementTableIndex);
Assert.Equal(0, e.ElementCount);
Assert.Equal(1, e.AttributeTableIndex);
Assert.Equal(1, e.AttributeCount);
});
At(xmb.Elements, 1, e =>
{
Assert.Equal("not-a-package", e.Name);
Assert.Equal(0, e.ElementTableIndex);
Assert.Equal(2, e.ElementCount);
Assert.Equal(0, e.AttributeTableIndex);
Assert.Equal(1, e.AttributeCount);
});
}
public async Task AddLyrics(string dirName, IProgress <ProgressData> progress = null)
{
DirectoryInfo dInfo = new DirectoryInfo(dirName);
HashSet <string> filenames =
new HashSet <string>(dInfo.GetFiles("*.xml")
.Select(fInfo => fInfo.Name));
string filenameXlsxName = dirName + "/filenames.xlsx";
XlsxReader xlsx = new XlsxReader(filenameXlsxName);
IEnumerable <Record> records = xlsx.GetRows("XX", "filenames")
.Where(record => filenames.Contains((string)record[1]));
int total = records.Count();
int count = 0;
foreach (Record record in records)
{
string entryName = (string)record[0];
string xmlName = dInfo.FullName + '\\' + (string)record[1];
count++;
progress?.Report(new ProgressData {
count = count, total = total, filename = entryName
});
if (!HasFile(entryName))
{
Xmb xmb = new Xmb();
using (FileStream xmlStream = new FileStream(xmlName, FileMode.Open, FileAccess.Read))
{
xmb.ReadXml(xmlStream);
}
ZipArchiveEntry entry = zipArchive.CreateEntry(entryName);
using Stream entryStream = entry.Open();
await xmb.WriteXmb(entryStream);
_entries.Add(new PatchZipEntry(entry));
}
}
}
public void GuessTypeFromValueTest(string value, Xmb.ValueType expected)
{
Assert.Equal(expected, Xmb.GuessTypeFromValue(value));
}
public void XmbAcceptanceTest()
{
XDocument document;
using (var stream = File.OpenRead("xmb/acceptance-test.xml"))
{
document = XDocument.Load(stream);
}
var xmb = new Xmb(document);
At(xmb.Elements, xmb.RootElementIndex, e1 =>
{
Assert.Equal("not-a-package", e1.Name);
Assert.Equal(1, e1.ElementCount);
Assert.Equal(1, e1.AttributeCount);
At(xmb.Variants, e1.VariantOffset, variant =>
{
Assert.Equal(string.Empty, variant.Name);
});
At(xmb.Attributes, xmb.AttributeIndexTable, e1.AttributeTableIndex, attribute =>
{
Assert.Equal("name", attribute.Name);
At(xmb.Variants, attribute.VariantOffset, variant =>
{
Assert.Equal("test", variant.Name);
});
});
At(xmb.Elements, xmb.ElementIndexTable, e1.ElementTableIndex, e2 =>
{
Assert.Equal("items", e2.Name);
Assert.Equal(2, e2.ElementCount);
Assert.Equal(0, e2.AttributeCount);
At(xmb.Variants, e2.VariantOffset, variant =>
{
Assert.Equal(string.Empty, variant.Name);
});
At(xmb.Elements, xmb.ElementIndexTable, e2.ElementTableIndex, e3 =>
{
Assert.Equal("item", e3.Name);
Assert.Equal(0, e3.ElementCount);
Assert.Equal(1, e3.AttributeCount);
At(xmb.Variants, e3.VariantOffset, variant =>
{
Assert.Equal(string.Empty, variant.Name);
});
At(xmb.Attributes, xmb.AttributeIndexTable, e3.AttributeTableIndex, attribute =>
{
Assert.Equal("name", attribute.Name);
At(xmb.Variants, attribute.VariantOffset, variant =>
{
Assert.Equal("item1", variant.Name);
});
});
});
At(xmb.Elements, xmb.ElementIndexTable, e2.ElementTableIndex + 1, e3 =>
{
Assert.Equal("item", e3.Name);
Assert.Equal(0, e3.ElementCount);
Assert.Equal(2, e3.AttributeCount);
At(xmb.Variants, e3.VariantOffset, variant =>
{
Assert.Equal("Value", variant.Name);
});
At(xmb.Attributes, xmb.AttributeIndexTable, e3.AttributeTableIndex, attribute =>
{
Assert.Equal("name", attribute.Name);
At(xmb.Variants, attribute.VariantOffset, variant =>
{
Assert.Equal("item2", variant.Name);
});
});
At(xmb.Attributes, xmb.AttributeIndexTable, e3.AttributeTableIndex + 1, attribute =>
{
Assert.Equal("id", attribute.Name);
At(xmb.Variants, attribute.VariantOffset, variant =>
{
Assert.Equal("1", variant.Name);
});
});
});
});
});
}
public void Open(Xmb xmb)
{
Open(xmb.Document);
}
