private static bool MatchParametersToPredicateDeclaration(ParameterizedPredicate pp, Domain d)
{
foreach (Predicate pDefinition in d.Predicates)
{
if (pDefinition.Name == pp.Name)
{
if (pDefinition is ParameterizedPredicate)
{
ParameterizedPredicate ppDefinition = (ParameterizedPredicate)pDefinition;
if (pp.Parameters.Count() != ppDefinition.Parameters.Count())
{
return(false);
}
for (int i = 0; i < pp.Parameters.Count(); i++)
{
if (ppDefinition.Parameters.ElementAt(i).Type == "")
{
ppDefinition.Parameters.ElementAt(i).Type = pp.Parameters.ElementAt(i).Type;
}
else if (ppDefinition.Parameters.ElementAt(i).Type != pp.Parameters.ElementAt(i).Type)
{
return(false);
}
}
return(true);
}
}
}
return(false);
}
public override Formula PartiallyGround(Dictionary <string, Constant> dBindings)
{
if (Predicate is ParameterizedPredicate)
{
ParameterizedPredicate ppred = (ParameterizedPredicate)Predicate;
Predicate pGrounded = ppred.PartiallyGround(dBindings);
return(new PredicateFormula(pGrounded));
}
if (Predicate is KnowPredicate)
{
throw new NotImplementedException();
}
if (Predicate is KnowGivenPredicate)
{
throw new NotImplementedException();
}
return(this);
}
private static Predicate ReadPredicate(CompoundExpression exp, Domain d)
{
ParameterizedPredicate pp = new ParameterizedPredicate(exp.Type);
int iExpression = 0;
Parameter p = null;
string sName = "";
List <Parameter> lUntypedParameters = new List <Parameter>();
for (iExpression = 0; iExpression < exp.SubExpressions.Count; iExpression++)
{
sName = exp.SubExpressions[iExpression].ToString();
if (sName == "-")
{
string sType = exp.SubExpressions[iExpression + 1].ToString();
foreach (Parameter pUntyped in lUntypedParameters)
{
pUntyped.Type = sType;
}
lUntypedParameters.Clear();
iExpression++;//skip the "-" and the type
}
else
{
p = new Parameter("", sName);
lUntypedParameters.Add(p);
pp.AddParameter(p);
}
}
if (d.Types.Count == 1)
{
foreach (Parameter pUntyped in lUntypedParameters)
{
pUntyped.Type = d.Types[0];
}
}
return(pp);
}
private void ConvertToSingleAgentProblem()
{
/*foreach (var otherAgent in agents)
* {
* if (otherAgent.Name != agent.Name)
* {
* RemoveAgentFromDomain(domain, otherAgent);
* //problem.RemoveConstant(otherAgent);
* }
* }*/
// Currently A1 plays
GroundedPredicate activeAgentPredicate = new GroundedPredicate("active-agent");
activeAgentPredicate.AddConstant(new Constant(m_AgentDomain.AgentCallsign, m_ActiveAgent.Name));
m_AgentProblem.AddKnown(activeAgentPredicate);
ParameterizedPredicate activeAgentParamPredicate = new ParameterizedPredicate("active-agent");
Parameter pIsAgent = new Parameter(m_AgentDomain.AgentCallsign, "?a");
activeAgentParamPredicate.AddParameter(pIsAgent);
m_AgentDomain.AddPredicate(activeAgentParamPredicate);
ParameterizedPredicate activeAgentParamPredicateJoint = new ParameterizedPredicate("active-agent");
Parameter pIsAgentJoint = new Parameter(m_AgentDomain.AgentCallsign, "?a1");
activeAgentParamPredicateJoint.AddParameter(pIsAgentJoint);
foreach (var action in m_AgentDomain.Actions)
{
Action originalAction = action.Clone();
if (action.Preconditions.ContainsParameter(pIsAgent) || action.Preconditions.ContainsParameter(pIsAgentJoint))
{
if (action.Preconditions.CountAgents(m_AgentDomain.AgentCallsign) > 1)
{
// Joint Action
ParameterizedPredicate paramPredicateAgentAt = new ParameterizedPredicate("agent-at");
paramPredicateAgentAt.AddParameter(new Parameter(m_AgentDomain.AgentCallsign, "?a2"));
paramPredicateAgentAt.AddParameter(new Parameter("pos", "?start"));
action.Preconditions.RemovePredicate(paramPredicateAgentAt);
// Joint Action Disaster site
ParameterizedPredicate paramPredicateIn = new ParameterizedPredicate("in");
paramPredicateIn.AddParameter(new Parameter(m_AgentDomain.AgentCallsign, "?a2"));
paramPredicateIn.AddParameter(new Parameter("location", "?r1"));
action.Preconditions.RemovePredicate(paramPredicateIn);
action.Preconditions.AddPredicate(activeAgentParamPredicateJoint);
}
else
{
CompoundFormula newcf = new CompoundFormula("and");
newcf.SimpleAddOperand(action.Preconditions);
newcf.SimpleAddOperand(activeAgentParamPredicate);
action.Preconditions = newcf;
}
}
action.OriginalActionBeforeRemovingAgent = originalAction;
}
}
internal virtual void RemovePredicate(ParameterizedPredicate paramPredicateAgentAt)
{
throw new NotImplementedException();
}
internal virtual void AddPredicate(ParameterizedPredicate activeAgentParamPredicate)
{
throw new NotImplementedException();
}
private static Formula ReadPredicate(CompoundExpression exp, Dictionary <string, string> dParameterNameToType, bool bParametrized, Domain d)
{
Predicate p = null;
int iExpression = 0;
string sName = "";
if (bParametrized)
{
p = new ParameterizedPredicate(exp.Type);
}
else
{
p = new GroundedPredicate(exp.Type);
}
bool bAllConstants = true;
for (iExpression = 0; iExpression < exp.SubExpressions.Count; iExpression++)
{
sName = exp.SubExpressions[iExpression].ToString();
if (bParametrized)
{
Argument a = null;
if (sName.StartsWith("?"))
{
// if (!dParameterNameToType.ContainsKey(sName))
// dParameterNameToType.Add(sName,)
a = new Parameter(dParameterNameToType[sName], sName);
bAllConstants = false;
}
else
{
if (!d.ConstantNameToType.ContainsKey(sName))
{
d.ConstantNameToType.Add(sName, dParameterNameToType[sName]);
//throw new Exception("Predicate " + sName + " undefined");// SAGI co
}
a = new Constant(d.ConstantNameToType[sName], sName);
}
((ParameterizedPredicate)p).AddParameter(a);
}
else
{
try
{
Constant c = new Constant(d.ConstantNameToType[sName], sName);
((GroundedPredicate)p).AddConstant(c);
}
catch (Exception e)
{
Console.WriteLine();
}
}
}
if (bParametrized)
{
if (!MatchParametersToPredicateDeclaration((ParameterizedPredicate)p, d))
{
throw new NotImplementedException();
}
}
if (bParametrized && bAllConstants)
{
GroundedPredicate gp = new GroundedPredicate(p.Name);
foreach (Constant c in ((ParameterizedPredicate)p).Parameters)
{
gp.AddConstant(c);
}
p = gp;
}
PredicateFormula vf = new PredicateFormula(p);
return(vf);
}
