tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Revert "Explosion refactor TEST MERG (#6995)" (#7005)

Browse Source
This commit is contained in:
Leon Friedrich
2022-03-06 06:02:34 +13:00
committed by GitHub
parent cd1902cdf2
commit c95516e5b2
71 changed files with 766 additions and 3964 deletions
Download Patch File Download Diff File Expand all files Collapse all files

438
Content.Server/Explosion/EntitySystems/ExplosionSystem.GridMap.cs
View File

@@ -1,438 +0,0 @@
using Content.Shared.Atmos;
using Robust.Shared.Map;
namespace Content.Server.Explosion.EntitySystems;
// This partial part of the explosion system has all of the functions used to facilitate explosions moving across grids.
// A good portion of it is focused around keeping track of what tile-indices on a grid correspond to tiles that border
// space. AFAIK no other system currently needs to track these "edge-tiles". If they do, this should probably be a
// property of the grid itself?
public sealed partial class ExplosionSystem : EntitySystem
{
/// <summary>
/// Set of tiles of each grid that are directly adjacent to space, along with the directions that face space.
/// </summary>
private Dictionary<GridId, Dictionary<Vector2i, AtmosDirection>> _gridEdges = new();
/// <summary>
/// Set of tiles of each grid that are diagonally adjacent to space
/// </summary>
private Dictionary<GridId, HashSet<Vector2i>> _diagGridEdges = new();
/// <summary>
/// On grid startup, prepare a map of grid edges.
/// </summary>
private void OnGridStartup(GridStartupEvent ev)
{
if (!_mapManager.TryGetGrid(ev.GridId, out var grid))
return;
Dictionary<Vector2i, AtmosDirection> edges = new();
HashSet<Vector2i> diagEdges = new();
_gridEdges[ev.GridId] = edges;
_diagGridEdges[ev.GridId] = diagEdges;
foreach (var tileRef in grid.GetAllTiles())
{
if (tileRef.Tile.IsEmpty)
continue;
if (IsEdge(grid, tileRef.GridIndices, out var dir))
edges.Add(tileRef.GridIndices, dir);
else if (IsDiagonalEdge(grid, tileRef.GridIndices))
diagEdges.Add(tileRef.GridIndices);
}
}
private void OnGridRemoved(GridRemovalEvent ev)
{
_airtightMap.Remove(ev.GridId);
_gridEdges.Remove(ev.GridId);
_diagGridEdges.Remove(ev.GridId);
}
/// <summary>
/// Take our map of grid edges, where each is defined in their own grid's reference frame, and map those
/// edges all onto one grids reference frame.
/// </summary>
public (Dictionary<Vector2i, GridBlockData>, ushort) TransformGridEdges(MapId targetMap, GridId? referenceGrid, List<GridId> localGrids)
{
Dictionary<Vector2i, GridBlockData> transformedEdges = new();
var targetMatrix = Matrix3.Identity;
Angle targetAngle = new();
ushort tileSize = DefaultTileSize;
// if the explosion is centered on some grid (and not just space), get the transforms.
if (referenceGrid != null)
{
var targetGrid = _mapManager.GetGrid(referenceGrid.Value);
var xform = Transform(targetGrid.GridEntityId);
targetAngle = xform.WorldRotation;
targetMatrix = xform.InvWorldMatrix;
tileSize = targetGrid.TileSize;
}
var offsetMatrix = Matrix3.Identity;
offsetMatrix.R0C2 = tileSize / 2;
offsetMatrix.R1C2 = tileSize / 2;
// here we will get a triple nested for loop:
// foreach other grid
// foreach edge tile in that grid
// foreach tile in our grid that touches that tile (vast majority of the time: 1 tile, but could be up to 4)
HashSet<Vector2i> transformedTiles = new();
foreach (var gridToTransform in localGrids)
{
// we treat the target grid separately
if (gridToTransform == referenceGrid)
continue;
if (!_gridEdges.TryGetValue(gridToTransform, out var edges))
continue;
if (!_mapManager.TryGetGrid(gridToTransform, out var grid) ||
grid.ParentMapId != targetMap)
continue;
if (grid.TileSize != tileSize)
{
Logger.Error($"Explosions do not support grids with different grid sizes. GridIds: {gridToTransform} and {referenceGrid}");
continue;
}
var xform = EntityManager.GetComponent<TransformComponent>(grid.GridEntityId);
var matrix = offsetMatrix * xform.WorldMatrix * targetMatrix;
var angle = xform.WorldRotation - targetAngle;
var (x, y) = angle.RotateVec((tileSize / 4, tileSize / 4));
foreach (var (tile, dir) in edges)
{
var center = matrix.Transform(tile);
// this tile might touch several other tiles, or maybe just one tile. Here we use a Vector2i HashSet to
// remove duplicates.
transformedTiles.Clear();
transformedTiles.Add(new((int) MathF.Floor(center.X + x), (int) MathF.Floor(center.Y + y))); // initial direction
transformedTiles.Add(new((int) MathF.Floor(center.X - y), (int) MathF.Floor(center.Y + x))); // rotated 90 degrees
transformedTiles.Add(new((int) MathF.Floor(center.X - x), (int) MathF.Floor(center.Y - y))); // rotated 180 degrees
transformedTiles.Add(new((int) MathF.Floor(center.X + y), (int) MathF.Floor(center.Y - x))); // rotated 270 degrees
foreach (var newIndices in transformedTiles)
{
if (!transformedEdges.TryGetValue(newIndices, out var data))
{
data = new();
transformedEdges[newIndices] = data;
}
data.BlockingGridEdges.Add(new(tile, gridToTransform, center, angle, tileSize));
}
}
}
// Next we transform any diagonal edges.
Vector2i newIndex;
foreach (var gridToTransform in localGrids)
{
// we treat the target grid separately
if (gridToTransform == referenceGrid)
continue;
if (!_diagGridEdges.TryGetValue(gridToTransform, out var diagEdges))
continue;
if (!_mapManager.TryGetGrid(gridToTransform, out var grid) ||
grid.ParentMapId != targetMap)
continue;
if (grid.TileSize != tileSize)
{
Logger.Error($"Explosions do not support grids with different grid sizes. GridIds: {gridToTransform} and {referenceGrid}");
continue;
}
var xform = EntityManager.GetComponent<TransformComponent>(grid.GridEntityId);
var matrix = offsetMatrix * xform.WorldMatrix * targetMatrix;
var angle = xform.WorldRotation - targetAngle;
foreach (var tile in diagEdges)
{
var center = matrix.Transform(tile);
newIndex = new((int) MathF.Floor(center.X), (int) MathF.Floor(center.Y));
if (!transformedEdges.TryGetValue(newIndex, out var data))
{
data = new();
transformedEdges[newIndex] = data;
}
// explosions are not allowed to propagate diagonally ONTO grids. so we just use defaults for some fields.
data.BlockingGridEdges.Add(new(default, null, center, angle, tileSize));
}
}
if (referenceGrid == null)
return (transformedEdges, tileSize);
// finally, we also include the blocking tiles from the reference grid.
if (_gridEdges.TryGetValue(referenceGrid.Value, out var localEdges))
{
foreach (var (tile, _) in localEdges)
{
// grids cannot overlap, so tile should NEVER be an existing entry.
var data = new GridBlockData();
transformedEdges[tile] = data;
data.UnblockedDirections = AtmosDirection.Invalid; // all directions are blocked automatically.
data.BlockingGridEdges.Add(new(tile, referenceGrid.Value, ((Vector2) tile + 0.5f) * tileSize, 0, tileSize));
}
}
if (_diagGridEdges.TryGetValue(referenceGrid.Value, out var localDiagEdges))
{
foreach (var tile in localDiagEdges)
{
// grids cannot overlap, so tile should NEVER be an existing entry.
var data = new GridBlockData();
transformedEdges[tile] = data;
data.UnblockedDirections = AtmosDirection.Invalid; // all directions are blocked automatically.
data.BlockingGridEdges.Add(new(default, null, ((Vector2) tile + 0.5f) * tileSize, 0, tileSize));
}
}
return (transformedEdges, tileSize);
}
/// <summary>
/// Given an grid-edge blocking map, check if the blockers are allowed to propagate to each other through gaps in grids.
/// </summary>
/// <remarks>
/// After grid edges were transformed into the reference frame of some other grid, this function figures out
/// which of those edges are actually blocking explosion propagation.
/// </remarks>
public void GetUnblockedDirections(Dictionary<Vector2i, GridBlockData> transformedEdges, ushort tileSize)
{
foreach (var (tile, data) in transformedEdges)
{
if (data.UnblockedDirections == AtmosDirection.Invalid)
continue; // already all blocked.
var tileCenter = ((Vector2) tile + 0.5f) * tileSize;
foreach (var edge in data.BlockingGridEdges)
{
// if a blocking edge contains the center of the tile, block all directions
if (edge.Box.Contains(tileCenter))
{
data.UnblockedDirections = AtmosDirection.Invalid;
break;
}
// check north
if (edge.Box.Contains(tileCenter + (0, tileSize / 2)))
data.UnblockedDirections &= ~AtmosDirection.North;
// check south
if (edge.Box.Contains(tileCenter + (0, -tileSize / 2)))
data.UnblockedDirections &= ~AtmosDirection.South;
// check east
if (edge.Box.Contains(tileCenter + (tileSize / 2, 0)))
data.UnblockedDirections &= ~AtmosDirection.East;
// check west
if (edge.Box.Contains(tileCenter + (-tileSize / 2, 0)))
data.UnblockedDirections &= ~AtmosDirection.West;
}
}
}
/// <summary>
/// When a tile is updated, we might need to update the grid edge maps.
/// </summary>
private void OnTileChanged(object? sender, TileChangedEventArgs e)
{
// only need to update the grid-edge map if the tile changed from space to not-space.
if (!e.NewTile.Tile.IsEmpty && !e.OldTile.IsEmpty)
return;
var tileRef = e.NewTile;
if (!_mapManager.TryGetGrid(tileRef.GridIndex, out var grid))
return;
if (!_gridEdges.TryGetValue(tileRef.GridIndex, out var edges))
{
edges = new();
_gridEdges[tileRef.GridIndex] = edges;
}
if (!_diagGridEdges.TryGetValue(tileRef.GridIndex, out var diagEdges))
{
diagEdges = new();
_diagGridEdges[tileRef.GridIndex] = diagEdges;
}
if (tileRef.Tile.IsEmpty)
{
// if the tile is empty, it cannot itself be an edge tile.
edges.Remove(tileRef.GridIndices);
diagEdges.Remove(tileRef.GridIndices);
// add any valid neighbours to the list of edge-tiles
for (var i = 0; i < Atmospherics.Directions; i++)
{
var direction = (AtmosDirection) (1 << i);
var neighbourIndex = tileRef.GridIndices.Offset(direction);
if (grid.TryGetTileRef(neighbourIndex, out var neighbourTile) && !neighbourTile.Tile.IsEmpty)
{
edges[neighbourIndex] = edges.GetValueOrDefault(neighbourIndex) | direction.GetOpposite();
diagEdges.Remove(neighbourIndex);
}
}
foreach (var diagNeighbourIndex in GetDiagonalNeighbors(tileRef.GridIndices))
{
if (edges.ContainsKey(diagNeighbourIndex))
continue;
if (grid.TryGetTileRef(diagNeighbourIndex, out var neighbourIndex) && !neighbourIndex.Tile.IsEmpty)
diagEdges.Add(diagNeighbourIndex);
}
return;
}
// the tile is not empty space, but was previously. So update directly adjacent neighbours, which may no longer
// be edge tiles.
AtmosDirection spaceDir;
for (var i = 0; i < Atmospherics.Directions; i++)
{
var direction = (AtmosDirection) (1 << i);
var neighbourIndex = tileRef.GridIndices.Offset(direction);
if (edges.TryGetValue(neighbourIndex, out spaceDir))
{
spaceDir = spaceDir & ~direction.GetOpposite();
if (spaceDir != AtmosDirection.Invalid)
edges[neighbourIndex] = spaceDir;
else
{
// no longer a direct edge ...
edges.Remove(neighbourIndex);
// ... but it could now be a diagonal edge
if (IsDiagonalEdge(grid, neighbourIndex, tileRef.GridIndices))
diagEdges.Add(neighbourIndex);
}
}
}
// and again for diagonal neighbours
foreach (var neighborIndex in GetDiagonalNeighbors(tileRef.GridIndices))
{
if (diagEdges.Contains(neighborIndex) && !IsDiagonalEdge(grid, neighborIndex, tileRef.GridIndices))
diagEdges.Remove(neighborIndex);
}
// finally check if the new tile is itself an edge tile
if (IsEdge(grid, tileRef.GridIndices, out spaceDir))
edges.Add(tileRef.GridIndices, spaceDir);
else if (IsDiagonalEdge(grid, tileRef.GridIndices))
diagEdges.Add(tileRef.GridIndices);
}
/// <summary>
/// Check whether a tile is on the edge of a grid (i.e., whether it borders space).
/// </summary>
/// <remarks>
/// Optionally ignore a specific Vector2i. Used by <see cref="OnTileChanged"/> when we already know that a
/// given tile is not space. This avoids unnecessary TryGetTileRef calls.
/// </remarks>
private bool IsEdge(IMapGrid grid, Vector2i index, out AtmosDirection spaceDirections)
{
spaceDirections = AtmosDirection.Invalid;
for (var i = 0; i < Atmospherics.Directions; i++)
{
var direction = (AtmosDirection) (1 << i);
if (!grid.TryGetTileRef(index.Offset(direction), out var neighborTile) || neighborTile.Tile.IsEmpty)
spaceDirections |= direction;
}
return spaceDirections != AtmosDirection.Invalid;
}
private bool IsDiagonalEdge(IMapGrid grid, Vector2i index, Vector2i? ignore = null)
{
foreach (var neighbourIndex in GetDiagonalNeighbors(index))
{
if (neighbourIndex == ignore)
continue;
if (!grid.TryGetTileRef(neighbourIndex, out var neighborTile) || neighborTile.Tile.IsEmpty)
return true;
}
return false;
}
/// <summary>
/// Enumerate over diagonally adjacent tiles.
/// </summary>
internal static IEnumerable<Vector2i> GetDiagonalNeighbors(Vector2i pos)
{
yield return pos + (1, 1);
yield return pos + (-1, -1);
yield return pos + (1, -1);
yield return pos + (-1, 1);
}
}
public struct GridEdgeData : IEquatable<GridEdgeData>
{
public Vector2i Tile;
public GridId? Grid;
public Box2Rotated Box;
public GridEdgeData(Vector2i tile, GridId? grid, Vector2 center, Angle angle, float size)
{
Tile = tile;
Grid = grid;
Box = new(Box2.CenteredAround(center, (size, size)), angle, center);
}
/// <inheritdoc />
public bool Equals(GridEdgeData other)
{
return Tile.Equals(other.Tile) && Grid.Equals(other.Grid);
}
/// <inheritdoc />
public override int GetHashCode()
{
unchecked
{
return (Tile.GetHashCode() * 397) ^ Grid.GetHashCode();
}
}
}
public record GridBlockData
{
/// <summary>
/// What directions of this tile are not blocked by some other grid?
/// </summary>
public AtmosDirection UnblockedDirections = AtmosDirection.All;
/// <summary>
/// Hashset contains information about the edge-tiles, which belong to some other grid(s), that are blocking
/// this tile.
/// </summary>
public HashSet<GridEdgeData> BlockingGridEdges = new();
}