< Summary

Information
Class: GridForge.Grids.GridOccupantManager
Assembly: GridForge
File(s): /home/runner/work/GridForge/GridForge/src/GridForge/Grids/Managers/GridOccupantManager.cs
Line coverage
100%
Covered lines: 262
Uncovered lines: 0
Coverable lines: 262
Total lines: 718
Line coverage: 100%
Branch coverage
100%
Covered branches: 180
Total branches: 180
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
add_OnOccupantAdded(...)100%11100%
remove_OnOccupantAdded(...)100%11100%
add_OnOccupantRemoved(...)100%11100%
remove_OnOccupantRemoved(...)100%11100%
.ctor(...)100%11100%
TryRegister(...)100%66100%
GetOccupiedIndices(...)100%44100%
TryGetOccupancyTicket(...)100%88100%
TryAddVoxelOccupant(...)100%66100%
TryAddVoxelOccupant(...)100%44100%
TryAddVoxelOccupant(...)100%44100%
TryAddVoxelOccupant(...)100%66100%
TryDeregister(...)100%66100%
TryRemoveVoxelOccupant(...)100%66100%
TryRemoveVoxelOccupant(...)100%22100%
TryRemoveVoxelOccupant(...)100%44100%
TryRemoveVoxelOccupant(...)100%44100%
ForgetTrackedOccupancy(...)100%66100%
ClearTrackedOccupancies(...)100%22100%
ReleaseTrackedOccupancies(...)100%22100%
TryGetAddContext(...)100%44100%
TrackActiveScanCell(...)100%44100%
TryGetGridOccupancies(...)100%22100%
RemoveTrackedOccupancies(...)100%44100%
TryGetCurrentTrackedVoxel(...)100%66100%
TryTrackOccupancy(...)100%66100%
ForgetTrackedOccupancyUnsafe(...)100%66100%
TryRemoveTrackedTicket(...)100%22100%
TryGetTrackedRecordUnsafe(...)100%22100%
GetTrackedOccupanciesSnapshot(...)100%1010100%
TryGetRemovalContext(...)100%1010100%
TryRemoveOccupantFromScanCell(...)100%22100%
ReleaseActiveScanCellIfEmpty(...)100%66100%
TryGetOrAddOccupancyRecord(...)100%66100%
CopyTrackedOccupancies(...)100%66100%
FinalizeTrackedOccupancySnapshot(...)100%44100%
CompareTrackedOccupancies(...)100%1414100%
NotifyOccupantAdded(...)100%66100%
NotifyOccupantRemoved(...)100%66100%
GetWorldRegistry(...)100%22100%
PublishWorldRegistry(...)100%22100%
TryGetWorldRegistry(...)100%11100%

File(s)

/home/runner/work/GridForge/GridForge/src/GridForge/Grids/Managers/GridOccupantManager.cs

#LineLine coverage
 1//=======================================================================
 2// GridOccupantManager.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 System.Collections.Generic;
 10using System.Threading;
 11using GridForge.Spatial;
 12using SwiftCollections.Pool;
 13
 14namespace GridForge.Grids;
 15
 16/// <summary>
 17/// Provides utility methods for managing voxel occupants within a grid.
 18/// Supports adding, removing, and retrieving occupants with thread-safe operations.
 19/// </summary>
 20public static class GridOccupantManager
 21{
 22    #region Constants & Events
 23
 24    /// <summary>
 25    /// Maximum number of occupants allowed per voxel.
 26    /// </summary>
 27    public const byte MaxOccupantCount = byte.MaxValue;
 28
 29    /// <summary>
 30    /// Event triggered when an occupant is added.
 31    /// </summary>
 32    private static Action<OccupantEventInfo>? _onOccupantAdded;
 33
 34    /// <inheritdoc cref="_onOccupantAdded"/>
 35    public static event Action<OccupantEventInfo> OnOccupantAdded
 36    {
 1737        add => _onOccupantAdded += value;
 1738        remove => _onOccupantAdded -= value;
 39    }
 40
 41    /// <summary>
 42    /// Event triggered when an occupant is removed.
 43    /// </summary>
 44    private static Action<OccupantEventInfo>? _onOccupantRemoved;
 45
 46    /// <inheritdoc cref="_onOccupantRemoved"/>
 47    public static event Action<OccupantEventInfo> OnOccupantRemoved
 48    {
 1749        add => _onOccupantRemoved += value;
 1750        remove => _onOccupantRemoved -= value;
 51    }
 52
 53    #endregion
 54
 55    #region Private Fields
 56
 57    /// <summary>
 58    /// Immutable snapshot of one tracked occupancy.
 59    /// </summary>
 60    private readonly struct TrackedOccupancy
 61    {
 62        public readonly WorldVoxelIndex VoxelIndex;
 63        public readonly OccupantTicket Ticket;
 64
 65        public TrackedOccupancy(WorldVoxelIndex voxelIndex, OccupantTicket ticket)
 66        {
 17767            VoxelIndex = voxelIndex;
 17768            Ticket = ticket;
 17769        }
 70    }
 71
 72    #endregion
 73
 74    #region Occupant Management
 75
 76    /// <summary>
 77    /// Attempts to register the occupant with the current voxel it is on in the supplied world.
 78    /// </summary>
 79    public static bool TryRegister(GridWorld world, IVoxelOccupant occupant)
 80    {
 1281        return occupant != null
 1282            && world != null
 1283            && world.TryGetGridAndVoxel(occupant.Position, out VoxelGrid? grid, out Voxel? voxel)
 1284            && grid!.TryAddVoxelOccupant(voxel!, occupant);
 85    }
 86
 87    /// <summary>
 88    /// Returns a snapshot of the voxel indices currently tracked for the occupant in the supplied world.
 89    /// </summary>
 90    /// <param name="world">The world whose occupancy registry should be queried.</param>
 91    /// <param name="occupant">The occupant whose tracked voxel indices should be returned.</param>
 92    /// <returns>A deterministic snapshot of the occupant's currently tracked voxel indices.</returns>
 93    public static IEnumerable<WorldVoxelIndex> GetOccupiedIndices(GridWorld world, IVoxelOccupant occupant)
 94    {
 2195        TrackedOccupancy[] occupancies = GetTrackedOccupanciesSnapshot(world, occupant);
 2196        if (occupancies.Length == 0)
 1397            return Array.Empty<WorldVoxelIndex>();
 98
 899        WorldVoxelIndex[] indices = new WorldVoxelIndex[occupancies.Length];
 38100        for (int i = 0; i < occupancies.Length; i++)
 11101            indices[i] = occupancies[i].VoxelIndex;
 102
 8103        return indices;
 104    }
 105
 106    /// <summary>
 107    /// Attempts to retrieve the scan-cell ticket for the occupant at a specific voxel in the supplied world.
 108    /// </summary>
 109    /// <param name="world">The world whose occupancy registry should be queried.</param>
 110    /// <param name="occupant">The occupant whose registration should be queried.</param>
 111    /// <param name="index">The tracked voxel index to look up.</param>
 112    /// <param name="ticket">The tracked scan-cell ticket for the occupant at that voxel.</param>
 113    /// <returns>True if the occupant is registered to the voxel, otherwise false.</returns>
 114    public static bool TryGetOccupancyTicket(
 115        GridWorld world,
 116        IVoxelOccupant occupant,
 117        WorldVoxelIndex index,
 118        out OccupantTicket ticket)
 119    {
 209120        ticket = default;
 209121        if (world == null || occupant == null || !TryGetWorldRegistry(world, out WorldOccupancyRegistry? registry))
 7122            return false;
 123
 202124        lock (registry!.SyncRoot)
 202125            return TryGetTrackedRecordUnsafe(registry, occupant, out OccupancyRecord? record)
 202126                && record!.Tickets.TryGetValue(index, out ticket);
 202127    }
 128
 129    /// <summary>
 130    /// Attempts to add an occupant from the given world-scoped voxel identity in the supplied world.
 131    /// </summary>
 132    public static bool TryAddVoxelOccupant(
 133        GridWorld world,
 134        WorldVoxelIndex index,
 135        IVoxelOccupant occupant)
 136    {
 3137        return occupant != null
 3138            && world != null
 3139            && world.TryGetGridAndVoxel(index, out VoxelGrid? grid, out Voxel? voxel)
 3140            && grid!.TryAddVoxelOccupant(voxel!, occupant);
 141    }
 142
 143    /// <summary>
 144    /// Attempts to add an occupant at the given world position.
 145    /// </summary>
 146    public static bool TryAddVoxelOccupant(this VoxelGrid grid, IVoxelOccupant occupant)
 147    {
 406148        return occupant != null
 406149            && grid.TryGetVoxel(occupant.Position, out Voxel? voxel)
 406150            && grid.TryAddVoxelOccupant(voxel!, occupant);
 151    }
 152
 153    /// <summary>
 154    /// Attempts to add an occupant at the specified voxel index.
 155    /// </summary>
 156    public static bool TryAddVoxelOccupant(
 157        this VoxelGrid grid,
 158        VoxelIndex voxelIndex,
 159        IVoxelOccupant occupant)
 160    {
 6161        return occupant != null
 6162            && grid.TryGetVoxel(voxelIndex, out Voxel? target)
 6163            && grid.TryAddVoxelOccupant(target!, occupant);
 164    }
 165
 166    /// <summary>
 167    /// Adds an occupant to the grid.
 168    /// </summary>
 169    public static bool TryAddVoxelOccupant(
 170        this VoxelGrid grid,
 171        Voxel targetVoxel,
 172        IVoxelOccupant occupant)
 173    {
 839174        if (!TryGetAddContext(grid, targetVoxel, occupant, out GridWorld? world, out ScanCell? scanCell))
 1175            return false;
 176
 177        OccupantTicket ticket;
 178        byte occupantCount;
 179
 838180        lock (grid.OccupantSyncRoot)
 181        {
 838182            if (!targetVoxel.HasVacancy)
 65183                return false;
 184
 773185            ticket = scanCell!.AddOccupant(targetVoxel.WorldIndex, occupant);
 772186            if (!TryTrackOccupancy(world!, occupant, targetVoxel.WorldIndex, ticket))
 187            {
 4188                scanCell.TryRemoveOccupant(targetVoxel.WorldIndex, ticket);
 4189                return false;
 190            }
 191
 768192            TrackActiveScanCell(grid, targetVoxel.ScanCellKey);
 193
 768194            targetVoxel.OccupantCount++;
 768195            occupantCount = targetVoxel.OccupantCount;
 768196        }
 197
 768198        NotifyOccupantAdded(targetVoxel, occupant, ticket, occupantCount);
 199
 768200        return true;
 69201    }
 202
 203    /// <summary>
 204    /// Attempts to de-register the occupant from every voxel currently tracked in the supplied world.
 205    /// </summary>
 206    public static bool TryDeregister(GridWorld world, IVoxelOccupant occupant)
 207    {
 8208        TrackedOccupancy[] occupancies = GetTrackedOccupanciesSnapshot(world, occupant);
 8209        if (occupancies.Length == 0)
 1210            return false;
 211
 7212        bool removedAny = false;
 213
 32214        for (int i = 0; i < occupancies.Length; i++)
 215        {
 9216            WorldVoxelIndex voxelIndex = occupancies[i].VoxelIndex;
 9217            if (!world.TryGetGridAndVoxel(voxelIndex, out VoxelGrid? grid, out Voxel? voxel))
 218            {
 1219                removedAny |= ForgetTrackedOccupancy(world, occupant, voxelIndex);
 1220                continue;
 221            }
 222
 8223            removedAny |= grid!.TryRemoveVoxelOccupant(voxel!, occupant);
 224        }
 225
 7226        return removedAny;
 227    }
 228
 229    /// <summary>
 230    /// Attempts to remove an occupant from the given world-scoped voxel identity in the supplied world.
 231    /// </summary>
 232    public static bool TryRemoveVoxelOccupant(
 233        GridWorld world,
 234        WorldVoxelIndex index,
 235        IVoxelOccupant occupant)
 236    {
 2237        return occupant != null
 2238            && world != null
 2239            && world.TryGetGridAndVoxel(index, out VoxelGrid? grid, out Voxel? voxel)
 2240            && grid!.TryRemoveVoxelOccupant(voxel!, occupant);
 241    }
 242
 243    /// <summary>
 244    /// Attempts to remove an occupant from the given world position.
 245    /// </summary>
 246    public static bool TryRemoveVoxelOccupant(
 247        this VoxelGrid grid,
 248        IVoxelOccupant occupant)
 249    {
 143250        if (!TryGetGridOccupancies(grid, occupant, out TrackedOccupancy[] occupancies))
 4251            return false;
 252
 139253        return RemoveTrackedOccupancies(grid, occupant, occupancies);
 254    }
 255
 256    /// <summary>
 257    /// Attempts to remove an occupant at the specified voxel coordinates.
 258    /// </summary>
 259    public static bool TryRemoveVoxelOccupant(
 260        this VoxelGrid grid,
 261        VoxelIndex voxelIndex,
 262        IVoxelOccupant occupant)
 263    {
 4264        return occupant != null
 4265            && grid.TryGetVoxel(voxelIndex, out Voxel? targetVoxel)
 4266            && grid.TryRemoveVoxelOccupant(targetVoxel!, occupant);
 267    }
 268
 269    /// <summary>
 270    /// Removes an occupant from this grid.
 271    /// </summary>
 272    public static bool TryRemoveVoxelOccupant(
 273        this VoxelGrid grid,
 274        Voxel targetVoxel,
 275        IVoxelOccupant occupant)
 276    {
 165277        if (!TryGetRemovalContext(grid, targetVoxel, occupant, out ScanCell? scanCell, out OccupantTicket ticket))
 6278            return false;
 279
 159280        bool success = false;
 159281        byte occupantCount = targetVoxel.OccupantCount;
 282
 159283        lock (grid.OccupantSyncRoot)
 284        {
 159285            success = TryRemoveOccupantFromScanCell(
 159286                grid,
 159287                targetVoxel,
 159288                occupant,
 159289                scanCell!,
 159290                ticket,
 159291                out occupantCount);
 159292        }
 293
 159294        if (success)
 158295            NotifyOccupantRemoved(targetVoxel, occupant, ticket, occupantCount);
 296
 159297        return success;
 298    }
 299
 300    #endregion
 301
 302    #region Internal Helpers
 303
 304    internal static bool ForgetTrackedOccupancy(
 305        GridWorld? world,
 306        IVoxelOccupant occupant,
 307        WorldVoxelIndex index)
 308    {
 776309        if (world == null || occupant == null || !TryGetWorldRegistry(world, out WorldOccupancyRegistry? registry))
 2310            return false;
 311
 774312        lock (registry!.SyncRoot)
 774313            return ForgetTrackedOccupancyUnsafe(occupant, index, registry);
 774314    }
 315
 316    internal static void ClearTrackedOccupancies(GridWorld world)
 317    {
 1077318        if (!TryGetWorldRegistry(world, out WorldOccupancyRegistry? registry))
 985319            return;
 320
 92321        lock (registry!.SyncRoot)
 92322            registry.Records.Clear();
 92323    }
 324
 325    internal static void ReleaseTrackedOccupancies(GridWorld world)
 326    {
 327        // Detach before clearing: callers that already captured this registry retain
 328        // its lock, but subsequent lookups must not discover the released registry.
 1064329        WorldOccupancyRegistry? registry = Interlocked.Exchange(ref world.OccupancyRegistry, null);
 1064330        if (registry == null)
 975331            return;
 332
 89333        lock (registry.SyncRoot)
 89334            registry.Records.Clear();
 89335    }
 336
 337    #endregion
 338
 339    #region Private Methods
 340
 341    private static bool TryGetAddContext(
 342        VoxelGrid grid,
 343        Voxel targetVoxel,
 344        IVoxelOccupant occupant,
 345        out GridWorld? world,
 346        out ScanCell? scanCell)
 347    {
 839348        world = grid.World;
 839349        scanCell = null;
 839350        return occupant != null
 839351            && world != null
 839352            && grid.TryGetScanCell(targetVoxel.ScanCellKey, out scanCell);
 353    }
 354
 355    private static void TrackActiveScanCell(VoxelGrid grid, int scanCellKey)
 356    {
 768357        grid.ActiveScanCells ??= SwiftHashSetPool<int>.Shared.Rent();
 768358        if (!grid.ActiveScanCells.Contains(scanCellKey))
 174359            grid.ActiveScanCells.Add(scanCellKey);
 768360    }
 361
 362    private static bool TryGetGridOccupancies(
 363        VoxelGrid grid,
 364        IVoxelOccupant occupant,
 365        out TrackedOccupancy[] occupancies)
 366    {
 143367        occupancies = Array.Empty<TrackedOccupancy>();
 143368        if (grid.World == null)
 1369            return false;
 370
 142371        occupancies = GetTrackedOccupanciesSnapshot(grid.World, occupant, grid.GridIndex);
 142372        return occupancies.Length > 0;
 373    }
 374
 375    private static bool RemoveTrackedOccupancies(
 376        VoxelGrid grid,
 377        IVoxelOccupant occupant,
 378        TrackedOccupancy[] occupancies)
 379    {
 139380        bool removedAny = false;
 381
 556382        for (int i = 0; i < occupancies.Length; i++)
 383        {
 139384            WorldVoxelIndex voxelIndex = occupancies[i].VoxelIndex;
 139385            if (!TryGetCurrentTrackedVoxel(grid, voxelIndex, out Voxel? voxel))
 386            {
 2387                removedAny |= ForgetTrackedOccupancy(grid.World!, occupant, voxelIndex);
 2388                continue;
 389            }
 390
 137391            removedAny |= TryRemoveVoxelOccupant(grid, voxel!, occupant);
 392        }
 393
 139394        return removedAny;
 395    }
 396
 397    private static bool TryGetCurrentTrackedVoxel(
 398        VoxelGrid grid,
 399        WorldVoxelIndex voxelIndex,
 400        out Voxel? voxel)
 401    {
 139402        voxel = null;
 139403        return grid.World != null
 139404            && voxelIndex.WorldSpawnToken == grid.World.SpawnToken
 139405            && voxelIndex.GridSpawnToken == grid.SpawnToken
 139406            && grid.TryGetVoxel(voxelIndex.VoxelIndex, out voxel);
 407    }
 408
 409    private static bool TryTrackOccupancy(
 410        GridWorld world,
 411        IVoxelOccupant occupant,
 412        WorldVoxelIndex index,
 413        OccupantTicket ticket)
 414    {
 778415        WorldOccupancyRegistry registry = GetWorldRegistry(world);
 778416        lock (registry.SyncRoot)
 417        {
 778418            if (!TryGetOrAddOccupancyRecord(registry, world, occupant, out OccupancyRecord record))
 2419                return false;
 420
 776421            if (record.Tickets.ContainsKey(index))
 422            {
 3423                GridForgeLogger.Channel.Warn($"Occupant {occupant.GlobalId} is already registered to voxel {index}.");
 3424                return false;
 425            }
 426
 773427            record.Tickets[index] = ticket;
 773428            return true;
 429        }
 778430    }
 431
 432    private static bool ForgetTrackedOccupancyUnsafe(
 433        IVoxelOccupant occupant,
 434        WorldVoxelIndex index,
 435        WorldOccupancyRegistry registry)
 436    {
 774437        if (!TryGetTrackedRecordUnsafe(registry, occupant, out OccupancyRecord? record)
 774438            || !TryRemoveTrackedTicket(record!, index))
 439        {
 2440            return false;
 441        }
 442
 772443        if (record!.Tickets.Count == 0)
 767444            registry.Records.Remove(occupant.GlobalId);
 445
 772446        return true;
 447    }
 448
 449    private static bool TryRemoveTrackedTicket(OccupancyRecord record, WorldVoxelIndex index)
 450    {
 773451        if (!record.Tickets.ContainsKey(index))
 1452            return false;
 453
 772454        record.Tickets.Remove(index);
 772455        return true;
 456    }
 457
 458    private static bool TryGetTrackedRecordUnsafe(
 459        WorldOccupancyRegistry registry,
 460        IVoxelOccupant occupant,
 461        out OccupancyRecord? record)
 462    {
 1142463        record = null;
 1142464        if (!registry.Records.TryGetValue(occupant.GlobalId, out record))
 19465            return false;
 466
 1123467        return ReferenceEquals(record.Occupant, occupant);
 468    }
 469
 470    private static TrackedOccupancy[] GetTrackedOccupanciesSnapshot(
 471        GridWorld world,
 472        IVoxelOccupant occupant,
 473        ushort? gridIndex = null)
 474    {
 171475        if (world == null || occupant == null || !TryGetWorldRegistry(world, out WorldOccupancyRegistry? registry))
 5476            return Array.Empty<TrackedOccupancy>();
 477
 166478        lock (registry!.SyncRoot)
 479        {
 166480            if (!TryGetTrackedRecordUnsafe(registry, occupant, out OccupancyRecord? record) || record!.Tickets.Count == 
 11481                return Array.Empty<TrackedOccupancy>();
 482
 155483            TrackedOccupancy[] occupancies = new TrackedOccupancy[record.Tickets.Count];
 155484            int count = CopyTrackedOccupancies(record, gridIndex, occupancies);
 155485            return FinalizeTrackedOccupancySnapshot(occupancies, count);
 486        }
 166487    }
 488
 489    private static bool TryGetRemovalContext(
 490        VoxelGrid grid,
 491        Voxel targetVoxel,
 492        IVoxelOccupant occupant,
 493        out ScanCell? scanCell,
 494        out OccupantTicket ticket)
 495    {
 165496        scanCell = null;
 165497        ticket = default;
 498
 165499        if (occupant == null || grid.World == null)
 1500            return false;
 501
 164502        if (!TryGetOccupancyTicket(grid.World, occupant, targetVoxel.WorldIndex, out ticket))
 503        {
 4504            GridForgeLogger.Channel.Warn($"Occupant {occupant.GlobalId} is not registered to voxel {targetVoxel.WorldInd
 4505            return false;
 506        }
 507
 160508        return targetVoxel.IsOccupied
 160509            && grid.TryGetScanCell(targetVoxel.ScanCellKey, out scanCell) == true;
 510    }
 511
 512    private static bool TryRemoveOccupantFromScanCell(
 513        VoxelGrid grid,
 514        Voxel targetVoxel,
 515        IVoxelOccupant occupant,
 516        ScanCell scanCell,
 517        OccupantTicket ticket,
 518        out byte occupantCount)
 519    {
 159520        occupantCount = targetVoxel.OccupantCount;
 521
 159522        if (!scanCell.TryRemoveOccupant(targetVoxel.WorldIndex, ticket))
 1523            return false;
 524
 158525        ForgetTrackedOccupancy(grid.World!, occupant, targetVoxel.WorldIndex);
 158526        ReleaseActiveScanCellIfEmpty(grid, targetVoxel, scanCell);
 527
 158528        targetVoxel.OccupantCount--;
 158529        occupantCount = targetVoxel.OccupantCount;
 158530        return true;
 531    }
 532
 533    private static void ReleaseActiveScanCellIfEmpty(
 534        VoxelGrid grid,
 535        Voxel targetVoxel,
 536        ScanCell scanCell)
 537    {
 158538        if (scanCell.IsOccupied || grid.ActiveScanCells == null)
 134539            return;
 540
 24541        grid.ActiveScanCells.Remove(targetVoxel.ScanCellKey);
 24542        if (grid.IsOccupied)
 1543            return;
 544
 23545        GridForgeLogger.Channel.Info($"Releasing unused active scan cells collection.");
 23546        SwiftHashSetPool<int>.Shared.Release(grid.ActiveScanCells);
 23547        grid.ActiveScanCells = null;
 23548    }
 549
 550    private static bool TryGetOrAddOccupancyRecord(
 551        WorldOccupancyRegistry registry,
 552        GridWorld world,
 553        IVoxelOccupant occupant,
 554        out OccupancyRecord record)
 555    {
 778556        if (registry.Records.TryGetValue(occupant.GlobalId, out record))
 557        {
 10558            if (ReferenceEquals(record.Occupant, occupant))
 8559                return true;
 560
 2561            GridForgeLogger.Channel.Warn($"Occupant id collision detected for {occupant.GlobalId} in world {world.SpawnT
 2562            return false;
 563        }
 564
 768565        record = new OccupancyRecord(occupant);
 768566        registry.Records[occupant.GlobalId] = record;
 768567        return true;
 568    }
 569
 570    private static int CopyTrackedOccupancies(
 571        OccupancyRecord record,
 572        ushort? gridIndex,
 573        TrackedOccupancy[] occupancies)
 574    {
 155575        int count = 0;
 576
 634577        foreach (WorldVoxelIndex index in record.Tickets.Keys)
 578        {
 162579            if (gridIndex.HasValue && index.GridIndex != gridIndex.Value)
 580                continue;
 581
 159582            occupancies[count++] = new TrackedOccupancy(index, record.Tickets[index]);
 583        }
 584
 155585        return count;
 586    }
 587
 588    private static TrackedOccupancy[] FinalizeTrackedOccupancySnapshot(
 589        TrackedOccupancy[] occupancies,
 590        int count)
 591    {
 155592        if (count == 0)
 1593            return Array.Empty<TrackedOccupancy>();
 594
 154595        if (count != occupancies.Length)
 1596            Array.Resize(ref occupancies, count);
 597
 154598        Array.Sort(occupancies, CompareTrackedOccupancies);
 154599        return occupancies;
 600    }
 601
 602    private static int CompareTrackedOccupancies(TrackedOccupancy left, TrackedOccupancy right)
 603    {
 15604        int result = left.VoxelIndex.WorldSpawnToken.CompareTo(right.VoxelIndex.WorldSpawnToken);
 15605        if (result != 0)
 2606            return result;
 607
 13608        result = left.VoxelIndex.GridIndex.CompareTo(right.VoxelIndex.GridIndex);
 13609        if (result != 0)
 5610            return result;
 611
 8612        result = left.VoxelIndex.VoxelIndex.x.CompareTo(right.VoxelIndex.VoxelIndex.x);
 8613        if (result != 0)
 2614            return result;
 615
 6616        result = left.VoxelIndex.VoxelIndex.y.CompareTo(right.VoxelIndex.VoxelIndex.y);
 6617        if (result != 0)
 1618            return result;
 619
 5620        result = left.VoxelIndex.VoxelIndex.z.CompareTo(right.VoxelIndex.VoxelIndex.z);
 5621        if (result != 0)
 1622            return result;
 623
 4624        result = left.VoxelIndex.GridSpawnToken.CompareTo(right.VoxelIndex.GridSpawnToken);
 4625        if (result != 0)
 1626            return result;
 627
 3628        result = left.Ticket.Slot.CompareTo(right.Ticket.Slot);
 3629        return result != 0
 3630            ? result
 3631            : left.Ticket.Generation.CompareTo(right.Ticket.Generation);
 632    }
 633
 634    /// <summary>
 635    /// Notifies listeners that an occupant was added.
 636    /// </summary>
 637    private static void NotifyOccupantAdded(
 638        Voxel targetVoxel,
 639        IVoxelOccupant occupant,
 640        OccupantTicket ticket,
 641        byte occupantCount)
 642    {
 768643        OccupantEventInfo eventInfo = new(targetVoxel.WorldIndex, occupant, ticket, occupantCount);
 768644        Action<OccupantEventInfo>? handlers = _onOccupantAdded;
 768645        if (handlers != null)
 646        {
 5647            var handlerDelegates = handlers.GetInvocationList();
 22648            for (int i = 0; i < handlerDelegates.Length; i++)
 649            {
 650                try
 651                {
 6652                    ((Action<OccupantEventInfo>)handlerDelegates[i])(eventInfo);
 5653                }
 1654                catch (Exception ex)
 655                {
 1656                    GridForgeLogger.Channel.Error($"[Voxel {targetVoxel.WorldIndex}] Occupant add error: {ex.Message}");
 1657                }
 658            }
 659        }
 660
 768661        targetVoxel.NotifyOccupantAdded(eventInfo);
 768662    }
 663
 664    /// <summary>
 665    /// Notifies listeners that an occupant was removed.
 666    /// </summary>
 667    private static void NotifyOccupantRemoved(
 668        Voxel targetVoxel,
 669        IVoxelOccupant occupant,
 670        OccupantTicket ticket,
 671        byte occupantCount)
 672    {
 158673        OccupantEventInfo eventInfo = new(targetVoxel.WorldIndex, occupant, ticket, occupantCount);
 158674        Action<OccupantEventInfo>? handlers = _onOccupantRemoved;
 158675        if (handlers != null)
 676        {
 3677            var handlerDelegates = handlers.GetInvocationList();
 14678            for (int i = 0; i < handlerDelegates.Length; i++)
 679            {
 680                try
 681                {
 4682                    ((Action<OccupantEventInfo>)handlerDelegates[i])(eventInfo);
 3683                }
 1684                catch (Exception ex)
 685                {
 1686                    GridForgeLogger.Channel.Error($"[Voxel {targetVoxel.WorldIndex}] Occupant remove error: {ex.Message}
 1687                }
 688            }
 689        }
 690
 158691        targetVoxel.NotifyOccupantRemoved(eventInfo);
 158692    }
 693
 694    private static WorldOccupancyRegistry GetWorldRegistry(GridWorld world)
 695    {
 778696        WorldOccupancyRegistry? registry = Volatile.Read(ref world.OccupancyRegistry);
 778697        if (registry != null)
 688698            return registry;
 699
 90700        return PublishWorldRegistry(world, new WorldOccupancyRegistry());
 701    }
 702
 703    private static WorldOccupancyRegistry PublishWorldRegistry(
 704        GridWorld world,
 705        WorldOccupancyRegistry candidate)
 706    {
 707        // Return the captured winner, not a reread that can observe concurrent detachment.
 91708        return Interlocked.CompareExchange(ref world.OccupancyRegistry, candidate, null) ?? candidate;
 709    }
 710
 711    private static bool TryGetWorldRegistry(GridWorld world, out WorldOccupancyRegistry? registry)
 712    {
 2227713        registry = Volatile.Read(ref world.OccupancyRegistry);
 2227714        return registry != null;
 715    }
 716
 717    #endregion
 718}

Methods/Properties

add_OnOccupantAdded(System.Action`1<GridForge.Grids.OccupantEventInfo>)
remove_OnOccupantAdded(System.Action`1<GridForge.Grids.OccupantEventInfo>)
add_OnOccupantRemoved(System.Action`1<GridForge.Grids.OccupantEventInfo>)
remove_OnOccupantRemoved(System.Action`1<GridForge.Grids.OccupantEventInfo>)
.ctor(GridForge.Spatial.WorldVoxelIndex,GridForge.OccupantTicket)
TryRegister(GridForge.Grids.GridWorld,GridForge.Spatial.IVoxelOccupant)
GetOccupiedIndices(GridForge.Grids.GridWorld,GridForge.Spatial.IVoxelOccupant)
TryGetOccupancyTicket(GridForge.Grids.GridWorld,GridForge.Spatial.IVoxelOccupant,GridForge.Spatial.WorldVoxelIndex,GridForge.OccupantTicket&)
TryAddVoxelOccupant(GridForge.Grids.GridWorld,GridForge.Spatial.WorldVoxelIndex,GridForge.Spatial.IVoxelOccupant)
TryAddVoxelOccupant(GridForge.Grids.VoxelGrid,GridForge.Spatial.IVoxelOccupant)
TryAddVoxelOccupant(GridForge.Grids.VoxelGrid,GridForge.Spatial.VoxelIndex,GridForge.Spatial.IVoxelOccupant)
TryAddVoxelOccupant(GridForge.Grids.VoxelGrid,GridForge.Grids.Voxel,GridForge.Spatial.IVoxelOccupant)
TryDeregister(GridForge.Grids.GridWorld,GridForge.Spatial.IVoxelOccupant)
TryRemoveVoxelOccupant(GridForge.Grids.GridWorld,GridForge.Spatial.WorldVoxelIndex,GridForge.Spatial.IVoxelOccupant)
TryRemoveVoxelOccupant(GridForge.Grids.VoxelGrid,GridForge.Spatial.IVoxelOccupant)
TryRemoveVoxelOccupant(GridForge.Grids.VoxelGrid,GridForge.Spatial.VoxelIndex,GridForge.Spatial.IVoxelOccupant)
TryRemoveVoxelOccupant(GridForge.Grids.VoxelGrid,GridForge.Grids.Voxel,GridForge.Spatial.IVoxelOccupant)
ForgetTrackedOccupancy(GridForge.Grids.GridWorld,GridForge.Spatial.IVoxelOccupant,GridForge.Spatial.WorldVoxelIndex)
ClearTrackedOccupancies(GridForge.Grids.GridWorld)
ReleaseTrackedOccupancies(GridForge.Grids.GridWorld)
TryGetAddContext(GridForge.Grids.VoxelGrid,GridForge.Grids.Voxel,GridForge.Spatial.IVoxelOccupant,GridForge.Grids.GridWorld&,GridForge.Grids.ScanCell&)
TrackActiveScanCell(GridForge.Grids.VoxelGrid,System.Int32)
TryGetGridOccupancies(GridForge.Grids.VoxelGrid,GridForge.Spatial.IVoxelOccupant,GridForge.Grids.GridOccupantManager/TrackedOccupancy[]&)
RemoveTrackedOccupancies(GridForge.Grids.VoxelGrid,GridForge.Spatial.IVoxelOccupant,GridForge.Grids.GridOccupantManager/TrackedOccupancy[])
TryGetCurrentTrackedVoxel(GridForge.Grids.VoxelGrid,GridForge.Spatial.WorldVoxelIndex,GridForge.Grids.Voxel&)
TryTrackOccupancy(GridForge.Grids.GridWorld,GridForge.Spatial.IVoxelOccupant,GridForge.Spatial.WorldVoxelIndex,GridForge.OccupantTicket)
ForgetTrackedOccupancyUnsafe(GridForge.Spatial.IVoxelOccupant,GridForge.Spatial.WorldVoxelIndex,GridForge.Grids.WorldOccupancyRegistry)
TryRemoveTrackedTicket(GridForge.Grids.OccupancyRecord,GridForge.Spatial.WorldVoxelIndex)
TryGetTrackedRecordUnsafe(GridForge.Grids.WorldOccupancyRegistry,GridForge.Spatial.IVoxelOccupant,GridForge.Grids.OccupancyRecord&)
GetTrackedOccupanciesSnapshot(GridForge.Grids.GridWorld,GridForge.Spatial.IVoxelOccupant,System.Nullable`1<System.UInt16>)
TryGetRemovalContext(GridForge.Grids.VoxelGrid,GridForge.Grids.Voxel,GridForge.Spatial.IVoxelOccupant,GridForge.Grids.ScanCell&,GridForge.OccupantTicket&)
TryRemoveOccupantFromScanCell(GridForge.Grids.VoxelGrid,GridForge.Grids.Voxel,GridForge.Spatial.IVoxelOccupant,GridForge.Grids.ScanCell,GridForge.OccupantTicket,System.Byte&)
ReleaseActiveScanCellIfEmpty(GridForge.Grids.VoxelGrid,GridForge.Grids.Voxel,GridForge.Grids.ScanCell)
TryGetOrAddOccupancyRecord(GridForge.Grids.WorldOccupancyRegistry,GridForge.Grids.GridWorld,GridForge.Spatial.IVoxelOccupant,GridForge.Grids.OccupancyRecord&)
CopyTrackedOccupancies(GridForge.Grids.OccupancyRecord,System.Nullable`1<System.UInt16>,GridForge.Grids.GridOccupantManager/TrackedOccupancy[])
FinalizeTrackedOccupancySnapshot(GridForge.Grids.GridOccupantManager/TrackedOccupancy[],System.Int32)
CompareTrackedOccupancies(GridForge.Grids.GridOccupantManager/TrackedOccupancy,GridForge.Grids.GridOccupantManager/TrackedOccupancy)
NotifyOccupantAdded(GridForge.Grids.Voxel,GridForge.Spatial.IVoxelOccupant,GridForge.OccupantTicket,System.Byte)
NotifyOccupantRemoved(GridForge.Grids.Voxel,GridForge.Spatial.IVoxelOccupant,GridForge.OccupantTicket,System.Byte)
GetWorldRegistry(GridForge.Grids.GridWorld)
PublishWorldRegistry(GridForge.Grids.GridWorld,GridForge.Grids.WorldOccupancyRegistry)
TryGetWorldRegistry(GridForge.Grids.GridWorld,GridForge.Grids.WorldOccupancyRegistry&)