Question

所以我对编程很新。我目前正在开发一个地形生成程序，除此之外一切都很顺利：

    public static class Desert
    {
        public const int iChance = 15;
        public static int chance = iChance;
        public static int chancepoint = 0;
        public const int octaves = 4;
        public const int lengthMin = 60;
        public const int lengthMax = 90;
        public const float scaleMin = 250;
        public const float scaleMax = 350;
        public const float persistenceMin = 0.5f;
        public const float persistenceMax = 0.9f;
        public const pType ptype = pType.Lowland;
        public const bTag[] tags = { bTag.desert };
    }
    public static class Meadow
    {
        public const int iChance = 45;
        public static int chance = iChance;
        public static int chancepoint = 0;
        public const int octaves = 4;
        public const int lengthMin = 45;
        public const int lengthMax = 70;
        public const float scaleMin = 200;
        public const float scaleMax = 470;
        public const float persistenceMin = 0.35f;
        public const float persistenceMax = 0.70f;
        public const pType ptype = pType.noAbs;
        public const bTag[] tags = { bTag.lush };
    }

这些是每种不同类型的'Biome'的属性。

我目前有大约7个，除了每个字段的值外，它们都完全相同。

有没有办法缩短代码？我研究了继承，但最终出现了错误，我有点困惑。＆GT;＆LT;

如果我不得不写的话会很棒：

public static class Desert
    {
        iChance = 15;
        chance = iChance;
        chancepoint = 0;
        octaves = 4;
        lengthMin = 60;
        lengthMax = 90;
        scaleMin = 250;
        scaleMax = 350;
        persistenceMin = 0.5f;
        persistenceMax = 0.9f;
        ptype = pType.Lowland;
        strongTags = { bTag.desert };
    }

提前致谢。

哦，对于这个问题的小问题感到抱歉，如果你看到程序的其余部分，你可能会尖叫我的代码有多糟糕。 XD

编辑：可能明智地告诉你，除了“机会”的价值之外，我再也不会改变课堂内的东西。

Answer 1

您可以使用非静态类，而不是使用静态类。

public class Biome {
    // Instance fields with default values
    public int iChance = 15;
    public int chance = iChance;
    public int chancepoint = 0;
    public int octaves = 4;
    public int lengthMin = 60;
    public int lengthMax = 90;
    public float scaleMin = 250;
    public float scaleMax = 350;
    public float persistenceMin = 0.5f;
    public float persistenceMax = 0.9f;
    public pType ptype = pType.Lowland;
    public bTag[] tags = { bTag.desert };
}

这里使用构造函数进行初始化：

public Biome(int iChance, int chance, int chancepoint, int octaves, public int lengthMin, int lengthMax, float scaleMin, float scaleMax, float persistenceMin, float persistenceMax,pType ptype, bTag[] tags) {
    // init fields here
}

然后调用构造函数：

Biome bimoe = new Biome(15, iChance, 0, 4, 60, 90, 250, 350, 0.5f, 0.9f, pType.Lowland, { bTag.desert });

有了这个，很难看出哪个参数属于哪个字段，但它要短得多。

如果字段必须是只读的，则可以仅使用公开get和set访问者来创建属性。例如：

public Chance { get { return chance; } }

在这种情况下，将字段设为私有：

private int chance = iChance;

（就个人而言，对于这种情况，我会将所有数据都放在一个文件中）

Answer 2

以下内容会更短：

public const int iChance = 15, octaves = 4, lengthMin = 60, lengthMax = 90;
public const float scaleMin = 250, scaleMax = 350, persistenceMin = 0.5f,
                   persistenceMax = 0.9f;
public static int chance = iChance, chancepoint = 0;

但是......这些看起来不像static字段，或者甚至可能不是const。它们看起来应该是实例属性的东西。也许是这样的：

public class Terrain {
   public int Chance {get;private set;}
   public int LengthMin {get;private set;}
   // ...
   private Terrain(int chance, int lengthMin, ...) {
       Chance = chance;
       LengthMin = lengthMin;
       // ...
   }
   private static readonly Terrain
       desert = new Terrain(45, 45, ...),
       meadow = new Terrain(15, 60, ...),
       ...;
   public static Terrain Desert { get { return desert;}}
   public static Terrain Meadow { get { return meadow;}}
}

Answer 3

我对地形生成程序知之甚少，但您应该将数据存储在数据库中。然后创建类以将该数据映射到您的应用程序。我建议你查找“数据结构”，看哪一个最适合你的应用程序。

Answer 4

最好只使用一个没有继承，甚至结构的类。 Desert，Meadow等逻辑上不是类，它必须是对象（可能是常量）。

Answer 5

你可以做的是使用一个名为Terrain的类，并使用静态构造函数多次初始化：

   public class Terrain
    {
            public int IChance { get; private set; }
    public int Chancepoint { get; private set; }
    public int Octaves { get; private set; }
    public int LengthMin { get; private set; }
    public int LengthMax { get; private set; }
    public float ScaleMin { get; private set; }
    public float ScaleMax { get; private set; }
    public float PersistenceMin { get; private set; }
    public float PersistenceMax { get; private set; }
    public pType Ptype { get; private set; }
    public bTag[] Tags { get; private set; }

        public static Terrain Desert()
        {
            return new Terrain
                {
                    IChance = 15,
                    Chancepoint = 0,
                    Octaves = 4,
                    LengthMin = 60,
                    LengthMax = 90,
                    ScaleMin = 250,
                    ScaleMax = 350,
                    PersistenceMin = 0.5f,
                    PersistenceMax = 0.9f,
                    Ptype = pType.Lowland,
                    Tags = new bTag[] {bTag.Desert}
                };
        }
}

Answer 6

joe的答案很好，但是构造函数调用有太多未命名的参数 - 350是什么意思？

这是数据驱动设计的理想选择。

不是在代码中定义所有Biome类型，而是将Biome类型的所有数据放入文件中，并在运行时读取文件。 C＃语言有很多东西可以帮助你做到这一点，搜索的关键词是序列化（and here's a link to MSDN about it）。

最大的好处是您可以更改数据值而无需重新编译代码。

缺点是需要更多代码来定义第一个实例，但之后，您可以轻松地创建任意数量的实例。

Answer 7

你可以做一些像宣布这样的抽象类然后继承它的东西：

    public abstract class Terrain
    {
        public int iChance;
        public int chance;
        public int chancepoint;
        public int octaves;
        public int lengthMin;
        public int lengthMax;
        public float scaleMin;
        public float scaleMax;
        public float persistenceMin;
        public float persistenceMax;
        public pType ptype;
        public Tag[] strongTags;
    }

    public class Desert : Terrain
    {

    }

    public enum pType
    {
        Desert = 1,
        LowLand = 2
    }

    public enum Tag
    {
        desert = 1,
        lush = 2
    }

然后你可以实例化沙漠：

var desert = new Desert()
            {
                iChance = 15
                ,chance = 15
                ,chancepoint = 0
                ,octaves = 4
                ,lengthMin = 60
                ,lengthMax = 90
                ,scaleMin = 250
                ,scaleMax = 350
                ,persistenceMin = 0.5f
                ,persistenceMax = 0.9f 
                ,ptype = pType.Desert
                ,strongTags = new Tag[]{Tag.desert}
            };

Answer 8

不确定您的具体要求是什么，但这不是更好的方法：

public abstract class BiomeBase
{
    public int Chance      { get; set; }
    public int Chancepoint { get; set; }
    public int Octaves     { get; set; }
    // you get the idea ...
}

然后您继承了Desert和Meadow：

public class Desert : BiomeBase
{
    // everything is inherited ...
    // you can also add your own properties meant for Desert only (if needed)
}

public class Meadow : BiomeBase
{
    // everything is inherited ...
}

现在Desert包含Biome所有内容，您可以像这样使用它：

var desert = new Desert
{
    Chance = 5,
    Octaves = 1, 
    /// etc
};

Answer 9

首先，你不能继承static classes。所以你必须开始使用实例。

其次，如果要扩展对象，则可以使用继承。例如，如果你想在沙漠上添加一个新的属性“bool HasScorpions”，而不是在Meadow上。

由于您使用相同的属性但想要使用不同的值，我个人使用接口。这样，您可以在轻松设置值的同时使属性只读。

public interface Terrain
{
    int iChance = {get { return 15; private set; } ..and repeat.
    int chance = iChance;
    int chancepoint = 0;
    int octaves = 4;
    int lengthMin = 60;
    int lengthMax = 90;
    float scaleMin = 250;
    float scaleMax = 350;
    float persistenceMin = 0.5f;
    float persistenceMax = 0.9f;
    pType ptype = pType.Lowland;
    bTag[] tags = { bTag.desert };
}

有没有办法缩短它？

9 个答案: