コード例 #1
0
 public void Generator_GenerateOutputFiles()
 {
     string rootPath = @"C:\Users\kwan\Documents\GitHub\ContentPress\Source\ContentPress\ContentPress.App\Project";
     SiteGenerator sg = new SiteGenerator(rootPath);
     var files = sg.GetContentFiles();
     var result = sg.GenerateOutputFiles(files);
 }
コード例 #2
0
        public async Task Handle()
        {
            var expirationTime = DateTime.UtcNow.Add(ExpirationPeriod);

            var provider  = new DynamoDBImageProvider(_dynamoDb, _s3Images, BucketNames.Images, expirationTime);
            var generator = new SiteGenerator(provider);

            var site = await generator.GenerateAsync();

            var storer = new S3SiteStorer(_s3Site, BucketNames.Site, expirationTime);
            await storer.StoreAsync(site);
        }
コード例 #3
0
        public void DeleteThisWhenTheServiceIsRunning_generatePages()
        {
            var contentGenerator = new ContentGenerator();

            var filesystemRepository = new HtmlWriter(baseUrl);

            var documentParser = new DocumentParser();

            var siteGenerator = new SiteGenerator(
                contentGenerator,
                filesystemRepository,
                documentParser,
                new MarkDownMutator(filesystemRepository, contentGenerator));

            siteGenerator.GenerateSite(new ReadWritePaths(readPath, writePath), baseUrl, editBaseUrl);
        }
コード例 #4
0
        public void GenerateSite(Configuration configuration, FilesystemRepository filesystemRepository)
        {
            var contentGenerator     = new ContentGenerator();
            var extractor            = new TagsExtractor(filesystemRepository);
            var htmlTransformer      = new MarkdownToHtml();
            var expandTagsToMarkdown = new ExpandTagsToMarkdown(filesystemRepository);
            var readMdAndWriteHtml   = new ReadMdAndWriteHtml(filesystemRepository, contentGenerator, htmlTransformer, expandTagsToMarkdown);

            var siteGenerator = new SiteGenerator(
                contentGenerator,
                filesystemRepository,
                extractor,
                readMdAndWriteHtml,
                htmlTransformer);

            siteGenerator.Execute(configuration, baseUrl, editBaseUrl);
        }
コード例 #5
0
        static void Main(string[] args)
        {
            var options = (Parser.Default.ParseArguments <Options>(args) as Parsed <Options>)?.Value;

            if (options == null)
            {
                return;
            }

            Console.WriteLine("================ 開始 ================");

            var ganerator = new SiteGenerator(options.SourcePath, options.DestinationPath, options.IsPreviewMode);

            ganerator.PageGenerated += page => Console.WriteLine($"ページ変換: {page.Content.Title}");
            ganerator.Generate();

            Console.WriteLine("================ 完了 ================");
        }
コード例 #6
0
    public void Generate(int _type, float size, int _numberOfSites, float _mainRoadWidth, float _sideRoadWidth)
    {
        lStreets = new List <GameObject>();
        siteGen  = GetComponent <SiteGenerator>();
        vBuilder = GetComponent <VoronoiBuilder>();
        Ground.transform.localScale = new Vector3(size, 0.01f, size);
        groundRad     = size / 2f;
        numberOfSites = _numberOfSites;
        mainRoadWidth = _mainRoadWidth;
        sideRoadWidth = _sideRoadWidth;
        type          = (GenerationType)_type;


        List <Vector2> sites = new List <Vector2>();

        switch (type)
        {
        case GenerationType.Orgnic:
            sites = siteGen.GenerateRandom(new Vector2(Ground.transform.position.x, Ground.transform.position.z), groundRad, width, height, numberOfSites);
            break;

        case GenerationType.Circular:
            sites = siteGen.GenerateCircular(height, width, groundRad, new Vector2(Ground.transform.position.x, Ground.transform.position.z), 3, numberOfSites);
            break;

        case GenerationType.Grid:
            sites = siteGen.GenerateGrid(new Vector2(Ground.transform.position.x, Ground.transform.position.z), groundRad, 400, 400);
            break;

        default:
            break;
        }



        List <Edge> vEdges = vBuilder.GenerateVoronoi(sites, new Vector2(Ground.transform.position.x, Ground.transform.position.z), groundRad);
        int         i      = 0;

        for (i = 0; i < vEdges.Count; i++)
        {
            // check to see if the curent edge is entirely out of the worldbound
            if (CheckWholeEdge(vEdges[i]))
            {
                continue;
            }
            if (!CheckPositiontoWorldBounds(vEdges[i].start))
            {
                Vector2[] inter = EdgeToCircleIntersection(vEdges[i]);


                float dis1 = Vector2.Distance(vEdges[i].start, inter[0]);
                float dis2 = Vector2.Distance(vEdges[i].start, inter[1]);

                if (dis1 < dis2)
                {
                    vEdges[i].start = inter[0];
                }
                else
                {
                    vEdges[i].start = inter[1];
                }
            }
            if (!CheckPositiontoWorldBounds(vEdges[i].end))
            {
                Vector2[] inter = EdgeToCircleIntersection(vEdges[i]);


                float dis1 = Vector2.Distance(vEdges[i].start, inter[0]);
                float dis2 = Vector2.Distance(vEdges[i].start, inter[1]);

                if (dis1 < dis2)
                {
                    vEdges[i].end = inter[0];
                }
                else
                {
                    vEdges[i].end = inter[1];
                }
            }
            GameObject newMainRoad = Instantiate(mainRoadPF, new Vector3(vEdges[i].start.x, 0.1f, vEdges[i].start.y), Quaternion.identity);
            newMainRoad.GetComponent <MeshBuilderVoronoi>().GenerateMesh(vEdges[i].start, vEdges[i].end, mainRoadWidth);
            newMainRoad.transform.rotation = Quaternion.LookRotation(new Vector3(vEdges[i].ndir.x, 0, vEdges[i].ndir.y));
            newMainRoad.name = vEdges[i].LR;
            newMainRoad.GetComponent <AttachPoints>().CreateAttachPoints(Vector3.Distance(vEdges[i].start, vEdges[i].end), 5);

            Vector2 midPoint = new Vector2((vEdges[i].start.x + vEdges[i].end.x) / 2, (vEdges[i].start.y + vEdges[i].end.y) / 2f);
            Vector2 rotation = Vector2.Perpendicular(vEdges[i].ndir);

            GameObject       t  = Instantiate(turtlePf, new Vector3(midPoint.x, 0.1f, midPoint.y), Quaternion.LookRotation(new Vector3(rotation.x, 0, rotation.y)));
            TurtleController tc = t.GetComponent <TurtleController>();
            tc.streeWidth  = sideRoadWidth;
            tc.startStreet = newMainRoad;
            if (type == GenerationType.Circular)
            {
                float disToMid = Vector2.Distance(midPoint, Ground.transform.position);
                float p        = disToMid * 100 / groundRad;
                int   itt      = 0;
                if (p < 33.3f)
                {
                    itt = 3;
                }
                else if (p < 66.6f)
                {
                    itt = 2;
                }
                else
                {
                    itt = 1;
                }

                tc.Generate(itt);
            }
            else
            {
                tc.Generate(1);
            }
        }
    }
コード例 #7
0
        public static int Main(string[] args)
        {
            IOptions options = new Options();

            if (!CommandLine.Parser.Default.ParseArguments(args, options))
            {
                ErrorWriterContext.Current.WriteLine(options.GetUsage());
                return(Constants.ERROR);
            }
            OptionsContext.Current = new ProgramOptionsContext(options);


            if (IOContext.Current.DirectoryExists(OptionsContext.Current.Options.OutputDirectory))
            {
                if (!OptionsContext.Current.Options.Force)
                {
                    ErrorWriterContext.Current.WriteLine(Invariant($"Output Directory '{OptionsContext.Current.Options.OutputDirectory}' already exists in the current folder."));
                    return(Constants.ERROR);
                }
                else
                {
                    System.IO.Directory.Delete(OptionsContext.Current.Options.OutputDirectory, true);
                }
            }

            // Metadata Providers
            IMetadataProvider fragmentMetadataProvider = new MetadataProvider(LayoutType.Fragment);
            IMetadataProvider pageMetadataProvider     = new MetadataProvider(LayoutType.Page);
            IMetadataProvider blogPostMetadataProvider = new MetadataProvider(LayoutType.Post);

            // Page Providers
            FragmentProvider fragmentProvider = new FragmentProvider(fragmentMetadataProvider);
            PageProvider     pageProvider     = new PageProvider(pageMetadataProvider);
            BlogPostProvider blogPostProvider = new BlogPostProvider(blogPostMetadataProvider);
            // IDEA: have option to pick between static page and first blog page?
            // TODO: make "Blog" an optional header page that takes the user to the latest blog post

            IFragmentComposer fragmentComposer = new FragmentComposer(fragmentProvider, pageProvider);
            IReadOnlyDictionary <string, Func <LayoutType, HtmlAgilityPack.HtmlDocument> > fragmentComposingFunctions = fragmentComposer.FragmentComposingFunctions;

            // Composers
            ITemplateComposer pageComposer     = new PageComposer(pageProvider, fragmentComposingFunctions);
            ITemplateComposer blogPostComposer = new BlogComposer(blogPostProvider, fragmentComposingFunctions);

            IList <IGenerator> generators = new List <IGenerator>()
            {
                new BasePageGenerator(pageComposer),
                new BasePageGenerator(blogPostComposer)
            };

            IGenerator siteGenerator = new SiteGenerator(generators);

            try
            {
                siteGenerator.Generate();
            }
            catch
            {
                // Other places that throw should write out an error message
                return(Constants.ERROR);
            }

            return(Constants.SUCCESS);
        }
コード例 #8
0
ファイル: Program.cs プロジェクト: speedsticko/ContentPress
        static void Main(string[] args)
        {
            var parameters = GetParameters(args);

            string rootPath = parameters.ProjectRoot;

            if (parameters.Generate)
            {
                SiteGenerator sg = new SiteGenerator(rootPath);
                DatabaseAddin dbAddin = new DatabaseAddin();
                SeedDatabaseAddin seedAddin = new SeedDatabaseAddin();
                sg.BeforeGenerateSite += new SiteGenerator.BeforeGenerateSiteHandler(seedAddin.BeforeGenerateSiteHandler);
                sg.BeforeGenerateContent += new SiteGenerator.BeforeGenerateContentHandler(dbAddin.BeforeContentHandler);

                var files = sg.GetContentFiles();
                var result = sg.GenerateOutputFiles(files);
                Console.WriteLine("Generated static site.");
            }

            if (Debugger.IsAttached)
            {
                Console.ReadLine();
            }
        }
コード例 #9
0
 // Use this for initialization
 void Start()
 {
     sites         = new List <Site>();
     edges         = new HashSet <VoronoiEdge>();
     siteGenerator = GameObject.Find("SiteGenerator").GetComponent <SiteGenerator>();
 }