public void Subscribe(CommandResultModelHandler commandResultModelHandler)
{
_commandResultModelHandler = commandResultModelHandler;
// Using anonymous delegate to add an additional parameter, commandResultModelHandler to send to ListenAndLearn method
_listenerDelegate = delegate(object sender, PropertyChangedEventArgs args) { _resultListener.ListenAndLearn(sender, args, _commandResultModelHandler); };
_commandResultModelHandler.PropertyChanged += _listenerDelegate;
}
public void ListenAndLearn(object sender, PropertyChangedEventArgs e, CommandResultModelHandler commandResultModelHandler)
{
Debug.WriteLine("A property has changed: " + e.PropertyName + " in " + commandResultModelHandler.GetPropSource());
_propertiesBeingChanged.Add(e.PropertyName);
if (commandResultModelHandler.isPropSourceChanged)
{
_propSourceBeingChanged = commandResultModelHandler.GetPropSource();
_resultModel = commandResultModelHandler.GetResultModel();
}
}
public LookResultModel(CommandResultModelHandler resultModelHandler)
{
_resultModelHandler = resultModelHandler;
_propSource = typeof(LookResultModel);
}
public MovementResultModel(CommandResultModelHandler resultModelHandler)
{
_resultModelHandler = resultModelHandler;
_propSource = typeof(MovementResultModel);
}
public bool BootstrapCommandDetermination(string stringInput)
{
var nlpResultModel = _runtime.Container.Resolve <NlpResult>();
nlpResultModel = _coreNlpProcessor.DeserializeInput(_pipeline, nlpResultModel, stringInput);
var jsonContentProvider = _runtime.Container.Resolve <IContentProvider>();
var currentAssemblyName = GetType().GetTypeInfo().Assembly.GetName().Name;
var errorDisplayables = _runtime.Container.Resolve <ErrorDisplayables>();
jsonContentProvider.Populate <ErrorDisplayables>(errorDisplayables, currentAssemblyName);
var basicValidatorHndlr = _runtime.Container.Resolve <BasicValidatorHandler>();
var rootValidator = basicValidatorHndlr.FetchModel <NlpResult>(nlpResultModel);
rootValidator.RuleFor(result => result.sentences).SetValidator(new ListMustContainOnlyOneItem <Sentence>(errorDisplayables));
rootValidator.RuleFor(result => result.sentences).SetValidator(new ListMustNotBeEmpty <Sentence>(errorDisplayables));
var rootValidatorResult = basicValidatorHndlr.ValidateModel(rootValidator);
if (!rootValidatorResult.IsValid)
{
foreach (var failure in rootValidatorResult.Errors)
{
Console.WriteLine(failure.ErrorMessage);
}
return(false);
}
var nerTypes = new List <string>
{
"PERSON",
"LOCATION",
"ORGANIZATION",
"MISC",
"MONEY",
"NUMBER",
"ORDINAL",
"PERCENT"
};
stringInput = "";
foreach (var token in nlpResultModel.sentences[0].tokens)
{
if (nerTypes.Contains(token.ner))
{
stringInput += token.word;
stringInput += token.after;
}
else
{
stringInput += token.word.ToLower();
stringInput += token.after.ToLower();
}
}
nlpResultModel = _runtime.Container.Resolve <NlpResult>();
nlpResultModel = _coreNlpProcessor.DeserializeInput(_pipeline, nlpResultModel, stringInput);
var sentenceModelToValidate = basicValidatorHndlr.FetchModel <Sentence>(nlpResultModel.sentences[0]);
sentenceModelToValidate.RuleFor(result => result.tokens).SetValidator(new CheckAllWordsIsInGameLex(_lexRepo));
basicValidatorHndlr.ValidateModel(sentenceModelToValidate);
var checkAllWordsIsInGameLex = basicValidatorHndlr.GetAValidator <CheckAllWordsIsInGameLex>(sentenceModelToValidate, "tokens");
var truncatedTokensToValidate = basicValidatorHndlr.FetchModel <IList <Token> >(checkAllWordsIsInGameLex.GetTokensNotFoundInGameLexes());
truncatedTokensToValidate.RuleFor(result => result).SetValidator(new CheckAllWordsIsInNlpLex(_lexicalizedParser));
var truncatedTokensToValidateResult = basicValidatorHndlr.ValidateModel(truncatedTokensToValidate);
var checkAllWordsIsInNlpLex = basicValidatorHndlr.GetAValidatorOfEnumerable <CheckAllWordsIsInNlpLex, Token>(truncatedTokensToValidate, 0);
if (!truncatedTokensToValidateResult.IsValid)
{
foreach (var tokenNotFound in checkAllWordsIsInNlpLex.GetTokensNotFoundInNlpLex())
{
Console.WriteLine("I do not understand the word ", tokenNotFound.word);
}
return(false);
}
var commandAggregatesRepo = _runtime.Container.Resolve <CommandAggregatesRepo>();
var allTokensIterator = _runtime.Container.Resolve <IListIterator <Token> >();
var allTokensAggregate = _runtime.Container.Resolve <IListAggregate <Token> >(new TypedParameter(typeof(IListIterator <>), allTokensIterator));
foreach (var token in nlpResultModel.sentences[0].tokens)
{
allTokensAggregate.Add(token);
}
var allBasicDependenciesIterator = _runtime.Container.Resolve <IListIterator <BasicDependency> >();
var allBasicDependenciesAggregate = _runtime.Container.Resolve <IListAggregate <BasicDependency> >(new TypedParameter(typeof(IListIterator <>), allBasicDependenciesIterator));
foreach (var basicDependency in nlpResultModel.sentences[0].basicDependencies)
{
allBasicDependenciesAggregate.Add(basicDependency);
}
var allEntityMentionsIterator = _runtime.Container.Resolve <IListIterator <Entitymention> >();
var allEntityMentionsAggregate = _runtime.Container.Resolve <IListAggregate <Entitymention> >(new TypedParameter(typeof(IListIterator <>), allEntityMentionsIterator));
foreach (var entityMention in nlpResultModel.sentences[0].entitymentions)
{
allEntityMentionsAggregate.Add(entityMention);
}
var wordsFoundInGameLexesIterator = _runtime.Container.Resolve <IDictionaryIterator <string, dynamic> >();
var wordsFoundInGameLexesAggregate = _runtime.Container.Resolve <IDictionaryAggregate <string, dynamic> >(new TypedParameter(typeof(IDictionaryIterator <,>), wordsFoundInGameLexesIterator));
foreach (var wordsFoundInGameLex in checkAllWordsIsInGameLex.GetWordsFoundInGameLexes())
{
wordsFoundInGameLexesAggregate.AddOrReplace(wordsFoundInGameLex.Key, wordsFoundInGameLex.Value);
}
var tokensNotFoundInGameLexesIterator = _runtime.Container.Resolve <IListIterator <Token> >();
var tokensNotFoundInGameLexesAggregate = _runtime.Container.Resolve <IListAggregate <Token> >(new TypedParameter(typeof(IListIterator <>), tokensNotFoundInGameLexesIterator));
foreach (var tokenNotFoundInGameLexes in checkAllWordsIsInGameLex.GetTokensNotFoundInGameLexes())
{
tokensNotFoundInGameLexesAggregate.Add(tokenNotFoundInGameLexes);
}
var tokensFoundInNlpLexIterator = _runtime.Container.Resolve <IListIterator <Token> >();
var tokensFoundInNlpLexAggregate = _runtime.Container.Resolve <IListAggregate <Token> >(new TypedParameter(typeof(IListIterator <>), tokensFoundInNlpLexIterator));
foreach (var tokenFoundInNlpLex in checkAllWordsIsInNlpLex.GetTokensFoundInNlpLex())
{
tokensFoundInNlpLexAggregate.Add(tokenFoundInNlpLex);
}
var tokensNotFoundInNlpLexIterator = _runtime.Container.Resolve <IListIterator <Token> >();
var tokensNotFoundInNlpLexAggregate = _runtime.Container.Resolve <IListAggregate <Token> >(new TypedParameter(typeof(IListIterator <>), tokensNotFoundInNlpLexIterator));
foreach (var tokenNotFoundInNlpLex in checkAllWordsIsInNlpLex.GetTokensNotFoundInNlpLex())
{
tokensNotFoundInNlpLexAggregate.Add(tokenNotFoundInNlpLex);
}
commandAggregatesRepo.Set(
allTokensAggregate,
allBasicDependenciesAggregate,
allEntityMentionsAggregate,
wordsFoundInGameLexesAggregate,
tokensNotFoundInGameLexesAggregate,
tokensFoundInNlpLexAggregate,
tokensNotFoundInNlpLexAggregate
);
// BUG - for an unknown reason, cannot use Autofac to resolve IntentionBuilderFactory, as it does not adhere to InstancePerDependency registration. Using New instead as a workaround.
_intentionBuilderFactory = new IntentionBuilderFactory(commandAggregatesRepo, _mapperRepo, _lexRepo);
_baseIntentionResult = _intentionBuilderFactory.DetermineBaseIntention();
// **TEMP**
switch (_baseIntentionResult)
{
case BaseIntentions.Adverb:
Console.WriteLine("I'm not sure what you're trying to do?");
break;
case BaseIntentions.AdverbMod:
Console.WriteLine("What?");
break;
case BaseIntentions.Adjective:
Console.WriteLine("I'm not sure what you're trying to describe?");
break;
case BaseIntentions.Inventory:
Console.WriteLine("Sorry, I don't have any inventory functionality programmed in me");
break;
case BaseIntentions.Take:
Console.WriteLine("Sorry, I don't yet know how to take things");
break;
case BaseIntentions.ObjectOfInterest:
Console.WriteLine("What about it?");
break;
case BaseIntentions.MiscObject:
Console.WriteLine("What about it?");
break;
case BaseIntentions.Direction:
Console.WriteLine("What about that direction?");
break;
case BaseIntentions.Location:
Console.WriteLine("What about that location?");
break;
case BaseIntentions.NerPerson:
Console.WriteLine("I know that person!");
break;
case BaseIntentions.NerLocation:
Console.WriteLine("I know that place! I think it's very far away from here");
break;
case BaseIntentions.NerOrganization:
Console.WriteLine("What about them?");
break;
case BaseIntentions.NerMisc:
Console.WriteLine("What about it?");
break;
case BaseIntentions.NerMoney:
Console.WriteLine("Money won't help me now");
break;
case BaseIntentions.NerNumber:
Console.WriteLine("What about the number?");
break;
case BaseIntentions.NerOrdinal:
Console.WriteLine("Ordinal for what?");
break;
case BaseIntentions.NerPercent:
Console.WriteLine("Percentage of what?");
break;
case BaseIntentions.NerUnknown:
Console.WriteLine("I don't recognise that");
break;
case BaseIntentions.UnknownVerb:
Console.WriteLine("What are you trying to do");
break;
case BaseIntentions.UnknownNoun:
Console.WriteLine("What about it?");
break;
case BaseIntentions.UnknownNounPlural:
Console.WriteLine("What about them?");
break;
case BaseIntentions.UnknownAdjective:
Console.WriteLine("What are you trying to describe?");
break;
case BaseIntentions.UnknownAdverb:
Console.WriteLine("I'm not sure what you're trying to do");
break;
case BaseIntentions.EntirelyUnknown:
Console.WriteLine("I don't understand");
break;
}
_resultModelHandler = _runtime.Container.Resolve <CommandResultModelHandler>();
return(true);
}