public void GetCharacterResponse()
{
CurrentCharacter.Perceive(_events);
var possibleActions = CurrentCharacter.Decide();
var action = RolePlayCharacterAsset.TakeBestActions(possibleActions).FirstOrDefault();
_events.Clear();
CurrentCharacter.Update();
if (action != null)
{
var actionKey = action.Key.ToString();
if (actionKey == "Speak")
{
var nextState = action.Parameters[1];
var dialogues = _integratedAuthoringTool.GetDialogueActionsByState(action.Parameters[0].ToString());
var characterDialogue = dialogues.FirstOrDefault(dto => string.Equals(dto.Meaning.ToString(), action.Parameters[2].ToString(), StringComparison.CurrentCultureIgnoreCase) && string.Equals(dto.Style.ToString(), action.Parameters[3].ToString(), StringComparison.CurrentCultureIgnoreCase));
if (characterDialogue != null)
{
UpdateFeedbackScores(characterDialogue, "Client");
_events.Add((Name)string.Format("Event(Property-Change,{0},DialogueState(Player),{1})", CurrentCharacter.CharacterName, nextState));
UpdateCurrentState();
PlayDialogueAudio(characterDialogue.FileName);
GetCharacterDialogueSuccessEvent?.Invoke(Localization.GetAndFormat(characterDialogue.FileName, false, ScenarioCode));
}
}
}
GetCharacterStrongestEmotion();
}
private IEnumerator UpdateCoroutine()
{
_events.Clear();
while (m_rpc.GetBeliefValue(string.Format(IATConsts.DIALOGUE_STATE_PROPERTY, IATConsts.PLAYER)) != IATConsts.TERMINAL_DIALOGUE_STATE)
{
yield return(new WaitForSeconds(0.1f));
if (_events.Count == 0)
{
m_rpc.Update();
continue;
}
m_rpc.Perceive(_events);
var action = m_rpc.Decide().FirstOrDefault();
_events.Clear();
m_rpc.Update();
if (action == null)
{
continue;
}
Debug.Log("Action Key: " + action.Key);
if (canSpeak)
{
switch (action.Key.ToString())
{
case "Speak":
m_activeController.StartCoroutine(HandleSpeak(action));
canSpeak = false;
break;
case "Disconnect":
m_activeController.StartCoroutine(newHandleDisconnect());
m_dialogController.AddDialogLine(string.Format("- {0} disconnects -", m_rpc.CharacterName));
_currentCoroutine = null;
Object.Destroy(_body.Body);
break;
default:
Debug.LogWarning("Unknown action: " + action.Key);
break;
}
}
}
}
public void PlayerDecide()
{
if (_player != null)
{
var decisions = _player.Decide();
if (decisions.IsEmpty() || waitingforReply)
{
return;
}
UpdateButtonTexts(false, decisions.ToList());
}
}
private void decide(SuecaEvent ev)
{
//Console.WriteLine("DECING FOR EVENT: " + ev.Name);
string[] tags = ev.Tags.ToArray();
string[] meanings = ev.Meanings.ToArray();
IEnumerable <ActionLibrary.IAction> possibleActions = _rpc.Decide();
if (possibleActions == null || possibleActions.IsEmpty())
{
//Console.WriteLine("No action");
return;
}
else
{
ActionLibrary.IAction chosenAction = possibleActions.FirstOrDefault();
saveToFile();
switch (chosenAction.Key.ToString())
{
case "Speak":
Name currentState = chosenAction.Parameters[0];
Name nextState = chosenAction.Parameters[1];
Name meaning = chosenAction.Parameters[2];
Name style = chosenAction.Parameters[3];
var possibleDialogs = _iat.GetDialogueActions(IATConsts.AGENT, currentState, nextState, meaning, style);
var dialog = getUtterance(possibleDialogs);
Console.WriteLine(dialog);
EmotionalSuecaPlayer.SuecaPub.PerformUtteranceWithTags("", dialog, tags, meanings);
break;
case "Animation":
Name state = chosenAction.Parameters[0];
Name emotionName = chosenAction.Parameters[1];
Console.WriteLine("[ANIMATION] Soft reaction to " + state + " with the style " + emotionName);
break;
default:
Console.WriteLine("Unknown Action");
break;
}
}
}
private IEnumerator UpdateCoroutine()
{
while (m_rpc.GetBeliefValue(string.Format(IATConsts.DIALOGUE_STATE_PROPERTY, IATConsts.PLAYER)) != IATConsts.TERMINAL_DIALOGUE_STATE)
{
yield return(new WaitForSeconds(1));
if (_body._speechController.IsPlaying)
{
continue;
}
var action = m_rpc.Decide().Shuffle().FirstOrDefault();
_events.Clear();
m_rpc.Update();
if (action == null)
{
continue;
}
switch (action.Key.ToString())
{
case "Speak":
m_activeController.StartCoroutine(HandleSpeak(action));
break;
case "Disconnect":
m_activeController.StartCoroutine(HandleDisconnect());
m_dialogController.AddDialogLine(string.Format("- {0} disconnects -", m_rpc.CharacterName));
_currentCoroutine = null;
Object.Destroy(_body.Body);
GameObject.FindObjectOfType <SingleCharacterDemo>().Restart();
break;
default:
Debug.LogWarning("Unknown action: " + action.Key);
break;
}
}
}
public void Decide()
{
IEnumerable <ActionLibrary.IAction> possibleActions = rpc.Decide();
ActionLibrary.IAction chosenAction = possibleActions.FirstOrDefault();
if (chosenAction == null)
{
Console.WriteLine("No action");
//saveToFile();
return;
}
else
{
//saveToFile();
switch (chosenAction.Key.ToString())
{
case "Speak":
Name currentState = chosenAction.Parameters[0];
Name nextState = chosenAction.Parameters[1];
Name meaning = chosenAction.Parameters[2];
Name style = chosenAction.Parameters[3];
var possibleDialogs = GameGlobals.FAtiMAIat.GetDialogueActions(currentState, nextState, meaning, style);
int randomUttIndex = UnityEngine.Random.Range(0, possibleDialogs.Count());
var dialog = possibleDialogs[randomUttIndex].Utterance;
currSpeeches.Add(invoker.GetName() + ": \"" + StripSpeechSentence(dialog) + "\"");
break;
default:
break;
}
}
}
private IEnumerator DetermineAgentDialogue(float updateTime)
{
while (true)
{
var actions = agent1RPC.Decide().ToArray();
var action = actions.Where(a => a.Key.ToString().Equals(IATConsts.DIALOG_ACTION_KEY)).FirstOrDefault();
if (action != null)
{
Name cs = action.Parameters[0];
Name ns = action.Parameters[1];
Name m = action.Parameters[2];
Name s = action.Parameters[3];
var dialogs = iat.GetDialogueActions(cs, ns, m, s);
var dialog = dialogs.Shuffle().FirstOrDefault();
var processed = this.ReplaceVariablesInDialogue(dialog.Utterance);
HandleSpeakAction(dialog.Id, agent1RPC.CharacterName.ToString(), IATConsts.PLAYER);
AgentUtterance.text = processed;
}
yield return(new WaitForSeconds(updateTime));
}
}
private List <DialogueStateActionDTO> DeterminePlayerDialogues()
{
var actions = playerRPC.Decide().ToArray();
var dOpt = new List <DialogueStateActionDTO>();
foreach (var action in actions)
{
if (action.Key.ToString().Equals(IATConsts.DIALOG_ACTION_KEY))
{
Name currentState = action.Parameters[0];
Name nextState = action.Parameters[1];
Name meaning = action.Parameters[2];
Name style = action.Parameters[3];
var dialogs = iat.GetDialogueActions(currentState, nextState, meaning, style);
dOpt.AddRange(dialogs);
}
}
dOpt = dOpt.Distinct().ToList();
var additional = iat.GetDialogueActionsByState("Any");
dOpt.AddRange(additional);
return(dOpt);
}
public static string SendResponse(HttpListenerRequest request)
{
lock (l)
{
switch (request.RawUrl)
{
case "/perceptions":
if (request.HasEntityBody)
{
using (System.IO.Stream body = request.InputStream) // here we have data
{
using (System.IO.StreamReader reader = new System.IO.StreamReader(body, request.ContentEncoding))
{
string e = reader.ReadToEnd();
var p = JsonConvert.DeserializeObject <Perceptions>(e);
try
{
p.UpdatePerceptions(Walter);
#if !DEBUG
Console.WriteLine("New percetion");
var array = JObject.Parse(e)["Vision"].ToString();
dynamic dynJson = JsonConvert.DeserializeObject(array);
foreach (var print in dynJson)
{
Console.WriteLine(print);
Console.WriteLine(JObject.Parse(print)["Prefab"] + " " + JObject.Parse(print)["GUID"]);
}
//Console.WriteLine("End-----------------------------");
//Console.ReadLine();
#endif
}
catch (Exception)
{
//Debug.WriteLine(p.ToString());
throw new Exception(p.ToString());
}
return(JsonConvert.True);
}
}
}
return(JsonConvert.False);
case "/decide":
var decision = Walter.Decide();
//var action = decision.FirstOrDefault();
//foreach (var a in decision) {
// Console.WriteLine("MODA TUTORIAL: Action: " + a.Name.ToString() + " Target " + a.Target + " Utility: " + a.Utility);
//}
if (decision.Count() < 1)
{
#if DEBUG
Console.WriteLine("No decision");
#endif
return(JsonConvert.Null);
}
//Console.WriteLine("Before conversion: " + decision.FirstOrDefault().ToString());
var action = Action.ToAction(decision.First());
//Console.WriteLine("ACTION conversion: " + action.Name + " " + action.Target + "; ");
string t = decision.Count().ToString() + ": ";
foreach (var a in decision)
{
t += a.Name + " = " + a.Target + "; ";
}
Console.WriteLine(t);
return(JsonConvert.SerializeObject(action));
case "/events":
if (request.HasEntityBody)
{
using (System.IO.Stream body = request.InputStream) // here we have data
{
using (System.IO.StreamReader reader = new System.IO.StreamReader(body, request.ContentEncoding))
{
string s = reader.ReadToEnd();
var e = JsonConvert.DeserializeObject <Event>(s);
try
{
e.Perceive(Walter);
}
catch (Exception excpt)
{
//Debug.WriteLine(e.ToString());
throw new Exception(e.ToString());
}
return(JsonConvert.True);
}
}
}
return(JsonConvert.False);
default:
return(JsonConvert.Null);
}
}
}
public static string SendResponse(HttpListenerRequest request)
{
lock (l)
{
switch (request.RawUrl)
{
case "/perceptions":
if (request.HasEntityBody)
{
using (System.IO.Stream body = request.InputStream) // here we have data
{
using (System.IO.StreamReader reader = new System.IO.StreamReader(body, request.ContentEncoding))
{
string e = reader.ReadToEnd();
var p = JsonConvert.DeserializeObject <Perceptions>(e);
try
{
p.UpdatePerceptions(Walter);
}
catch (Exception excpt)
{
//Debug.WriteLine(p.ToString());
throw new Exception(p.ToString());
}
return(JsonConvert.True);
}
}
}
return(JsonConvert.False);
case "/decide":
var decision = Walter.Decide();
if (decision.Count() < 1)
{
return(JsonConvert.Null);
}
var action = Action.ToAction(decision.First());
string t = decision.Count().ToString() + ": ";
foreach (var a in decision)
{
t += a.Name + " = " + a.Target + "; ";
}
Debug.WriteLine(t);
return(JsonConvert.SerializeObject(action));
case "/events":
if (request.HasEntityBody)
{
using (System.IO.Stream body = request.InputStream) // here we have data
{
using (System.IO.StreamReader reader = new System.IO.StreamReader(body, request.ContentEncoding))
{
string s = reader.ReadToEnd();
var e = JsonConvert.DeserializeObject <Event>(s);
try
{
e.Perceive(Walter);
}
catch (Exception excpt)
{
//Debug.WriteLine(e.ToString());
throw new Exception(e.ToString());
}
return(JsonConvert.True);
}
}
}
return(JsonConvert.False);
default:
return(JsonConvert.Null);
}
}
}
private void decide(SuecaEvent ev)
{
Console.WriteLine(_agentName + "---" + "DECING FOR EVENT: " + ev.Name);
string[] tags = ev.Tags.ToArray();
string[] meanings = ev.Meanings.ToArray();
try
{
IEnumerable <ActionLibrary.IAction> possibleActions = _rpc.Decide();
if (possibleActions == null || possibleActions.IsEmpty())
{
Console.WriteLine(_agentName + "---" + "No action");
saveToFile();
return;
}
else
{
ActionLibrary.IAction chosenAction = possibleActions.FirstOrDefault();
saveToFile();
switch (chosenAction.Key.ToString())
{
case "Speak":
Name currentState = chosenAction.Parameters[0];
Name nextState = chosenAction.Parameters[1];
Name meaning = chosenAction.Parameters[2];
Name style = chosenAction.Parameters[3];
var possibleDialogs = _iat.GetDialogueActions(IATConsts.AGENT, currentState, nextState, meaning, style);
var dialog = getUtterance(possibleDialogs);
Console.WriteLine(_agentName + "---" + dialog);
EmotionalSuecaPlayer.SuecaPub.StartedUtterance(_esp._id, ev.Name, "");
EmotionalSuecaPlayer.SuecaPub.PerformUtteranceWithTags("", dialog, tags, meanings);
break;
case "Animation":
Name state = chosenAction.Parameters[0];
string emotionName = chosenAction.Parameters[1].ToString().ToLower();
if (emotionName == "distress" || emotionName == "shame")
{
emotionName = "sadness";
}
else if (emotionName == "pride")
{
emotionName = "joy";
}
else if (emotionName == "reproach")
{
emotionName = "anger";
}
Console.WriteLine("[ANIMATION] reaction to " + state + " with the style " + emotionName);
EmotionalSuecaPlayer.SuecaPub.PlayAnimation("", emotionName + "3");
break;
default:
Console.WriteLine(_agentName + "---" + "Unknown Action");
break;
}
}
}
catch (Exception e)
{
Console.WriteLine(_agentName + "---" + e.ToString());
}
}
// Update is called once per frame
void Update()
{
if (_agentController == null)
{
return;
}
if (!_agentController.IsRunning)
{
return;
}
if (_agentController._body._speechController.IsPlaying)
{
return;
}
if (_agentController.getJustReplied())
{
var reply = _agentController.getReply();
HandleEffects(new List <Name> {
EventHelper.ActionEnd(_agentController.RPC.CharacterName, (Name)("Speak(" + reply.CurrentState.ToString() + "," + reply.NextState.ToString() + "," + reply.Meaning.ToString() + "," + reply.Style.ToString() + ")"), (Name)"Player")
});
waitingforReply = false;
}
if (Input.GetKeyDown(KeyCode.P))
{
if (Time.timeScale > 0)
{
Time.timeScale = 0;
}
else
{
Time.timeScale = 1;
}
}
if (Input.GetKeyDown(KeyCode.Escape))
{
this.Restart();
}
if (Input.GetKeyDown(KeyCode.S))
{
this.SaveState();
}
_agentController.UpdateEmotionExpression();
if (Player != null)
{
var decision = Player.Decide().FirstOrDefault();
if (decision == null || waitingforReply)
{
return;
}
if (decision.Target != _agentController.RPC.CharacterName)
{
return;
}
var dialogActions = _iat.GetDialogueActions(decision.Parameters.ElementAt(0), Name.BuildName("*"), Name.BuildName("*"), Name.BuildName("*"));
UpdateButtonTexts(false, dialogActions);
waitingforReply = true;
}
}
public IEnumerator UpdateCoroutine()
{
while (m_rpc.GetBeliefValue(string.Format(IATConsts.DIALOGUE_STATE_PROPERTY, IATConsts.PLAYER)) != IATConsts.TERMINAL_DIALOGUE_STATE)
{
yield return(new WaitForSeconds(1));
if (_body._speechController.IsPlaying)
{
continue;
}
var action = m_rpc.Decide().FirstOrDefault();
if (action == null)
{
Debug.Log(RPC.CharacterName.ToString() + " decided: nothing");
}
else
{
Debug.Log(RPC.CharacterName.ToString() + " decided: " + action.Key);
}
_events.Clear();
m_rpc.Update();
UpdateEmotionExpression();
if (action == null)
{
continue;
}
lastAction = action;
if (action != null)
{
Debug.Log(RPC.CharacterName.ToString() + " decision is:" + action.Name + " towards " + action.Target);
switch (action.Key.ToString())
{
case "Speak":
updateHeadController(action.Target.ToString());
GameObject.FindGameObjectWithTag(action.Target.ToString())
.GetComponentInChildren <HeadLookController>()._target = this._body.gameObject;
m_activeController.StartCoroutine(HandleSpeak(action));
break;
case "Disconnect":
m_activeController.StartCoroutine(newHandleDisconnect());
m_dialogController.AddDialogLine(string.Format("- {0} disconnects -", m_rpc.CharacterName));
_currentCoroutine = null;
Object.Destroy(_body.Body);
break;
default:
Debug.LogWarning("Unknown action: " + action.Key);
break;
}
}
}
}
static void Main(string[] args)
{
//AssetStorage
var storage = AssetStorage.FromJson(File.ReadAllText("../../../../Examples/AssetStorage.json"));
//Loading the asset
var rpc = new RolePlayCharacterAsset();
rpc.LoadAssociatedAssets(storage);
rpc.ActivateIdentity(new Identity((Name)"Portuguese", (Name)"Culture", 1));
Console.WriteLine("Starting Mood: " + rpc.Mood);
var actions = rpc.Decide();
var action = actions.FirstOrDefault();
rpc.Update();
Console.WriteLine("The name of the character loaded is: " + rpc.CharacterName);
// Console.WriteLine("The following event was perceived: " + event1);
Console.WriteLine("Mood after event: " + rpc.Mood);
Console.WriteLine("Strongest emotion: " + rpc.GetStrongestActiveEmotion()?.EmotionType + "-" + rpc.GetStrongestActiveEmotion()?.Intensity);
Console.WriteLine("First Response: " + action?.Name + ", Target:" + action?.Target.ToString());
var busyAction = rpc.Decide().FirstOrDefault();
Console.WriteLine("Second Response: " + busyAction?.Name + ", Target:" + action?.Target.ToString());
var event3 = EventHelper.ActionEnd(rpc.CharacterName.ToString(), action?.Name.ToString(), "Player");
rpc.Perceive(new[] { event3 });
action = rpc.Decide().FirstOrDefault();
Console.WriteLine("Third Response: " + action?.Name + ", Target:" + action?.Target.ToString());
int x = 0;
while (true)
{
Console.WriteLine("Mood after tick: " + rpc.Mood + " x: " + x + " tick: " + rpc.Tick);
Console.WriteLine("Strongest emotion: " + rpc.GetStrongestActiveEmotion()?.EmotionType + "-" + rpc.GetStrongestActiveEmotion()?.Intensity);
rpc.Update();
Console.ReadLine();
if (x == 10)
{
var event1 = EventHelper.ActionEnd("Player", "Kick", rpc.CharacterName.ToString());
rpc.Perceive(new[] { event1 });
action = rpc.Decide().FirstOrDefault();
rpc.Update();
}
if (x == 11)
{
rpc.ResetEmotionalState();
}
if (x == 25)
{
var event1 = EventHelper.ActionEnd("Player", "Kick", rpc.CharacterName.ToString());
rpc.Perceive(new[] { event1 });
action = rpc.Decide().FirstOrDefault();
rpc.Update();
}
else if (x == 30)
{
Console.WriteLine("Reloading " + rpc.GetStrongestActiveEmotion().Intensity + " " + rpc.GetStrongestActiveEmotion().EmotionType + " mood: " + rpc.Mood);
Console.WriteLine("Reloading result: " + rpc.GetStrongestActiveEmotion().Intensity + " " + rpc.GetStrongestActiveEmotion().EmotionType + " mood: " + rpc.Mood);
}
x++;
}
}
// Update is called once per frame
void Update()
{
if (_agentController == null)
{
return;
}
if (!_agentController.IsRunning)
{
return;
}
if (_agentController.getJustReplied())
{
var reply = _agentController.getReply();
waitingForReply = false;
Initialized = true;
UpdateHistory(reply.Utterance);
ClearDialogOptions();
var cs = reply.CurrentState;
var ns = reply.NextState;
var m = reply.Meaning;
var sty = reply.Style;
List <Name> events = new List <Name>();
events.Add(EventHelper.ActionEnd(_agentController.RPC.CharacterName.ToString(),
"Speak(" + cs + "," + ns + ", " + m + "," + sty + ")", "Player"));
events.Add(EventHelper.PropertyChange("DialogueState(" + _agentController.RPC.CharacterName + ")", ns,
_agentController.RPC.CharacterName.ToString()));
events.Add(EventHelper.PropertyChange("Has(Floor)", "Player",
_agentController.RPC.CharacterName.ToString()));
Player.Perceive(events);
}
if (Input.GetKeyDown(KeyCode.P))
{
if (Time.timeScale > 0)
{
Time.timeScale = 0;
}
else
{
Time.timeScale = 1;
}
}
if (Input.GetKeyDown(KeyCode.Alpha1))
{
if (!m_buttonList.IsEmpty())
{
m_buttonList[0].onClick.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.Alpha2))
{
if (!m_buttonList.IsEmpty())
{
m_buttonList[1].onClick.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.Alpha3))
{
if (!m_buttonList.IsEmpty())
{
m_buttonList[2].onClick.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.Alpha4))
{
if (!m_buttonList.IsEmpty())
{
m_buttonList[3].onClick.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.Alpha5))
{
if (!m_buttonList.IsEmpty())
{
m_buttonList[4].onClick.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.Alpha6))
{
if (!m_buttonList.IsEmpty())
{
m_buttonList[5].onClick.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.Keypad1))
{
if (!m_buttonList.IsEmpty())
{
m_buttonList[0].onClick.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.Keypad2))
{
if (!m_buttonList.IsEmpty())
{
m_buttonList[1].onClick.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.Keypad3))
{
if (!m_buttonList.IsEmpty())
{
m_buttonList[2].onClick.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.Keypad4))
{
if (!m_buttonList.IsEmpty())
{
m_buttonList[3].onClick.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.Keypad5))
{
if (!m_buttonList.IsEmpty())
{
m_buttonList[4].onClick.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.Keypad6))
{
if (!m_buttonList.IsEmpty())
{
m_buttonList[5].onClick.Invoke();
}
}
if (Input.GetKeyDown(KeyCode.S))
{
this.SaveState();
}
if (_agentController.IsRunning)
{
_agentController.UpdateEmotionExpression();
if (waitingForReply == false)
{
var action = Player.Decide().FirstOrDefault();
if (action == null)
{
return;
}
// Debug.Log("Action Key: " + action.Key);
var currentState = action.Parameters[0].ToString();
var possibleOptions = _iat.GetDialogueActionsByState(currentState).ToList();
var originalPossibleActions = possibleOptions;
if (PJScenario)
{
if (!Initialized)
{
var newOptions =
possibleOptions.Shuffle(rand).Where(x => x.CurrentState == "Start").Take(3).ToList();
newOptions.AddRange(_iat.GetDialogueActionsByState("Introduction"));
possibleOptions = newOptions;
}
else
{
// var uhm = rand.Next(0, 10);
// Debug.Log(" rand " + uhm );
var newOptions = possibleOptions.Where(x => !alreadyUsedDialogs.ContainsKey(x.Utterance)).Shuffle(rand).Take(3).ToList();
var additionalOptions =
_iat.GetDialogueActionsByState("Start").Shuffle(rand).Take(2).ToList();
possibleOptions = newOptions.Concat(additionalOptions).ToList();
if (alreadyUsedDialogs.Count() > 12 && possibleOptions.Count() < 6)
{
var ClosureOptions = _iat.GetDialogueActionsByState("Closure").Shuffle(rand).Take(1).ToList();
possibleOptions = newOptions.Concat(additionalOptions).Concat(ClosureOptions).ToList();
}
}
}
// UpdatePapers();
waitingForReply = true;
AddDialogButtons(possibleOptions);
}
}
}
