Как реализовать разное поведение оружия?

Реализация разного поведения оружия в C#

Для реализации разного поведения оружия в C# Backend-приложениях (например, в игровых серверах или симуляторах) применяется комбинация объектно-ориентированных принципов и шаблонов проектирования. Вот основные подходы:

1. Базовый абстрактный класс или интерфейс

Создаём общий контракт для всех типов оружия:

public abstract class Weapon
{
    public string Name { get; protected set; }
    public int Damage { get; protected set; }
    public float AttackSpeed { get; protected set; }
    
    public abstract void Attack(Character target);
    public abstract void Reload();
    public virtual string GetDescription() => $"Оружие: {Name}, Урон: {Damage}";
}

2. Стратегия через наследование (Полиморфизм)

Самый простой подход — создание конкретных классов-наследников:

public class Sword : Weapon
{
    public Sword()
    {
        Name = "Меч";
        Damage = 20;
        AttackSpeed = 1.5f;
    }
    
    public override void Attack(Character target)
    {
        // Логика ближнего боя
        target.TakeDamage(Damage);
        Console.WriteLine($"Нанесён рубящий удар мечом на {Damage} урона");
    }
    
    public override void Reload()
    {
        // Меч не требует перезарядки
        Console.WriteLine("Заточка меча...");
    }
}

public class Rifle : Weapon
{
    private int _ammoCount;
    private const int MaxAmmo = 30;
    
    public Rifle()
    {
        Name = "Винтовка";
        Damage = 15;
        AttackSpeed = 0.8f;
        _ammoCount = MaxAmmo;
    }
    
    public override void Attack(Character target)
    {
        if (_ammoCount <= 0)
        {
            Console.WriteLine("Нет патронов!");
            return;
        }
        
        _ammoCount--;
        target.TakeDamage(Damage);
        Console.WriteLine($"Выстрел из винтовки. Осталось патронов: {_ammoCount}");
    }
    
    public override void Reload()
    {
        _ammoCount = MaxAmmo;
        Console.WriteLine("Винтовка перезаряжена");
    }
}

3. Паттерн "Стратегия" для гибкости

Для более сложных сценариев, где поведение может меняться динамически:

public interface IAttackStrategy
{
    void ExecuteAttack(Weapon weapon, Character target);
}

public class MeleeAttackStrategy : IAttackStrategy
{
    public void ExecuteAttack(Weapon weapon, Character target)
    {
        // Расчёт урона с учётом брони цели
        int finalDamage = weapon.Damage - target.Armor;
        target.TakeDamage(Math.Max(finalDamage, 1));
    }
}

public class RangedAttackStrategy : IAttackStrategy
{
    public void ExecuteAttack(Weapon weapon, Character target)
    {
        // Расчёт урона с учётом дистанции
        float distance = CalculateDistance(weapon.Owner, target);
        float damageMultiplier = distance > 100 ? 0.5f : 1.0f;
        int finalDamage = (int)(weapon.Damage * damageMultiplier);
        target.TakeDamage(finalDamage);
    }
    
    private float CalculateDistance(Character a, Character b) { /* ... */ }
}

public class ConfigurableWeapon : Weapon
{
    private IAttackStrategy _attackStrategy;
    
    public ConfigurableWeapon(string name, int damage, IAttackStrategy strategy)
    {
        Name = name;
        Damage = damage;
        _attackStrategy = strategy;
    }
    
    public void SetAttackStrategy(IAttackStrategy newStrategy)
    {
        _attackStrategy = newStrategy;
    }
    
    public override void Attack(Character target)
    {
        _attackStrategy.ExecuteAttack(this, target);
    }
    
    public override void Reload() { /* ... */ }
}

4. Компонентный подход (Entity-Component-System)

Для максимальной гибкости в больших проектах:

public class WeaponComponent
{
    public WeaponData Data { get; set; }
    public IAttackBehavior AttackBehavior { get; set; }
    public IReloadBehavior ReloadBehavior { get; set; }
    
    public void PerformAttack(Character target)
    {
        AttackBehavior?.Attack(Data, target);
    }
}

// Данные оружия (отдельно от поведения)
public class WeaponData
{
    public string Name { get; set; }
    public int BaseDamage { get; set; }
    public float Cooldown { get; set; }
    public WeaponType Type { get; set; }
}

// Поведения как отдельные компоненты
public interface IAttackBehavior
{
    void Attack(WeaponData data, Character target);
}

public class ProjectileAttack : IAttackBehavior
{
    public void Attack(WeaponData data, Character target)
    {
        // Создание снаряда, трассировка и т.д.
        Console.WriteLine($"Запущен снаряд с уроном {data.BaseDamage}");
    }
}

5. Конфигурация через данные (Data-Driven Design)

Поведение можно задавать через конфигурационные файлы:

{
  "weapons": [
    {
      "id": "sword_01",
      "name": "Стальной меч",
      "damage": 25,
      "attackType": "melee",
      "behaviorClass": "Game.Weapons.MeleeBehavior",
      "specialEffects": ["bleeding", "stun_chance"]
    },
    {
      "id": "rifle_01",
      "name": "Снайперская винтовка",
      "damage": 65,
      "attackType": "ranged",
      "behaviorClass": "Game.Weapons.SniperBehavior",
      "requiresAmmo": true
    }
  ]
}

6. Фабричный метод для создания оружия

public class WeaponFactory
{
    public Weapon CreateWeapon(WeaponType type)
    {
        return type switch
        {
            WeaponType.Sword => new Sword(),
            WeaponType.Rifle => new Rifle(),
            WeaponType.Shotgun => new Shotgun(),
            WeaponType.MagicStaff => new MagicStaff(),
            _ => throw new ArgumentException("Неизвестный тип оружия")
        };
    }
    
    public Weapon CreateWeaponFromConfig(WeaponConfig config)
    {
        var weapon = CreateWeapon(config.Type);
        // Дополнительная настройка из конфига
        weapon.Damage = config.BaseDamage * config.DamageMultiplier;
        return weapon;
    }
}

Ключевые принципы реализации:

1. Инкапсуляция поведения — каждый тип оружия инкапсулирует свою уникальную логику
2. Открытость/закрытость — система легко расширяема новыми типами оружия без изменения существующего кода
3. Разделение данных и логики — данные оружия (урон, скорость) отделены от поведения (логики атаки)
4. Внедрение зависимостей — поведения можно внедрять через конструкторы для тестирования
5. Конфигурируемость — параметры и поведения можно менять без перекомпиляции

Пример использования:

class Program
{
    static void Main()
    {
        // Создание оружия через фабрику
        var factory = new WeaponFactory();
        var sword = factory.CreateWeapon(WeaponType.Sword);
        var rifle = factory.CreateWeapon(WeaponType.Rifle);
        
        // Использование полиморфизма
        Character enemy = new Character("Враг", 100);
        
        sword.Attack(enemy);  // Вызовет метод Attack класса Sword
        rifle.Attack(enemy);  // Вызовет метод Attack класса Rifle
        
        // Динамическая смена поведения
        var configWeapon = new ConfigurableWeapon("Гибкое оружие", 20, 
            new MeleeAttackStrategy());
        
        configWeapon.Attack(enemy);  // Ближняя атака
        
        configWeapon.SetAttackStrategy(new RangedAttackStrategy());
        configWeapon.Attack(enemy);  // Дальняя атака
    }
}

Такой подход позволяет создавать сложные системы оружия с уникальным поведением, легко расширяемые и поддерживаемые, что особенно важно в Backend-разработке игровых серверов, где требуется высокая производительность и гибкость.