Exemplo n.º 1
0
        /// <summary>
        /// i.e. won't detect negative edge or holds
        /// </summary>
        /// <param name="inputHistory"></param>
        /// <param name="motionInput"></param>
        /// <returns></returns>
        public static bool InterpretNormalAttackInput(InputHistory inputHistory, AttackMotionInput motionInput)
        {
            InputHistoryEntry    entry   = inputHistory.GetEntry(0);
            IList <ButtonStatus> buttons = entry.buttons;

            ButtonStatus[] reference = motionInput.buttons;

            for (int i = 0; i < buttons.Count; i++)
            {
                ButtonStatus currStatus = buttons[i];
                if (reference[i] == ButtonStatus.Down &&
                    currStatus == ButtonStatus.Down)
                {
                    // Down match
                }
                else if (reference[i] == ButtonStatus.Up)
                {
                    // Up ignored
                }
                else
                {
                    // mismatch!
                    // TODO: might lead to strange behavior currently. i.e. 632AB might not give nothing instead of A DP
                    return(false);
                }
            }

            return(InterpretMotionInput(inputHistory, motionInput));
        }
Exemplo n.º 2
0
        /**
         * Warning, not called every frame
         * Only called when new input is detected from scanner
         */
        public void ParseNewInput(InputHistory inputHistory)
        {
            bool matched = false;

            matched = InterpretAttack(inputHistory);
            if (!matched)
            {
                matched = InterpretMovement(inputHistory);
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// Attack input priority is determined here too!
        /// </summary>
        /// <param name="inputHistory"></param>
        /// <returns>true if interpreted to something</returns>
        private bool InterpretAttack(InputHistory inputHistory)
        {
            // // invul moves

            // // button combos
            // if (InterpretUtil.InterpretTapButtonCombo(inputHistory, RC)) {
            //     DebugMessage(RC.ToString());
            //     inputActions.RC(RC.frameLimit);
            //     return true;
            // }

            // if (InterpretUtil.InterpretTapButtonCombo(inputHistory, ForwardThrow)) {
            //     DebugMessage(ForwardThrow.ToString());
            //     inputActions.InputBufferCancel(ForwardThrow.frameLimit);
            //     inputActions.Throw(true);
            //     return true;
            // }

            // if (InterpretUtil.InterpretTapButtonCombo(inputHistory, BackwardThrow)) {
            //     DebugMessage(BackwardThrow.ToString());
            //     inputActions.InputBufferCancel(BackwardThrow.frameLimit);
            //     inputActions.Throw(false);
            //     return true;
            // }

            // // specials
            // if (InterpretUtil.InterpretSpecialAttackInput (inputHistory, S236B)) {
            //     DebugMessage(S236B.ToString());
            //     inputActions.S236 (Button.B);
            //     return true;
            // }

            // command normals

            // normals
            // if (InterpretUtil.InterpretNormalAttackInput(inputHistory, N5A)) {
            //     DebugMessage(N5A.ToString());
            //     inputActions.N5(Button.A);
            //     return true;
            // }
            // if (InterpretUtil.InterpretNormalAttackInput(inputHistory, N5B)) {
            //     DebugMessage(N5B.ToString());
            //     inputActions.N5(Button.B);
            //     return true;
            // }
            // if (InterpretUtil.InterpretNormalAttackInput(inputHistory, N5C)) {
            //     DebugMessage(N5C.ToString());
            //     inputActions.N5(Button.C);
            //     return true;
            // }

            return(false);
        }
Exemplo n.º 4
0
        private bool InterpretMovement(InputHistory inputHistory)
        {
            // inputActions.StopWalk();
            // if (InterpretUtil.InterpretMotionInput(inputHistory, M66))
            // {
            //     DebugMessage(M66.ToString());
            //     inputActions.Dash();
            //     return true;
            // } else {
            //     inputActions.StopRun();
            // }

            // if (InterpretUtil.InterpretMotionInput(inputHistory, M44))
            // {
            //     DebugMessage(M44.ToString());
            //     inputActions.BackDash();
            //     return true;
            // }


            // if (InterpretUtil.InterpretMotionInput(inputHistory, MJump))
            // {
            //     DebugMessage(MJump.ToString());
            //     inputActions.Jump(inputHistory.GetEntry(0).direction);
            //     return true;
            // } else {
            //     inputActions.ReleaseJump();
            // }

            inputActions.Walk(Numpad.N5);

            if (InterpretUtil.InterpretMotionInput(inputHistory, M6))
            {
                DebugMessage(M6.ToString());
                inputActions.Walk(Numpad.N6);
                return(true);
            }
            if (InterpretUtil.InterpretMotionInput(inputHistory, M4))
            {
                DebugMessage(M4.ToString());
                inputActions.Walk(Numpad.N4);
                return(true);
            }

            return(false);
        }
Exemplo n.º 5
0
        public BattleInputScanner()
        {
            runningFrames = 0; // Frame 1 will be first update frame

            // parser = new BattleInputParser();
            // ChangeDirectionEventSource = GetComponent<IStateManager>();
            // ChangeDirectionEventSource.ChangeDirectionEvent += ChangeDirectionEventHandler;

            nextDirection = Numpad.N5;
            nextButtons   = new List <ButtonStatus> ();
            for (int j = 0; j < ButtonCount; j++)
            {
                nextButtons.Add(ButtonStatus.Up);
            }
            newInputs = false;

            // initialize input history
            inputHistory = new InputHistory(InputHistorySize, ButtonCount);
        }
Exemplo n.º 6
0
        /// <summary>
        /// i.e. won't detect negative edge
        /// Great for detecting FD, not so great for detecting throw
        /// </summary>
        /// <param name="inputHistory"></param>
        /// <param name="motionInput"></param>
        /// <returns></returns>
        public static bool InterpretHoldButtonCombo(InputHistory inputHistory, AttackMotionInput motionInput)
        {
            int index       = 0;
            int totalFrames = 0;

            InputHistoryEntry    entry   = null;
            IList <ButtonStatus> buttons = null;

            ButtonStatus[] reference = motionInput.buttons;

            bool noMatchesFound = true; // has the input history matched a button combo yet?

            while (noMatchesFound)
            {
                if (index >= inputHistory.GetSize())
                {
                    return(false);
                }

                entry   = inputHistory.GetEntry(index);
                buttons = entry.buttons;

                bool noMismatch = true;

                for (int i = 0; i < buttons.Count; i++)
                {
                    ButtonStatus currStatus = buttons[i];
                    if (reference[i] == ButtonStatus.Down &&
                        (currStatus == ButtonStatus.Down || currStatus == ButtonStatus.Hold))
                    {
                        // held[i] = true;
                    }
                    else if (reference[i] == ButtonStatus.Up)
                    {
                        // Up ignored
                    }
                    else
                    {
                        // mismatch!
                        // TODO: might lead to strange behavior currently. i.e. 632AB might not give nothing instead of A DP
                        noMismatch = false;
                    }
                }
                if (index > 0)
                {
                    // i.e. first input has running frames since last input.
                    // Only factor in if motion input is longer than 1 input (ie. 46A)
                    totalFrames += inputHistory.GetEntry(index - 1).runningFrames;
                    if (totalFrames > motionInput.frameLimit)
                    {
                        return(false);
                    }
                }

                if (noMismatch)
                {
                    return(InterpretMotionInput(inputHistory, motionInput));
                }

                index++;
            }
            return(false);
        }
Exemplo n.º 7
0
        /// <summary>
        /// i.e. won't detect negative edge
        /// Great for detecting FD, not so great for detecting throw
        /// </summary>
        /// <param name="inputHistory"></param>
        /// <param name="motionInput"></param>
        /// <returns></returns>
        public static bool InterpretTapButtonCombo(InputHistory inputHistory, AttackMotionInput motionInput)
        {
            int index       = 0;
            int totalFrames = 0;

            InputHistoryEntry    entry   = null;
            IList <ButtonStatus> buttons = null;

            ButtonStatus[] reference   = motionInput.buttons;
            int[]          frameLimits = new int[reference.Length];

            bool noMatchesFound = true; // has the input history matched a button combo yet?

            while (noMatchesFound)
            {
                if (index >= inputHistory.GetSize())
                {
                    return(false);
                }

                entry   = inputHistory.GetEntry(index);
                buttons = entry.buttons;

                for (int i = 0; i < buttons.Count; i++)
                {
                    ButtonStatus currStatus = buttons[i];
                    if (reference[i] == ButtonStatus.Down)
                    {
                        if (currStatus == ButtonStatus.Down)
                        {
                            frameLimits[i] = motionInput.frameLimit + 1;
                        }
                        else
                        {
                            // ignore everything else
                        }
                    }
                    else
                    {
                        // reference up doesn't affect button combo
                        frameLimits[i] = 100; // indicate safe state
                    }
                }
                if (index > 0)
                {
                    // i.e. first input has running frames since last input.
                    // Only factor in if motion input is longer than 1 input (ie. 46A)
                    totalFrames += inputHistory.GetEntry(index - 1).runningFrames;
                    if (totalFrames > motionInput.frameLimit)
                    {
                        return(false);
                    }
                }

                bool buttonComboDetected = true;
                for (int i = 0; i < frameLimits.Length; i++)
                {
                    if (frameLimits[i] <= 0)
                    {
                        buttonComboDetected = false;
                    }
                    frameLimits[i] = frameLimits[i] - 1;
                }
                if (buttonComboDetected)
                {
                    return(InterpretMotionInput(inputHistory, motionInput));
                }

                index++;
            }
            return(false);
        }
Exemplo n.º 8
0
        /// <summary>
        /// Return true if input history matches the numpad inputs given
        ///
        /// TODO: Make sure this function isn't too slow
        /// </summary>
        /// <param name="inputHistory">The player's most recent inputs</param>
        /// <param name="motionInput">All possible forms of the given motion input</param>
        /// <returns>true if the player inputs match this motion input</returns>
        public static bool InterpretMotionInput(InputHistory inputHistory, MotionInput motionInput)
        {
            int    historyIndex   = -1;        // which index in the input history to look at?
            Numpad prevInput      = Numpad.N0; // most recently interpreted numpad direction
            int    curIndex       = 0;         // which index in the motion inputs to look at?
            int    totalFrames    = 0;         // total frames the input took to input
            bool   noMatchesFound = false;     // has the input history matched a motion input yet?

            // assume watching all at first
            bool[] notWatching = new bool[motionInput.motionInputs.Count];
            while (!noMatchesFound)
            {
                // find next input in inputHistory to consider
                historyIndex++;
                if (historyIndex >= inputHistory.GetSize())
                {
                    return(false);
                }
                InputHistoryEntry currEntry = inputHistory.GetEntry(historyIndex);
                // add to total frames

                if (currEntry.direction != prevInput)
                {
                    // new numpad input to investigate!
                    // update prev input for next iteration
                    prevInput = currEntry.direction;
                    for (int i = 0; i < notWatching.Length; i++)
                    {
                        if (notWatching[i] == false)
                        {
                            // still watching this motion input list
                            IList <Numpad> curMotionInput = motionInput.motionInputs[i];
                            if (curIndex == curMotionInput.Count - 1 &&
                                curMotionInput[curIndex] == currEntry.direction)
                            {
                                // curMotionInput was on watch list and is not exhausted
                                // means a match was detected!
                                if (totalFrames <= motionInput.frameLimit)
                                {
                                    // TODO: You can put this check earlier probably!
                                    return(true);
                                }
                                notWatching[i] = true;
                            }
                            else if (curMotionInput[curIndex] != currEntry.direction)
                            {
                                // motion input did not match up, don't watch it anymore
                                notWatching[i] = true;
                            }
                        }
                    }
                    // looking for next index on next new direction found
                    curIndex++;
                }

                // are we watching any other motion inputs?
                noMatchesFound = true;
                foreach (bool notWatch in notWatching)
                {
                    noMatchesFound = noMatchesFound && notWatch;
                }

                if (historyIndex > 0)
                {
                    // i.e. first input has running frames since last input.
                    // Only factor in if motion input is longer than 1 input (ie. 46A)
                    totalFrames += inputHistory.GetEntry(historyIndex - 1).runningFrames;
                }
            }
            return(false);
        }