public Demo2() { Blackboard = new Blackboard(); Demo2_DefineUnits(Blackboard); m_IDSelector = new KS_ScheduledIDSelector(Blackboard); m_prologEval = new KS_ScheduledPrologEval(Blackboard, inputPool: m_IDSelector.OutputPool, prologExpName: ApplTest_Prolog); /* * fixme: consider creating a filtered by boolean result KS or a more general filter by KC_EvaluatedExpression (once I have more EvaluatedExpressions than Prolog). */ m_filterByPrologResult = new KS_ScheduledFilterSelector(Blackboard, inputPool: m_prologEval.OutputPool, outputPool: FilteredPrologResultPool, filter: KS_ScheduledPrologEval.FilterByPrologResult(ApplTest_Prolog, true)); m_uniformRandomSelector = new KS_ScheduledUniformDistributionSelector(Blackboard, inputPool: FilteredPrologResultPool, outputPool: UniformlySelectedOutputPool, numberToSelect: 1); m_choicePresenter = new KS_ScheduledChoicePresenter(Blackboard, UniformlySelectedOutputPool); m_filterPoolCleaner = new KS_ScheduledFilterPoolCleaner(Blackboard, new string[] { m_IDSelector.OutputPool, // Output pool for ID selector m_prologEval.OutputPool, // Output pool for prolog eval m_filterByPrologResult.OutputPool, // Output pool for filter that filters by prolog result m_uniformRandomSelector.OutputPool // Final output pool (written into by UniformDistributionSelector) }); Controller = new ScheduledSequenceController(); Controller.AddKnowledgeSource(m_IDSelector); Controller.AddKnowledgeSource(m_prologEval); Controller.AddKnowledgeSource(m_filterByPrologResult); Controller.AddKnowledgeSource(m_uniformRandomSelector); Controller.AddKnowledgeSource(m_choicePresenter); Controller.AddKnowledgeSource(m_filterPoolCleaner); // Put request for starting content unit in blackboard Unit req = new Unit(); req.AddComponent(new KC_IDSelectionRequest("start", true)); req.SetActiveRequest(true); Blackboard.AddUnit(req); }
public DemoEnsembleLite() { Blackboard = new Blackboard(); DemoEnsemble_DefineUnits(Blackboard); /* * This prolog evaluator evauates the conditions of rules in the rules pool. * Construct the prolog evaluator with the following parameters: * * The blackboard on which to do the work. * * The input pool to look for ContentUnits with prolog expressions to evaluate. * * The name of the prolog expression to evaluate (in this case the prolog expression named ApplTest_Prolog, for which a string constant is defined in KCNames). */ var prologEval = new KS_ScheduledPrologEval(Blackboard, inputPool: RulesPool, outputPool: EvalRulesPool, ApplTest_Prolog); /* * fixme: consider creating a filtered by boolean result KS or a more general filter by KC_EvaluatedExpression (once I have more EvaluatedExpressions than Prolog). * This filter selector selects all the rules whose prolog expression evaluated to true. */ var filterByPrologResult = new KS_ScheduledFilterSelector(Blackboard, inputPool: EvalRulesPool, outputPool: SatisfiedRulesPool, filter: KS_ScheduledPrologEval.FilterByPrologResult(ApplTest_Prolog, true)); /* * This KS prints out info about satisified rules (for debugging). */ var printFilteredRules = new KS_ScheduledPrintPool(Blackboard, SatisfiedRulesPool); /* * This KS takes a pool of things to weight (in this case dialog) and a pool of utility sources (in this case satisfied rules) and sums the utility sources * applicable to each unit to weight to compute a new pool of weighted units. */ var weightDialogWithRules = new KS_ScheduledUtilitySum(Blackboard, SatisfiedRulesPool, DialogPool, WeightedDialogPool); /* * This KS prints out the pool of weighted dialog (for debugging). */ var printWeightedDialog = new KS_ScheduledPrintPool(Blackboard, WeightedDialogPool); /* * This KS selects the most highly weighted dialog lines into a pool (e.g. if the highest weighting is 10, and their are two dialog lines * that share that weight, it will copy both of them into the output pool). */ var selectHighestWeightedDialog = new KS_ScheduledHighestTierSelector <KC_Utility>(Blackboard, WeightedDialogPool, HighestWeightedDialogPool); /* * This KS prints out the units in the HighestWeightedDialogPool (for debugging). */ var printHighestWeightedDialog = new KS_ScheduledPrintPool(Blackboard, HighestWeightedDialogPool); /* * This KS selects one line at random from the HighestWeightedDialogPool. */ var selectDialogLine = new KS_ScheduledUniformDistributionSelector(Blackboard, inputPool: HighestWeightedDialogPool, outputPool: SelectedDialogPool, numberToSelect: 1); /* * This KS prints out the units in the SelectedDialogPool (there will be only one dialog line in this pool). (for debugging) */ var printSelectedDialogLine = new KS_ScheduledPrintPool(Blackboard, SelectedDialogPool); /* * This KS is updating the prolog KB based on the effects on the selected dialog line. * fixme: for now I'm just using KS_ScheduledExecute to call the SelectChoice_PrologKBChanges. Need to refactor SelectChoice_PrologKBChanges because it's not just tied to SelectChoice and possibly move KB updates into * a special purpose KS. */ var updatePrologKB = new KS_ScheduledExecute( () => { var selectedDialodLines = from Unit node in Blackboard.LookupUnits <Unit>() where ScheduledKnowledgeSource.SelectFromPool(node, SelectedDialogPool) select node; foreach (Unit unit in selectedDialodLines) { /* * SelectChoice_PrologKBChanges() is an event handler, so it expects a sender as well as for args to be wrapped in EventArgs. * So I'm using this as the sender (PrologKBChanges doesn't actually use the sender) wrapping in SelectChoiceEventArgs. */ var eventArgs = new SelectChoiceEventArgs(unit, Blackboard); EventHandlers_ChoicePresenter.SelectChoice_PrologKBChanges(this, eventArgs); } } ); /* * This KS cleans up all the pools that were created during the selection process. */ var poolCleaner = new KS_ScheduledFilterPoolCleaner( Blackboard, new string[] { EvalRulesPool, SatisfiedRulesPool, WeightedDialogPool, HighestWeightedDialogPool, SelectedDialogPool } ); Controller = new ScheduledSequenceController(); Controller.AddKnowledgeSource(prologEval); Controller.AddKnowledgeSource(filterByPrologResult); Controller.AddKnowledgeSource(printFilteredRules); Controller.AddKnowledgeSource(weightDialogWithRules); Controller.AddKnowledgeSource(printWeightedDialog); Controller.AddKnowledgeSource(selectHighestWeightedDialog); Controller.AddKnowledgeSource(printHighestWeightedDialog); Controller.AddKnowledgeSource(selectDialogLine); Controller.AddKnowledgeSource(printSelectedDialogLine); Controller.AddKnowledgeSource(updatePrologKB); Controller.AddKnowledgeSource(poolCleaner); }