public void StartInputHandlerDirectiveSerializesProperly()
        {
            var actual = new StartInputHandlerDirective {
                MaximumHistoryLength = 512, TimeoutMilliseconds = 5000
            };

            Assert.True(Utility.CompareJson(actual, "StartInputHandlerDirective.json"));
        }
        public static StartInputHandlerDirective WhenFirstButtonDown(this SkillResponse response, string[] possibleGadgetIds, string triggerEventName, int timeoutMilliseconds)
        {
            var directive = new StartInputHandlerDirective {
                TimeoutMilliseconds = timeoutMilliseconds
            };

            AddTimeOutAndEvent(directive, triggerEventName);
            AddButtonDownTrigger(directive, triggerEventName, possibleGadgetIds);

            SetDirective(response, directive);
            return(directive);
        }
        private static void AddButtonDownTrigger(StartInputHandlerDirective directive, string triggerEventName, string[] possibleGadgetIds)
        {
            var recogniser = new PatternRecognizer
            {
                GadgetIds = possibleGadgetIds.ToList(),
                Fuzzy     = true
            };

            recogniser.Patterns.Add(new Pattern {
                Action = ButtonAction.Down
            });

            directive.Recognizers.Add(triggerEventName, recogniser);
        }
        public static StartInputHandlerDirective AddRollCall(this SkillResponse response, int timeoutMilliseconds, params string[] friendlyNames)
        {
            var directive = new StartInputHandlerDirective
            {
                TimeoutMilliseconds = timeoutMilliseconds,
                Proxies             = friendlyNames.ToList()
            };


            AddTimeOutAndEvent(directive, RollCallCompleteName);
            AddRollCallRecognisers(directive, friendlyNames);
            SetDirective(response, directive);
            return(directive);
        }
        private static void AddRollCallRecognisers(StartInputHandlerDirective directive, string[] names)
        {
            var recogniser = new PatternRecognizer
            {
                Fuzzy  = true,
                Anchor = PatternRecognizerAnchor.Start
            };

            directive.Recognizers.Add(RollCallCompleteName, recogniser);

            foreach (var name in names)
            {
                var pattern = CreateRollCallPattern(name);
                recogniser.Patterns.Add(pattern);
            }
        }
        private static void AddTimeOutAndEvent(StartInputHandlerDirective directive, string eventName, string meetTrigger = null)
        {
            directive.Events.Add("timed out", new InputHandlerEvent
            {
                Meets = new List <string> {
                    "timed out"
                },
                EndInputHandler = true,
                Reports         = GadgetEventReportType.History
            });

            directive.Events.Add(eventName, new InputHandlerEvent
            {
                Meets = new List <string> {
                    meetTrigger ?? eventName
                },
                EndInputHandler = true,
                Reports         = GadgetEventReportType.Matches
            });
        }
        public static StartInputHandlerDirective SetEvents()
        {
            var directive = new StartInputHandlerDirective
            {
                TimeoutMilliseconds = (int)TimeSpan.FromSeconds(10).TotalMilliseconds
            };

            directive.Recognizers.Add("hitYellow", new PatternRecognizer
            {
                Fuzzy    = true,
                Patterns = new List <Pattern>
                {
                    new Pattern
                    {
                        Colors = new List <string> {
                            "FFFF00"
                        },
                        Action = ButtonAction.Down
                    }
                }
            });

            directive.Events.Add("win", new InputHandlerEvent
            {
                Meets = new List <string> {
                    "hitYellow"
                },
                Reports = GadgetEventReportType.Matches
            });

            directive.Events.Add("lose", new InputHandlerEvent
            {
                Meets = new List <string> {
                    "timed out"
                },
                Reports = GadgetEventReportType.History
            });

            return(directive);
        }