< Summary

Information
Class: Trailblazer.Pathing.NavigationMapOverlayState
Assembly: Trailblazer
File(s): /home/runner/work/Trailblazer/Trailblazer/src/Trailblazer/Pathing/Map/Operations/NavigationMapOverlayState.cs
Line coverage
100%
Covered lines: 139
Uncovered lines: 0
Coverable lines: 139
Total lines: 253
Line coverage: 100%
Branch coverage
100%
Covered branches: 30
Total branches: 30
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
.ctor(...)100%11100%
get_CellCount()100%11100%
get_ConnectionCount()100%11100%
get_TransitionCount()100%11100%
get_PersistentNodeCount()100%11100%
get_RetainedBytes()100%11100%
GetCellAt(...)100%11100%
GetConnectionAt(...)100%11100%
GetTransitionAt(...)100%11100%
TryGetCell(...)100%11100%
TryGetConnection(...)100%11100%
TryGetTransition(...)100%11100%
Apply(...)100%1818100%
Apply(...)100%44100%
Apply(...)100%44100%
Apply(...)100%44100%

File(s)

/home/runner/work/Trailblazer/Trailblazer/src/Trailblazer/Pathing/Map/Operations/NavigationMapOverlayState.cs

#LineLine coverage
 1//=======================================================================
 2// NavigationMapOverlayState.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2024-present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using System;
 9using GridForge.Spatial;
 10
 11namespace Trailblazer.Pathing;
 12
 13/// <summary>Stores one map's immutable overlay roots in canonical key order.</summary>
 14internal sealed class NavigationMapOverlayState
 15{
 116    internal static readonly NavigationMapOverlayState Empty = new(
 117        PersistentVoxelIndexMap<NavigationCellOverlayOperation>.Empty,
 118        PersistentStringMap<NavigationConnectionOverlayOperation>.Empty,
 119        PersistentStringMap<TraversalTransitionOverlayOperation>.Empty,
 120        highWaterSequence: 0,
 121        lastApplyCopiedNodeCount: 0,
 122        retainedPayloadBytes: 0);
 23
 24    private readonly PersistentVoxelIndexMap<NavigationCellOverlayOperation> _cells;
 25    private readonly PersistentStringMap<NavigationConnectionOverlayOperation> _connections;
 26    private readonly PersistentStringMap<TraversalTransitionOverlayOperation> _transitions;
 27
 2552728    private NavigationMapOverlayState(
 2552729        PersistentVoxelIndexMap<NavigationCellOverlayOperation> cells,
 2552730        PersistentStringMap<NavigationConnectionOverlayOperation> connections,
 2552731        PersistentStringMap<TraversalTransitionOverlayOperation> transitions,
 2552732        long highWaterSequence,
 2552733        int lastApplyCopiedNodeCount,
 2552734        long retainedPayloadBytes)
 35    {
 2552736        _cells = cells;
 2552737        _connections = connections;
 2552738        _transitions = transitions;
 2552739        HighWaterSequence = highWaterSequence;
 2552740        LastApplyCopiedNodeCount = lastApplyCopiedNodeCount;
 2552741        RetainedPayloadBytes = retainedPayloadBytes;
 2552742    }
 43
 636544    internal int CellCount => _cells.Count;
 45
 668846    internal int ConnectionCount => _connections.Count;
 47
 3754548    internal int TransitionCount => _transitions.Count;
 49
 2487050    internal int PersistentNodeCount => checked(
 2487051        _cells.PersistentNodeCount
 2487052        + _connections.PersistentNodeCount
 2487053        + _transitions.PersistentNodeCount);
 54
 2441255    internal long RetainedBytes => checked(
 2441256        48L
 2441257        + _cells.RetainedBytes
 2441258        + _connections.RetainedBytes
 2441259        + _transitions.RetainedBytes
 2441260        + RetainedPayloadBytes);
 61
 62    internal long RetainedPayloadBytes { get; }
 63
 64    internal int LastApplyCopiedNodeCount { get; }
 65
 66    internal long HighWaterSequence { get; }
 67
 68    internal NavigationCellOverlayOperation GetCellAt(int ordinal) =>
 4169        _cells.GetValueAt(ordinal);
 70
 71    internal NavigationConnectionOverlayOperation GetConnectionAt(int ordinal) =>
 572        _connections.GetValueAt(ordinal);
 73
 74    internal TraversalTransitionOverlayOperation GetTransitionAt(int ordinal) =>
 3302775        _transitions.GetValueAt(ordinal);
 76
 77    internal bool TryGetCell(VoxelIndex index, out NavigationCellOverlayOperation operation) =>
 17505678        _cells.TryGetValue(index, out operation);
 79
 80    internal bool TryGetConnection(
 81        string id,
 82        out NavigationConnectionOverlayOperation operation) =>
 449783        _connections.TryGetValue(id, out operation);
 84
 85    internal bool TryGetTransition(
 86        string id,
 87        out TraversalTransitionOverlayOperation operation) =>
 10688        _transitions.TryGetValue(id, out operation);
 89
 90    internal NavigationMapOverlayState Apply(NavigationMapOverlayDelta delta, long operationSequence)
 91    {
 2092        PersistentVoxelIndexMap<NavigationCellOverlayOperation> cells = _cells;
 2093        PersistentStringMap<NavigationConnectionOverlayOperation> connections = _connections;
 2094        PersistentStringMap<TraversalTransitionOverlayOperation> transitions = _transitions;
 2095        int copiedNodeCount = 0;
 2096        long retainedPayloadBytes = RetainedPayloadBytes;
 97
 2098        ReadOnlySpan<NavigationCellOverlayOperation> cellChanges = delta.CellSpan;
 19699        for (int i = 0; i < cellChanges.Length; i++)
 100        {
 78101            NavigationCellOverlayOperation change = cellChanges[i];
 78102            if (cells.TryGetValue(change.Index, out NavigationCellOverlayOperation prior))
 103            {
 4104                retainedPayloadBytes = checked(
 4105                    retainedPayloadBytes
 4106                    - NavigationMapOverlayDelta.EstimateRetainedPayload(prior));
 107            }
 108            int copied;
 78109            if (change.Kind == NavigationCellOverlayOperationKind.RevertToBake)
 2110                cells = cells.Remove(change.Index, out _, out copied);
 111            else
 112            {
 76113                cells = cells.Set(change.Index, change, out copied);
 76114                retainedPayloadBytes = checked(
 76115                    retainedPayloadBytes
 76116                    + NavigationMapOverlayDelta.EstimateRetainedPayload(change));
 117            }
 78118            copiedNodeCount = checked(copiedNodeCount + copied);
 119        }
 120
 20121        ReadOnlySpan<NavigationConnectionOverlayOperation> connectionChanges = delta.ConnectionSpan;
 52122        for (int i = 0; i < connectionChanges.Length; i++)
 123        {
 6124            NavigationConnectionOverlayOperation change = connectionChanges[i];
 6125            if (connections.TryGetValue(change.Id, out NavigationConnectionOverlayOperation prior))
 126            {
 2127                retainedPayloadBytes = checked(
 2128                    retainedPayloadBytes
 2129                    - NavigationMapOverlayDelta.EstimateRetainedPayload(prior));
 130            }
 131            int copied;
 6132            if (change.Kind == NavigationConnectionOverlayOperationKind.RevertToBake)
 1133                connections = connections.Remove(change.Id, out _, out copied);
 134            else
 135            {
 5136                connections = connections.Set(change.Id, change, out copied);
 5137                retainedPayloadBytes = checked(
 5138                    retainedPayloadBytes
 5139                    + NavigationMapOverlayDelta.EstimateRetainedPayload(change));
 140            }
 6141            copiedNodeCount = checked(copiedNodeCount + copied);
 142        }
 143
 20144        ReadOnlySpan<TraversalTransitionOverlayOperation> transitionChanges = delta.TransitionSpan;
 46145        for (int i = 0; i < transitionChanges.Length; i++)
 146        {
 3147            TraversalTransitionOverlayOperation change = transitionChanges[i];
 3148            if (transitions.TryGetValue(change.Id, out TraversalTransitionOverlayOperation prior))
 149            {
 2150                retainedPayloadBytes = checked(
 2151                    retainedPayloadBytes
 2152                    - NavigationMapOverlayDelta.EstimateRetainedPayload(prior));
 153            }
 154            int copied;
 3155            if (change.Kind == TraversalTransitionOverlayOperationKind.RevertToBake)
 1156                transitions = transitions.Remove(change.Id, out _, out copied);
 157            else
 158            {
 2159                transitions = transitions.Set(change.Id, change, out copied);
 2160                retainedPayloadBytes = checked(
 2161                    retainedPayloadBytes
 2162                    + NavigationMapOverlayDelta.EstimateRetainedPayload(change));
 163            }
 3164            copiedNodeCount = checked(copiedNodeCount + copied);
 165        }
 166
 20167        return new NavigationMapOverlayState(
 20168            cells,
 20169            connections,
 20170            transitions,
 20171            operationSequence,
 20172            copiedNodeCount,
 20173            retainedPayloadBytes);
 174    }
 175
 176    internal NavigationMapOverlayState Apply(
 177        NavigationCellOverlayOperation change,
 178        long operationSequence)
 179    {
 17227180        long retainedPayloadBytes = RetainedPayloadBytes;
 17227181        if (_cells.TryGetValue(change.Index, out NavigationCellOverlayOperation prior))
 72182            retainedPayloadBytes -= NavigationMapOverlayDelta.EstimateRetainedPayload(prior);
 183        int copied;
 184        PersistentVoxelIndexMap<NavigationCellOverlayOperation> cells;
 17227185        if (change.Kind == NavigationCellOverlayOperationKind.RevertToBake)
 54186            cells = _cells.Remove(change.Index, out _, out copied);
 187        else
 188        {
 17173189            cells = _cells.Set(change.Index, change, out copied);
 17173190            retainedPayloadBytes = checked(
 17173191                retainedPayloadBytes + NavigationMapOverlayDelta.EstimateRetainedPayload(change));
 192        }
 17227193        return new NavigationMapOverlayState(
 17227194            cells,
 17227195            _connections,
 17227196            _transitions,
 17227197            operationSequence,
 17227198            copied,
 17227199            retainedPayloadBytes);
 200    }
 201
 202    internal NavigationMapOverlayState Apply(
 203        NavigationConnectionOverlayOperation change,
 204        long operationSequence)
 205    {
 4158206        long retainedPayloadBytes = RetainedPayloadBytes;
 4158207        if (_connections.TryGetValue(change.Id, out NavigationConnectionOverlayOperation prior))
 23208            retainedPayloadBytes -= NavigationMapOverlayDelta.EstimateRetainedPayload(prior);
 209        int copied;
 210        PersistentStringMap<NavigationConnectionOverlayOperation> connections;
 4158211        if (change.Kind == NavigationConnectionOverlayOperationKind.RevertToBake)
 2212            connections = _connections.Remove(change.Id, out _, out copied);
 213        else
 214        {
 4156215            connections = _connections.Set(change.Id, change, out copied);
 4156216            retainedPayloadBytes = checked(
 4156217                retainedPayloadBytes + NavigationMapOverlayDelta.EstimateRetainedPayload(change));
 218        }
 4158219        return new NavigationMapOverlayState(
 4158220            _cells,
 4158221            connections,
 4158222            _transitions,
 4158223            operationSequence,
 4158224            copied,
 4158225            retainedPayloadBytes);
 226    }
 227
 228    internal NavigationMapOverlayState Apply(
 229        TraversalTransitionOverlayOperation change,
 230        long operationSequence)
 231    {
 4121232        long retainedPayloadBytes = RetainedPayloadBytes;
 4121233        if (_transitions.TryGetValue(change.Id, out TraversalTransitionOverlayOperation prior))
 9234            retainedPayloadBytes -= NavigationMapOverlayDelta.EstimateRetainedPayload(prior);
 235        int copied;
 236        PersistentStringMap<TraversalTransitionOverlayOperation> transitions;
 4121237        if (change.Kind == TraversalTransitionOverlayOperationKind.RevertToBake)
 1238            transitions = _transitions.Remove(change.Id, out _, out copied);
 239        else
 240        {
 4120241            transitions = _transitions.Set(change.Id, change, out copied);
 4120242            retainedPayloadBytes = checked(
 4120243                retainedPayloadBytes + NavigationMapOverlayDelta.EstimateRetainedPayload(change));
 244        }
 4121245        return new NavigationMapOverlayState(
 4121246            _cells,
 4121247            _connections,
 4121248            transitions,
 4121249            operationSequence,
 4121250            copied,
 4121251            retainedPayloadBytes);
 252    }
 253}
Generated by: ReportGenerator 5.5.11.0
09/02/2026 - 04:28:06
GitHub | reportgenerator.io

Methods/Properties

.cctor()
.ctor(Trailblazer.Pathing.PersistentVoxelIndexMap`1<Trailblazer.Pathing.NavigationCellOverlayOperation>,Trailblazer.Pathing.PersistentStringMap`1<Trailblazer.Pathing.NavigationConnectionOverlayOperation>,Trailblazer.Pathing.PersistentStringMap`1<Trailblazer.Pathing.TraversalTransitionOverlayOperation>,System.Int64,System.Int32,System.Int64)
get_CellCount()
get_ConnectionCount()
get_TransitionCount()
get_PersistentNodeCount()
get_RetainedBytes()
GetCellAt(System.Int32)
GetConnectionAt(System.Int32)
GetTransitionAt(System.Int32)
TryGetCell(GridForge.Spatial.VoxelIndex,Trailblazer.Pathing.NavigationCellOverlayOperation&)
TryGetConnection(System.String,Trailblazer.Pathing.NavigationConnectionOverlayOperation&)
TryGetTransition(System.String,Trailblazer.Pathing.TraversalTransitionOverlayOperation&)
Apply(Trailblazer.Pathing.NavigationMapOverlayDelta,System.Int64)
Apply(Trailblazer.Pathing.NavigationCellOverlayOperation,System.Int64)
Apply(Trailblazer.Pathing.NavigationConnectionOverlayOperation,System.Int64)
Apply(Trailblazer.Pathing.TraversalTransitionOverlayOperation,System.Int64)