コード例 #1
0
    // Update is called once per frame
    void Update()
    {
        ChartEditor editor = ChartEditor.Instance;

        if (editor.currentState == ChartEditor.State.Playing && !GameSettings.bot)
        {
            Chart.GameMode gameMode = editor.currentChart.gameMode;
            LaneInfo       laneInfo = editor.laneInfo;

            if (gameMode == Chart.GameMode.Drums)
            {
                foreach (Note.DrumPad drumPad in EnumX <Note.DrumPad> .Values)
                {
                    if (bannedDrumPadInputs.ContainsKey(drumPad))
                    {
                        continue;
                    }

                    if (DrumsInput.GetPadPressedInput(drumPad, laneInfo))
                    {
                        animations[(int)drumPad].Press();
                    }
                    else
                    {
                        animations[(int)drumPad].Release();
                    }
                }
            }
            else
            {
                foreach (Note.GuitarFret fret in EnumX <Note.GuitarFret> .Values)
                {
                    if (bannedFretInputs.ContainsKey(fret))
                    {
                        continue;
                    }

                    if (GuitarInput.GetFretInput(fret))
                    {
                        animations[(int)fret].Press();
                    }
                    else
                    {
                        animations[(int)fret].Release();
                    }
                }
            }
        }
        else
        {
            for (int i = 0; i < animations.Length; ++i)
            {
                if (!animations[i].running)
                {
                    animations[i].Release();
                }
            }
        }
    }
コード例 #2
0
    void UpdateDrumPadPresses()
    {
        ChartEditor editor   = ChartEditor.Instance;
        LaneInfo    laneInfo = editor.laneInfo;

        foreach (Note.DrumPad drumPad in EnumX <Note.DrumPad> .Values)
        {
            if (bannedDrumPadInputs.ContainsKey(drumPad))
            {
                continue;
            }

            bool lanePressed = false;
            switch (Globals.gameSettings.drumsModeOptions)
            {
            case GameSettings.DrumModeOptions.ProDrums:
            {
                lanePressed = DrumsInput.GetTomPressedInput(drumPad, laneInfo) || DrumsInput.GetCymbalPressedInput(drumPad, laneInfo);
                break;
            }

            default:
            {
                lanePressed = DrumsInput.GetPadPressedInput(drumPad, laneInfo);
                break;
            }
            }

            if (lanePressed)
            {
                animations[(int)drumPad].Press();
            }
            else
            {
                animations[(int)drumPad].Release();
            }
        }
    }
コード例 #3
0
    // Update is called once per frame
    void Update()
    {
        ChartEditor editor = ChartEditor.Instance;

        if (editor.currentState == ChartEditor.State.Playing && !GameSettings.bot)
        {
            Chart.GameMode gameMode = editor.currentChart.gameMode;
            LaneInfo       laneInfo = editor.laneInfo;

            if (gameMode == Chart.GameMode.Drums)
            {
                foreach (Note.DrumPad drumPad in EnumX <Note.DrumPad> .Values)
                {
                    if (bannedDrumPadInputs.ContainsKey(drumPad))
                    {
                        continue;
                    }

                    bool lanePressed = false;
                    switch (GameSettings.drumsModeOptions)
                    {
                    case GameSettings.DrumModeOptions.ProDrums:
                    {
                        lanePressed = DrumsInput.GetTomPressedInput(drumPad, laneInfo) || DrumsInput.GetCymbalPressedInput(drumPad, laneInfo);
                        break;
                    }

                    default:
                    {
                        lanePressed = DrumsInput.GetPadPressedInput(drumPad, laneInfo);
                        break;
                    }
                    }

                    if (lanePressed)
                    {
                        animations[(int)drumPad].Press();
                    }
                    else
                    {
                        animations[(int)drumPad].Release();
                    }
                }
            }
            else
            {
                foreach (Note.GuitarFret fret in EnumX <Note.GuitarFret> .Values)
                {
                    if (bannedFretInputs.ContainsKey(fret))
                    {
                        continue;
                    }

                    if (GuitarInput.GetFretInput(fret))
                    {
                        animations[(int)fret].Press();
                    }
                    else
                    {
                        animations[(int)fret].Release();
                    }
                }
            }
        }
        else
        {
            for (int i = 0; i < animations.Length; ++i)
            {
                if (!animations[i].running)
                {
                    animations[i].Release();
                }
            }
        }
    }
コード例 #4
0
    public void Update(float time, HitWindow <DrumsNoteHitKnowledge> hitWindow, uint noteStreak, LaneInfo laneInfo)
    {
        DrumsNoteHitKnowledge nextNoteToHit = hitWindow.oldestUnhitNote;
        int inputMask = DrumsInput.GetPadPressedInputMask(laneInfo);

        if (nextNoteToHit != null)
        {
            int noteMask = nextNoteToHit.note.mask;
            int laneMask = laneInfo.laneMask;

            // Cull notes from the notemask by lanes that are being used
            foreach (Note.DrumPad pad in EnumX <Note.DrumPad> .Values)
            {
                if (pad == Note.DrumPad.Kick)
                {
                    continue;
                }

                int padBitInput = (int)pad;
                int padMask     = 1 << padBitInput;

                bool includeLane = (padMask & laneMask) != 0;
                if (!includeLane)
                {
                    noteMask &= ~padMask;
                }
            }

            bool badHit = false;

            if ((inputMask | noteMask) != noteMask)
            {
                badHit = true;
            }
            else
            {
                foreach (Note.DrumPad drumPad in EnumX <Note.DrumPad> .Values)
                {
                    bool hitPad = DrumsInput.GetPadPressedInput(drumPad, laneInfo);
                    if (hitPad)
                    {
                        if (nextNoteToHit.GetHitTime(drumPad) == NoteHitKnowledge.NULL_TIME)
                        {
                            nextNoteToHit.SetHitTime(drumPad, time);
                        }
                        else
                        {
                            badHit = true;
                        }
                    }
                }
            }

            if (badHit)
            {
                // Bad input
                Debug.Log("Missed due to bad input");
                MissNote(time, MissSubType.Overhit);

                foreach (Note.DrumPad drumPad in EnumX <Note.DrumPad> .Values)
                {
                    nextNoteToHit.SetHitTime(drumPad, NoteHitKnowledge.NULL_TIME);
                }
            }
            else
            {
                float min = float.MaxValue, max = float.MinValue;
                int   totalHitsMask = 0;

                foreach (Note.DrumPad drumPad in EnumX <Note.DrumPad> .Values)
                {
                    if (nextNoteToHit.GetHitTime(drumPad) != NoteHitKnowledge.NULL_TIME)
                    {
                        float hitTime = nextNoteToHit.GetHitTime(drumPad);
                        min = Mathf.Min(min, hitTime);
                        max = Mathf.Max(max, hitTime);

                        totalHitsMask |= 1 << (int)drumPad;
                    }
                }

                float totalSlop = max - min;

                if (min != float.MaxValue && time - min > DrumsTiming.slopBufferTime)
                {
                    // Technically an underhit
                    Debug.Log("Missed due to underhit");
                    MissNote(time, MissSubType.Overhit);
                }
                else if (totalHitsMask == noteMask && totalSlop < DrumsTiming.slopBufferTime)
                {
                    HitNote(time, nextNoteToHit);
                }
            }
        }
        else if (inputMask != 0)
        {
            Debug.Log("Missed due to hitting pad when there was no hit in window");
            MissNote(time, MissSubType.Overhit);
        }
    }