Шаблоны реализации динамически расширяемой архитектуры игровой логики

РЕДАКТИРОВАТЬ
Извините, что неправильно прочитал вопрос. Мое новое понимание целей.

У нас есть животное с поведением (скажем, прыжок), которое мы хотим изменить, исходя из состояния животного (скажем, "Замороженного") или состояния окружающей среды (скажем, гравитации или температуры)

Мы не хотим продолжать распространять животное, но хотели бы его настроить.

У меня есть частичное решение для расширения функциональности. Возможно, этого будет достаточно или можно использовать в качестве отправной точки.

Нам нужны две новые концепции

IEnvironment
Не совсем необходимо, вы упоминаете изменение силы тяжести почти как в сторону, но достаточно просто, чтобы включить

IStateful/IState
Нам нужны некоторые критерии для тестирования. Вместо добавления к интерфейсу мы можем определить животное как включающее в себя сумку состояний, к которой мы можем добавить или удалить.

public interface IEnvironment {
    double Gravity { get; set; }
}   

public interface IState {
    string Name { get; }
    bool Is(object target);
}

public interface IStateful {
    void SetState(string  name);
    void SetState(string name, Func<object, bool> test);
    void ClearState(string name);
    bool IsInState(string name);
}

У нас все еще есть (в основном) те же классы WithBehaviours, мы просто добавляем состояния и экстернализируем конфигурацию

public abstract class WithBehaviors : IStateful {

    private readonly List<IState> _states;
    private readonly List<Behavior> _behaviors;
    private readonly IEnvironment _environment;

    protected WithBehaviors(IEnvironment environment) {
        _environment = environment;
        _behaviors = new List<Behavior>();
        _states = new List<IState>();
    }

    #region IStateful


    public void SetState(string name) {
        SetState(name , o=> true);
    }

    public void SetState(string name, Func<object, bool> test) {
        if (_states.Any(s => Match(s, name))) {
        throw new ArgumentException();
        }
        _states.Add(new State(name, test));
    }

    public void ClearState(string name) {
        _states.RemoveAll(s => Match(s, name));
    }

    public bool IsInState(string name) {
        var theState = _states.FirstOrDefault(s => Match(s, name));
        return theState != null && theState.Is(this);
    }

    private static bool Match(IState state, string name) {
        return state.Name.Equals(name, StringComparison.CurrentCultureIgnoreCase);
    }

    #endregion

    public void RegisterBehaviour(string name, Action<object> defaultAction) {
        _behaviors.Add(new Behavior(name, defaultAction));
    }

    public void RegisterBehaviorModifier(
        string name, 
        Func<IEnvironment, IStateful, bool> check,
        Action<object> replacementAction = null
    ) {
        ActOn(name, 
            b => b.BehaviorActions.Add(new BehaviorAction(check, 
                                                          replacementAction ?? (o =>{}))));
    }


    public void Invoke(string behaviourName) {
        ActOn(behaviourName, behavior => {
            var replacement = behavior.BehaviorActions.FirstOrDefault(b => b.Check(_environment, this));
            if (replacement == null) {
                behavior.DefaultAction(this);
            } else {
                replacement.Action(this);
            }
        });
    }

    private void ActOn(string name, Action<Behavior> action) {
        var behavior = _behaviors.FirstOrDefault(b => name.Equals(b.Name, StringComparison.CurrentCultureIgnoreCase));
        if (behavior != null) {
            action(behavior);
        }
    }

    private class Behavior {
        public Behavior(string name, Action<object> defaultAction) {
            Name = name;
            DefaultAction = defaultAction;
            BehaviorActions = new   List<BehaviorAction>();
        }

        public string Name { get; private set; }
        public Action<object> DefaultAction { get; private set; }
        public List<BehaviorAction> BehaviorActions { get; private set; }
    }

    private class BehaviorAction {

        public BehaviorAction(Func<IEnvironment, IStateful, bool> check, Action<object> action) {
            Check = check;
            Action = action;
        }

        public Func<IEnvironment, IStateful, bool> Check { get; private set; }
        public Action<object> Action { get; private set; }

    }

}

public class WithBehaviors<T> : WithBehaviors where T : class {

    public WithBehaviors(IEnvironment environment) : base(environment) {}

    public void RegisterBehaviour(string name, Action<T> defaultAction) {
        base.RegisterBehaviour(name, obj => defaultAction((T)obj));
    }

    public void RegisterBehaviorModifier(
        string name,
        Func<IEnvironment, IStateful, bool> check,
        Action<T> replacementAction = null
    ) {
        base.RegisterBehaviorModifier(name, 
                                      check,
                                      (replacementAction != null)
                                          ? (Action<object>)(o => replacementAction((T)o))
                                          : null);
    }

}


public  class Rabbit : WithBehaviors<Rabbit> {
    public Rabbit(IEnvironment environment) : base(environment){}

    public int XVal { get; set; }

}

public class State : IState {

    private readonly Func<object, bool> _test;

    public State(string name, Func<object, bool> test = null) {
        Name = name;
        _test = test;
    }

    public string Name { get; private set; }

    public bool Is(object target) {
        return _test(target);
    }
}

Государство включает тест на цель, а также простое да/нет, например, устаревшее состояние может быть определено как энергия ниже определенного уровня. Может быть чрезмерным.

[TestClass]
public class BehaviorsFixture {

    #region Setup

    private Mock<IEnvironment> _mockEnvironment;

    private Rabbit CreateRabbit() {

        var buggs = new Rabbit(_mockEnvironment.Object);
        buggs.RegisterBehaviour(Behaviors.Jump, r => r.XVal += 10);

        // gravity GTE 30, cannot jump
        buggs.RegisterBehaviorModifier(Behaviors.Jump, (e, o) => e.Gravity >= 30);

        // gravity GTE 20, (but LT 30), jumps 5
        buggs.RegisterBehaviorModifier(Behaviors.Jump, (e, o) => e.Gravity >= 20, r => r.XVal += 5);

        // if the rabbit is frozen it cannot jump
        buggs.RegisterBehaviorModifier(Behaviors.Jump, (e, o) => o.IsInState(States.Frozen));

        // if the rabbit is chilled it can only jump 2
        buggs.RegisterBehaviorModifier(Behaviors.Jump, (e, o) => o.IsInState(States.Chilled), r => r.XVal += 2);

        return buggs;
    }

    #endregion

    [TestInitialize]
    public void TestInitialize() {
    _mockEnvironment = new Mock<IEnvironment>();
    _mockEnvironment.SetupProperty(mk => mk.Gravity, 9.81);
    }


    [TestMethod]
    public void JumpingInGravity() {

        var buggs = CreateRabbit();

        Assert.AreEqual(0, buggs.XVal);

        buggs.Invoke(Behaviors.Jump);
        buggs.Invoke(Behaviors.Jump);

        Assert.AreEqual(20, buggs.XVal);

        // higher gravity means can only jump 5
        _mockEnvironment.Object.Gravity = 20.0;

        buggs.Invoke(Behaviors.Jump);

        Assert.AreEqual(25, buggs.XVal);


        // even higher gravity, cannot jump
        _mockEnvironment.Object.Gravity = 30.0;

        buggs.Invoke(Behaviors.Jump);

        Assert.AreEqual(25, buggs.XVal);


        // set gravity back to normal - can jump
        _mockEnvironment.Object.Gravity = 9.81;

        buggs.Invoke(Behaviors.Jump);

        Assert.AreEqual(35, buggs.XVal);

    }

    [TestMethod]
    public void JumpingWhenCold() {

        var buggs = CreateRabbit();

        Assert.AreEqual(0, buggs.XVal);

        buggs.Invoke(Behaviors.Jump);

        Assert.AreEqual(10, buggs.XVal);

        // if frozen, cannot jump
        buggs.SetState(States.Frozen);

        buggs.Invoke(Behaviors.Jump);

        Assert.AreEqual(10, buggs.XVal);

        // remove, can jump again
        buggs.ClearState(States.Frozen);

        buggs.Invoke(Behaviors.Jump);

        Assert.AreEqual(20, buggs.XVal);

        // if chilled, can jump a bit
        buggs.SetState(States.Chilled);

        buggs.Invoke(Behaviors.Jump);

        Assert.AreEqual(22, buggs.XVal);

        // remove, can jump again
        buggs.ClearState(States.Chilled);

        buggs.Invoke(Behaviors.Jump);

        Assert.AreEqual(32, buggs.XVal);

        }
    }

}

Выдающиеся проблемы связаны с

• Приоритет проверок. В настоящий момент мы запускаем первый, который мы используем. Тщательный порядок конфигурации может дать правильный ответ, но подвержен ошибкам. Возможно, добавьте приоритет и отсортируйте его при проверке
• Модификация существующей функциональности. В настоящий момент мы можем ее заменить, но скажем, что гравитация позволила нам прыгнуть только наполовину нормально, нет возможности разрешить это (за исключением повторной тщательной настройки)

Надеюсь, это ближе к тому, что вы искали. Извините снова о беспорядке.