예제 #1
0
        /// <summary>
        /// Creates a PropNet for the game with the given description.
        /// </summary>
        public static PropNet Create(IList<Expression> description, IComponentFactory componentFactory)
        {
            Console.WriteLine("Building propnet...");

            _componentFactory = componentFactory;
            DateTime startTime = DateTime.UtcNow;

            description = GdlCleaner.Run(description);
            description = DeORer.Run(description);
            description = VariableConstrainer.ReplaceFunctionValuedVariables(description);
            description = Relationizer.Run(description);
            description = CondensationIsolator.Run(description);

            if (Logger.IsDebugEnabled)
                foreach (var gdl in description)
                    Logger.Debug(gdl);

            //We want to start with a rule graph and follow the rule graph. Start by finding general information about the game
            ISentenceDomainModel model = SentenceDomainModelFactory.CreateWithCartesianDomains(description);
            //Restrict domains to values that could actually come up in rules.
            //See chinesecheckers4's "count" relation for an example of why this could be useful.
            model = SentenceDomainModelOptimizer.RestrictDomainsToUsefulValues(model);

            Logger.Debug("Setting constants...");

            //TODO: ConstantChecker constantChecker = ConstantCheckerFactory.createWithForwardChaining(model);
            IConstantChecker constantChecker = ConstantCheckerFactory.CreateWithProver(model);
            Logger.Debug("Done setting constants");

            HashSet<String> sentenceFormNames = SentenceForms.GetNames(model.SentenceForms);
            bool usingBase = sentenceFormNames.Contains("base");
            bool usingInput = sentenceFormNames.Contains("input");

            //For now, we're going to build this to work on those with a particular restriction on the dependency graph:
            //Recursive loops may only contain one sentence form. This describes most games, but not all legal games.
            IDictionary<ISentenceForm, ICollection<ISentenceForm>> dependencyGraph = model.DependencyGraph;
            Logger.Debug("Computing topological ordering... ");

            //ConcurrencyUtils.checkForInterruption();
            IEnumerable<ISentenceForm> topologicalOrdering = GetTopologicalOrdering(model.SentenceForms, dependencyGraph, usingBase, usingInput);
            Logger.Debug("done");

            List<TermObject> roles = GameContainer.GameInformation.GetRoles();
            var components = new Dictionary<Fact, IComponent>();
            var negations = new Dictionary<Fact, IComponent>();
            IConstant trueComponent = _componentFactory.CreateConstant(true);
            IConstant falseComponent = _componentFactory.CreateConstant(false);
            var functionInfoMap = new Dictionary<ISentenceForm, FunctionInfo>();
            var completedSentenceFormValues = new Dictionary<ISentenceForm, ICollection<Fact>>();

            var sentenceFormAdder = new SentenceFormAdder(_componentFactory, DoesProcessor, TrueProcessor, TempFact);

            foreach (ISentenceForm form in topologicalOrdering)
            {
                //ConcurrencyUtils.checkForInterruption();
                Logger.Debug("Adding sentence form " + form);

                if (constantChecker.IsConstantForm(form))
                {
                    Logger.Debug(" (constant)");
                    //Only add it if it's important
                    if (form.Name.Equals(GameContainer.Parser.TokLegal) || form.Name.Equals(GameContainer.Parser.TokGoal)
                                                                            || form.Name.Equals(GameContainer.Parser.TokInit))
                    {
                        //Add it
                        foreach (Fact trueSentence in constantChecker.GetTrueSentences(form))
                        {
                            var trueProp = _componentFactory.CreateProposition(trueSentence);
                            trueProp.AddInput(trueComponent);
                            trueComponent.AddOutput(trueProp);
                            components[trueSentence] = trueComponent;
                        }
                    }

                    Logger.Debug("Checking whether {0} is a functional constant...", form);
                    AddConstantsToFunctionInfo(form, constantChecker, functionInfoMap);
                    AddFormToCompletedValues(form, completedSentenceFormValues, constantChecker);

                    continue;
                }
                Logger.Debug(string.Empty);
                //TODO: Adjust "recursive forms" appropriately
                //Add a temporary sentence form thingy? ...
                var temporaryComponents = new Dictionary<Fact, IComponent>();
                var temporaryNegations = new Dictionary<Fact, IComponent>();

                sentenceFormAdder.AddSentenceForm(form, model, components, negations, trueComponent, falseComponent, usingBase, usingInput,
                    ImmutableHashSet.Create(form), temporaryComponents, temporaryNegations, functionInfoMap, constantChecker,
                    completedSentenceFormValues);

                //TODO: Pass these over groups of multiple sentence forms
                if (temporaryComponents.Any())
                    Logger.Debug("Processing temporary components...");
                ProcessTemporaryComponents(temporaryComponents, temporaryNegations, components, negations, trueComponent, falseComponent);
                AddFormToCompletedValues(form, completedSentenceFormValues, components);

                //TODO: Add this, but with the correct total number of components (not just Propositions)
                Console.WriteLine("  {0} components added", completedSentenceFormValues[form].Count);
            }
            //Connect "next" to "true"
            Logger.Debug("Adding transitions...");
            AddTransitions(components);
            //Set up "init" proposition
            Logger.Debug("Setting up 'init' proposition...");
            SetUpInit(components, trueComponent, falseComponent);
            //Now we can safely...
            RemoveUselessBasePropositions(components, negations, trueComponent, falseComponent);
            Logger.Debug("Creating component set...");
            var componentSet = new HashSet<IComponent>(components.Values);
            CompleteComponentSet(componentSet);
            //ConcurrencyUtils.checkForInterruption();
            Logger.Debug("Initializing propnet object...");
            //Make it look the same as the PropNetFactory results, until we decide how we want it to look
            NormalizePropositions(componentSet);
            var propnet = new PropNet(roles, componentSet);

            Logger.Debug("Done setting up propnet; took {0}ms, has {1} components and {2} links", (DateTime.UtcNow - startTime).TotalMilliseconds, componentSet.Count, propnet.GetNumLinks());
            Logger.Debug("Propnet has {0} ands; {1} ors; {2} nots", propnet.GetNumAnds(), propnet.GetNumOrs(), propnet.GetNumNots());

            if (ConfigurationManager.AppSettings["OutputPropNet"] == "true")
                propnet.RenderToFile("propnet.dot");

            return propnet;
        }