public bool Add(MethodRefWrapper mRefW, VariableWrapper lhsW, FieldRefWrapper fldW, VariableWrapper rhsW) { int[] iarr = new int[4]; iarr[0] = ProgramDoms.domM.IndexOf(mRefW); if (iarr[0] == -1) { return(false); } iarr[1] = ProgramDoms.domV.IndexOf(lhsW); if (iarr[1] == -1) { return(false); } iarr[2] = ProgramDoms.domF.IndexOf(fldW); if (iarr[2] == -1) { return(false); } iarr[3] = ProgramDoms.domV.IndexOf(rhsW); if (iarr[3] == -1) { return(false); } return(base.Add(iarr)); }
public void OnGraphVariableListChange() { if (inputPortReflectionInfo.inputValueType != typeof(VariableWrapper)) { return; } VariableWrapper variableWrapper = inputPortReflectionInfo.GetInputNodeVariableValue() as VariableWrapper; if (variableWrapper == null) { //这里不要直接检查连线合法性,所有读写技能变量的节点类型都改变后,统一检查一次连线合法性。下同 NodeView.UpdateGraphVariableNodeIOPortType(null, false); return; } GraphVariableInfo graphVariableInfo = GraphEditorWindow.instance.data.GetGraphVariableInfo(variableWrapper.variableId); if (graphVariableInfo == null) { NodeView.UpdateGraphVariableNodeIOPortType(null, false); return; } NodeView.UpdateGraphVariableNodeIOPortType(graphVariableInfo.valueType, false); }
/// <summary> /// 载入完成时,如果是<see cref="GetVariableNode"/>或者<see cref="SetVariableNode"/> 则需要初始化更新对应端口的类型 /// </summary> public override void OnLoadFinish() { base.OnLoadFinish(); //初始化读写节点的端口类型 //如果input port端口的类型是VariableWrapper,则看是否设置的有值,有值的话更新整个端口的类型 VariableWrapper variableWrapper = inputPortReflectionInfo.GetInputNodeVariableValue() as VariableWrapper; if (variableWrapper == null) { return; } int variableId = variableWrapper.variableId; GraphEditorData data = NodeView.graph.data; GraphVariableInfo graphVariableInfo = data.GetGraphVariableInfo(variableId); if (graphVariableInfo != null) { NodeView.UpdateGraphVariableNodeIOPortType(graphVariableInfo.valueType, true); } else { NodeView.UpdateGraphVariableNodeIOPortType(null, true); } }
private void WriteValueLabelStringRecord(VariableWrapper variable) { var variableName = _encoding.GetBytes(variable.Name !); var variableLength = variableName.Length; var valueLength = variable.ValueLength; var valueLabels = variable.ValueLabels !.ToDictionary(x => _encoding.GetPaddedValueAsByteArray((string)x.Key, valueLength), x => _encoding.GetBytes(x.Value)); var valuesLength = valueLabels !.Select(x => 4 + valueLength + 4 + x.Value.Length).Aggregate((a, b) => a + b); var length = 4 + variableLength + 4 + 4 + valuesLength; WriteInfoHeader(InfoRecordType.LongStringValueLabels, 1, length); _writer.Write(variableLength); _writer.Write(variableName); _writer.Write(valueLength); _writer.Write(variable.ValueLabels !.Count); foreach (var(value, label) in valueLabels) { // Write the value of the value label _writer.Write(valueLength); _writer.Write(value); //Write the label bytes _writer.Write(label.Length); _writer.Write(label); } }
public static Game FromXml(XElement xml) { Game g = new Game(); Editor.MainViewModel mvm = Editor.MainViewModel.FromXML(xml); g.Settings = mvm.Settings; foreach (var zone in mvm.Zones) { g.Zones.Add(zone.ZoneId, new ZoneWrapper(zone)); foreach (var room in zone.Rooms) { var roomWrapper = new RoomWrapper(room); g.Rooms.Add(room.RoomID, roomWrapper); } } foreach (var v in mvm.Variables) { var wrapper = new VariableWrapper(v); g.VarById[v.Id] = wrapper; g.VarByName[v.Name] = wrapper; } foreach (var stat in mvm.Settings.PlayerStatistics) { g.Statistics.Add(new PlayerStatisticWrapper(stat)); } foreach (var a in mvm.Settings.EquipmentSlots) { g.EquippedItems.Add(a, null); } foreach (var a in mvm.Arrays) { g.ArraysById.Add(a.Id, new List <object>()); } return(g); }
public void VariableWrapperTest() { var test = new RuntimeTestObject(); var var1 = new VariableWrapper(test, "doubleVal"); var var2 = new VariableWrapper(test, "intVal"); var var3 = new VariableWrapper(test, "propertyVal"); var var4 = new VariableWrapper(test, "propertyVal2"); var var5 = new VariableWrapper(test, "a"); var var6 = new VariableWrapper(test, "b"); Assert.IsFalse(var1.IsReadOnly); Assert.IsTrue(var3.IsReadOnly); var1.Value = 3.5; Assert.IsTrue(var1.Value == 3.5); var2.Value = "Hello"; Assert.IsTrue(var2.Value.Real == 0); var2.Value = "Hello"; Assert.AreEqual(Value.Zero, var2.Value); var4.Value = 0; Assert.AreEqual(Value.EmptyString, var4.Value); test.a.Value = 3; Assert.AreEqual(new Value(3), test.a.Value); test.b.Value = "Something"; Assert.AreEqual(new Value("Something"), test.b.Value); }
public void EvaluateReturnsChangingValueForX(int value) { var wrapper = new VariableWrapper <int>(value); var node = new VariableNode <int>(wrapper); Assert.That(node.Evaluate(value), Is.EqualTo(value)); wrapper.Value += 7; Assert.That(node.Evaluate(value + 7), Is.EqualTo(value + 7)); }
private void WriteVariableRecord(VariableWrapper variable) { var valueLength = variable.ValueLength; var isString = variable.FormatType == FormatType.A; var length = !isString ? 0 : valueLength < 256 ? valueLength : 255; var missingValues = variable.MissingValuesObject; WriteVariable((uint)length, variable.Label, variable.MissingValueType, missingValues, variable.OutputFormat, variable.ShortName8Bytes); WriteBlankAndGhostRecords(variable); }
public bool Add(VariableWrapper varW) { int[] iarr = new int[1]; iarr[0] = ProgramDoms.domV.IndexOf(varW); if (iarr[0] == -1) { return(false); } return(base.Add(iarr)); }
public static VariableWrapper getVarW(IVariable var) { if (VarToWrapperMap.ContainsKey(var)) { return(VarToWrapperMap[var]); } else { VariableWrapper varW = new VariableWrapper(var); VarToWrapperMap.Add(var, varW); return(varW); } }
public static AddressWrapper getAddrW(IVariable var) { if (VarToAddrWrapperMap.ContainsKey(var)) { return(VarToAddrWrapperMap[var]); } else { VariableWrapper varW = getVarW(var); AddressWrapper addW = new AddressWrapper(varW); VarToAddrWrapperMap[var] = addW; return(addW); } }
public static HeapElemWrapper getHeapElemW(IVariable var) { if (VarToHeapElemWrapperMap.ContainsKey(var)) { return(VarToHeapElemWrapperMap[var]); } else { VariableWrapper varW = getVarW(var); HeapElemWrapper hpW = new HeapElemWrapper(varW); VarToHeapElemWrapperMap[var] = hpW; return(hpW); } }
public bool Add(MethodRefWrapper methW, VariableWrapper varW) { int[] iarr = new int[2]; iarr[0] = ProgramDoms.domM.IndexOf(methW); if (iarr[0] == -1) { return(false); } iarr[1] = ProgramDoms.domV.IndexOf(varW); if (iarr[1] == -1) { return(false); } return(base.Add(iarr)); }
public bool Add(VariableWrapper varW, HeapElemWrapper allocW) { int[] iarr = new int[2]; iarr[0] = ProgramDoms.domV.IndexOf(varW); if (iarr[0] == -1) { return(false); } iarr[1] = ProgramDoms.domH.IndexOf(allocW); if (iarr[1] == -1) { return(false); } return(base.Add(iarr)); }
public bool Add(VariableWrapper lhsW, VariableWrapper rhsW) { int[] iarr = new int[2]; iarr[0] = ProgramDoms.domV.IndexOf(lhsW); if (iarr[0] == -1) { return(false); } iarr[1] = ProgramDoms.domV.IndexOf(rhsW); if (iarr[1] == -1) { return(false); } return(base.Add(iarr)); }
static VariableWrapper[] MethodParameters( out VariableWrapper module, out VariableWrapper inputReader, out VariableWrapper outputWriter, out VariableWrapper resolve, out VariableWrapper reject) { var result = new VariableWrapper[5]; result[0] = Parameter(typeof(object), out module); result[1] = Parameter(typeof(IJSValueReader), out inputReader); result[2] = Parameter(typeof(IJSValueWriter), out outputWriter); result[3] = Parameter(typeof(MethodResultCallback), out resolve); result[4] = Parameter(typeof(MethodResultCallback), out reject); return(result); }
public bool Add(InstructionWrapper invkW, VariableWrapper argW) { int[] iarr = new int[2]; iarr[0] = ProgramDoms.domI.IndexOf(invkW); if (iarr[0] == -1) { return(false); } iarr[1] = ProgramDoms.domV.IndexOf(argW); if (iarr[1] == -1) { return(false); } return(base.Add(iarr)); }
public bool Add(ExHandlerWrapper ehW, VariableWrapper varW) { int[] iarr = new int[2]; iarr[0] = ProgramDoms.domEH.IndexOf(ehW); if (iarr[0] == -1) { return(false); } iarr[1] = ProgramDoms.domV.IndexOf(varW); if (iarr[1] == -1) { return(false); } return(base.Add(iarr)); }
public bool Add(MethodRefWrapper mRefW, int argNum, VariableWrapper argW) { int[] iarr = new int[3]; iarr[0] = ProgramDoms.domM.IndexOf(mRefW); if (iarr[0] == -1) { return(false); } iarr[1] = argNum; iarr[2] = ProgramDoms.domV.IndexOf(argW); if (iarr[2] == -1) { return(false); } return(base.Add(iarr)); }
private void WriteMissingStringRecord(VariableWrapper variable) { var variableName = _encoding.GetBytes(variable.Name !); var variableLength = variableName.Length; var missingCount = Math.Abs((int)variable.MissingValueType); var length = 4 + variableLength + 1 + 4 + 8 * missingCount; WriteInfoHeader(InfoRecordType.LongStringMissing, 1, length); _writer.Write(variableLength); _writer.Write(variableName); //padding with 0x0A _writer.Write((byte)missingCount); _writer.Write(8); foreach (var missing in variable.MissingValuesObject) { _writer.Write(_encoding.GetPaddedValueAsByteArray((string)missing, 8)); } }
private void WriteBlankAndGhostRecords(VariableWrapper variable) { var extraRecordCount = variable.FormatType != FormatType.A ? 0 : SpssMath.GetNumberOf32ByteBlocks(variable.ValueLength); for (var i = 1; i < extraRecordCount; i++) { if (i % 32 != 0) { WriteBlankRecord(); continue; } var ghostIndex = i / 32; var len = ghostIndex == variable.GhostNames.Count ? variable.LastGhostVariableLength : 255; WriteGhostRecord(variable.GhostNames[ghostIndex - 1], len, variable.Label, variable.MissingValuesObject); } }
public void OperatorNodeEvaluatesBottomUp() { // y = (2 + 3) * (1 - (7 + x)) // x = 3, so we get: -45 var x = new VariableWrapper <float>(3); Func <float, float, float> add = (a, b) => a + b; Func <float, float, float> subtract = (a, b) => a - b; Func <float, float, float> multiplyNode = (a, b) => a * b; // We don't set parent nodes because we don't care about those in this test var leftSubtree = new OperatorNode <float>("add", add, new ConstantNode <float>(2), new ConstantNode <float>(3)); var rightLeaf = new OperatorNode <float>("add", add, new ConstantNode <float>(7), new VariableNode <float>(x)); var rightSubtree = new OperatorNode <float>("subtract", subtract, new ConstantNode <float>(1), rightLeaf); var root = new OperatorNode <float>("multiply", multiplyNode, leftSubtree, rightSubtree); var actual = root.Evaluate(x.Value); var expected = (2 + 3) * (1 - (7 + x.Value)); Assert.That(actual, Is.EqualTo(expected)); }
public bool Add(MethodRefWrapper mRefW, VariableWrapper lhsW, HeapElemWrapper allocW) { int[] iarr = new int[3]; iarr[0] = ProgramDoms.domM.IndexOf(mRefW); if (iarr[0] == -1) { return(false); } iarr[1] = ProgramDoms.domV.IndexOf(lhsW); if (iarr[1] == -1) { return(false); } iarr[2] = ProgramDoms.domH.IndexOf(allocW); if (iarr[2] == -1) { return(false); } return(base.Add(iarr)); }
public bool Add(MethodRefWrapper mRefW, InstructionWrapper instW, VariableWrapper varW) { int[] iarr = new int[3]; iarr[0] = ProgramDoms.domM.IndexOf(mRefW); if (iarr[0] == -1) { return(false); } iarr[1] = ProgramDoms.domP.IndexOf(instW); if (iarr[1] == -1) { return(false); } iarr[2] = ProgramDoms.domV.IndexOf(varW); if (iarr[2] == -1) { return(false); } return(base.Add(iarr)); }
public static string FormatText(string line, ScriptWrapper script) { return(Regex.Replace(line, "\\{\\{(?<VarName>.*?)\\}\\}", a => { var mvm = MainViewModel.GetMainViewModelStatic(); var varName = a.Groups["VarName"].Value; string res = "INVALID VARIABLE NAME"; VariableWrapper v = null; if (script != null) { v = script.GetVarByName(varName); } else if (mvm.CurrentGame.VarByName.ContainsKey(varName)) { v = mvm.CurrentGame.VarByName[varName]; } if (v != null) { if (v.VariableBase.IsDateTime) { return v.CurrentDateTimeValue.ToString(); } if (v.VariableBase.IsNumber) { return v.CurrentNumberValue.ToString(); } if (v.VariableBase.IsString) { return v.CurrentStringValue.ToString(); } if (v.VariableBase.IsItem) { return (v.CurrentItemValue != null ? v.CurrentItemValue.CurrentName : "NULL ITEM"); } } return res; })); }
public HeapElemWrapper(VariableWrapper varW) { this.varW = varW; kind = HeapElemKind.StructObj; }
/// <summary> /// 根据input port的类型,将对应数据初始化 /// </summary> /// <param name="inputPortReflectionInfo"></param> /// <param name="type"></param> /// <param name="valueString"></param> /// <param name="nodeView"></param> private static void SetNodeInputVariableValue(InputPortReflectionInfo inputPortReflectionInfo, Type type, string valueString, NodeEditorView nodeView) { if (inputPortReflectionInfo.inputValueType != type) { Debug.LogErrorFormat("节点{0}中的Input Port {1} 的泛型改变了,之前是{2},现在是{3}", nodeView.ReflectionInfo.Type, inputPortReflectionInfo.PortName, type.FullName, inputPortReflectionInfo.inputValueType.FullName); return; } if (type == typeof(int)) { int value = int.Parse(valueString); inputPortReflectionInfo.SetInputNodeVariableValue(value); } else if (type == typeof(float)) { float value = float.Parse(valueString); inputPortReflectionInfo.SetInputNodeVariableValue(value); } else if (type == typeof(string)) { inputPortReflectionInfo.SetInputNodeVariableValue(valueString); } else if (type == typeof(bool)) { bool value = Boolean.Parse(valueString); inputPortReflectionInfo.SetInputNodeVariableValue(value); } else if (type.IsEnum) { object value = Enum.Parse(type, valueString); inputPortReflectionInfo.SetInputNodeVariableValue(value); } else if (type == typeof(List <int>)) { string[] splitString = valueString.Split('|'); List <int> value = new List <int>(); for (int i = 0; i < splitString.Length; i++) { value.Add(int.Parse(splitString[i])); } inputPortReflectionInfo.SetInputNodeVariableValue(value); } else if (type == typeof(LayerMaskWrapper)) { LayerMaskWrapper value = valueString; inputPortReflectionInfo.SetInputNodeVariableValue(value); } else if (type == typeof(VariableWrapper)) { int intValue; if (int.TryParse(valueString, out intValue)) { VariableWrapper variableWrapper = intValue; inputPortReflectionInfo.SetInputNodeVariableValue(variableWrapper); } else { Debug.LogErrorFormat("标记为VariableWrapper类型的input接口,但是它记录的值不是int类型的: {0}", valueString); } } }
public static VariableWrapper[] Parameters(Type[] types, out VariableWrapper[] parameters) { return(parameters = types.Select(t => VariableWrapper.CreateParameter(t)).ToArray()); }
public static VariableWrapper Parameter(Type type, out VariableWrapper parameter) { return(parameter = VariableWrapper.CreateParameter(type)); }
public static VariableWrapper Variable(Type type, out VariableWrapper variable, Expression init = null) { return(variable = VariableWrapper.CreateVariable(type, init)); }