需要C＃OOP建议：什么是适当的数据结构？

Question

Okay, I need some solid OOP advice. Here's the setup: I have a player object with code that handles things like movement, pathfinding logic, etc. Now I need to assign each player a large table of variables and settings. Namely, each player has about 40 different weapon actions he can perform, and each weapon has 6-8 variables associated with it. My question is, which data-structure is most appropriate. Note, I don't want to create a class for each weapon because weapons are never instantiated in my game.

Here are the specifics: Each player has 40 different weapons that need to be pulled by name. For example:

Weapon #1: Pistol
Weapon #2: Shotgun
Weapon #3: Rifle
Weapon #4: Bow
Weapon #5: RocketLauncher

Each weapon then has the same set of variables assigned to it. For example:

Pistol.HasBeenUnlocked (true/false)
Pistol.Priority (1-40)
Pistol.AmmoQuantityMax (0-10)
Pistol.AmmoQuantityCurrent (0-10)
Pistol.UIButtonState ("Hidden", "Selected", "Deselected", "CoolOff")
Pistol.CoolOffTimerMax (0.0-5.0)
Pistol.CoolOffOn (true/false)

Now I want some sort of data-structure that organizes all these variables and makes them easy to access. For example, I want to be able to loop through all 40 weapons and generate buttons for them based on whether they were unlocked by a particular player. Here's what I want to do:

for (int i = 0; i < Player.Weapons.NumberOfWeaponsTotal(); i++) {
     if (Player.Weapons.Weapon[i].UIButtonState == "Hidden"){
          // don't create a UI button to fire weapon
     }
     else {
          // create a UI button to fire weapon
     }
}

Variable names across the different weapons will be the same. So Weapons.Pistol.UIButtonState will exist, as will Weapons.Rifle.UIButtonState.

So what's the best way to organize this? A 2D array isn't pretty. A structure doesn't seem robust enough. A class sees strange. I've never used classes for this sort of thing. I want to make sure this is somehow linked to the player, so when he's destroyed, so is this "object".

Answer 1

I think classes would be ideal for this scenario. Create an IWeapon interface that has the common properties and methods like Name , GetAmmoCount() , IsEnabled , etc. Then create classes for each type of weapon with all the specific properties. (But if you have 8 different pistols with the same methods and properties, you could create a generic Pistol class and just set the variables accordingly).

In the Player object, have a List<IWeapon> to hold all the weapons the player has.

When the Player is destroyed, just call the .Empty() method on the List to remove them all.

The weapon being held would be an additional member of the Player class: IWeapon ActiveWeapon .

You can do things like:

if(ActiveWeapon.GetAmmoCount() > 0) ActiveWeapon.Fire());

Or:

this.ActiveWeapon = new Pistol("LaserPistol");
this.Weapons.Add(this.ActiveWeapon);

this.ActiveWeapon = new AssaultRifle();

The advantage here is that your Player doesn't have to know exactly which types of weapons they might have until runtime, and you can easily swap them for other ones.

Edit: I found a page that gives an example of this using the Strategy design pattern : http://hnaser.blogspot.com/2009/07/abc-of-design-patterns.html

Answer 2

Define a struct or a class type that contains all the properties that all the different weapons have. Create an array[40] of this weapon type and store it as a property on the player type. Define an enum of ints to use as named indices into the weapons array. Pistol = 0, Shotgun = 1, etc. Use these enum names to index into the weapons array in your code.

On the rare occasion when you do need to look up a weapon by string name, you can just scan through the weapons array until you find the weapon whose name matches what you're looking for. Capture the index of that weapon and throw away the string name, so that all further operations are by indexed array. The cost of a linear scan through 40 items will not be noticeable.

If you really do absolutely have to avoid scanning the list for a matching name, you could construct a Dictionary to provide fast lookup by name. You'll want the dictionary entries to return the weapons of a particular player, so you'll need a different dictionary instance for each player, and store it in a field of the player object. If the simple scan is sufficient (it almost certainly is), don't bother with the dictionary approach.

Regardless of whether you define the weapon type as a struct or a class, it is a structured type and you are creating instances of this type every time you use it. 40 instances per player. The main difference between class and struct is where/how the memory is allocated and whether assignment copies the values or not. If you are careful to never assign a weapon from the array into a local weapon variable, and you don't use the dictionary thing above or do anything else that needs to share references to the same weapon data, then struct should be fine. If in doubt, use class.

You don't need to worry about the weapons getting disposed of when the player goes away - as long as the weapons array is the only thing that keeps a long term reference to the weapons, then they will all be disposed when the player is disposed. Proper encapsulation and minimizing cross-references between different objects will help here.

If you are certain that your selection of weapons will always have the same variables and the same actions (methods), then you can get by with a single weapon type for all the weapons, and that type can be a struct or a class.

If you start getting into special cases where this action behaves differently for that weapon, or this weapon has additional data that none of the other weapons need, then you should look at defining a base weapon class and descendents of that for specialization as needed.

Answer 3

Disclaimer

You could use a model like this to archieve what you need. Please bear in mind that, as any design, it may contains flaws. It is intended to help you to solve your problem, not as a solution.

Weapon

This class represents a Weapon in your app. Note the overriding methods in order to implement comparison/search/indexing properly.

public class Weapon
{
    public Weapon(WeaponName name)
    {
        Name = name;
    }

    public WeaponName Name { get; set; }
    public int Priority { get; set; }
    public int MaxAmmoQuantity { get; set; }
    public int CurrentAmmoQuantity { get; set; }

    public override string ToString()
    {
        return Enum.GetName(typeof(WeaponName), Name);
    }

    public override bool Equals(object obj)
    {
        if (obj == null) return false;

        var other = obj as Weapon;
        if (other == null) return false;

        return Name == other.Name;
    }

    public override int GetHashCode()
    {
        return Name.GetHashCode();
    }
}

WeaponName

Fixed options for the weapon names (assuming, as you said, there will be limited options for them)

public enum WeaponName
{
    Pistol,
    Shotgun,
    Rifle,
    Bow,
    RocketLauncher
}

Player

Note that:

• Internally, you can store weapons in the structure you like, but for the outside world only an IEnumerable instance is published
• It represents the fact that a player can grab a weapon or change the active one (here you can add any actions needed). Via events, the player communicates the outside world about his actions.

• You are giving the object methods with semantics. Rather than player.Weapons.Add you are making explicit the player's behavior.

  public class Player { private readonly IList _ownedWeapons = new List(); protected Weapon ActiveWeapon { get; private set; }

   public IEnumerable<WeaponName> OwnedWeapons { get; set; } public event EventHandler<WeaponEventArgs> WeaponGrabbed; public event EventHandler<WeaponEventArgs> ActiveWeaponChanged; public void InvokeActiveWeaponChanged() { var handler = ActiveWeaponChanged; if (handler != null) handler(this, new WeaponEventArgs(ActiveWeapon)); } public void InvokeWeaponGrabbed(Weapon weapon) { var handler = WeaponGrabbed; if (handler != null) handler(this, new WeaponEventArgs(weapon)); } public void SwitchWeapon(WeaponName weaponName) { ActiveWeapon = _ownedWeapons.Where(weapon => weapon.Name == weaponName).First(); InvokeActiveWeaponChanged(); } public void Grab(Weapon weapon) { _ownedWeapons.Add(weapon); InvokeWeaponGrabbed(weapon); } 

  }

  public class WeaponEventArgs : EventArgs { public WeaponEventArgs(Weapon weapon) { Weapon = weapon; }

    public Weapon Weapon { get; set; } } 

WeaponsRepository

• Centralized all the knowledge about weapons player can use in your app, registering available weapon names and their creation in the constructor.
• Also, it provides methods to create and query available weapons.

• You can tell what weapons a player do not have yet by using the WeaponsNotOwnedBy method.

  public class WeaponRepository { readonly Dictionary> _availableWeapons = new Dictionary>();

   public WeaponRepository() { _availableWeapons.Add(WeaponName.Pistol, () => new Weapon(WeaponName.Pistol) ); _availableWeapons.Add(WeaponName.Shotgun, () => new Weapon(WeaponName.Shotgun) ); } public Weapon Create(WeaponName name) { return _availableWeapons[name](); } public IEnumerable<WeaponName> AvailableWeapons() { return Enum.GetValues(typeof (WeaponName)).Cast<WeaponName>(); } public IEnumerable<WeaponName> WeaponsNotOwnedBy(Player player) { return AvailableWeapons().Where(weaponName => !player.OwnedWeapons.Contains(weaponName)); } 

  }

Usage

• You could assing a class the responsiblity to build and update the player's toolbar.
• Create one button per weapon using the method AvailableWeapons in WeaponRepository in the BuildToolbar method.
• In this class, subscribe to the player's event. In this way, you can enable/disable/highlight active weapon as needed.

Note: Im ommiting WeaponButton for brevity

public class WeaponToolbarBuilder
{
    private readonly Player _player;
    private readonly WeaponRepository _weaponRepository;
    private List<WeaponButton> _buttons = new List<WeaponButton>();

    public WeaponToolbarBuilder(Player player, WeaponRepository weaponRepository)
    {
        _player = player;
        _weaponRepository = weaponRepository;

        _player.ActiveWeaponChanged += _player_ActiveWeaponChanged;
        _player.WeaponGrabbed += _player_WeaponGrabbed;
    }

    void _player_WeaponGrabbed(object sender, WeaponEventArgs e)
    {
        var weaponButton = _buttons.Where(button => button.WeaponName == e.Weapon.Name).First();
        weaponButton.Enable();
    }

    void _player_ActiveWeaponChanged(object sender, WeaponEventArgs e)
    {
        var currentActiveButton = _buttons.Where(button => button.Highlighted).First();
        currentActiveButton.Highlight(false);

        var newActiveButton = _buttons.Where(button => button.WeaponName == e.Weapon.Name);
        newActiveButton.Highlight(true);
    }

    public void BuildToolbar() { ... }
}