Esempio n. 1
0
        public TreeGenForClimate GetRandomGenForClimate(TreeVariant[] gens, int climate, int forest, int y)
        {
            int   rain      = TerraGenConfig.GetRainFall((climate >> 8) & 0xff, y);
            int   temp      = TerraGenConfig.GetScaledAdjustedTemperature((climate >> 16) & 0xff, y - TerraGenConfig.seaLevel);
            float heightRel = ((float)y - TerraGenConfig.seaLevel) / ((float)api.WorldManager.MapSizeY - TerraGenConfig.seaLevel);
            int   fertility = TerraGenConfig.GetFertility(rain, temp, heightRel);

            float total = 0;
            float fertDist, rainDist, tempDist, forestDist, heightDist;

            distances.Clear();

            for (int i = 0; i < gens.Length; i++)
            {
                TreeVariant variant = gens[i];

                fertDist   = Math.Abs(fertility - variant.FertMid) / variant.FertRange;
                rainDist   = Math.Abs(rain - variant.RainMid) / variant.RainRange;
                tempDist   = Math.Abs(temp - variant.TempMid) / variant.TempRange;
                forestDist = Math.Abs(forest - variant.ForestMid) / variant.ForestRange;
                heightDist = Math.Abs((y / worldheight) - variant.HeightMid) / variant.HeightRange;


                double distSq =
                    Math.Max(0, fertDist * fertDist - 1) +
                    Math.Max(0, rainDist * rainDist - 1) +
                    Math.Max(0, tempDist * tempDist - 1) +
                    Math.Max(0, forestDist * forestDist - 1) +
                    Math.Max(0, heightDist * heightDist - 1)
                ;

                if (random.NextDouble() < distSq)
                {
                    continue;
                }

                float distance = (fertDist + rainDist + tempDist + forestDist + heightDist) * variant.Weight / 100f;

                distances.Add(variant, distance);

                total += distance;
            }

            distances = distances.Shuffle(random);

            double rnd = random.NextDouble();

            foreach (var val in distances)
            {
                rnd -= val.Value / total;
                if (rnd <= 0.001)
                {
                    float suitabilityBonus = GameMath.Clamp(0.7f - val.Value, 0f, 0.7f) * 1 / 0.7f * val.Key.SuitabilitySizeBonus;

                    float size = val.Key.MinSize + (float)random.NextDouble() * (val.Key.MaxSize - val.Key.MinSize) + suitabilityBonus;

                    float rainVal = Math.Max(0, (rain / 255f - treeGenProps.vinesMinRain) / (1 - treeGenProps.vinesMinRain));
                    float tempVal = Math.Max(0, (TerraGenConfig.DescaleTemperature(temp) / 255f - treeGenProps.descVineMinTempRel) / (1 - treeGenProps.descVineMinTempRel));

                    float vinesGrowthChance = 2f * rainVal * tempVal;

                    ITreeGenerator treegen = treeGenerators.GetGenerator(val.Key.Generator);

                    if (treegen == null)
                    {
                        api.World.Logger.Error("treengenproperties.json references tree generator {0}, but no such generator exists!", val.Key.Generator);
                        return(null);
                    }


                    return(new TreeGenForClimate(treegen, size, vinesGrowthChance));
                }
            }

            return(null);
        }
Esempio n. 2
0
        public override bool OnWorldEditCommand(WorldEdit.WorldEdit worldEdit, CmdArgs args)
        {
            if (treeGenerators == null)
            {
                treeGenerators = new TreeGeneratorsUtil(worldEdit.sapi);
            }

            string cmd = args.PopWord();

            switch (cmd)
            {
            case "tsizemin":
            {
                float size = 0.7f;
                if (args.Length > 0)
                {
                    float.TryParse(args[0], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out size);
                }
                MinTreeSize = size;

                worldEdit.Good("Tree Min Size=" + size + " set.");

                return(true);
            }

            case "tsizemax":
            {
                float size = 0.7f;
                if (args.Length > 0)
                {
                    float.TryParse(args[0], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out size);
                }
                MaxTreeSize = size;

                worldEdit.Good("Tree Max Size=" + size + " set.");

                return(true);
            }

            case "tsize":
            {
                float min = 0.7f;
                if (args.Length > 0)
                {
                    float.TryParse(args[0], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out min);
                }
                MinTreeSize = min;

                float max = 1.3f;
                if (args.Length > 1)
                {
                    float.TryParse(args[1], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out max);
                }
                MaxTreeSize = max;

                worldEdit.Good("Tree Min Size=" + min + ", max size =" + MaxTreeSize + " set.");

                return(true);
            }

            case "trnd":
                return(true);

            case "tv":
                int index = 0;

                string variant = args.PopWord();

                bool numeric = int.TryParse(variant, NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out index);

                treeGenerators.ReloadTreeGenerators();

                if (numeric)
                {
                    var val = treeGenerators.GetGenerator(index);
                    if (val.Key == null)
                    {
                        worldEdit.Bad("No such tree variant found.");
                        return(true);
                    }

                    TreeVariant = val.Key.ToShortString();
                    worldEdit.Good("Tree variant " + val.Key + " set.");
                }
                else
                {
                    if (variant != null && treeGenerators.GetGenerator(new AssetLocation(variant)) != null)
                    {
                        TreeVariant = variant;
                        worldEdit.Good("Tree variant " + variant + " set.");
                    }
                    else
                    {
                        worldEdit.Bad("No such tree variant found.");
                    }
                }

                return(true);
            }

            return(false);
        }