Esempio n. 1
0
        static bool GenerateMap(MapGenArgs genArgs)
        {
            MapGenTheme theme = MapGenTheme.Forest;

            if (genArgs.Args.Length > 0 &&
                !CommandParser.GetEnum(genArgs.Player, genArgs.Args, "Seed", ref theme))
            {
                return(false);
            }

            MapGenTemplate         templ = (MapGenTemplate)Enum.Parse(typeof(MapGenTemplate), genArgs.Theme.Substring(3), true);
            fCraftMapGeneratorArgs args  = fCraftMapGeneratorArgs.MakeTemplate(templ);
            Level map = genArgs.Level;

            float ratio = map.Height / 96.0f;

            args.MaxHeight    = (int)Math.Round(args.MaxHeight * ratio);
            args.MaxDepth     = (int)Math.Round(args.MaxDepth * ratio);
            args.SnowAltitude = (int)Math.Round(args.SnowAltitude * ratio);

            args.Theme      = theme;
            args.AddTrees   = theme == MapGenTheme.Forest;
            args.AddWater   = theme != MapGenTheme.Desert;
            args.WaterLevel = (map.Height - 1) / 2;

            fCraftMapGenerator generator = new fCraftMapGenerator(args);

            generator.Generate(map);
            return(true);
        }
Esempio n. 2
0
        static bool GenerateMap(MapGenArgs genArgs)
        {
            MapGenTheme theme = MapGenTheme.Forest;

            if (genArgs.Args != "" && !Utils.TryParseEnum(genArgs.Args, out theme))
            {
                string[] themes = Enum.GetNames(typeof(MapGenTheme));
                Player.Message(genArgs.Player, "Seed must be one of the following themes: " + themes.Join());
                return(false);
            }

            MapGenTemplate         templ = (MapGenTemplate)Enum.Parse(typeof(MapGenTemplate), genArgs.Theme.Substring(3), true);
            fCraftMapGeneratorArgs args  = fCraftMapGeneratorArgs.MakeTemplate(templ);
            Level map = genArgs.Level;

            float ratio = map.Height / 96.0f;

            args.MaxHeight    = (int)Math.Round(args.MaxHeight * ratio);
            args.MaxDepth     = (int)Math.Round(args.MaxDepth * ratio);
            args.SnowAltitude = (int)Math.Round(args.SnowAltitude * ratio);

            args.Theme      = theme;
            args.AddTrees   = theme == MapGenTheme.Forest;
            args.AddWater   = theme != MapGenTheme.Desert;
            args.WaterLevel = (map.Height - 1) / 2;

            fCraftMapGenerator generator = new fCraftMapGenerator(args);

            generator.Generate(map);
            return(true);
        }
Esempio n. 3
0
        static bool Gen(Player p, Level lvl, string seed, MapGenTheme theme)
        {
            MapGenBiome biome = MapGenBiome.Forest;

            if (seed.Length > 0 && !CommandParser.GetEnum(p, seed, "Seed", ref biome))
            {
                return(false);
            }
            fCraftMapGenArgs args = fCraftMapGenArgs.MakeTemplate(theme);

            float ratio = lvl.Height / 96.0f;

            args.MaxHeight    = (int)Math.Round(args.MaxHeight * ratio);
            args.MaxDepth     = (int)Math.Round(args.MaxDepth * ratio);
            args.SnowAltitude = (int)Math.Round(args.SnowAltitude * ratio);

            args.Biome      = biome;
            args.AddTrees   = biome == MapGenBiome.Forest;
            args.AddWater   = biome != MapGenBiome.Desert;
            args.WaterLevel = (lvl.Height - 1) / 2;

            new fCraftMapGen(args).Generate(lvl);
            args.ApplyEnv(lvl.Config);
            return(true);
        }
Esempio n. 4
0
        public static void RegisterGenerators()
        {
            string[] names = Enum.GetNames(typeof(MapGenBiome));
            string   desc  = "%HSeed specifies biome of the map. " +
                             "It must be one of the following: &f" + names.Join();

            for (MapGenTheme theme = 0; theme < MapGenTheme.Count; theme++)
            {
                // Because of the way C# implements for loop closures, '=> Gen(p, lvl, seed, theme_)'
                //  captures the variable from the LAST iteration, not the current one
                // Hence this causes an error to get thrown later, because 'Gen' is always executed
                //  with 'MapGenTheme.Count' theme instead of the expected theme
                // Using a local variable copy fixes this
                MapGenTheme theme_ = theme;

                MapGen.Register(theme_.ToString(), GenType.fCraft,
                                (p, lvl, seed) => Gen(p, lvl, seed, theme_), desc);
            }
        }
Esempio n. 5
0
        public void ApplyTheme(MapGenTheme theme)
        {
            // base defaults ("Grass")
            SurfaceThickness = 1;
            SoilThickness    = 5;
            BedrockThickness = 1;
            AirBlock         = Block.Air;
            SurfaceBlock     = Block.Grass;
            ShallowBlock     = Block.Dirt;
            DeepBlock        = Block.Stone;
            BedrockBlock     = Block.Admincrete;

            Preset = theme.ToString();
            switch (theme)
            {
            case MapGenTheme.Arctic:
                DeepBlock        = Block.White;
                SurfaceThickness = 0;
                SoilThickness    = 0;
                break;

            case MapGenTheme.Desert:
                DeepBlock        = Block.Sand;
                SurfaceThickness = 0;
                SoilThickness    = 0;
                break;

            case MapGenTheme.Hell:
                DeepBlock        = Block.Obsidian;
                SurfaceThickness = 0;
                SoilThickness    = 0;
                break;

            case MapGenTheme.Swamp:
                SurfaceBlock = Block.Dirt;
                break;
            }
            // TODO: actually add trees in "Forest" mode
        }
Esempio n. 6
0
        public void ApplyTheme(MapGenTheme theme) {
            // base defaults ("Grass")
            SurfaceThickness = 1;
            SoilThickness = 5;
            BedrockThickness = 1;
            AirBlock = Block.Air;
            SurfaceBlock = Block.Grass;
            ShallowBlock = Block.Dirt;
            DeepBlock = Block.Stone;
            BedrockBlock = Block.Admincrete;

            Preset = theme.ToString();
            switch (theme) {
                case MapGenTheme.Arctic:
                    DeepBlock = Block.White;
                    SurfaceThickness = 0;
                    SoilThickness = 0;
                    break;
                case MapGenTheme.Desert:
                    DeepBlock = Block.Sand;
                    SurfaceThickness = 0;
                    SoilThickness = 0;
                    break;
                case MapGenTheme.Hell:
                    DeepBlock = Block.Obsidian;
                    SurfaceThickness = 0;
                    SoilThickness = 0;
                    break;
                case MapGenTheme.Swamp:
                    SurfaceBlock = Block.Dirt;
                    break;
            }
            // TODO: actually add trees in "Forest" mode
        }
Esempio n. 7
0
        public static RealisticMapGenParameters CreateParameters(RealisticMapGenTerrainType terrainType,
                                                                 MapGenTheme theme)
        {
            RealisticMapGenParameters genParams;

            switch (terrainType)
            {
            case RealisticMapGenTerrainType.Archipelago:
                genParams = new RealisticMapGenParameters {
                    MaxHeight          = 8,
                    MaxDepth           = 20,
                    FeatureScale       = 3,
                    Roughness          = .46f,
                    MatchWaterCoverage = true,
                    WaterCoverage      = .85f
                };
                break;

            case RealisticMapGenTerrainType.Atoll:
                genParams = new RealisticMapGenParameters {
                    Theme              = new RealisticMapGenBlockTheme(MapGenTheme.Desert),
                    MaxHeight          = 2,
                    MaxDepth           = 39,
                    UseBias            = true,
                    Bias               = .9f,
                    MidPoint           = 1,
                    LoweredCorners     = 4,
                    FeatureScale       = 2,
                    DetailScale        = 5,
                    MarbledHeightmap   = true,
                    InvertHeightmap    = true,
                    MatchWaterCoverage = true,
                    WaterCoverage      = .95f
                };
                break;

            case RealisticMapGenTerrainType.Bay:
                genParams = new RealisticMapGenParameters {
                    MaxHeight        = 22,
                    MaxDepth         = 12,
                    UseBias          = true,
                    Bias             = 1,
                    MidPoint         = -1,
                    RaisedCorners    = 3,
                    LoweredCorners   = 1,
                    TreeSpacingMax   = 12,
                    TreeSpacingMin   = 6,
                    MarbledHeightmap = true,
                    DelayBias        = true
                };
                break;

            case RealisticMapGenTerrainType.Dunes:
                genParams = new RealisticMapGenParameters {
                    AddTrees         = false,
                    AddWater         = false,
                    Theme            = new RealisticMapGenBlockTheme(MapGenTheme.Desert),
                    MaxHeight        = 12,
                    MaxDepth         = 7,
                    FeatureScale     = 2,
                    DetailScale      = 3,
                    Roughness        = .44f,
                    MarbledHeightmap = true,
                    InvertHeightmap  = true
                };
                break;

            case RealisticMapGenTerrainType.Hills:
                genParams = new RealisticMapGenParameters {
                    AddWater       = false,
                    MaxHeight      = 8,
                    MaxDepth       = 8,
                    FeatureScale   = 2,
                    TreeSpacingMin = 7,
                    TreeSpacingMax = 13
                };
                break;

            case RealisticMapGenTerrainType.Ice:
                genParams = new RealisticMapGenParameters {
                    Theme              = new RealisticMapGenBlockTheme(MapGenTheme.Arctic),
                    AddTrees           = false,
                    MaxHeight          = 2,
                    MaxDepth           = 2032,
                    FeatureScale       = 2,
                    DetailScale        = 7,
                    Roughness          = .64f,
                    MarbledHeightmap   = true,
                    MatchWaterCoverage = true,
                    WaterCoverage      = .3f,
                    MaxHeightVariation = 0
                };
                break;

            case RealisticMapGenTerrainType.Island:
                genParams = new RealisticMapGenParameters {
                    MaxHeight        = 16,
                    MaxDepth         = 39,
                    UseBias          = true,
                    Bias             = .7f,
                    MidPoint         = 1,
                    LoweredCorners   = 4,
                    FeatureScale     = 3,
                    DetailScale      = 7,
                    MarbledHeightmap = true,
                    DelayBias        = true,
                    AddBeaches       = true,
                    Roughness        = 0.45f
                };
                break;

            case RealisticMapGenTerrainType.Lake:
                genParams = new RealisticMapGenParameters {
                    MaxHeight          = 14,
                    MaxDepth           = 20,
                    UseBias            = true,
                    Bias               = .65f,
                    MidPoint           = -1,
                    RaisedCorners      = 4,
                    FeatureScale       = 2,
                    Roughness          = .56f,
                    MatchWaterCoverage = true,
                    WaterCoverage      = .3f
                };
                break;

            case RealisticMapGenTerrainType.Mountains:
                genParams = new RealisticMapGenParameters {
                    AddWater           = false,
                    MaxHeight          = 40,
                    MaxDepth           = 10,
                    FeatureScale       = 1,
                    DetailScale        = 7,
                    MarbledHeightmap   = true,
                    AddSnow            = true,
                    MatchWaterCoverage = true,
                    WaterCoverage      = .5f,
                    Roughness          = .55f,
                    CliffThreshold     = .9f
                };
                break;

            case RealisticMapGenTerrainType.Defaults:
                genParams = new RealisticMapGenParameters();
                break;

            case RealisticMapGenTerrainType.River:
                genParams = new RealisticMapGenParameters {
                    MaxHeight          = 22,
                    MaxDepth           = 8,
                    FeatureScale       = 0,
                    DetailScale        = 6,
                    MarbledHeightmap   = true,
                    MatchWaterCoverage = true,
                    WaterCoverage      = .31f
                };
                break;

            case RealisticMapGenTerrainType.Streams:
                genParams = new RealisticMapGenParameters {
                    MaxHeight          = 5,
                    MaxDepth           = 4,
                    FeatureScale       = 2,
                    DetailScale        = 7,
                    Roughness          = .55f,
                    MarbledHeightmap   = true,
                    MatchWaterCoverage = true,
                    WaterCoverage      = .25f,
                    TreeSpacingMin     = 8,
                    TreeSpacingMax     = 14
                };
                break;

            case RealisticMapGenTerrainType.Peninsula:
                genParams = new RealisticMapGenParameters {
                    MaxHeight       = 22,
                    MaxDepth        = 12,
                    UseBias         = true,
                    Bias            = .5f,
                    MidPoint        = -1,
                    RaisedCorners   = 3,
                    LoweredCorners  = 1,
                    TreeSpacingMax  = 12,
                    TreeSpacingMin  = 6,
                    InvertHeightmap = true,
                    WaterCoverage   = .5f
                };
                break;

            case RealisticMapGenTerrainType.Flat:
                genParams = new RealisticMapGenParameters {
                    MaxHeight          = 0,
                    MaxDepth           = 0,
                    MaxHeightVariation = 0,
                    AddWater           = false,
                    DetailScale        = 0,
                    FeatureScale       = 0,
                    AddCliffs          = false
                };
                break;

            default:
                throw new ArgumentOutOfRangeException("terrainType");
            }

            genParams.Theme = new RealisticMapGenBlockTheme(theme);
            switch (theme)
            {
            case MapGenTheme.Arctic:
            case MapGenTheme.Desert:
            case MapGenTheme.Grass:
            case MapGenTheme.Hell:
                genParams.AddTrees = false;
                break;
            }
            return(genParams);
        }
        public RealisticMapGenBlockTheme(MapGenTheme theme)
        {
            GroundThickness   = 5;
            SeaFloorThickness = 3;
            AirBlock          = Block.Air;
            SnowBlock         = Block.White;
            BaseTheme         = theme;

            switch (theme)
            {
            case MapGenTheme.Arctic:
                WaterSurfaceBlock     = Block.Glass;
                DeepWaterSurfaceBlock = Block.Water;
                GroundSurfaceBlock    = Block.White;
                WaterBlock            = Block.Water;
                GroundBlock           = Block.White;
                SeaFloorBlock         = Block.White;
                BedrockBlock          = Block.Stone;
                CliffBlock            = Block.Stone;
                GroundThickness       = 1;
                break;

            case MapGenTheme.Desert:
                WaterSurfaceBlock     = Block.Water;
                DeepWaterSurfaceBlock = Block.Water;
                GroundSurfaceBlock    = Block.Sand;
                WaterBlock            = Block.Water;
                GroundBlock           = Block.Sand;
                SeaFloorBlock         = Block.Sand;
                BedrockBlock          = Block.Stone;
                CliffBlock            = Block.Gravel;
                break;

            case MapGenTheme.Hell:
                WaterSurfaceBlock     = Block.Lava;
                DeepWaterSurfaceBlock = Block.Lava;
                GroundSurfaceBlock    = Block.Obsidian;
                WaterBlock            = Block.Lava;
                GroundBlock           = Block.Stone;
                SeaFloorBlock         = Block.Obsidian;
                BedrockBlock          = Block.Stone;
                CliffBlock            = Block.Stone;
                break;

            case MapGenTheme.Forest:
            case MapGenTheme.Grass:
                WaterSurfaceBlock     = Block.Water;
                DeepWaterSurfaceBlock = Block.Water;
                GroundSurfaceBlock    = Block.Grass;
                WaterBlock            = Block.Water;
                GroundBlock           = Block.Dirt;
                SeaFloorBlock         = Block.Sand;
                BedrockBlock          = Block.Stone;
                CliffBlock            = Block.Stone;
                break;

            case MapGenTheme.Swamp:
                WaterSurfaceBlock     = Block.Water;
                DeepWaterSurfaceBlock = Block.Water;
                GroundSurfaceBlock    = Block.Dirt;
                WaterBlock            = Block.Water;
                GroundBlock           = Block.Dirt;
                SeaFloorBlock         = Block.Leaves;
                BedrockBlock          = Block.Stone;
                CliffBlock            = Block.Stone;
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Esempio n. 9
0
        public MapGeneratorArgs( [NotNull] string fileName ) {
            if( fileName == null ) throw new ArgumentNullException( "fileName" );
            XDocument doc = XDocument.Load( fileName );
            XElement root = doc.Root;

            XAttribute versionTag = root.Attribute( "version" );
            int version = 0;
            if( versionTag != null && !String.IsNullOrEmpty(versionTag.Value) ) {
                version = Int32.Parse( versionTag.Value );
            }

            Theme = (MapGenTheme)Enum.Parse( typeof( MapGenTheme ), root.Element( "theme" ).Value, true );
            Seed = Int32.Parse( root.Element( "seed" ).Value );
            MapWidth = Int32.Parse( root.Element( "dimX" ).Value );
            MapLength = Int32.Parse( root.Element( "dimY" ).Value );
            MapHeight = Int32.Parse( root.Element( "dimH" ).Value );
            MaxHeight = Int32.Parse( root.Element( "maxHeight" ).Value );
            MaxDepth = Int32.Parse( root.Element( "maxDepth" ).Value );

            AddWater = Boolean.Parse( root.Element( "addWater" ).Value );
            if( root.Element( "customWaterLevel" ) != null ) CustomWaterLevel = Boolean.Parse( root.Element( "customWaterLevel" ).Value );
            MatchWaterCoverage = Boolean.Parse( root.Element( "matchWaterCoverage" ).Value );
            WaterLevel = Int32.Parse( root.Element( "waterLevel" ).Value );
            WaterCoverage = float.Parse( root.Element( "waterCoverage" ).Value );

            UseBias = Boolean.Parse( root.Element( "useBias" ).Value );
            if( root.Element( "delayBias" ) != null ) DelayBias = Boolean.Parse( root.Element( "delayBias" ).Value );
            Bias = float.Parse( root.Element( "bias" ).Value );
            RaisedCorners = Int32.Parse( root.Element( "raisedCorners" ).Value );
            LoweredCorners = Int32.Parse( root.Element( "loweredCorners" ).Value );
            MidPoint = Int32.Parse( root.Element( "midPoint" ).Value );

            if( version == 0 ) {
                DetailScale = Int32.Parse( root.Element( "minDetailSize" ).Value );
                FeatureScale = Int32.Parse( root.Element( "maxDetailSize" ).Value );
            } else {
                DetailScale = Int32.Parse( root.Element( "detailScale" ).Value );
                FeatureScale = Int32.Parse( root.Element( "featureScale" ).Value );
            }
            Roughness = float.Parse( root.Element( "roughness" ).Value );
            LayeredHeightmap = Boolean.Parse( root.Element( "layeredHeightmap" ).Value );
            MarbledHeightmap = Boolean.Parse( root.Element( "marbledHeightmap" ).Value );
            InvertHeightmap = Boolean.Parse( root.Element( "invertHeightmap" ).Value );
            if( root.Element( "aboveFuncExponent" ) != null ) AboveFuncExponent = float.Parse( root.Element( "aboveFuncExponent" ).Value );
            if( root.Element( "belowFuncExponent" ) != null ) BelowFuncExponent = float.Parse( root.Element( "belowFuncExponent" ).Value );

            AddTrees = Boolean.Parse( root.Element( "addTrees" ).Value );
            TreeSpacingMin = Int32.Parse( root.Element( "treeSpacingMin" ).Value );
            TreeSpacingMax = Int32.Parse( root.Element( "treeSpacingMax" ).Value );
            TreeHeightMin = Int32.Parse( root.Element( "treeHeightMin" ).Value );
            TreeHeightMax = Int32.Parse( root.Element( "treeHeightMax" ).Value );

            if( root.Element( "addCaves" ) != null ) {
                AddCaves = Boolean.Parse( root.Element( "addCaves" ).Value );
                AddCaveLava = Boolean.Parse( root.Element( "addCaveLava" ).Value );
                AddCaveWater = Boolean.Parse( root.Element( "addCaveWater" ).Value );
                AddOre = Boolean.Parse( root.Element( "addOre" ).Value );
                CaveDensity = float.Parse( root.Element( "caveDensity" ).Value );
                CaveSize = float.Parse( root.Element( "caveSize" ).Value );
            }

            if( root.Element( "addSnow" ) != null ) AddSnow = Boolean.Parse( root.Element( "addSnow" ).Value );
            if( root.Element( "snowAltitude" ) != null ) SnowAltitude = Int32.Parse( root.Element( "snowAltitude" ).Value );
            if( root.Element( "snowTransition" ) != null ) SnowTransition = Int32.Parse( root.Element( "snowTransition" ).Value );

            if( root.Element( "addCliffs" ) != null ) AddCliffs = Boolean.Parse( root.Element( "addCliffs" ).Value );
            if( root.Element( "cliffSmoothing" ) != null ) CliffSmoothing = Boolean.Parse( root.Element( "cliffSmoothing" ).Value );
            if( root.Element( "cliffThreshold" ) != null ) CliffThreshold = float.Parse( root.Element( "cliffThreshold" ).Value );

            if( root.Element( "addBeaches" ) != null ) AddBeaches = Boolean.Parse( root.Element( "addBeaches" ).Value );
            if( root.Element( "beachExtent" ) != null ) BeachExtent = Int32.Parse( root.Element( "beachExtent" ).Value );
            if( root.Element( "beachHeight" ) != null ) BeachHeight = Int32.Parse( root.Element( "beachHeight" ).Value );

            if( root.Element( "maxHeightVariation" ) != null ) MaxHeightVariation = Int32.Parse( root.Element( "maxHeightVariation" ).Value );
            if( root.Element( "maxDepthVariation" ) != null ) MaxDepthVariation = Int32.Parse( root.Element( "maxDepthVariation" ).Value );

            if( root.Element( "addGiantTrees" ) != null ) AddGiantTrees = Boolean.Parse( root.Element( "addGiantTrees" ).Value );

            Validate();
        }
Esempio n. 10
0
        public static fCraftMapGenArgs MakeTemplate(MapGenTheme template)
        {
            switch (template)
            {
            case MapGenTheme.Archipelago:
                return(new fCraftMapGenArgs {
                    MaxHeight = 8,
                    MaxDepth = 20,
                    FeatureScale = 3,
                    Roughness = .46f,
                    MatchWaterCoverage = true,
                    WaterCoverage = .85f
                });

            case MapGenTheme.Atoll:
                return(new fCraftMapGenArgs {
                    Biome = MapGenBiome.Desert,
                    MaxHeight = 2,
                    MaxDepth = 39,
                    UseBias = true,
                    Bias = .9f,
                    MidPoint = 1,
                    LoweredCorners = 4,
                    FeatureScale = 2,
                    DetailScale = 5,
                    MarbledHeightmap = true,
                    InvertHeightmap = true,
                    MatchWaterCoverage = true,
                    WaterCoverage = .95f
                });

            case MapGenTheme.Bay:
                return(new fCraftMapGenArgs {
                    MaxHeight = 22,
                    MaxDepth = 12,
                    UseBias = true,
                    Bias = 1,
                    MidPoint = -1,
                    RaisedCorners = 3,
                    LoweredCorners = 1,
                    TreeSpacingMax = 12,
                    TreeSpacingMin = 6,
                    MarbledHeightmap = true,
                    DelayBias = true
                });

            case MapGenTheme.Dunes:
                return(new fCraftMapGenArgs {
                    AddTrees = false,
                    AddWater = false,
                    Biome = MapGenBiome.Desert,
                    MaxHeight = 12,
                    MaxDepth = 7,
                    FeatureScale = 2,
                    DetailScale = 3,
                    Roughness = .44f,
                    MarbledHeightmap = true,
                    InvertHeightmap = true
                });

            case MapGenTheme.Hills:
                return(new fCraftMapGenArgs {
                    AddWater = false,
                    MaxHeight = 8,
                    MaxDepth = 8,
                    FeatureScale = 2,
                    TreeSpacingMin = 7,
                    TreeSpacingMax = 13
                });

            case MapGenTheme.Ice:
                return(new fCraftMapGenArgs {
                    AddTrees = false,
                    Biome = MapGenBiome.Arctic,
                    MaxHeight = 2,
                    MaxDepth = 2032,
                    FeatureScale = 2,
                    DetailScale = 7,
                    Roughness = .64f,
                    MarbledHeightmap = true,
                    MatchWaterCoverage = true,
                    WaterCoverage = .3f,
                    MaxHeightVariation = 0
                });

            case MapGenTheme.Island2:
                return(new fCraftMapGenArgs {
                    MaxHeight = 16,
                    MaxDepth = 39,
                    UseBias = true,
                    Bias = .7f,
                    MidPoint = 1,
                    LoweredCorners = 4,
                    FeatureScale = 3,
                    DetailScale = 7,
                    MarbledHeightmap = true,
                    DelayBias = true,
                    AddBeaches = true,
                    Roughness = 0.45f
                });

            case MapGenTheme.Lake:
                return(new fCraftMapGenArgs {
                    MaxHeight = 14,
                    MaxDepth = 20,
                    UseBias = true,
                    Bias = .65f,
                    MidPoint = -1,
                    RaisedCorners = 4,
                    FeatureScale = 2,
                    Roughness = .56f,
                    MatchWaterCoverage = true,
                    WaterCoverage = .3f
                });

            case MapGenTheme.Mountains2:
                return(new fCraftMapGenArgs {
                    AddWater = false,
                    MaxHeight = 40,
                    MaxDepth = 10,
                    FeatureScale = 1,
                    DetailScale = 7,
                    MarbledHeightmap = true,
                    AddSnow = true,
                    MatchWaterCoverage = true,
                    WaterCoverage = .5f,
                    Roughness = .55f,
                    CliffThreshold = .9f
                });

            case MapGenTheme.Random:
                return(new fCraftMapGenArgs());

            case MapGenTheme.River:
                return(new fCraftMapGenArgs {
                    MaxHeight = 22,
                    MaxDepth = 8,
                    FeatureScale = 0,
                    DetailScale = 6,
                    MarbledHeightmap = true,
                    MatchWaterCoverage = true,
                    WaterCoverage = .31f
                });

            case MapGenTheme.Streams:
                return(new fCraftMapGenArgs {
                    MaxHeight = 5,
                    MaxDepth = 4,
                    FeatureScale = 2,
                    DetailScale = 7,
                    Roughness = .55f,
                    MarbledHeightmap = true,
                    MatchWaterCoverage = true,
                    WaterCoverage = .25f,
                    TreeSpacingMin = 8,
                    TreeSpacingMax = 14
                });

            case MapGenTheme.Peninsula:
                return(new fCraftMapGenArgs {
                    MaxHeight = 22,
                    MaxDepth = 12,
                    UseBias = true,
                    Bias = .5f,
                    MidPoint = -1,
                    RaisedCorners = 3,
                    LoweredCorners = 1,
                    TreeSpacingMax = 12,
                    TreeSpacingMin = 6,
                    InvertHeightmap = true,
                    WaterCoverage = .5f
                });

            default:
                throw new ArgumentOutOfRangeException("template");
            }
        }
Esempio n. 11
0
        public static RealisticMapGenParameters CreateParameters( RealisticMapGenTerrainType terrainType,
                                                                  MapGenTheme theme ) {
            RealisticMapGenParameters genParams;
            switch( terrainType ) {
                case RealisticMapGenTerrainType.Archipelago:
                    genParams = new RealisticMapGenParameters {
                        MaxHeight = 8,
                        MaxDepth = 20,
                        FeatureScale = 3,
                        Roughness = .46f,
                        MatchWaterCoverage = true,
                        WaterCoverage = .85f
                    };
                    break;

                case RealisticMapGenTerrainType.Atoll:
                    genParams = new RealisticMapGenParameters {
                        Theme = new RealisticMapGenBlockTheme( MapGenTheme.Desert ),
                        MaxHeight = 2,
                        MaxDepth = 39,
                        UseBias = true,
                        Bias = .9f,
                        MidPoint = 1,
                        LoweredCorners = 4,
                        FeatureScale = 2,
                        DetailScale = 5,
                        MarbledHeightmap = true,
                        InvertHeightmap = true,
                        MatchWaterCoverage = true,
                        WaterCoverage = .95f
                    };
                    break;

                case RealisticMapGenTerrainType.Bay:
                    genParams = new RealisticMapGenParameters {
                        MaxHeight = 22,
                        MaxDepth = 12,
                        UseBias = true,
                        Bias = 1,
                        MidPoint = -1,
                        RaisedCorners = 3,
                        LoweredCorners = 1,
                        TreeSpacingMax = 12,
                        TreeSpacingMin = 6,
                        MarbledHeightmap = true,
                        DelayBias = true
                    };
                    break;

                case RealisticMapGenTerrainType.Dunes:
                    genParams = new RealisticMapGenParameters {
                        AddTrees = false,
                        AddWater = false,
                        Theme = new RealisticMapGenBlockTheme( MapGenTheme.Desert ),
                        MaxHeight = 12,
                        MaxDepth = 7,
                        FeatureScale = 2,
                        DetailScale = 3,
                        Roughness = .44f,
                        MarbledHeightmap = true,
                        InvertHeightmap = true
                    };
                    break;

                case RealisticMapGenTerrainType.Hills:
                    genParams = new RealisticMapGenParameters {
                        AddWater = false,
                        MaxHeight = 8,
                        MaxDepth = 8,
                        FeatureScale = 2,
                        TreeSpacingMin = 7,
                        TreeSpacingMax = 13
                    };
                    break;

                case RealisticMapGenTerrainType.Ice:
                    genParams = new RealisticMapGenParameters {
                        Theme = new RealisticMapGenBlockTheme( MapGenTheme.Arctic ),
                        AddTrees = false,
                        MaxHeight = 2,
                        MaxDepth = 2032,
                        FeatureScale = 2,
                        DetailScale = 7,
                        Roughness = .64f,
                        MarbledHeightmap = true,
                        MatchWaterCoverage = true,
                        WaterCoverage = .3f,
                        MaxHeightVariation = 0
                    };
                    break;

                case RealisticMapGenTerrainType.Island:
                    genParams = new RealisticMapGenParameters {
                        MaxHeight = 16,
                        MaxDepth = 39,
                        UseBias = true,
                        Bias = .7f,
                        MidPoint = 1,
                        LoweredCorners = 4,
                        FeatureScale = 3,
                        DetailScale = 7,
                        MarbledHeightmap = true,
                        DelayBias = true,
                        AddBeaches = true,
                        Roughness = 0.45f
                    };
                    break;

                case RealisticMapGenTerrainType.Lake:
                    genParams = new RealisticMapGenParameters {
                        MaxHeight = 14,
                        MaxDepth = 20,
                        UseBias = true,
                        Bias = .65f,
                        MidPoint = -1,
                        RaisedCorners = 4,
                        FeatureScale = 2,
                        Roughness = .56f,
                        MatchWaterCoverage = true,
                        WaterCoverage = .3f
                    };
                    break;

                case RealisticMapGenTerrainType.Mountains:
                    genParams = new RealisticMapGenParameters {
                        AddWater = false,
                        MaxHeight = 40,
                        MaxDepth = 10,
                        FeatureScale = 1,
                        DetailScale = 7,
                        MarbledHeightmap = true,
                        AddSnow = true,
                        MatchWaterCoverage = true,
                        WaterCoverage = .5f,
                        Roughness = .55f,
                        CliffThreshold = .9f
                    };
                    break;

                case RealisticMapGenTerrainType.Defaults:
                    genParams = new RealisticMapGenParameters();
                    break;

                case RealisticMapGenTerrainType.River:
                    genParams = new RealisticMapGenParameters {
                        MaxHeight = 22,
                        MaxDepth = 8,
                        FeatureScale = 0,
                        DetailScale = 6,
                        MarbledHeightmap = true,
                        MatchWaterCoverage = true,
                        WaterCoverage = .31f
                    };
                    break;

                case RealisticMapGenTerrainType.Streams:
                    genParams = new RealisticMapGenParameters {
                        MaxHeight = 5,
                        MaxDepth = 4,
                        FeatureScale = 2,
                        DetailScale = 7,
                        Roughness = .55f,
                        MarbledHeightmap = true,
                        MatchWaterCoverage = true,
                        WaterCoverage = .25f,
                        TreeSpacingMin = 8,
                        TreeSpacingMax = 14
                    };
                    break;

                case RealisticMapGenTerrainType.Peninsula:
                    genParams = new RealisticMapGenParameters {
                        MaxHeight = 22,
                        MaxDepth = 12,
                        UseBias = true,
                        Bias = .5f,
                        MidPoint = -1,
                        RaisedCorners = 3,
                        LoweredCorners = 1,
                        TreeSpacingMax = 12,
                        TreeSpacingMin = 6,
                        InvertHeightmap = true,
                        WaterCoverage = .5f
                    };
                    break;

                case RealisticMapGenTerrainType.Flat:
                    genParams = new RealisticMapGenParameters {
                        MaxHeight = 0,
                        MaxDepth = 0,
                        MaxHeightVariation = 0,
                        AddWater = false,
                        DetailScale = 0,
                        FeatureScale = 0,
                        AddCliffs = false
                    };
                    break;

                default:
                    throw new ArgumentOutOfRangeException( "terrainType" );
            }

            genParams.Theme = new RealisticMapGenBlockTheme( theme );
            switch( theme ) {
                case MapGenTheme.Arctic:
                case MapGenTheme.Desert:
                case MapGenTheme.Grass:
                case MapGenTheme.Hell:
                    genParams.AddTrees = false;
                    break;
            }
            return genParams;
        }
Esempio n. 12
0
        public MapGeneratorArgs([NotNull] string fileName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException("fileName");
            }
            XDocument doc  = XDocument.Load(fileName);
            XElement  root = doc.Root;

            XAttribute versionTag = root.Attribute("version");
            int        version    = 0;

            if (versionTag != null && !String.IsNullOrEmpty(versionTag.Value))
            {
                version = Int32.Parse(versionTag.Value);
            }

            Theme     = (MapGenTheme)Enum.Parse(typeof(MapGenTheme), root.Element("theme").Value, true);
            Seed      = Int32.Parse(root.Element("seed").Value);
            MapWidth  = Int32.Parse(root.Element("dimX").Value);
            MapLength = Int32.Parse(root.Element("dimY").Value);
            MapHeight = Int32.Parse(root.Element("dimH").Value);
            MaxHeight = Int32.Parse(root.Element("maxHeight").Value);
            MaxDepth  = Int32.Parse(root.Element("maxDepth").Value);

            AddWater = Boolean.Parse(root.Element("addWater").Value);
            if (root.Element("customWaterLevel") != null)
            {
                CustomWaterLevel = Boolean.Parse(root.Element("customWaterLevel").Value);
            }
            MatchWaterCoverage = Boolean.Parse(root.Element("matchWaterCoverage").Value);
            WaterLevel         = Int32.Parse(root.Element("waterLevel").Value);
            WaterCoverage      = float.Parse(root.Element("waterCoverage").Value);

            UseBias = Boolean.Parse(root.Element("useBias").Value);
            if (root.Element("delayBias") != null)
            {
                DelayBias = Boolean.Parse(root.Element("delayBias").Value);
            }
            Bias           = float.Parse(root.Element("bias").Value);
            RaisedCorners  = Int32.Parse(root.Element("raisedCorners").Value);
            LoweredCorners = Int32.Parse(root.Element("loweredCorners").Value);
            MidPoint       = Int32.Parse(root.Element("midPoint").Value);

            if (version == 0)
            {
                DetailScale  = Int32.Parse(root.Element("minDetailSize").Value);
                FeatureScale = Int32.Parse(root.Element("maxDetailSize").Value);
            }
            else
            {
                DetailScale  = Int32.Parse(root.Element("detailScale").Value);
                FeatureScale = Int32.Parse(root.Element("featureScale").Value);
            }
            Roughness        = float.Parse(root.Element("roughness").Value);
            LayeredHeightmap = Boolean.Parse(root.Element("layeredHeightmap").Value);
            MarbledHeightmap = Boolean.Parse(root.Element("marbledHeightmap").Value);
            InvertHeightmap  = Boolean.Parse(root.Element("invertHeightmap").Value);
            if (root.Element("aboveFuncExponent") != null)
            {
                AboveFuncExponent = float.Parse(root.Element("aboveFuncExponent").Value);
            }
            if (root.Element("belowFuncExponent") != null)
            {
                BelowFuncExponent = float.Parse(root.Element("belowFuncExponent").Value);
            }

            AddTrees       = Boolean.Parse(root.Element("addTrees").Value);
            TreeSpacingMin = Int32.Parse(root.Element("treeSpacingMin").Value);
            TreeSpacingMax = Int32.Parse(root.Element("treeSpacingMax").Value);
            TreeHeightMin  = Int32.Parse(root.Element("treeHeightMin").Value);
            TreeHeightMax  = Int32.Parse(root.Element("treeHeightMax").Value);

            if (root.Element("addCaves") != null)
            {
                AddCaves     = Boolean.Parse(root.Element("addCaves").Value);
                AddCaveLava  = Boolean.Parse(root.Element("addCaveLava").Value);
                AddCaveWater = Boolean.Parse(root.Element("addCaveWater").Value);
                AddOre       = Boolean.Parse(root.Element("addOre").Value);
                CaveDensity  = float.Parse(root.Element("caveDensity").Value);
                CaveSize     = float.Parse(root.Element("caveSize").Value);
            }

            if (root.Element("addSnow") != null)
            {
                AddSnow = Boolean.Parse(root.Element("addSnow").Value);
            }
            if (root.Element("snowAltitude") != null)
            {
                SnowAltitude = Int32.Parse(root.Element("snowAltitude").Value);
            }
            if (root.Element("snowTransition") != null)
            {
                SnowTransition = Int32.Parse(root.Element("snowTransition").Value);
            }

            if (root.Element("addCliffs") != null)
            {
                AddCliffs = Boolean.Parse(root.Element("addCliffs").Value);
            }
            if (root.Element("cliffSmoothing") != null)
            {
                CliffSmoothing = Boolean.Parse(root.Element("cliffSmoothing").Value);
            }
            if (root.Element("cliffThreshold") != null)
            {
                CliffThreshold = float.Parse(root.Element("cliffThreshold").Value);
            }

            if (root.Element("addBeaches") != null)
            {
                AddBeaches = Boolean.Parse(root.Element("addBeaches").Value);
            }
            if (root.Element("beachExtent") != null)
            {
                BeachExtent = Int32.Parse(root.Element("beachExtent").Value);
            }
            if (root.Element("beachHeight") != null)
            {
                BeachHeight = Int32.Parse(root.Element("beachHeight").Value);
            }

            if (root.Element("maxHeightVariation") != null)
            {
                MaxHeightVariation = Int32.Parse(root.Element("maxHeightVariation").Value);
            }
            if (root.Element("maxDepthVariation") != null)
            {
                MaxDepthVariation = Int32.Parse(root.Element("maxDepthVariation").Value);
            }

            if (root.Element("addGiantTrees") != null)
            {
                AddGiantTrees = Boolean.Parse(root.Element("addGiantTrees").Value);
            }

            Validate();
        }
Esempio n. 13
0
        private void ApplyTheme(MapGenTheme theme)
        {
            args.Theme = theme;
            switch (theme)
            {
            case MapGenTheme.Arctic:
                bWaterSurface     = Block.Glass;
                bDeepWaterSurface = Block.Water;
                bGroundSurface    = Block.White;
                bWater            = Block.Water;
                bGround           = Block.White;
                bSeaFloor         = Block.White;
                bBedrock          = Block.Stone;
                bCliff            = Block.Stone;
                groundThickness   = 1;
                break;

            case MapGenTheme.Desert:
                bWaterSurface     = Block.Water;
                bDeepWaterSurface = Block.Water;
                bGroundSurface    = Block.Sand;
                bWater            = Block.Water;
                bGround           = Block.Sand;
                bSeaFloor         = Block.Sand;
                bBedrock          = Block.Stone;
                bCliff            = Block.Gravel;
                break;

            case MapGenTheme.Hell:
                bWaterSurface     = Block.Lava;
                bDeepWaterSurface = Block.Lava;
                bGroundSurface    = Block.Obsidian;
                bWater            = Block.Lava;
                bGround           = Block.Stone;
                bSeaFloor         = Block.Obsidian;
                bBedrock          = Block.Stone;
                bCliff            = Block.Stone;
                break;

            case MapGenTheme.Forest:
                bWaterSurface     = Block.Water;
                bDeepWaterSurface = Block.Water;
                bGroundSurface    = Block.Grass;
                bWater            = Block.Water;
                bGround           = Block.Dirt;
                bSeaFloor         = Block.Sand;
                bBedrock          = Block.Stone;
                bCliff            = Block.Stone;
                break;

            case MapGenTheme.Swamp:
                bWaterSurface     = Block.Water;
                bDeepWaterSurface = Block.Water;
                bGroundSurface    = Block.Dirt;
                bWater            = Block.Water;
                bGround           = Block.Dirt;
                bSeaFloor         = Block.Leaves;
                bBedrock          = Block.Stone;
                bCliff            = Block.Stone;
                break;
            }
        }
Esempio n. 14
0
 void ApplyTheme(MapGenTheme theme)
 {
     args.Theme = theme;
     switch (theme)
     {
         case MapGenTheme.Arctic:
             bWaterSurface = Block.Glass;
             bDeepWaterSurface = Block.Water;
             bGroundSurface = Block.White;
             bWater = Block.Water;
             bGround = Block.White;
             bSeaFloor = Block.White;
             bBedrock = Block.Stone;
             bCliff = Block.Stone;
             groundThickness = 1;
             break;
         case MapGenTheme.Desert:
             bWaterSurface = Block.Water;
             bDeepWaterSurface = Block.Water;
             bGroundSurface = Block.Sand;
             bWater = Block.Water;
             bGround = Block.Sand;
             bSeaFloor = Block.Sand;
             bBedrock = Block.Stone;
             bCliff = Block.Gravel;
             break;
         case MapGenTheme.Hell:
             bWaterSurface = Block.Lava;
             bDeepWaterSurface = Block.Lava;
             bGroundSurface = Block.Obsidian;
             bWater = Block.Lava;
             bGround = Block.Stone;
             bSeaFloor = Block.Obsidian;
             bBedrock = Block.Stone;
             bCliff = Block.Stone;
             break;
         case MapGenTheme.Forest:
             bWaterSurface = Block.Water;
             bDeepWaterSurface = Block.Water;
             bGroundSurface = Block.Grass;
             bWater = Block.Water;
             bGround = Block.Dirt;
             bSeaFloor = Block.Sand;
             bBedrock = Block.Stone;
             bCliff = Block.Stone;
             break;
         case MapGenTheme.Swamp:
             bWaterSurface = Block.Water;
             bDeepWaterSurface = Block.Water;
             bGroundSurface = Block.Dirt;
             bWater = Block.Water;
             bGround = Block.Dirt;
             bSeaFloor = Block.Leaves;
             bBedrock = Block.Stone;
             bCliff = Block.Stone;
             break;
     }
 }
Esempio n. 15
0
        static bool Gen(Player p, Level lvl, string seed, MapGenTheme theme)
        {
            MapGenBiome      biome = MapGenBiome.Forest;
            fCraftMapGenArgs args  = fCraftMapGenArgs.MakeTemplate(theme);

            float ratio = lvl.Height / 96.0f;

            args.MaxHeight    = (int)Math.Round(args.MaxHeight * ratio);
            args.MaxDepth     = (int)Math.Round(args.MaxDepth * ratio);
            args.SnowAltitude = (int)Math.Round(args.SnowAltitude * ratio);
            args.WaterLevel   = (lvl.Height - 1) / 2;

            string[] seedparts = seed.Split(',');
            if (seedparts.Length > 1)
            {
                seed = seedparts[0];
            }
            if (seed.Length > 0 && !CommandParser.GetEnum(p, seed, "Biome", ref biome))
            {
                return(false);
            }

            args.Biome    = biome;
            args.AddTrees = biome == MapGenBiome.Forest;
            args.AddWater = biome != MapGenBiome.Desert;

            int ar;

            char[] equals_chararray = new char[] { '=' };
            for (ar = 1; ar < seedparts.Length; ar++)
            {
                string[] arg = (seedparts[ar]).Split(equals_chararray, 2);
                if (arg.Length != 2)
                {
                    arg = new string[2] {
                        arg[0], "1"
                    }
                }
                ;
                switch (arg[0].ToLower())
                {
                case "s":
                case "seed":
                    if (!Int32.TryParse(arg[1], out args.Seed))
                    {
                        p.Message("&W\"{0}\" is not a valid integer Seed.", arg[1]);
                        return(false);
                    }
                    break;

                case "w":
                case "water":
                    if (!CommandParser.GetBool(p, arg[1], ref args.AddWater))
                    {
                        return(false);
                    }
                    break;

                case "wc":
                case "watercoverage":
                    if (!CommandParser.GetReal(p, arg[1], "WaterCoverage", ref args.WaterCoverage, 0.0f, 1.0f))
                    {
                        args.AddWater = true;
                    }
                    args.MatchWaterCoverage = true;
                    break;

                case "t":
                case "tree":
                case "trees":
                    if (!CommandParser.GetBool(p, arg[1], ref args.AddTrees))
                    {
                        return(false);
                    }
                    break;

                case "sn":
                case "snow":
                    if (!CommandParser.GetBool(p, arg[1], ref args.AddSnow))
                    {
                        return(false);
                    }
                    break;

                case "sl":
                case "snowlevel":
                case "snowaltitude":
                    if (!CommandParser.GetInt(p, arg[1], "SnowAltitude", ref args.SnowAltitude, 0, lvl.Height - 1))
                    {
                        return(false);
                    }
                    args.AddSnow = true;
                    break;

                case "tsl":
                case "treespacingmin":
                    if (!CommandParser.GetInt(p, arg[1], "TreeSpacingMin", ref args.TreeSpacingMin, 0))
                    {
                        return(false);
                    }
                    args.AddTrees = true;
                    break;

                case "tsh":
                case "treespacingmax":
                    if (!CommandParser.GetInt(p, arg[1], "TreeSpacingMax", ref args.TreeSpacingMax, 0))
                    {
                        return(false);
                    }
                    args.AddTrees = true;
                    break;

                case "thl":
                case "treeheightmin":
                    if (!CommandParser.GetInt(p, arg[1], "TreeHeightMin", ref args.TreeHeightMin, 0))
                    {
                        return(false);
                    }
                    args.AddTrees = true;
                    break;

                case "thh":
                case "treeheightmax":
                    if (!CommandParser.GetInt(p, arg[1], "TreeHeightMax", ref args.TreeHeightMax, 0))
                    {
                        return(false);
                    }
                    args.AddTrees = true;
                    break;

                default:
                    p.Message("&WSeed option\"{0}\" is unknown.", arg[0]);
                    return(false);
                }
            }

            new fCraftMapGen(args).Generate(lvl);
            args.ApplyEnv(lvl.Config);
            return(true);
        }
    }