Need help with Input Buffering

[vagrant axle]

how would you guys approach integrating input buffering with this implementation? The goal is to do _ability.Perform(), then if the player presses input again within a specific buffer, then trigger _ability.Perform() again BUT only after the 1st Perform is complete. I have a bool indicating start and end with isPerformingAbility

public class DashAbility : Ability {

        private readonly Player _player;
        private readonly IDash _ability;
        private readonly IInput _input;

        public DashAbility(Player player, IDash ability, IInput input) {
            _player = player;
            _ability = ability;
            _input = input;
            _input.OnDash += TryAbility;
        }

        public override void TryAbility() {
            if (!NeedsMet()) return;
            _ability.Perform();
        }

        private bool NeedsMet() => _player.CanDash;
    }

[native violet]

Is this a complicated way to say, "I need the player to not be able to dash until they stop dashing"? or am i misunderstanding something?

[vagrant axle]

no...the goal is I want the player to Dash, and then if the dash button is pressed again during that Dash, then Dash again after the 1st dash is complete

[native violet]

Right, that makes more sense

I would have a coroutine that delays until the end of the dash, which, after the delay, checks a bool that has been updated with the buffer status, and runs the dash again if that buffer is true

so, basically

bool dashing, dashBuffer;
float dashTime;

public override void TryAbility()
{
  if (!Needsmet()) return;

  if (dashing) dashBuffer = true;
  else _ability.Perform();
}

IEnumerator bufferCheck()
{
  yield return new WaitForSeconds(dashTime);

  if (dashBuffer && NeedsMet()) _ability.Perform();
  else dashing = false;
}

and StartCoroutine(bufferCheck()) runs in _ability.Perform(), or a wrapper that calls them sequentially

[native violet]

Just curious, did this work? @vagrant axle

[vagrant axle]

so I managed to get the input buffering working with this. What do you think?

private void Update() {
            if (_nextAbility == null) {
                return;
            }

            if ((Time.time - _nextAbilityTime) >= _nextAbilityTimeMax) {
                _nextAbility = null;
                return;
            }

            if (!_character.Parameters.IsPerformingAbility) {
                _nextAbility.Invoke(true);
                _nextAbility = null;
            }
        }

        private void QueueAbility(Action<bool> ability, float time, float bufferTime) {
            if (_character.Parameters.IsPerformingAbility) {
                _nextAbility = ability;
                _nextAbilityTime = time;
                _nextAbilityTimeMax = bufferTime;
            }
            else {
                ability.Invoke(false);
            }
        }

[native violet]

I feel like coroutines would do you better here, but this definitely works

[vagrant axle]

coroutines for performance?

[native violet]

Maybe, I just think update loops are messy, and should be avoided unless you're updating something per-frame

[verbal vigil]

Personally I would create an enum that stores the character state (i.e. idle, jumping, dashing) etc.
When the player presses an input you could then perform the behaviour relevant to the current state

[native violet]

This wouldn't work. Like at all

[verbal vigil]

Why not?

[native violet]

First of all, this person is trying to make a dynamic ability system, using an enum that tracks each ability like that wouldn't easily allow for abilities to be enabled and disabled as easily as just a class connected to an object

Second of all, how would this solve the input buffering issue?

[verbal vigil]

Agree completely on first point.
I was just worried that if the player's dash is interrupted (ex collides into obstacle) then the second dash might not work as intended. I guess you could account for this sort of thing in your NeedsMet() method though