How to check if a list contains the contents of another in for fighting game motion inputs

Unity Engine
,
1

So I’m currently working on a little personal programming project, I’m trying to make a sort of fighting game prototype to at least understand the programming that goes into making a fighting game. One thing I’m having particular trouble with is the motion inputs. I’ve got a system rigged up where, when an input for a direction is detected, a string representing that input is temporarily added to a list, and then shortly removed. Let’s use a classic quarter-circle forward motion, the Hadouken, as an example. The script checks that “Recent Inputs” list for a down input, then checks if the two inputs that come after it are down-forward and forward, if so, then…hadouken!

foreach (string input in recentInputs)
{
    #region Quartercricles

        //Quartercircle Forward
        if (input == "down")
        {
            if(input != null)
            {
                int startingInputIndex = recentInputs.IndexOf(input);
                int baseStartingInputIndex = startingInputIndex;
                             
                             
                if (recentInputs[startingInputIndex += 1] == "downForward" && recentInputs[startingInputIndex += 1] == "forward")
                {
                    Debug.Log("Hadouken!");
                    startingInputIndex = baseStartingInputIndex;

                }
            }
        }

This code kind of works, but I feel like it’s really unreliable and inefficient. I mean look how long the code for a half circle is. Imagine if I wanted to do a 360 or a 720, it’d be a nightmare.

if (input == "back")
{
    int startingInputIndex = recentInputs.IndexOf(input);
    int baseStartingInputIndex = startingInputIndex;

    if (recentInputs[startingInputIndex += 1] == "downBack" && recentInputs[startingInputIndex += 1] == "down" && recentInputs[startingInputIndex += 1] == "downForward" && recentInputs[startingInputIndex += 1] == "forward")
    {
        Debug.Log("Yoga Fire!");
        startingInputIndex = baseStartingInputIndex;
    }

}

What I would ideally like to do is just set up lists with the motions already in them, and then see if my Recent Inputs list contains that same set of inputs, so if there’s a series of inputs that match up with the QCF list, it runs the Hadoken code, and so on. This would allow me to create a far more universal input system than what I have currently. Is there a way to do that, to see if a list contains the contents of another, in order? Or can you think of some better way to pull off these motion inputs, something more efficient?

2
  1. Don’t use strings, use enums.
  2. Don’t manually check every element of the array with bespoke code for every move like this. Do something like make an expected list of inputs and use a loop to compare each element in order (or just compare the lists with e.g. Enumerable.SequenceEqual Method (System.Linq) | Microsoft Learn

Then you can reuse that code for every single move, just passing in the different move lists. You could even put all the moves in a prefix tree/ trie for maximum efficiency:

Basically whenever input comes in, you check all the children of the current node in the prefix tree and see if any match. If they do, you go down that node. Eventually you get to a leaf node which is a completed move.

3

Assuming timing is irrelevant (it isn’t in most fighting games), just turn the inputs into a series of tokens.

When a new token is added to the list of ongoing tokens, check it against known combo sequences.

If you want to add in timing, make the ongoing token list get cleared if too much time passes on a given token, or perhaps too much time passes overall.

If you want to add in quality of input, store timing marks with each input token and see how close thy are to optimal.

A lot of golf or baseball games do systems like this, where you are graded according to being close to a particular input cadence.

In a single expression, this practice is sub-ideal:

Because the +=1 is a side effect that is only conditionally executed in the second half if the first half was true.