public BaseValue Call(IFunction function, IExecutionContext context)
{
if (function == null)
{
throw new ArgumentNullException(nameof(function));
}
if (function.Arguments.Count != context.Count)
{
throw new ArgumentOutOfRangeException(nameof(context));
}
// convert arguments
var actualArguments = new BaseValue[context.Count];
for (var i = 0; i < context.Count; ++i)
{
actualArguments[i] = ConvertTo(context[i], function.Arguments[i]);
}
// call the function
return(function.Call(new ExecutionContext(
actualArguments,
this,
context.Entity,
context.Line,
context.Column)));
}
public ValueSuggestion(CaretToken caretToken, BaseValue value)
: base(caretToken,
FormatValue(value),
value.ToString(CultureInfo.CurrentCulture),
value.Type.ToString())
{
}
public BaseValueView(BaseValue baseValue)
{
BaseValue = baseValue;
DataContext = baseValue;
InitializeComponent();
}
public void FromJsonTest_InvalidJson()
{
string json = "Invalid";
BaseValue expected = null;
BaseValue result = BaseValue.FromJson(json);
Assert.AreEqual(expected, result);
}
public void SetValue(string arrayName, string index, BaseValue value)
{
if (this.arrays.TryGetValue(arrayName, out ArrayValue array))
{
array.SetIndex(index, value);
this.arrays[arrayName] = array;
}
}
public void SetValue(string arrayName, string index, BaseValue value)
{
if (this.arrays.TryGetValue(arrayName, out ArrayValue array))
{
var contents = array.ToDictionary();
contents[index] = value;
this.arrays[arrayName] = new ArrayValue(contents);
}
}
private static string FormatValue(BaseValue value)
{
if (value is DateTimeValue)
{
return("date(" + value.ToString() + ")");
}
return(value.ToString());
}
/// <summary>
/// 设置内部变量的值
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
public static void SetInternalValue(string name, object value)
{
BaseValue bv = data.GetBaseValue(name);
if (bv != null)
{
bv.SetValue(value);
}
}
public Type.TimeSpan Subtract(TimeOfDay other)
{
Type.TimeSpan result = BaseValue.Subtract(other.BaseValue);
Type.TimeSpan microNano = new Type.TimeSpan(0, 0, 0, 0, 0,
other.m_microsecond, other.m_nanosecond);
return(result.Subtract(microNano));
}
public TimeOfDay Add(TimeSpan timeSpan)
{
TimeOfDay result = new TimeOfDay(BaseValue.Add(timeSpan.ToSystemTimeSpan()),
m_microsecond, m_nanosecond);
result = result.AddMicrosecondsInternal(timeSpan.Microseconds);
result = result.AddNanosecondsInternal(timeSpan.Nanoseconds);
return(result.CheckForWrapAround());
}
public LogicRuntimeMachine(int id, LogicObjectContainer data)
{
this.id = id;
this.data = data;
for (int i = 0; i < data.internalValueList.Count; i++)
{
BaseValue bv = data.internalValueList[i];
inValueEventDic.Add(bv.name, null);
}
}
internal override void CompileBy(FunctionCompiler compiler, bool isLastOperator)
{
BaseValue.CompileBy(compiler, false);
CompilePropertyBy(compiler);
compiler.Emitter.Emit(OpCode.LdMember);
if (isLastOperator)
{
compiler.Emitter.Emit(OpCode.Pop);
}
}
public override string ToString()
{
try
{
return(BaseValue.ToString() + " " + Symbol);
}
catch (System.Exception)
{
return(Value.ToString());
}
}
/// <summary>
/// Changes a Talent by the given number of points.
/// </summary>
/// <param name="stat">Medicine, Speech, Herbalim, BombCrafting, Bestiary, Veterancy, Engineering, or History.</param>
/// <param name="points">Positive points to increase, negative points to decrease.</param>
public void AdjustTalent(string stat, int points)
{
if (BaseValue.ContainsKey(stat))
{
BaseValue[stat] += points;
}
else
{
throw new ArgumentException("Tried to change an invalid Talent.");
}
}
public void FromJsonTest_IncompleteJson_NoKey()
{
string json = "{\"value\":10}";
BaseValue expected = new BaseValue()
{
Key = null, Value = 10
};
BaseValue result = BaseValue.FromJson(json);
Assert.AreEqual(expected.Key, result.Key);
Assert.AreEqual(expected.Value, result.Value);
}
public void FromJsonTest_IncompleteJson_NoValue()
{
string json = "{\"StatKey\":\"B_DMG\"}";
BaseValue expected = new BaseValue()
{
Key = "B_DMG", Value = 0
};
BaseValue result = BaseValue.FromJson(json);
Assert.AreEqual(expected.Key, result.Key);
Assert.AreEqual(expected.Value, result.Value);
}
private static List <EntityView> GetOrAddList(
BaseValue key,
Dictionary <BaseValue, List <EntityView> > index)
{
if (!index.TryGetValue(key, out var list))
{
list = new List <EntityView>();
index.Add(key, list);
}
return(list);
}
public void FromJsonTest_Succes()
{
string json = "{\"StatKey\":\"B_DMG\",\"value\":10}";
BaseValue expected = new BaseValue()
{
Key = "B_DMG", Value = 10
};
BaseValue result = BaseValue.FromJson(json);
Assert.AreEqual(expected.Key, result.Key);
Assert.AreEqual(expected.Value, result.Value);
}
/// <summary>
/// Indicates whether this instance and a specified <see cref="Length" /> are equal.
/// </summary>
/// <param name="another">Another length to compare to.</param>
/// <returns><c>true</c> if <paramref name="another" /> and this instance represent the same value; otherwise, <c>false</c>.</returns>
public Boolean Equals(Length another)
{
if (ReferenceEquals(null, another))
{
return(false);
}
if (ReferenceEquals(this, another))
{
return(true);
}
return(BaseValue.Equals(another.BaseValue));
}
/// <summary>
/// Indicates whether this instance and a specified object are equal.
/// </summary>
/// <param name="obj">Another object to compare to.</param>
/// <returns><c>true</c> if <paramref name="obj" /> and this instance are the same type and represent the same value; otherwise, <c>false</c>.
/// </returns>
public override Boolean Equals(Object obj)
{
if (ReferenceEquals(null, obj))
{
return(false);
}
if (ReferenceEquals(this, obj))
{
return(true);
}
return((obj is Length) && BaseValue.Equals(((Length)obj).BaseValue));
}
private void Update()
{
//MiddleCenterTextBlock.Text = (BaseValue + LinkedCharacteristicValue).ToString();
if (UsesLinkedCharacteristic)
{
MiddleLeftTextBlock.Text = BaseValue.ToString();
MiddleRightTextBlock.Text = (BaseValue + LinkedCharacteristicValue).ToString();
}
else
{
MiddleLeftTextBlock.Text = LeftValue.ToString();
MiddleRightTextBlock.Text = RightValue.ToString();
}
}
/// <summary>
/// 获取内部变量的值
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static object GetInternalValue(string name)
{
BaseValue bv = data.GetBaseValue(name);
if (bv != null)
{
return(bv.GetValue());
}
else
{
Debug.LogError("不存在内部变量：" + name);
return(null);
}
}
public bool EqualTo(BaseValue v)
{
if (v == null)
{
return(false);
}
if (typeName.Equals(v.typeName) && value.Equals(v.value))
{
return(true);
}
return(false);
}
public void SetValue(object value)
{
if (value == null)
{
return;
}
fieldValues.Clear();
Type type = value.GetType();
BindingFlags flags = BindingFlags.Instance | BindingFlags.Public;
FieldInfo[] fields = type.GetFields(flags);
ScriptName = type.FullName;
for (int i = 0; i < fields.Length; i++)
{
FieldInfo f = fields[i];
object v = f.GetValue(value);
if (v == null)
{
continue;
}
BaseValue scriptValue = new BaseValue(f.Name, v);
fieldValues.Add(scriptValue);
}
BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.Instance;
if (isDeclaredOnly)
{
bindingAttr = bindingAttr | BindingFlags.DeclaredOnly;
}
PropertyInfo[] propertyInfos = type.GetProperties(bindingAttr);
for (int i = 0; i < propertyInfos.Length; i++)
{
PropertyInfo property = propertyInfos[i];
if (property.CanRead && property.CanWrite)
{
try
{
BaseValue scriptValue = new BaseValue(property.Name, property.GetValue(value, null));
propertyValues.Add(scriptValue);
}
catch
{
continue;
}
}
}
}
private void AddButton_Click(object sender, RoutedEventArgs e)
{
if (!(List.ItemsSource is IList <BaseValue>))
{
return;
}
var newItem =
new BaseValue((this.FindParent <CharacterSheetControl>().DataContext as CharacterSheetViewModel)
?.CurrentSheet);
new BaseValueView(newItem).ShowDialog();
((IList <BaseValue>)List.ItemsSource).Add(newItem);
//List.SelectedItem = newItem;
}
/// <summary>
/// 设置内部变量的值
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
public void SetInternalValue(string name, object value)
{
BaseValue bv = data.GetBaseValue(name);
if (bv != null)
{
if (!bv.GetValue().Equals(value))
{
if (inValueEventDic[name] != null)
{
inValueEventDic[name](name, value);
}
}
bv.SetValue(value);
}
}
public IEnumerable <Attribute> Fetch(string path, DateTime lastWriteTime)
{
using (var reader = Execute(path, lastWriteTime))
{
while (reader.Read())
{
var name = reader.GetString(0);
var source = reader.GetInt32(1);
var type = reader.GetInt32(2);
var valueSize = reader.GetInt64(4);
// parse value
BaseValue value = null;
switch ((AttributeType)type)
{
case AttributeType.Int:
value = new IntValue(reader.GetInt32(3));
break;
case AttributeType.Double:
value = new RealValue(reader.GetDouble(3));
break;
case AttributeType.String:
value = new StringValue(reader.GetString(3));
break;
case AttributeType.DateTime:
value = new DateTimeValue(reader.GetDateTime(3));
break;
case AttributeType.Image:
var buffer = new byte[valueSize];
var length = reader.GetBytes(3, 0, buffer, 0, buffer.Length);
Trace.Assert(buffer.Length == length);
value = new ImageValue(buffer);
break;
default:
throw new ArgumentOutOfRangeException();
}
// return the attribute
yield return(new Attribute(name, value, (AttributeSource)source));
}
}
}
/// <summary>
/// 使用 绘制内部变量菜单
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
/// <param name="typeNames"></param>
/// <returns></returns>
public static object DrawInternalValueMenu(string name, string value, string[] typeNames)
{
if (LogicSystemEditorWindow.data != null)
{
List <string> names = LogicSystemEditorWindow.data.GetInternalValueNamesByTypes(typeNames);
BaseValue v = LogicSystemEditorWindow.data.GetBaseValue(value);
if (v != null)
{
name += "(" + v.typeName + ")";
}
return(EditorDrawGUIUtil.DrawPopup(name, value, names));
}
else
{
return(EditorDrawGUIUtil.DrawBaseValue(name, value));
}
}
public override string ToString()
{
try
{
return(JsonConvert.DeserializeObject <string>(BaseValue));
}
catch
{
if (!BaseValue.IsSet())
{
return("");
}
else
{
return(JsonConvert.DeserializeObject <string>(JsonConvert.SerializeObject(BaseValue)));
}
}
}
private static bool ContainsPrefixSuffix(BaseValue value, string prefix, string suffix)
{
var text = value.ToString();
var prefixIndex = text.IndexOf(prefix, StringComparison.CurrentCultureIgnoreCase);
if (prefixIndex < 0)
{
return(false);
}
var suffixIndex = text.LastIndexOf(suffix, StringComparison.CurrentCultureIgnoreCase);
if (prefixIndex + prefix.Length > suffixIndex)
{
return(false);
}
return(true);
}
