public void TestSerializationWithBaseAndParts()
{
// Create an entity as in TestSerialization
// Then create a derivedAsset from it
// Then create a partAsset and add this partAsset as a composition to derivedAsset
// Serialize and deserialize derivedAsset
// Check that deserialized derivedAsset has all base/baseParts correctly serialized
var originAsset = CreateOriginAsset();
var derivedAsset = (PrefabAsset)originAsset.CreateChildAsset("base");
var basePartAsset = new PrefabAsset();
var entityPart1 = new Entity() { Name = "EPart1" };
var entityPart2 = new Entity() { Name = "EPart2" };
basePartAsset.Hierarchy.Entities.Add(entityPart1);
basePartAsset.Hierarchy.Entities.Add(entityPart2);
basePartAsset.Hierarchy.RootEntities.Add(entityPart1.Id);
basePartAsset.Hierarchy.RootEntities.Add(entityPart2.Id);
// Add 2 asset parts from the same base
var instance = basePartAsset.CreatePrefabInstance(derivedAsset, "part");
derivedAsset.Hierarchy.Entities.AddRange(instance.Entities);
derivedAsset.Hierarchy.RootEntities.AddRange(instance.RootEntities);
var instance2 = basePartAsset.CreatePrefabInstance(derivedAsset, "part");
derivedAsset.Hierarchy.Entities.AddRange(instance2.Entities);
derivedAsset.Hierarchy.RootEntities.AddRange(instance2.RootEntities);
using (var stream = new MemoryStream())
{
AssetSerializer.Save(stream, derivedAsset);
stream.Position = 0;
var serializedVersion = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(serializedVersion);
stream.Position = 0;
var newAsset = (PrefabAsset)AssetSerializer.Load(stream, "xkentity");
Assert.NotNull(newAsset.Base);
Assert.NotNull(newAsset.BaseParts);
// We should have only 1 base part, as we created parts from the same base
Assert.AreEqual(1, newAsset.BaseParts.Count);
CheckAsset(derivedAsset, newAsset);
CheckAsset(originAsset, (PrefabAsset)newAsset.Base.Asset);
CheckGenericAsset(basePartAsset, (PrefabAsset)newAsset.BaseParts[0].Asset);
}
}
public void TestMultiplePrefabsInheritanceAndChildren()
{
// The purpose of this test is to check that modifying a prefab base is correctly propagated through all
// derived prefabs. We use the following scenario:
//
// a1: base asset
// a2: inherit from a1 by composition with 2 instances (baseParts: a1 => 2 instances)
// a3: inherit from a1 by composition with 1 instances (baseParts: a1 => 1 instances)
// a4: inherit from a2 and a3 by composition with 1 instances for each (baseParts: a1 => 1 instance, a2 => 1 instance)
//
// Unlike TestMultiplePrefabsMixedInheritance, we use only inheritance by composition for this scenario to match current use cases
var package = new Package();
var assetItems = package.Assets;
// First we create assets with the following configuration:
// a1: a2: (baseParts: a1, 2 instances) a3: (baseParts: a1) a4: (baseParts: a2 x 1, a3 x 1)
// | er | er1 (base: er) | er1' (base: er) | eRoot
// | ea | ea1 (base: ea) | ea1' (base: ea) | er1* (base: er)
// | eb | eb1 (base: eb) | eb1' (base: eb) | ea1* (base: ea)
// | ec | ec1 (base: ec) | ec1' (base: ec) | eb1* (base: eb)
// | er2 (base: er) | ec1* (base: ec)
// | ea2 (base: ea) | er2* (base: er)
// | eb2 (base: eb) | ea2* (base: ea)
// | ec2 (base: ec) | eb2* (base: eb)
// | ec2* (base: ec)
// | er1'* (base: er)
// | ea1'* (base: ea)
// | eb1'* (base: eb)
// | ec1'* (base: ec)
var a1 = new PrefabAsset();
var er = new Entity("er");
var ea = new Entity("ea");
var eb = new Entity("eb");
var ec = new Entity("ec");
a1.Hierarchy.Parts.Add(new EntityDesign(er));
a1.Hierarchy.Parts.Add(new EntityDesign(ea));
a1.Hierarchy.Parts.Add(new EntityDesign(eb));
a1.Hierarchy.Parts.Add(new EntityDesign(ec));
a1.Hierarchy.RootPartIds.Add(er.Id);
er.AddChild(ea);
er.AddChild(eb);
er.AddChild(ec);
assetItems.Add(new AssetItem("a1", a1));
var member = (IMemberDescriptor)TypeDescriptorFactory.Default.Find(typeof(Entity))[nameof(Entity.Name)];
var a2 = new PrefabAsset();
var a2PartInstance1 = a1.CreatePrefabInstance(a2, "a1");
foreach (var entity in a2PartInstance1.Parts)
{
entity.Entity.Name += "1";
}
var a2PartInstance2 = a1.CreatePrefabInstance(a2, "a1");
foreach (var entity in a2PartInstance2.Parts)
{
entity.Entity.Name += "2";
}
a2.Hierarchy.Parts.AddRange(a2PartInstance1.Parts);
a2.Hierarchy.Parts.AddRange(a2PartInstance2.Parts);
a2.Hierarchy.RootPartIds.AddRange(a2PartInstance1.RootPartIds);
a2.Hierarchy.RootPartIds.AddRange(a2PartInstance2.RootPartIds);
Assert.AreEqual(8, a2.Hierarchy.Parts.Count);
Assert.AreEqual(2, a2.Hierarchy.RootPartIds.Count);
assetItems.Add(new AssetItem("a2", a2));
var a3 = new PrefabAsset();
var a3PartInstance1 = a1.CreatePrefabInstance(a3, "a1");
foreach (var entity in a3PartInstance1.Parts)
{
entity.Entity.Name += "1'";
}
a3.Hierarchy.Parts.AddRange(a3PartInstance1.Parts);
a3.Hierarchy.RootPartIds.AddRange(a3PartInstance1.RootPartIds);
Assert.AreEqual(4, a3.Hierarchy.Parts.Count);
Assert.AreEqual(1, a3.Hierarchy.RootPartIds.Count);
assetItems.Add(new AssetItem("a3", a3));
var a4 = new PrefabAsset();
var eRoot = new Entity("eRoot");
var a2PartInstance3 = a2.CreatePrefabInstance(a4, "a2");
foreach (var entity in a2PartInstance3.Parts)
{
entity.Entity.Name += "*";
}
foreach (var entity in a2PartInstance3.Parts.Where(t => a2PartInstance3.RootPartIds.Contains(t.Entity.Id)))
{
eRoot.AddChild(entity.Entity);
}
var a3PartInstance2 = a3.CreatePrefabInstance(a4, "a3");
foreach (var entity in a3PartInstance2.Parts)
{
entity.Entity.Name += "*";
}
a4.Hierarchy.Parts.Add(new EntityDesign(eRoot));
a4.Hierarchy.Parts.AddRange(a2PartInstance3.Parts);
a4.Hierarchy.Parts.AddRange(a3PartInstance2.Parts);
a4.Hierarchy.RootPartIds.Add(eRoot.Id);
a4.Hierarchy.RootPartIds.AddRange(a3PartInstance2.RootPartIds);
Assert.AreEqual(13, a4.Hierarchy.Parts.Count);
Assert.AreEqual(2, a4.Hierarchy.RootPartIds.Count);
assetItems.Add(new AssetItem("a4", a4));
Assert.True(a1.DumpTo(Console.Out, "a1 BEFORE PrefabMergeAsset"));
Assert.True(a2.DumpTo(Console.Out, "a2 BEFORE PrefabMergeAsset"));
Assert.True(a3.DumpTo(Console.Out, "a3 BEFORE PrefabMergeAsset"));
Assert.True(a4.DumpTo(Console.Out, "a4 BEFORE PrefabMergeAsset"));
// Then we simulate a concurrent change to a1 by someone that didn't have a2/a3/a4
// - Add one component to a1, linking to an existing entity ea
// - Add a root entity to a1 with a link to an existing entity eb
//
// a1: a2: (baseParts: a1, 2 instances) a3: (baseParts: a1) a4: (baseParts: a2 x 1, a3 x 1)
// | er | er1 (base: er) | er1' (base: er) | eRoot
// | ea | ea1 (base: ea) | ea1' (base: ea) | er1* (base: er)
// | eb | eb1 (base: eb) | eb1' (base: eb) | ea1* (base: ea)
// | ec + link ea | ec1 + link ea1 (base: ec) | ec1' + link ea1' (base: ec) | eb1* (base: eb)
// | ex | er2 (base: er) | ex(1') (base: ex) | ec1* + link ea1* (base: ec)
// | ey + link eb | ea2 (base: ea) | ey(1') + link eb1' | er2* (base: er)
// | eb2 (base: eb) | ea2* (base: ea)
// | ec2 + link ea2 (base: ec) | eb2* (base: eb)
// | ex(1) | ec2* + link ea2* (base: ec)
// | ey(1) + link eb1 | er1'* (base: er)
// | ex(2) | ea1'* (base: ea)
// | ey(2) + link eb2 | eb1'* (base: eb)
// | ec1'* + link ea1'* (base: ec)
// | ex(1*)
// | ey(1*) + link eb1*
// | ex(2*)
// | ey(2*) + link eb2*
// | ex(1') (base: ex)
// | ey(1') + link eb1'*
ec.Components.Add(new TestEntityComponent() { EntityLink = ea });
var ex = new Entity("ex");
var ey = new Entity("ey");
ey.Components.Add(new TestEntityComponent() { EntityLink = eb });
ex.AddChild(ey);
a1.Hierarchy.Parts.Add(new EntityDesign(ex));
a1.Hierarchy.Parts.Add(new EntityDesign(ey));
a1.Hierarchy.RootPartIds.Add(ex.Id);
Assert.AreEqual(6, a1.Hierarchy.Parts.Count);
Assert.AreEqual(2, a1.Hierarchy.RootPartIds.Count);
// Simulates the loading of this package
using (var session = new PackageSession())
{
var logger = new LoggerResult();
session.AddExistingPackage(package, logger);
Assert.False(logger.HasErrors);
Assert.True(a1.DumpTo(Console.Out, "a1 AFTER PrefabMergeAsset"));
// ------------------------------------------------
// Check for a2
// ------------------------------------------------
// a2: (baseParts: a1, 2 instances)
// | er1 (base: er)
// | ea1 (base: ea)
// | eb1 (base: eb)
// | ec1 + link ea1 (base: ec)
// | er2 (base: er)
// | ea2 (base: ea)
// | eb2 (base: eb)
// | ec2 + link ea2 (base: ec)
// | ex(1)
// | ey(1) + link eb1
// | ex(2)
// | ey(2) + link eb2
{
Assert.True(a2.DumpTo(Console.Out, "a2 AFTER PrefabMergeAsset"));
Assert.AreEqual(4, a2.Hierarchy.RootPartIds.Count);
Assert.True(a2.Hierarchy.Parts.All(it => it.Base != null));
// Check that we have all expected entities
Assert.AreEqual(12, a2.Hierarchy.Parts.Count);
var eb1 = a2.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "eb1")?.Entity;
var eb2 = a2.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "eb2")?.Entity;
Assert.NotNull(eb1);
Assert.NotNull(eb2);
// Check that we have ex and ey
var exList = a2.Hierarchy.Parts.Where(it => it.Entity.Name == ex.Name).ToList();
Assert.AreEqual(2, exList.Count);
// Check that both [ex] have both 1 element [ey] and the links to eb1/eb2 are correct
{
var expecting = new List<Entity>() { eb1, eb2 };
for (int i = 0; i < exList.Count; i++)
{
var ex1 = exList[i].Entity;
Assert.AreEqual(1, ex1.Transform.Children.Count);
var ey1 = ex1.Transform.Children[0].Entity;
Assert.AreEqual(ey.Name, ey1.Name);
Assert.NotNull(ey1.Get<TestEntityComponent>());
var entityLink = ey1.Get<TestEntityComponent>().EntityLink;
Assert.True(expecting.Contains(entityLink));
expecting.Remove(entityLink);
}
}
// Check link from ec1 to ea1
{
var ec1 = a2.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "ec1")?.Entity;
Assert.NotNull(ec1);
var ea1 = a2.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "ea1")?.Entity;
Assert.NotNull(ea1);
Assert.NotNull(ec1.Get<TestEntityComponent>());
Assert.AreEqual(ea1, ec1.Get<TestEntityComponent>().EntityLink);
}
// Check link from ec2 to ea2
{
var ec2 = a2.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "ec2")?.Entity;
Assert.NotNull(ec2);
var ea2 = a2.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "ea2")?.Entity;
Assert.NotNull(ea2);
Assert.NotNull(ec2.Get<TestEntityComponent>());
Assert.AreEqual(ea2, ec2.Get<TestEntityComponent>().EntityLink);
}
}
// ------------------------------------------------
// Check for a3
// ------------------------------------------------
// a3: (baseParts: a1)
// | er1' (base: er)
// | ea1' (base: ea)
// | eb1' (base: eb)
// | ec1' + link ea1' (base: ec)
// | ex1' (base: ex)
// | ey1' + link eb1'
{
Assert.True(a3.DumpTo(Console.Out, "a3 AFTER PrefabMergeAsset"));
Assert.AreEqual(2, a3.Hierarchy.RootPartIds.Count);
Assert.True(a3.Hierarchy.Parts.All(it => it.Base != null));
// Check that we have all expected entities
Assert.AreEqual(6, a3.Hierarchy.Parts.Count);
var eb1 = a3.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "eb1'")?.Entity;
Assert.NotNull(eb1);
// Check that we have ex and ey
var exList = a3.Hierarchy.Parts.Where(it => it.Entity.Name == ex.Name).ToList();
Assert.AreEqual(1, exList.Count);
// Check that [ex] have 1 element [ey] and the link to eb1 is correct
{
var ex1 = exList[0].Entity;
Assert.AreEqual(1, ex1.Transform.Children.Count);
var ey1 = ex1.Transform.Children[0].Entity;
Assert.AreEqual(ey.Name, ey1.Name);
Assert.NotNull(ey1.Get<TestEntityComponent>());
Assert.AreEqual(eb1, ey1.Get<TestEntityComponent>().EntityLink);
}
{
var ec1 = a3.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "ec1'")?.Entity;
Assert.NotNull(ec1);
var ea1 = a3.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "ea1'")?.Entity;
Assert.NotNull(ea1);
Assert.NotNull(ec1.Get<TestEntityComponent>());
Assert.AreEqual(ea1, ec1.Get<TestEntityComponent>().EntityLink);
}
}
// ------------------------------------------------
// Check for a4
// ------------------------------------------------
// a4: (baseParts: a2 x 1, a3 x 1)
// | eNewRoot
// | er1* (base: er)
// | ea1* (base: ea)
// | eb1* (base: eb)
// | ec1* + link ea1* (base: ec)
// | er2* (base: er)
// | ea2* (base: ea)
// | eb2* (base: eb)
// | ec2* + link ea2* (base: ec)
// | er1'* (base: er)
// | ea1'* (base: ea)
// | eb1'* (base: eb)
// | ec1'* + link ea1'* (base: ec)
// | ex(1*)
// | ey(1*) + link eb1*
// | ex(2*)
// | ey(2*) + link eb2*
// | ex(1') (base: ex)
// | ey(1') + link eb1'*
{
Assert.True(a4.DumpTo(Console.Out, "a4 AFTER PrefabMergeAsset"));
Assert.AreEqual(5, a4.Hierarchy.RootPartIds.Count);
Assert.True(a4.Hierarchy.Parts.Where(it => it.Entity.Name != "eRoot").All(it => it.Entity.Name != "eRoot" && it.Base != null));
// Check that we have all expected entities
Assert.AreEqual(19, a4.Hierarchy.Parts.Count);
var eb1 = a4.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "eb1*")?.Entity;
var eb1_2 = a4.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "eb1'*")?.Entity;
var eb2 = a4.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "eb2*")?.Entity;
Assert.NotNull(eb1);
Assert.NotNull(eb1_2);
Assert.NotNull(eb2);
// Check that we have ex and ey
var exList = a4.Hierarchy.Parts.Where(it => it.Entity.Name == ex.Name).ToList();
Assert.AreEqual(3, exList.Count);
// Check that both [ex] have both 1 element [ey] and the links to eb1/eb2 are correct
{
var expecting = new List<Entity>() { eb1, eb1_2, eb2 };
for (int i = 0; i < exList.Count; i++)
{
var ex1 = exList[i].Entity;
Assert.AreEqual(1, ex1.Transform.Children.Count);
var ey1 = ex1.Transform.Children[0].Entity;
Assert.AreEqual(ey.Name, ey1.Name);
Assert.NotNull(ey1.Get<TestEntityComponent>());
var entityLink = ey1.Get<TestEntityComponent>().EntityLink;
Assert.True(expecting.Contains(entityLink));
expecting.Remove(entityLink);
}
}
// Check all [er] entities
Action<string> checkErX = (erName) =>
{
var er1 = a4.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == erName)?.Entity;
Assert.NotNull(er1);
Assert.AreEqual(3, er1.Transform.Children.Count);
var ec1 = er1.Transform.Children.FirstOrDefault(it => it.Entity.Name.StartsWith("ec"))?.Entity;
Assert.NotNull(ec1);
var ea1 = er1.Transform.Children.FirstOrDefault(it => it.Entity.Name.StartsWith("ea"))?.Entity;
Assert.NotNull(ea1);
Assert.NotNull(ec1.Get<TestEntityComponent>());
Assert.AreEqual(ea1, ec1.Get<TestEntityComponent>().EntityLink);
};
checkErX("er1*");
checkErX("er2*");
checkErX("er1'*");
}
}
}
public void TestMultiplePrefabsMixedInheritance()
{
// The purpose of this test is to check that modifying a prefab base is correctly propagated through all
// derived prefabs. We use the following scenario:
// a1: base asset)
// a2: inherit from a1 by composition with 2 instances (baseParts: a1, 2 instances)
// a3: direct inheritance from a2 (base: a2)
// This scenario doesn't happen in practice, as we have restricted only to inheritance by composition for prefabs
// but we verify that the code is actually working for this scenario
var package = new Package();
var assetItems = package.Assets;
// Before Adding Package
// a1: a2: (baseParts: a1, 2 instances) a3: (base: a2)
// | ea | ea1 (base: ea) | ea1' (base: ea1)
// | eb | eb1 (base: eb) | eb1' (base: eb1)
// | ea2 (base: ea) | ea2' (base: ea2)
// | eb2 (base: eb) | eb2' (base: eb2)
// After adding the package to the session
// We add one entity to the base a1
// a1: a2: (baseParts: a1, 2 instances) a3: (base: a2)
// | ea | ea1 (base: ea) | ea1' (base: ea1)
// | eb | eb1 (base: eb) | eb1' (base: eb1)
// | ec | ec1 (base: ec) | ec1' (base: ec1)
// | ea2 (base: ea) | ea2' (base: ea2)
// | eb2 (base: eb) | eb2' (base: eb2)
// | ec2 (base: ec) | ec2' (base: ec2)
var a1 = new PrefabAsset();
var ea = new Entity("ea");
var eb = new Entity("eb");
a1.Hierarchy.Parts.Add(new EntityDesign(ea));
a1.Hierarchy.Parts.Add(new EntityDesign(eb));
a1.Hierarchy.RootPartIds.Add(ea.Id);
a1.Hierarchy.RootPartIds.Add(eb.Id);
assetItems.Add(new AssetItem("a1", a1));
var a2 = new PrefabAsset();
var aPartInstance1 = a1.CreatePrefabInstance(a2, "a1");
var aPartInstance2 = a1.CreatePrefabInstance(a2, "a1");
a2.Hierarchy.Parts.AddRange(aPartInstance1.Parts);
a2.Hierarchy.Parts.AddRange(aPartInstance2.Parts);
a2.Hierarchy.RootPartIds.AddRange(aPartInstance1.RootPartIds);
a2.Hierarchy.RootPartIds.AddRange(aPartInstance2.RootPartIds);
assetItems.Add(new AssetItem("a2", a2));
// Modify a1 to add entity ec
var ec = new Entity("ec");
a1.Hierarchy.Parts.Add(new EntityDesign(ec));
a1.Hierarchy.RootPartIds.Add(ec.Id);
var a3 = (PrefabAsset)a2.CreateDerivedAsset("a2");
assetItems.Add(new AssetItem("a3", a3));
// Create a session with this project
using (var session = new PackageSession())
{
var logger = new LoggerResult();
session.AddExistingPackage(package, logger);
Assert.False(logger.HasErrors);
Assert.AreEqual(6, a2.Hierarchy.RootPartIds.Count);
Assert.True(a2.Hierarchy.Parts.All(it => it.Base != null));
Assert.AreEqual(6, a3.Hierarchy.RootPartIds.Count);
Assert.True(a3.Hierarchy.Parts.All(it => it.Base != null && a2.Hierarchy.Parts.ContainsKey(it.Base.BasePartId)));
}
}
public void TestMergeSimpleWithBasePartsAndLinksForChildren()
{
// Similar to TestMergeSimpleWithBasePartsAndLinks, but perform merge on Entity.Transform.Children instead
// Also Check that an asset that was removed is not added and links are actually removed as well
// part1: part2: newAsset (BaseParts: part1): newAssetMerged (BaseParts: part2):
// ERoot ERoot ERoot1 ERoot1
// EA EA EA1 (base: EA) EA1' (base: EA)
// EB EB EB1 (base: EB) EB1' (base: EB)
// EC + link: EA EC + link: EA EC1 (base: EC) + link: EA1 EC1' (base: EC) + link: EA1'
// ED + link: EB ED1' (base: ED) + link: EB1'
// ERoot2 ERoot2
// EA2 (base: EA) EA2' (base: EA)
//
// EC2 (base: EC) + link: EA2 EC2' (base: EC) + link: EA2'
// ED2' (base: ED) + noLink
var eRoot = new Entity("Root");
var entityA = new Entity() { Name = "A" };
var entityB = new Entity() { Name = "B" };
var entityC = new Entity() { Name = "C" };
// EC + link: EA
entityC.Add(new TestEntityComponent() { EntityLink = entityA });
eRoot.Transform.Children.Add(entityA.Transform);
eRoot.Transform.Children.Add(entityB.Transform);
eRoot.Transform.Children.Add(entityC.Transform);
// part1 Asset
var part1 = new PrefabAsset();
part1.Hierarchy.Parts.Add(new EntityDesign(eRoot));
part1.Hierarchy.Parts.Add(new EntityDesign(entityA));
part1.Hierarchy.Parts.Add(new EntityDesign(entityB));
part1.Hierarchy.Parts.Add(new EntityDesign(entityC));
part1.Hierarchy.RootPartIds.Add(eRoot.Id);
// part2 Asset
var part2 = AssetCloner.Clone(part1);
var eRootPart2 = part2.Hierarchy.Parts.Where(it => it.Entity.Name == "Root").Select(it => it.Entity).First();
var entityD = new Entity() { Name = "D" };
eRootPart2.Transform.Children.Add(entityD.Transform);
// ED + link: EB
var entityBFrom2 = part2.Hierarchy.Parts.Where(it => it.Entity.Name == "B").Select(it => it.Entity).First();
entityD.Add(new TestEntityComponent() { EntityLink = entityBFrom2 });
part2.Hierarchy.Parts.Add(new EntityDesign(entityD));
// originalAsset: Add a new instanceId for this part
var asset = new PrefabAsset();
// Create derived parts
//var eRoot1Asset = (PrefabAsset)part1.CreateDerivedAsset("part");
//var eRoot2Asset = (PrefabAsset)part1.CreateDerivedAsset("part");
//asset.AddPart(eRoot1Asset);
//asset.AddPart(eRoot2Asset);
Guid eRoot1Id;
Guid eRoot2Id;
var eRoot1Asset = part1.CreatePrefabInstance(asset, "part", out eRoot1Id);
var eRoot2Asset = part1.CreatePrefabInstance(asset, "part", out eRoot2Id);
asset.Hierarchy.Parts.AddRange(eRoot1Asset.Parts);
asset.Hierarchy.Parts.AddRange(eRoot2Asset.Parts);
asset.Hierarchy.RootPartIds.AddRange(eRoot1Asset.RootPartIds);
asset.Hierarchy.RootPartIds.AddRange(eRoot2Asset.RootPartIds);
//var eRoot2 = asset.Hierarchy.Entities[eRoot2Asset.Hierarchy.RootEntities[0]];
var eRoot2 = asset.Hierarchy.Parts[eRoot2Asset.RootPartIds[0]];
var entityToRemove = eRoot2.Entity.Transform.Children.First(it => it.Entity.Name == "B");
eRoot2.Entity.Transform.Children.Remove(entityToRemove);
asset.Hierarchy.Parts.Remove(entityToRemove.Entity.Id);
// EntityD must be now part of the new asset
Assert.AreEqual(2, asset.Hierarchy.RootPartIds.Count);
Assert.AreEqual(9, asset.Hierarchy.Parts.Count);
Assert.AreEqual(2, asset.Hierarchy.Parts.Count(it => it.Entity.Name == "D"));
foreach (var entity in asset.Hierarchy.Parts.Where(it => it.Entity.Name == "D"))
{
// Check that we have the correct baesId and basePartInstanceId
Assert.True(entity.Base != null);
Assert.AreEqual(entityD.Id, entity.Base.BasePartId);
}
var entityDesignD1 = asset.Hierarchy.Parts[asset.Hierarchy.Parts[asset.Hierarchy.RootPartIds[0]].Entity.Transform.Children.Where(it => it.Entity.Name == "D").Select(it => it.Entity.Id).FirstOrDefault()];
Assert.NotNull(entityDesignD1);
//Assert.AreEqual(eRoot1Asset.Id, entityDesignD1.Design.BasePartInstanceId);
Assert.AreEqual(eRoot1Id, entityDesignD1.Base.InstanceId);
var testComponentD1 = entityDesignD1.Entity.Get<TestEntityComponent>();
Assert.NotNull(testComponentD1);
var entityB1 = asset.Hierarchy.Parts[asset.Hierarchy.RootPartIds[0]].Entity.Transform.Children.Where(it => it.Entity.Name == "B").Select(it => it.Entity).First();
Assert.AreEqual(entityB1, testComponentD1.EntityLink);
var entityDesignD2 = asset.Hierarchy.Parts[asset.Hierarchy.Parts[asset.Hierarchy.RootPartIds[1]].Entity.Transform.Children.Where(it => it.Entity.Name == "D").Select(it => it.Entity.Id).FirstOrDefault()];
Assert.NotNull(entityDesignD2);
//Assert.AreEqual(eRoot2Asset.Id, entityDesignD2.Design.BasePartInstanceId);
Assert.AreEqual(eRoot2Id, entityDesignD2.Base.InstanceId);
var testComponentD2 = entityDesignD2.Entity.Get<TestEntityComponent>();
Assert.NotNull(testComponentD2);
Assert.AreEqual(null, testComponentD2.EntityLink);
}
public void TestMergeSimpleWithBasePartsAndLinks()
{
// part1: part2: newAsset (BaseParts: part1): newAssetMerged (BaseParts: part2):
// EA EA EA1 (base: EA) [0] EA1' (base: EA)
// EB EB EB1 (base: EB) [1] EB1' (base: EB)
// EC + link: EA EC + link: EA EC1 (base: EC) + link: EA1 [2] EC1' (base: EC) + link: EA1'
// ED + link: EB EA2 (base: EA) [3] EA2' (base: EA)
// EB2 (base: EB) [4] EB2' (base: EB)
// EC2 (base: EC) + link: EA2 [5] EC2' (base: EC) + link: EA2'
// [6] ED1' (base: ED) + link: EB1'
// [7] ED2' (base: ED) + link: EB2'
var entityA = new Entity() { Name = "A" };
var entityB = new Entity() { Name = "B" };
var entityC = new Entity() { Name = "C" };
// EC + link: EA
entityC.Add(new TestEntityComponent() { EntityLink = entityA });
// part1 Asset
var basePart = new PrefabAsset();
basePart.Hierarchy.Parts.Add(new EntityDesign(entityA));
basePart.Hierarchy.Parts.Add(new EntityDesign(entityB));
basePart.Hierarchy.Parts.Add(new EntityDesign(entityC));
basePart.Hierarchy.RootPartIds.Add(entityA.Id);
basePart.Hierarchy.RootPartIds.Add(entityB.Id);
basePart.Hierarchy.RootPartIds.Add(entityC.Id);
// originalAsset: Add a new instanceId for this part
var asset = new PrefabAsset();
// Create part1 asset
Guid part1InstanceId;
Guid part12InstanceId;
var part1 = basePart.CreatePrefabInstance(asset, "part", out part1InstanceId);
var entityB1 = part1.Parts.First(it => it.Entity.Name == "B").Entity;
var part12 = basePart.CreatePrefabInstance(asset, "part", out part12InstanceId);
var entityB2 = part12.Parts.First(it => it.Entity.Name == "B").Entity;
// create part2 assset
var entityD = new Entity() { Name = "D" };
basePart.Hierarchy.Parts.Add(new EntityDesign(entityD));
basePart.Hierarchy.RootPartIds.Add(entityD.Id);
// ED + link: EB
var entityBFrom2 = basePart.Hierarchy.Parts.Where(it => it.Entity.Name == "B").Select(it => it.Entity).First();
entityD.Add(new TestEntityComponent() { EntityLink = entityBFrom2 });
asset.Hierarchy.Parts.AddRange(part1.Parts);
asset.Hierarchy.Parts.AddRange(part12.Parts);
asset.Hierarchy.RootPartIds.AddRange(part1.RootPartIds);
asset.Hierarchy.RootPartIds.AddRange(part12.RootPartIds);
// EntityD must be now part of the new asset
Assert.AreEqual(8, asset.Hierarchy.RootPartIds.Count);
Assert.AreEqual(8, asset.Hierarchy.Parts.Count);
Assert.AreEqual(2, asset.Hierarchy.Parts.Count(it => it.Entity.Name == "D"));
foreach (var entity in asset.Hierarchy.Parts.Where(it => it.Entity.Name == "D"))
{
// Check that we have the correct baesId and basePartInstanceId
Assert.True(entity.Base != null);
Assert.AreEqual(entityD.Id, entity.Base.BasePartId);
// Make sure that the entity is in the RootEntities
Assert.True(asset.Hierarchy.RootPartIds.Contains(entity.Entity.Id));
}
var entityDesignD1 = asset.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "D" && it.Base.InstanceId == part1InstanceId);
Assert.NotNull(entityDesignD1);
var entityDesignD2 = asset.Hierarchy.Parts.FirstOrDefault(it => it.Entity.Name == "D" && it.Base.InstanceId == part12InstanceId);
Assert.NotNull(entityDesignD2);
// Check components
var testComponentD1 = entityDesignD1.Entity.Get<TestEntityComponent>();
Assert.NotNull(testComponentD1);
Assert.AreEqual(entityB1, testComponentD1.EntityLink);
var testComponentD2 = entityDesignD2.Entity.Get<TestEntityComponent>();
Assert.NotNull(testComponentD2);
Assert.AreEqual(entityB2, testComponentD2.EntityLink);
}
public void TestCascadedInheritance()
{
// Test with:
// a1: an asset with 2 entities
// a2: an asset using a1 by composition with 2 instances
// a3: an asset based on a2
//
// Add one entity to a1. Check that a2 and a3 will get correctly the entities replicated
// Before Merge
// a1: a2: (baseParts: a1, 2 instances) a3: (base: a2)
// | ea | ea1 (base: ea) | ea1' (base: ea1)
// | eb | eb1 (base: eb) | eb1' (base: eb1)
// | ea2 (base: ea) | ea2' (base: ea2)
// | eb2 (base: eb) | eb2' (base: eb2)
// After Merge
// We add one entity to the base a1
// a1: a2: (baseParts: a1, 2 instances) a3: (base: a2)
// | ea | ea1 (base: ea) | ea1' (base: ea1)
// | eb | eb1 (base: eb) | eb1' (base: eb1)
// | ec | ec1 (base: ec) | ec1' (base: ec1)
// | ea2 (base: ea) | ea2' (base: ea2)
// | eb2 (base: eb) | eb2' (base: eb2)
// | ec2 (base: ec) | ec2' (base: ec2)
var a1 = new PrefabAsset();
var ea = new Entity("ea");
var eb = new Entity("eb");
a1.Hierarchy.Entities.Add(ea);
a1.Hierarchy.Entities.Add(eb);
a1.Hierarchy.RootEntities.Add(ea.Id);
a1.Hierarchy.RootEntities.Add(eb.Id);
var a2 = new PrefabAsset();
var aPartInstance1 = a1.CreatePrefabInstance(a2, "a1");
var aPartInstance2 = a1.CreatePrefabInstance(a2, "a1");
a2.Hierarchy.Entities.AddRange(aPartInstance1.Entities);
a2.Hierarchy.Entities.AddRange(aPartInstance2.Entities);
a2.Hierarchy.RootEntities.AddRange(aPartInstance1.RootEntities);
a2.Hierarchy.RootEntities.AddRange(aPartInstance2.RootEntities);
// Modify a1 to add entity ec
var ec = new Entity("ec");
a1.Hierarchy.Entities.Add(ec);
a1.Hierarchy.RootEntities.Add(ec.Id);
var a3 = (PrefabAsset)a2.CreateChildAsset("a2");
// Merge a2
var result2 = a2.Merge(null, null, new List<AssetBase>()
{
new AssetBase("a1", (Asset)AssetCloner.Clone(a1))
});
Assert.False(result2.HasErrors);
Assert.AreEqual(6, a2.Hierarchy.RootEntities.Count);
Assert.True(a2.Hierarchy.Entities.All(it => it.Design.BaseId.HasValue && it.Design.BasePartInstanceId.HasValue));
// Merge a3
var result3 = a3.Merge((Asset)AssetCloner.Clone(a3.Base.Asset), (Asset)AssetCloner.Clone(a2), null);
Assert.False(result3.HasErrors);
Assert.AreEqual(6, a3.Hierarchy.RootEntities.Count);
Assert.True(a3.Hierarchy.Entities.All(it => !it.Design.BasePartInstanceId.HasValue));
Assert.True(a3.Hierarchy.Entities.All(it => it.Design.BaseId.HasValue && a2.Hierarchy.Entities.ContainsKey(it.Design.BaseId.Value)));
}
