¿Cuál es la mejor manera de incrementar una enumeración?

Question

Hola chicos. Esperaba que alguien pudiera ayudarme a descubrir cómo aumentar la enumeración. Tengo un juego que usa la enumeración para obtener los puntos por matar a un enemigo, quiero que el valor del enemigo aumente en 10 cada vez que muere uno de los enemigos. Aquí está el código que tengo para la enumeración:

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

    { 

    Martian = 10, 

    Vesuvian = 20, 

    Mercurian = 30, 

    Meteor = 50, 

    MotherShip = 100, 

    Destroyer = 200 

    } 

y el método para obtener la puntuación llama de otra clase cuando un enemigo muere:

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; 
    } 

¿Alguna sugerencia? Solo puedo encontrar formas complicadas de hacer esto, que ni siquiera creo que funcione.

También me preguntaba, tengo una etiqueta de puntuación más alta que se actualiza si es inferior a la puntuación, por lo que la puntuación más alta se convierte en puntaje, pero cuando la aplicación se reinicia, si el juego se completa o si el jugador se queda sin vida, la puntuación más alta vuelve a cero, ¿hay alguna forma de mantener el valor de la puntuación más alta para que el puntaje más alto siempre esté allí?

Agradezco su ayuda con mis preguntas chicos, realmente lo creo.

Gracias!

Answer 1

Este diseño no es muy orientado a objetos. Un mejor enfoque sería tener una interfaz IEnemy. Esa interfaz requeriría un método de GetScore (presumiblemente entre otros). Ese método podría devolver el valor del enemigo. Luego tienes una clase separada para cada uno de tus enemigos que implementa la interfaz de IEnemy.

public interface IEnemy{ 
    int GetScore(); 
} 

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

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

Esto tiene muchas ventajas sobre el uso de una enumeración, por ejemplo, puede tener enemigos que tienen la misma puntuación, pero diferentes de otros atributos.

Answer 2

En este caso, no lo almacenaría como una enumeración, suena más como marcadores de rango que valores discretos. Me podría tener algunas constantes y un método que comprueba

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

Etc

Pero para responder a la pregunta acerca de incrementar una enumeración: puedes echarlo a la de tipo base (generalmente int):

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

Answer 3

¿Por qué usar la enumeración? ¿Por qué no crear la interfaz ISCOrable, que solo tiene la propiedad GetScore e implementarla en sus clases "Enemigos"? Luego puedes probar si tu enemigo es IScorable y, en caso afirmativo, leer esta propiedad. O si todas tus clases enemigas derivan de una, entonces ponla ahí.

También La forma en que usa Enumeration es incorrecta. Las enumeraciones están destinadas a fines completamente diferentes.

Answer 4

Crearía una clase abstracta llamada Enemy, con una propiedad llamada KillScore (o lo que quieras).Derivar cada uno de sus tipos de enemigos a partir de que:

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; } 
    } 
} 

Sólo una instancia sus clases individuales, por ejemplo:

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

Luego, su función getScore se hace muy fácil:

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; 
} 

(Un la interfaz funcionaría también, pero esto le da cierto control sobre los valores predeterminados, le permite hacer algunas funciones comunes en la clase base que pueden o no anularse en las clases secundarias, etc. .).

Answer 5

Probablemente su mejor opción sea utilizar polimorfismo. Entonces tendrías una clase base llamada enemigo y sería abstracto.

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

Entonces heredarías de ella para cada ocasión.

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

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

Luego, en su principal método sólo hay que crear el tipo correcto de enemigo:

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

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