コード例 #1
0
        /// <summary>Process the output file path.</summary>
        /// <param name="parsedOptions">The parsed options.</param>
        /// <param name="processedOptions">The processed options.</param>
        /// <param name="startingDirectory">The starting directory.</param>
        public void ProcesOutputFilePath(ParsedCommandLineOptions parsedOptions, CommandLineToolOptions processedOptions, string startingDirectory)
        {
            // Without a parsed object and a input file path we can't do anything.
            if (parsedOptions == null || processedOptions == null)
            {
                return;
            }

            // Generate an output-path when none is given.
            if (!string.IsNullOrEmpty(parsedOptions.OutputFilePath))
            {
                // if the GIVEN output-path is not rooted we strip of the filename and tag the directory on it.
                processedOptions.RootedOutputFilePath = Path.IsPathRooted(parsedOptions.OutputFilePath)
                    ? parsedOptions.OutputFilePath
                    : Path.Combine(startingDirectory, parsedOptions.OutputFilePath);
            }
            else
            {
                processedOptions.GeneratedOutputFilePath = Path.ChangeExtension(parsedOptions.InputFilePath, ".ink.json");

                // if the GENERATED output-path is not rooted we strip of the filename and tag the directory on it.
                processedOptions.RootedOutputFilePath = Path.IsPathRooted(processedOptions.GeneratedOutputFilePath)
                    ? processedOptions.GeneratedOutputFilePath
                    : Path.Combine(startingDirectory, processedOptions.GeneratedOutputFilePath);
            }
        }
コード例 #2
0
        /// <summary>Creates the story from the file contents.</summary>
        /// <param name="fileContent">Content of the file.</param>
        /// <param name="options">The options.</param>
        /// <param name="compiler">The compiler.</param>
        /// <param name="compileSuccess">if set to <c>true</c> [compile success].</param>
        /// <param name="finished">if set to <c>true</c> [finished].</param>
        /// <returns></returns>
        public Runtime.IStory CreateStory(string fileContent, CommandLineToolOptions options, out Parsed.Fiction parsedFiction)
        {
            Runtime.IStory story = null;

            if (!options.IsInputFileJson)
            {
                // Loading a normal ink file (as opposed to an already compiled JSON file)
                var compiler = CreateCompiler(fileContent, options);

                if (options.IsOnlyShowJsonStatsActive)
                {
                    ShowStats(compiler, options);
                    parsedFiction = null;
                }
                else
                {
                    //Parsed.Fiction parsedFiction = null;
                    // Full compile
                    story = compiler.Compile(out parsedFiction);
                }
            }
            else
            {
                story         = CreateStoryFromJson(fileContent, options);
                parsedFiction = null;
            }

            return(story);
        }
コード例 #3
0
        /// <summary>Creates the story from JSON.</summary>
        /// <param name="fileContent">Content of the file.</param>
        /// <param name="options">The options.</param>
        /// <returns></returns>
        private Runtime.IStory CreateStoryFromJson(string fileContent, CommandLineToolOptions options)
        {
            // Opening up a compiled JSON file for playing
            var story = EngineInteractor.CreateStoryFromJson(fileContent);

            // No purpose for loading an already compiled file other than to play it
            options.IsPlayMode = true;
            return(story);
        }
コード例 #4
0
        /// <summary>Creates the compiler with specific compiler options.</summary>
        /// <param name="fileContent">Content of the file.</param>
        /// <param name="options">The options.</param>
        /// <returns></returns>
        private IInkCompiler CreateCompiler(string fileContent, CommandLineToolOptions options)
        {
            CompilerOptions compilerOptions = new CompilerOptions
            {
                sourceFilename = options.InputFilePath,
                pluginNames    = options.PluginNames,
                countAllVisits = options.IsCountAllVisitsNeeded,
            };

            return(CompilerInteractor.CreateCompiler(fileContent, compilerOptions));
        }
コード例 #5
0
        /// <summary>Set the output format.</summary>
        /// <param name="options"></param>
        public IToolOutputManagable CreateOuputManager(CommandLineToolOptions options)
        {
            // Set console's output encoding to UTF-8
            ConsoleInteractor.SetEncodingToUtF8();

            if (options.IsJsonOutputNeeded)
            {
                return(new JsonToolOutputManager(ConsoleInteractor));
            }

            return(new ConsoleToolOutputManager(ConsoleInteractor));
        }
コード例 #6
0
        /// <summary>Shows the stats of the compiled story.</summary>
        /// <param name="compiler">The compiler.</param>
        /// <param name="options">The options.</param>
        private void ShowStats(IInkCompiler compiler, CommandLineToolOptions options)
        {
            // Only want stats, don't need to code-gen
            var parsedStory = compiler.Parse();

            // Print any errors
            PrintAllMessages();

            // Generate stats, then print as JSON
            var stats = Stats.Generate(compiler.ParsedFiction);

            OutputManager.ShowStats(options, stats);
        }
コード例 #7
0
        /// <summary>Does a Run with the specified options.</summary>
        /// <param name="options">The options.</param>
        public void Run(CommandLineToolOptions options)
        {
            if (options == null)
            {
                ConsoleInteractor.WriteErrorMessage("Missing options object");
                ConsoleInteractor.EnvironmentExitWithCodeError1();
            }

            // Read the file content
            string fileContent = ReadFileText(toolOptions.InputFileDirectory, toolOptions.InputFileName);

            Parsed.Fiction parsedFiction;
            var            story = CreateStory(fileContent, options, out parsedFiction);

            // If we have a story without errors we have compiled successfully.
            var compileSuccess = !(story == null || Errors.Count > 0);

            OutputManager.ShowCompileSuccess(options, compileSuccess);

            // If we only wanted to show the stats we are done now.
            if (options.IsOnlyShowJsonStatsActive)
            {
                return;
            }


            PrintAllMessages();

            // Without having successfully compiled we can not go on to play or flush JSON.
            if (!compileSuccess)
            {
                ConsoleInteractor.EnvironmentExitWithCodeError1();
            }

            if (options.IsFountainFileOutputNeeded)
            {
                WriteStoryToFountainFile(parsedFiction, options);
            }

            if (options.IsPlayMode)
            {
                PlayStory(story, parsedFiction, options);
            }
            else
            {
                WriteStoryToJsonFile(story, options);
            }
        }
コード例 #8
0
        /// <summary>Writes the compiled story to a Fountain file.</summary>
        /// <param name="story">The story.</param>
        /// <param name="options">The options.</param>
        public void WriteStoryToFountainFile(Parsed.Fiction parsedFiction, CommandLineToolOptions options)
        {
            string fountainContent = FountainExponentialAdapter.ConvertToFountainExponential(parsedFiction, options.InputFileName);

            try
            {
                FileSystemInteractor.WriteAllTextToFile(options.RootedOutputFountainFilePath, fountainContent, System.Text.Encoding.UTF8);

                OutputManager.ShowExportComplete(options);
            }
            catch
            {
                ConsoleInteractor.WriteErrorMessage("Could not write to output file '{0}'", options.RootedOutputFilePath);
                ConsoleInteractor.EnvironmentExitWithCodeError1();
            }
        }
コード例 #9
0
        /// <summary>Writes the compiled story to a JSON file.</summary>
        /// <param name="story">The story.</param>
        /// <param name="options">The options.</param>
        public void WriteStoryToJsonFile(Runtime.IStory story, CommandLineToolOptions options)
        {
            // Compile mode
            var jsonStr = story.ToJson();

            try
            {
                FileSystemInteractor.WriteAllTextToFile(options.RootedOutputFilePath, jsonStr, System.Text.Encoding.UTF8);

                OutputManager.ShowExportComplete(options);
            }
            catch
            {
                ConsoleInteractor.WriteErrorMessage("Could not write to output file '{0}'", options.RootedOutputFilePath);
                ConsoleInteractor.EnvironmentExitWithCodeError1();
            }
        }
コード例 #10
0
        /// <summary>Process the flags by copying them from the parsed options to the processed options so we can always compare them.</summary>
        /// <param name="parsedOptions">The parsed options.</param>
        /// <param name="processedOptions">The processed options.</param>
        public void ProcesFlags(ParsedCommandLineOptions parsedOptions, CommandLineToolOptions processedOptions)
        {
            // Without a parsed object and a input file path we can't do anything.
            if (parsedOptions == null || processedOptions == null)
            {
                return;
            }

            // Most of the flags are not changed while running except for IsPlayMode.
            processedOptions.IsPlayMode                            = parsedOptions.IsPlayMode;
            processedOptions.IsVerboseMode                         = parsedOptions.IsVerboseMode;
            processedOptions.IsCountAllVisitsNeeded                = parsedOptions.IsCountAllVisitsNeeded;
            processedOptions.IsOnlyShowJsonStatsActive             = parsedOptions.IsOnlyShowJsonStatsActive;
            processedOptions.IsJsonOutputNeeded                    = parsedOptions.IsJsonOutputNeeded;
            processedOptions.IsKeepRunningAfterStoryFinishedNeeded = parsedOptions.IsKeepOpenAfterStoryFinishNeeded;
            processedOptions.PluginNames                           = parsedOptions.PluginNames;
        }
コード例 #11
0
        /// <summary>Plays the story.</summary>
        /// <param name="story">The story.</param>
        /// <param name="compiler">The compiler.</param>
        /// <param name="options">The options.</param>
        /// <exception cref="Exception"></exception>
        public void PlayStory(Runtime.IStory story, Parsed.Fiction parsedFiction, CommandLineToolOptions options)
        {
            // Always allow ink external fall-backs
            story.allowExternalFunctionFallbacks = true;

            //Capture a CTRL+C key combo so we can restore the console's foreground color back to normal when exiting
            ConsoleInteractor.ResetColorOnCancelKeyPress();

            try
            {
                ConsoleUserInterfaceOptions uiOptions = new ConsoleUserInterfaceOptions()
                {
                    IsAutoPlayActive = false,
                    IsKeepRunningAfterStoryFinishedNeeded = options.IsKeepRunningAfterStoryFinishedNeeded,
                    IsJsonOutputNeeded = options.IsJsonOutputNeeded
                };
                UserInterface.Begin(story, parsedFiction, uiOptions);
            }
            catch (Runtime.StoryException e)
            {
                if (e.Message.Contains("Missing function binding"))
                {
                    Errors.Add(e.Message);

                    // If you get an error while playing, just print immediately
                    PrintAllMessages();
                }
                else
                {
                    throw e;
                }
            }
            catch (Exception e)
            {
                string storyPath = "<END>";
                var    path      = story.state.currentPathString;
                if (path != null)
                {
                    storyPath = path.ToString();
                }
                throw new Exception(e.Message + " (Internal story path: " + storyPath + ")", e);
            }
        }
コード例 #12
0
        /// <summary>Process the input file path.</summary>
        /// <param name="parsedOptions">The parsed options.</param>
        /// <param name="processedOptions">The processed options.</param>
        /// <param name="startingDirectory">The starting directory.</param>
        public void ProcesInputFilePath(ParsedCommandLineOptions parsedOptions, CommandLineToolOptions processedOptions, string startingDirectory)
        {
            // Without a parsed object and a input file path we can't do anything.
            if (parsedOptions == null || processedOptions == null)
            {
                return;
            }

            processedOptions.InputFilePath = parsedOptions.InputFilePath;

            // Get the file's actual name, needed for reading after the working directory has changed.
            processedOptions.InputFileName = Path.GetFileName(parsedOptions.InputFilePath);

            processedOptions.RootedInputFilePath = Path.IsPathRooted(parsedOptions.InputFilePath)
                ? parsedOptions.InputFilePath
                : Path.Combine(startingDirectory, parsedOptions.InputFilePath);

            processedOptions.InputFileDirectory = Path.GetDirectoryName(processedOptions.RootedInputFilePath);
        }
コード例 #13
0
        /// <summary>Creates the command line tool options.</summary>
        /// <param name="args">The arguments.</param>
        /// <returns></returns>
        private CommandLineToolOptions CreateCommandLineToolOptions(string[] args)
        {
            toolOptions = new CommandLineToolOptions();

            // Getting the current dir early is better in unstable situations.
            string startingDirectory = Directory.GetCurrentDirectory();

            var parsedOptions = new ParsedCommandLineOptions();

#if USE_NETCORE_CONFIGURATION
            IConfigurationRoot config = ReadConfiguration(args, parsedOptions);

            Logger = new LoggerConfiguration()
                     .ReadFrom.Configuration(config)
                     .CreateLogger();

            Logger.Information("Started on {0}", _startTime);
            Logger.Information("Config read.");
            Logger.Debug("Config {@0}", config);
#else
            Logger        = new LoggerConfiguration().CreateLogger();
            parsedOptions = ParseArguments(args, options);
#endif

            if (parsedOptions == null || !parsedOptions.IsInputPathGiven)
            {
                ExitWithUsageInstructions();
            }

            ProcesOutputFilePath(parsedOptions, toolOptions, startingDirectory);
            ProcesOutputFountainFilePath(parsedOptions, toolOptions, startingDirectory);
            ProcesInputFilePath(parsedOptions, toolOptions, startingDirectory);
            ProcesFlags(parsedOptions, toolOptions);

            return(toolOptions);
        }