/// <summary>
/// Create json string from InvokerNode.
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static string ToJson(this InvokerNode node)
{
return(Object(null, true,
Field("type", node.NodeName),
Field("ID", node.Id),
Field("actionGroup", node.ActionGroup),
Field("functionID", node.ActionGroup.Equals(ActionGroup.Skill) ? node.FuncNames[0] : node.FuncIndex.ToString()),
//Field("functionName", node.ActionGroup.Equals(ActionGroup.Skill) ? node.FuncNames[0] : node.FuncNames[node.FuncIndex]),
Field("functionName", node.FunctionName),
Field("executeSkill", node.ExecuteSkill),
node.Rect.ToJson()));
}
private void AnalyzeNextElement(ElementNode element, CustomDefinition enviroument, bool isStatic = false)
{
switch (element.NodeType)
{
case NodeType.Variable:
DefineVariableNode variable = null;
if (enviroument is ClassDefinition classDefinition)
{
variable = classDefinition.GetField(element.Content);
}
if (enviroument is StructDefinition structDefinition)
{
variable = structDefinition.GetField(element.Content);
}
if (enviroument is InterfaceDefinition)
{
return; //TODO:报错 接口不存在字段
}
if (variable == null)
{
return; //TODO:报错 类型 "" 中不存在 "" 的定义
}
if (isStatic && !variable.IsStatic)
{
return; //TODO:报错 对象引用对于非静态的字段、方法或属性 "" 是必须的
}
element.Definition = variable;
element.Type = element.Definition.Type;
if (element.NextElement != null)
{
AnalyzeNextElement(element.NextElement, element.Type);
}
break;
case NodeType.Invoker:
InvokerNode invoker = (InvokerNode)element;
foreach (ExpressionNode expressionNode in invoker.Parms)
{
AnalyzeExpression(expressionNode);
}
if (!enviroument.Contain(invoker.NameWithParms))
{
return; //TODO:报错 当前上文中不存在函数 ""
}
FunctionDefinition function = enviroument.GetFunctionDefinition(invoker.NameWithParms);
if (isStatic && !function.IsStatic)
{
return; //TODO:报错 对象引用对于非静态的字段、方法或属性 "" 是必须的
}
invoker.Function = function;
invoker.Type = function.ReturnType;
if (invoker.NextElement != null)
{
AnalyzeNextElement(invoker.NextElement, element.Type);
}
break;
case NodeType.Array:
if (!Symbols.Contain(element.Content))
{
return; //TODO:报错 当前上文中不存在标识符 ""
}
DefineVariableNode variableNode = null;
if (enviroument is ClassDefinition classDefinition1)
{
variableNode = classDefinition1.GetField(element.Content);
}
if (enviroument is StructDefinition structDefinition1)
{
variableNode = structDefinition1.GetField(element.Content);
}
if (enviroument is InterfaceDefinition)
{
return; //TODO:报错 接口不存在字段
}
if (variableNode == null)
{
return; //TODO:报错 类型 "" 中不存在 "" 的定义
}
if (isStatic && !variableNode.IsStatic)
{
return; //TODO:报错 对象引用对于非静态的字段、方法或属性 "" 是必须的
}
element.Definition = Symbols[element.Content];
element.Type = element.Definition.Type;
if (element.NextElement != null)
{
AnalyzeNextElement(element.NextElement, element.Type);
}
break;
}
}
private void AnalyzeElement(ElementNode element) //写的不好
{
switch (element.NodeType)
{
case NodeType.Unknown:
return; //TODO:报错 未知错误
case NodeType.Expression:
AnalyzeExpression(element.Expression);
element.Type = element.Expression.Type;
break;
case NodeType.NumericLiteral:
element.Type = Symbols.GetDefinition("int");
break;
case NodeType.FloatLiteral:
element.Type = Symbols.GetDefinition("float");
break;
case NodeType.StringLiteral:
element.Type = Symbols.GetDefinition("string");
break;
case NodeType.CharacterLiteral:
element.Type = Symbols.GetDefinition("char");
break;
case NodeType.BooleanLiteral:
element.Type = Symbols.GetDefinition("bool");
break;
case NodeType.New:
NewNode newNode = (NewNode)element;
foreach (ExpressionNode expressionNode in newNode.Parms)
{
AnalyzeExpression(expressionNode);
}
newNode.Type = Symbols.GetDefinition(newNode.TypeName);
if (newNode.Type == null)
{
return; //TODO:报错 未能找到类型或命名空间名称 ""（是否缺少 using 指令或程序集引用？）
}
if (newNode.Type is InterfaceDefinition)
{
return; //TODO:报错 无法创建接口 "" 的实例
}
if (!newNode.Type.Contain(newNode.NameWithParms))
{
return; //TODO:报错 当前上文中不存在函数 ""
}
newNode.Constructor = newNode.Type.GetFunctionDefinition(newNode.NameWithParms);
if (newNode.NextElement != null)
{
AnalyzeNextElement(newNode.NextElement, element.Type);
}
newNode.Type = newNode.LastElement.Type; //由头一个标识符表示整串标识符的类型
break;
case NodeType.Variable:
if (Symbols.Contain(element.Content)) //处理标识符表示对象的情况
{
DefineVariableNode variable = Symbols[element.Content];
if (_analyzingFunction.IsStatic && !variable.IsStatic)
{
return; //TODO:报错 对象引用对于非静态的字段、方法或属性 "" 是必须的
}
element.Definition = variable;
element.Type = element.Definition.Type;
if (element.NextElement != null)
{
AnalyzeNextElement(element.NextElement, element.Type);
}
element.Type = element.LastElement.Type; //由头一个标识符表示整串标识符的类型
break;
}
//处理标识符表示类型名字的情况
CustomDefinition definition = Symbols.GetDefinition(element.Content);
if (definition == null)
{
return; //TODO:报错 未能找到类型或命名空间名称 ""（是否缺少 using 指令或程序集引用？）
}
element.NodeType = NodeType.CustomType;
element.Type = definition;
if (element.NextElement == null)
{
return; //TODO:报错 "" 是个类型，在给定的上下文中无效
}
AnalyzeNextElement(element.NextElement, element.Type, true);
element.Type = element.LastElement.Type; //由头一个标识符表示整串标识符的类型
break;
case NodeType.Invoker:
InvokerNode invoker = (InvokerNode)element;
foreach (ExpressionNode expressionNode in invoker.Parms)
{
AnalyzeExpression(expressionNode);
}
if (!_analyzingStructure.Contain(invoker.NameWithParms))
{
return; //TODO:报错 当前上文中不存在函数 ""
}
FunctionDefinition function = _analyzingStructure.GetFunctionDefinition(invoker.NameWithParms);
if (_analyzingFunction.IsStatic && !function.IsStatic)
{
return; //TODO:报错 对象引用对于非静态的字段、方法或属性 "" 是必须的
}
invoker.Function = function;
invoker.Type = function.ReturnType;
if (invoker.NextElement != null)
{
AnalyzeNextElement(invoker.NextElement, element.Type);
}
invoker.Type = invoker.LastElement.Type; //由头一个标识符表示整串标识符的类型
break;
case NodeType.Array:
ArrayNode array = (ArrayNode)element;
if (!Symbols.Contain(array.Content))
{
return; //TODO:报错 当前上文中不存在标识符 ""
}
DefineVariableNode variableNode = Symbols[array.Content];
if (_analyzingFunction.IsStatic && !variableNode.IsStatic)
{
return; //TODO:报错 对象引用对于非静态的字段、方法或属性 "" 是必须的
}
array.Definition = Symbols[array.Content];
array.Type = array.Definition.Type;
foreach (ExpressionNode arrayExpression in array.Expressions)
{
AnalyzeExpression(arrayExpression);
if (!Symbols.CanImplicitCast(arrayExpression.Type, Symbols.GetDefinition("int")))
{
return; //TODO:报错 无法将类型 "" 隐式转换为 ""
}
}
if (array.NextElement != null)
{
AnalyzeNextElement(array.NextElement, array.Type);
}
array.Type = array.LastElement.Type; //由头一个标识符表示整串标识符的类型
break;
}
}
private void AnalyzeChunk(ChunkNode chunk, bool newList = true)
{
if (newList)
{
Symbols.PushList();
}
foreach (SyntaxNode analysisNode in chunk.Nodes)
{
switch (analysisNode.NodeType)
{
case NodeType.Assign:
AnalyzeAssign((AssignNode)analysisNode);
break;
case NodeType.Continue:
AnalyzeContinue((ContinueNode)analysisNode);
break;
case NodeType.Break:
AnalyzeBreak((BreakNode)analysisNode);
break;
case NodeType.Return:
AnalyzeReturn((ReturnNode)analysisNode);
break;
case NodeType.DefineVariable:
AnalyzeVarDef((DefineVariableNode)analysisNode);
break;
case NodeType.Invoker:
InvokerNode invokerNode = (InvokerNode)analysisNode;
AnalyzeElement(invokerNode);
if (invokerNode.GetLastElement().NodeType != NodeType.Invoker)
{
return; //TODO:报错 只有assignment、invoker 和 new 对象表达式可用作语句
}
break;
case NodeType.New:
NewNode newNode = (NewNode)analysisNode;
AnalyzeElement(newNode);
switch (newNode.GetLastElement().NodeType)
{
case NodeType.New:
case NodeType.Invoker:
break;
default:
return; //TODO:报错 只有assignment、invoker 和 new 对象表达式可用作语句
}
break;
case NodeType.If:
AnalyzeIf((IfNode)analysisNode);
break;
case NodeType.For:
AnalyzeForNode((ForNode)analysisNode);
break;
case NodeType.While:
AnalyzeWhileNode((WhileNode)analysisNode);
break;
}
}
if (newList)
{
Symbols.PopList();
}
}
/// <summary>
/// Create InvokerNode from json string.
/// </summary>
/// <param name="node"></param>
/// <param name="jObj"></param>
/// <returns></returns>
private static Node Serialize(this InvokerNode node, JsonObject jObj)
{
node.NodeName = jObj["type"].String;
node.Id = jObj["ID"].String;
node.ActionGroup = jObj["actionGroup"].ActionGroup;
if (node.ActionGroup == ActionGroup.Skill)
{
node.FuncIndex = 0;
node.FuncNames = new[] { jObj["functionID"].String };
try
{ node.FunctionName = jObj["functionName"].String; }
catch (Exception) { /*Debug.Log("Your behaviour has a deprecated format");*/ }
if (jObj["executeSkill"] != null)
{
node.ExecuteSkill = jObj["executeSkill"].Bool;
}
}
else if (node.ActionGroup == ActionGroup.Inventory)
{
//node.FuncIndex = jObj["functionID"].Int;
node.FuncNames = AgentFunctions.GetFunctions <InventoryActionInterface>();
try
{ node.FunctionName = jObj["functionName"].String; }
catch (Exception) { /*Debug.Log("Your behaviour has a deprecated format");*/ }
}
else
{
//node.FuncIndex = jObj["functionID"].Int;
node.FuncNames = AgentFunctions.GetFunctions <MotionActionInterface>();
try
{ node.FunctionName = jObj["functionName"].String; }
catch (Exception) { /*Debug.Log("Your behaviour has a deprecated format");*/ }
}
var sortedFunctions = node.FuncNames;
System.Array.Sort(sortedFunctions, StringComparer.InvariantCulture);
if (node.FunctionName != null)
{
for (var i = 0; i < node.FuncNames.Length; i++)
{
if (node.FuncNames[i] == node.FunctionName)
{
node.FuncIndex = i;
}
}
}
if (node.FuncIndex == -1)
{
node.FuncIndex = jObj["functionID"].Int;
}
var x = jObj["rect"]["posX"].Float;
var y = jObj["rect"]["posY"].Float;
var w = jObj["rect"]["width"].Float;
var h = jObj["rect"]["height"].Float;
node.Rect = new Rect(x, y, w, h);
return(node);
}
