Constructeur avec un tableau de sous-classes d'une classe abstraite en tant que paramètre

Question

Je travaille sur un système d'inventaire de joueur pour un jeu.

J'ai un struct emplacement qui a une liste <Loot> collection qui représente quels types d'articles sont autorisés en elle. La classe abstraite Le butin est sous-classé par tous les éléments lootables - c'est-à-dire: valides Valeurs de contenu pour le Emplacement struct.

Je veux exprimer qu'un sous peut avoir des restrictions sur les sous-classes de Loot qu'il peut contenir. Par exemple, si la fente représente un conteneur de munitions, je veux seulement tenir Loot sous-classes qui sont des conteneurs de munitions, comme « carquois » et « Pouches Shot » (qui sous-classement Container quelque part le long de la ligne).

classe Loot

public abstract class Loot : GameEntity, ILootable 
{ 
    public int MaxUnitsPerStack { get; set; } 
    public int MaxUnitsCarriable { get; set; } 
    public int MaxUnitsOwnable { get; set; } 

    public void Stack() { } 
    public void Split() { } 
    public void Scrap() { } 
} 

classe Container

public abstract class Container : Loot 
{ 
    public List<Slot> Slots { get; set; } 

    public Container(int slots) 
    { 
     this.Slots = new List<Slot>(slots); 
    } 
} 

struct Slot

public struct Slot 
{ 
    public Loot Content; 
    public int Count; 
    public List<Loot> ExclusiveLootTypes; 

    public Slot(Loot[] exclusiveLootTypes) 
    { 
     this.Content = null; 
     this.Count = 0; 

     List<Loot> newList; 
     if (exclusiveLootTypes.Count() > 0) 
     { 
      newList = new List<Loot>(exclusiveLootTypes.Count()); 
      foreach (Loot l in exclusiveLootTypes) 
      { 
       newList.Add(l); 
      } 
     } 
     else { newList = new List<Loot>(); } 
     this.ExclusiveLootTypes = newList; 
    } 
} 

PlayerInventory

public struct PlayerInventory 
{ 
    static Dictionary<Slot, string> Slots; 

    static void Main() 
    { 
     Slots = new Dictionary<Slot, string>(); 

     /* Add a bunch of slots */ 
     Slots.Add(new Slot(/* I don't know the 
           syntax for this: 
           Quiver, Backpack */), "Backpack"); // Container 
    } 

} 

Je ne sais pas comment fournir les arguments pour les sous-classes Loot dans la fente appel constructeur dans la principale méthode de la PlayerInventory classe.

J'espère que c'est clair. Merci d'avance.

EDIT

j'ai pu résoudre ce (et par là, je veux dire pour le compiler) en utilisant l'approche de David Sieler ainsi que quelques réflexions.

struct Slot

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Reflection; 

    public struct Slot 
    { 
     private Loot _content; 
     private int _count; 
     public List ExclusiveLootTypes; 

     public Loot Content 
     { 
      get { return _content; } 
      private set 
      { 
       if ((ExclusiveLootTypes.Contains(value.GetType())) && (value.GetType().IsSubclassOf(Type.GetType("Loot")))) 
       { 
        _content = value; 
       } 
      } 
     } 

     public int Count 
     { 
      get { return _count; } 
      set { _count = value; } 
     } 

     public Slot(params Type[] exclusiveLootTypes) 
     { 
      this._content = null; 
      this._count = 0; 

      List newList; 
      if (exclusiveLootTypes.Count() > 0) 
      { 
       newList = new List(exclusiveLootTypes.Count()); 
       foreach (Type l in exclusiveLootTypes) 
       { 
        newList.Add(l); 
       } 
      } 
      else { newList = new List(); } 
      this.ExclusiveLootTypes = newList; 
     } 
    } 

appel à PlayerInventory constructeur Fente

Slots.Add(new Slot(typeof(Backpack))); 

Merci encore à tous pour la discussion.

Answer 1

Une approche consiste à passer un tableau d'objets Type au constructeur de l'emplacement:

public Slot(Type[] exclusiveLootTypes) { 
    // be sure and check that each Type is a subtype of Loot! 
} 

// Construction looks like: 
new Slot(new[] {GetType(AmmoContainer), GetType(GemContainer) /* or whatever */}); 

ensuite écrire un setter de propriété pour Content qui vérifie le type de l'objet assigné, et signale une sorte d'erreur si ce type ne figure pas dans ExclusiveLootTypes.

Answer 2

Vous trouveriez probablement plus facile à utiliser params dans la définition du constructeur à sous:

Slot(params Loot[] exclusiveLootTypes) 

Cela vous permettra de l'appeler comme:

new Slot(lootItem1, lootItem2, lootItem2 /*...etc*/); 

Sinon, vous auriez Vous devez créer un tableau et le transmettre.

Answer 3

et de combiner la suggestion précédente d'utiliser params, vous pouvez utiliser une extension LINQ pour convertir les params dans une liste en une seule étape:

public Slot(params Type[] exclusiveLootTypes) 
{ 
    this.Content = null; 
    this.Count = 0; 

    this.ExclusiveLootTypes = exclusiveLootTypes.ToList(); 
} 

Answer 4

Il semble que votre conception de l'objet a besoin d'un léger ajustement.

Et si les types d'éléments de butin étaient également des interfaces, par exemple, tous les éléments de butin de mémoire héritent de IAmmoContainer.

Ensuite, vous pouvez transmettre le type IAmmoContainer pour restreindre l'emplacement.

public class Quiver : Container, IAmmoContainer 
public class ShotPouch : Container, IAmmoContainer 
// ... 
new Slot(typeof(IAmmoContainer)) 

EDIT

Sur la base de la discussion dans les commentaires, voici comment je vais sur la conception de ce système.

La classe Loot est correcte. Il représente la base de la hiérarchie du butin.

Ensuite, vous définissez des interfaces pour les «emplacements» qu'un élément peut occuper. Par exemple:

public class LongSword : Loot, IRightHandItem 
public class ShortSword : Loot, IRightHandItem, ILeftHandItem 

Puis la classe PlayerInventory a des "emplacements" en tant que propriétés, qui sont limités au type approprié.

public class PlayerInventory 
{ 
    public List<IRightHandItem> RightHandSlot { get; private set; } 
    public List<ILeftHandItem> LeftHandSlot { get; private set; } 
    // etc... 
}