Beispiel #1
0
        public static List <Item> FindKnownItems(StringWords input, MOB mob, int start, int end)
        {
            input.ValidateEndIndex(ref end);
            Item[]      items         = GeneralUtilities.VisibleItems(mob, mob.Body);
            List <Item> matchingItems = new List <Item>();

            foreach (Item item in items)
            {
                if (mob.CanRecognize(item, input, start, end))
                {
                    matchingItems.Add(item);
                }
            }
            return(matchingItems);
        }
Beispiel #2
0
        /// <summary>
        /// Find the first word in an input that matches a preposition from a list of prepositions
        /// </summary>
        /// <param name="text">Input to search</param>
        /// <param name="typeOfPreposition">Type/List of prepositions</param>
        /// <param name="prepositionValue">Which preposition was found (can be cast to that preposition). -1 if no preposition found.</param>
        /// <param name="startIndex">Which word in input to start searching on (inclusive). Defaults to 0 (start of input)</param>
        /// <param name="endIndex">Which word in input to stop searching on (exclusive). Defaults to -1 (end of input)</param>
        /// <returns>Index of the first word of the preposition</returns>
        public static int FindAPreposition(StringWords text, Type typeOfPreposition, out int prepositionValue, int startIndex = 0, int endIndex = -1) //TODO: Replace typeOfPreposition for an easier-to-use type of variable. An enum of enums?
        {
            text.ValidateEndIndex(ref endIndex);

            //Array values = Enum.GetValues(typeOfPreposition);
            string[][] options = OptionsForPreposition(typeOfPreposition);
            for (int i = startIndex; i < endIndex; i++)
            {
                int j = i;
                prepositionValue = MatchString(options, text.Segments, ref j); //NOTE: This assumes enums always have default-assigned values (0, 1, 2, etc.)
                if (prepositionValue != -1)
                {
                    return(i);
                }
            }
            prepositionValue = -1;
            return(-1);
        }
Beispiel #3
0
        /// <summary>
        /// Check if 'input' (or a specific part of it) can be found inside of 'text'.
        /// </summary>
        /// <param name="input">Text to search for</param>
        /// <param name="text">Text to look inside for matches</param>
        /// <param name="startIndex">First word of 'input' to start searching for</param>
        /// <param name="endIndex">After last word of 'input' to search for (exclusive end)</param>
        /// <returns>True if text contains input in the same order.</returns>
        public static bool CheckAutoCompleteText(StringWords input, string text, int startIndex = 0, int endIndex = -1)
        {
            input.ValidateEndIndex(ref endIndex);
            if (startIndex >= endIndex)
            {
                throw new ArgumentException("startIndex must be before endIndex");
            }

            int textIndex = 0;

            for (int inputIndex = 0; textIndex < text.Length; textIndex++)
            {
                string wordToFind = input.Segments[inputIndex];

                textIndex = text.IndexOf(wordToFind, textIndex);
                if (textIndex == -1)
                {
                    return(false);                 //Input word was not found.
                }
                if (textIndex != 0)
                { //Check to make sure this could reasonably be the start of a word. If not, continue at the next character.
                    char prevChar = text[textIndex - 1];
                    //TODO: Finetune below checks.
                    //if (!Char.IsWhiteSpace(prevChar)) continue;
                    if (Char.IsLetterOrDigit(prevChar))
                    {
                        continue;
                    }
                }

                //Found a match. Continue with the next word.
                inputIndex++;
                if (inputIndex == endIndex)
                {
                    return(true);               //No next word, found all the words.
                }
                textIndex += wordToFind.Length; //Skip the matched text (plus 1 character from loop counter)
            }
            //Ran out of letters before matching all the words.
            return(false);
        }
Beispiel #4
0
        /// <summary>
        /// Attempt to parse user's input text as a direction / distance.
        /// </summary>
        /// <param name="text">Full input to parse</param>
        /// <param name="startIndex">Index of first word to try to parse (inclusive). </param>
        /// <param name="endIndex">Index of last word to try to parse (exclusive). If the text is found, this will be updated
        /// to after the last word found (first index not belonging to the MovementDirection)</param>
        /// <param name="requireDirection">If true, parsing will return failure if no direction component is found.</param>
        /// <param name="requireDistance">If true, parsing will return failure if no distance component is found.</param>
        /// <param name="getDistance">If true, distance may be parsed. This is ignored (assumed true) if requireDistance is true.</param>
        /// <returns>The direction and distance parsed from the input text.</returns>
        public static MovementDirection ParseAsDirection(StringWords text, int startIndex, ref int endIndex, bool requireDirection = false, bool requireDistance = false, bool getDirection = true, bool getDistance = true)
        {
            text.ValidateEndIndex(ref endIndex);

            getDistance |= requireDistance;

            Directions foundDirection = Directions.NoDirection;
            //List<Directions> directions = new List<Directions>();
            KeyValuePair <string[][], Directions[]> directionOptions = DirectionCommand.GetDirectionOptions();

            string[][]   directionStrings = directionOptions.Key;
            Directions[] directionValues  = directionOptions.Value;
            int          foundDistance    = -1;
            MovementUnit foundUnit        = MovementUnit.NoDistance;
            int          i = startIndex;

            for (; i < endIndex; i++)
            {
                string word = text.Segments[i];
                if (foundDirection == Directions.NoDirection)
                {
                    int found = MatchString(directionStrings, text.Segments, ref i);
                    if (found != -1)
                    {
                        foundDirection = directionValues[found];
                        //Loop will increment but i is already the correct value after MatchString,
                        i--; //decrement here to 'skip' the increment.
                        continue;
                    }
                }
                if (getDistance && foundUnit == MovementUnit.NoDistance)
                {
                    int distanceWords = ParseAsDistance(text, out foundDistance, out foundUnit, i, Math.Min(i + 1, endIndex - 1));
                    if (distanceWords != 0)
                    {
                        if (distanceWords == 2)
                        {
                            i++;
                        }
                        continue;
                    }
                }

                break;
            }
            if (foundDirection == Directions.NoDirection && requireDirection)
            {
                return(null);
            }
            if (foundUnit == MovementUnit.NoDistance && requireDistance)
            {
                return(null);
            }
            if (foundDirection == Directions.NoDirection && foundUnit == MovementUnit.NoDistance)
            {
                return(null);
            }

            endIndex = i;
            return(new MovementDirection()
            {
                direction = foundDirection,
                distanceCount = foundDistance,
                distanceUnit = foundUnit
            });
        }