Was ist der beste Weg, um eine Enumeration zu erhöhen?

Question

Hey Leute. Ich hatte gehofft, dass jemand mir helfen könnte herauszufinden, wie man die Enumeration erhöhen kann. Ich habe ein Spiel, das Aufzählung verwendet, um die Punkte für das Töten eines Feindes zu erhalten. Ich möchte, dass der Wert des Feindes jedes Mal um 10 erhöht wird, wenn einer der Gegner getötet wird. Hier ist der Code, den ich für die Zählung haben:

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

    { 

    Martian = 10, 

    Vesuvian = 20, 

    Mercurian = 30, 

    Meteor = 50, 

    MotherShip = 100, 

    Destroyer = 200 

    } 

und das Verfahren die Gäste aus einer anderen Klasse aufgerufen werden, wenn ein Feind stirbt:

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

Irgendwelche Vorschläge? Ich kann nur komplizierte Wege finden, dies zu tun, die ich glaube nicht einmal funktioniert.

Auch ich habe mich gefragt, ich habe eine Highscore-Label, die aktualisiert wird, wenn es weniger als Punktzahl ist, so Highscore wird Punktzahl, aber wenn die Anwendung neu gestartet wird, wenn das Spiel abgeschlossen ist oder wenn der Spieler von Leben ausgeht Highscore wird auf Null zurückgesetzt, gibt es eine Möglichkeit, den Highscore-Wert dort zu halten, sodass immer die höchste Punktzahl vorhanden ist?

Ich schätze all Ihre Hilfe mit meinen Fragen Jungs, ich tue wirklich.

Danke!

Answer 1

Dieses Design ist nicht sehr objektorientiert. Ein besserer Ansatz wäre eine IEnemy-Schnittstelle. Diese Schnittstelle würde eine Methode von GetScore (vermutlich unter anderen) erfordern. Diese Methode könnte dann den Wert des Feindes zurückgeben. Dann haben Sie eine separate Klasse für jeden Ihrer Feinde, die die IEnemy-Schnittstelle implementiert.

public interface IEnemy{ 
    int GetScore(); 
} 

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

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

Dies hat viele Vorteile gegenüber einer Aufzählung verwenden, zum Beispiel können Sie Feinde haben, die die gleiche Punktzahl haben, aber verschiedene andere Attribute.

Answer 2

In diesem Fall würde ich es nicht als Enum speichern - es klingt eher wie Entfernungsmarkierungen als diskrete Werte. Ich könnte haben einige Konstanten und eine Methode, die

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

prüft Etc

Aber die Frage nach Inkrementieren eine ENUM zu beantworten: Sie es an die Basis-Typ umwandeln kann (in der Regel int):

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

Answer 3

Warum Aufzählung verwenden? Warum nicht entweder die Schnittstelle IScorable erstellen, die nur die Eigenschaft GetScore hat und sie in Ihre "Enemies" -Klassen implementieren. Dann können Sie testen, ob Ihr Feind IScorable ist und wenn ja, lesen Sie diese Eigenschaft. Oder wenn alle deine gegnerischen Klassen von einem abstammen, dann lege es dort hinein.

Auch die Art, wie Sie Enumeration verwenden, ist falsch. Aufzählungen sind für ganz unterschiedliche Zwecke gedacht.

Answer 4

Ich würde eine abstrakte Klasse namens Enemy erstellen, mit einer Eigenschaft namens KillScore (oder was auch immer Sie mögen).Leiten Sie jede Ihrer Gegnertypen aus, dass:

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

Sie nur instanziiert Ihre einzelnen Klassen, zum Beispiel:

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

Dann Ihre GetScore Funktion wird sehr einfach:

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

(Ein Schnittstelle würde auch funktionieren, aber das gibt Ihnen einige Kontrolle über Standardwerte, ermöglicht es Ihnen, einige allgemeine Funktionen in der Basisklasse zu tun, die in den untergeordneten Klassen usw .).

Answer 5

Wahrscheinlich wäre Ihre beste Wette Polymorphie zu verwenden. Du hättest also eine Basisklasse namens Feind und es wäre abstrakt.

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

Dann würden Sie von ihm für jedes Mal erben.

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

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

dann in der Hauptmethode, die Sie müssen nur die richtige Art von Feind erstellen:

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

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