protected override void load(int version, string agentType, List <property_t> properties)
{
base.load(version, agentType, properties);
string typeName = null;
string propertyName = null;
string str3 = null;
foreach (property_t _t in properties)
{
if (_t.name == "Operator")
{
str3 = _t.value;
}
else if (_t.name == "Opl")
{
if (_t.value.IndexOf('(') == -1)
{
this.m_opl = LoadLeft(_t.value, ref propertyName, null);
}
else
{
this.m_opl_m = behaviac.Action.LoadMethod(_t.value);
}
}
else if (_t.name == "Opr")
{
this.m_opr = LoadRight(_t.value, propertyName, ref typeName);
}
}
if ((!string.IsNullOrEmpty(str3) && ((this.m_opl != null) || (this.m_opl_m != null))) && (this.m_opr != null))
{
this.m_comparator = Create(typeName, str3, this.m_opl, this.m_opr);
}
}
public static VariableComparator Create(string comparionOperator, Property lhs, CMethodBase lhs_m, Property rhs, CMethodBase rhs_m)
{
E_VariableComparisonType comparisonType = VariableComparator.ParseComparisonType(comparionOperator);
VariableComparator pComparator = VariableComparator.Create(lhs, lhs_m, rhs, rhs_m);
pComparator.SetComparisonType(comparisonType);
return(pComparator);
}
public static VariableComparator Create(string typeName, string comparionOperator, Property lhs, Property rhs)
{
E_VariableComparisonType type = VariableComparator.ParseComparisonType(comparionOperator);
if (Agent.IsAgentClassName(typeName))
{
typeName = "void*";
}
VariableComparator comparator = VariableComparator.Create(typeName, lhs, rhs);
comparator.SetComparisonType(type);
return(comparator);
}
protected override void load(int version, string agentType, List <property_t> properties)
{
base.load(version, agentType, properties);
string typeName = null;
string propertyName = null;
string text = null;
using (List <property_t> .Enumerator enumerator = properties.GetEnumerator())
{
while (enumerator.MoveNext())
{
property_t current = enumerator.get_Current();
if (current.name == "Operator")
{
text = current.value;
}
else if (current.name == "Opl")
{
int num = current.value.IndexOf('(');
if (num == -1)
{
this.m_opl = Condition.LoadLeft(current.value, ref propertyName, null);
}
else
{
this.m_opl_m = Action.LoadMethod(current.value);
}
}
else if (current.name == "Opr")
{
this.m_opr = Condition.LoadRight(current.value, propertyName, ref typeName);
}
else if (current.name == "BinaryOperator")
{
if (current.value == "Or")
{
this.m_bAnd = false;
}
else if (current.value == "And")
{
this.m_bAnd = true;
}
}
}
}
if (!string.IsNullOrEmpty(text) && (this.m_opl != null || this.m_opl_m != null) && this.m_opr != null)
{
this.m_comparator = Condition.Create(typeName, text, this.m_opl, this.m_opr);
}
}
public static bool DoCompare(Agent pAgent, VariableComparator comparator, Property opl, CMethodBase opl_m, Property opr)
{
bool bResult = false;
if (opl != null)
{
Agent agent_left = pAgent;
ParentType pt = opl.GetParentType();
if (pt == ParentType.PT_INSTANCE)
{
agent_left = Agent.GetInstance(opl.GetInstanceNameString(), agent_left.GetContextId());
Debug.Check(agent_left != null || Utils.IsStaticClass(opl.GetInstanceNameString()));
}
Agent agent_right = pAgent;
pt = opr.GetParentType();
if (pt == ParentType.PT_INSTANCE)
{
agent_right = Agent.GetInstance(opr.GetInstanceNameString(), agent_left.GetContextId());
Debug.Check(agent_right != null || Utils.IsStaticClass(opr.GetInstanceNameString()));
}
bResult = comparator.Execute(agent_left, agent_right);
}
else if (opl_m != null)
{
ParentType pt = opl_m.GetParentType();
Agent agent_left = pAgent;
if (pt == ParentType.PT_INSTANCE)
{
agent_left = Agent.GetInstance(opl_m.GetInstanceNameString(), agent_left.GetContextId());
Debug.Check(agent_left != null || Utils.IsStaticClass(opl_m.GetInstanceNameString()));
}
object returnValue = opl_m.run(agent_left, pAgent);
Agent agent_right = pAgent;
pt = opr.GetParentType();
if (pt == ParentType.PT_INSTANCE)
{
agent_right = Agent.GetInstance(opr.GetInstanceNameString(), agent_right.GetContextId());
Debug.Check(agent_right != null || Utils.IsStaticClass(opr.GetInstanceNameString()));
}
bResult = comparator.Execute(returnValue, agent_left, agent_right);
}
return(bResult);
}
public static VariableComparator Create(string typeName, string comparionOperator, Property lhs, Property rhs)
{
E_VariableComparisonType comparisonType = VariableComparator.ParseComparisonType(comparionOperator);
//bool bAgentPtr = false;
//it might be par or the right value of condition/assignment
if (Agent.IsAgentClassName(typeName))
{
//bAgentPtr = true;
typeName = "void*";
}
VariableComparator pComparator = VariableComparator.Create(typeName, lhs, rhs);
pComparator.SetComparisonType(comparisonType);
return(pComparator);
}
public static bool DoCompare(Agent pAgent, VariableComparator comparator, Property opl, CMethodBase opl_m, Property opr)
{
bool result = false;
if (opl != null)
{
Agent agent = pAgent;
ParentType parentType = opl.GetParentType();
if (parentType == ParentType.PT_INSTANCE)
{
agent = Agent.GetInstance(opl.GetInstanceNameString(), agent.GetContextId());
}
Agent agentR = pAgent;
parentType = opr.GetParentType();
if (parentType == ParentType.PT_INSTANCE)
{
agentR = Agent.GetInstance(opr.GetInstanceNameString(), agent.GetContextId());
}
result = comparator.Execute(agent, agentR);
}
else if (opl_m != null)
{
ParentType parentType2 = opl_m.GetParentType();
Agent agent2 = pAgent;
if (parentType2 == ParentType.PT_INSTANCE)
{
agent2 = Agent.GetInstance(opl_m.GetInstanceNameString(), agent2.GetContextId());
}
object lhs = opl_m.run(agent2, pAgent);
Agent agent3 = pAgent;
parentType2 = opr.GetParentType();
if (parentType2 == ParentType.PT_INSTANCE)
{
agent3 = Agent.GetInstance(opr.GetInstanceNameString(), agent3.GetContextId());
}
result = comparator.Execute(lhs, agent2, agent3);
}
return(result);
}
public static bool DoCompare(Agent pAgent, VariableComparator comparator, Property opl, CMethodBase opl_m, Property opr)
{
bool flag = false;
if (opl != null)
{
Agent agentL = pAgent;
if (opl.GetParentType() == ParentType.PT_INSTANCE)
{
agentL = Agent.GetInstance(opl.GetInstanceNameString(), agentL.GetContextId());
}
Agent instance = pAgent;
if (opr.GetParentType() == ParentType.PT_INSTANCE)
{
instance = Agent.GetInstance(opr.GetInstanceNameString(), agentL.GetContextId());
}
return(comparator.Execute(agentL, instance));
}
if (opl_m == null)
{
return(flag);
}
ParentType parentType = opl_m.GetParentType();
Agent parent = pAgent;
if (parentType == ParentType.PT_INSTANCE)
{
parent = Agent.GetInstance(opl_m.GetInstanceNameString(), parent.GetContextId());
}
object lhs = opl_m.run(parent, pAgent);
Agent agentR = pAgent;
if (opr.GetParentType() == ParentType.PT_INSTANCE)
{
agentR = Agent.GetInstance(opr.GetInstanceNameString(), agentR.GetContextId());
}
return(comparator.Execute(lhs, parent, agentR));
}
public static bool DoCompare(Agent pAgent, VariableComparator comparator, Property opl, CMethodBase opl_m, Property opr, CMethodBase opr_m)
{
bool bResult = false;
if (opl != null)
{
Agent agent_left = opl.GetParentAgent(pAgent);
Agent agent_right = opr != null?opr.GetParentAgent(pAgent) : opr_m.GetParentAgent(pAgent);
bResult = comparator.Execute(agent_left, agent_right);
}
else if (opl_m != null)
{
Agent agent_left = opl_m.GetParentAgent(pAgent);
object returnValue = opl_m.Invoke(agent_left, pAgent);
Agent agent_right = opr != null?opr.GetParentAgent(pAgent) : opr_m.GetParentAgent(pAgent);
bResult = comparator.Execute(returnValue, agent_left, agent_right);
}
return(bResult);
}
private VariableComparator(VariableComparator copy)
{
this.m_lhs = copy.m_lhs;
this.m_rhs = copy.m_rhs;
}
public virtual bool load(List <property_t> properties)
{
string opr2TypeName = null;
string comparatorName = null;
for (int i = 0; i < properties.Count; ++i)
{
property_t p = properties[i];
if (p.name == "Mode")
{
switch (p.value)
{
case "Condition":
this.m_mode = TransitionMode.Condition;
break;
case "Success":
this.m_mode = TransitionMode.Success;
break;
case "Failure":
this.m_mode = TransitionMode.Failure;
break;
case "End":
this.m_mode = TransitionMode.End;
break;
}
}
else if (p.name == "Opl")
{
if (StringUtils.IsValidString(p.value))
{
int pParenthesis = p.value.IndexOf('(');
if (pParenthesis == -1)
{
string typeName = null;
this.m_opl = Condition.LoadRight(p.value, ref typeName);
}
else
{
//method
this.m_opl_m = Action.LoadMethod(p.value);
}
}
}
else if (p.name == "Opr1")
{
if (StringUtils.IsValidString(p.value))
{
int pParenthesis = p.value.IndexOf('(');
if (pParenthesis == -1)
{
string typeName = null;
this.m_opr1 = Condition.LoadRight(p.value, ref typeName);
}
else
{
//method
this.m_opr1_m = Action.LoadMethod(p.value);
}
}
}
else if (p.name == "Operator")
{
comparatorName = p.value;
switch (p.value)
{
case "Invalid":
this.m_operator = EOperatorType.E_INVALID;
break;
case "Assign":
this.m_operator = EOperatorType.E_ASSIGN;
break;
case "Add":
this.m_operator = EOperatorType.E_ADD;
break;
case "Sub":
this.m_operator = EOperatorType.E_SUB;
break;
case "Mul":
this.m_operator = EOperatorType.E_MUL;
break;
case "Div":
this.m_operator = EOperatorType.E_DIV;
break;
case "Equal":
this.m_operator = EOperatorType.E_EQUAL;
break;
case "NotEqual":
this.m_operator = EOperatorType.E_NOTEQUAL;
break;
case "Greater":
this.m_operator = EOperatorType.E_GREATER;
break;
case "Less":
this.m_operator = EOperatorType.E_LESS;
break;
case "GreaterEqual":
this.m_operator = EOperatorType.E_GREATEREQUAL;
break;
case "LessEqual":
this.m_operator = EOperatorType.E_LESSEQUAL;
break;
}
}
else if (p.name == "Opr2")
{
if (StringUtils.IsValidString(p.value))
{
int pParenthesis = p.value.IndexOf('(');
if (pParenthesis == -1)
{
this.m_opr2 = Condition.LoadRight(p.value, ref opr2TypeName);
}
else
{
//method
this.m_opr2_m = Action.LoadMethod(p.value);
}
}
}
else
{
//Debug.Check(0, "unrecognised property %s", p.name);
}
}
// compare
if (this.m_operator >= EOperatorType.E_EQUAL && this.m_operator <= EOperatorType.E_LESSEQUAL)
{
if (!string.IsNullOrEmpty(comparatorName) && (this.m_opl != null || this.m_opl_m != null) &&
(this.m_opr2 != null || this.m_opr2_m != null))
{
this.m_comparator = Condition.Create(comparatorName, this.m_opl, this.m_opl_m, this.m_opr2, this.m_opr2_m);
}
}
return(this.m_opl != null);
}
