public static string ConvertToString(Type type, object value, string errorString)
{
if (typeof(EntityType).IsAssignableFrom(type))
{
EntityType entityType = (EntityType)value;
return(entityType.Name);
}
if (typeof(Entity).IsAssignableFrom(type))
{
Entity entity = (Entity)value;
return(entity.UIN.ToString());
}
if (typeof(Type) == type)
{
return(((Type)value).FullName);
}
if (SimpleTypesUtils.IsSimpleType(type))
{
return(value.ToString());
}
if (errorString != null)
{
Log.Fatal("Entity System: Serialization for type \"{0}\" are not supported ({1}).", type.ToString(), errorString);
}
return(null);
}
static void ConsoleCommand_ShowDebugInformationWindow(string arguments)
{
bool show = DebugInformationWindow.Instance == null;
try
{
show = (bool)SimpleTypesUtils.GetSimpleTypeValue(typeof(bool), arguments);
}
catch { }
ShowDebugInformationWindow(show);
}
protected override bool OnLoad(TextBlock block)
{
if (!base.OnLoad(block))
{
return(false);
}
if (block.IsAttributeExist("value"))
{
this.aBX = SimpleTypesUtils.GetSimpleTypeValue(this.aBw, block.GetAttribute("value"));
}
return(true);
}
private void OnConsoleConfigCommand(string arguments, object userData)
{
Config.Parameter parameter = (Config.Parameter)userData;
if (string.IsNullOrEmpty(arguments))
{
object value = parameter.GetValue();
Print(string.Format("Value: \"{0}\", Default value: \"{1}\"",
value != null ? value : "(null)", parameter.DefaultValue));
return;
}
try
{
if (parameter.Field != null)
{
object value = SimpleTypesUtils.GetSimpleTypeValue(parameter.Field.FieldType,
arguments);
if (value == null)
{
throw new Exception("Not simple type");
}
parameter.Field.SetValue(null, value);
}
else if (parameter.Property != null)
{
object value = SimpleTypesUtils.GetSimpleTypeValue(parameter.Property.PropertyType,
arguments);
if (value == null)
{
throw new Exception("Not simple type");
}
parameter.Property.SetValue(null, value, null);
}
}
catch (FormatException e)
{
string s = "";
if (parameter.Field != null)
{
s = parameter.Field.FieldType.ToString();
}
else if (parameter.Property != null)
{
s = parameter.Property.PropertyType.ToString();
}
Print(string.Format("Config : Invalid parameter format \"{0}\" {1}", s,
e.Message), new ColorValue(1, 0, 0));
}
}
public override bool OnLinkedTextClick(string linkName)
{
if (linkName == "variableType")
{
Type variableType = this.VariableType;
if (!LogicEditorFunctionality.Instance.ShowTypeDialog(null, ref variableType))
{
return(false);
}
if (variableType != this.VariableType)
{
if (this.abD != null)
{
this.abD.SetForDeletion(false);
Entities.Instance.DeleteEntitiesQueuedForDeletion();
}
this.abC = variableType.Name;
this.abd = null;
if (SimpleTypesUtils.IsSimpleType(this.VariableType))
{
this.abD = (LogicAction)Entities.Instance.Create(EntityTypes.Instance.GetByName("LogicGetConstantValueAction"), this);
((LogicGetConstantValueAction)this.abD).ValueType = this.VariableType;
this.abD.PostCreate();
}
}
return(true);
}
else
{
if (!(linkName == "valueAction"))
{
return(base.OnLinkedTextClick(linkName));
}
LogicAction logicAction = this.abD;
if (!LogicEditorFunctionality.Instance.ShowActionDialog(this, this.abd, false, ref logicAction))
{
return(false);
}
this.abD = logicAction;
return(true);
}
}
/// <summary>
/// 数据转换: 将<paramref name="strValue"/>转化成<paramref name="type"/>，输出<paramref name="outValue"/>
/// </summary>
/// <param name="type"></param>
/// <param name="strValue"></param>
/// <param name="errorString"></param>
/// <param name="outValue"></param>
/// <returns></returns>
public static bool ConvertFromString(Type type, string strValue, string errorString, out object outValue)
{
outValue = null;
try
{
#region Simple Type
if (SimpleTypesUtils.IsSimpleType(type))
{
if (strValue == "")
{
if (type == typeof(string))
{
outValue = "";
return(true);
}
if (errorString != null)
{
Log.Error("Entity System: Serialization error. The invalid value \"{0}\" for type \"{1}\" ({2}).", strValue, type, errorString);
}
return(false);
}
outValue = SimpleTypesUtils.GetSimpleTypeValue(type, strValue);
return(outValue != null);
}
#endregion
#region Entity
if (typeof(Entity).IsAssignableFrom(type))
{
if (strValue == "null" || strValue == "")
{
return(true);
}
Entity loadingEntityBySerializedUIN = Entities.Instance.GetLoadingEntityBySerializedUIN(uint.Parse(strValue));
bool isEntityExists = (EntitySystemWorld.Instance.IsSingle() || EntitySystemWorld.Instance.IsEditor()) && loadingEntityBySerializedUIN == null;
if (isEntityExists)
{
if (errorString != null)
{
Log.Error("Entity System: Serialization error. The entity with UIN \"{0}\" is not exists ({1}).", strValue, errorString);
}
return(false);
}
outValue = loadingEntityBySerializedUIN;
return(true);
}
#endregion
#region EntityType
if (typeof(EntityType).IsAssignableFrom(type))
{
if (strValue == "null" || strValue == "")
{
return(true);
}
EntityType byName = EntityTypes.Instance.GetByName(strValue);
if (byName == null)
{
if (errorString != null)
{
Log.Error("Entity System: Serialization error. The entity type is not defined \"{0}\" ({1}).", strValue, errorString);
}
return(false);
}
outValue = byName;
return(true);
}
#endregion
#region typeof(Type) == type
if (typeof(Type) == type)
{
if (strValue == "null" || strValue == "")
{
return(true);
}
if (strValue.Contains("Engine.UISystem.E"))
{
string[] rControl = new string[]
{
"VideoBox",
"Button",
"CheckBox",
"ComboBox",
"Control",
"EditBox",
"ListBox",
"ScrollBar",
"TabControl",
"TextBox"
};
for (int i = 0; i < rControl.Length; i++)
{
string str = rControl[i];
bool flag17 = strValue == "Engine.UISystem.E" + str;
if (flag17)
{
strValue = "Engine.UISystem." + str;
break;
}
}
}
Type typeControl = null;
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
for (int j = 0; j < assemblies.Length; j++)
{
Assembly assembly = assemblies[j];
typeControl = assembly.GetType(strValue);
if (typeControl != null)
{
break;
}
}
if (typeControl == null)
{
if (errorString != null)
{
Log.Error("Entity System: Serialization error. The entity type is not found \"{0}\" ({1}).", strValue, errorString);
}
return(false);
}
outValue = typeControl;
return(true);
}
#endregion
if (errorString != null)
{
Log.Fatal("Entity System: Serialization for type \"{0}\" are not supported ({1}).", type.ToString(), errorString);
}
return(false);
}
catch (FormatException ex)
{
if (errorString != null)
{
Log.Error("Entity System: Serialization error: \"{0}\" ({1}).", ex.Message, errorString);
}
return(false);
}
}
public static bool SaveFieldValue(bool entitySerialize, object owner, FieldInfo field, TextBlock block, object defaultValue, string errorString)
{
if (field == null)
{
return(false);
}
object value = field.GetValue(owner);
if (value == null)
{
return(true);
}
string serializeName = GetFieldSerializeName(entitySerialize, field);
errorString += string.Format(", property: \"{0}\"", serializeName);
bool IsList = field.FieldType.IsGenericType && field.FieldType.Name == typeof(List <>).Name;
bool isArray = field.FieldType.IsArray;
bool FieldIsCollection = IsList | isArray;
if (FieldIsCollection)
{
if (isArray && field.FieldType.GetArrayRank() != 1)
{
Log.Fatal("Entity System: Serialization of arrays are supported only for one dimensions arrays ({0}).", errorString);
return(false);
}
bool saveResult = SaveCollectionFieldValue(entitySerialize, owner, field, block, defaultValue, errorString);
return(saveResult);
}
bool isEntityType = typeof(EntityType).IsAssignableFrom(field.FieldType);
bool isEntity = typeof(Entity).IsAssignableFrom(field.FieldType);
bool simpleSerialization = (SimpleTypesUtils.IsSimpleType(field.FieldType) | isEntityType | isEntity) || typeof(Type) == field.FieldType;
if (simpleSerialization)
{
if (!entitySerialize & isEntity)
{
Log.Fatal("Entity System: Serialization Entity classes in entity types is forbidden ({0}).", errorString);
return(false);
}
if (isEntity)
{
Entity entity = (Entity)value;
if (!entity.AllowSaveHerit())
{
Log.Fatal("Entity System: Serialization error. The reference to entity which does not allow serialization ({0}). Field to serialize: \"{1}\".", entity.ToString(), errorString);
return(false);
}
}
string saveValueString = ConvertToString(field.FieldType, value, errorString);
string defaultSaveValueString = null;
if (defaultValue != null)
{
bool isEnum = field.FieldType.IsEnum;
if (isEnum)
{
defaultSaveValueString = Enum.GetName(field.FieldType, defaultValue);
}
else
{
defaultSaveValueString = defaultValue.ToString();
}
}
bool shouldSave = (defaultSaveValueString != null && defaultSaveValueString != saveValueString) || (defaultValue == null && saveValueString != "");
if (shouldSave)
{
block.SetAttribute(serializeName, saveValueString);
}
return(true);
}
TextBlock blockSerialize = block.AddChild(serializeName);
Type type = field.FieldType;
if (field.FieldType == typeof(LogicEntityObject))
{
type = field.GetValue(owner).GetType();
}
while (type != null)
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
for (int m = 0; m < fields.Length; m++)
{
FieldInfo fieldInfo = fields[m];
if (!IsFieldSerializable(fieldInfo, entitySerialize))
{
continue;
}
bool saveResult = SaveFieldValue(entitySerialize, value, fieldInfo, blockSerialize, errorString);
if (!saveResult)
{
return(false);
}
}
type = type.BaseType;
}
return(true);
}
private static bool SaveCollectionFieldValue(
bool entitySerialize, object obj, FieldInfo fieldInfo, TextBlock textBlock,
object defaultObj, string errorMessage)
{
object value = fieldInfo.GetValue(obj);
bool isArray = fieldInfo.FieldType.IsArray;
List <object> items = new List <object>();
#region 获得Collection中的元素 -> items
if (isArray)
{
PropertyInfo propertyLength = fieldInfo.FieldType.GetProperty("Length");
MethodInfo methodGetValue = fieldInfo.FieldType.GetMethod("GetValue", new Type[]
{
typeof(int)
});
int arrayLength = (int)propertyLength.GetValue(value, null);
for (int i = 0; i < arrayLength; i++)
{
object o = methodGetValue.Invoke(value, new object[] { i });
items.Add(o);
}
}
else
{
PropertyInfo propertyCount = fieldInfo.FieldType.GetProperty("Count");
PropertyInfo propertyItem = fieldInfo.FieldType.GetProperty("Item");
int listCount = (int)propertyCount.GetValue(value, null);
for (int j = 0; j < listCount; j++)
{
object o1 = propertyItem.GetValue(value, new object[] { j });
items.Add(o1);
}
}
#endregion
bool entityTypeDefaultSerialize = !entitySerialize && obj is EntityType && defaultObj != null;
#region EntityType 如果是缺省值，就不保存
if (entityTypeDefaultSerialize)
{
int itemsCount = 0;
if (isArray)
{
PropertyInfo propertyLength = fieldInfo.FieldType.GetProperty("Length");
itemsCount = (int)propertyLength.GetValue(defaultObj, null);
}
else
{
PropertyInfo propertyCount = fieldInfo.FieldType.GetProperty("Count");
itemsCount = (int)propertyCount.GetValue(defaultObj, null);
}
if (items.Count == 0 & itemsCount == 0)
{
return(true);
}
}
#endregion
Type typeElement = typeof(object);
if (isArray)
{
typeElement = fieldInfo.FieldType.GetElementType();
}
else
{
typeElement = fieldInfo.FieldType.GetGenericArguments()[0];
}
string fieldSerializeName = GetFieldSerializeName(entitySerialize, fieldInfo);
if (typeElement == typeof(string))
{
TextBlock stringsBlock = textBlock.AddChild(fieldSerializeName);
for (int k = 0; k < items.Count; k++)
{
object item = items[k];
TextBlock textBlock3 = stringsBlock.AddChild("item");
if (item != null)
{
textBlock3.SetAttribute("value", (string)item);
}
else
{
textBlock3.SetAttribute(NULL_ITEM, true.ToString());
}
}
return(true);
}
bool isEntityType = typeof(EntityType).IsAssignableFrom(typeElement);
bool isEntity = typeof(Entity).IsAssignableFrom(typeElement);
bool simpleTypeSerializing = (SimpleTypesUtils.IsSimpleType(typeElement) | isEntityType | isEntity) || typeof(Type) == typeElement;
if (simpleTypeSerializing)
{
if (!entitySerialize & isEntity)
{
Log.Fatal("Entity System: Serialization Entity classes in entity types is forbidden ({0}).", errorMessage);
return(false);
}
char itemSeperator = typeElement.IsPrimitive | isEntity? ' ' : ';';
StringBuilder stringBuilder = new StringBuilder();
for (int l = 0; l < items.Count; l++)
{
object item = items[l];
if (isEntity && item != null)
{
Entity entity = (Entity)item;
if (!entity.AllowSaveHerit())
{
Log.Fatal("Entity System: Serialization error. The reference to entity which does not allow serialization ({0}). Field to serialize: \"{1}\".", entity.ToString(), errorMessage);
return(false);
}
}
if (l != 0)
{
stringBuilder.Append(itemSeperator);
}
if (item != null)
{
stringBuilder.Append(ConvertToString(typeElement, item, errorMessage + ": " + fieldSerializeName));
}
else
{
stringBuilder.Append("null");
}
}
textBlock.SetAttribute(fieldSerializeName, stringBuilder.ToString());
return(true);
}
TextBlock textBlockField = textBlock.AddChild(fieldSerializeName);
List <FieldInfo> list = GetTypeSerializableFields(entitySerialize, typeElement);
for (int m = 0; m < items.Count; m++)
{
object item = items[m];
TextBlock textBlockItem = textBlockField.AddChild("item");
if (item == null)
{
textBlockItem.SetAttribute(NULL_ITEM, true.ToString());
continue;
}
for (int k = 0; k < list.Count; k++)
{
FieldInfo elementField = list[k];
bool _saveResult = SaveFieldValue(entitySerialize, item, elementField, textBlockItem, errorMessage);
if (!_saveResult)
{
return(false);
}
}
}
return(true);
}
public static bool LoadFieldValue(bool entitySerialize, object owner, FieldInfo field, TextBlock block, string errorString)
{
string fieldName = GetFieldSerializeName(entitySerialize, field);
errorString += string.Format(", property: \"{0}\"", fieldName);
bool isList = field.FieldType.IsGenericType && field.FieldType.Name == typeof(List <>).Name;
bool isArray = field.FieldType.IsArray;
if (isList || isArray)
{
if (isArray && field.FieldType.GetArrayRank() != 1)
{
Log.Fatal("Entity System: Serialization of arrays are supported only for one dimensions arrays ({0}).", errorString);
return(false);
}
bool loadResult = LoadArrayFieldValue(entitySerialize, owner, field, block, errorString);
return(loadResult);
}
bool isEntityType = typeof(EntityType).IsAssignableFrom(field.FieldType);
bool isEntity = typeof(Entity).IsAssignableFrom(field.FieldType);
bool typeSupport = (SimpleTypesUtils.IsSimpleType(field.FieldType) | isEntityType | isEntity) || typeof(Type) == field.FieldType;
if (typeSupport)
{
if (!entitySerialize & isEntity)
{
Log.Fatal("Entity System: Serialization Entity classes in entity types is forbidden ({0}).", errorString);
return(false);
}
bool fieldExists = block.IsAttributeExist(fieldName);
if (fieldExists)
{
string fieldValue = block.GetAttribute(fieldName);
object value;
bool convertResult = ConvertFromString(field.FieldType, fieldValue, errorString, out value);
if (!convertResult)
{
return(false);
}
field.SetValue(owner, value);
}
return(true);
}
TextBlock textBlock = block.FindChild(fieldName);
if (textBlock == null)
{
return(true);
}
object obj = field.GetValue(owner);
if (obj == null)
{
obj = field.FieldType.InvokeMember("", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance, null, null, null);
field.SetValue(owner, obj);
}
Type type = field.FieldType;
if (type == typeof(LogicEntityObject))
{
type = field.GetValue(owner).GetType();
}
while (type != null)
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
for (int j = 0; j < fields.Length; j++)
{
FieldInfo fieldInfo = fields[j];
if (!IsFieldSerializable(fieldInfo, entitySerialize))
{
continue;
}
bool loadFailure = !LoadFieldValue(entitySerialize, obj, fieldInfo, textBlock, errorString);
if (loadFailure)
{
return(false);
}
}
type = type.BaseType;
}
if (obj.GetType().IsValueType)
{
field.SetValue(owner, obj);
}
return(true);
}
private static bool LoadArrayFieldValue(bool entitySerialize, object targetObj, FieldInfo fieldInfo, TextBlock textBlock, string text)
{
bool isArray = fieldInfo.FieldType.IsArray;
Type typeElement;
if (isArray)
{
typeElement = fieldInfo.FieldType.GetElementType();
}
else
{
typeElement = fieldInfo.FieldType.GetGenericArguments()[0];
}
string name = GetFieldSerializeName(entitySerialize, fieldInfo);
TextBlock blockChild = textBlock.FindChild(name);
#region typeElement == typeof(string)
if (typeElement == typeof(string))
{
if (blockChild != null)
{
List <object> list = new List <object>(blockChild.Children.Count);
foreach (TextBlock current in blockChild.Children)
{
string currentValue = current.GetAttribute("value");
if (string.IsNullOrEmpty(currentValue) && string.Compare(current.GetAttribute(NULL_ITEM), "true", true) == 0)
{
currentValue = null;
}
list.Add(currentValue);
}
SetArrayFieldValue(targetObj, fieldInfo, list);
}
return(true);
}
#endregion
#region Simple Type
bool typeIsEntityType = typeof(EntityType).IsAssignableFrom(typeElement);
bool typeIsEntity = typeof(Entity).IsAssignableFrom(typeElement);
if ((SimpleTypesUtils.IsSimpleType(typeElement) | typeIsEntityType | typeIsEntity) || typeof(Type) == typeElement)
{
if (!entitySerialize & typeIsEntity)
{
Log.Fatal("Entity System: Serialization Entity classes in entity types is forbidden ({0}).", text);
return(false);
}
if (textBlock.IsAttributeExist(name))
{
string nameAttr = textBlock.GetAttribute(name);
string[] nameArr;
if (nameAttr.Length != 0)
{
char c = ';';
bool flag11 = typeElement.IsPrimitive | typeIsEntity;
if (flag11)
{
c = ' ';
}
nameArr = nameAttr.Split(new char[] { c });
}
else
{
nameArr = new string[0];
}
List <object> values = new List <object>(nameArr.Length);
for (int i = 0; i < nameArr.Length; i++)
{
string strValue = nameArr[i];
object item;
bool loadFailure = !ConvertFromString(typeElement, strValue, text, out item);
if (loadFailure)
{
return(false);
}
values.Add(item);
}
SetArrayFieldValue(targetObj, fieldInfo, values);
}
return(true);
}
#endregion
if (blockChild != null)
{
List <FieldInfo> typeElementFields = GetTypeSerializableFields(entitySerialize, typeElement);
List <object> children = new List <object>(blockChild.Children.Count);
foreach (TextBlock textChild in blockChild.Children)
{
object elementObject;
if (string.Compare(textChild.GetAttribute(NULL_ITEM), "true", true) != 0)
{
elementObject = typeElement.InvokeMember("", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance, null, null, null);
if (elementObject == null)
{
Log.Fatal("EntitySystem: Serialization: InvokeMember failed for \"{0}\"", typeElement);
return(false);
}
using (List <FieldInfo> .Enumerator itElementField = typeElementFields.GetEnumerator())
{
while (itElementField.MoveNext())
{
FieldInfo currentField = itElementField.Current;
bool loadOk = LoadFieldValue(entitySerialize, elementObject, currentField, textChild, text);
if (!loadOk)
{
return(false);
}
}
children.Add(elementObject);
continue;
}
}
children.Add(null);
}
SetArrayFieldValue(targetObj, fieldInfo, children);
}
return(true);
}
