public void ImportContent(PropertyStream stream)
{
this.Name = stream.GetString(Hashes.FamilyName);
this.FamilyFunds = stream.GetS32(Hashes.FamilyFunds);
this.ExportTime = stream.GetS64(Hashes.ExportTime);
this.BioText = stream.GetString(Hashes.BioText);
this.LifetimeHappinessNotificationShown = stream.GetBoolean(Hashes.LifetimeHappinessNotificationShown);
this.Members = new List <SimDescription>();
PropertyStream sims = stream.GetChild(Hashes.Members);
int scount = sims.GetS32(Hashes.SimDescriptionCount);
for (uint i = 0; i < scount; i++)
{
PropertyStream child = sims.GetChild(i);
SimDescription sim = new SimDescription();
sim.ImportContent(child);
this.Members.Add(sim);
}
this.Relationships = new Dictionary <ulong, ulong>();
PropertyStream relationships = stream.GetChild(Hashes.Relationships);
uint ucount = relationships.GetU32(Hashes.NumRelationships);
for (uint i = 0; i < ucount; i++)
{
PropertyStream child = relationships.GetChild(i);
UInt64 a = child.GetU64(Hashes.CurrentSimDescId);
UInt64 b = child.GetU64(Hashes.OtherSimDescId);
this.Relationships.Add(a, b);
}
}
//! Reads/Writes struct properties from/to a stream
public override void Serialize(PropertyStream stream)
{
base.Serialize(stream);
stream.SerializeStruct("Src", m_Src);
stream.SerializeStruct("Dest", m_Dest);
m_fSpeed = stream.Serialize<float>("Speed");
}
public void Write(Stream output)
{
output.WriteValueU32(4);
PropertyStream root = new PropertyStream();
this.HouseholdContents.ExportContent(root);
root.Write(output);
}
public void Read(Stream input)
{
uint version = input.ReadValueU32();
PropertyStream root = new PropertyStream();
root.Read(input);
this.HouseholdContents = new HouseholdContents();
this.HouseholdContents.ImportContent(root);
}
/// <summary>
/// This will get and parse named properties
/// </summary>
/// <param name="ps">A populated property stream</param>
/// <returns>A list of NamedProperty objects</returns>
private List <NamedProperty> ParseNamedProperties(PropertyStream ps)
{
NamedPropertyMapper mapper = new NamedPropertyMapper(_namedPropertyParser);
List <PropertyEntry> namedPropertyEntries = GetNamedProperties(ps);
List <NamedProperty> namedProperties = new List <NamedProperty>();
foreach (var property in namedPropertyEntries)
{
namedProperties.Add(mapper.MapProperty(property));
}
return(namedProperties);
}
/// <summary>
/// Populates the value of variable length properties
/// </summary>
private void PopulateVariableLengthProperties(PropertyStream ps, string storage)
{
var variableLengthReader = new VariableLengthStreamReader(_compoundFile);
foreach (var item in ps.Data)
{
if (!TypeMapper.IsFixedLength(item.PropertyTag.Type))
{
object obj = variableLengthReader.GetVariableLengthProperty(item, storage);
(item as VariableLengthPropertyEntry).VariableLengthData = obj;
}
}
}
/// <summary>
/// This method returns the stream names of named properties
/// </summary>
/// <returns></returns>
private List <PropertyEntry> GetNamedProperties(PropertyStream ps)
{
List <PropertyEntry> namedProperties = new List <PropertyEntry>();
foreach (var item in ps.Data)
{
if (item.PropertyTag.ID >= 0x8000 && item.PropertyTag.ID <= 0x8FFF)
{
namedProperties.Add(item);
}
}
return(namedProperties);
}
public void ReadPropertyStreamDefaultTest()
{
parser = new MsgParser(@"TestFiles\TestMessage-default.msg");
msgFile = parser.Parse();
PropertyStream ps = msgFile.PropertyStream;
Assert.That(ps.Header, Is.Not.Null);
Assert.That(ps.Header.NextRecipientId, Is.EqualTo(3));
Assert.That(ps.Header.NextAttachmentId, Is.EqualTo(1));
Assert.That(ps.Header.RecipientCount, Is.EqualTo(3));
Assert.That(ps.Header.AttachmentCount, Is.EqualTo(1));
Assert.That(ps.NumberOfProperties, Is.EqualTo(24));
}
//! serializes the entity to/from a PropertyStream
public override void Serialize(PropertyStream stream)
{
base.Serialize(stream);
m_ChildEntityPath = stream.Serialize<string>("ChildEntityPath");
if (m_ChildEntityPath.Length > 0)
{
m_ChildEntity = new Entity();
m_ChildEntity.LoadFromXML(m_ChildEntityPath, null);
m_ChildEntity.Init();
AddChild(m_ChildEntity);
}
}
public void ImportContent(PropertyStream stream)
{
PropertyStream child = stream.GetChild(HashHousehold);
this.Household = new Household();
this.Household.ImportContent(child);
int count = stream.GetS32(HashInventoryCount);
this.Inventories = stream.GetS32s(HashInventoryKeyIndices);
if (this.Inventories.Length != count)
{
throw new Exception("count mismatch");
}
}
//! serializes the entity to/from a PropertyStream
public override void Serialize(PropertyStream stream)
{
base.Serialize(stream);
m_strTemplatePath = stream.Serialize<string>("TemplatePath");
if (m_strTemplatePath.Length > 0)
{
LoadFromXML(m_strTemplatePath, this);
}
// serialize the instance data
if(GetNumChildren() > 0)
{
m_InstanceData.m_Instance = GetChild(0);
stream.SerializeStruct("InstanceData", m_InstanceData);
}
}
/// <summary>
/// The class will read and parse a property stream.
/// See https://msdn.microsoft.com/en-us/library/ee203894(v=exchg.80).aspx for the structure.
/// </summary>
/// <param name="storage">Which storage to read from. If null, read from the top-level storage</param>
/// <returns>A populated Property Stream</returns>
internal PropertyStream ReadPropertyStream(string storage = null)
{
PropertyStream ps = new PropertyStream();
ps.Header = new Headers.TopLevelHeader();
CFStream propStream;
byte[] data;
if (storage == null) // we want the top-level property stream
{
propStream = _compoundFile.RootStorage.GetStream(PropertyStream.STREAM_NAME);
data = propStream.GetData();
ps.Header.NextRecipientId = BitConverter.ToInt32(data, 8);
ps.Header.NextAttachmentId = BitConverter.ToInt32(data, 12);
ps.Header.RecipientCount = BitConverter.ToInt32(data, 16);
ps.Header.AttachmentCount = BitConverter.ToInt32(data, 20);
ps.NumberOfProperties = (data.Length - Headers.TopLevelHeader.HEADER_SIZE_BYTES) / PropertyEntry.SIZE_BYTES;
ps.Data = new List <PropertyEntry>();
for (int i = 0; i < ps.NumberOfProperties; i++)
{
//start reading at 32
ps.Data.Add(ReadPropertyEntry(data.Skip(Headers.TopLevelHeader.HEADER_SIZE_BYTES).Skip(i * 16).Take(16).ToArray()));
}
}
else //we want the attachment/recipient property stream
{
propStream = _compoundFile.RootStorage.GetStorage(storage).GetStream(PropertyStream.STREAM_NAME);
data = propStream.GetData();
ps.NumberOfProperties = (data.Length - Headers.BaseHeader.HEADER_SIZE_BYTES) / PropertyEntry.SIZE_BYTES;
ps.Data = new List <PropertyEntry>();
for (int i = 0; i < ps.NumberOfProperties; i++)
{
//start reading at 8
ps.Data.Add(ReadPropertyEntry(data.Skip(Headers.BaseHeader.HEADER_SIZE_BYTES).Skip(i * 16).Take(16).ToArray()));
}
}
PopulateVariableLengthProperties(ps, storage);
return(ps);
}
//! recursive read from XML
void ReadEntity(XmlTextReader xmlReader, Entity parent)
{
Entity entity = null;
string entityTypeName = xmlReader.Name;
if (parent != null)
{
// create entity
string assemblyName = Assembly.GetExecutingAssembly().GetName().Name;
string fullTypeName = assemblyName + "." + entityTypeName;
entity = Assembly.GetExecutingAssembly().CreateInstance(fullTypeName) as Entity;
}
else
{
string thisTypeName = GetType().Name;
Debug.Assert(thisTypeName == entityTypeName, "Trying to load an entity of type " + entityTypeName + " into an " + thisTypeName);
entity = this;
}
// read children
while(xmlReader.Read())
{
if(xmlReader.NodeType == XmlNodeType.EndElement)
{
break;
}
else if(xmlReader.NodeType == XmlNodeType.Element)
{
if (xmlReader.Name == "Properties")
{
// read properties
PropertyStream stream = new PropertyStream();
stream.ReadFromXML(xmlReader, null);
entity.Serialize(stream);
}
else
{
ReadEntity(xmlReader, entity);
}
}
} // end while
if(parent != null)
{
// Add entity after it has been serialized to ensure proper event handling inside of AddChild()
parent.AddChild(entity);
}
}
//! serializes the entity to/from a PropertyStream
public override void Serialize(PropertyStream stream)
{
base.Serialize(stream);
m_bEnabled = stream.Serialize<bool>("Enabled");
m_bVisible = stream.Serialize<bool>("Visible");
stream.SerializeReference("Visitor", m_VisitorRef);
}
//! serializes the entity to/from a PropertyStream
public override void Serialize(PropertyStream stream)
{
base.Serialize(stream);
stream.SerializeReference("Material", MaterialRef);
}
public void ExportContent(PropertyStream stream)
{
throw new NotImplementedException();
}
//! serializes the entity to/from a PropertyStream
public override void Serialize(PropertyStream stream)
{
base.Serialize(stream);
}
//! Reads/Writes struct properties from/to a stream
public override void Serialize(PropertyStream stream)
{
base.Serialize(stream);
m_AutoStart = stream.Serialize<bool>("AutoStart");
}
//! serializes the entity to/from a PropertyStream
public override void Serialize(PropertyStream stream)
{
base.Serialize(stream);
m_strPath = stream.Serialize<string>("Path");
}
//! serializes the entity to/from a PropertyStream
public virtual void Serialize(PropertyStream stream)
{
m_ID = stream.Serialize<uint>("ID");
m_Name = stream.Serialize<string>("Name");
}
//! serialize the instance data
public override void Serialize(PropertyStream stream)
{
m_Instance.Serialize(stream);
}
public void ImportContent(PropertyStream stream)
{
this.FirstName = stream.GetString(Hashes.FirstName);
this.LastName = stream.GetString(Hashes.LastName);
this.Flags = stream.GetU32(Hashes.Flags);
}
//! serializes the entity to/from a PropertyStream
public override void Serialize(PropertyStream stream)
{
base.Serialize(stream);
m_vPosition = stream.Serialize<Vector2>("Position");
m_fRotation = stream.Serialize<float>("Rotation");
m_vScale = stream.Serialize<Vector2>("Scale");
m_vCenter = stream.Serialize<Vector2>("Center");
m_BoundingBox = stream.Serialize<BoundingBox>("BBox");
m_bHFlip = stream.Serialize<bool>("HFlip");
m_bVFlip = stream.Serialize<bool>("VFlip");
}
//! serializes the entity to/from a PropertyStream
public override void Serialize(PropertyStream stream)
{
base.Serialize(stream);
m_vPosition = stream.Serialize<Vector3>("Position");
m_vRotation = stream.Serialize<Vector3>("Rotation");
m_vScale = stream.Serialize<Vector3>("Scale");
m_vCenter = stream.Serialize<Vector3>("Center");
m_BoundingBox = stream.Serialize<BoundingBox>("BBox");
}
//! serializes the entity to/from a PropertyStream
public override void Serialize(PropertyStream stream)
{
base.Serialize(stream);
m_FOV = stream.Serialize<float>("FOV");
m_ZNear = stream.Serialize<float>("ZNear");
m_ZFar = stream.Serialize<float>("ZFar");
m_eType = (E_Type)stream.Serialize<int>("Projection");
m_vUpVector = stream.Serialize<Vector3>("UpVector");
}
//! Reads/Writes struct properties from/to a stream
public override void Serialize(PropertyStream stream)
{
base.Serialize(stream);
bool bLighting = stream.Serialize<bool>("Lighting");
SetFlag(E_Flag.MF_Lighting, bLighting);
m_Color = stream.Serialize<Color>("Color");
m_Color.A = (byte)(stream.Serialize<float>("Alpha")*255.0f);
stream.SerializeArray<string>("Textures", m_strTextures);
for(int i=0; i<m_strTextures.Count; ++i)
{
if(m_strTextures[i].Length > 0)
{
// remove extension
string path = m_strTextures[i].Split('.')[0];
m_aTextures[i] = Engine.Instance().Content.Load<Texture2D>(path);
}
else
{
m_aTextures[i] = null;
}
}
}
