Multi purpose item class design in C# [duplicate]

Question

I'm currently trying to get my head around how to create an item class which contains data for multiple purposes.

As for example I would like to have an Axe which could be used as weapon, but also as a tool to chop trees. The class should contain the following:

Durability, weight, damage vs npcs/players (when attacking), damage vs trees (when chopping), attack speed, chop speed and some enum in which equipment slot the axe fits (e.g. melee slot).

What would be the typical approach?

I stumbled about this answer, but I'm not 100% sure if I'm understanding him right. Is it something like:

public class Item {

    public int durability;
    public float weight;

    public Weapon weapon;
    public Tool tool;

    public class Weapon {
        public int damage; // damage vs players
        public int speed; // attack speed
    }

    public class Tool {
        public int damage; // damage vs trees
        public int speed; // chop speed
    }
}

?

Answer 1

A common approach which is quite popular among game developers is the Entity-Component-System.

Each Entity (class Item) only contains the most basic functionality and data which is common to all items, plus a List<ItemComponent>. ItemComponent is an abstract class with sub-classes like WeaponItemComponent, ToolItemComponent and any other features you only want to have on some of your items. These components contain the data and code which is relevant for performing that feature. Each Item can have one of each of these components (or more than one, if you want to allow that), but doesn't have to.

One way to interact with components is by using an event system. Your item class would have a method HandleEvent(event) which then calls component.HandleEvent(event) for all components. The internal implementation of each component decides if it needs to do something for that event.

Another way is by explicitly getting a component from an item:

WeaponItemComponent wic = item.GetComponent<WeaponItemComponent>();
if (wic != null) {
    enemy.hp -= wic.damage;
}

Answer 2

It seems right but it doesn't allow for as much future-proofing if you decide to add further items that the item can interact with to your game at a later date.

Maybe try something like:

public enum ItemType {Weapon, Tool}

public struct ItemInfo
{
     public ItemType itemType;
     public int damage;
     public int speed;
}

public class Item
{
    private int durability;
    private float weight;
    private List<ItemInfo> _itemInfo = new <itemInfo>();
}

This allows you to keep a simple list of all of the interactions your item may have.