private static SharedVariable BytesToSharedVariable(FieldSerializationData fieldSerializationData, Dictionary <string, int> fieldIndexMap, byte[] bytes, int dataPosition, IVariableSource variableSource, bool fromField, string namePrefix)
{
SharedVariable sharedVariable = null;
string text = (string)LoadField(fieldSerializationData, fieldIndexMap, typeof(string), namePrefix + "Type", null);
if (string.IsNullOrEmpty(text))
{
return(null);
}
string name = (string)LoadField(fieldSerializationData, fieldIndexMap, typeof(string), namePrefix + "Name", null);
bool flag = Convert.ToBoolean(LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), namePrefix + "IsShared", null, null, null));
bool flag2 = Convert.ToBoolean(LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), namePrefix + "IsGlobal", null, null, null));
if (flag && fromField)
{
if (!flag2)
{
sharedVariable = variableSource.GetVariable(name);
}
else
{
if (globalVariables == null)
{
globalVariables = GlobalVariables.Instance;
}
if (globalVariables != null)
{
sharedVariable = globalVariables.GetVariable(name);
}
}
}
Type typeWithinAssembly = TaskUtility.GetTypeWithinAssembly(text);
if (typeWithinAssembly == null)
{
return(null);
}
bool flag3 = true;
if (sharedVariable == null || !(flag3 = sharedVariable.GetType().Equals(typeWithinAssembly)))
{
sharedVariable = (TaskUtility.CreateInstance(typeWithinAssembly) as SharedVariable);
sharedVariable.Name = name;
sharedVariable.IsShared = flag;
sharedVariable.IsGlobal = flag2;
sharedVariable.NetworkSync = Convert.ToBoolean(LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), namePrefix + "NetworkSync", null));
if (!flag2)
{
sharedVariable.PropertyMapping = (string)LoadField(fieldSerializationData, fieldIndexMap, typeof(string), namePrefix + "PropertyMapping", null);
sharedVariable.PropertyMappingOwner = (GameObject)LoadField(fieldSerializationData, fieldIndexMap, typeof(GameObject), namePrefix + "PropertyMappingOwner", null);
sharedVariable.InitializePropertyMapping(variableSource as BehaviorSource);
}
if (!flag3)
{
sharedVariable.IsShared = true;
}
LoadFields(fieldSerializationData, fieldIndexMap, sharedVariable, namePrefix, variableSource);
}
return(sharedVariable);
}
protected override string ProcessControl(string variableIdentifier, IVariableSource variableSource,
ContentControl contentControl, List <string> otherParameters)
{
try
{
var variable = variableSource.GetVariable(variableIdentifier);
if (variable == null)
{
return(null);
}
//If the variable is not of a complex type or if the content control does not support nested controls,
//(ie, is not a RichText control), then just return the string representation of the variable
if (contentControl.Type != OpenXmlExtensions.ContentControlType.RichText ||
!(variable is Dictionary <string, object> innerData))
{
return(variable.ToString());
}
//If the variable is complex (dictionary) type and the control is rich text, we need to do
//recursive replacement. For that we will add it to the queue
var innerVariableSource = new VariableSource(innerData);
Enqueue(new ControlReplacementExecutionData
{
Controls = contentControl.DescendingControls, VariableSource = innerVariableSource
});
return(null);
}
catch (VariableNotFoundException)
{
return(null);
}
}
internal static bool EvaluateVariable(string varIdentifier, IVariableSource data, out object variableValue)
{
bool value;
try
{
variableValue = data.GetVariable(varIdentifier);
value = EvaluateVariableValue(variableValue);
}
catch (VariableNotFoundException)
{
value = false;
variableValue = null;
}
return(value);
}
protected override string ProcessDropdownControl(string variableIdentifier, IVariableSource data,
SdtContentDropDownList dropdown, List <string> otherParameters)
{
//This is the list that we should check to see if the value should be singular or plural
var list = data.GetVariable <IList>(variableIdentifier);
var singular = list.Count <= 1;
if (dropdown.ChildElements.Count == 0)
{
return(null);
}
var dropdownChildElement = singular || dropdown.ChildElements.Count == 1
? dropdown.ChildElements[0]
: dropdown.ChildElements[1];
return(GetListItemValue(dropdownChildElement));
}
protected override string ProcessControl(string variableIdentifier, IVariableSource variableSource,
ContentControl contentControl, List <string> otherParameters)
{
try {
var variable = variableSource.GetVariable(variableIdentifier);
if (variable == null)
{
return(null);
}
var imagePath = variable.ToString();
var byteArray = File.ReadAllBytes(imagePath);
return(Convert.ToBase64String(byteArray));
} catch (VariableNotFoundException) {
return(null);
}
}
private static SharedVariable DeserializeSharedVariable(Dictionary <string, object> dict, IVariableSource variableSource, bool fromSource, List <UnityEngine.Object> unityObjects)
{
if (dict == null)
{
return(null);
}
SharedVariable sharedVariable = null;
object obj;
if (!fromSource && variableSource != null && dict.TryGetValue("Name", out obj))
{
object value;
dict.TryGetValue("IsGlobal", out value);
if (!dict.TryGetValue("IsGlobal", out value) || !Convert.ToBoolean(value))
{
sharedVariable = variableSource.GetVariable(obj as string);
}
else
{
if (JSONDeserializationDeprecated.globalVariables == null)
{
JSONDeserializationDeprecated.globalVariables = GlobalVariables.Instance;
}
if (JSONDeserializationDeprecated.globalVariables != null)
{
sharedVariable = JSONDeserializationDeprecated.globalVariables.GetVariable(obj as string);
}
}
}
Type typeWithinAssembly = TaskUtility.GetTypeWithinAssembly(dict["Type"] as string);
if (typeWithinAssembly == null)
{
return(null);
}
bool flag = true;
if (sharedVariable == null || !(flag = sharedVariable.GetType().Equals(typeWithinAssembly)))
{
sharedVariable = (TaskUtility.CreateInstance(typeWithinAssembly) as SharedVariable);
sharedVariable.name = (dict["Name"] as string);
object obj2;
if (dict.TryGetValue("IsShared", out obj2))
{
sharedVariable.isShared = Convert.ToBoolean(obj2);
}
if (dict.TryGetValue("IsGlobal", out obj2))
{
sharedVariable.isGlobal = Convert.ToBoolean(obj2);
}
if (dict.TryGetValue("NetworkSync", out obj2))
{
sharedVariable.networkSync = Convert.ToBoolean(obj2);
}
if (!sharedVariable.isGlobal && dict.TryGetValue("PropertyMapping", out obj2))
{
sharedVariable.propertyMapping = (obj2 as string);
if (dict.TryGetValue("PropertyMappingOwner", out obj2))
{
sharedVariable.propertyMappingOwner = (JSONDeserializationDeprecated.IndexToUnityObject(Convert.ToInt32(obj2), unityObjects) as GameObject);
}
sharedVariable.InitializePropertyMapping(variableSource as BehaviorSource);
}
if (!flag)
{
sharedVariable.isShared = true;
}
JSONDeserializationDeprecated.DeserializeObject(null, sharedVariable, dict, variableSource, unityObjects);
}
return(sharedVariable);
}
internal static bool EvaluateConditionalVariableWithParameters(string varIdentifier,
IVariableSource variableSource,
List <string> otherParameters)
{
var value = EvaluateVariable(varIdentifier, variableSource, out var variableValue);
//If no special parameters are found simply return the found value
if (otherParameters.Count <= 0)
{
return(value);
}
//Process the extra parameters
string lastOperator = null;
foreach (var otherParameter in otherParameters)
{
switch (otherParameter)
{
case OrTagIdentifier:
case AndTagIdentifier:
case EqualTagIdentifier:
case GreaterTagIdentifier:
case LessTagIdentifier:
lastOperator = otherParameter;
break;
case NotTagIdentifier:
value = !value;
lastOperator = null;
break;
default:
{
if (lastOperator != null)
{
object nextValue;
nextValue = variableSource.GetVariable(otherParameter) ?? otherParameter;
var nextValueEvaluated = EvaluateVariableValue(nextValue);
switch (lastOperator)
{
case OrTagIdentifier:
value = value || nextValueEvaluated;
break;
case AndTagIdentifier:
value = value && nextValueEvaluated;
break;
case EqualTagIdentifier:
value = variableValue?.ToString() == nextValue.ToString();
break;
case GreaterTagIdentifier:
try
{
value = float.Parse(variableValue?.ToString()) > float.Parse(nextValue.ToString());
}
catch
{
try
{
value = int.Parse(variableValue?.ToString()) > int.Parse(nextValue.ToString());
}
catch
{
// ignored
}
}
break;
case LessTagIdentifier:
try
{
value = float.Parse(variableValue?.ToString()) < float.Parse(nextValue.ToString());
}
catch
{
try
{
value = int.Parse(variableValue?.ToString()) < int.Parse(nextValue.ToString());
}
catch
{
// ignored
}
}
break;
}
lastOperator = null;
}
break;
}
}
}
return(value);
}
private static bool VariableNameValid(IVariableSource variableSource, string variableName)
{
return(!variableName.Equals(string.Empty) && (variableSource == null || variableSource.GetVariable(variableName) == null));
}
private static void DoVariablesToICodeSync(IVariableSource variableSource, FsmVariable[] iCodeVariables)
{
if (variableSource == null)
{
return;
}
SharedVariable behaviorDesignerVariable = null;
FsmVariable iCodeVariable = null;
for (int i = 0; i < iCodeVariables.Length; ++i)
{
iCodeVariable = iCodeVariables[i];
if ((behaviorDesignerVariable = variableSource.GetVariable(iCodeVariable.Name)) != null)
{
// FsmInt
if (iCodeVariable is FsmInt)
{
if (behaviorDesignerVariable is SharedInt)
{
(iCodeVariable as FsmInt).Value = (int)behaviorDesignerVariable.GetValue();
}
continue;
}
// FsmFloat
if (iCodeVariable is FsmFloat)
{
if (behaviorDesignerVariable is SharedFloat)
{
(iCodeVariable as FsmFloat).Value = (float)behaviorDesignerVariable.GetValue();
}
continue;
}
// FsmBool
if (iCodeVariable is FsmBool)
{
if (behaviorDesignerVariable is SharedBool)
{
(iCodeVariable as FsmBool).Value = (bool)behaviorDesignerVariable.GetValue();
}
continue;
}
// FsmString
if (iCodeVariable is FsmString)
{
if (behaviorDesignerVariable is SharedString)
{
(iCodeVariable as FsmString).Value = (string)behaviorDesignerVariable.GetValue();
}
continue;
}
// FsmColor
if (iCodeVariable is FsmColor)
{
if (behaviorDesignerVariable is SharedColor)
{
(iCodeVariable as FsmColor).Value = (Color)behaviorDesignerVariable.GetValue();
}
continue;
}
// FsmVector2
if (iCodeVariable is FsmVector2)
{
if (behaviorDesignerVariable is SharedVector2)
{
(iCodeVariable as FsmVector2).Value = (Vector2)behaviorDesignerVariable.GetValue();
}
continue;
}
// FsmVector3
if (iCodeVariable is FsmVector3)
{
if (behaviorDesignerVariable is SharedVector3)
{
(iCodeVariable as FsmVector3).Value = (Vector3)behaviorDesignerVariable.GetValue();
}
continue;
}
// FsmObject
if (iCodeVariable is FsmObject)
{
if (behaviorDesignerVariable is SharedGameObject)
{
(iCodeVariable as FsmObject).Value = (GameObject)behaviorDesignerVariable.GetValue();
}
else if (behaviorDesignerVariable is SharedObject)
{
(iCodeVariable as FsmObject).Value = (Object)behaviorDesignerVariable.GetValue();
}
continue;
}
}
}
}
protected override string ProcessControl(string variableIdentifier, IVariableSource variableSource,
ContentControl original, List <string> otherParameters)
{
try
{
GetParameters(otherParameters, out var separator, out var lastSeparator);
var dataItems = variableSource.GetVariable <IList>(variableIdentifier);
if (dataItems == null || dataItems.Count == 0)
{
//No items found, remove the content
original.Remove();
return(null);
}
//Copy the content control as many times as we have items
for (var i = 0; i < dataItems.Count; i++)
{
var dataItem = dataItems[i];
var clone = original.Clone();
switch (dataItem)
{
case string _:
case int _:
case float _:
case double _:
case decimal _:
SetTextAndRemovePlaceholderFormat(clone.SdtElement, dataItem.ToString());
break;
case Dictionary <string, object> dictItem:
{
if (dictItem.ContainsKey("index") == false)
{
dictItem.Add("index", i + 1);
}
//Since we are creating new elements, we should add them to the queue with both this and the inner data
var innerSource = new VariableSource(dictItem);
var exInner = new ControlReplacementExecutionData(clone.DescendingControls, innerSource);
var ex = new ControlReplacementExecutionData(clone.DescendingControls, variableSource);
Enqueue(exInner);
OnInnerControlReplacementEnqueued(ex);
OnInnerControlReplacementEnqueued(exInner);
//Support old styled documents
var innerRep1 = new InnerRepeatingVariableControlReplacer();
var innerRep2 = new InnerRepeatingConditionalRemoveControlReplacer();
innerRep1.ReplaceAll(ex.Controls, ex.VariableSource);
innerRep2.ReplaceAll(ex.Controls, ex.VariableSource);
break;
}
}
var lasttext = clone.SdtElement.Descendants <Text>().LastOrDefault();
if (lasttext != null)
{
if (i < dataItems.Count - 2)
{
lasttext.InsertAfterSelf(new Text(separator)
{
Space = SpaceProcessingModeValues.Preserve
});
}
else if (i < dataItems.Count - 1)
{
lasttext.InsertAfterSelf(new Text(lastSeparator)
{
Space = SpaceProcessingModeValues.Preserve
});
}
}
}
//Delete the original
original.Remove();
return(null);
}
catch (VariableNotFoundException)
{
return(null);
}
}
