Jaki jest najlepszy sposób zwiększania wyliczenia?

Question

Hej, chłopaki. Miałem nadzieję, że ktoś będzie w stanie mi pomóc wymyślić, jak zwiększyć wyliczenie. Mam grę, która używa wyliczenia, aby zdobyć punkty za zabicie wroga, chcę, aby wartość wroga zwiększała się o 10 za każdym razem, gdy jeden z wrogów zostanie zabity. Oto kod mam dla wyliczenia:

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

    { 

    Martian = 10, 

    Vesuvian = 20, 

    Mercurian = 30, 

    Meteor = 50, 

    MotherShip = 100, 

    Destroyer = 200 

    } 

i sposobu, aby uzyskać wynik wywołana z innej klasy, kiedy wróg umiera:

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

sugestie? Mogę tylko wymyślić skomplikowane sposoby, aby to zrobić, że nawet nie działa.

Zastanawiam się również, mam markę, która jest aktualizowana, jeśli jest mniejsza niż wynik, więc najlepszy wynik to wynik, ale gdy aplikacja ponownie się uruchomi, jeśli gra zostanie ukończona lub jeśli graczowi zabraknie życia, highscore resetuje się ponownie do zera, czy jest jakiś sposób, aby utrzymać wysoką wartość tam, więc najwyższy wynik jest zawsze tam?

Doceniam twoją pomoc z moimi pytaniami, naprawdę.

Dzięki!

Answer 1

Ten projekt nie jest bardzo zorientowany obiektowo. Lepszym rozwiązaniem byłoby posiadanie interfejsu IEnemy. Ten interfejs wymagałby metody GetScore (prawdopodobnie między innymi). Ta metoda może następnie zwrócić wartość wroga. Następnie masz osobną klasę dla każdego z wrogów, który implementuje interfejs IEnemy.

public interface IEnemy{ 
    int GetScore(); 
} 

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

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

Ma to wiele zalet w porównaniu do używania wyliczenia, na przykład można mieć wrogów, którzy mają ten sam wynik, ale różne inne atrybuty.

Answer 2

W tym przypadku nie zapisałbym tego jako wyliczenia - brzmi to bardziej jak znaczniki zakresu niż dyskretne wartości. mogę mieć pewne stałe i metodę, która sprawdza

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

Etc

jednak odpowiedzieć na pytanie o zwiększający enum: można oddać go do typu bazowego (zazwyczaj int):

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

Answer 3

Dlaczego używać wyliczenia? Dlaczego nie stworzyć interfejsu IScorable, który ma tylko własność GetScore i zaimplementować go w swoich klasach "Wrogowie". Następnie możesz sprawdzić, czy twój wróg jest niezadowalający, a jeśli tak, przeczytaj tę właściwość. Lub jeśli wszystkie klasy wroga pochodzą od jednego, a następnie umieść go tam.

Również sposób, w jaki używasz wyliczenia, jest nieprawidłowy. Wyliczenia są przeznaczone do całkowicie różnych celów.

Answer 4

Chciałbym utworzyć klasę abstrakcyjną o nazwie Enemy, z właściwością o nazwie KillScore (lub cokolwiek chcesz).Wyprowadź każdego z typów wroga od tego:

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

Wystarczy wystąpienia indywidualne zajęcia, na przykład:

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

Następnie czynność GetScore staje się bardzo proste:

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

(Interfejs też by działał, ale to daje ci pewną kontrolę nad wartościami domyślnymi, pozwala ci na wykonywanie pewnych wspólnych funkcji w klasie bazowej, które mogą, ale nie muszą być nadpisywane w klasach potomnych, itp. .).

Answer 5

Prawdopodobnie najlepszym rozwiązaniem byłoby użycie polimorfizmu. Więc masz klasę podstawową nazywaną wrogiem i będzie ona abstrakcyjna.

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

Następnie odziedziczylibyście go za każdym razem.

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

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

Następnie w głównym sposobem trzeba tylko stworzyć odpowiedni rodzaj wroga:

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

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