/*
* Use this class in order to limit the publishing of states that reveal a certain dependency that shouldn't be revealed.
* This class shall pick which dependencies should we reveal and which should we not reveal.
*/
public void PrepareSelection(AAdvancedProjectionActionPublisher publisher, List <MapsAgent> mafsAgents, List <Agent> agents, AHandleTraces tracesHandler, List <Domain> lDomains, List <Problem> lProblems)
{
//TODO: handle traces later...
List <Action> allProjectionAction = new List <Action>();
GroundedPredicate newPrePredicate = null;
newPrePredicate = new GroundedPredicate(Domain.ARTIFICIAL_PREDICATE + "StartState");
List <Predicate> predicates = new List <Predicate>();
predicates.Add(newPrePredicate);
int index = 0;
Dictionary <Agent, List <Action> > agentsProjections = new Dictionary <Agent, List <Action> >();
//Measuring the time for the dependencies generation:
List <DateTime> dependenciesProjectionStartTimes = new List <DateTime>();
List <DateTime> dependenciesProjectionEndTimes = new List <DateTime>();
foreach (Agent agent in agents)
{
agent.initLandmarksDetect();
//this returns all of the projections, we will need to take only some of them and look at how does it affect the solution
DateTime startDependenciesGeneration = DateTime.Now;
dependenciesProjectionStartTimes.Add(startDependenciesGeneration);
List <Action> currentlProjAction = agent.getAdvancedProjectionPublicAction(index, predicates);
DateTime endDependenciesGeneration = DateTime.Now;
dependenciesProjectionEndTimes.Add(endDependenciesGeneration);
//Save the dependencies for later usage:
agentsProjections.Add(agent, currentlProjAction);
foreach (Action act in currentlProjAction)
{
act.agent = agent.name;
}
index += 1000;
}
Program.SaveTimeMeasurmentsForCreatingDependencies(dependenciesProjectionStartTimes, dependenciesProjectionEndTimes);
/*
* LeakageTrace.setAgents(agents);
* Dictionary<Agent, LeakageTrace> traces = new Dictionary<Agent, LeakageTrace>();
* List<Action> publicActionsForTraces = new List<Action>();
* foreach (Agent agent in agents)
* {
* LeakageTrace trace = new LeakageTrace(agent);
* traces.Add(agent, trace);
* publicActionsForTraces.AddRange(agentsProjections[agent]);
* }
* AdvancedLandmarkProjectionPlaner.firstTimeWritenStates = new Dictionary<Agent, bool>();
* foreach (Agent agent in agents)
* {
* traces[agent].initializeOperators(publicActionsForTraces, agent.privateActions);
* AdvancedLandmarkProjectionPlaner.writeFirstHalfOfJsonToFile(agent, traces[agent]);
* AdvancedLandmarkProjectionPlaner.firstTimeWritenStates.Add(agent, true);
* }
*
* tracesHandler.setAgents(agents);
* tracesHandler.setTraces(traces);
*/
//clear the actions affected dictionary:
AdvancedLandmarkProjectionPlaner.actionsAffectedForAgent = new Dictionary <Agent, Dictionary <Predicate, List <Action> > >();
//publish all of the chosen projections, by the chosen policy:
Console.WriteLine("Choosing which dependencies to publish");
publisher.setAgents(agents);
DateTime dependenciesSelectionStartTime = DateTime.Now;
publisher.publishActions(allProjectionAction, agentsProjections);
DateTime dependenciesSelectionEndTime = DateTime.Now;
Program.SaveTimeMeasurmentForSelectingDependencies(dependenciesSelectionStartTime, dependenciesSelectionEndTime);
Dictionary <string, MapsAgent> name2mafsAgent = new Dictionary <string, MapsAgent>();
foreach (MapsAgent mapsAgent in mafsAgents)
{
name2mafsAgent.Add(mapsAgent.name, mapsAgent);
}
Dictionary <string, Agent> name2agent = new Dictionary <string, Agent>();
Dictionary <string, List <Action> > agentName2agentProjActions = new Dictionary <string, List <Action> >();
foreach (Agent agent in agents)
{
name2agent.Add(agent.name, agent);
//Set start state dependencies:
MapsAgent mapsAgent = name2mafsAgent[agent.name];
List <Predicate> startStatePredicates = agent.GetPrivateStartState().Cast <Predicate>().ToList();
//List<Predicate> startState = GetTransformedArtificialPredicates(agent, startStatePredicates);
mapsAgent.SetDependenciesAtStartState(startStatePredicates);
agentName2agentProjActions[agent.name] = new List <Action>();
}
foreach (Action action in allProjectionAction)
{
MapsAgent mafsAgent = name2mafsAgent[action.agent];
Agent agent = name2agent[action.agent];
List <Predicate> effects = GetTransformedArtificialPredicates(agent, action.HashEffects);
mafsAgent.AddToEffectsActionsAndDependencies(action.Name, effects);
List <Predicate> preconditions = GetTransformedArtificialPredicates(agent, action.HashPrecondition);
mafsAgent.AddToPreconditionActionsAndDependencies(action.Name, preconditions);
agentName2agentProjActions[agent.name].Add(action);
}
MapsPlanner.allProjectionActions = allProjectionAction;
foreach (Agent a in agents)
{
MapsAgent mAgent = name2mafsAgent[a.name];
//Create a new projection hueristics, based on only the selected dependencies:
mAgent.projectionHeuristic = new AdvancedProjectionHeuristic(a, agents, lDomains, lProblems, agentName2agentProjActions, predicates);
}
}
/*
* Use this class in order to not select any dependencies at the execution of the MAFS planner.
* It is as if it is just a regular MAFS projection planner, without limiting the messages delivered by the planner.
*/
public void PrepareSelection(AAdvancedProjectionActionPublisher publisher, List <MapsAgent> mafsAgents, List <Agent> agents, AHandleTraces tracesHandler, List <Domain> lDomains, List <Problem> lProblems)
{
//Don't do anything here...
}
