public void Test_EA_AppraiseEvent()
{
var asset = BuildTestAsset();
asset.AddOrUpdateAppraisalRule(new AppraisalRuleDTO()
{
EventMatchingTemplate = (Name)"Event(Action-End,*,*,*)",
Conditions = new Conditions.DTOs.ConditionSetDTO(),
AppraisalVariables = new AppraisalVariables(new List <AppraisalVariableDTO>()
{
new AppraisalVariableDTO()
{
Name = OCCAppraisalVariables.PRAISEWORTHINESS,
Value = (Name)"5"
}
})
});
var m_kb = new KB((Name)"Matt");
asset.AppraiseEvents(new List <Name>()
{
EventHelper.ActionEnd("Matt", "Speak(Start,S1,-,-)", "Sarah")
},
new ConcreteEmotionalState(),
new AM(), m_kb, null);
Assert.IsNotNull(asset.DefaultEmotionDisposition);
}
private void PerceiveActionEnd(RolePlayCharacterAsset rpc)
{
var e = EventHelper.ActionEnd(Subject, Name, Value);
Debug.WriteLine(e.ToString());
rpc.Perceive(e);
}
private void HandleSpeakAction(Guid id, string subject, string target)
{
var d = iat.GetDialogActionById(id);
var dAct = string.Format("Speak({0},{1},{2},{3})", d.CurrentState, d.NextState, d.Meaning, d.Style);
agent1RPC.Perceive(EventHelper.ActionEnd(subject, dAct, target));
playerRPC.Perceive(EventHelper.ActionEnd(subject, dAct, target));
var dStatePropertyAgent = string.Format(IATConsts.DIALOGUE_STATE_PROPERTY, IATConsts.PLAYER);
var dStatePropertyPlayer = string.Format(IATConsts.DIALOGUE_STATE_PROPERTY, agent1RPC.CharacterName.ToString());
agent1RPC.Perceive(EventHelper.PropertyChange(dStatePropertyAgent, d.NextState, subject));
playerRPC.Perceive(EventHelper.PropertyChange(dStatePropertyPlayer, d.NextState, subject));
agent1RPC.Perceive(EventHelper.PropertyChange("Has(Floor)", target, subject));
playerRPC.Perceive(EventHelper.PropertyChange("Has(Floor)", target, subject));
if (SaveLog)
{
this.SaveState();
}
playerDialogues = DeterminePlayerDialogues();
UpdatePlayerDialogOptions(true);
}
void Reply(System.Guid id, Name initiator, Name target)
{
Debug.Log("We are replying" + initiator + " and " + target);
// Retrieving the chosen dialog object
var dialog = _iat.GetDialogActionById(id);
// Playing the audio of the dialogue line
this.StartCoroutine(Speak(id, initiator, target));
//Writing the dialog on the canvas
GameObject.Find("DialogueText").GetComponent <Text>().text =
initiator + ": " + dialog.Utterance;
// Getting the full action Name
var actualActionName = "Speak(" + dialog.CurrentState + ", " + dialog.NextState + ", " + dialog.Meaning +
", " + dialog.Meaning + ")";
//So we can generate its event
var eventName = EventHelper.ActionEnd(initiator, (Name)actualActionName, target);
ClearAllDialogButtons();
//Inform each participating agent of what happened
_rpcList.Find(x => x.CharacterName == initiator).Perceive(eventName);
_rpcList.Find(x => x.CharacterName == target).Perceive(eventName);
//Handle the consequences of their actions
HandleEffects(eventName);
}
private void PlayerReplyAction(string replyActionName, string nextState)
{
var events = new List <Name>();
events.Add(EventHelper.ActionEnd(IATConsts.PLAYER, replyActionName, _agentController.RPC.CharacterName.ToString()));
var effects = _wm.Simulate(events);
foreach (var eff in effects)
{
var ef = eff.ToPropertyChangeEvent();
if (eff.ObserverAgent == _agentController.RPC.CharacterName)
{
_agentController.AddEvent(ef);
}
else if (eff.ObserverAgent == Player.CharacterName)
{
Player.Perceive(ef);
}
else
{
_agentController.AddEvent(ef);
Player.Perceive(ef);
}
}
_agentController.canSpeak = true;
waitingForReply = true;
}
private void AddEffects(WorldModelAsset wm)
{
var a1 = EventHelper.ActionEnd("John", "Speak([x],[y],*,*)", "Sarah");
var a2 = EventHelper.ActionEnd("John", "Shoot", "Sarah");
var a3 = (Name)"Event(Action-End , [s], *, John)";
var a4 = (Name)"Event(Action-End , [s], Surf, [t])";
wm.addActionTemplate(a1, 1);
wm.addActionTemplate(a2, 1);
wm.addActionTemplate(a3, 1);
wm.addActionTemplate(a4, 1);
wm.AddActionEffect(a1, new EffectDTO()
{
PropertyName = (Name)"Has(Floor)", NewValue = (Name)"Player"
});
wm.AddActionEffect(a2, new EffectDTO()
{
PropertyName = (Name)"DialogueState(Player)", NewValue = (Name)"Start"
});
wm.AddActionEffect(a3, new EffectDTO()
{
PropertyName = (Name)"Has(Floor)", NewValue = (Name)"False"
});
wm.AddActionEffect(a4, new EffectDTO()
{
PropertyName = (Name)"DialogueState([t])", NewValue = (Name)"[s]"
});
}
private IEnumerator PlayerReplyAction(string replyActionName, Name target)
{
HandleEffects(new List <Name> {
EventHelper.ActionEnd(_player.CharacterName.ToString(), replyActionName, target.ToString())
});
yield return(new WaitForSeconds(0.5f));
}
private static string HandleActionsRequest(APIRequest req, ServerState serverState)
{
if (req.Method != HTTPMethod.POST)
{
return(JsonConvert.SerializeObject("Error: Invalid operation"));
}
IEnumerable <EffectDTO> eventEffects = null;
var scenario = serverState.Scenarios[req.ScenarioName][req.ScenarioInstance];
if (!string.IsNullOrEmpty(req.RequestBody))
{
Name ev = null;
try
{
var requests = JsonConvert.DeserializeObject <ExecuteRequestDTO[]>(req.RequestBody);
foreach (var a in requests)
{
ev = EventHelper.ActionEnd(a.Subject, a.Action, a.Target);
foreach (var rpc in scenario.Characters)
{
rpc.Perceive(ev);
}
if (scenario.WorldModel != null)
{
eventEffects = scenario.WorldModel.Simulate(new[] { ev });
foreach (var eff in eventEffects)
{
if (eff.ObserverAgent == WellFormedNames.Name.UNIVERSAL_SYMBOL)
{
foreach (var rpc in scenario.Characters)
{
rpc.Perceive(EventHelper.PropertyChange(eff.PropertyName, eff.NewValue, (Name)a.Subject));
}
}
else
{
var obs = scenario.Characters.Where(r => r.CharacterName == eff.ObserverAgent).FirstOrDefault();
{
obs?.Perceive(EventHelper.PropertyChange(eff.PropertyName, eff.NewValue, (Name)a.Subject));
}
}
}
}
}
return(JsonConvert.SerializeObject((string.Format("{0} actions(s) executed and {1} effects triggered", requests.Count(), eventEffects?.Count()))));
}
catch (Exception ex)
{
return(JsonConvert.SerializeObject(String.Format(APIErrors.ERROR_EXCEPTION_PERCEIVE, ev, ex.Message)));
}
}
else
{
return(JsonConvert.SerializeObject(APIErrors.ERROR_EMPTY_ACTION_REQUEST_LIST));
}
}
private IEnumerator PlayerReplyAction(string replyActionName, string nextState)
{
const float WAIT_TIME = 0.5f;
_agentController.RPC.Perceive(EventHelper.ActionStart(IATConsts.PLAYER, replyActionName, _agentController.RPC.CharacterName.ToString()));
yield return(new WaitForSeconds(WAIT_TIME));
_agentController.RPC.Perceive(EventHelper.ActionEnd(IATConsts.PLAYER, replyActionName, _agentController.RPC.CharacterName.ToString()));
_agentController.RPC.Perceive(EventHelper.PropertyChange(string.Format(IATConsts.DIALOGUE_STATE_PROPERTY, IATConsts.PLAYER), nextState, "SELF"));
}
private void LoadGame(RolePlayCharacterAsset rpc)
{
_playerRpc = rpc;
_playerRpc.IsPlayer = true;
// Turn off the choose your character panel
initialCanvas.gameObject.SetActive(false);
//Turning on the Dialogue canvas
GameCanvas.gameObject.SetActive(true);
// Update character's name in the Game although I'm overcomplicating things a bit.
var otherRPCsList = _rpcList;
otherRPCsList.Remove(rpc);
_agentBodyControlers = new List <UnityBodyImplement>();
foreach (var agent in otherRPCsList)
{
// Initializing textual for each different character
var charName = agent.CharacterName.ToString();
var rand = UnityEngine.Random.Range(0, CharacterBodies.Count);
nameToBody.Add(charName, CharacterBodies[rand]);
CharacterBodies.RemoveAt(rand);
var body = nameToBody[charName];
//Initializing and saving into a list the Body Controller of the First Character
var unityBodyImplement = body.GetComponent <UnityBodyImplement>();
body.name = charName;
body.GetComponentInChildren <TextMesh>().text = charName;
_agentBodyControlers.Add(unityBodyImplement);
}
_rpcList.Add(_playerRpc);
if (introduceAgents)
{
List <Name> events = new List <Name>();
foreach (var r in _rpcList)
{
events.Add(EventHelper.ActionEnd(r.CharacterName, (Name)"Enters", (Name)"-"));
}
foreach (var r in _rpcList)
{
r.Perceive(events);
r.Update();
}
}
initialized = true;
}
public void Test_WM_AddingEffects()
{
var wm = BuildWorldModelAsset();
var a1 = EventHelper.ActionEnd("John", "Speak(*,*,*,*)", "Sarah");
wm.addActionTemplate(a1, 2);
wm.AddActionEffect(a1, new EffectDTO()
{
PropertyName = (Name)"Has(Floor)", NewValue = (Name)"Player"
});
Assert.AreEqual(1, wm.GetAllEventEffects().Count);
}
private IEnumerator PlayerReplyAction(string replyActionName, string nextState)
{
ClearButtons();
const float WAIT_TIME = 0.1f;
_agentController.RPC.Perceive(EventHelper.ActionStart(IATConsts.PLAYER, replyActionName, _agentController.RPC.CharacterName.ToString()));
yield return(new WaitForSeconds(WAIT_TIME));
_agentController.RPC.Perceive(EventHelper.ActionEnd(IATConsts.PLAYER, replyActionName, _agentController.RPC.CharacterName.ToString()));
HandleEffects(new List <Name> {
EventHelper.ActionEnd(IATConsts.PLAYER, replyActionName, _agentController.RPC.CharacterName.ToString())
});
}
private void LoadScenario(SingleCharacterDemo.ScenarioData data)
{
ClearButtons();
_iat = data.IAT;
_introPanel.SetActive(true);
_introText.text = string.Format("<b>{0}</b>\n\n\n{1}", _iat.ScenarioName, _iat.ScenarioDescription);
var characterSources = _iat.GetAllCharacterSources().ToList();
int CharacterCount = 0;
foreach (var source in characterSources)
{
var rpc = RolePlayCharacterAsset.LoadFromFile(source.Source);
rpc.LoadAssociatedAssets();
_iat.BindToRegistry(rpc.DynamicPropertiesRegistry);
rpcList.Add(rpc);
var body = m_bodies.FirstOrDefault(b => b.BodyName == rpc.BodyName);
_agentController = new MultiCharacterAgentController(data, rpc, _iat, body.CharaterArchtype, m_characterAnchors[CharacterCount], m_dialogController);
StopAllCoroutines();
_agentControllers.Add(_agentController);
CharacterCount++;
}
AddButton("Back to Scenario Selection Menu", () =>
{
_iat = null;
LoadScenarioMenu();
});
foreach (var actor in rpcList)
{
foreach (var anotherActor in rpcList)
{
if (actor != anotherActor)
{
var changed = new[] { EventHelper.ActionEnd(anotherActor.CharacterName.ToString(), "Enters", "Room") };
actor.Perceive(changed);
}
}
}
RandomizeNext();
SetCamera();
}
private List <Name> NoDialoguesLeft(RolePlayCharacter.RolePlayCharacterAsset rpc)
{
var decisions = rpc.Decide();
var hasFloor = _EventTriggerVariables[(Name)"Has(Floor)"];
var dialogueStates = rpc.GetAllBeliefs().ToList().FindAll(x => x.Name.ToString().Contains(_EventTriggerVariables[(Name)"DialogueState"]));
List <string> dialogueStateTargets = new List <string>();
List <string> dialogueStateValues = new List <string>();
List <Name> noDialogueEvents = new List <Name>();
foreach (var d in dialogueStates)
{
var belief = d.Name.ToString().Split('(', ')');
dialogueStateTargets.Add(belief[1]);
dialogueStateValues.Add(d.Value);
}
if (rpc.GetBeliefValue(hasFloor) != rpc.CharacterName.ToString())
{
return(null);
}
if (!decisions.Any())
{
int i = 0;
foreach (var target in dialogueStateTargets)
{
noDialogueEvents.Add(EventHelper.ActionEnd(target, "NoDialoguesLeft(" + target + "," + dialogueStateValues[i] + ")", rpc.CharacterName.ToString()));
i++;
}
return(noDialogueEvents);
}
/* var speakDecisions = decisions.Select(x => x.Key.ToString() == "Speak");
*
* if (speakDecisions.IsEmpty())
*
* return noDialoguesEvent;
*/
return(null);
}
private IEnumerator HandleDisconnectAction(IAction actionRpc)
{
yield return(null);
m_rpc.Perceive(new Name[] { EventHelper.ActionEnd(m_rpc.CharacterName.ToString(), actionRpc.Name.ToString(), IATConsts.PLAYER) });
AddEvent(EventHelper.PropertyChange(string.Format(IATConsts.DIALOGUE_STATE_PROPERTY, IATConsts.PLAYER), "Disconnected", "SELF").ToString());
if (_body)
{
_body.Hide();
}
yield return(new WaitForSeconds(0.1f));
GameObject.Destroy(GameObject.FindGameObjectWithTag("Score"));
_finalScore.SetActive(true);
GameObject.FindGameObjectWithTag("FinalScoreText").GetComponent <FinalScoreScript>().FinalScore(RPC.Mood);
}
private IEnumerator HandleDisconnectAction(IAction actionRpc)
{
yield return(null);
m_rpc.Perceive(new Name[] { EventHelper.ActionEnd(m_rpc.CharacterName.ToString(), actionRpc.Name.ToString(), IATConsts.PLAYER) });
if (_body)
{
_body.Hide();
}
yield return(new WaitForSeconds(2));
GameObject.Destroy(GameObject.FindGameObjectWithTag("Score"));
if (m_scenarioData.IAT.ScenarioName.Contains("PJ"))
{
_finalScore.SetActive(true);
GameObject.FindGameObjectWithTag("FinalScoreText").GetComponent <FinalScoreScript>().FinalScore(RPC.Mood);
}
}
static void Main(string[] args)
{
var iat = IntegratedAuthoringToolAsset.LoadFromFile("../../../Examples/CiF-Tutorial/JobInterview.iat");
rpcList = new List <RolePlayCharacterAsset>();
foreach (var source in iat.GetAllCharacterSources())
{
var rpc = RolePlayCharacterAsset.LoadFromFile(source.Source);
//rpc.DynamicPropertiesRegistry.RegistDynamicProperty(Name.BuildName("Volition"),cif.VolitionPropertyCalculator);
rpc.LoadAssociatedAssets();
iat.BindToRegistry(rpc.DynamicPropertiesRegistry);
rpcList.Add(rpc);
}
foreach (var actor in rpcList)
{
foreach (var anotherActor in rpcList)
{
if (actor != anotherActor)
{
var changed = new[] { EventHelper.ActionEnd(anotherActor.CharacterName.ToString(), "Enters", "Room") };
actor.Perceive(changed);
}
}
}
foreach (var actor in rpcList)
{
if (actor.Decide().FirstOrDefault() != null)
{
Console.WriteLine(actor.CharacterName.ToString() + " decided to perform " + actor.Decide().FirstOrDefault().Name);
}
}
Console.ReadKey();
}
void Reply(System.Guid id, Name initiator, Name target)
{
dialogueTimerAux = dialogueTimer;
// Retrieving the chosen dialog object
var dialog = _iat.GetDialogActionById(id);
var utterance = dialog.Utterance;
var meaning = dialog.Meaning;
var style = dialog.Style;
var nextState = dialog.NextState;
var currentState = dialog.CurrentState;
// Playing the audio of the dialogue line
if (useTextToSpeech)
{
this.StartCoroutine(Speak(id, initiator, target));
}
//Writing the dialog on the canvas
GameObject.Find("DialogueText").GetComponent <Text>().text =
initiator + " says: '" + utterance + "' ->towards " + target;
// Getting the full action Name
var actualActionName = "Speak(" + currentState + ", " + nextState + ", " + meaning +
", " + style + ")";
//So we can generate its event
var eventName = EventHelper.ActionEnd(initiator, (Name)actualActionName, target);
ClearAllDialogButtons();
//Inform each participating agent of what happened
_rpcList.Find(x => x.CharacterName == initiator).Perceive(eventName);
_rpcList.Find(x => x.CharacterName == target).Perceive(eventName);
//Handle the consequences of their actions
HandleEffects(eventName);
}
public void Test_EA_AppraiseEvent()
{
var asset = BuildTestAsset();
var rpc = new RolePlayCharacterAsset();
asset.AddOrUpdateAppraisalRule(new AppraisalRuleDTO()
{
EventMatchingTemplate = (Name)"Event(Action-End,*,*,*)",
Praiseworthiness = (Name)"5"
});
var m_kb = new KB((Name)"Matt");
asset.AppraiseEvents(new List <Name>()
{
EventHelper.ActionEnd("Matt", "Speak(*,*,*,*)", "Sarah")
},
new ConcreteEmotionalState(),
new AM(), m_kb);
}
public bool TestEventRecording(string subject, string evt, string target)
{
var rpc = BuildRPCAsset();
var eve = EventHelper.ActionEnd(subject, evt, target);
rpc.Perceive(eve);
var records = rpc.EventRecords;
bool ret = false;
foreach (var r in records)
{
if (r.Event.ToString() == eve.ToString())
{
ret = true;
}
}
return(ret);
}
private void PopulateEventSet(int set)
{
eventSets = new Dictionary <int, List <string> >();
var eventList = new List <string>();
if (set == 1)
{
eventList = new List <string>()
{
EventHelper.ActionEnd("Matt", "EntersRoom", "Sarah").ToString(),
EventHelper.ActionEnd("Sarah", "EntersRoom", "Matt").ToString(),
EventHelper.ActionEnd("Matt", "Speak(Start, S1, -, -)", "Sarah").ToString(),
EventHelper.ActionEnd("Matt", "Speak(Start, S1, -, Polite)", "Sarah").ToString(),
EventHelper.ActionEnd("Matt", "Speak(Start, S1, Silly, Polite)", "Sarah").ToString(),
EventHelper.PropertyChange("Has(Floor)", "Sarah", "Matt").ToString(),
//THIS SHOULD BE THE LAST EVENT
EventHelper.ActionEnd("Matt", "Speak(Start, S1, SE(Flirt, Initiate), Positive)", "Sarah").ToString()
};
}
eventSets.Add(set, eventList);
}
public void SetPlayerAction(Guid actionId)
{
var reply = _currentPlayerDialogue.FirstOrDefault(a => a.Id.Equals(actionId));
if (reply != null && _chatScoreHistory.LastOrDefault(c => c.ChatObject.Agent == "Player")?.ChatObject.CurrentState != reply.CurrentState)
{
var actionFormat = $"Speak({reply.CurrentState},{reply.NextState},{reply.Meaning},{reply.Style})";
// Submit dialogue choice to the IAT event list.
_events.Add(EventHelper.ActionStart(IATConsts.PLAYER, actionFormat, CurrentCharacter.CharacterName.ToString()));
_events.Add(EventHelper.ActionEnd(IATConsts.PLAYER, actionFormat, CurrentCharacter.CharacterName.ToString()));
_events.Add(EventHelper.PropertyChange(string.Format(IATConsts.DIALOGUE_STATE_PROPERTY, IATConsts.PLAYER), reply.NextState, "Player"));
// UCM tracker tracks the filename ID of each player dialogue choice made
TrackerEventSender.SendEvent(new TraceEvent("DialogueSelection", TrackerAsset.Verb.Initialized, new Dictionary <string, string>
{
{ TrackerContextKey.PlayerDialogueState.ToString(), reply.CurrentState },
{ TrackerContextKey.PlayerDialogueCode.ToString(), reply.FileName },
{ TrackerContextKey.PlayerDialogueText.ToString(), reply.Utterance }
}));
TrackerEventSender.SendEvaluationEvent(TrackerEvalautionEvent.AssetActivity, new Dictionary <TrackerEvaluationKey, string>
{
{ TrackerEvaluationKey.AssetId, "FAtiMA" },
{ TrackerEvaluationKey.Action, "DialogueSelection" }
});
TrackerEventSender.SendEvaluationEvent(TrackerEvalautionEvent.GameActivity, new Dictionary <TrackerEvaluationKey, string>
{
{ TrackerEvaluationKey.Event, "DialogueSelection" },
{ TrackerEvaluationKey.GoalOrientation, "Progression" },
{ TrackerEvaluationKey.Tool, "DialogueChoices" }
});
_feedbackScores.Clear();
UpdateFeedbackScores(reply, "Player");
GetCharacterResponse();
GetFeedbackEvent?.Invoke(_feedbackScores, FeedbackLevel);
}
}
public void Test_IAT_DP_ValidDialogue_NoMatch(string context, string lastEventMethodCall)
{
var iat = Build_IAT_Asset();
var id = new Guid();
var d = new DialogueStateActionDTO()
{
CurrentState = "Start",
Meaning = "-",
NextState = "S1",
Style = "-",
Utterance = "sbahh",
Id = id,
UtteranceId = "1"
};
var id2 = new Guid();
var d2 = new DialogueStateActionDTO()
{
CurrentState = "S1",
Meaning = "-",
NextState = "S2",
Style = "Rude",
Utterance = "ssadasdasdh",
Id = id2,
UtteranceId = "2"
};
iat.AddDialogAction(d);
iat.AddDialogAction(d2);
// iat.AddNewCharacterSource(new CharacterSourceDTO(){});
var rpc = BuildRPCAsset();
// Associating IAT to RPC
iat.BindToRegistry(rpc.DynamicPropertiesRegistry);
// Making sure the RPC is well Initialized
rpc.Perceive(EventHelper.ActionEnd("Sarah", "EnterRoom", "Matt"));
rpc.Perceive(EventHelper.ActionEnd("Sarah", "Speak(S3,S4,Polite, Rude)", "Matt"));
// Initializing
var condSet = new ConditionSet();
var cond = Condition.Parse("[x] = True");
IEnumerable <SubstitutionSet> resultingConstraints = new List <SubstitutionSet>();
if (context != "")
{
var conditions = context.Split(',');
cond = Condition.Parse(conditions[0]);
// Apply conditions to RPC
foreach (var res in conditions)
{
cond = Condition.Parse(res);
condSet = condSet.Add(cond);
}
resultingConstraints = condSet.Unify(rpc.m_kb, Name.SELF_SYMBOL, null);
}
condSet = new ConditionSet();
cond = Condition.Parse(lastEventMethodCall);
condSet = condSet.Add(cond);
var result = condSet.Unify(rpc.m_kb, Name.SELF_SYMBOL, resultingConstraints);
Assert.IsEmpty(result);
}
private void PopulateEventSet(int set)
{
eventSets = new Dictionary <int, List <string> >();
var eventList = new List <string>();
if (set == 1)
{
eventList = new List <string>()
{
EventHelper.ActionEnd("Matt", "EntersRoom", "Sarah").ToString(),
EventHelper.ActionEnd("Sarah", "EntersRoom", "Matt").ToString(),
EventHelper.PropertyChange("Has(Floor)", "Matt", "Matt").ToString(),
EventHelper.PropertyChange("Likes(Sarah)", "True", "Matt").ToString(),
EventHelper.ActionEnd("Matt", "Speak(Start, S1, Hello, Positive)", "Sarah").ToString()
};
}
else if (set == 2)
{
eventList = new List <string>()
{
EventHelper.ActionEnd("Matt", "EntersRoom", "Sarah").ToString(),
EventHelper.ActionEnd("Sarah", "EntersRoom", "Matt").ToString(),
EventHelper.PropertyChange("Likes(Matt)", "False", "Sarah").ToString()
};
}
else if (set == 3)
{
eventList = new List <string>()
{
EventHelper.ActionEnd("Matt", "EntersRoom", "Tom").ToString(),
EventHelper.ActionEnd("Sarah", "EntersRoom", "Tom").ToString(),
EventHelper.ActionEnd("Tom", "EntersRoom", "Sarah").ToString(),
EventHelper.ActionEnd("Tom", "EntersRoom", "Matt").ToString(),
EventHelper.PropertyChange("Likes(Sarah)", "True", "Tom").ToString(),
EventHelper.PropertyChange("Likes(Matt)", "False", "Tom").ToString(),
EventHelper.ActionEnd("Sarah", "Speak(*, *, SE(Flirt, Start), Positive)", "Tom").ToString()
};
}
else if (set == 4)
{
eventList = new List <string>()
{
EventHelper.ActionEnd("Matt", "EntersRoom", "Tom").ToString(),
EventHelper.ActionEnd("Sarah", "EntersRoom", "Tom").ToString(),
EventHelper.ActionEnd("Tom", "EntersRoom", "Sarah").ToString(),
EventHelper.ActionEnd("Tom", "EntersRoom", "Matt").ToString(),
EventHelper.PropertyChange("Likes(Sarah)", "True", "Tom").ToString(),
EventHelper.PropertyChange("Likes(Matt)", "False", "Tom").ToString(),
EventHelper.ActionEnd("Sarah", "Speak(*, *, SE(Flirt, Answer), Positive)", "Tom").ToString()
};
}
else if (set == 5)
{
eventList = new List <string>()
{
EventHelper.ActionEnd("Matt", "EntersRoom", "Tom").ToString(),
EventHelper.ActionEnd("Sarah", "EntersRoom", "Tom").ToString(),
EventHelper.ActionEnd("Tom", "EntersRoom", "Sarah").ToString(),
EventHelper.ActionEnd("Tom", "EntersRoom", "Matt").ToString(),
EventHelper.PropertyChange("Likes(Sarah)", "True", "Tom").ToString(),
EventHelper.PropertyChange("Likes(Matt)", "False", "Tom").ToString(),
EventHelper.ActionEnd("Sarah", "Speak(*, *, SE(Flirt, Finish), Positive)", "Tom").ToString(),
EventHelper.PropertyChange("Has(Floor)", "Tom", "Tom").ToString()
};
}
eventSets.Add(set, eventList);
}
// Update is called once per frame
void FixedUpdate()
{
if (Input.GetKeyDown(KeyCode.P))
{
Time.timeScale = Time.timeScale > 0 ? 0 : 1;
}
if (Input.GetKeyDown(KeyCode.Escape))
{
this.Restart();
}
if (Input.GetKeyDown(KeyCode.S))
{
this.SaveState();
}
if (!stopTime)
{
// Timeleft -= Time.deltaTime;
// if (Timeleft < 0)
// RandomizeNext();
}
if (Input.GetKeyDown(KeyCode.Keypad1) || Input.GetKeyDown(KeyCode.Alpha1))
{
if (!m_buttonList.IsEmpty())
{
if (m_buttonList.ElementAt(0))
{
m_buttonList.First().onClick.Invoke();
}
}
}
if (Input.GetKeyDown(KeyCode.Keypad2) || Input.GetKeyDown(KeyCode.Alpha2))
{
if (!m_buttonList.IsEmpty())
{
if (m_buttonList.ElementAt(1))
{
m_buttonList.ElementAt(1).onClick.Invoke();
}
}
}
if (Input.GetKeyDown(KeyCode.Keypad3) || Input.GetKeyDown(KeyCode.Alpha3))
{
if (!m_buttonList.IsEmpty())
{
if (m_buttonList.ElementAt(2))
{
m_buttonList.ElementAt(2).onClick.Invoke();
}
}
}
if (Input.GetKeyDown(KeyCode.Keypad4) || Input.GetKeyDown(KeyCode.Alpha4))
{
if (!m_buttonList.IsEmpty())
{
if (m_buttonList.ElementAt(3))
{
m_buttonList.ElementAt(3).onClick.Invoke();
}
}
}
if (Input.GetKeyDown(KeyCode.Keypad5) || Input.GetKeyDown(KeyCode.Alpha5))
{
if (!m_buttonList.IsEmpty())
{
if (m_buttonList.ElementAt(4))
{
m_buttonList.ElementAt(4).onClick.Invoke();
}
}
}
if (rpcList != null && _agentControllers != null)
{
foreach (var agent in _agentControllers)
{
if (agent.getJustReplied())
{
// Debug.Log("we got a reply!");
var reply = agent.getReply();
var lastAction = agent.getLastAction();
HandleEffects(new List <Name> {
EventHelper.ActionEnd(agent.RPC.CharacterName, (Name)("Speak(" + reply.CurrentState.ToString() + "," + reply.NextState.ToString() + "," + reply.Meaning.ToString() + "," + reply.Style.ToString() + ")"), lastAction.Target)
});
// will probably need to launch a courotine
waitingforReply = false;
PlayerDecide();
break;
}
}
}
}
private void LoadScenario(SingleCharacterDemo.ScenarioData data)
{
ClearButtons();
_iat = data.IAT;
if (skipDescription)
{
_introPanel.SetActive(true);
_introText.text = string.Format("<b>{0}</b>\n\n\n{1}", _iat.ScenarioName, _iat.ScenarioDescription);
}
if (_iat.m_worldModelSource != null)
{
if (_iat.m_worldModelSource.Source != "" && _iat.m_worldModelSource.Source != null)
{
_wm = WorldModel.WorldModelAsset.LoadFromFile(_iat.GetWorldModelSource().Source);
}
}
var characterSources = _iat.GetAllCharacterSources().ToList();
int CharacterCount = 0;
foreach (var source in characterSources)
{
var rpc = RolePlayCharacterAsset.LoadFromFile(source.Source);
rpc.LoadAssociatedAssets();
_iat.BindToRegistry(rpc.DynamicPropertiesRegistry);
rpcList.Add(rpc);
var body = m_bodies.FirstOrDefault(b => b.BodyName == rpc.BodyName);
UnityEngine.Random.InitState((int)System.DateTime.Now.Ticks);
var r = UnityEngine.Random.Range(0, 30);
Debug.Log("Going to wait" + r);
StartCoroutine(JustWait(UnityEngine.Random.Range(0, 3)));
_agentController = new MultiCharacterAgentController(data, rpc, _iat, body.CharaterArchtype, m_characterAnchors[CharacterCount], m_dialogController);
// StopAllCoroutines();
_agentControllers.Add(_agentController);
if (rpc.CharacterName == _player.CharacterName)
{
_player = rpc;
}
CharacterCount++;
}
foreach (var agent in _agentControllers)
{
if (agent.RPC.CharacterName != _player.CharacterName)
{
agent.StartBehaviour(this, VersionMenu);
}
}
foreach (var actor in rpcList)
{
foreach (var anotherActor in rpcList)
{
if (actor != anotherActor)
{
var changed = new[] { EventHelper.ActionEnd(anotherActor.CharacterName.ToString(), "Enters", "Room") };
actor.Perceive(changed);
}
}
}
SetCamera();
PlayerDecide();
}
public void AddActionEnd(string subject, string actionName, string target)
{
Events.Add(EventHelper.ActionEnd(subject, actionName, target));
}
// Update is called once per frame
void UpdateFunction()
{
IAction finalDecision = null;
String agentName = "";
// a simple cycle to go through all the agents and get their decision
foreach (var rpc in _rpcList)
{
// From all the decisions the rpc wants to perform we want the first one
var decision = rpc.Decide().FirstOrDefault();
if (decision != null)
{
agentName = rpc.CharacterName.ToString();
finalDecision = decision;
break;
}
}
//If there was a decision I want to print it
if (finalDecision != null)
{
Debug.Log(" The agent " + agentName + " decided to perform " + finalDecision.Name);
// NTerm: 0 1 2 3 4
// If it is a speaking action it is composed by Speak ( [ms], [ns] , [m}, [sty])
var currentState = finalDecision.Name.GetNTerm(1);
var nextState = finalDecision.Name.GetNTerm(2);
var meaning = finalDecision.Name.GetNTerm(3);
var style = finalDecision.Name.GetNTerm(4);
// Returns a list of all the dialogues given the parameters
var dialog = _iat.GetDialogueActions(currentState, nextState, meaning, style).FirstOrDefault();
//Let's print all available dialogues:
if (dialog != null)
{
Debug.Log(agentName + " says: " + dialog.Utterance + " towards " + finalDecision.Target);
}
var actualCurrentState = dialog.CurrentState;
var actualNextState = dialog.NextState;
var actualMeaning = dialog.Meaning;
var actualStyle = dialog.Style;
var actualActionName = "Speak(" + actualCurrentState + ", " + actualNextState + ", " + actualMeaning +
", " + actualStyle + ")";
var eventName = EventHelper.ActionEnd((Name)agentName, (Name)actualActionName, finalDecision.Target);
var consequences = _worldModel.Simulate(new Name[] { eventName });
foreach (var eff in consequences)
{
Debug.Log("Effect: " + eff.PropertyName + " " + eff.NewValue + " " + eff.ObserverAgent);
foreach (var rpc in _rpcList)
{
if (eff.ObserverAgent == rpc.CharacterName || eff.ObserverAgent == (Name)"*")
{
rpc.Perceive(EventHelper.PropertyChange(eff.PropertyName, eff.NewValue, eff.ObserverAgent));
;
}
}
}
}
// else there was no decision
}
static void Main(string[] args)
{
var iat = IntegratedAuthoringToolAsset.LoadFromFile("../../../Examples/CiF-Tutorial/JobInterview.iat");
rpcList = new List <RolePlayCharacterAsset>();
var wm = new WorldModelAsset();
wm.AddActionEffect((Name)"Event(Action-End, *, Speak(*,*,*,*), [t])", new EffectDTO()
{
PropertyName = (Name)"Has(Floor)",
NewValue = (Name)"[t]",
ObserverAgent = (Name)"*"
});
wm.AddActionEffect((Name)"Event(Action-End, [i], Speak([cs],[ns],*,*), SELF)", new EffectDTO()
{
PropertyName = (Name)"DialogueState([i])",
NewValue = (Name)"[ns]",
ObserverAgent = (Name)"[t]"
});
wm.AddActionEffect((Name)"Event(Action-End, SELF, Speak([cs],[ns],*,*), [t])", new EffectDTO()
{
PropertyName = (Name)"DialogueState([t])",
NewValue = (Name)"[ns]",
ObserverAgent = (Name)"[i]"
});
wm.SaveToFile("../../../Examples/WM-Tutorial/WorldModel.wm");
foreach (var source in iat.GetAllCharacterSources())
{
var rpc = RolePlayCharacterAsset.LoadFromFile(source.Source);
//rpc.DynamicPropertiesRegistry.RegistDynamicProperty(Name.BuildName("Volition"),cif.VolitionPropertyCalculator);
rpc.LoadAssociatedAssets();
iat.BindToRegistry(rpc.DynamicPropertiesRegistry);
rpcList.Add(rpc);
}
foreach (var actor in rpcList)
{
foreach (var anotherActor in rpcList)
{
if (actor != anotherActor)
{
var changed = new[] { EventHelper.ActionEnd(anotherActor.CharacterName.ToString(), "Enters", "Room") };
actor.Perceive(changed);
}
}
// actor.SaveToFile("../../../Examples/" + actor.CharacterName + "-output1" + ".rpc");
}
List <Name> _events = new List <Name>();
List <IAction> _actions = new List <IAction>();
IAction action = null;
while (true)
{
_actions.Clear();
foreach (var rpc in rpcList)
{
rpc.Tick++;
Console.WriteLine("Character perceiving: " + rpc.CharacterName + " its mood: " + rpc.Mood);
rpc.Perceive(_events);
var decisions = rpc.Decide();
_actions.Add(decisions.FirstOrDefault());
foreach (var act in decisions)
{
Console.WriteLine(rpc.CharacterName + " has this action: " + act.Name);
}
rpc.SaveToFile("../../../Examples/WM-Tutorial/" + rpc.CharacterName + "-output" + ".rpc");
}
_events.Clear();
var randomGen = new Random(Guid.NewGuid().GetHashCode());
var pos = randomGen.Next(rpcList.Count);
int i = 0;
var initiator = rpcList[pos];
action = _actions.ElementAt(pos);
Console.WriteLine();
if (action == null)
{
Console.WriteLine(initiator.CharacterName + " does not have any action to do ");
}
if (action != null)
{
var initiatorName = initiator.CharacterName.ToString();
var targetName = action.Target.ToString();
var nextState = action.Parameters[1].ToString();
var currentState = action.Parameters[0].ToString();
Console.WriteLine("Action: " + initiatorName + " does " + action.Name + " to " +
targetName + "\n" + action.Parameters[1]);
_events.Add(EventHelper.ActionEnd(initiatorName, action.Name.ToString(),
action.Target.ToString()));
Console.WriteLine();
Console.WriteLine("Dialogue:");
Console.WriteLine("Current State: " + currentState);
if (iat.GetDialogueActions(action.Parameters[0], action.Parameters[1], action.Parameters[2], action.Parameters[3]).FirstOrDefault() != null)
{
Console.WriteLine(initiator.CharacterName + " says: ''" +
iat.GetDialogueActions(action.Parameters[0], action.Parameters[1], action.Parameters[2], action.Parameters[3]).FirstOrDefault().Utterance + "'' to " + targetName);
}
else
{
Console.WriteLine(initiator.CharacterName + " says: " + "there is no dialogue suited for this action");
}
// WORLD MODEL
var effects = wm.Simulate(_events.ToArray());
foreach (var ef in effects)
{
if (ef.ObserverAgent == (Name)"*")
{
foreach (var rpc in rpcList)
{
var proChange =
EventHelper.PropertyChange(ef.PropertyName.ToString(), ef.NewValue.ToString(), "World");
rpc.Perceive(proChange);
}
}
else
{
var proChange =
EventHelper.PropertyChange(ef.PropertyName.ToString(), ef.NewValue.ToString(), "World");
rpcList.Find(x => x.CharacterName == ef.ObserverAgent).Perceive(proChange);
}
}
Console.WriteLine("Next State: " + nextState);
}
Console.WriteLine();
Console.ReadKey();
}
}
static void Main(string[] args)
{
var playerStr = IATConsts.PLAYER;
//Loading the asset
var iat = IntegratedAuthoringToolAsset.FromJson(File.ReadAllText("../../../../Examples/IAT-Tutorial/Scenarios/ForTheRecord.iat"), new GAIPS.Rage.AssetStorage());
var currentState = IATConsts.INITIAL_DIALOGUE_STATE;
var rpc = iat.Characters.ElementAt(0);
while (currentState != IATConsts.TERMINAL_DIALOGUE_STATE)
{
var playerDialogs = iat.GetDialogueActionsByState(currentState);
Console.WriteLine("Current Dialogue State: " + currentState);
Console.WriteLine("Available choices: ");
for (int i = 0; i < playerDialogs.Count(); i++)
{
Console.WriteLine(i + " - " + playerDialogs.ElementAt(i).Utterance);
}
int pos = -1;
do
{
Console.Write("Select Option: ");
} while (!Int32.TryParse(Console.ReadLine(), out pos) || pos >= playerDialogs.Count() || pos < 0);
var chosenDialog = playerDialogs.ElementAt(pos);
var actionName = iat.BuildSpeakActionName(chosenDialog.Id);
var speakEvt = EventHelper.ActionEnd(playerStr, actionName.ToString(), rpc.CharacterName.ToString());
currentState = chosenDialog.NextState;
var dialogStateChangeEvt = EventHelper.PropertyChange(string.Format(IATConsts.DIALOGUE_STATE_PROPERTY, playerStr), chosenDialog.NextState, playerStr);
rpc.Perceive(speakEvt);
rpc.Perceive(dialogStateChangeEvt);
var characterActions = rpc.Decide();
var characterAction = characterActions.FirstOrDefault();
if (characterAction.Key.ToString() == IATConsts.DIALOG_ACTION_KEY)
{
var dialog = iat.GetDialogueActions(
characterAction.Parameters[0],
characterAction.Parameters[1],
characterAction.Parameters[2],
characterAction.Parameters[3]).FirstOrDefault();
Console.WriteLine("\n" + rpc.CharacterName + ": " + dialog.Utterance + "\n");
currentState = characterAction.Parameters[1].ToString();
Console.WriteLine("\nMood: " + rpc.Mood);
}
else
{
Console.WriteLine("\n" + rpc.CharacterName + ": " + characterAction.Name + "\n");
}
}
// The next step in this tutorrial is to start using the World Model to cause effects in the belief state of the characters
Console.WriteLine("Dialogue Reached a Terminal State");
Console.ReadKey();
}
