public static List <Landmark> GetPublicLandmarks(GroundedPredicate goalFact, Agent courentAgent)
{
List <List <Action> > publicActionslandmarks = new List <List <Action> >();
List <Landmark> publicLandmark = new List <Landmark>();
Queue <Landmark> PrivacyPreservingQueue = new Queue <Landmark>();
Landmark l = new Landmark("pre", false);
l.AddPrivateFact(goalFact, "pre");
l.isPublic = false;
PrivacyPreservingQueue.Enqueue(l);
// publicLandmark.Add(l);
if (courentAgent.PublicPredicates.Contains(goalFact))
{
throw new Exception("it is not should to be public predicate");
}
foreach (Agent agent in agents)
{
if (agent.name.Equals(courentAgent.name))
{
agent.initPublicLandmarksDetect(l);
}
else
{
agent.initPublicLandmarksDetect(null);
}
}
while (PrivacyPreservingQueue.Count > 0)
{
Landmark ppLandmark = PrivacyPreservingQueue.Dequeue();
foreach (Agent agent in agents)
{
agent.Reset();
}
foreach (Agent agent in agents)
{
if (courentAgent.name.Equals(agent.name))
{
agent.SetLandmarkToExplorer(ppLandmark);
}
else
{
agent.SetLandmarkToExplorer((Landmark)null);
}
}
HashSet <GroundedPredicate> publicSet = new HashSet <GroundedPredicate>();
foreach (Agent agent in agents)
{
HashSet <GroundedPredicate> tmp = agent.Detection();
foreach (var gp in tmp)
{
if (!publicSet.Contains(gp))
{
publicSet.Add(gp);
}
}
}
bool flag2 = true;
while (flag2)
{
flag2 = false;
foreach (Agent agent in agents)
{
HashSet <GroundedPredicate> tmp = agent.WhatYoCanGet(publicSet);
foreach (var gp in tmp)
{
if (!publicSet.Contains(gp))
{
publicSet.Add(gp);
flag2 = true;
}
}
}
}
List <Agent> relevantAgents = new List <Agent>();
foreach (Agent agent in agents)
{
List <Action> lAchievers = agent.CanGet();
if (lAchievers != null)
{
relevantAgents.Add(agent);
List <Action> publicActions = courentAgent.GetPublicActions(lAchievers);
if (publicActions.Count > 0)
{
if (ppLandmark.lAchievers != null)
{
ppLandmark.lAchievers.AddRange(publicActions);
}
else
{
ppLandmark.lAchievers = publicActions;
}
}
}
}
if (relevantAgents.Count == 1)
{
List <Landmark> newPPLandmarks = relevantAgents.ElementAt(0).DetectNewLocalLandmarks(false);
for (int i = 0; i < newPPLandmarks.Count; i++)
{
Landmark ppl = newPPLandmarks.ElementAt(i);
if (ppLandmark.mix)
{
publicLandmark.Remove(ppLandmark);
List <GroundedPredicate> publicFacts = courentAgent.GetPublicFacts(ppLandmark.facts.Keys.ToList());
foreach (GroundedPredicate publicFact in publicFacts)
{
ppl.AddPublicFact(publicFact, "pre");
}
ppl.lAchievers = new List <Action>();
ppl.lAchievers.AddRange(ppLandmark.lAchievers);
}
if (ppl.isPublic || ppl.mix)
{
publicLandmark.Add(ppl);
}
if (!ppl.isPublic || ppl.mix)
{
PrivacyPreservingQueue.Enqueue(ppl);
}
}
}
else
{
if (relevantAgents.Count > 1)
{
throw new Exception("only one agent can Achieve private landmark");
}
}
}
List <Landmark> ans = new List <Landmark>();
for (int i = 0; i < publicLandmark.Count; i++)
{
Landmark ppl = publicLandmark.ElementAt(i);
Landmark newl = new Landmark("Goal", true);
foreach (GroundedPredicate pgp in courentAgent.GetPublicFacts(ppl.facts.Keys.ToList()))
{
newl.AddPublicFact(pgp, "art-goal");
}
ans.Add(newl);
}
return(ans);
}
public static KeyValuePair <List <List <Action> >, List <Landmark> > GetPublicActionsLandmarks(GroundedPredicate goalFact, Agent courentAgent, out int localDepth, bool pos)
{
List <List <Action> > publicActionslandmarks = new List <List <Action> >();
List <Landmark> publicLandmark = new List <Landmark>();
Queue <Landmark> PrivacyPreservingQueue = new Queue <Landmark>();
List <Landmark> tmpForTest = new List <Landmark>();
List <Landmark> tmpForDepthTest = new List <Landmark>();
Landmark l = new Landmark("pre", false);
l.AddPrivateFact(goalFact, "pre");
l.isPublic = false;
PrivacyPreservingQueue.Enqueue(l);
//publicLandmark.Add(l);
if (courentAgent.PublicPredicates.Contains(goalFact))
{
throw new Exception("it is not should to be public predicate");
}
foreach (Agent agent in agents)
{
if (agent.name.Equals(courentAgent.name))
{
agent.initPublicLandmarksDetect(l);
}
else
{
agent.initPublicLandmarksDetect(null);
}
}
List <Action> allAchievers;
int index = 0;
while (PrivacyPreservingQueue.Count > 0)
{
bool closeLandmark = false;
allAchievers = null;
Landmark ppLandmark = PrivacyPreservingQueue.Dequeue();
if (ppLandmark.facts.Count == 0)
{
Console.WriteLine("ddd");
}
bool f = true;
foreach (Landmark land in tmpForTest)
{
if (land.Equals(ppLandmark))
{
f = false;
break;
}
}
if (f)
{
Landmark nl = new Landmark("dd", false);
nl.facts = new Dictionary <GroundedPredicate, string>(ppLandmark.facts);
nl.index = ppLandmark.index;
tmpForTest.Add(nl);
}
foreach (Landmark land in tmpForDepthTest)
{
if (land.Identical(ppLandmark))
{
f = false;
break;
}
}
if (f)
{
tmpForDepthTest.Add(ppLandmark);
}
foreach (Agent agent in agents)
{
agent.Reset();
}
foreach (Agent agent in agents)
{
if (courentAgent.name.Equals(agent.name))
{
agent.SetLandmarkToExplorer(ppLandmark);
}
else
{
agent.SetLandmarkToExplorer((Landmark)null);
}
}
HashSet <GroundedPredicate> publicSet = new HashSet <GroundedPredicate>();
foreach (Agent agent in agents)
{
HashSet <GroundedPredicate> tmp = agent.DetectionGlobal();
foreach (var gp in tmp)
{
if (!publicSet.Contains(gp))
{
publicSet.Add(gp);
}
}
}
bool flag2 = true;
while (flag2)
{
flag2 = false;
foreach (Agent agent in agents)
{
HashSet <GroundedPredicate> tmp = agent.WhatYoCanGet(publicSet);
foreach (var gp in tmp)
{
if (!publicSet.Contains(gp))
{
publicSet.Add(gp);
flag2 = true;
}
}
}
}
List <Agent> relevantAgents = new List <Agent>();
foreach (Agent agent in agents)
{
List <Action> lAchievers = agent.CanGet();
if (lAchievers != null)
{
relevantAgents.Add(agent);
allAchievers = lAchievers;
if (!ppLandmark.secondRound)
{
foreach (GroundedPredicate fact in ppLandmark.facts.Keys.ToList())
{
bool flag = false;
foreach (Action act in lAchievers)
{
if (act.HashEffects.Contains(fact))
{
flag = true;
break;
}
}
if (!flag)
{
ppLandmark.facts.Remove(fact);
}
}
List <Action> publicActions = courentAgent.GetPublicActions(lAchievers);
List <Action> privateAchievers = new List <Action>(allAchievers);
foreach (Action pubAct in publicActions)
{
privateAchievers.Remove(pubAct);
}
bool possibleInTheInitial = agent.PossibleInTheInitial(privateAchievers);
/* bool test = agent.PossibleInTheInitial(allAchievers);
* if (test && !possibleInTheInitial)
* {
* Console.WriteLine("***");
* }*/
if (ppLandmark.AchieversPossibleInTheInitial == false)
{
ppLandmark.AchieversPossibleInTheInitial = possibleInTheInitial;
}
if (publicActions.Count > 0)
{
if (ppLandmark.lAchievers != null)
{
ppLandmark.lAchievers.AddRange(publicActions);
}
else
{
ppLandmark.lAchievers = publicActions;
}
if (publicActions.Count == lAchievers.Count)
{
closeLandmark = true;
}
}
}
}
}
if (ppLandmark.lAchievers == null)
{
ppLandmark.lAchievers = new List <Action>();
}
if (allAchievers == null)
{
ppLandmark.secondRound = true;
}
if (!closeLandmark && ppLandmark.secondRound)
{
if (relevantAgents.Count == 1)
{
List <Landmark> newPPLandmarks = relevantAgents.ElementAt(0).DetectNewLocalLandmarks(true);
foreach (Landmark slave in newPPLandmarks)
{
slave.myMuster = ppLandmark;
slave.index = index;
index++;
}
for (int i = 0; i < newPPLandmarks.Count; i++)
{
Landmark ppl = newPPLandmarks.ElementAt(i);
ppl.AchieversPossibleInTheInitial = ppLandmark.AchieversPossibleInTheInitial;
ppl.lAchievers = new List <Action>(ppLandmark.lAchievers);
PrivacyPreservingQueue.Enqueue(ppl);
}
if (newPPLandmarks.Count == 0)
{
if (ppLandmark.lAchievers != null && ppLandmark.lAchievers.Count > 0)
{
if (ppLandmark.publicEffects != null)
{
ppLandmark.facts = new Dictionary <GroundedPredicate, string>();
foreach (GroundedPredicate gp in ppLandmark.publicEffects)
{
ppLandmark.facts.Add(gp, "pre");
}
publicLandmark.Add(ppLandmark);
}
}
}
}
else
{
if (relevantAgents.Count > 1)
{
throw new Exception("only one agent can Achieve private landmark");
}
if (relevantAgents.Count == 0)
{
if (ppLandmark.lAchievers != null && ppLandmark.lAchievers.Count > 0)
{
ppLandmark.facts = new Dictionary <GroundedPredicate, string>();
foreach (GroundedPredicate gp in ppLandmark.publicEffects)
{
ppLandmark.facts.Add(gp, "pre");
}
publicLandmark.Add(ppLandmark);
}
}
}
}
else
{
if (closeLandmark)
{
publicLandmark.Add(ppLandmark);
}
else
{
foreach (GroundedPredicate gp in ppLandmark.facts.Keys.ToList())
{
bool dell = true;
foreach (Action act in allAchievers)
{
if (ppLandmark.lAchievers == null || !ppLandmark.lAchievers.Contains(act))
{
if (act.HashEffects.Contains(gp))
{
dell = false;
break;
}
}
}
if (dell)
{
if (ppLandmark.publicEffects == null)
{
ppLandmark.publicEffects = new List <GroundedPredicate>();
}
ppLandmark.publicEffects.Add(gp);
ppLandmark.facts.Remove(gp);
}
else
{
bool flag = false;
if (ppLandmark.lAchievers != null)
{
foreach (Action act in ppLandmark.lAchievers)
{
if (act.HashEffects.Contains(gp))
{
flag = true;
break;
}
}
if (flag)
{
if (ppLandmark.publicEffects == null)
{
ppLandmark.publicEffects = new List <GroundedPredicate>();
}
ppLandmark.publicEffects.Add(gp);
}
}
}
}
ppLandmark.secondRound = true;
PrivacyPreservingQueue.Enqueue(ppLandmark);
}
}
}
if (pos)
{
int size = 0;
foreach (Landmark la in tmpForTest)
{
size += la.facts.Count();
}
AdvancedLandmarkProjectionPlaner.sizeOfRegressionTree += size;
}
HashSet <Landmark> dellPar = new HashSet <Landmark>();
foreach (Landmark land in tmpForDepthTest)
{
if (land.myMuster != null)
{
dellPar.Add(land.myMuster);
}
}
foreach (Landmark ldel in dellPar)
{
tmpForDepthTest.Remove(ldel);
}
int depth = 0;
foreach (Landmark land in tmpForDepthTest)
{
depth += land.depth;
}
localDepth = depth;
List <Landmark> landmarks = new List <Landmark>();
for (int i = 0; i < publicLandmark.Count; i++)
{
Landmark ppl = publicLandmark.ElementAt(i);
if (ppl.lAchievers != null)
{
landmarks.Add(ppl);
publicActionslandmarks.Add(ppl.lAchievers);
}
}
return(new KeyValuePair <List <List <Action> >, List <Landmark> >(publicActionslandmarks, landmarks));;
}
