< Summary

Information
Class: Gravitas.CollisionHandling.CollisionPositionCorrection
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/CollisionPositionCorrection.cs
Line coverage
100%
Covered lines: 17
Uncovered lines: 0
Coverable lines: 17
Total lines: 59
Line coverage: 100%
Branch coverage
100%
Covered branches: 18
Total branches: 18
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
TryGetCompactScale(...)100%88100%
GetWeightedDistance(...)100%1010100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/CollisionPositionCorrection.cs

#LineLine coverage
 1//=======================================================================
 2// CollisionPositionCorrection.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System.Diagnostics;
 9using FixedMathSharp;
 10
 11namespace Gravitas.CollisionHandling;
 12
 13/// <summary>Retains compact correction rounding only when mass weighting cannot amplify it.</summary>
 14internal static class CollisionPositionCorrection
 15{
 16    internal static bool TryGetCompactScale(
 17        Fixed64 depth,
 18        Fixed64 inverseMassA,
 19        Fixed64 inverseMassB,
 20        out Fixed64 scale)
 21    {
 22        // Callers provide nonnegative inverse masses with a positive total.
 23        // Later mass multiplication must not amplify common-scale or normal rounding.
 5854824        if (!Fixed64.TryAdd(inverseMassA, inverseMassB, out Fixed64 totalInverseMass)
 5854825            || inverseMassA > Fixed64.One || inverseMassB > Fixed64.One
 5854826            || Fixed64.CompareProducts(depth, Fixed64.One, totalInverseMass, Fixed64.MaxValue) > 0)
 27        {
 11328            scale = default;
 11329            return false;
 30        }
 31
 5843532        scale = depth / totalInverseMass;
 33        // Rounded common scales must also fit when multiplied back by mass.
 5843534        return Fixed64.CompareProducts(scale, totalInverseMass, Fixed64.MaxValue, Fixed64.One) <= 0;
 35    }
 36
 37    internal static Fixed64 GetWeightedDistance(
 38        Fixed64 depth,
 39        Fixed64 inverseMass,
 40        Fixed64 inverseMassA,
 41        Fixed64 inverseMassB)
 42    {
 43        // Callers select one of the two masses; these exact fractions need no wide division.
 26344        if (inverseMass == Fixed64.Zero) return Fixed64.Zero;
 22645        if (inverseMassA == Fixed64.Zero || inverseMassB == Fixed64.Zero) return depth;
 19046        if (inverseMassA == inverseMassB) return depth * Fixed64.Half;
 47
 48        // A nonnegative mass fraction cannot exceed one, so the weighted depth fits
 49        // even when the shared scale or the sum of inverse masses does not.
 11450        bool fits = Fixed64.TryAdd(inverseMassA, inverseMassB, out Fixed64 totalInverseMass)
 11451            ? Fixed64.TryMultiplyDivide(depth, inverseMass, totalInverseMass, out Fixed64 distance)
 11452            : Fixed64.TryMultiplyDivideBySum(
 11453                depth, inverseMass, Fixed64.One, Fixed64.One,
 11454                inverseMassA, inverseMassB, Fixed64.Zero, Fixed64.Zero,
 11455                out distance);
 56        Debug.Assert(fits);
 11457        return distance;
 58    }
 59}