Question

嘿，伙计们。我希望有人能够帮我弄清楚如何增加枚举。我有一个使用枚举来获得杀死敌人的点数的游戏，我希望每当敌人被杀时敌人的值增加10。以下是我对枚举的代码：

  public enum gamescore// Enumeration to hold the score values of the enemies

  {

  Martian = 10,

  Vesuvian = 20,

  Mercurian = 30,

  Meteor = 50,

  MotherShip = 100,

  Destroyer = 200

  }

以及在敌人死亡时从另一个班级调用得分的方法：

    public int GetScore()// The method that utilieses the enumeration to get the score for the enemy killed
    {

        if (this is Martian)
        {
            return (int)gamescore.Martian;
        }
        else if (this is Vesuvian)
        {
            return (int)gamescore.Vesuvian;
        }
        else if (this is Mercurian)
        {
            return (int)gamescore.Mercurian;
        }
        else if (this is Destroyer)
        {
            return (int)gamescore.Destroyer;
        }
        else if (this is Meteor)
        {
            return (int)gamescore.Meteor;
        }
        else if (this is Mothership)
        {
            return (int)gamescore.MotherShip;
        }
        return 0;
    }

有什么建议吗？我只能提出复杂的方法来做到这一点，我认为甚至无效。

另外我想知道，我有一个高分标签，如果它低于分数就会更新，所以高分会成为分数，但是当应用程序重新启动时，如果游戏完成或者玩家用完了生命，那么高分重置为零，有没有办法保持高分值，所以最高分始终存在？

我非常感谢你们对我的问题的帮助，我真的很喜欢。

谢谢！

Answer 1

在这种情况下，我不会将其存储为枚举 - 它听起来更像是范围标记而不是谨慎的值。我可能有一些常量和检查

的方法

if(score>100) return "awesome";
if(score>40) return "meh";

等

但要回答有关增加枚举的问题：您可以将其强制转换为基类型（通常是int）：

myEnumValue = (MyEnum)((int)myEnumValue + 10);

Answer 2

这种设计不是非常面向对象的。更好的方法是拥有一个IEnemy界面。该接口需要一种GetScore方法（可能是其他方法）。那个方法可以返回敌人的价值。然后你为每个实现IEnemy界面的敌人都有一个单独的类。

public interface IEnemy{
   int GetScore();
}

public class Martian : IEnemy{
   int GetScore(){ return 10; }
}

public class Vesuvian : IEnemy{
   int GetScore(){ return 20; }
}
...

与使用枚举相比，这有许多好处，例如，您可以拥有具有相同分数但具有不同其他属性的敌人。

Answer 3

为什么要使用枚举？为什么不创建接口IScorable，只有属性GetScore并在你的“敌人”类中实现它。然后你可以测试你的敌人是否是IScorable，如果是，请阅读这个属性。或者，如果所有敌人的类都来自一个，那么就把它放在那里。

此外，您使用枚举的方式也是错误的。这些枚举适用于完全不同的用户。

Answer 4

我会创建一个名为Enemy的抽象类，其中包含一个名为KillScore的属性（或者您喜欢的任何内容）。从中获取每个敌人类型：

public abstract class Enemy
{
    virtual public int KillScore
    {
        get { return 0; }
    }
}

public class Martian : Enemy
{
    public override int KillScore
    {
        get { return 10; }
    }
}

// All the other classes here

public class Destoyer : Enemy
{
    public override int KillScore
    {
        get { return 200; }
    }
}

您只需实例化您的个别课程，例如：

    Martian martian = new Martian();
    Destoyer destroyer = new Destoyer();
    int score = GetScore(martian);
    score = GetScore(destroyer);

然后您的GetScore功能变得非常简单：

public int GetScore(Enemy enemy)
{
    // Debug Statement to show you what this enemy actually is
    Console.WriteLine("{0} {1}", enemy.GetType(), enemy.KillScore);
    return enemy.KillScore;
}

（接口也可以正常工作，但是这可以让你对默认值进行一些控制，允许你在基类中做一些可能会或者可能不会在子类中重写的常用功能等。）。 p>

Answer 5

可能你最好的选择是使用多态性。所以你有一个叫做敌人的基类，它是抽象的。

public abstract class Enemy
{
  public abstract int GetScore();
}

然后你每次都会继承它。

public class Martian : Enemy
{
  public int GetScore() { return 10; }
}

public class Vesuvian : Enemy
{
  public int GetScore() { return 20; }
}

然后在你的主要方法中你必须创造正确类型的敌人：

Enemy blah = new Martian();
Enemy blah1 = new Vesuvian();

int x = blah.GetScore(); // This is 10.
int y = blah1.GetScore(); // This is 20.

增加枚举的最佳方法是什么？

5 个答案: