mirror of
https://github.com/modernuo/ModernUO
synced 2026-08-11 22:23:06 -04:00
299 lines
11 KiB
C#
299 lines
11 KiB
C#
/*************************************************************************
|
|
* ModernUO *
|
|
* Copyright 2019-2026 - ModernUO Development Team *
|
|
* Email: hi@modernuo.com *
|
|
* File: Map.MultiEnumerator.cs *
|
|
* *
|
|
* This program is free software: you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation, either version 3 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
|
|
*************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using Server.Collections;
|
|
using Server.Items;
|
|
|
|
namespace Server;
|
|
|
|
public partial class Map
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiSectorEnumerable<BaseMulti> GetMultisInSector(Point3D p) => GetMultisInSector<BaseMulti>(p);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiSectorEnumerable<BaseMulti> GetMultisInSector(Point2D p) => GetMultisInSector<BaseMulti>(p);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiSectorEnumerable<BaseMulti> GetMultisInSector(int x, int y) => GetMultisInSector<BaseMulti>(x, y);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiSectorEnumerable<T> GetMultisInSector<T>(Point3D p) where T : BaseMulti =>
|
|
new(this, new Point2D(p.X, p.Y));
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiSectorEnumerable<T> GetMultisInSector<T>(Point2D p) where T : BaseMulti => new(this, p);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiSectorEnumerable<T> GetMultisInSector<T>(int x, int y) where T : BaseMulti => new(this, new Point2D(x, y));
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerable<BaseMulti> GetMultisInRange(Point3D p) => GetMultisInRange<BaseMulti>(p);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerable<BaseMulti> GetMultisInRange(Point3D p, int range) => GetMultisInRange<BaseMulti>(p, range);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerable<T> GetMultisInRange<T>(Point3D p) where T : BaseMulti => GetMultisInRange<T>(p, Core.GlobalMaxUpdateRange);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerable<T> GetMultisInRange<T>(Point3D p, int range) where T : BaseMulti =>
|
|
GetMultisInRange<T>(p.m_X, p.m_Y, range);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerable<BaseMulti> GetMultisInRange(Point2D p) => GetMultisInRange<BaseMulti>(p);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerable<BaseMulti> GetMultisInRange(Point2D p, int range) => GetMultisInRange<BaseMulti>(p, range);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerable<T> GetMultisInRange<T>(Point2D p) where T : BaseMulti => GetMultisInRange<T>(p, Core.GlobalMaxUpdateRange);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerable<T> GetMultisInRange<T>(Point2D p, int range) where T : BaseMulti =>
|
|
GetMultisInRange<T>(p.m_X, p.m_Y, range);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerable<T> GetMultisInRange<T>(int x, int y, int range) where T : BaseMulti
|
|
{
|
|
var clampedRange = Math.Max(0, range);
|
|
var edge = clampedRange * 2 + 1;
|
|
return GetMultisInBounds<T>(new Rectangle2D(x - clampedRange, y - clampedRange, edge, edge));
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerable<BaseMulti> GetMultisInBounds(Rectangle2D bounds, bool makeBoundsInclusive = false) =>
|
|
GetMultisInBounds<BaseMulti>(bounds, makeBoundsInclusive);
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerable<T> GetMultisInBounds<T>(Rectangle2D bounds, bool makeBoundsInclusive = false) where T : BaseMulti =>
|
|
new(this, bounds, makeBoundsInclusive);
|
|
|
|
private static readonly HashSet<Serial> _sharedDupes = [];
|
|
|
|
public ref struct MultiSectorEnumerable<T>(Map map, Point2D loc) where T : BaseMulti
|
|
{
|
|
public static MultiSectorEnumerable<T> Empty
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get => new();
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiSectorEnumerator<T> GetEnumerator() => new(map, loc);
|
|
}
|
|
|
|
public ref struct MultiSectorEnumerator<T> where T : BaseMulti
|
|
{
|
|
private readonly Span<BaseMulti> _list;
|
|
private readonly int _version;
|
|
private readonly Sector _sector;
|
|
private int _index;
|
|
private T _current;
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiSectorEnumerator(Map map, Point2D loc)
|
|
{
|
|
if (map == null)
|
|
{
|
|
_list = Span<BaseMulti>.Empty;
|
|
_sector = null;
|
|
_version = 0;
|
|
}
|
|
else
|
|
{
|
|
_sector = map.GetSector(loc.m_X, loc.m_Y);
|
|
_list = CollectionsMarshal.AsSpan(_sector.Multis);
|
|
_version = _sector.MultisVersion;
|
|
}
|
|
|
|
_index = -1;
|
|
_current = null;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public bool MoveNext()
|
|
{
|
|
if (_sector != null && _version != _sector.MultisVersion)
|
|
{
|
|
throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_EnumFailedVersion);
|
|
}
|
|
|
|
while (++_index < _list.Length)
|
|
{
|
|
if (_list[_index] is T { Deleted: false } o)
|
|
{
|
|
_current = o;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public T Current
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get => _current;
|
|
}
|
|
}
|
|
|
|
public ref struct MultiBoundsEnumerable<T> where T : BaseMulti
|
|
{
|
|
public static MultiBoundsEnumerable<T> Empty
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get => new(null, Rectangle2D.Empty, false);
|
|
}
|
|
|
|
private Map _map;
|
|
private Rectangle2D _bounds;
|
|
private bool _makeBoundsInclusive;
|
|
|
|
public MultiBoundsEnumerable(Map map, Rectangle2D bounds, bool makeBoundsInclusive)
|
|
{
|
|
_map = map;
|
|
_bounds = bounds;
|
|
_makeBoundsInclusive = makeBoundsInclusive;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerator<T> GetEnumerator() => new(_map, _bounds, _makeBoundsInclusive);
|
|
}
|
|
|
|
public ref struct MultiBoundsEnumerator<T> where T : BaseMulti
|
|
{
|
|
private Map _map;
|
|
private int _sectorStartX;
|
|
private int _sectorEndX;
|
|
private int _sectorEndY;
|
|
private Rectangle2D _bounds;
|
|
|
|
private int _currentSectorX;
|
|
private int _currentSectorY;
|
|
|
|
private Span<BaseMulti> _currentList;
|
|
private int _currentIndex;
|
|
private int _currentVersion;
|
|
private Sector _currentSector;
|
|
private T _current;
|
|
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public MultiBoundsEnumerator(Map map, Rectangle2D bounds, bool makeBoundsInclusive)
|
|
{
|
|
_sharedDupes.Clear();
|
|
|
|
_map = map;
|
|
_bounds = bounds;
|
|
|
|
if (makeBoundsInclusive)
|
|
{
|
|
++bounds.Width;
|
|
++bounds.Height;
|
|
}
|
|
|
|
_bounds = bounds;
|
|
|
|
if (map != null)
|
|
{
|
|
map.CalculateSectors(bounds, out _sectorStartX, out var _sectorStartY, out _sectorEndX, out _sectorEndY);
|
|
|
|
// We start the X sector one short because it gets incremented immediately in MoveNext()
|
|
_currentSectorX = _sectorStartX - 1;
|
|
_currentSectorY = _sectorStartY;
|
|
}
|
|
|
|
_currentList = default;
|
|
_currentIndex = -1;
|
|
_currentVersion = 0;
|
|
_currentSector = null;
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public bool MoveNext()
|
|
{
|
|
var map = _map;
|
|
|
|
if (map == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ref var bounds = ref _bounds;
|
|
var currentSectorX = _currentSectorX;
|
|
var currentSectorY = _currentSectorY;
|
|
var sectorEndX = _sectorEndX;
|
|
var sectorEndY = _sectorEndY;
|
|
|
|
while (true)
|
|
{
|
|
// Try to advance in the current list
|
|
if (_currentList.Length > 0)
|
|
{
|
|
if (_currentVersion != _currentSector.MultisVersion)
|
|
{
|
|
throw new InvalidOperationException(CollectionThrowStrings.InvalidOperation_EnumFailedVersion);
|
|
}
|
|
|
|
while (++_currentIndex < _currentList.Length)
|
|
{
|
|
var item = _currentList[_currentIndex];
|
|
if (item is T { Deleted: false } o && bounds.Contains(o.Location))
|
|
{
|
|
// Multis can span multiple sectors, so we need to deduplicate
|
|
if (_sharedDupes.Add(o.Serial))
|
|
{
|
|
_current = o;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Move to next sector
|
|
if (currentSectorX < sectorEndX)
|
|
{
|
|
_currentSectorX = ++currentSectorX;
|
|
}
|
|
else if (currentSectorY < sectorEndY)
|
|
{
|
|
_currentSectorX = currentSectorX = _sectorStartX;
|
|
_currentSectorY = ++currentSectorY;
|
|
}
|
|
else
|
|
{
|
|
// Ran out of sectors
|
|
return false;
|
|
}
|
|
|
|
_currentSector = map.GetRealSector(currentSectorX, currentSectorY);
|
|
_currentList = CollectionsMarshal.AsSpan(_currentSector.Multis);
|
|
_currentVersion = _currentSector.MultisVersion;
|
|
_currentIndex = -1;
|
|
}
|
|
}
|
|
|
|
public T Current
|
|
{
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
get => _current;
|
|
}
|
|
}
|
|
}
|