/// <summary>
/// Sets the value of the property
/// </summary>
/// <param name="script">The script.</param>
/// <param name="obj">The object.</param>
/// <param name="v">The value to set.</param>
public void SetValue(Script script, object obj, DynValue v)
{
this.CheckAccess(MemberDescriptorAccess.CanWrite, obj);
if (IsReadonly || IsConst)
throw new ScriptRuntimeException("userdata field '{0}.{1}' cannot be written to.", this.FieldInfo.DeclaringType.Name, this.Name);
object value = ScriptToClrConversions.DynValueToObjectOfType(v, this.FieldInfo.FieldType, null, false);
try
{
if (value is double)
value = NumericConversions.DoubleToType(FieldInfo.FieldType, (double)value);
FieldInfo.SetValue(IsStatic ? null : obj, value);
}
catch (ArgumentException)
{
// non-optimized setters fall here
throw ScriptRuntimeException.UserDataArgumentTypeMismatch(v.Type, FieldInfo.FieldType);
}
catch (InvalidCastException)
{
// optimized setters fall here
throw ScriptRuntimeException.UserDataArgumentTypeMismatch(v.Type, FieldInfo.FieldType);
}
catch (FieldAccessException ex)
{
throw new ScriptRuntimeException(ex);
}
}
public void CreateStackedMaps()
{
if (mapSlicesDropdown.options == null || mapSlicesDropdown.options.Count < 1)
{
return;
}
var numberOfSlices = Int32.Parse(mapSlicesDropdown.options[mapSlicesDropdown.value].text);
if (numberOfSlices < 2)
{
return;
}
var splittedList = SplitCenturiesInChunks(centuriesValues, numberOfSlices);
foreach (var centuryList in splittedList)
{
var s = "{ ";
foreach (var cent in centuryList)
{
s += cent.century + ", ";
}
s += "}";
}
var listOfMaps = new List <GameObject>();
foreach (var centuryList in splittedList)
{
var firstCentury = centuryList.First();
var lastCentury = centuryList.Count > 1 ? centuryList.Last() : centuryList.First();
var go = SilkMap.Instance.createPlane(firstCentury.from, lastCentury.to);
//go.name = $"Centuries {centuryList.First().century} to {centuryList.Last().century}";
var first = centuryList.First().century;
var last = centuryList.Last().century;
var from = I18N.instance.gameLang == LanguageCode.EN
? NumericConversions.AddOrdinal(first)
: NumericConversions.ArabicToRoman(first);
var to = I18N.instance.gameLang == LanguageCode.EN
? NumericConversions.AddOrdinal(last)
: NumericConversions.ArabicToRoman(last);
var timeParams = new[] { from, to };
go.name = I18N.instance.getValue("^stacked_centuries_label", timeParams);
listOfMaps.Add(go);
go.layer = LayerMask.NameToLayer("StackedMap");
RunOnChildrenRecursive(go, child => child.layer = LayerMask.NameToLayer("StackedMap"));
}
AnalyticsMonitor.instance.sendEvent("Generate_Time_Layers", new Dictionary <string, object>
{
{ "numberOfLayers", numberOfSlices }
});
MapUIManager.instance.ToggleMapViewingMode(listOfMaps);
}
private void HandleValueChanged(float value)
{
var crono = Stopwatch.StartNew();
UpdateTimeFrame(value);
//Debug.Log($"UpdateTimeFrame {crono.ElapsedMilliseconds * 0.001f} segundos");
//sliderText.text = slider.value.ToString(CultureInfo.InvariantCulture);
sliderText.text = I18N.instance.gameLang == LanguageCode.EN
? NumericConversions.AddOrdinal((int)slider.value)
: NumericConversions.ArabicToRoman((int)slider.value);
}
// Start is called before the first frame update
private void OnEnable()
{
slider.onValueChanged.RemoveAllListeners();
slider.onValueChanged.AddListener(HandleValueChanged);
sliderText.text = I18N.instance.gameLang == LanguageCode.EN
? NumericConversions.AddOrdinal((int)slider.value)
: NumericConversions.ArabicToRoman((int)slider.value);
if (currentValues == null)
{
currentValues = new List <TimeElement>();
}
}
public static DynValue SerializeObjectToDynValue(Script script, object o, DynValue valueForNulls = null, DynValue valueForEmptyEnumerable = null)
{
if (o == null)
{
return(valueForNulls ?? DynValue.Nil);
}
DynValue v = ClrToScriptConversions.TryObjectToTrivialDynValue(script, o);
if (v != null)
{
return(v);
}
if (o is Enum)
{
return(DynValue.NewNumber(NumericConversions.TypeToDouble(Enum.GetUnderlyingType(o.GetType()), o)));
}
Table t = new Table(script);
System.Collections.IEnumerable ienum = o as System.Collections.IEnumerable;
if (ienum != null)
{
foreach (object obj in ienum)
{
t.Append(SerializeObjectToDynValue(script, obj, valueForNulls, valueForEmptyEnumerable));
}
if (valueForEmptyEnumerable != null && t.Length == 0)
{
return(valueForEmptyEnumerable);
}
}
else
{
Type type = o.GetType();
foreach (PropertyInfo pi in Framework.Do.GetProperties(type))
{
var getter = Framework.Do.GetGetMethod(pi);
var isStatic = getter.IsStatic;
var obj = getter.Invoke(isStatic ? null : o, null); // convoluted workaround for --full-aot Mono execution
t.Set(pi.Name, SerializeObjectToDynValue(script, obj, valueForNulls, valueForEmptyEnumerable));
}
}
return(DynValue.NewTable(t));
}
/// <summary>
/// Sets the value of the property
/// </summary>
/// <param name="script">The script.</param>
/// <param name="obj">The object.</param>
/// <param name="v">The value to set.</param>
public void SetValue(Script script, object obj, DynValue v)
{
this.CheckAccess(MemberDescriptorAccess.CanWrite, obj);
if (m_Setter == null)
{
throw new ScriptRuntimeException("userdata property '{0}.{1}' cannot be written to.",
this.PropertyInfo.DeclaringType.Name, this.Name);
}
var value = ScriptToClrConversions.DynValueToObjectOfType(v, this.PropertyInfo.PropertyType, null, false);
try
{
if (value is double d)
{
value = NumericConversions.DoubleToType(this.PropertyInfo.PropertyType, d);
}
if (this.AccessMode == InteropAccessMode.LazyOptimized && m_OptimizedSetter == null)
{
this.OptimizeSetter();
}
if (m_OptimizedSetter != null)
{
m_OptimizedSetter(obj, value);
}
else
{
m_Setter.Invoke(this.IsStatic ? null : obj,
new[] { value }); // convoluted workaround for --full-aot Mono execution
}
}
catch (ArgumentException)
{
// non-optimized setters fall here
throw ScriptRuntimeException.UserDataArgumentTypeMismatch(v.Type, this.PropertyInfo.PropertyType);
}
catch (InvalidCastException)
{
// optimized setters fall here
throw ScriptRuntimeException.UserDataArgumentTypeMismatch(v.Type, this.PropertyInfo.PropertyType);
}
}
public static DynValue SerializeObjectToDynValue(Script script, object o, DynValue valueForNulls = null)
{
if (o == null)
{
return(valueForNulls ?? DynValue.Nil);
}
var v = ClrToScriptConversions.TryObjectToTrivialDynValue(script, o);
if (v != null)
{
return(v);
}
if (o is Enum)
{
return(DynValue.NewNumber(NumericConversions.TypeToDouble(Enum.GetUnderlyingType(o.GetType()), o)));
}
var t = new Table(script);
if (o is IEnumerable ienum)
{
foreach (var obj in ienum)
{
t.Append(SerializeObjectToDynValue(script, obj, valueForNulls));
}
}
else
{
var type = o.GetType();
foreach (var pi in Framework.Do.GetProperties(type))
{
var getter = Framework.Do.GetGetMethod(pi);
bool isStatic = getter.IsStatic;
var obj = getter.Invoke(isStatic ? null : o,
null); // convoluted workaround for --full-aot Mono execution
t.Set(pi.Name, SerializeObjectToDynValue(script, obj, valueForNulls));
}
}
return(DynValue.NewTable(t));
}
/// <summary>
/// Tries to convert a CLR object to a MoonSharp value, using more in-depth analysis
/// </summary>
internal static R_VAL ObjectToValue(RubyState state, object obj)
{
R_VAL v = TryObjectToSimpleValue(script, obj);
if (v != null)
{
return(v);
}
v = UserData.Create(obj);
if (v != null)
{
return(v);
}
if (obj is Type)
{
v = UserData.CreateStatic(obj as Type);
}
// unregistered enums go as integers
if (obj is Enum)
{
return(R_VAL.NewNumber(
NumericConversions.TypeToDouble(Enum.GetUnderlyingType(obj.GetType()), obj)));
}
if (v != null)
{
return(v);
}
if (obj is Delegate)
{
return(R_VAL.NewCallback(CallbackFunction.FromDelegate(script, ( Delegate )obj)));
}
if (obj is MethodInfo)
{
MethodInfo mi = ( MethodInfo )obj;
if (mi.IsStatic)
{
return(R_VAL.NewCallback(CallbackFunction.FromMethodInfo(script, mi)));
}
}
if (obj is System.Collections.IList)
{
Table t = TableConversions.ConvertIListToTable(script, (System.Collections.IList)obj);
return(R_VAL.NewTable(t));
}
if (obj is System.Collections.IDictionary)
{
Table t = TableConversions.ConvertIDictionaryToTable(script, (System.Collections.IDictionary)obj);
return(R_VAL.NewTable(t));
}
var enumerator = EnumerationToValue(script, obj);
if (enumerator != null)
{
return(enumerator);
}
throw ScriptRuntimeException.ConvertObjectFailed(obj);
}
/// <summary>
/// Tries to convert a CLR object to a MoonSharp value, using "simple" logic.
/// Does NOT throw on failure.
/// </summary>
internal static R_VAL TryObjectToSimpleValue(RubyState state, object obj)
{
if (obj == null)
{
return(R_VAL.NIL);
}
if (obj is R_VAL)
{
return(( R_VAL )obj);
}
Type t = obj.GetType();
if (obj is bool)
{
return(R_VAL.NewBoolean(( bool )obj));
}
if (obj is string || obj is StringBuilder || obj is char)
{
return(R_VAL.NewString(obj.ToString()));
}
if (obj is Closure)
{
return(R_VAL.NewClosure(( Closure )obj));
}
if (NumericConversions.NumericTypes.Contains(t))
{
return(R_VAL.NewNumber(NumericConversions.TypeToDouble(t, obj)));
}
if (obj is Table)
{
return(R_VAL.NewTable(( Table )obj));
}
if (obj is CallbackFunction)
{
return(R_VAL.NewCallback(( CallbackFunction )obj));
}
if (obj is Delegate)
{
Delegate d = ( Delegate )obj;
#if NETFX_CORE
MethodInfo mi = d.GetMethodInfo();
#else
MethodInfo mi = d.Method;
#endif
if (CallbackFunction.CheckCallbackSignature(mi, false))
{
return(R_VAL.NewCallback((Func <ScriptExecutionContext, CallbackArguments, R_VAL>)d));
}
}
return(R_VAL.NIL);
}
/// <summary>
/// Converts a R_VAL to a CLR object of a specific type
/// </summary>
internal static object ValueToObjectOfType(RubyState state, R_VAL value, Type desiredType,
object defaultValue, bool isOptional)
{
if (desiredType.IsByRef)
{
desiredType = desiredType.GetElementType();
}
if (desiredType == typeof(R_VAL))
{
return(value);
}
if (desiredType == typeof(object))
{
return(ValueToObject(state, value));
}
StringConversions.StringSubtype stringSubType = StringConversions.GetStringSubtype(desiredType);
string str = null;
Type nt = Nullable.GetUnderlyingType(desiredType);
Type nullableType = null;
if (nt != null)
{
nullableType = desiredType;
desiredType = nt;
}
switch (value.tt)
{
case DataType.Void:
if (isOptional)
{
return(defaultValue);
}
else if ((!desiredType.IsValueType) || (nullableType != null))
{
return(null);
}
break;
case DataType.Nil:
if (Framework.Do.IsValueType(desiredType))
{
if (nullableType != null)
{
return(null);
}
if (isOptional)
{
return(defaultValue);
}
}
else
{
return(null);
}
break;
case DataType.Boolean:
if (desiredType == typeof(bool))
{
return(value.Boolean);
}
if (stringSubType != StringConversions.StringSubtype.None)
{
str = value.Boolean.ToString();
}
break;
case DataType.Number:
if (Framework.Do.IsEnum(desiredType))
{
// number to enum conv
Type underType = Enum.GetUnderlyingType(desiredType);
return(NumericConversions.DoubleToType(underType, value.Number));
}
if (NumericConversions.NumericTypes.Contains(desiredType))
{
return(NumericConversions.DoubleToType(desiredType, value.Number));
}
if (stringSubType != StringConversions.StringSubtype.None)
{
str = value.Number.ToString();
}
break;
case DataType.String:
if (stringSubType != StringConversions.StringSubtype.None)
{
str = value.String;
}
break;
case DataType.Function:
if (desiredType == typeof(Closure))
{
return(value.Function);
}
else if (desiredType == typeof(ScriptFunctionDelegate))
{
return(value.Function.GetDelegate());
}
break;
case DataType.ClrFunction:
if (desiredType == typeof(CallbackFunction))
{
return(value.Callback);
}
else if (desiredType == typeof(Func <ScriptExecutionContext, CallbackArguments, R_VAL>))
{
return(value.Callback.ClrCallback);
}
break;
case DataType.UserData:
if (value.UserData.Object != null)
{
var udObj = value.UserData.Object;
var udDesc = value.UserData.Descriptor;
if (udDesc.IsTypeCompatible(desiredType, udObj))
{
return(udObj);
}
if (stringSubType != StringConversions.StringSubtype.None)
{
str = udDesc.AsString(udObj);
}
}
break;
case DataType.Table:
if (desiredType == typeof(Table) ||
Framework.Do.IsAssignableFrom(desiredType, typeof(Table)))
{
return(value.Table);
}
else
{
object o = TableConversions.ConvertTableToType(value.Table, desiredType);
if (o != null)
{
return(o);
}
}
break;
case DataType.Tuple:
break;
}
if (stringSubType != StringConversions.StringSubtype.None && str != null)
{
return(StringConversions.ConvertString(stringSubType, str, desiredType, value.Type));
}
throw ScriptRuntimeException.ConvertObjectFailed(value.Type, desiredType);
}
