public static EntityTemplate CreateFromOther(string name, EntityTemplate cloneSource)
{
List <Component> newComponents = new List <Component>();
foreach (Component component in cloneSource.ComponentTemplates)
{
Component newComponent = (Component)Activator.CreateInstance(component.GetType());
newComponent.ApplyFromTemplate(component);
newComponents.Add(newComponent);
}
EntityTemplate foo = new EntityTemplate(name, newComponents.ToArray());
foo.ParentName = cloneSource.Name;
// Children! phil
if ((cloneSource.ChildTemplates != null) && (cloneSource.ChildTemplates.Count > 0))
{
foo.AddChildren(cloneSource.ChildTemplates);
}
return(foo);
}
// TODO: This has code in common with SerializeEntity a bit.
private bool IsEntityExactMatchForTemplate(Entity childEntity, EntityTemplate childEntityTemplate)
{
bool exactMatch = (childEntity.TemplateId == childEntityTemplate.EntityTemplateId);
if (exactMatch)
{
for (int i = 0; exactMatch && (i < EntityManager.MaxComponentTypes); i++)
{
Component componentCurrent = GetComponent(childEntity, i);
Component templateComponentCurrent = childEntityTemplate.ComponentArray[i];
if ((componentCurrent != null) && (templateComponentCurrent != null))
{
exactMatch = !componentCurrent.IsDifferent(childEntity, templateComponentCurrent);
}
else
{
exactMatch = (componentCurrent == null) && (templateComponentCurrent == null);
}
}
}
return(exactMatch);
}
public static EntityTemplate NewInheritFrom(string name, string parent)
{
EntityTemplate cloneSource = EntityTemplateManager.GetTemplateByName(parent);
return(CreateFromOther(name, cloneSource));
}
public void SerializeEntity(BinaryWriter writer, Entity entity, List <int> extraIdsToSerialize, EntityEnumeration enumerationType, List <int> liveIdsWeSkippedSerializing)
{
Debug.Assert(((enumerationType == EntityEnumeration.Deep) && (extraIdsToSerialize != null)) ||
((enumerationType == EntityEnumeration.Shallow) && (extraIdsToSerialize == null)));
writer.Write(entity.UniqueId);
writer.Write(entity.OwnerUniqueId);
writer.Write(entity.TemplateId);
EntityTemplate entityTemplate = EntityTemplateManager.GetTemplateById(entity.TemplateId);
//bool addTransformChildrenToExtraIdsList = false;
// Now we write the number of components. To know how many we're going to write out,
// we need to figure out how many are different than the template ones.
int saveCount = 0;
for (int i = 0; i < EntityManager.MaxComponentTypes; i++)
{
Component componentCurrent = GetComponent(entity, i);
serializationComponentWorker1[i] = null;
if (componentCurrent != null)
{
bool exactMatch = false;
//if ((i == ComponentTypeIds.TransformChildren) && (enumerationType == EntityEnumeration.Deep))
if (enumerationType == EntityEnumeration.Deep)
{
throw new NotImplementedException();
/*
* // Big optimization: For TransformChildren, if the set of transform children for this entity matches
* // *exactly* what's in the template's children, then we can skip adding this component altogether,
* // saving a lot of space. We''ll assume the same order too.
* TransformChildren transformChildren = componentCurrent as TransformChildren;
* List<int> containedItemUniqueIds = transformChildren.GetContainedItemUniqueIds();
* exactMatch = (containedItemUniqueIds.Count == entityTemplate.ChildTemplates.Count);
* if (exactMatch)
* {
* for (int matchIndex = 0; exactMatch && (matchIndex < containedItemUniqueIds.Count); matchIndex++)
* {
* Entity childEntity = GetEntityByUniqueId(containedItemUniqueIds[matchIndex]);
* EntityTemplate childEntityTemplate = entityTemplate.ChildTemplates[matchIndex];
* exactMatch = IsEntityExactMatchForTemplate(childEntity, childEntityTemplate);
* }
* }
*
* // We'll need to serialize the extra ids if this wasn't an exact match.
* addTransformChildrenToExtraIdsList = !exactMatch;
*
* // If we're not adding them to the "please serialize" list, we need to add them to the
* // list of things we skipped serializing (in case they need to be removed)
* if (!addTransformChildrenToExtraIdsList)
* {
* foreach (int uniqueId in containedItemUniqueIds)
* {
* liveIdsWeSkippedSerializing.Add(GetEntityByUniqueId(uniqueId).LiveId);
* }
* }*/
}
else
{
Component templateComponent = entityTemplate.ComponentArray[i];
exactMatch = (templateComponent != null) && !componentCurrent.IsDifferent(entity, templateComponent);
}
if (!exactMatch)
{
// Need to serialize it, because it doesn't match the template.
serializationComponentWorker1[i] = componentCurrent;
saveCount++;
}
}
}
writer.Write((byte)saveCount);
for (int i = 0; i < EntityManager.MaxComponentTypes; i++)
{
Component componentCurrent = serializationComponentWorker1[i];
if (componentCurrent != null)
{
writer.Write(typeToComponentId[componentCurrent.GetType()]);
componentCurrent.Serialize(writer);
// Inventory is straightforward, because these are never part of a template, so we don't need to optimize them out.
// So always add them to the extra ids to serialize.
if (enumerationType == EntityEnumeration.Deep)
{
throw new NotImplementedException();
}
/*
* if ((i == ComponentTypeIds.Inventory) && (enumerationType == EntityEnumeration.Deep))
* {
* Inventory inventory = componentCurrent as Inventory;
* foreach (int uniqueId in inventory.GetContainedItemUniqueIds())
* {
* extraIdsToSerialize.Add(GetEntityByUniqueId(uniqueId).LiveId);
* }
* }
* else if ((i == ComponentTypeIds.TransformChildren) && addTransformChildrenToExtraIdsList)
* {
* TransformChildren transformChildren = componentCurrent as TransformChildren;
* foreach (int uniqueId in transformChildren.GetContainedItemUniqueIds())
* {
* extraIdsToSerialize.Add(GetEntityByUniqueId(uniqueId).LiveId);
* }
* }*/
}
}
}
