Esempio n. 1
0
    private void AddAttempt(AttackPlayerState attack)
    {
        HitAttemptStats stats = new HitAttemptStats(attack.name);

        hitAttemptDictionary.Add(GameManager.Instance.FrameCounter, stats);
        lastHitStatsFrame = GameManager.Instance.FrameCounter;

        Attempts++;
    }
Esempio n. 2
0
    private string ToCSVString()
    {
        string csv = "FrameCounter, " + HitAttemptStats.GetCSVHeader();

        foreach (int frameCount in hitAttemptDictionary.Keys)
        {
            csv += frameCount + ", " + hitAttemptDictionary[frameCount].ToCSVString();
        }

        return(csv);
    }
Esempio n. 3
0
    public void OnPlayerAttackEnded(Player player, AttackPlayerState attack)
    {
        HitAttemptStats stats = hitAttemptDictionary[lastHitStatsFrame];

        if ((stats.ResultType != ResultType.SUCCESS) && validInitFramesDictionary.ContainsKey(attack.name))
        {
            CalculateLateStats(stats, attack);
        }

        RemoveListeners(attack);
    }
Esempio n. 4
0
    private void PerAttackFrameIntersectionCheck(Bounds centeredFocusBounds, AttackPlayerState attack)
    {
        //List<int> validInitFrames;
        ValidInitFrames validInitFrames;

        if (validInitFramesDictionary.ContainsKey(attack.name))
        {
            validInitFrames = validInitFramesDictionary[attack.name];
        }
        else
        {
            validInitFrames = new ValidInitFrames();
            validInitFramesDictionary.Add(attack.name, validInitFrames);
        }
        //get old behaviour by clearing the frameCounter here
        //reset valid init frames
        //validInitFrames.Clear();

        int position = 1;

        for (float normalizedCurrentFrame = 0.0f;
             normalizedCurrentFrame < attack.FrameData.Frames.Length;
             normalizedCurrentFrame += Time.timeScale * attack.FrameData.PlayBackSpeed)
        {
            Frame frame = attack.FrameData.Frames[(int)normalizedCurrentFrame];
            foreach (Box box in frame.Boxes)
            {
                if (box is HitBox &&
                    (centeredFocusBounds.Intersects(box.GetRelativeBounds(player))))
                {
                    validInitFrames.AddToFrameSet(GameManager.Instance.FrameCounter - position);
                    break;
                }
            }

            position++;
        }

        //sort in ascending order

        /* make sure stats for last hit are present, this may not be the case if e.g. the player
         * hasn't attacked yet */
        if (hitAttemptDictionary.ContainsKey(lastHitStatsFrame))
        {
            HitAttemptStats stats = hitAttemptDictionary[lastHitStatsFrame];
            if ((stats.ResultType != ResultType.SUCCESS) && validInitFramesDictionary.ContainsKey(attack.name))
            {
                CalculateEarlyStats(stats, attack);
            }
        }
    }
Esempio n. 5
0
    private void CalculateDeltaStats(HitAttemptStats stats, AttackPlayerState attack, float maxThreshold)
    {
        List <int> validInitFrames = validInitFramesDictionary[attack.name].FrameCounts;

        if (validInitFrames.Count > 0)
        {
            foreach (int frame in validInitFrames)
            {
                int frameDelta = lastHitStatsFrame - frame;

                //if delta within maximum alotted threshold
                if (Mathf.Abs(frameDelta) < maxThreshold)
                {
                    stats.AddToHitFrameDeltaSet(frameDelta);
                }
            }
        }
    }
Esempio n. 6
0
    private void AddHit(AttackPlayerState attack)
    {
        HitAttemptStats stats = hitAttemptDictionary[lastHitStatsFrame];

        if (!stats.AttackName.Equals(attack.name))
        {
            Debug.LogError("Invalid hit add");
            return;
        }

        //only count hits once for multi-hit moves
        if ((stats.ResultType != ResultType.SUCCESS))
        {
            Hits++;
        }

        stats.ResultType       = ResultType.SUCCESS;
        stats.MinHitFrameDelta = 0;
    }
Esempio n. 7
0
 private void CalculateEarlyStats(HitAttemptStats stats, AttackPlayerState attack)
 {
     CalculateDeltaStats(stats, attack, maxEarlyThreshold);
 }