juni/crystall-punk-14
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Predict tile-prying (#21167)

Browse Source
This commit is contained in:
metalgearsloth
2023-10-24 00:20:33 +11:00
committed by GitHub
parent 33935c5ce8
commit 46a3076ecb
28 changed files with 154 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Content.Shared/Construction/EntitySystems/AnchorableSystem.cs
View File

@@ -18,6 +18,7 @@ using Content.Shared.Tag;
using Robust.Shared.Player;
using Robust.Shared.Serialization;
using Robust.Shared.Utility;
using SharedToolSystem = Content.Shared.Tools.Systems.SharedToolSystem;
namespace Content.Shared.Construction.EntitySystems;

13
Content.Shared/Decals/SharedDecalSystem.cs
View File

@@ -1,3 +1,4 @@
using System.Collections;
using System.Diagnostics.CodeAnalysis;
using System.Numerics;
using Robust.Shared.GameStates;
@@ -107,6 +108,18 @@ namespace Content.Shared.Decals
{
// used by client-side overlay code
}
public virtual HashSet<(uint Index, Decal Decal)> GetDecalsInRange(EntityUid gridId, Vector2 position, float distance = 0.75f, Func<Decal, bool>? validDelegate = null)
{
// NOOP on client atm.
return new HashSet<(uint Index, Decal Decal)>();
}
public virtual bool RemoveDecal(EntityUid gridId, uint decalId, DecalGridComponent? component = null)
{
// NOOP on client atm.
return true;
}
}
// TODO: Pretty sure paul was moving this somewhere but just so people know

152
Content.Shared/Maps/TileSystem.cs Normal file
View File

@@ -0,0 +1,152 @@
using System.Linq;
using System.Numerics;
using Content.Shared.Coordinates.Helpers;
using Content.Shared.Decals;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Random;
using Robust.Shared.Utility;
namespace Content.Shared.Maps;
/// <summary>
/// Handles server-side tile manipulation like prying/deconstructing tiles.
/// </summary>
public sealed class TileSystem : EntitySystem
{
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IRobustRandom _robustRandom = default!;
[Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
[Dependency] private readonly SharedDecalSystem _decal = default!;
[Dependency] private readonly SharedMapSystem _maps = default!;
[Dependency] private readonly TurfSystem _turf = default!;
/// <summary>
/// Returns a weighted pick of a tile variant.
/// </summary>
public byte PickVariant(ContentTileDefinition tile)
{
var variants = tile.PlacementVariants;
var sum = variants.Sum();
var accumulated = 0f;
var rand = _robustRandom.NextFloat() * sum;
for (byte i = 0; i < variants.Length; ++i)
{
accumulated += variants[i];
if (accumulated >= rand)
return i;
}
// Shouldn't happen
throw new InvalidOperationException($"Invalid weighted variantize tile pick for {tile.ID}!");
}
public bool PryTile(Vector2i indices, EntityUid gridId)
{
var grid = Comp<MapGridComponent>(gridId);
var tileRef = _maps.GetTileRef(gridId, grid, indices);
return PryTile(tileRef);
}
public bool PryTile(TileRef tileRef)
{
return PryTile(tileRef, false);
}
public bool PryTile(TileRef tileRef, bool pryPlating)
{
var tile = tileRef.Tile;
if (tile.IsEmpty)
return false;
var tileDef = (ContentTileDefinition) _tileDefinitionManager[tile.TypeId];
if (!tileDef.CanCrowbar && !(pryPlating && tileDef.CanAxe))
return false;
return DeconstructTile(tileRef);
}
public bool CutTile(TileRef tileRef)
{
var tile = tileRef.Tile;
if (tile.IsEmpty)
return false;
var tileDef = (ContentTileDefinition) _tileDefinitionManager[tile.TypeId];
if (!tileDef.CanWirecutter)
return false;
return DeconstructTile(tileRef);
}
public bool ReplaceTile(TileRef tileref, ContentTileDefinition replacementTile)
{
if (!TryComp<MapGridComponent>(tileref.GridUid, out var grid))
return false;
return ReplaceTile(tileref, replacementTile, tileref.GridUid, grid);
}
public bool ReplaceTile(TileRef tileref, ContentTileDefinition replacementTile, EntityUid grid, MapGridComponent? component = null)
{
DebugTools.Assert(tileref.GridUid == grid);
if (!Resolve(grid, ref component))
return false;
var variant = PickVariant(replacementTile);
var decals = _decal.GetDecalsInRange(tileref.GridUid, _turf.GetTileCenter(tileref).Position, 0.5f);
foreach (var (id, _) in decals)
{
_decal.RemoveDecal(tileref.GridUid, id);
}
_maps.SetTile(grid, component, tileref.GridIndices, new Tile(replacementTile.TileId, 0, variant));
return true;
}
private bool DeconstructTile(TileRef tileRef)
{
if (tileRef.Tile.IsEmpty)
return false;
var tileDef = (ContentTileDefinition) _tileDefinitionManager[tileRef.Tile.TypeId];
if (string.IsNullOrEmpty(tileDef.BaseTurf))
return false;
var gridUid = tileRef.GridUid;
var mapGrid = Comp<MapGridComponent>(gridUid);
const float margin = 0.1f;
var bounds = mapGrid.TileSize - margin * 2;
var indices = tileRef.GridIndices;
var coordinates = _maps.GridTileToLocal(gridUid, mapGrid, indices)
.Offset(new Vector2(
(_robustRandom.NextFloat() - 0.5f) * bounds,
(_robustRandom.NextFloat() - 0.5f) * bounds));
//Actually spawn the relevant tile item at the right position and give it some random offset.
var tileItem = Spawn(tileDef.ItemDropPrototypeName, coordinates);
Transform(tileItem).LocalRotation = _robustRandom.NextDouble() * Math.Tau;
// Destroy any decals on the tile
var decals = _decal.GetDecalsInRange(gridUid, coordinates.SnapToGrid(EntityManager, _mapManager).Position, 0.5f);
foreach (var (id, _) in decals)
{
_decal.RemoveDecal(tileRef.GridUid, id);
}
var plating = _tileDefinitionManager[tileDef.BaseTurf];
_maps.SetTile(gridUid, mapGrid, tileRef.GridIndices, new Tile(plating.TileId));
return true;
}
}

24
Content.Shared/Maps/TurfHelpers.cs
View File

@@ -86,30 +86,6 @@ namespace Content.Shared.Maps
return tile.Tile.IsSpace(tileDefinitionManager);
}
/// <summary>
/// Returns a weighted pick of a tile variant.
/// </summary>
public static byte PickVariant(this ContentTileDefinition tile, IRobustRandom? random = null)
{
IoCManager.Resolve(ref random);
var variants = tile.PlacementVariants;
var sum = variants.Sum();
var accumulated = 0f;
var rand = random.NextFloat() * sum;
for (byte i = 0; i < variants.Length; ++i)
{
accumulated += variants[i];
if (accumulated >= rand)
return i;
}
// Shouldn't happen
throw new InvalidOperationException($"Invalid weighted variantize tile pick for {tile.ID}!");
}
/// <summary>
/// Helper that returns all entities in a turf.
/// </summary>

1
Content.Shared/Radio/EntitySystems/EncryptionKeySystem.cs
View File

@@ -14,6 +14,7 @@ using Robust.Shared.Network;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
using Robust.Shared.Timing;
using SharedToolSystem = Content.Shared.Tools.Systems.SharedToolSystem;
namespace Content.Shared.Radio.EntitySystems;

26
Content.Shared/Tools/Components/TilePryingComponent.cs Normal file
View File

@@ -0,0 +1,26 @@
using Robust.Shared.GameStates;
using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
namespace Content.Shared.Tools.Components;
/// <summary>
/// Allows prying tiles up on a grid.
/// </summary>
[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
public sealed partial class TilePryingComponent : Component
{
[DataField("toolComponentNeeded"), AutoNetworkedField]
public bool ToolComponentNeeded = true;
[DataField("qualityNeeded", customTypeSerializer:typeof(PrototypeIdSerializer<ToolQualityPrototype>)), AutoNetworkedField]
public string QualityNeeded = "Prying";
/// <summary>
/// Whether this tool can pry tiles with CanAxe.
/// </summary>
[DataField("advanced"), AutoNetworkedField]
public bool Advanced = false;
[DataField("delay"), AutoNetworkedField]
public float Delay = 1f;
}

4
Content.Shared/Tools/Systems/SharedToolSystem.MultipleTool.cs
View File

@@ -1,9 +1,9 @@
using System.Linq;
using Content.Shared.Interaction;
using Content.Shared.Tools.Components;
using Content.Shared.Prying.Components;
using Content.Shared.Tools.Components;
namespace Content.Shared.Tools;
namespace Content.Shared.Tools.Systems;
public abstract partial class SharedToolSystem : EntitySystem
{

82
Content.Shared/Tools/Systems/SharedToolSystem.TilePrying.cs Normal file
View File

@@ -0,0 +1,82 @@
using Content.Shared.Database;
using Content.Shared.Fluids.Components;
using Content.Shared.Interaction;
using Content.Shared.Maps;
using Content.Shared.Tools.Components;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
namespace Content.Shared.Tools.Systems;
public abstract partial class SharedToolSystem
{
private void InitializeTilePrying()
{
SubscribeLocalEvent<TilePryingComponent, AfterInteractEvent>(OnTilePryingAfterInteract);
SubscribeLocalEvent<TilePryingComponent, TilePryingDoAfterEvent>(OnTilePryComplete);
}
private void OnTilePryingAfterInteract(EntityUid uid, TilePryingComponent component, AfterInteractEvent args)
{
if (args.Handled || !args.CanReach || args.Target != null && !HasComp<PuddleComponent>(args.Target))
return;
if (TryPryTile(uid, args.User, component, args.ClickLocation))
args.Handled = true;
}
private void OnTilePryComplete(EntityUid uid, TilePryingComponent component, TilePryingDoAfterEvent args)
{
if (args.Cancelled)
return;
var coords = GetCoordinates(args.Coordinates);
var gridUid = coords.GetGridUid(EntityManager);
if (!TryComp(gridUid, out MapGridComponent? grid))
{
Log.Error("Attempted to pry from a non-existent grid?");
return;
}
var tile = _maps.GetTileRef(gridUid.Value, grid, coords);
var center = _turfs.GetTileCenter(tile);
if (args.Used != null)
{
_adminLogger.Add(LogType.Tile, LogImpact.Low,
$"{ToPrettyString(args.User):actor} used {ToPrettyString(args.Used.Value):tool} to pry {_tileDefManager[tile.Tile.TypeId].Name} at {center}");
}
else
{
_adminLogger.Add(LogType.Tile, LogImpact.Low,
$"{ToPrettyString(args.User):actor} pried {_tileDefManager[tile.Tile.TypeId].Name} at {center}");
}
if (_netManager.IsServer)
_tiles.PryTile(tile, component.Advanced);
}
private bool TryPryTile(EntityUid toolEntity, EntityUid user, TilePryingComponent component, EntityCoordinates clickLocation)
{
if (!TryComp<ToolComponent>(toolEntity, out var tool) && component.ToolComponentNeeded)
return false;
if (!_mapManager.TryFindGridAt(clickLocation.ToMap(EntityManager, _transformSystem), out var gridUid, out var mapGrid))
return false;
var tile = _maps.GetTileRef(gridUid, mapGrid, clickLocation);
var coordinates = _maps.GridTileToLocal(gridUid, mapGrid, tile.GridIndices);
if (!InteractionSystem.InRangeUnobstructed(user, coordinates, popup: false))
return false;
var tileDef = (ContentTileDefinition) _tileDefManager[tile.Tile.TypeId];
if (!tileDef.CanCrowbar && !(tileDef.CanAxe && component.Advanced))
return false;
var ev = new TilePryingDoAfterEvent(GetNetCoordinates(coordinates));
return UseTool(toolEntity, user, toolEntity, component.Delay, component.QualityNeeded, ev, toolComponent: tool);
}
}

23
Content.Shared/Tools/Systems/SharedToolSystem.cs
View File

@@ -1,22 +1,35 @@
using Content.Shared.Administration.Logs;
using Content.Shared.DoAfter;
using Content.Shared.Interaction;
using Content.Shared.Maps;
using Content.Shared.Tools.Components;
using Robust.Shared.Map;
using Robust.Shared.Network;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
namespace Content.Shared.Tools;
namespace Content.Shared.Tools.Systems;
public abstract partial class SharedToolSystem : EntitySystem
{
[Dependency] private readonly IPrototypeManager _protoMan = default!;
[Dependency] private readonly SharedAudioSystem _audioSystem = default!;
[Dependency] private readonly SharedDoAfterSystem _doAfterSystem = default!;
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly INetManager _netManager = default!;
[Dependency] private readonly IPrototypeManager _protoMan = default!;
[Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
[Dependency] private readonly ITileDefinitionManager _tileDefManager = default!;
[Dependency] private readonly SharedAudioSystem _audioSystem = default!;
[Dependency] private readonly SharedDoAfterSystem _doAfterSystem = default!;
[Dependency] protected readonly SharedInteractionSystem InteractionSystem = default!;
[Dependency] private readonly SharedMapSystem _maps = default!;
[Dependency] private readonly SharedTransformSystem _transformSystem = default!;
[Dependency] private readonly TileSystem _tiles = default!;
[Dependency] private readonly TurfSystem _turfs = default!;
public override void Initialize()
{
InitializeMultipleTool();
InitializeTilePrying();
SubscribeLocalEvent<ToolComponent, ToolDoAfterEvent>(OnDoAfter);
}