public GroundedPredicate Ground(Dictionary<string, Constant> dBindings)
{
GroundedPredicate gp = new GroundedPredicate("K" + Knowledge.Name);
if (Knowledge is ParametrizedPredicate)
{
foreach (Argument a in ((ParametrizedPredicate)Knowledge).Parameters)
{
if (a is Parameter)
{
if (dBindings.ContainsKey(a.Name))
gp.AddConstant(dBindings[a.Name]);
else
throw new NotImplementedException();
}
else
gp.AddConstant((Constant)a);
}
}
else
{
foreach (Constant c in ((GroundedPredicate)Knowledge).Constants)
{
gp.AddConstant(c);
}
}
return gp;
}
public GroundedPredicate Ground(Dictionary <string, Constant> dBindings)
{
GroundedPredicate gp = new GroundedPredicate("K" + Knowledge.Name);
if (Knowledge is ParametrizedPredicate)
{
foreach (Argument a in ((ParametrizedPredicate)Knowledge).Parameters)
{
if (a is Parameter)
{
if (dBindings.ContainsKey(a.Name))
{
gp.AddConstant(dBindings[a.Name]);
}
else
{
throw new NotImplementedException();
}
}
else
{
gp.AddConstant((Constant)a);
}
}
}
else
{
foreach (Constant c in ((GroundedPredicate)Knowledge).Constants)
{
gp.AddConstant(c);
}
}
return(gp);
}
private static GroundedPredicate GetPredicate(string sName, int iX, int iY)
{
GroundedPredicate gpSafe = new GroundedPredicate(sName);
gpSafe.AddConstant(new Constant("pos", "p-" + iX));
gpSafe.AddConstant(new Constant("pos", "p-" + iY));
return(gpSafe);
}
private static GroundedPredicate GetSafe(int iX, int iY)
{
GroundedPredicate gpSafe = new GroundedPredicate("safe");
gpSafe.AddConstant(new Constant("pos", "p-" + iX));
gpSafe.AddConstant(new Constant("pos", "p-" + iY));
return(gpSafe);
}
public Predicate ReadFunctionExpression(CompoundExpression exp, Dictionary <string, string> dParameterNameToType, Domain d)
{
Constant c = null;
string sName = exp.SubExpressions[0].ToString();
if (exp.Type == "=")
{
string sParam1 = exp.SubExpressions[0].ToString();
string sParam2 = exp.SubExpressions[1].ToString();
if (!dParameterNameToType.ContainsKey(sParam1))
{
throw new ArgumentException("First argument of = must be a parameter");
}
ParametrizedPredicate pp = new ParametrizedPredicate("=");
pp.AddParameter(new Parameter(dParameterNameToType[sParam1], sParam1));
if (dParameterNameToType.ContainsKey(sParam2))
{
pp.AddParameter(new Parameter(dParameterNameToType[sParam2], sParam2));
}
else
{
pp.AddParameter(new Constant(d.ConstantNameToType[sParam2], sParam2));
}
return(pp);
}
GroundedPredicate p = new GroundedPredicate(exp.Type);
double dValue = 0.0;
if (d.Functions.Contains(sName))
{
c = new Constant("Function", sName);
}
else
{
throw new ArgumentException("First argument of increase or decrease must be a function");
}
p.AddConstant(c);
sName = exp.SubExpressions[1].ToString();
if (double.TryParse(sName, out dValue))
{
c = new Constant("Number", sName);
}
else
{
throw new ArgumentException("Second argument of increase or decrease must be a number");
}
p.AddConstant(c);
return(p);
}
public Predicate PartiallyGround(Dictionary <string, Constant> dBindings)
{
GroundedPredicate gpred = new GroundedPredicate(Name);
ParametrizedPredicate ppred = new ParametrizedPredicate(Name);
gpred.Negation = Negation;
ppred.Negation = Negation;
bool bAllGrounded = true;
foreach (Argument a in Parameters)
{
if (a is Parameter)
{
if (!dBindings.ContainsKey(a.Name))
{
ppred.AddParameter(a);
bAllGrounded = false;
}
else
{
ppred.AddParameter(dBindings[a.Name]);
gpred.AddConstant(dBindings[a.Name]);
}
}
else
{
gpred.AddConstant((Constant)a);
ppred.AddParameter(a);
}
}
if (bAllGrounded)
{
if (gpred.Name == "=")
{
bool bSame = gpred.Constants[0].Equals(gpred.Constants[1]);
if (bSame && !Negation || !bSame && Negation)
{
return(new GroundedPredicate(Domain.TRUE_PREDICATE));
}
else
{
return(new GroundedPredicate(Domain.FALSE_PREDICATE));
}
}
return(gpred);
}
else
{
return(ppred);
}
}
private void AddEffects(Formula fEffects)
{
if (fEffects is PredicateFormula)
{
AddEffect(((PredicateFormula)fEffects).Predicate);
}
else
{
CompoundFormula cf = (CompoundFormula)fEffects;
if (cf.Operator == "oneof" || cf.Operator == "or")//BUGBUG - should treat or differently
{
int iRandomIdx = RandomGenerator.Next(cf.Operands.Count);
AddEffects(cf.Operands[iRandomIdx]);
GroundedPredicate pChoice = new GroundedPredicate("Choice");
pChoice.AddConstant(new Constant("ActionIndex", "a" + (Time - 1)));//time - 1 because this is the action that generated the state, hence its index is i-1
pChoice.AddConstant(new Constant("ChoiceIndex", "c" + iRandomIdx));
State s = this;
while (s != null)
{
s.m_lPredicates.Add(pChoice);
s = s.m_sPredecessor;
}
}
else if (cf.Operator == "and")
{
foreach (Formula f in cf.Operands)
{
if (f is PredicateFormula)
{
AddEffect(((PredicateFormula)f).Predicate);
}
else
{
AddEffects(f);
}
}
}
else if (cf.Operator == "when")
{
if (m_sPredecessor.Contains(cf.Operands[0]))
{
AddEffects(cf.Operands[1]);
}
}
else
{
throw new NotImplementedException();
}
}
}
public override Predicate GenerateGiven(string sTag)
{
GroundedPredicate pGiven = new GroundedPredicate("Given" + Name);
foreach (Constant c in Constants)
{
pGiven.AddConstant(c);
}
pGiven.AddConstant(new Constant(Domain.TAG, sTag));
if (Negation)
{
return(pGiven.Negate());
}
return(pGiven);
}
public bool IsUnNone(int iX, int iY)
{
if (Belief.Observed == null)
{
return(false);
}
//Predicate p=new Predicate("cv");
foreach (Formula f in Belief.Problem.Hidden)
{
GroundedPredicate gp = new GroundedPredicate("opened");
gp.AddConstant(new Constant("pos", "p" + iX + "-" + iY));
//if(f.Contains
if (f.Contains(gp))
{
return(true);
}
//{
// string sPos = gp.Constants[0].Name;
// sPos = sPos.Replace("p", "");
// string[] asPos = sPos.Split('-');
// if ((iX == int.Parse(asPos[0])) && (iY == int.Parse(asPos[1]))) return true;
//}
}
return(false);
}
//for MPSR
public static Predicate GenerateKNot(Constant cTag1, Constant cTag2)
{
GroundedPredicate gp = new GroundedPredicate("KNot");
int iTag1 = int.Parse(cTag1.Name.Substring(3));
int iTag2 = int.Parse(cTag2.Name.Substring(3));
if (iTag1 < iTag2)
{
gp.AddConstant(cTag1);
gp.AddConstant(cTag2);
}
else
{
gp.AddConstant(cTag2);
gp.AddConstant(cTag1);
}
return(gp);
}
public GroundedPredicate Ground(Dictionary <string, Constant> dBindings)
{
GroundedPredicate gpred = new GroundedPredicate(Name);
gpred.Negation = Negation;
foreach (Argument a in Parameters)
{
if (a is Parameter)
{
if (!dBindings.ContainsKey(a.Name))
{
return(null);
}
gpred.AddConstant(dBindings[a.Name]);
}
else
{
gpred.AddConstant((Constant)a);
}
}
return(gpred);
}
public bool IsLocationBlocked(int iX, int iY)
{
GroundedPredicate gp = new GroundedPredicate("at");
gp.AddConstant(new Constant("pos", "p" + iX + "-" + iY));
Action aChecking = Domain.GetAction("checking");
if (aChecking.Effects.Contains(gp))
{
return(false);
}
return(true);
}
public bool IsPossibleLocation(int iX, int iY)
{
GroundedPredicate gp = new GroundedPredicate("at");
gp.AddConstant(new Constant("pos", "p" + iX + "-" + iY));
foreach (CompoundFormula cf in Belief.Hidden)
{
if (cf.Contains(gp))
{
return(true);
}
}
return(false);
}
private GroundedPredicate ReadGroundedPredicate(CompoundExpression exp, Domain d)
{
GroundedPredicate gp = new GroundedPredicate(exp.Type);
int iExpression = 0;
Constant c = null;
string sName = "";
for (iExpression = 0; iExpression < exp.SubExpressions.Count; iExpression++)
{
sName = exp.SubExpressions[iExpression].ToString();
c = d.GetConstant(sName);
gp.AddConstant(c);
}
return(gp);
}
public bool IsGoal(int iX, int iY)
{
//iX = -1;
//iY = -1;
if (Belief.Observed == null)
{
return(false);
}
GroundedPredicate gp = new GroundedPredicate("at");
gp.AddConstant(new Constant("pos", "p" + iX + "-" + iY));
//if(f.Contains
if (Belief.Problem.Goal.Contains(gp))
{
return(true);
}
return(false);
}
private void GetApplicableEffects(Formula fEffects, HashSet <Predicate> lAdd, HashSet <Predicate> lDelete)
{
if (fEffects is PredicateFormula)
{
Predicate p = ((PredicateFormula)fEffects).Predicate;
if (p.Negation)
{
lDelete.Add(p);
}
else
{
lAdd.Add(p);
}
}
else if (fEffects is ProbabilisticFormula)
{
ProbabilisticFormula pf = (ProbabilisticFormula)fEffects;
double dRand = RandomGenerator.NextDouble();
double dInitialRand = dRand;
int iOption = 0;
while (iOption < pf.Options.Count && dRand > 0)
{
dRand -= pf.Probabilities[iOption];
iOption++;
}
if (dRand < 0.01)
{
iOption--;
GetApplicableEffects(pf.Options[iOption], lAdd, lDelete);
}
else //the no-op option was chosen
{
iOption = -1;
}
GroundedPredicate pChoice = new GroundedPredicate("Choice");
pChoice.AddConstant(new Constant("ActionIndex", "a" + Time));
pChoice.AddConstant(new Constant("ChoiceIndex", "c" + ChoiceCount + "." + iOption));
ChoiceCount++;
State s = this;
while (s != null)
{
s.m_lPredicates.Add(pChoice);
s = s.m_sPredecessor;
}
}
else
{
CompoundFormula cf = (CompoundFormula)fEffects;
if (cf.Operator == "oneof" || cf.Operator == "or")//BUGBUG - should treat or differently
{
int iRandomIdx = RandomGenerator.Next(cf.Operands.Count);
GetApplicableEffects(cf.Operands[iRandomIdx], lAdd, lDelete);
GroundedPredicate pChoice = new GroundedPredicate("Choice");
pChoice.AddConstant(new Constant("ActionIndex", "a" + Time));
pChoice.AddConstant(new Constant("ChoiceIndex", "c" + ChoiceCount + "." + iRandomIdx));
ChoiceCount++;
State s = this;
while (s != null)
{
s.m_lPredicates.Add(pChoice);
s = s.m_sPredecessor;
}
}
else if (cf.Operator == "and")
{
foreach (Formula f in cf.Operands)
{
GetApplicableEffects(f, lAdd, lDelete);
}
}
else if (cf.Operator == "when")
{
if (Contains(cf.Operands[0]))
{
GetApplicableEffects(cf.Operands[1], lAdd, lDelete);
}
}
else if (cf is ParametrizedFormula)
{
ParametrizedFormula pf = (ParametrizedFormula)cf;
foreach (Formula fNew in pf.Ground(Problem.Domain.Constants))
{
GetApplicableEffects(fNew, lAdd, lDelete);
}
}
else
{
throw new NotImplementedException();
}
}
}
private GroundedPredicate ReadGroundedPredicate(CompoundExpression exp, Domain d)
{
GroundedPredicate gp = new GroundedPredicate(exp.Type);
int iExpression = 0;
Constant c = null;
string sName = "";
for (iExpression = 0; iExpression < exp.SubExpressions.Count; iExpression++)
{
sName = exp.SubExpressions[iExpression].ToString();
c = d.GetConstant(sName);
gp.AddConstant(c);
}
return gp;
}
public Action ReplaceNonDeterministicEffectsWithOptions(List<string> lAlwaysKnown, int cMaxOptions)
{
Action aNew = Clone();
List<CompoundFormula> lConditions = new List<CompoundFormula>();
List<Formula> lObligatory = new List<Formula>();
SplitEffects(lConditions, lObligatory);
//currently only handling non-determinism in conditional effects
CompoundFormula cfEffects = new CompoundFormula("and");
foreach (Formula f in lObligatory)
{
if (f is PredicateFormula)
cfEffects.AddOperand(f);
else
{
CompoundFormula cf = (CompoundFormula)f;
if (cf.Operator == "oneof" || cf.Operator == "or")
{
lConditions.Add(cf);
}
else
cfEffects.AddOperand(cf);
}
}
foreach (CompoundFormula cfCondition in lConditions)
{
Formula fDeterministicCondition = null;
if (cfCondition.ContainsNonDeterministicEffect())
{
//BUGBUG - may cause problems when we have different number of options for each condition - not sure!
if (cMaxOptions < cfCondition.GetMaxNonDeterministicOptions())
cMaxOptions = cfCondition.GetMaxNonDeterministicOptions();
int[] aPermutation = Permutation(cMaxOptions);
foreach (int iOption in aPermutation)
{
fDeterministicCondition = cfCondition.ChooseOption(iOption);
GroundedPredicate gpOption = new GroundedPredicate("option");
gpOption.AddConstant(new Constant(Domain.OPTION, "opt" + iOption));
if (cfCondition.Operator == "when")
{
((CompoundFormula)((CompoundFormula)fDeterministicCondition).Operands[0]).AddOperand(gpOption);
cfEffects.AddOperand(fDeterministicCondition);
}
else
{
CompoundFormula cfWhen = new CompoundFormula("when");
cfWhen.AddOperand(gpOption);
cfWhen.AddOperand(fDeterministicCondition);
cfEffects.AddOperand(cfWhen);
}
}
}
else
cfEffects.AddOperand(cfCondition);
}
for (int iOption = 0; iOption < cMaxOptions; iOption++)
{
GroundedPredicate gpCurrentOption = new GroundedPredicate("option");
gpCurrentOption.AddConstant(new Constant(Domain.OPTION, "opt" + iOption));
GroundedPredicate gpNextOption = new GroundedPredicate("option");
gpNextOption.AddConstant(new Constant(Domain.OPTION, "opt" + (iOption + 1) % cMaxOptions));
CompoundFormula cfWhen = new CompoundFormula("when");
cfWhen.AddOperand(gpCurrentOption);
CompoundFormula cfAnd = new CompoundFormula("and");
cfAnd.AddOperand(gpCurrentOption.Negate());
cfAnd.AddOperand(gpNextOption);
cfWhen.AddOperand(cfAnd);
cfEffects.AddOperand(cfWhen);
}
aNew.Effects = cfEffects;
if (Observe != null)//assuming that there can't be any observations
throw new NotImplementedException();
return aNew;
}
public static List<string> MasterMindHeuristic(PartiallySpecifiedState pssCurrent, Domain domain)
{
List<Constant> lColors = new List<Constant>();
List<Constant> lPegs = new List<Constant>();
List<Constant> lValues = new List<Constant>();
foreach (Constant c in domain.Constants)
{
if (c.Type.ToLower() == "color")
lColors.Add(c);
if (c.Type.ToLower() == "peg")
lPegs.Add(c);
if (c.Type.ToLower() == "value")
lValues.Add(c);
}
//DateTime dtStart = DateTime.Now;
//BeliefState bs = pssCurrent.m_bsInitialBelief;
//State s = bs.ChooseState(true);
//List<Predicate> l = bs.RunSatSolver();
//Console.WriteLine((DateTime.Now - dtStart).TotalSeconds);
Permute(lColors);
List<Constant> lGuessColors = new List<Constant>();
for (int iPeg = 0; iPeg < lPegs.Count; iPeg++)
{
/*
//foreach (GroundedPredicate gp in s.Predicates)
foreach (GroundedPredicate gp in l)
{
if (gp.ToString().StartsWith("(on p" + iPeg) && gp.Negation == false)
{
lGuessColors.Add(gp.Constants[1]);
}
}
*/
foreach (Constant cColor in lColors)
{
GroundedPredicate gp = new GroundedPredicate("on");
gp.AddConstant(lPegs[iPeg]);
gp.AddConstant(cColor);
if (!pssCurrent.Observed.Contains(gp.Negate()))
{
lGuessColors.Add(cColor);
break;
}
}
lColors.Remove(lGuessColors.Last());
}
if (lGuessColors.Count == lPegs.Count)
{
List<string> lActions = new List<string>();
string sGuess = "guess-all";
foreach (Constant c in lGuessColors)
sGuess += " " + c.Name;
lActions.Add(sGuess);
lActions.Add("evaluate-guess");
foreach (Constant cValue in lValues)
{
lActions.Add("observe-LocationHits " + cValue.Name);
lActions.Add("observe-ColorHits " + cValue.Name);
}
return lActions;
}
return null;
}
public State ChooseState(bool bRemoveNegativePredicates)
{
State s = new State(Problem);
if (Problem.Domain.Name == "mines4")
{
string[] a = new string[]{
"(obs0-at p1-1)",
"(obs0-at p2-1)",
"(obs2-at p3-1)",
"(mine-at p4-1)",
"(obs1-at p4-1)",
"(obs2-at p1-2)",
"(obs2-at p2-2)",
"(obs3-at p3-2)",
"(mine-at p4-2)",
"(obs1-at p4-2)",
"(mine-at p1-3)",
"(obs1-at p1-3)",
"(mine-at p2-3)",
"(obs1-at p2-3)",
"(obs2-at p3-3)",
"(obs1-at p4-3)",
"(obs2-at p1-4)",
"(obs2-at p2-4)",
"(obs1-at p3-4)",
"(obs0-at p4-4)"};
foreach (GroundedPredicate p in m_lObserved)
s.AddPredicate(p);
foreach (string str in a)
{
string[] a1 = str.Replace("(","").Replace(")","").Split(' ');
GroundedPredicate gp = new GroundedPredicate(a1[0]);
gp.AddConstant(new Constant("pos", a1[1]));
s.AddPredicate(gp);
}
}
else if (SDRPlanner.SimulationStartState == null || UnderlyingEnvironmentState != null)
{
if (Problem.Name.Contains("Large"))
s = ChooseStateForLargeDomains();
else
{
List<Predicate> lAssignment = null;
Debug.Write("Choosing hidden variables ");
while (lAssignment == null)
{
Debug.Write(".");
lAssignment = ChooseHiddenPredicates(m_lHiddenFormulas, true);
}
Debug.WriteLine("");
foreach (Predicate p in lAssignment)
{
s.AddPredicate(p);
}
foreach (GroundedPredicate p in m_lObserved)
{
s.AddPredicate(p);
}
}
}
else
{
Parser p = new Parser();
string sNextState = SDRPlanner.SimulationStartState[0];
SDRPlanner.SimulationStartState.RemoveAt(0);
CompoundFormula cfInit = p.ParseFormula(sNextState, Problem.Domain);
foreach (PredicateFormula pf in cfInit.Operands)
s.AddPredicate(pf.Predicate);
foreach (GroundedPredicate gp in Observed)
s.AddPredicate(gp);
}
if (bRemoveNegativePredicates)
s.RemoveNegativePredicates();
if (UnderlyingEnvironmentState == null)
UnderlyingEnvironmentState = s;
return s;
}
public bool IsPossibleLocation(int iX, int iY)
{
GroundedPredicate gp = new GroundedPredicate("at");
gp.AddConstant(new Constant("pos", "p" + iX + "-" + iY));
foreach (CompoundFormula cf in Belief.Hidden)
if (cf.Contains(gp))
return true;
return false;
}
public Predicate PartiallyGround(Dictionary<string, Constant> dBindings)
{
GroundedPredicate gpred = new GroundedPredicate(Name);
ParametrizedPredicate ppred = new ParametrizedPredicate(Name);
gpred.Negation = Negation;
ppred.Negation = Negation;
bool bAllGrounded = true;
foreach (Argument a in Parameters)
{
if (a is Parameter)
{
if (!dBindings.ContainsKey(a.Name))
{
ppred.AddParameter(a);
bAllGrounded = false;
}
else
{
ppred.AddParameter(dBindings[a.Name]);
gpred.AddConstant(dBindings[a.Name]);
}
}
else
{
gpred.AddConstant((Constant)a);
ppred.AddParameter(a);
}
}
if (bAllGrounded)
{
if (gpred.Name == "=")
{
bool bSame = gpred.Constants[0].Equals(gpred.Constants[1]);
if (bSame && !Negation || !bSame && Negation)
return new GroundedPredicate(Domain.TRUE_PREDICATE);
else
return new GroundedPredicate(Domain.FALSE_PREDICATE);
}
return gpred;
}
else
return ppred;
}
public GroundedPredicate Ground(Dictionary<string, Constant> dBindings)
{
GroundedPredicate gpred = new GroundedPredicate(Name);
gpred.Negation = Negation;
foreach (Argument a in Parameters)
{
if (a is Parameter)
{
if (!dBindings.ContainsKey(a.Name))
return null;
gpred.AddConstant(dBindings[a.Name]);
}
else
gpred.AddConstant((Constant)a);
}
return gpred;
}
public bool IsUnNone(int iX, int iY)
{
if (Belief.Observed == null)
return false;
//Predicate p=new Predicate("cv");
foreach (Formula f in Belief.Problem.Hidden)
{
GroundedPredicate gp = new GroundedPredicate("opened");
gp.AddConstant(new Constant("pos", "p" + iX + "-" + iY));
//if(f.Contains
if (f.Contains(gp)) return true;
//{
// string sPos = gp.Constants[0].Name;
// sPos = sPos.Replace("p", "");
// string[] asPos = sPos.Split('-');
// if ((iX == int.Parse(asPos[0])) && (iY == int.Parse(asPos[1]))) return true;
//}
}
return false;
}
public GroundedPredicate Ground(Dictionary<string, Constant> dBindings)
{
GroundedPredicate gp = new GroundedPredicate("K" + Knowledge.Name);
if (Knowledge is ParametrizedPredicate)
{
foreach (Argument a in ((ParametrizedPredicate)Knowledge).Parameters)
{
if (a is Parameter)
{
if (dBindings.ContainsKey(a.Name))
gp.AddConstant(dBindings[a.Name]);
else
throw new NotImplementedException();
}
else
gp.AddConstant((Constant)a);
}
}
else
{
foreach (Constant c in ((GroundedPredicate)Knowledge).Constants)
{
gp.AddConstant(c);
}
}
if (Parametrized)
{
if (dBindings.ContainsKey(Domain.VALUE_PARAMETER))
gp.AddConstant(dBindings[Domain.VALUE_PARAMETER]);
else
throw new NotImplementedException();
}
else
{
if (Value)
gp.AddConstant(new Constant(Domain.VALUE, Domain.TRUE_VALUE));
else
gp.AddConstant(new Constant(Domain.VALUE, Domain.FALSE_VALUE));
}
return gp;
}
private Formula ReadPredicate(CompoundExpression exp, Dictionary<string, string> dParameterNameToType, bool bParametrized, Domain d)
{
Predicate p = null;
int iExpression = 0;
string sName = "";
if (bParametrized)
p = new ParametrizedPredicate(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("?"))
{
a = new Parameter(dParameterNameToType[sName], sName);
bAllConstants = false;
}
else
{
a = new Constant(d.ConstantNameToType[sName], sName);
}
((ParametrizedPredicate)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((ParametrizedPredicate)p, d))
throw new NotImplementedException();
if (bParametrized && bAllConstants)
{
GroundedPredicate gp = new GroundedPredicate(p.Name);
foreach (Constant c in ((ParametrizedPredicate)p).Parameters)
gp.AddConstant(c);
p = gp;
}
PredicateFormula vf = new PredicateFormula(p);
return vf;
}
public override Predicate GenerateGiven(string sTag)
{
GroundedPredicate pGiven = new GroundedPredicate("Given" + Name);
foreach (Constant c in Constants)
pGiven.AddConstant(c);
pGiven.AddConstant(new Constant(Domain.TAG, sTag));
if (Negation)
return pGiven.Negate();
return pGiven;
}
public bool IsGoal(int iX, int iY)
{
//iX = -1;
//iY = -1;
if (Belief.Observed == null)
return false;
GroundedPredicate gp = new GroundedPredicate("at");
gp.AddConstant(new Constant("pos", "p" + iX + "-" + iY));
//if(f.Contains
if (Belief.Problem.Goal.Contains(gp)) return true;
return false;
}
public static List <string> MasterMindHeuristic(PartiallySpecifiedState pssCurrent, Domain domain)
{
List <Constant> lColors = new List <Constant>();
List <Constant> lPegs = new List <Constant>();
List <Constant> lValues = new List <Constant>();
foreach (Constant c in domain.Constants)
{
if (c.Type.ToLower() == "color")
{
lColors.Add(c);
}
if (c.Type.ToLower() == "peg")
{
lPegs.Add(c);
}
if (c.Type.ToLower() == "value")
{
lValues.Add(c);
}
}
//DateTime dtStart = DateTime.Now;
//BeliefState bs = pssCurrent.m_bsInitialBelief;
//State s = bs.ChooseState(true);
//List<Predicate> l = bs.RunSatSolver();
//Console.WriteLine((DateTime.Now - dtStart).TotalSeconds);
Permute(lColors);
List <Constant> lGuessColors = new List <Constant>();
for (int iPeg = 0; iPeg < lPegs.Count; iPeg++)
{
/*
* //foreach (GroundedPredicate gp in s.Predicates)
* foreach (GroundedPredicate gp in l)
* {
* if (gp.ToString().StartsWith("(on p" + iPeg) && gp.Negation == false)
* {
* lGuessColors.Add(gp.Constants[1]);
* }
*
*
* }
*/
foreach (Constant cColor in lColors)
{
GroundedPredicate gp = new GroundedPredicate("on");
gp.AddConstant(lPegs[iPeg]);
gp.AddConstant(cColor);
if (!pssCurrent.Observed.Contains(gp.Negate()))
{
lGuessColors.Add(cColor);
break;
}
}
lColors.Remove(lGuessColors.Last());
}
if (lGuessColors.Count == lPegs.Count)
{
List <string> lActions = new List <string>();
string sGuess = "guess-all";
foreach (Constant c in lGuessColors)
{
sGuess += " " + c.Name;
}
lActions.Add(sGuess);
lActions.Add("evaluate-guess");
foreach (Constant cValue in lValues)
{
lActions.Add("observe-LocationHits " + cValue.Name);
lActions.Add("observe-ColorHits " + cValue.Name);
}
return(lActions);
}
return(null);
}
private static GroundedPredicate GetPredicate(string sName, int iX, int iY)
{
GroundedPredicate gpSafe = new GroundedPredicate(sName);
gpSafe.AddConstant(new Constant("pos", "p" + iX + "-" + iY));
return gpSafe;
}
public bool IsLocationBlocked(int iX, int iY)
{
GroundedPredicate gp = new GroundedPredicate("at");
gp.AddConstant(new Constant("pos", "p" + iX + "-" + iY));
Action aChecking = Domain.GetAction("checking");
if (aChecking.Effects.Contains(gp))
return false;
return true;
}
private static GroundedPredicate GetSafe(int iX, int iY)
{
GroundedPredicate gpSafe = new GroundedPredicate("safe");
gpSafe.AddConstant(new Constant("pos", "p-" + iX));
gpSafe.AddConstant(new Constant("pos", "p-" + iY));
return gpSafe;
}
private Formula ReadPredicate(CompoundExpression exp, Dictionary <string, string> dParameterNameToType, bool bParametrized, Domain d)
{
Predicate p = null;
int iExpression = 0;
string sName = "";
if (bParametrized)
{
p = new ParametrizedPredicate(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("?"))
{
a = new Parameter(dParameterNameToType[sName], sName);
bAllConstants = false;
}
else
{
a = new Constant(d.ConstantNameToType[sName], sName);
}
((ParametrizedPredicate)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((ParametrizedPredicate)p, d))
{
throw new NotImplementedException();
}
}
if (bParametrized && bAllConstants)
{
GroundedPredicate gp = new GroundedPredicate(p.Name);
foreach (Constant c in ((ParametrizedPredicate)p).Parameters)
{
gp.AddConstant(c);
}
p = gp;
}
PredicateFormula vf = new PredicateFormula(p);
return(vf);
}
public static List<string> LargeWumpusHeuristic(PartiallySpecifiedState pssCurrent, Domain d)
{
List<string> lActions = new List<string>();
GroundedPredicate gpAtX = null, gpAtY = null;
foreach (GroundedPredicate gp in pssCurrent.Observed)
{
if (!gp.Negation)
{
if (gp.Name == "at-x")
gpAtX = gp;
if (gp.Name == "at-y")
gpAtY = gp;
}
}
string sX = gpAtX.Constants[0].Name;
string sY = gpAtY.Constants[0].Name;
int iX = int.Parse(sX.Split('-')[1]);
int iY = int.Parse(sY.Split('-')[1]);
VisitedLocations.Add(iX * 1000 + iY);
GroundedPredicate gpAlive = new GroundedPredicate("alive");
if (pssCurrent.Hidden.Contains(gpAlive))
lActions.Add("check-alive_" + sX + "_" + sY);
GroundedPredicate gpStench = new GroundedPredicate("stench");
gpStench.AddConstant(gpAtX.Constants[0]);
gpStench.AddConstant(gpAtY.Constants[0]);
if (pssCurrent.Hidden.Contains(gpStench))
lActions.Add("smell-wumpus " + sX + " " + sY);
GroundedPredicate gpBreeze = new GroundedPredicate("breeze");
gpBreeze.AddConstant(gpAtX.Constants[0]);
gpBreeze.AddConstant(gpAtY.Constants[0]);
if (pssCurrent.Hidden.Contains(gpBreeze))
lActions.Add("feel-breeze " + sX + " " + sY);
GroundedPredicate gpGold = new GroundedPredicate("gold-at");
gpGold.AddConstant(gpAtX.Constants[0]);
gpGold.AddConstant(gpAtY.Constants[0]);
if (pssCurrent.Hidden.Contains(gpGold))
lActions.Add("observe-gold " + sX + " " + sY);
if (lActions.Count == 0)
{
List<string> lNotVisited = new List<string>();
List<string> lSafe = new List<string>();
if (iX > 1)
{
if(!VisitedLocations.Contains((iX - 1) * 1000 + iY))
lNotVisited.Add("move-left");
if (pssCurrent.Observed.Contains(GetSafe(iX - 1, iY)))
lSafe.Add("move-left");
}
if (iX < Size )
{
if(!VisitedLocations.Contains((iX + 1) * 1000 + iY))
lNotVisited.Add("move-right");
if (pssCurrent.Observed.Contains(GetSafe(iX + 1, iY)))
lSafe.Add("move-right");
}
if (iY > 1)
{
if(!VisitedLocations.Contains(iX * 1000 + (iY - 1)))
lNotVisited.Add("move-up");
if (pssCurrent.Observed.Contains(GetSafe(iX, iY - 1)))
lSafe.Add("move-up");
}
if (iY < Size)
{
if(!VisitedLocations.Contains(iX * 1000 + (iY + 1)))
lNotVisited.Add("move-down");
if (pssCurrent.Observed.Contains(GetSafe(iX, iY + 1)))
lSafe.Add("move-down");
}
List<string> lSafeAndNotVisited = new List<string>(lSafe.Intersect(lNotVisited));
if (lSafeAndNotVisited.Count > 0)
{
int idx = RandomGenerator.Next(lSafeAndNotVisited.Count);
lActions.Add(lSafeAndNotVisited[idx]);
}
else if (lSafe.Count > 0)
{
int idx = RandomGenerator.Next(lSafe.Count);
lActions.Add(lSafe[idx]);
}
else
{
int idx = RandomGenerator.Next(4);
if (idx == 0)
lActions.Add("move-down");
if (idx == 1)
lActions.Add("move-up");
if (idx == 2)
lActions.Add("move-left");
if (idx == 3)
lActions.Add("move-right");
}
}
return lActions;
}
private State ChooseStateForLargeDomains()
{
State s = new State(Problem);
foreach (Predicate pKnown in Problem.Known)
s.AddPredicate(pKnown);
if (Problem.Name.Contains("Wumpus"))
{
int cWumpuses = LargeWumpusDomain.WumpusCount, cPits = LargeWumpusDomain.PitCount;
List<int> lPositions = new List<int>();
for (int i = 0; i < cWumpuses; i++)
{
int pos = GetRandomUniquePosition(lPositions, LargeWumpusDomain.Size);
int x = pos % 1000;
int y = pos / 1000;
GroundedPredicate gpWumpus = new GroundedPredicate("wumpus-at");
gpWumpus.AddConstant(new Constant("pos", "p-" + x));
gpWumpus.AddConstant(new Constant("pos", "p-" + y));
s.AddPredicate(gpWumpus);
if (x > 1)
{
GroundedPredicate gpStench = new GroundedPredicate("stench");
gpStench.AddConstant(new Constant("pos", "p-" + (x - 1)));
gpStench.AddConstant(new Constant("pos", "p-" + y));
s.AddPredicate(gpStench);
}
if (x < LargeWumpusDomain.Size)
{
GroundedPredicate gpStench = new GroundedPredicate("stench");
gpStench.AddConstant(new Constant("pos", "p-" + (x + 1)));
gpStench.AddConstant(new Constant("pos", "p-" + y));
s.AddPredicate(gpStench);
}
if (y > 1)
{
GroundedPredicate gpStench = new GroundedPredicate("stench");
gpStench.AddConstant(new Constant("pos", "p-" + x));
gpStench.AddConstant(new Constant("pos", "p-" + (y - 1)));
s.AddPredicate(gpStench);
}
if (y < LargeWumpusDomain.Size)
{
GroundedPredicate gpStench = new GroundedPredicate("stench");
gpStench.AddConstant(new Constant("pos", "p-" + x));
gpStench.AddConstant(new Constant("pos", "p-" + (y + 1)));
s.AddPredicate(gpStench);
}
}
for (int i = 0; i < cPits; i++)
{
int pos = GetRandomUniquePosition(lPositions, LargeWumpusDomain.Size);
int x = pos % 1000;
int y = pos / 1000;
GroundedPredicate gpPit = new GroundedPredicate("pit-at");
gpPit.AddConstant(new Constant("pos", "p-" + x));
gpPit.AddConstant(new Constant("pos", "p-" + y));
s.AddPredicate(gpPit);
if (x > 1)
{
GroundedPredicate gpBreeze = new GroundedPredicate("breeze");
gpBreeze.AddConstant(new Constant("pos", "p-" + (x - 1)));
gpBreeze.AddConstant(new Constant("pos", "p-" + y));
s.AddPredicate(gpBreeze);
}
if (x < LargeWumpusDomain.Size)
{
GroundedPredicate gpBreeze = new GroundedPredicate("breeze");
gpBreeze.AddConstant(new Constant("pos", "p-" + (x + 1)));
gpBreeze.AddConstant(new Constant("pos", "p-" + y));
s.AddPredicate(gpBreeze);
}
if (y > 1)
{
GroundedPredicate gpBreeze = new GroundedPredicate("breeze");
gpBreeze.AddConstant(new Constant("pos", "p-" + x));
gpBreeze.AddConstant(new Constant("pos", "p-" + (y - 1)));
s.AddPredicate(gpBreeze);
}
if (y < LargeWumpusDomain.Size)
{
GroundedPredicate gpBreeze = new GroundedPredicate("breeze");
gpBreeze.AddConstant(new Constant("pos", "p-" + x));
gpBreeze.AddConstant(new Constant("pos", "p-" + (y + 1)));
s.AddPredicate(gpBreeze);
}
}
for (int iX = 1; iX <= LargeWumpusDomain.Size; iX++)
for (int iY = 1; iY <= LargeWumpusDomain.Size; iY++)
{
if (!lPositions.Contains(iY * 1000 + iX))
{
GroundedPredicate gpSafe = new GroundedPredicate("safe");
gpSafe.AddConstant(new Constant("pos", "p-" + iX));
gpSafe.AddConstant(new Constant("pos", "p-" + iY));
s.AddPredicate(gpSafe);
}
}
int pGold = GetRandomUniquePosition(lPositions, LargeWumpusDomain.Size);
int xGold = pGold % LargeWumpusDomain.Size;
int yGold = pGold / LargeWumpusDomain.Size;
GroundedPredicate gpGold = new GroundedPredicate("gold-at");
gpGold.AddConstant(new Constant("pos", "p-" + xGold));
gpGold.AddConstant(new Constant("pos", "p-" + yGold));
s.AddPredicate(gpGold);
}
if (Problem.Name.Contains("Mine"))
{
bool[,] aBoard = new bool[MineSweeper.Size, MineSweeper.Size];
List<GroundedPredicate> lPredicates = new List<GroundedPredicate>();
for (int iMine = 0; iMine < MineSweeper.Size; iMine++)
{
int iX = RandomGenerator.Next(MineSweeper.Size);
int iY = RandomGenerator.Next(MineSweeper.Size);
GroundedPredicate gp = new GroundedPredicate("mine-at");
gp.AddConstant(new Constant("pos", "p" + iX + "-" + iY));
aBoard[iX, iY] = true;
lPredicates.Add(gp);
}
for (int iX = 0; iX < MineSweeper.Size; iX++)
for (int iY = 0; iY < MineSweeper.Size; iY++)
{
int cNeighbors = 0;
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++)
if (i != 0 || j != 0)
if (iX + i >= 0 && iX + i < MineSweeper.Size)
if (iY + j >= 0 && iY + j < MineSweeper.Size)
if (aBoard[iX + i, iY + j])
cNeighbors++;
GroundedPredicate gp = new GroundedPredicate("mine-count");
gp.AddConstant(new Constant("pos", "p" + iX + "-" + iY));
gp.AddConstant(new Constant("value", "v" + cNeighbors));
lPredicates.Add(gp);
}
foreach (Predicate p in lPredicates)
s.AddPredicate(p);
}
if (Problem.Name.Contains("Battleship"))
{
int[,] aMap = new int[Battleship.Size, Battleship.Size];
List<GroundedPredicate> lPredicates = new List<GroundedPredicate>();
int cFailures = 0;
for (int iShipType = Battleship.ShipTypes; iShipType > 0; iShipType--)
{
int cShips = Battleship.ShipCount[iShipType];
int iLength = iShipType;
for (int iShip = 0; iShip < cShips; iShip++)
{
bool bDone = false;
int cAttempts = 100;
while (!bDone && cAttempts > 0)
{
cAttempts--;
int iX = RandomGenerator.Next(Battleship.Size - iLength);
int iY = RandomGenerator.Next(Battleship.Size - iLength);
bool bVertical = RandomGenerator.NextDouble() < 0.5;
GroundedPredicate gp = null;
if (bVertical)
{
bool bFree = true;
for (int i = 0; i < iLength && bFree; i++)
if (aMap[iX, iY + i] > 0)
bFree = false;
if (bFree)
{
for (int i = 0; i < iLength && bFree; i++)
{
gp = new GroundedPredicate("ship-at");
//gp.AddConstant(new Constant("ship", "s-" + iShip));
gp.AddConstant(new Constant("pos", "p-" + iX));
gp.AddConstant(new Constant("pos", "p-" + (iY + i)));
lPredicates.Add(gp);
aMap[iX, iY + i] = 2;
}
for (int i = -1; i <= iLength; i++)
{
for (int j = -1; j <= 1; j++)
if (iX + j >= 0 && iX + j < Battleship.Size && iY + i >= 0 && iY + i < Battleship.Size)
{
if(aMap[iX + j, iY + i] == 0)
aMap[iX + j, iY + i] = 1;
}
}
bDone = true;
}
}
else
{
bool bFree = true;
for (int i = 0; i < iLength && bFree; i++)
if (aMap[iX + i, iY] > 0)
bFree = false;
if (bFree)
{
for (int i = 0; i < iLength && bFree; i++)
{
gp = new GroundedPredicate("ship-at");
//gp.AddConstant(new Constant("ship", "s-" + iShip));
gp.AddConstant(new Constant("pos", "p-" + (iX + i)));
gp.AddConstant(new Constant("pos", "p-" + iY));
lPredicates.Add(gp);
aMap[iX + i, iY] = 2;
}
for (int i = -1; i <= iLength; i++)
{
for (int j = -1; j <= 1; j++)
if (iX + i >= 0 && iX + i < Battleship.Size && iY + j >= 0 && iY + j < Battleship.Size)
{
if(aMap[iX + i, iY + j] == 0)
aMap[iX + i, iY + j] = 1;
}
}
bDone = true;
}
}
}
if (cAttempts == 0)
cFailures++;
}
}
if (cFailures > 0)
Console.WriteLine();
for (int iX = 0; iX < Battleship.Size; iX++)
{
for (int iY = 0; iY < Battleship.Size; iY++)
{
if (aMap[iX, iY] != 2)
{
GroundedPredicate gp = new GroundedPredicate("water-at");
gp.AddConstant(new Constant("pos", "p-" + iX));
gp.AddConstant(new Constant("pos", "p-" + iY));
lPredicates.Add(gp);
Debug.Write('-');
}
else
Debug.Write('X');
/*
gp = new GroundedPredicate("hit");
gp.AddConstant(new Constant("POS", "p-" + iX));
gp.AddConstant(new Constant("POS", "p-" + iY));
gp.Negation = true;
lPredicates.Add(gp);
* */
}
Debug.Write("\n");
}
foreach (Predicate p in lPredicates)
s.AddPredicate(p);
}
return s;
}
private void GetApplicableEffects(Formula fEffects, HashSet<Predicate> lAdd, HashSet<Predicate> lDelete)
{
if (fEffects is PredicateFormula)
{
Predicate p = ((PredicateFormula)fEffects).Predicate;
if (p.Negation)
lDelete.Add(p);
else
lAdd.Add(p);
}
else if (fEffects is ProbabilisticFormula)
{
ProbabilisticFormula pf = (ProbabilisticFormula)fEffects;
double dRand = RandomGenerator.NextDouble();
double dInitialRand = dRand;
int iOption = 0;
while (iOption < pf.Options.Count && dRand > 0)
{
dRand -= pf.Probabilities[iOption];
iOption++;
}
if (dRand < 0.01)
{
iOption--;
GetApplicableEffects(pf.Options[iOption], lAdd, lDelete);
}
else //the no-op option was chosen
{
iOption = -1;
}
GroundedPredicate pChoice = new GroundedPredicate("Choice");
pChoice.AddConstant(new Constant("ActionIndex", "a" + Time));
pChoice.AddConstant(new Constant("ChoiceIndex", "c" + ChoiceCount + "." + iOption));
ChoiceCount++;
State s = this;
while (s != null)
{
s.m_lPredicates.Add(pChoice);
s = s.m_sPredecessor;
}
}
else
{
CompoundFormula cf = (CompoundFormula)fEffects;
if (cf.Operator == "oneof" || cf.Operator == "or")//BUGBUG - should treat or differently
{
int iRandomIdx = RandomGenerator.Next(cf.Operands.Count);
GetApplicableEffects(cf.Operands[iRandomIdx], lAdd, lDelete);
GroundedPredicate pChoice = new GroundedPredicate("Choice");
pChoice.AddConstant(new Constant("ActionIndex", "a" + Time));
pChoice.AddConstant(new Constant("ChoiceIndex", "c" + ChoiceCount + "." + iRandomIdx));
ChoiceCount++;
State s = this;
while (s != null)
{
s.m_lPredicates.Add(pChoice);
s = s.m_sPredecessor;
}
}
else if (cf.Operator == "and")
{
foreach (Formula f in cf.Operands)
{
GetApplicableEffects(f, lAdd, lDelete);
}
}
else if (cf.Operator == "when")
{
if (Contains(cf.Operands[0]))
GetApplicableEffects(cf.Operands[1], lAdd, lDelete);
}
else if (cf is ParametrizedFormula)
{
ParametrizedFormula pf = (ParametrizedFormula)cf;
foreach (Formula fNew in pf.Ground(Problem.Domain.Constants))
GetApplicableEffects(fNew, lAdd, lDelete);
}
else
throw new NotImplementedException();
}
}
public CompoundFormula RemoveNonDeterminism(int iActionIndex, ref int iChoiceIndex, CompoundFormula cfAndChoices)
{
CompoundFormula cfNew = null;
if (Operator == "and")
{
cfNew = new CompoundFormula("and");
foreach (Formula f in Operands)
{
if (f is PredicateFormula)
{
cfNew.AddOperand(f);
}
else
{
CompoundFormula cfOperand = ((CompoundFormula)f).RemoveNonDeterminism(iActionIndex, ref iChoiceIndex, cfAndChoices);
cfNew.AddOperand(cfOperand);
}
}
}
else if (Operator == "oneof" || Operator == "or")
{
cfNew = new CompoundFormula("and");
CompoundFormula cfChoices = new CompoundFormula(Operator);
foreach (Formula f in Operands)
{
GroundedPredicate pChoice = new GroundedPredicate("Choice");
pChoice.AddConstant(new Constant("ActionIndex", "a" + iActionIndex));
pChoice.AddConstant(new Constant("ChoiceIndex", "c" + iChoiceIndex));
iChoiceIndex++;
CompoundFormula cfWhen = new CompoundFormula("when");
cfWhen.AddOperand(pChoice);
cfWhen.AddOperand(f);
cfNew.AddOperand(cfWhen);
cfChoices.AddOperand(pChoice);
}
cfAndChoices.AddOperand(cfChoices);
}
else if (Operator == "when")
{
if(Operands[1] is PredicateFormula)
return this;
CompoundFormula cfSecond = ((CompoundFormula)Operands[1]).RemoveNonDeterminism(iActionIndex, ref iChoiceIndex, cfAndChoices);
bool bInserted = false;
cfNew = cfSecond.InsertGiven(Operands[0], out bInserted);
if (!bInserted)
{
cfNew = new CompoundFormula("when");
cfNew.AddOperand(Operands[0]);
cfNew.AddOperand(cfSecond);
}
/*
cfNew = new CompoundFormula("when");
if (cfSecond.Operator == "and")
{
cfNew.AddOperand(Operands[0]);
cfNew.AddOperand(cfSecond);
}
else if (cfSecond.Operator == "when")
{
CompoundFormula cfAnd = new CompoundFormula("and");
cfAnd.AddOperand(Operands[0]);
cfAnd.AddOperand(cfSecond.Operands[0]);
cfNew.AddOperand(cfAnd);
cfNew.AddOperand(cfSecond.Operands[1]);
}
* */
}
else if (Operator == "not")
{
cfNew = new CompoundFormula("not");
if (cfNew.Operands[0] is PredicateFormula)
cfNew.AddOperand(Operands[0]);
else
cfNew.AddOperand(((CompoundFormula)Operands[0]).RemoveNonDeterminism(iActionIndex, ref iChoiceIndex, cfAndChoices));
}
else
throw new NotImplementedException();
return cfNew;
}
private void AddEffects(Formula fEffects)
{
if (fEffects is PredicateFormula)
{
AddEffect(((PredicateFormula)fEffects).Predicate);
}
else
{
CompoundFormula cf = (CompoundFormula)fEffects;
if (cf.Operator == "oneof" || cf.Operator == "or")//BUGBUG - should treat or differently
{
int iRandomIdx = RandomGenerator.Next(cf.Operands.Count);
AddEffects(cf.Operands[iRandomIdx]);
GroundedPredicate pChoice = new GroundedPredicate("Choice");
pChoice.AddConstant(new Constant("ActionIndex", "a" + (Time - 1)));//time - 1 because this is the action that generated the state, hence its index is i-1
pChoice.AddConstant(new Constant("ChoiceIndex", "c" + iRandomIdx));
State s = this;
while (s != null)
{
s.m_lPredicates.Add(pChoice);
s = s.m_sPredecessor;
}
}
else if (cf.Operator == "and")
{
foreach (Formula f in cf.Operands)
{
if (f is PredicateFormula)
{
AddEffect(((PredicateFormula)f).Predicate);
}
else
AddEffects(f);
}
}
else if (cf.Operator == "when")
{
if (m_sPredecessor.Contains(cf.Operands[0]))
AddEffects(cf.Operands[1]);
}
else
throw new NotImplementedException();
}
}
public static List <string> LargeWumpusHeuristic(PartiallySpecifiedState pssCurrent, Domain d)
{
List <string> lActions = new List <string>();
GroundedPredicate gpAtX = null, gpAtY = null;
foreach (GroundedPredicate gp in pssCurrent.Observed)
{
if (!gp.Negation)
{
if (gp.Name == "at-x")
{
gpAtX = gp;
}
if (gp.Name == "at-y")
{
gpAtY = gp;
}
}
}
string sX = gpAtX.Constants[0].Name;
string sY = gpAtY.Constants[0].Name;
int iX = int.Parse(sX.Split('-')[1]);
int iY = int.Parse(sY.Split('-')[1]);
VisitedLocations.Add(iX * 1000 + iY);
GroundedPredicate gpAlive = new GroundedPredicate("alive");
if (pssCurrent.Hidden.Contains(gpAlive))
{
lActions.Add("check-alive_" + sX + "_" + sY);
}
GroundedPredicate gpStench = new GroundedPredicate("stench");
gpStench.AddConstant(gpAtX.Constants[0]);
gpStench.AddConstant(gpAtY.Constants[0]);
if (pssCurrent.Hidden.Contains(gpStench))
{
lActions.Add("smell-wumpus " + sX + " " + sY);
}
GroundedPredicate gpBreeze = new GroundedPredicate("breeze");
gpBreeze.AddConstant(gpAtX.Constants[0]);
gpBreeze.AddConstant(gpAtY.Constants[0]);
if (pssCurrent.Hidden.Contains(gpBreeze))
{
lActions.Add("feel-breeze " + sX + " " + sY);
}
GroundedPredicate gpGold = new GroundedPredicate("gold-at");
gpGold.AddConstant(gpAtX.Constants[0]);
gpGold.AddConstant(gpAtY.Constants[0]);
if (pssCurrent.Hidden.Contains(gpGold))
{
lActions.Add("observe-gold " + sX + " " + sY);
}
if (lActions.Count == 0)
{
List <string> lNotVisited = new List <string>();
List <string> lSafe = new List <string>();
if (iX > 1)
{
if (!VisitedLocations.Contains((iX - 1) * 1000 + iY))
{
lNotVisited.Add("move-left");
}
if (pssCurrent.Observed.Contains(GetSafe(iX - 1, iY)))
{
lSafe.Add("move-left");
}
}
if (iX < Size)
{
if (!VisitedLocations.Contains((iX + 1) * 1000 + iY))
{
lNotVisited.Add("move-right");
}
if (pssCurrent.Observed.Contains(GetSafe(iX + 1, iY)))
{
lSafe.Add("move-right");
}
}
if (iY > 1)
{
if (!VisitedLocations.Contains(iX * 1000 + (iY - 1)))
{
lNotVisited.Add("move-up");
}
if (pssCurrent.Observed.Contains(GetSafe(iX, iY - 1)))
{
lSafe.Add("move-up");
}
}
if (iY < Size)
{
if (!VisitedLocations.Contains(iX * 1000 + (iY + 1)))
{
lNotVisited.Add("move-down");
}
if (pssCurrent.Observed.Contains(GetSafe(iX, iY + 1)))
{
lSafe.Add("move-down");
}
}
List <string> lSafeAndNotVisited = new List <string>(lSafe.Intersect(lNotVisited));
if (lSafeAndNotVisited.Count > 0)
{
int idx = RandomGenerator.Next(lSafeAndNotVisited.Count);
lActions.Add(lSafeAndNotVisited[idx]);
}
else if (lSafe.Count > 0)
{
int idx = RandomGenerator.Next(lSafe.Count);
lActions.Add(lSafe[idx]);
}
else
{
int idx = RandomGenerator.Next(4);
if (idx == 0)
{
lActions.Add("move-down");
}
if (idx == 1)
{
lActions.Add("move-up");
}
if (idx == 2)
{
lActions.Add("move-left");
}
if (idx == 3)
{
lActions.Add("move-right");
}
}
}
return(lActions);
}
public Predicate ReadFunctionExpression(CompoundExpression exp, Dictionary<string, string> dParameterNameToType, Domain d)
{
Constant c = null;
string sName = exp.SubExpressions[0].ToString();
if (exp.Type == "=")
{
string sParam1 = exp.SubExpressions[0].ToString();
string sParam2 = exp.SubExpressions[1].ToString();
if (!dParameterNameToType.ContainsKey(sParam1))
throw new ArgumentException("First argument of = must be a parameter");
ParametrizedPredicate pp = new ParametrizedPredicate("=");
pp.AddParameter(new Parameter(dParameterNameToType[sParam1], sParam1));
if (dParameterNameToType.ContainsKey(sParam2))
pp.AddParameter(new Parameter(dParameterNameToType[sParam2], sParam2));
else
pp.AddParameter(new Constant(d.ConstantNameToType[sParam2], sParam2));
return pp;
}
GroundedPredicate p = new GroundedPredicate(exp.Type);
double dValue = 0.0;
if (d.Functions.Contains(sName))
c = new Constant("Function", sName);
else
throw new ArgumentException("First argument of increase or decrease must be a function");
p.AddConstant(c);
sName = exp.SubExpressions[1].ToString();
if (double.TryParse(sName, out dValue))
c = new Constant("Number", sName);
else
throw new ArgumentException("Second argument of increase or decrease must be a number");
p.AddConstant(c);
return p;
}
