C# 游戏开发：设计可扩展的玩家角色属性系统

首先，我们需要定义一个接口，用于规范公用属性加成的方法：

public interface IAttributeModifier
{
    Dictionary<string, float> GetAttributeModifiers();
}

接下来，我们需要定义一个公用玩家属性类，用于存储玩家的所有属性，并提供属性加成的接口：

public class PlayerAttributes
{
    private Dictionary<string, float> _attributes = new Dictionary<string, float>();

    public void SetAttribute(string name, float value)
    {
        if (_attributes.ContainsKey(name))
        {
            _attributes[name] = value;
        }
        else
        {
            _attributes.Add(name, value);
        }
    }

    public float GetAttribute(string name)
    {
        if (_attributes.ContainsKey(name))
        {
            return _attributes[name];
        }
        else
        {
            return 0;
        }
    }

    public void ApplyAttributeModifiers(List<IAttributeModifier> modifiers)
    {
        foreach (IAttributeModifier modifier in modifiers)
        {
            Dictionary<string, float> modifierAttributes = modifier.GetAttributeModifiers();

            foreach (KeyValuePair<string, float> attribute in modifierAttributes)
            {
                if (_attributes.ContainsKey(attribute.Key))
                {
                    _attributes[attribute.Key] += attribute.Value;
                }
                else
                {
                    _attributes.Add(attribute.Key, attribute.Value);
                }
            }
        }
    }
}

最后，我们需要定义一个接口集合，用于获取所有实现了属性加成接口的类，并计算总属性加成：

public class AttributeModifierSystem
{
    private List<IAttributeModifier> _modifiers = new List<IAttributeModifier>();

    public void AddModifier(IAttributeModifier modifier)
    {
        _modifiers.Add(modifier);
    }

    public void RemoveModifier(IAttributeModifier modifier)
    {
        _modifiers.Remove(modifier);
    }

    public Dictionary<string, float> GetTotalAttributeModifiers()
    {
        Dictionary<string, float> totalModifiers = new Dictionary<string, float>();

        foreach (IAttributeModifier modifier in _modifiers)
        {
            Dictionary<string, float> modifierAttributes = modifier.GetAttributeModifiers();

            foreach (KeyValuePair<string, float> attribute in modifierAttributes)
            {
                if (totalModifiers.ContainsKey(attribute.Key))
                {
                    totalModifiers[attribute.Key] += attribute.Value;
                }
                else
                {
                    totalModifiers.Add(attribute.Key, attribute.Value);
                }
            }
        }

        return totalModifiers;
    }
}

使用示例：

// 创建公用属性对象
PlayerAttributes playerAttributes = new PlayerAttributes();

// 设置基本属性
playerAttributes.SetAttribute('Strength', 10);
playerAttributes.SetAttribute('Agility', 15);
playerAttributes.SetAttribute('Intelligence', 20);

// 创建属性加成对象
class AttributeModifier : IAttributeModifier
{
    public Dictionary<string, float> GetAttributeModifiers()
    {
        Dictionary<string, float> modifiers = new Dictionary<string, float>();

        modifiers.Add('Strength', 5);
        modifiers.Add('Agility', 10);
        modifiers.Add('Intelligence', 15);

        return modifiers;
    }
}

// 创建属性加成系统对象
AttributeModifierSystem modifierSystem = new AttributeModifierSystem();

// 添加属性加成对象
modifierSystem.AddModifier(new AttributeModifier());

// 应用属性加成
playerAttributes.ApplyAttributeModifiers(modifierSystem.GetModifiers());

// 获取总属性加成
Dictionary<string, float> totalModifiers = modifierSystem.GetTotalAttributeModifiers();

// 输出所有属性及其值
foreach (KeyValuePair<string, float> attribute in playerAttributes.GetAttributes())
{
    Console.WriteLine(attribute.Key + ': ' + attribute.Value);
}

// 输出总属性加成
foreach (KeyValuePair<string, float> modifier in totalModifiers)
{
    Console.WriteLine(modifier.Key + ' Modifier: ' + modifier.Value);
}