public bool DuplicateControl(WorldDynamic currentState, PlanAction action, StoryGraph currentGraph, KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, StoryNode currentNode, int globalNodeNumber, bool succsessControl) { StoryNode testNode = currentGraph.CreateTestNode(currentState, action, agent, currentNode, false, globalNodeNumber, succsessControl); testNode.UpdateHashCode(); foreach (var checkedNode in currentGraph.GetNodes()) { checkedNode.UpdateHashCode(); if (currentGraph.TwoNodesComparison(testNode, checkedNode)) { currentGraph.DeleteTestNode(ref testNode); return(false); } } currentGraph.DeleteTestNode(ref testNode); return(true); }
public void MultiAVandAC(ref PlanAction receivedAction, WorldDynamic currentState, KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, CSP_Module cspModule, StoryGraph currentGraph, StoryNode currentNode, bool root, ref int globalNodeNumber, ref Queue <StoryNode> queue) { List <PlanAction> actionsList = cspModule.MassiveAssignVariables(ref receivedAction, currentState, agent); AgentStateStatic sCurrentAgent = (AgentStateStatic)agent.Key.Clone(); AgentStateDynamic dCurrentAgent = (AgentStateDynamic)agent.Value.Clone(); KeyValuePair <AgentStateStatic, AgentStateDynamic> currentAgent = new KeyValuePair <AgentStateStatic, AgentStateDynamic>(sCurrentAgent, dCurrentAgent); WorldDynamic statePrefab = (WorldDynamic)currentState.Clone(); foreach (var a in actionsList) { ActionControl(a, currentGraph, currentAgent, statePrefab, currentNode, root, ref globalNodeNumber, ref queue); } // Cleaning actionsList = null; currentNode = null; statePrefab = null; GC.Collect(); }
public void DuplicateNodeConnecting(WorldDynamic currentState, PlanAction action, KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, StoryNode currentNode, int globalNodeNumber, ref Queue <StoryNode> queue, bool succsessControl, ref bool skip) { StoryNode testNode = CreateTestNode(currentState, action, agent, currentNode, false, globalNodeNumber, succsessControl); testNode.UpdateHashCode(); if (!testNode.Equals(currentNode)) { foreach (var checkedNode in nodes) { if (TwoNodesComparison(testNode, checkedNode) && !currentNode.ConnectedWith(checkedNode)) { DeleteTestNode(ref testNode); ConnectionTwoNodes(action, currentNode, checkedNode, true); break; } } } else { DeleteTestNode(ref testNode); skip = true; } }
public void CounterreactionControl(PlanAction action, StoryGraph currentGraph, KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, WorldDynamic currentState, StoryNode currentNode, bool root, ref int globalNodeNumber, ref Queue <StoryNode> queue, ref bool controlOne, ref bool controlTwo) { bool succsessControl = ProbabilityCalculating(action); action.success = succsessControl; action.fail = !succsessControl; bool constraintsControl = ConstraintsControl(currentState, action, succsessControl); bool deadEndsControl = DeadEndsControl(action, currentState, agent, succsessControl); bool duplicateControl = DuplicateControl(currentState, action, currentGraph, agent, currentNode, globalNodeNumber, succsessControl); //bool cyclesControl = CyclesControl(currentState, action, currentGraph, agent, currentNode, duplicateControl, globalNodeNumber, succsessControl); bool cyclesControl = true; controlOne = constraintsControl & deadEndsControl & cyclesControl; controlTwo = duplicateControl; }
/// <summary> /// Checking whether the application of an action would violate the established constraints. /// </summary> public bool ConstraintsControl(WorldDynamic currentState, PlanAction action, bool succsessControl) { WorldDynamic worldForTest = (WorldDynamic)currentState.Clone(); if (!succsessControl) { action.Fail(ref worldForTest); } else { action.ApplyEffects(ref worldForTest); } foreach (var constraint in constraints) { if (!constraint.IsSatisfied(worldForTest)) { // Cleaning worldForTest = null; GC.Collect(); // Return result return(false); } } // Cleaning worldForTest = null; GC.Collect(); // Return result return(true); }
public bool CyclesControl(WorldDynamic currentState, PlanAction action, StoryGraph currentGraph, KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, StoryNode currentNode, bool duplicated, int globalNodeNumber, bool succsessControl) { bool result = false; // We create a test node similar to the one we are going to add to the graph as a result of the current action. StoryNode testNode = currentGraph.CreateTestNode(currentState, action, agent, currentNode, !duplicated, globalNodeNumber, succsessControl); StoryNode duplicatedNode = null; Edge testEdge = new Edge(); if (!duplicated) { duplicatedNode = currentGraph.GetNode(testNode); if (currentNode.Equals(duplicatedNode)) { return(false); } testEdge.SetUpperNode(ref currentNode); testEdge.SetLowerNode(ref duplicatedNode); currentNode.AddEdge(testEdge); duplicatedNode.AddEdge(testEdge); currentNode.AddLinkToNode(ref duplicatedNode); duplicatedNode.AddLinkToNode(ref currentNode); } string[] colors = new string[currentGraph.GetNodes().Count + 2]; for (int i = 0; i < currentGraph.GetNodes().Count + 2; i++) { colors[i] = "white"; } result = TarjanAlgStep(currentGraph.GetRoot(), ref colors, !duplicated, duplicatedNode); if (!duplicated) { currentNode.RemoveEdge(testEdge); currentNode.DeleteLink(duplicatedNode); duplicatedNode.RemoveEdge(testEdge); duplicatedNode.DeleteLink(currentNode); testEdge.ClearUpperNode(); testEdge.ClearLowerNode(); testEdge = null; } // We delete the test node and mark the loop test as passed. currentGraph.DeleteTestNode(ref testNode); return(result); }
/// <summary> /// Create a new node for the story graph and inserts it. /// </summary> public void CreateNewNode(PlanAction action, KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, WorldDynamic currentState, StoryNode currentNode, ref int globalNodeNumber, bool succsessControl, bool counteract) { WorldDynamic newState = (WorldDynamic)currentState.Clone(); if (!succsessControl) { action.Fail(ref newState); } else { action.ApplyEffects(ref newState); } newState.UpdateHashCode(); // Create an empty new node. StoryNode newNode = new StoryNode(); if (counteract) { newNode.counteract = true; } // We assign the state of the world (transferred) to the new node. newNode.SetWorldState((WorldDynamic)newState.Clone()); newNode.SetActiveAgent(newNode.GetWorldState().GetAgentByName(agent.Key.GetName())); if (agent.Key.GetRole() == AgentRole.PLAYER) { newNode.SetActivePlayer(true); } else { newNode.SetActivePlayer(false); } ConnectionTwoNodes(action, currentNode, newNode, false); globalNodeNumber++; newNode.SetNumberInSequence(globalNodeNumber); if (nodes.Contains(newNode)) { bool test = true; } // Add a new node to the graph. AddNode(newNode); }
public StoryNode CreateTestNode(WorldDynamic currentState, PlanAction action, KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, StoryNode currentNode, bool connection, int globalNodeNumber, bool succsessControl) { WorldDynamic worldForTest = (WorldDynamic)currentState.Clone(); if (!succsessControl) { action.Fail(ref worldForTest); } else { action.ApplyEffects(ref worldForTest); } worldForTest.UpdateHashCode(); StoryNode testNode = new StoryNode(); //if (counteract) { testNode.counteract = true; } //testNode.SetWorldState(worldForTest); testNode.SetWorldState((WorldDynamic)worldForTest.Clone()); // Create a clone of the agent. //KeyValuePair<AgentStateStatic, AgentStateDynamic> newAgent = // new KeyValuePair<AgentStateStatic, AgentStateDynamic>((AgentStateStatic)agent.Key.Clone(), (AgentStateDynamic)agent.Value.Clone()); testNode.SetActiveAgent(testNode.GetWorldState().GetAgentByName(agent.Key.GetName())); // We take the last node from the list of all nodes and assign whether the player is active and which of the agents was active on this turn. if (agent.Key.GetRole() == AgentRole.PLAYER) { testNode.SetActivePlayer(true); } else { testNode.SetActivePlayer(false); } //testNode.SetActiveAgent(newAgent); /*if (connection) * { * ConnectionTwoNodes(action, currentNode, testNode, false); * }*/ testNode.SetNumberInSequence(globalNodeNumber + 1); return(testNode); }
/// <summary> /// Checking the action for violation of the established constraints and the reachability of the goal state (control of cycles and deadends). /// </summary> public void ActionControl(PlanAction action, StoryGraph currentGraph, KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, WorldDynamic currentState, StoryNode currentNode, bool root, ref int globalNodeNumber, ref Queue <StoryNode> queue) { bool succsessControl = ProbabilityCalculating(action); action.success = succsessControl; action.fail = !succsessControl; bool constraintsControl = ConstraintsControl(currentState, action, succsessControl); bool deadEndsControl = DeadEndsControl(action, currentState, agent, succsessControl); bool duplicateControl = DuplicateControl(currentState, action, currentGraph, agent, currentNode, globalNodeNumber, succsessControl); //bool cyclesControl = CyclesControl(currentState, action, currentGraph, agent, currentNode, duplicateControl, globalNodeNumber, succsessControl); bool cyclesControl = true; if (constraintsControl && deadEndsControl && cyclesControl && duplicateControl) { // If all checks are passed, then we apply the action. ApplyAction(action, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, succsessControl, false); } else if (!constraintsControl && deadEndsControl && cyclesControl && duplicateControl) { // If the action violates the constraints, then convergence will not apply it, but will apply its counter-reaction. ActionCounteract(action, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue); } else if (!duplicateControl && cyclesControl) { bool skip = false; // connection current node --> finded node currentGraph.DuplicateNodeConnecting(currentState, action, agent, currentNode, globalNodeNumber, ref queue, succsessControl, ref skip); if (skip) { //NothingToDo newAction = new NothingToDo(); //newAction.Arguments.Add(agent); //ApplyAction(newAction, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, succsessControl, true); ActionCounteract(action, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue); } } else { ActionCounteract(action, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue); } }
public void SingleAVandAC(ref PlanAction receivedAction, WorldDynamic currentState, KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, CSP_Module cspModule, StoryGraph currentGraph, StoryNode currentNode, bool root, ref int globalNodeNumber, ref Queue <StoryNode> queue) { cspModule.AssignVariables(ref receivedAction, currentState, agent); ActionControl(receivedAction, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue); // Cleaning currentNode = null; GC.Collect(); }
public bool DeadEndsControl(PlanAction action, WorldDynamic currentState, KeyValuePair <AgentStateStatic, AgentStateDynamic> player, bool succsessControl) { if (player.Key.GetRole() == AgentRole.PLAYER) { WorldDynamic worldForTest = (WorldDynamic)currentState.Clone(); if (!succsessControl) { action.Fail(ref worldForTest); } else { action.ApplyEffects(ref worldForTest); } worldForTest.GetAgentByRole(AgentRole.PLAYER).Value.CalculatePlan(worldForTest.GetAgentByRole(AgentRole.PLAYER), worldForTest); if (worldForTest.GetAgentByRole(AgentRole.PLAYER).Value.GetPlanStatus()) { // Cleaning worldForTest = null; GC.Collect(); // Return result return(true); } else { // Cleaning worldForTest = null; GC.Collect(); // Return result return(false); } } else { return(true); } }
/// <summary> /// The probability of success of the action is calculated, and if successful, it is applied. /// </summary> public void ApplyAction(PlanAction action, StoryGraph currentGraph, KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, WorldDynamic currentState, StoryNode currentNode, bool root, ref int globalNodeNumber, bool succsessControl, bool counteract) { // We apply a successful/unsuccessful option to perform an action. if (root) { currentGraph.CreateRootNode(action, agent, currentState, currentNode, ref globalNodeNumber, succsessControl); } else { currentGraph.CreateNewNode(action, agent, currentState, currentNode, ref globalNodeNumber, succsessControl, counteract); } }
/// <summary> /// /// </summary> /// <param name="firstNode">Current node</param> /// <param name="secondNode">New node</param> public void ConnectionTwoNodes(PlanAction action, StoryNode firstNode, StoryNode secondNode, bool duplicate) { Edge newEdge = new Edge(); newEdge.SetAction(action); newEdge.SetUpperNode(ref firstNode); newEdge.SetLowerNode(ref secondNode); firstNode.AddEdge(newEdge); secondNode.AddEdge(newEdge); firstNode.AddLinkToNode(ref secondNode); secondNode.AddLinkToNode(ref firstNode); if (firstNode.GetEdges().Count != firstNode.GetLinks().Count) { bool test = true; } }
public void CreateRootNode(PlanAction action, KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, WorldDynamic currentState, StoryNode currentNode, ref int globalNodeNumber, bool succsessControl) { WorldDynamic newState = (WorldDynamic)currentState.Clone(); if (!succsessControl) { action.Fail(ref newState); } else { action.ApplyEffects(ref newState); } if (agent.Key.GetRole() == AgentRole.PLAYER) { currentNode.SetActivePlayer(true); } else { currentNode.SetActivePlayer(false); } // We assign the state of the world (transferred) to the new node. currentNode.SetWorldState((WorldDynamic)newState.Clone()); //Edge newEdge = new Edge(); // We adjust the edge - assign its action and indicate the nodes that it connects. //newEdge.SetAction(action); //newEdge.SetUpperNode(ref currentNode); //currentNode.AddEdge(newEdge); globalNodeNumber++; currentNode.SetNumberInSequence(globalNodeNumber); }
public List<PlanAction> MassiveAssignVariables(ref PlanAction action, WorldDynamic currentState, KeyValuePair<AgentStateStatic, AgentStateDynamic> initiator) { List<PlanAction> actions = new List<PlanAction>(); if (action is Move) { int locationsCount = currentState.GetLocationByName(currentState.SearchAgentAmongLocations(initiator.Key).GetName()).Key.GetConnectedLocations().Count; List<Move> moveArr = new List<Move>(); for (int i = 0; i < locationsCount; i++) { Move move = new Move(); moveArr.Add(move); } for (int i = 0; i < locationsCount; i++) { moveArr[i].Arguments.Add(initiator); moveArr[i].Arguments.Add(currentState.GetLocationByName(currentState.SearchAgentAmongLocations(initiator.Key).GetName())); moveArr[i].Arguments.Add(currentState.GetLocationByName (currentState.GetLocationByName( currentState.SearchAgentAmongLocations(initiator.Key).GetName()).Key.GetConnectedLocationsFromIndex(i).GetName())); } foreach (var a in moveArr) { actions.Add(a); } } return actions; }
public bool AssignVariables(ref PlanAction action, WorldDynamic currentState, KeyValuePair<AgentStateStatic, AgentStateDynamic> initiator) { if (action is Entrap || action is CounterEntrap) { foreach (var agent in currentState.GetAgents()) { if ((agent.Key.GetRole() == AgentRole.USUAL || agent.Key.GetRole() == AgentRole.PLAYER) && agent.Value.GetStatus() && !currentState.GetLocation(currentState.SearchAgentAmongLocations(agent.Key)).Value.SearchAgent(initiator.Key) && !agent.Equals(initiator)) { action.Arguments.Add(agent); action.Arguments.Add(initiator); action.Arguments.Add(currentState.GetLocationByName(currentState.SearchAgentAmongLocations(initiator.Key).GetName())); return true; } } return false; } else if (action is Fight || action is CounterFight) { foreach (var agent in currentState.GetAgents()) { if ((agent.Key.GetRole() == AgentRole.USUAL || agent.Key.GetRole() == AgentRole.PLAYER) && agent.Value.GetStatus() && currentState.GetLocation(currentState.SearchAgentAmongLocations(initiator.Key)).Value.SearchAgent(agent.Key)) { action.Arguments.Add(initiator); action.Arguments.Add(agent); action.Arguments.Add(currentState.GetLocation(currentState.SearchAgentAmongLocations(initiator.Key))); return true; } } return false; } else if (action is InvestigateRoom || action is CounterInvestigateRoom) { foreach (var killer in currentState.GetAgents()) { if (killer.Key.GetRole() == AgentRole.KILLER && killer.Value.GetStatus()) { action.Arguments.Add(initiator); action.Arguments.Add(killer); action.Arguments.Add(currentState.GetLocationByName(currentState.SearchAgentAmongLocations(initiator.Key).GetName())); return true; } } return false; } else if (action is Kill || action is CounterKill) { foreach (var agent in currentState.GetAgents()) { if ((agent.Key.GetRole() == AgentRole.USUAL || agent.Key.GetRole() == AgentRole.PLAYER) && agent.Value.GetStatus() && currentState.GetLocation(currentState.SearchAgentAmongLocations(initiator.Key)).Value.SearchAgent(agent.Key)) { action.Arguments.Add(agent); action.Arguments.Add(initiator); action.Arguments.Add(currentState.GetLocation(currentState.SearchAgentAmongLocations(initiator.Key))); return true; } } return false; } else if (action is Move || action is CounterMove) { if (action.Arguments.Count() != 0) { List<string> arguments = new List<string>(); foreach (var argument in action.Arguments) { arguments.Add((string)argument); } action.Arguments.Clear(); action.Arguments.Add(initiator); action.Arguments.Add(currentState.GetLocationByName(arguments[1])); action.Arguments.Add(currentState.GetLocationByName(arguments[2])); return true; } else { action.Arguments.Add(initiator); action.Arguments.Add(currentState.GetLocationByName(currentState.SearchAgentAmongLocations(initiator.Key).GetName())); if (initiator.Value.GetTargetLocation() != null && initiator.Key.GetRole() != AgentRole.PLAYER && currentState.SearchAgentAmongLocations(initiator.Key).ConnectionChecking(initiator.Value.GetTargetLocation())) { action.Arguments.Add(currentState.GetLocationByName(initiator.Value.GetTargetLocation().GetName())); return true; } else { KeyValuePair<LocationStatic, LocationDynamic> randLoc = currentState. GetRandomConnectedLocation(currentState.GetLocationByName(currentState.SearchAgentAmongLocations(initiator.Key).GetName())); if (currentState.GetLocationByName(currentState.SearchAgentAmongLocations(initiator.Key).GetName()). Key.ConnectionChecking(randLoc.Key)) { action.Arguments.Add(randLoc); return true; } } } return false; } else if (action is NeutralizeKiller || action is CounterNeutralizeKiller) { foreach (var killer in currentState.GetAgents()) { if (killer.Key.GetRole() == AgentRole.KILLER && killer.Value.GetStatus()) { action.Arguments.Add(initiator); action.Arguments.Add(killer); action.Arguments.Add(currentState.GetLocation(currentState.SearchAgentAmongLocations(initiator.Key))); return true; } } return false; } else if (action is Reassure || action is CounterReassure) { foreach (var agent in currentState.GetAgents()) { if (agent.Key.GetRole() == AgentRole.USUAL && agent.Value.GetStatus() && currentState.GetLocation(currentState.SearchAgentAmongLocations(initiator.Key)).Value.SearchAgent(agent.Key) && !agent.Key.Equals(initiator.Key) && agent.Value.AngryCheck()) { action.Arguments.Add(agent); action.Arguments.Add(initiator); action.Arguments.Add(currentState.GetAgentByName(agent.Value.GetObjectOfAngry().GetObjectOfAngry().GetName())); break; } } foreach (var killer in currentState.GetAgents()) { if (killer.Key.GetRole() == AgentRole.KILLER && killer.Value.GetStatus()) { action.Arguments.Add(killer); break; } } action.Arguments.Add(currentState.GetLocation(currentState.SearchAgentAmongLocations(initiator.Key))); return true; } else if (action is Run || action is CounterRun) { action.Arguments.Add(initiator); action.Arguments.Add(currentState.GetLocation(currentState.SearchAgentAmongLocations(initiator.Key))); action.Arguments.Add(currentState. GetRandomLocationWithout(currentState.GetLocationByName(currentState.SearchAgentAmongLocations(initiator.Key).GetName()))); return true; } else if (action is NothingToDo) { action.Arguments.Add(initiator); } else if (action is TellAboutASuspicious || action is CounterTellAboutASuspicious) { foreach (var agent in currentState.GetAgents()) { if (agent.Key.GetRole() == AgentRole.USUAL && agent.Value.GetStatus() && currentState.GetLocation(currentState.SearchAgentAmongLocations(initiator.Key)).Value.SearchAgent(agent.Key)) { action.Arguments.Add(agent); break; } } action.Arguments.Add(initiator); action.Arguments.Add(currentState.GetLocation(currentState.SearchAgentAmongLocations(initiator.Key))); action.Arguments.Add(currentState.GetRandomLocationWithout (currentState.GetLocationByName(currentState.SearchAgentAmongLocations(initiator.Key).GetName()))); return true; } else if (action is Talk || action is CounterTalk) { action.Arguments.Add(initiator); foreach (var agent in currentState.GetAgents()) { if (agent.Value.GetStatus() && currentState.GetLocation(currentState.SearchAgentAmongLocations(initiator.Key)).Value.SearchAgent(agent.Key) && agent.Key.GetName() != initiator.Key.GetName()) { action.Arguments.Add(agent); return true; } } return false; } return false; }
/// <summary> /// The agent updates his beliefs, calculates a plan, chooses an action, assigns variables to it, and sends it for further control. /// </summary> public void ActionRequest(KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, ref StoryGraph currentGraph, ref WorldDynamic currentState, StoryNode currentNode, bool root, ref int globalNodeNumber, ref Queue <StoryNode> queue) { CSP_Module cspModule = new CSP_Module(); if (agent.Key.GetRole().Equals(AgentRole.PLAYER)) { agent.Value.RefreshBeliefsAboutTheWorld(currentState, agent); agent.Value.GenerateNewPDDLProblem(agent, currentState); agent.Value.ReceiveAvailableActions(agent); List <PlanAction> receivedActions = agent.Value.GetAvailableActions(); for (int i = 0; i < receivedActions.Count; i++) { PlanAction receivedAction = receivedActions[i]; if (receivedAction != null) { switch (receivedAction.GetType().ToString().Remove(0, 20)) { case "Move": MultiAVandAC(ref receivedAction, currentState, agent, cspModule, currentGraph, currentNode, root, ref globalNodeNumber, ref queue); break; case "Fight": // Not relevant yet break; case "InvestigateRoom": SingleAVandAC(ref receivedAction, currentState, agent, cspModule, currentGraph, currentNode, root, ref globalNodeNumber, ref queue); break; case "NeutralizeKiller": // Not relevant yet break; case "NothingToDo": SkipTurn(currentState); break; case "Reassure": // Not relevant yet break; case "Run": // Not relevant yet break; case "Talk": // Not relevant yet break; } // Cleaning receivedAction = null; GC.Collect(); } } // Cleaning receivedActions = null; GC.Collect(); } else { agent.Value.RefreshBeliefsAboutTheWorld(currentState, agent); agent.Value.GenerateNewPDDLProblem(agent, currentState); agent.Value.CalculatePlan(agent, currentState); agent.Value.ReceiveAvailableActions(agent); PlanAction receivedAction = agent.Value.ChooseAction(); if (receivedAction != null) { cspModule.AssignVariables(ref receivedAction, currentState, agent); ActionControl(receivedAction, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue); // Cleaning receivedAction = null; currentNode = null; GC.Collect(); } else { SkipTurn(currentState); } } }
public void ActionCounteract(PlanAction action, StoryGraph currentGraph, KeyValuePair <AgentStateStatic, AgentStateDynamic> agent, WorldDynamic currentState, StoryNode currentNode, bool root, ref int globalNodeNumber, ref Queue <StoryNode> queue) { CSP_Module cspModule = new CSP_Module(); bool stageOne_NewNode = true; bool stageTwo_ConnectedNode = false; bool counterreactionFound = false; bool skip = false; string currentAction = action.GetType().ToString().Remove(0, 20); while (!counterreactionFound) { PlanAction counterreactionTalk = new CounterTalk(); bool assignVariables = cspModule.AssignVariables(ref counterreactionTalk, currentState, agent); counterreactionTalk.Arguments.Add(currentAction); if (assignVariables && counterreactionTalk.CheckPreconditions(currentState)) { bool constractionAndDeadEndAndCicle = false; bool duplicate = false; CounterreactionControl(counterreactionTalk, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue, ref constractionAndDeadEndAndCicle, ref duplicate); if (stageOne_NewNode) { if (constractionAndDeadEndAndCicle && duplicate) { ApplyAction(counterreactionTalk, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, true, true); counterreactionFound = true; } } else if (stageTwo_ConnectedNode) { if (constractionAndDeadEndAndCicle && !duplicate) { currentGraph.DuplicateNodeConnecting(currentState, counterreactionTalk, agent, currentNode, globalNodeNumber, ref queue, true, ref skip); counterreactionFound = true; } } } if (!counterreactionFound) { PlanAction counterreactionEntrap = new CounterEntrap(); assignVariables = cspModule.AssignVariables(ref counterreactionEntrap, currentState, agent); counterreactionEntrap.Arguments.Add(currentAction); if (assignVariables && counterreactionEntrap.CheckPreconditions(currentState)) { bool constractionAndDeadEndAndCicle = false; bool duplicate = false; CounterreactionControl(counterreactionEntrap, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue, ref constractionAndDeadEndAndCicle, ref duplicate); if (stageOne_NewNode) { if (constractionAndDeadEndAndCicle && duplicate) { ApplyAction(counterreactionEntrap, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, true, true); counterreactionFound = true; } } else if (stageTwo_ConnectedNode) { if (constractionAndDeadEndAndCicle && !duplicate) { currentGraph.DuplicateNodeConnecting(currentState, counterreactionEntrap, agent, currentNode, globalNodeNumber, ref queue, true, ref skip); counterreactionFound = true; } } } } if (!counterreactionFound) { PlanAction counterreactionKill = new CounterKill(); assignVariables = cspModule.AssignVariables(ref counterreactionKill, currentState, agent); counterreactionKill.Arguments.Add(currentAction); if (assignVariables && counterreactionKill.CheckPreconditions(currentState)) { bool constractionAndDeadEndAndCicle = false; bool duplicate = false; CounterreactionControl(counterreactionKill, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue, ref constractionAndDeadEndAndCicle, ref duplicate); if (stageOne_NewNode) { if (constractionAndDeadEndAndCicle && duplicate) { ApplyAction(counterreactionKill, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, true, true); counterreactionFound = true; } } else if (stageTwo_ConnectedNode) { if (constractionAndDeadEndAndCicle && !duplicate) { currentGraph.DuplicateNodeConnecting(currentState, counterreactionKill, agent, currentNode, globalNodeNumber, ref queue, true, ref skip); counterreactionFound = true; } } } } if (!counterreactionFound) { PlanAction counterreactionIR = new InvestigateRoom(); assignVariables = cspModule.AssignVariables(ref counterreactionIR, currentState, agent); counterreactionIR.Arguments.Add(currentAction); if (assignVariables && counterreactionIR.CheckPreconditions(currentState)) { bool constractionAndDeadEndAndCicle = false; bool duplicate = false; CounterreactionControl(counterreactionIR, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue, ref constractionAndDeadEndAndCicle, ref duplicate); if (stageOne_NewNode) { if (constractionAndDeadEndAndCicle && duplicate) { ApplyAction(counterreactionIR, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, true, true); counterreactionFound = true; } } else if (stageTwo_ConnectedNode) { if (constractionAndDeadEndAndCicle && !duplicate) { currentGraph.DuplicateNodeConnecting(currentState, counterreactionIR, agent, currentNode, globalNodeNumber, ref queue, true, ref skip); counterreactionFound = true; } } } } if (!counterreactionFound) { PlanAction counterreactionNK = new CounterNeutralizeKiller(); assignVariables = cspModule.AssignVariables(ref counterreactionNK, currentState, agent); counterreactionNK.Arguments.Add(currentAction); if (assignVariables && counterreactionNK.CheckPreconditions(currentState)) { bool constractionAndDeadEndAndCicle = false; bool duplicate = false; CounterreactionControl(counterreactionNK, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue, ref constractionAndDeadEndAndCicle, ref duplicate); if (stageOne_NewNode) { if (constractionAndDeadEndAndCicle && duplicate) { ApplyAction(counterreactionNK, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, true, true); counterreactionFound = true; } } else if (stageTwo_ConnectedNode) { if (constractionAndDeadEndAndCicle && !duplicate) { currentGraph.DuplicateNodeConnecting(currentState, counterreactionNK, agent, currentNode, globalNodeNumber, ref queue, true, ref skip); counterreactionFound = true; } } } } if (!counterreactionFound) { PlanAction counterreactionTalkAboutSuspicious = new CounterTellAboutASuspicious(); assignVariables = cspModule.AssignVariables(ref counterreactionTalkAboutSuspicious, currentState, agent); counterreactionTalkAboutSuspicious.Arguments.Add(currentAction); if (assignVariables && counterreactionTalkAboutSuspicious.CheckPreconditions(currentState)) { bool constractionAndDeadEndAndCicle = false; bool duplicate = false; CounterreactionControl(counterreactionTalkAboutSuspicious, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue, ref constractionAndDeadEndAndCicle, ref duplicate); if (stageOne_NewNode) { if (constractionAndDeadEndAndCicle && duplicate) { ApplyAction(counterreactionTalkAboutSuspicious, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, true, true); counterreactionFound = true; } } else if (stageTwo_ConnectedNode) { if (constractionAndDeadEndAndCicle && !duplicate) { currentGraph.DuplicateNodeConnecting(currentState, counterreactionTalkAboutSuspicious, agent, currentNode, globalNodeNumber, ref queue, true, ref skip); counterreactionFound = true; } } } } if (!counterreactionFound) { PlanAction counterreactionFight = new CounterFight(); assignVariables = cspModule.AssignVariables(ref counterreactionFight, currentState, agent); counterreactionFight.Arguments.Add(currentAction); if (assignVariables && counterreactionFight.CheckPreconditions(currentState)) { bool constractionAndDeadEndAndCicle = false; bool duplicate = false; CounterreactionControl(counterreactionFight, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue, ref constractionAndDeadEndAndCicle, ref duplicate); if (stageOne_NewNode) { if (constractionAndDeadEndAndCicle && duplicate) { ApplyAction(counterreactionFight, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, true, true); counterreactionFound = true; } } else if (stageTwo_ConnectedNode) { if (constractionAndDeadEndAndCicle && !duplicate) { currentGraph.DuplicateNodeConnecting(currentState, counterreactionFight, agent, currentNode, globalNodeNumber, ref queue, true, ref skip); counterreactionFound = true; } } } } if (!counterreactionFound) { PlanAction counterreactionReassure = new CounterReassure(); assignVariables = cspModule.AssignVariables(ref counterreactionReassure, currentState, agent); counterreactionReassure.Arguments.Add(currentAction); if (assignVariables && counterreactionReassure.CheckPreconditions(currentState)) { bool constractionAndDeadEndAndCicle = false; bool duplicate = false; CounterreactionControl(counterreactionReassure, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue, ref constractionAndDeadEndAndCicle, ref duplicate); if (stageOne_NewNode) { if (constractionAndDeadEndAndCicle && duplicate) { ApplyAction(counterreactionReassure, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, true, true); counterreactionFound = true; } } else if (stageTwo_ConnectedNode) { if (constractionAndDeadEndAndCicle && !duplicate) { currentGraph.DuplicateNodeConnecting(currentState, counterreactionReassure, agent, currentNode, globalNodeNumber, ref queue, true, ref skip); counterreactionFound = true; } } } } if (!counterreactionFound) { PlanAction counterreactionRun = new CounterRun(); assignVariables = cspModule.AssignVariables(ref counterreactionRun, currentState, agent); counterreactionRun.Arguments.Add(currentAction); if (assignVariables && counterreactionRun.CheckPreconditions(currentState)) { bool constractionAndDeadEndAndCicle = false; bool duplicate = false; CounterreactionControl(counterreactionRun, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue, ref constractionAndDeadEndAndCicle, ref duplicate); if (stageOne_NewNode) { if (constractionAndDeadEndAndCicle && duplicate) { ApplyAction(counterreactionRun, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, true, true); counterreactionFound = true; } } else if (stageTwo_ConnectedNode) { if (constractionAndDeadEndAndCicle && !duplicate) { currentGraph.DuplicateNodeConnecting(currentState, counterreactionRun, agent, currentNode, globalNodeNumber, ref queue, true, ref skip); counterreactionFound = true; } } } } if (!counterreactionFound) { PlanAction counterreactionMove = new CounterMove(); assignVariables = cspModule.AssignVariables(ref counterreactionMove, currentState, agent); counterreactionMove.Arguments.Add(currentAction); if (assignVariables && counterreactionMove.CheckPreconditions(currentState)) { bool constractionAndDeadEndAndCicle = false; bool duplicate = false; CounterreactionControl(counterreactionMove, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue, ref constractionAndDeadEndAndCicle, ref duplicate); if (stageOne_NewNode) { if (constractionAndDeadEndAndCicle && duplicate) { ApplyAction(counterreactionMove, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, true, true); counterreactionFound = true; } } else if (stageTwo_ConnectedNode) { if (constractionAndDeadEndAndCicle && !duplicate) { currentGraph.DuplicateNodeConnecting(currentState, counterreactionMove, agent, currentNode, globalNodeNumber, ref queue, true, ref skip); counterreactionFound = true; } } } } if (stageTwo_ConnectedNode) { PlanAction counterreactionSkip = new NothingToDo(); counterreactionSkip.Arguments.Add(agent); bool constractionAndDeadEndAndCicle = false; bool duplicate = false; CounterreactionControl(counterreactionSkip, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, ref queue, ref constractionAndDeadEndAndCicle, ref duplicate); if (constractionAndDeadEndAndCicle && duplicate) { ApplyAction(counterreactionSkip, currentGraph, agent, currentState, currentNode, root, ref globalNodeNumber, true, true); counterreactionFound = true; } else if (constractionAndDeadEndAndCicle && !duplicate) { currentGraph.DuplicateNodeConnecting(currentState, counterreactionSkip, agent, currentNode, globalNodeNumber, ref queue, true, ref skip); counterreactionFound = true; } } //stageOne_NewNode = false; //stageTwo_ConnectedNode = true; if (stageOne_NewNode) { stageOne_NewNode = false; stageTwo_ConnectedNode = true; } else if (stageTwo_ConnectedNode) { stageOne_NewNode = true; stageTwo_ConnectedNode = false; } } }
public void ClearAction() { action = null; }
public void SetAction(PlanAction action) { this.action = action; }
/// <summary> /// Calculation of the probability of success of the action. /// </summary> public bool ProbabilityCalculating(PlanAction action) { Random random = new Random(); int probability = random.Next(0, 100); int threshold = 0; if (action is Entrap) { threshold = 80; } else if (action is CounterEntrap) { threshold = 100; } else if (action is Fight) { threshold = 75; } else if (action is CounterFight) { threshold = 100; } else if (action is InvestigateRoom || action is CounterInvestigateRoom) { threshold = 60; } else if (action is Kill || action is CounterKill) { threshold = 100; } else if (action is Move || action is CounterMove) { threshold = 100; } else if (action is NeutralizeKiller || action is CounterNeutralizeKiller) { threshold = 100; } else if (action is NothingToDo) { threshold = 100; } else if (action is Reassure) { threshold = 80; } else if (action is CounterReassure) { threshold = 100; } else if (action is Run || action is CounterRun) { threshold = 100; } else if (action is TellAboutASuspicious) { threshold = 80; } else if (action is CounterTellAboutASuspicious) { threshold = 100; } else if (action is Talk || action is CounterTalk) { threshold = 100; } if (probability <= threshold) { return(true); } else { return(false); } }