private static SerializableProperties GetSerializableProperties(TypeInfo type)
{
if (SerializablePropertiesByType.TryGetValue(type, out var properties))
{
return(properties);
}
var dataContract = type.GetCustomAttribute(typeof(XmlSerializableDataContractAttribute)) as XmlSerializableDataContractAttribute;
var enableCamelCaseNameCompat = dataContract == null ? false : dataContract.EnableCamelCaseNameCompat;
var declaredProperties = new List <SerializableProperty>();
foreach (var declaredProperty in type.DeclaredProperties)
{
if (declaredProperty.GetCustomAttribute(typeof(XmlIgnoreAttribute)) != null)
{
continue;
}
if (declaredProperty.SetMethod == null)
{
continue;
}
var dataMember = declaredProperty.GetCustomAttribute(typeof(DataMemberAttribute)) as DataMemberAttribute;
if (dataMember == null)
{
continue;
}
var shouldSerializeMethodName = string.Concat("ShouldSerialize", declaredProperty.Name);
var shouldSerializeMethod = type.GetDeclaredMethod(shouldSerializeMethodName);
declaredProperties.Add(new SerializableProperty(declaredProperty, dataMember, shouldSerializeMethod, enableCamelCaseNameCompat));
}
var inheritedProperties = Enumerable.Empty <SerializableProperty>();
if (type.BaseType != typeof(object))
{
inheritedProperties = GetSerializableProperties(type.BaseType.GetTypeInfo()).EnumeratedInOrder;
}
var serializableProperties = new SerializableProperties(declaredProperties, inheritedProperties);
return(SerializablePropertiesByType.GetOrAdd(type, serializableProperties));
}
public virtual void Load(XElement componentElement)
{
if (componentElement == null)
{
return;
}
foreach (XAttribute attribute in componentElement.Attributes())
{
if (!SerializableProperties.TryGetValue(attribute.Name.ToString().ToLowerInvariant(), out SerializableProperty property))
{
continue;
}
property.TrySetValue(this, attribute.Value);
}
ParseMsg();
OverrideRequiredItems(componentElement);
}
private void UpdateSignals(string[] newSignals)
{
signals = new string[customInterfaceElementList.Count];
for (int i = 0; i < customInterfaceElementList.Count; i++)
{
var element = customInterfaceElementList[i];
if (i < newSignals.Length)
{
var newSignal = newSignals[i];
signals[i] = newSignal;
element.ShouldSetProperty = element.Signal != newSignal;
element.Signal = newSignal;
}
else
{
signals[i] = element.Signal;
}
if (element.HasPropertyName && element.ShouldSetProperty)
{
if (element.TargetOnlyParentProperty)
{
if (SerializableProperties.ContainsKey(element.PropertyName))
{
SerializableProperties[element.PropertyName].TrySetValue(this, element.Signal);
}
}
else
{
foreach (var po in item.AllPropertyObjects)
{
if (!po.SerializableProperties.ContainsKey(element.PropertyName))
{
continue;
}
po.SerializableProperties[element.PropertyName].TrySetValue(po, element.Signal);
}
}
customInterfaceElementList[i].ShouldSetProperty = false;
}
}
UpdateSignalsProjSpecific();
}
public virtual void Load(XElement componentElement, bool usePrefabValues)
{
if (componentElement != null && !usePrefabValues)
{
foreach (XAttribute attribute in componentElement.Attributes())
{
if (!SerializableProperties.TryGetValue(attribute.Name.ToString().ToLowerInvariant(), out SerializableProperty property))
{
continue;
}
property.TrySetValue(this, attribute.Value);
}
ParseMsg();
OverrideRequiredItems(componentElement);
}
if (item.Submarine != null)
{
SerializableProperty.UpgradeGameVersion(this, originalElement, item.Submarine.Info.GameVersion);
}
}
private float GetSoundVolume(ItemSound sound)
{
if (sound == null)
{
return(0.0f);
}
if (sound.VolumeProperty == "")
{
return(sound.VolumeMultiplier);
}
if (SerializableProperties.TryGetValue(sound.VolumeProperty, out SerializableProperty property))
{
float newVolume = 0.0f;
try
{
newVolume = (float)property.GetValue(this);
}
catch
{
return(0.0f);
}
newVolume *= sound.VolumeMultiplier;
if (!MathUtils.IsValid(newVolume))
{
DebugConsole.Log("Invalid sound volume (item " + item.Name + ", " + GetType().ToString() + "): " + newVolume);
GameAnalyticsManager.AddErrorEventOnce(
"ItemComponent.PlaySound:" + item.Name + GetType().ToString(),
GameAnalyticsSDK.Net.EGAErrorSeverity.Error,
"Invalid sound volume (item " + item.Name + ", " + GetType().ToString() + "): " + newVolume);
return(0.0f);
}
return(MathHelper.Clamp(newVolume, 0.0f, 1.0f));
}
return(0.0f);
}
private void ValueChanged(CustomInterfaceElement numberInputElement, int value)
{
if (numberInputElement == null)
{
return;
}
numberInputElement.Signal = value.ToString();
if (!numberInputElement.TargetOnlyParentProperty)
{
foreach (ISerializableEntity e in item.AllPropertyObjects)
{
if (!e.SerializableProperties.ContainsKey(numberInputElement.PropertyName))
{
continue;
}
e.SerializableProperties[numberInputElement.PropertyName].TrySetValue(e, value);
}
}
else if (SerializableProperties.ContainsKey(numberInputElement.PropertyName))
{
SerializableProperties[numberInputElement.PropertyName].TrySetValue(this, value);
}
}
private void TextChanged(CustomInterfaceElement textElement, string text)
{
if (textElement == null)
{
return;
}
textElement.Signal = text;
if (!textElement.TargetOnlyParentProperty)
{
foreach (ISerializableEntity e in item.AllPropertyObjects)
{
if (!e.SerializableProperties.ContainsKey(textElement.PropertyName))
{
continue;
}
e.SerializableProperties[textElement.PropertyName].TrySetValue(e, text);
}
}
else if (SerializableProperties.ContainsKey(textElement.PropertyName))
{
SerializableProperties[textElement.PropertyName].TrySetValue(this, text);
}
}
private void PromoteProperties(Stream streamResult, MessageItem messageItem, bool invalidAnnotationToken)
{
foreach (ISerializableProperty serializableProperty in SerializableProperties.DeserializeFrom(streamResult))
{
this.diagnosticsSession.TraceDebug <SerializablePropertyId>("Setting property {0}", serializableProperty.Id);
switch (serializableProperty.Id)
{
case SerializablePropertyId.AnnotationToken:
{
SerializableStreamProperty serializableStreamProperty = (SerializableStreamProperty)serializableProperty;
if (invalidAnnotationToken)
{
this.diagnosticsSession.TraceDebug("Skip promoting invalid annotation token", new object[0]);
serializableStreamProperty.CopyTo(Stream.Null);
continue;
}
using (Stream stream = messageItem.OpenPropertyStream(ItemSchema.AnnotationToken, PropertyOpenMode.Create))
{
serializableStreamProperty.CopyTo(stream);
this.diagnosticsSession.TraceDebug <long>("Bytes written: {0}", stream.Position);
continue;
}
break;
}
case SerializablePropertyId.Tasks:
break;
case (SerializablePropertyId)3:
case (SerializablePropertyId)7:
case (SerializablePropertyId)8:
continue;
case SerializablePropertyId.Meetings:
{
string text = messageItem.TryGetProperty(StoreObjectSchema.ItemClass) as string;
if (text == null || !ObjectClass.IsMeetingMessage(text))
{
messageItem.SafeSetProperty(ItemSchema.XmlExtractedMeetings, serializableProperty.Value);
continue;
}
continue;
}
case SerializablePropertyId.Addresses:
messageItem.SafeSetProperty(ItemSchema.XmlExtractedAddresses, serializableProperty.Value);
continue;
case SerializablePropertyId.Keywords:
messageItem.SafeSetProperty(ItemSchema.XmlExtractedKeywords, serializableProperty.Value);
continue;
case SerializablePropertyId.Phones:
messageItem.SafeSetProperty(ItemSchema.XmlExtractedPhones, serializableProperty.Value);
continue;
case SerializablePropertyId.Emails:
messageItem.SafeSetProperty(ItemSchema.XmlExtractedEmails, serializableProperty.Value);
continue;
case SerializablePropertyId.Urls:
messageItem.SafeSetProperty(ItemSchema.XmlExtractedUrls, serializableProperty.Value);
continue;
case SerializablePropertyId.Contacts:
messageItem.SafeSetProperty(ItemSchema.XmlExtractedContacts, serializableProperty.Value);
continue;
case SerializablePropertyId.Language:
this.diagnosticsSession.TraceDebug("Detected language: {0}", new object[]
{
serializableProperty.Value
});
messageItem.SafeSetProperty(ItemSchema.DetectedLanguage, serializableProperty.Value);
continue;
default:
continue;
}
messageItem.SafeSetProperty(ItemSchema.XmlExtractedTasks, serializableProperty.Value);
}
}
