/// <summary> /// Handles the intent logic. /// </summary> /// <param name="intent">The LuisResult containing the detected intent.</param> /// <returns>A list of actions for Robbie to execute, based on the provided intent.</returns> private async Task <IList <IAction> > HandleIntent(LuisResult intent) { // todo: UpdateEmotions shouldn't always happen. Preferably move to Intent.HandleIntent or in it's actionclass if (!currentIdentityPersonId.Equals(AnonymousPersonId)) { await UpdateEmotion(); var experienceProfile = await GetClientForCurrentUser().GetExperienceProfile(); if (experienceProfile.OnsiteBehavior.ActiveProfiles?.Length > 0 && experienceProfile.OnsiteBehavior.ActiveProfiles[0].PatternMatches?.Length > 0) { // todo: log profile card to events, just debugging purposes var patternName = experienceProfile.OnsiteBehavior.ActiveProfiles?[0].PatternMatches?[0].PatternName; var matchPercentage = experienceProfile.OnsiteBehavior.ActiveProfiles?[0].PatternMatches?[0].MatchPercentage; ReportEvent("behaviour", $"{patternName} {matchPercentage}"); // todo: get profile, just for debugging purposes // ReSharper disable once UnusedVariable var profile = await GetClientForCurrentUser().GetProfile(); } } // create intent handler after intent has been returned and retrieve all actions that are tied to this intent var handler = new IntentHandler(intent, GetClientForCurrentUser()); var actions = await handler.HandleIntent(); return(actions); }
/// <summary> /// Find an appropriate intent handler and use it to process the incoming intent. /// </summary> /// <param name="request"></param> /// <param name="lambdaContext"></param> /// <returns></returns> public override SkillResponse HandleRequest(SkillRequest request, ILambdaContext lambdaContext) { IntentRequest intentRequest = request.Request as IntentRequest; lambdaContext.Logger.LogLine("Request Intent: " + intentRequest.Intent.Name); IntentHandler handler = CustomIntentHandlers.Find(x => x.IsHandlerForIntent(intentRequest.Intent)); if (handler != null) { // Custom handler return(handler.HandleIntent(intentRequest.Intent, request.Session, lambdaContext)); } else if (SupportedIntents.Contains(intentRequest.Intent.Name)) { // Otherwise we have a story intent return(Story.CreateResponse(intentRequest.Intent, request.Session, lambdaContext)); } else { // Otherwise we have no way of dealing with this intent lambdaContext.Logger.LogLine("No intent handler found"); return(ResponseBuilder.Empty()); } }
protected virtual async Task MessageReceived(IDialogContext context, IAwaitable <Message> item) { if (this.handlerByIntent == null) { this.handlerByIntent = new Dictionary <string, IntentHandler>(GetHandlersByIntent()); } var message = await item; var messageText = await GetLuisQueryTextAsync(context, message); var luisRes = await this.service.QueryAsync(messageText); var intent = BestIntentFrom(luisRes); IntentHandler handler = null; if (intent == null || !this.handlerByIntent.TryGetValue(intent.Intent, out handler)) { handler = this.handlerByIntent[string.Empty]; } if (handler != null) { await handler(context, luisRes); } else { var text = $"No default intent handler found."; throw new Exception(text); } }
protected override async Task <string> ClassifyDialog(ITurnContext context) { if (Result == null) { // Is initialization .. return(null); } // Find TopIntent var topIntent = Result?.GetTopScoringIntent(); // If classification is too bad, set to none. topIntent = (topIntent?.Item2 ?? 0) < 0.3 ? ("None", 1) : topIntent; bool contains = IntentHandler.TryGetValue(topIntent?.Item1?.ToLower(), out string handler); if (contains) { // Default handler return(handler); } else if (topIntent?.Item1?.ToLower()?.StartsWith("st_") ?? false) { // Smalltalk return(nameof(SingleStepSmalltalk <IBot4Dialog, BotServices>)); } else { await SendMessage($"I did not found anything for {topIntent?.Item1}", context); } return(null); }
protected virtual async Task MessageReceived(IDialogContext context, IAwaitable <Message> item) { if (this.handlerByIntent == null) { this.handlerByIntent = LuisDialog.EnumerateHandlers(this).ToDictionary(kv => kv.Key, kv => kv.Value); } var message = await item; var luisRes = await this.service.QueryAsync(message.Text); var maximum = luisRes.Intents.Max(t => t.Score ?? 0); var intent = luisRes.Intents.FirstOrDefault(i => { var curScore = i.Score ?? 0; return(curScore == maximum); }); IntentHandler handler = null; if (intent == null || !this.handlerByIntent.TryGetValue(intent.Intent, out handler)) { handler = this.handlerByIntent[string.Empty]; } if (handler != null) { await handler(context, luisRes); } else { var text = $"No default intent handler found."; throw new Exception(text); } }
protected virtual async Task MessageReceived(IDialogContext context, IAwaitable <Message> item) { if (this.handlerByIntent == null) { this.handlerByIntent = new Dictionary <string, IntentHandler>(GetHandlersByIntent()); } var message = await item; var messageText = await GetLuisQueryTextAsync(context, message); var tasks = this.services.Select(s => s.QueryAsync(messageText)).ToArray(); var winner = this.BestResultFrom(await Task.WhenAll(tasks)); IntentHandler handler = null; if (winner == null || !this.handlerByIntent.TryGetValue(winner.BestIntent.Intent, out handler)) { handler = this.handlerByIntent[string.Empty]; } if (handler != null) { await handler(context, winner?.Result); } else { var text = $"No default intent handler found."; throw new Exception(text); } }
void Start() { mainCam = Camera.main; targetTracker = gameObject.GetComponentInChildren<EnemyTargeting> (); weapon = gameObject.GetComponentInChildren<Weapon>(); intentHandler = new IntentHandler(); currentState = State.Passive; potentialState = State.Passive; }
void Awake() { Growthbeat.GetInstance().Initialize(applicationId, credentialId); IntentHandler.GetInstance().AddNoopIntentHandler(); IntentHandler.GetInstance().AddUrlIntentHandler(); IntentHandler.GetInstance().AddCustomIntentHandler("GrowthbeatComponent", "HandleCustomIntent"); GrowthLink.GetInstance().Initialize(applicationId, credentialId); GrowthPush.GetInstance().RequestDeviceToken(senderId, environment); Growthbeat.GetInstance().Start(); }
private void LoadIntentHandlers() { var handler = new Dictionary <string, string> { // Mappings from intent (lower case) to dialogs. As ID we've used the names of the classes { "None".ToLower(), nameof(NoneDialog) }, { "Echo".ToLower(), nameof(EchoDialog) }, // Special Smalltalks { "ST_Greeting".ToLower(), nameof(GreetingDialog) } }; handler.Keys.ToList().ForEach(k => IntentHandler.Add(k, handler[k])); }
public Enemy.Action InterpretIntent(float patience, IntentHandler.Intent intent) { switch (intent) //Switch is based on what the player action is { case IntentHandler.Intent.INTENT_ATTACK_LIGHT: if (Random.Range(1, 10) >= agility) //If greater than agility, block { return Enemy.Action.BLOCK; } else { break; } case IntentHandler.Intent.INTENT_STRAFE: if (patience > 50) { return Enemy.Action.STRAFE; } else { break; } case IntentHandler.Intent.INTENT_RETREAT: return Enemy.Action.CHARGE; case IntentHandler.Intent.INTENT_APPROACH: if (patience < 60) { return Enemy.Action.BLOCK; } else { return Enemy.Action.CHARGE; } case IntentHandler.Intent.INTENT_ATTACK_STRONG: if (Random.Range(1, 10) >= agility) //If greater than agility, block { return Enemy.Action.BLOCK; } else { break; } } return Enemy.Action.IDLE; }
internal static extern void AndroidPlatformConfiguration_SetOptionalIntentHandlerForUI( HandleRef self, /* from(AndroidPlatformConfiguration_IntentHandler_t) */ IntentHandler intent_handler, /* from(void *) */ IntPtr intent_handler_arg);
internal static extern void AndroidPlatformConfiguration_SetOptionalIntentHandlerForUI(HandleRef self, IntentHandler intent_handler, IntPtr intent_handler_arg);
private static async Task <ResultType> VerifyTusVersionIfApplicable(ContextAdapter context, IntentHandler intentHandler) { // Options does not require a correct tus resumable header. if (intentHandler.Intent == IntentType.GetOptions) { return(ResultType.ContinueExecution); } var tusResumableHeader = context.Request.GetHeader(HeaderConstants.TusResumable); if (tusResumableHeader == HeaderConstants.TusResumableValue) { return(ResultType.ContinueExecution); } context.Response.SetHeader(HeaderConstants.TusResumable, HeaderConstants.TusResumableValue); context.Response.SetHeader(HeaderConstants.TusVersion, HeaderConstants.TusResumableValue); await context.Response.Error(HttpStatusCode.PreconditionFailed, $"Tus version {tusResumableHeader} is not supported. Supported versions: {HeaderConstants.TusResumableValue}"); return(ResultType.StopExecution); }
private static Models.Concatenation.FileConcat GetFileConcatenationFromIntentHandler(IntentHandler intentHandler) { return(intentHandler is ConcatenateFilesHandler concatFilesHandler ? concatFilesHandler.UploadConcat.Type : null); }
internal static extern void AndroidPlatformConfiguration_SetOptionalIntentHandlerForUI( HandleRef self, /* from(AndroidPlatformConfiguration_IntentHandler_t) */ IntentHandler intent_handler, /* from(void *) */ IntPtr intent_handler_arg);
public void handlePlayerIntent(IntentHandler.Intent intent) { Action action = intentInterpreter.InterpretIntent(patience, intent); if (action == Action.LIGHT_ATTACK) { //If the AI decides to do a light attack, reset the patience because it attacked. lightAttack(player.transform); //Do a light attack ResetPatience(); //Reset patience to 0 defend(false); //Stop the AI from defending } if (action == Action.BLOCK) { //Blocks the attack. True for blocking, false to stop. defend(true); } if (action == Action.STRAFE) { //Is a placeholder for dodge. 1 or -1 to decide direction, 0 to not strafe. (Fix that soon? (TM)) strafe(player.transform, player.h); } else { strafe(player.transform, 0); } if (action == Action.IDLE) { //Sets to Idle & disables all other movement defend(false); } if (action == Action.CHARGE) { dash(player.transform); } }