protected override void initializeAbilities()
{
SpecifiedSlot = newField <string>("specifiedSlot", _specifiedSlot);
SpecifiedValue = newField <string>("specifiedValue", _specifiedValue);
CountValue = newField <int>("countValue", _countValue);
this
.AddAbility("set " + _databaseName + " specifier $specifier").CallAction(_ability_setSpecifier)
.Param(SpecifiedSlot, "$specifier")
.Param(SpecifiedValue, "$specifier")
.AddAnswer("value of $slot from " + _databaseName + " database", Question.HowToEvaluate).Call(_value_slotValue)
.Param(SpecifiedSlot, "$slot")
.AddAnswer(_databaseName + " database has $count result", Question.IsItTrue).Call(_value_resultCountCondition)
.Param(CountValue, "$count")
;
// register all values
foreach (var column in _externalDatabase.Columns)
{
Container.AddSpanElement(column);
foreach (var value in _externalDatabase.GetColumnValues(column))
{
Container.AddSpanElement(value);
Container.Add(SemanticItem.From(Question.WhatItSpecifies, column, Constraints.WithInput(value)));
}
}
}
private void _ability_askForHelp()
{
var question = _databaseQuestion();
_askedQuestion = question;
_body.Print(_askedQuestion.ReadableRepresentation());
}
private void _ability_acceptAdvice(string answer)
{
var query = _askedQuestion;
var newFact = SemanticItem.From(query.Question, answer, query.Constraints);
Log.NewFact(newFact);
_body.Db.Container.Add(newFact);
_body.Print("ok");
_askedQuestion = null;
FireEvent("advice was received");
}
private SemanticItem _field_simplified(ModuleContext context)
{
var answer = _body.InputHistory.Last();
var simplifiedAnswer = context.GetAnswer(Question.HowToSimplify, answer);
if (simplifiedAnswer == null)
{
simplifiedAnswer = SemanticItem.Entity(answer);
}
else
{
simplifiedAnswer = SemanticItem.Entity(simplifiedAnswer.InstantiateWithEntityVariables(simplifiedAnswer.Answer));
}
return(simplifiedAnswer);
}
private SemanticItem _countValue(ModuleContext context)
{
var numberValue = context.Input;
if (!int.TryParse(numberValue, out var number))
{
numberValue = context.GetAnswer(Question.HowToConvertItToNumber)?.Answer;
if (numberValue == null)
{
return(null);
}
if (!int.TryParse(numberValue, out number))
{
return(null);
}
}
return(SemanticItem.Entity(number.ToString()));
}
private double rankQuestion(SemanticItem question)
{
var q = question.Question;
var score = 0.0;
if (q == Question.IsItTrue)
{
score += 0.1;
}
else if (q == Question.Entity)
{
score += 0.0;
}
else if (q == Question.HowToEvaluate)
{
score += 0.2;
}
else if (q == Question.WhatShouldAgentDoNow)
{
score += 0.1;
}
else if (q == Question.HowToDo)
{
score += 0.1;
}
else
{
score += 1;
}
score += 1.0 / (1.0 + question.Constraints.VariableValues.Count());
var inputWords = new HashSet <string>(_body.InputHistory.Last().Split(' '));
var commonWordCount = question.ReadableRepresentation().Split(' ').Sum(qw => _body.InputHistory.Contains(qw) ? 1 : 0);
score += commonWordCount;
return(score);
}
public ChangeTypeCommand(SemanticItem item, SemanticItem newType)
{
Item = item;
NewType = newType;
OldType = ((IHaveType)item).TypeWord;
}
private SemanticItem _value_userSaidSomething(string userInputEvaluation, string something)
{
return(SemanticItem.Convert(userInputEvaluation.Contains(something)));
}
private SemanticItem _param_inputLiteral(ModuleContext context)
{
return(SemanticItem.Entity(context.Input));
}
private SemanticItem _value_slotValue(string slot)
{
return(SemanticItem.Entity(_externalDatabase.Read(slot)));
}
internal abstract void AddItem(SemanticItem item);
protected SemanticEditableContainer(SemanticItem item)
: base(item)
{
}
internal abstract void RemoveItem(SemanticItem item);
internal abstract void InsertItem(int index, SemanticItem item);
private SemanticItem _answer_questionWasAsked()
{
return(SemanticItem.Convert(_askedQuestion != null));
}
