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));
}
