var xform = Transform(uid);
if (xform.Anchored)
{
- component.LastPosition = _mapManager.TryGetGrid(xform.GridUid, out var grid)
+ component.LastPosition = TryComp<MapGridComponent>(xform.GridUid, out var grid)
? (xform.GridUid.Value, grid.TileIndicesFor(xform.Coordinates))
: (null, new Vector2i(0, 0));
Vector2i pos;
- if (transform.Anchored && _mapManager.TryGetGrid(transform.GridUid, out var grid))
+ if (transform.Anchored && TryComp<MapGridComponent>(transform.GridUid, out var grid))
{
pos = grid.CoordinatesToTile(transform.Coordinates);
}
if (comp.LastPosition is not (EntityUid gridId, Vector2i oldPos))
return;
- if (!_mapManager.TryGetGrid(gridId, out grid))
+ if (!TryComp(gridId, out grid))
return;
pos = oldPos;
{
var directions = DirectionFlag.None;
- if (_mapManager.TryGetGrid(xform.GridUid, out grid))
+ if (TryComp(xform.GridUid, out grid))
{
var pos = grid.TileIndicesFor(xform.Coordinates);
if (xform.Anchored)
{
- if (!_mapManager.TryGetGrid(xform.GridUid, out grid))
+ if (!TryComp(xform.GridUid, out grid))
{
Log.Error($"Failed to calculate IconSmoothComponent sprite in {uid} because grid {xform.GridUid} was missing.");
return;
using Content.Shared.Movement.Systems;
using Robust.Client.GameObjects;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
using Robust.Shared.Timing;
public sealed class JetpackSystem : SharedJetpackSystem
{
[Dependency] private readonly IGameTiming _timing = default!;
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly ClothingSystem _clothing = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
var coordinates = uidXform.Coordinates;
var gridUid = coordinates.GetGridUid(EntityManager);
- if (_mapManager.TryGetGrid(gridUid, out var grid))
+ if (TryComp<MapGridComponent>(gridUid, out var grid))
{
coordinates = new EntityCoordinates(gridUid.Value, grid.WorldToLocal(coordinates.ToMapPos(EntityManager, _transform)));
}
var xform = _entityManager.GetComponent<TransformComponent>(_entityManager.GetEntity(node.Entity));
- if (!_mapManager.TryGetGrid(xform.GridUid, out var grid))
+ if (!_entityManager.TryGetComponent<MapGridComponent>(xform.GridUid, out var grid))
return;
var gridTile = grid.TileIndicesFor(xform.Coordinates);
foreach (var (gridId, gridDict) in _gridIndex)
{
- var grid = _mapManager.GetGrid(gridId);
+ var grid = _entityManager.GetComponent<MapGridComponent>(gridId);
var (_, _, worldMatrix, invMatrix) = _entityManager.GetComponent<TransformComponent>(gridId).GetWorldPositionRotationMatrixWithInv();
var lCursorBox = invMatrix.TransformBox(cursorBox);
using Robust.Client.Graphics;
using Robust.Client.ResourceManagement;
using Robust.Shared.Enums;
-using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
namespace Content.Client.Radiation.Overlays;
public sealed class RadiationDebugOverlay : Overlay
{
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IEntityManager _entityManager = default!;
private readonly RadiationSystem _radiation;
{
var gridUid = _entityManager.GetEntity(netGrid);
- if (!_mapManager.TryGetGrid(gridUid, out var grid))
+ if (!_entityManager.TryGetComponent<MapGridComponent>(gridUid, out var grid))
continue;
foreach (var (tile, rads) in blockers)
{
var gridUid = _entityManager.GetEntity(netGrid);
- if (!_mapManager.TryGetGrid(gridUid, out var grid))
+ if (!_entityManager.TryGetComponent<MapGridComponent>(gridUid, out var grid))
continue;
if (query.TryGetComponent(gridUid, out var trs) && trs.MapID != args.MapId)
continue;
{
var gridUid = _entityManager.GetEntity(netGrid);
- if (!_mapManager.TryGetGrid(gridUid, out var grid))
+ if (!_entityManager.TryGetComponent<MapGridComponent>(gridUid, out var grid))
continue;
var (destTile, _) = blockers.Last();
var destWorld = grid.GridTileToWorldPos(destTile);
var puddleOrigin = new Vector2i(0, 0);
await server.WaitAssertion(() =>
{
- var grid = mapManager.GetGrid(gridId);
+ var grid = entityManager.GetComponent<MapGridComponent>(gridId);
var solution = new Solution("Blood", FixedPoint2.New(100));
var tileRef = grid.GetTileRef(puddleOrigin);
#pragma warning disable NUnit2045 // Interdependent tests
await server.WaitAssertion(() =>
{
- var grid = mapManager.GetGrid(gridId);
+ var grid = entityManager.GetComponent<MapGridComponent>(gridId);
var puddle = GetPuddleEntity(entityManager, grid, puddleOrigin);
#pragma warning disable NUnit2045 // Interdependent tests
/// </summary>
public sealed partial class AnomalySystem
{
- [Dependency] private readonly MapSystem _mapSystem = default!;
+ [Dependency] private readonly SharedMapSystem _mapSystem = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
private void InitializeGenerator()
using Content.Server.Anomaly.Components;
using Content.Shared.Anomaly.Components;
using Content.Shared.Atmos;
-using Robust.Server.GameObjects;
-using Robust.Shared.Map;
using Robust.Shared.Random;
using System.Linq;
using System.Numerics;
+using Robust.Shared.Map.Components;
namespace Content.Server.Anomaly.Effects;
public sealed class GasProducerAnomalySystem : EntitySystem
{
[Dependency] private readonly AtmosphereSystem _atmosphere = default!;
- [Dependency] private readonly TransformSystem _xform = default!;
- [Dependency] private readonly IMapManager _map = default!;
[Dependency] private readonly IRobustRandom _random = default!;
public override void Initialize()
{
var xform = Transform(uid);
- if (!_map.TryGetGrid(xform.GridUid, out var grid))
+ if (!TryComp<MapGridComponent>(xform.GridUid, out var grid))
return;
var localpos = xform.Coordinates.Position;
using Content.Shared.Administration;
using Content.Shared.Atmos;
using Robust.Shared.Console;
-using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
namespace Content.Server.Atmos.Commands
{
public sealed class DeleteGasCommand : IConsoleCommand
{
[Dependency] private readonly IEntityManager _entManager = default!;
- [Dependency] private readonly IMapManager _mapManager = default!;
public string Command => "deletegas";
public string Description => "Removes all gases from a grid, or just of one type if specified.";
return;
}
- if (!_mapManager.TryGetGrid(gridId, out _))
+ if (!_entManager.TryGetComponent<MapGridComponent>(gridId, out _))
{
shell.WriteLine($"No grid exists with id {gridId}");
return;
using Content.Server.NodeContainer.Nodes;
using Content.Shared.Atmos;
using Content.Shared.Atmos.Components;
-using Robust.Server.GameObjects;
-using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
namespace Content.Server.Atmos.Piping.EntitySystems;
public sealed class AtmosPipeAppearanceSystem : EntitySystem
{
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
public override void Initialize()
if (!Resolve(uid, ref appearance, ref container, ref xform, false))
return;
- if (!_mapManager.TryGetGrid(xform.GridUid, out var grid))
+ if (!TryComp<MapGridComponent>(xform.GridUid, out var grid))
return;
// get connected entities
using Content.Shared.Atmos.Piping.Unary.Components;
using Content.Shared.Construction.Components;
using JetBrains.Annotations;
-using Robust.Server.GameObjects;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
namespace Content.Server.Atmos.Piping.Unary.EntitySystems
{
[UsedImplicitly]
public sealed class GasPortableSystem : EntitySystem
{
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
[Dependency] private readonly NodeContainerSystem _nodeContainer = default!;
{
port = null;
- if (!_mapManager.TryGetGrid(gridId, out var grid))
+ if (!TryComp<MapGridComponent>(gridId, out var grid))
return false;
foreach (var entityUid in grid.GetLocal(coordinates))
using Content.Shared.Administration;
using Robust.Shared.Console;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
namespace Content.Server.Decals;
return;
}
- if (!_mapManager.GridExists(gridId))
+ if (!_entManager.HasComponent<MapGridComponent>(gridId))
{
shell.WriteError($"No grid with gridId {gridId} exists.");
return;
using Content.Shared.Administration;
using Robust.Shared.Console;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using SQLitePCL;
namespace Content.Server.Decals.Commands
if (!NetEntity.TryParse(args[1], out var rawGridIdNet) ||
!_entManager.TryGetEntity(rawGridIdNet, out var rawGridId) ||
- !_mapManager.GridExists(rawGridId))
+ !_entManager.HasComponent<MapGridComponent>(rawGridId))
{
shell.WriteError("Failed parsing gridId.");
return;
return;
// Transfer decals over to the new grid.
- var enumerator = MapManager.GetGrid(ev.Grid).GetAllTilesEnumerator();
+ var enumerator = Comp<MapGridComponent>(ev.Grid).GetAllTilesEnumerator();
var oldChunkCollection = oldComp.ChunkCollection.ChunkCollection;
var chunkCollection = newComp.ChunkCollection.ChunkCollection;
using Content.Server.Disposal.Unit.Components;
using Content.Server.Disposal.Unit.EntitySystems;
using Content.Server.Popups;
-using Content.Server.UserInterface;
using Content.Shared.Destructible;
using Content.Shared.Disposal.Components;
-using Content.Shared.Hands.Components;
-using Content.Shared.Movement.Events;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
-using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
using Robust.Shared.Random;
-using Robust.Shared.Timing;
using static Content.Shared.Disposal.Components.SharedDisposalRouterComponent;
using static Content.Shared.Disposal.Components.SharedDisposalTaggerComponent;
{
public sealed class DisposalTubeSystem : EntitySystem
{
- [Dependency] private readonly IGameTiming _gameTiming = default!;
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly SharedAppearanceSystem _appearanceSystem = default!;
[Dependency] private readonly PopupSystem _popups = default!;
var oppositeDirection = nextDirection.GetOpposite();
var xform = Transform(target);
- if (!_mapManager.TryGetGrid(xform.GridUid, out var grid))
+ if (!TryComp<MapGridComponent>(xform.GridUid, out var grid))
return null;
var position = xform.Coordinates;
using Content.Shared.Movement.Systems;
using Content.Shared.NPC.Systems;
using Content.Shared.Zombies;
-using Robust.Shared.Audio;
using Robust.Shared.Audio.Systems;
-using Robust.Shared.GameStates;
using Robust.Shared.Map;
-using Robust.Shared.Player;
+using Robust.Shared.Map.Components;
namespace Content.Server.Dragon;
public sealed partial class DragonSystem : EntitySystem
{
[Dependency] private readonly CarpRiftsConditionSystem _carpRifts = default!;
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly ITileDefinitionManager _tileDef = default!;
[Dependency] private readonly MovementSpeedModifierSystem _movement = default!;
[Dependency] private readonly NpcFactionSystem _faction = default!;
var xform = Transform(uid);
// Have to be on a grid fam
- if (!_mapManager.TryGetGrid(xform.GridUid, out var grid))
+ if (!TryComp<MapGridComponent>(xform.GridUid, out var grid))
{
_popup.PopupEntity(Loc.GetString("carp-rift-anchor"), uid, uid);
return;
using Content.Shared.Maps;
using Content.Shared.Stacks;
using JetBrains.Annotations;
-using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
namespace Content.Server.Engineering.EntitySystems
{
[UsedImplicitly]
public sealed class SpawnAfterInteractSystem : EntitySystem
{
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly SharedDoAfterSystem _doAfterSystem = default!;
[Dependency] private readonly StackSystem _stackSystem = default!;
return;
if (string.IsNullOrEmpty(component.Prototype))
return;
- if (!_mapManager.TryGetGrid(args.ClickLocation.GetGridUid(EntityManager), out var grid))
+ if (!TryComp<MapGridComponent>(args.ClickLocation.GetGridUid(EntityManager), out var grid))
return;
if (!grid.TryGetTileRef(args.ClickLocation, out var tileRef))
return;
using Content.Shared.Damage;
using Content.Shared.Explosion;
using Content.Shared.FixedPoint;
-using Robust.Shared.Map;
using Robust.Shared.Map.Components;
namespace Content.Server.Explosion.EntitySystems;
if (!EntityManager.TryGetComponent(uid, out TransformComponent? transform) || !transform.Anchored)
return;
- if (!_mapManager.TryGetGrid(transform.GridUid, out var grid))
+ if (!TryComp<MapGridComponent>(transform.GridUid, out var grid))
return;
UpdateAirtightMap(transform.GridUid.Value, grid, grid.CoordinatesToTile(transform.Coordinates));
/// </summary>
private void OnGridStartup(GridStartupEvent ev)
{
- var grid = _mapManager.GetGrid(ev.EntityUid);
+ var grid = Comp<MapGridComponent>(ev.EntityUid);
Dictionary<Vector2i, NeighborFlag> edges = new();
_gridEdges[ev.EntityUid] = edges;
using Content.Shared.Explosion;
using Content.Shared.Explosion.Components;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
using Robust.Shared.Timing;
else if (referenceGrid != null)
{
// reference grid defines coordinate system that the explosion in space will use
- initialTile = _mapManager.GetGrid(referenceGrid.Value).WorldToTile(epicenter.Position);
+ initialTile = Comp<MapGridComponent>(referenceGrid.Value).WorldToTile(epicenter.Position);
}
else
{
var spaceAngle = Angle.Zero;
if (referenceGrid != null)
{
- var xform = Transform(_mapManager.GetGrid(referenceGrid.Value).Owner);
+ var xform = Transform(Comp<MapGridComponent>(referenceGrid.Value).Owner);
spaceMatrix = xform.WorldMatrix;
spaceAngle = xform.WorldRotation;
}
airtightMap = new();
var initialGridData = new ExplosionGridTileFlood(
- _mapManager.GetGrid(epicentreGrid.Value),
+ Comp<MapGridComponent>(epicentreGrid.Value),
airtightMap,
maxIntensity,
stepSize,
airtightMap = new();
data = new ExplosionGridTileFlood(
- _mapManager.GetGrid(grid),
+ Comp<MapGridComponent>(grid),
airtightMap,
maxIntensity,
stepSize,
using Robust.Shared.Audio;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Events;
using Robust.Shared.Physics.Systems;
public sealed class ImmovableRodSystem : EntitySystem
{
[Dependency] private readonly IRobustRandom _random = default!;
- [Dependency] private readonly IMapManager _map = default!;
[Dependency] private readonly BodySystem _bodySystem = default!;
[Dependency] private readonly PopupSystem _popup = default!;
if (!rod.DestroyTiles)
continue;
- if (!_map.TryGetGrid(trans.GridUid, out var grid))
+ if (!TryComp<MapGridComponent>(trans.GridUid, out var grid))
continue;
grid.SetTile(trans.Coordinates, Tile.Empty);
using Content.Shared.Maps;
using Robust.Shared.Console;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
namespace Content.Server.Interaction
{
var xform = _entities.GetComponent<TransformComponent>(attached);
var playerGrid = xform.GridUid;
- if (!mapManager.TryGetGrid(playerGrid, out var mapGrid))
+ if (!_entities.TryGetComponent<MapGridComponent>(playerGrid, out var mapGrid))
return;
var playerPosition = xform.Coordinates;
using Robust.Shared.Audio;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Random;
using Robust.Shared.Serialization.Manager;
using Robust.Shared.Spawners;
// This is shit but you get the idea.
var directionPos = casterXform.Coordinates.Offset(casterXform.LocalRotation.ToWorldVec().Normalized());
- if (!_mapManager.TryGetGrid(casterXform.GridUid, out var mapGrid))
+ if (!TryComp<MapGridComponent>(casterXform.GridUid, out var mapGrid))
return new List<EntityCoordinates>();
if (!directionPos.TryGetTileRef(out var tileReference, EntityManager, _mapManager))
using Content.Server.NPC.Pathfinding;
using Content.Server.NPC.Systems;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
namespace Content.Server.NPC.HTN.PrimitiveTasks.Operators;
public sealed partial class MoveToOperator : HTNOperator, IHtnConditionalShutdown
{
[Dependency] private readonly IEntityManager _entManager = default!;
- [Dependency] private readonly IMapManager _mapManager = default!;
private NPCSteeringSystem _steering = default!;
private PathfindingSystem _pathfind = default!;
private SharedTransformSystem _transform = default!;
!_entManager.TryGetComponent<PhysicsComponent>(owner, out var body))
return (false, null);
- if (!_mapManager.TryGetGrid(xform.GridUid, out var ownerGrid) ||
- !_mapManager.TryGetGrid(targetCoordinates.GetGridUid(_entManager), out var targetGrid))
+ if (!_entManager.TryGetComponent<MapGridComponent>(xform.GridUid, out var ownerGrid) ||
+ !_entManager.TryGetComponent<MapGridComponent>(targetCoordinates.GetGridUid(_entManager), out var targetGrid))
{
return (false, null);
}
using Content.Shared.DoAfter;
using Content.Shared.Doors.Components;
using Content.Shared.NPC;
+using Robust.Shared.Map.Components;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
using Robust.Shared.Utility;
private void GetObstacleEntities(PathPoly poly, int mask, int layer, List<EntityUid> ents)
{
// TODO: Can probably re-use this from pathfinding or something
- if (!_mapManager.TryGetGrid(poly.GraphUid, out var grid))
+ if (!TryComp<MapGridComponent>(poly.GraphUid, out var grid))
{
return;
}
[Dependency] private readonly IAdminManager _admin = default!;
[Dependency] private readonly IConfigurationManager _configManager = default!;
[Dependency] private readonly IGameTiming _timing = default!;
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly ClimbSystem _climb = default!;
[Dependency] private readonly DoAfterSystem _doAfter = default!;
using JetBrains.Annotations;
using Robust.Server.Player;
using Robust.Shared.Enums;
-using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Player;
using Robust.Shared.Utility;
[Dependency] private readonly IAdminManager _adminManager = default!;
[Dependency] private readonly INodeGroupFactory _nodeGroupFactory = default!;
[Dependency] private readonly ILogManager _logManager = default!;
- [Dependency] private readonly IMapManager _mapManager = default!;
private readonly List<int> _visDeletes = new();
private readonly List<BaseNodeGroup> _visSends = new();
private IEnumerable<Node> GetCompatibleNodes(Node node, EntityQuery<TransformComponent> xformQuery, EntityQuery<NodeContainerComponent> nodeQuery)
{
var xform = xformQuery.GetComponent(node.Owner);
- _mapManager.TryGetGrid(xform.GridUid, out var grid);
+ TryComp<MapGridComponent>(xform.GridUid, out var grid);
if (!node.Connectable(EntityManager, xform))
yield break;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Player;
using Robust.Shared.Random;
[Dependency] private readonly AlertLevelSystem _alertLevel = default!;
[Dependency] private readonly ChatSystem _chatSystem = default!;
[Dependency] private readonly ExplosionSystem _explosions = default!;
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly ITileDefinitionManager _tileDefManager = default!;
[Dependency] private readonly ItemSlotsSystem _itemSlots = default!;
}
else
{
- if (!_mapManager.TryGetGrid(xform.GridUid, out var grid))
+ if (!TryComp<MapGridComponent>(xform.GridUid, out var grid))
return;
var worldPos = _transform.GetWorldPosition(xform);
using Content.Shared.Movement.Systems;
using Content.Shared.Shuttles.Components;
using Content.Shared.Shuttles.Systems;
-using Robust.Shared.Map;
using Robust.Shared.Physics.Components;
using Robust.Shared.Player;
using DroneConsoleComponent = Content.Server.Shuttles.DroneConsoleComponent;
using DependencyAttribute = Robust.Shared.IoC.DependencyAttribute;
+using Robust.Shared.Map.Components;
namespace Content.Server.Physics.Controllers
{
public sealed class MoverController : SharedMoverController
{
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly ThrusterSystem _thruster = default!;
[Dependency] private readonly SharedTransformSystem _xformSystem = default!;
var gridId = xform.GridUid;
// This tries to see if the grid is a shuttle and if the console should work.
- if (!_mapManager.TryGetGrid(gridId, out var _) ||
+ if (!TryComp<MapGridComponent>(gridId, out var _) ||
!shuttleQuery.TryGetComponent(gridId, out var shuttleComponent) ||
!shuttleComponent.Enabled)
continue;
using Content.Shared.Interaction;
using Content.Shared.Maps;
using Content.Shared.Stacks;
+using Robust.Shared.Map.Components;
namespace Content.Server.Power.EntitySystems;
if (component.CablePrototypeId == null)
return;
- if(!_mapManager.TryGetGrid(args.ClickLocation.GetGridUid(EntityManager), out var grid))
+ if(!TryComp<MapGridComponent>(args.ClickLocation.GetGridUid(EntityManager), out var grid))
return;
var snapPos = grid.TileIndicesFor(args.ClickLocation);
using Content.Shared.Database;
using Content.Shared.DoAfter;
using Content.Shared.Interaction;
-using Content.Shared.Tools;
-using Content.Shared.Tools.Components;
using Robust.Shared.Map;
-using System.Xml.Schema;
using CableCuttingFinishedEvent = Content.Shared.Tools.Systems.CableCuttingFinishedEvent;
using SharedToolSystem = Content.Shared.Tools.Systems.SharedToolSystem;
public sealed partial class CableSystem : EntitySystem
{
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly ITileDefinitionManager _tileManager = default!;
[Dependency] private readonly SharedToolSystem _toolSystem = default!;
[Dependency] private readonly StackSystem _stack = default!;
[Dependency] private readonly ElectrocutionSystem _electrocutionSystem = default!;
[Dependency] private readonly IAdminLogManager _adminLogs = default!;
- [Dependency] private readonly PowerMonitoringConsoleSystem _powerMonitoringSystem = default!;
public override void Initialize()
{
using Content.Server.Power.Nodes;
using Content.Shared.Wires;
using JetBrains.Annotations;
-using Robust.Server.GameObjects;
-using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
namespace Content.Server.Power.EntitySystems
{
[UsedImplicitly]
public sealed class CableVisSystem : EntitySystem
{
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
[Dependency] private readonly NodeContainerSystem _nodeContainer = default!;
return;
var transform = Transform(uid);
- if (!_mapManager.TryGetGrid(transform.GridUid, out var grid))
+ if (!TryComp<MapGridComponent>(transform.GridUid, out var grid))
return;
var mask = WireVisDirFlags.None;
using Content.Shared.Physics;
using Content.Shared.Respawn;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Random;
namespace Content.Server.Respawn;
public sealed class SpecialRespawnSystem : SharedSpecialRespawnSystem
{
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IAdminLogManager _adminLog = default!;
[Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
[Dependency] private readonly AtmosphereSystem _atmosphere = default!;
if (!component.Respawn || !HasComp<StationMemberComponent>(entityGridUid) || entityMapUid == null)
return;
- if (!_mapManager.TryGetGrid(entityGridUid, out var grid) || MetaData(entityGridUid.Value).EntityLifeStage >= EntityLifeStage.Terminating)
+ if (!TryComp<MapGridComponent>(entityGridUid, out var grid) || MetaData(entityGridUid.Value).EntityLifeStage >= EntityLifeStage.Terminating)
return;
if (TryFindRandomTile(entityGridUid.Value, entityMapUid.Value, 10, out var coords))
{
targetCoords = EntityCoordinates.Invalid;
- if (!_mapManager.TryGetGrid(targetGrid, out var grid))
+ if (!TryComp<MapGridComponent>(targetGrid, out var grid))
return false;
var xform = Transform(targetGrid);
using Content.Shared.Damage;
using Content.Shared.Revenant;
using Robust.Shared.Random;
-using Robust.Shared.Map;
using Content.Shared.Tag;
using Content.Server.Storage.Components;
using Content.Server.Light.Components;
using Content.Shared.Bed.Sleep;
using System.Linq;
using System.Numerics;
-using Content.Server.Maps;
using Content.Server.Revenant.Components;
using Content.Shared.DoAfter;
using Content.Shared.Emag.Systems;
using Content.Shared.Revenant.Components;
using Robust.Shared.Physics.Components;
using Robust.Shared.Utility;
+using Robust.Shared.Map.Components;
namespace Content.Server.Revenant.EntitySystems;
public sealed partial class RevenantSystem
{
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly ThrowingSystem _throwing = default!;
[Dependency] private readonly EntityStorageSystem _entityStorage = default!;
[Dependency] private readonly EmagSystem _emag = default!;
//var coords = Transform(uid).Coordinates;
//var gridId = coords.GetGridUid(EntityManager);
var xform = Transform(uid);
- if (!_mapManager.TryGetGrid(xform.GridUid, out var map))
+ if (!TryComp<MapGridComponent>(xform.GridUid, out var map))
return;
var tiles = map.GetTilesIntersecting(Box2.CenteredAround(xform.WorldPosition,
new Vector2(component.DefileRadius * 2, component.DefileRadius))).ToArray();
return;
}
- centcomm.ShuttleIndex += _mapManager.GetGrid(shuttle.Value).LocalAABB.Width + ShuttleSpawnBuffer;
+ centcomm.ShuttleIndex += Comp<MapGridComponent>(shuttle.Value).LocalAABB.Width + ShuttleSpawnBuffer;
// Update indices for all centcomm comps pointing to same map
var query = AllEntityQuery<StationCentcommComponent>();
private float GetSoundRange(EntityUid uid)
{
- if (!_mapManager.TryGetGrid(uid, out var grid))
+ if (!TryComp<MapGridComponent>(uid, out var grid))
return 4f;
return MathF.Max(grid.LocalAABB.Width, grid.LocalAABB.Height) + 12.5f;
using Content.Shared.Shuttles.Components;
using Content.Shared.Temperature;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Collision.Shapes;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Events;
return;
var tilePos = args.NewTile.GridIndices;
- var grid = _mapManager.GetGrid(uid);
+ var grid = Comp<MapGridComponent>(uid);
var xformQuery = GetEntityQuery<TransformComponent>();
var thrusterQuery = GetEntityQuery<ThrusterComponent>();
return true;
var (x, y) = xform.LocalPosition + xform.LocalRotation.Opposite().ToWorldVec();
- var tile = _mapManager.GetGrid(xform.GridUid.Value).GetTileRef(new Vector2i((int) Math.Floor(x), (int) Math.Floor(y)));
+ var tile = Comp<MapGridComponent>(xform.GridUid.Value).GetTileRef(new Vector2i((int) Math.Floor(x), (int) Math.Floor(y)));
return tile.Tile.IsSpace();
}
/// </summary>
public void ConsumeTile(EntityUid hungry, TileRef tile, EventHorizonComponent eventHorizon)
{
- ConsumeTiles(hungry, new List<(Vector2i, Tile)>(new[] { (tile.GridIndices, Tile.Empty) }), tile.GridUid, _mapMan.GetGrid(tile.GridUid), eventHorizon);
+ ConsumeTiles(hungry, new List<(Vector2i, Tile)>(new[] { (tile.GridIndices, Tile.Empty) }), tile.GridUid, Comp<MapGridComponent>(tile.GridUid), eventHorizon);
}
/// <summary>
/// </summary>
public void AttemptConsumeTile(EntityUid hungry, TileRef tile, EventHorizonComponent eventHorizon)
{
- AttemptConsumeTiles(hungry, new TileRef[1] { tile }, tile.GridUid, _mapMan.GetGrid(tile.GridUid), eventHorizon);
+ AttemptConsumeTiles(hungry, new TileRef[1] { tile }, tile.GridUid, Comp<MapGridComponent>(tile.GridUid), eventHorizon);
}
/// <summary>
using Content.Shared.Construction.Components;
using Content.Shared.SubFloor;
+using Robust.Shared.Map.Components;
namespace Content.Server.SubFloor;
// No teleporting entities through floor tiles when anchoring them.
var xform = Transform(uid);
- if (MapManager.TryGetGrid(xform.GridUid, out var grid)
+ if (TryComp<MapGridComponent>(xform.GridUid, out var grid)
&& HasFloorCover(grid, grid.TileIndicesFor(xform.Coordinates)))
{
args.Cancel();
using System.Numerics;
-using Content.Server.Maps;
using Content.Server.Xenoarchaeology.XenoArtifacts.Effects.Components;
using Content.Server.Xenoarchaeology.XenoArtifacts.Events;
-using Content.Shared.Ghost;
using Content.Shared.Maps;
using Content.Shared.Physics;
using Content.Shared.Throwing;
-using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
using Robust.Shared.Random;
public sealed class ThrowArtifactSystem : EntitySystem
{
- [Dependency] private readonly IMapManager _map = default!;
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly EntityLookupSystem _lookup = default!;
[Dependency] private readonly ThrowingSystem _throwing = default!;
private void OnActivated(EntityUid uid, ThrowArtifactComponent component, ArtifactActivatedEvent args)
{
var xform = Transform(uid);
- if (_map.TryGetGrid(xform.GridUid, out var grid))
+ if (TryComp<MapGridComponent>(xform.GridUid, out var grid))
{
var tiles = grid.GetTilesIntersecting(
Box2.CenteredAround(xform.WorldPosition, new Vector2(component.Range * 2, component.Range)));
// Probably ignore CanCollide on the anchoring body?
var gridUid = coordinates.GetGridUid(EntityManager);
- if (!_mapManager.TryGetGrid(gridUid, out var grid))
+ if (!TryComp<MapGridComponent>(gridUid, out var grid))
return false;
var tileIndices = grid.TileIndicesFor(coordinates);
return EntityCoordinates.FromMap(coordinates.EntityId, mapPos, xformSys);
}
- var grid = mapManager.GetGrid(gridId.Value);
+ var grid = entMan.GetComponent<MapGridComponent>(gridId.Value);
var tileSize = grid.TileSize;
var localPos = coordinates.WithEntityId(gridId.Value).Position;
var x = (int)Math.Floor(localPos.X / tileSize) + tileSize / 2f;
using System.Runtime.CompilerServices;
using Content.Shared.Physics;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Random;
namespace Content.Shared.Maps
/// <summary>
/// Attempts to get the turf at map indices with grid id or null if no such turf is found.
/// </summary>
- public static TileRef GetTileRef(this Vector2i vector2i, EntityUid gridId, IMapManager? mapManager = null)
+ public static TileRef GetTileRef(this Vector2i vector2i, EntityUid gridId, IEntityManager? entityManager = null)
{
- mapManager ??= IoCManager.Resolve<IMapManager>();
+ entityManager ??= IoCManager.Resolve<IEntityManager>();
- if (!mapManager.TryGetGrid(gridId, out var grid))
+ if (!entityManager.TryGetComponent<MapGridComponent>(gridId, out var grid))
return default;
if (!grid.TryGetTileRef(vector2i, out var tile))
private static bool GetWorldTileBox(TileRef turf, out Box2Rotated res)
{
var entManager = IoCManager.Resolve<IEntityManager>();
- var map = IoCManager.Resolve<IMapManager>();
- if (map.TryGetGrid(turf.GridUid, out var tileGrid))
+ if (entManager.TryGetComponent<MapGridComponent>(turf.GridUid, out var tileGrid))
{
var gridRot = entManager.GetComponent<TransformComponent>(turf.GridUid).WorldRotation;
/// </summary>
public EntityCoordinates GetTileCenter(TileRef turf)
{
- var grid = _mapMan.GetGrid(turf.GridUid);
+ var grid = Comp<MapGridComponent>(turf.GridUid);
var center = (turf.GridIndices + new Vector2(0.5f, 0.5f)) * grid.TileSize;
return new EntityCoordinates(turf.GridUid, center);
}
sound = null;
// Fallback to the map?
- if (!_mapManager.TryGetGrid(xform.GridUid, out var grid))
+ if (!TryComp<MapGridComponent>(xform.GridUid, out var grid))
{
if (TryComp<FootstepModifierComponent>(xform.MapUid, out var modifier))
{
using Content.Shared.Gravity;
using Content.Shared.Movement.Systems;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Controllers;
EntityQuery<PhysicsComponent> bodyQuery)
{
// Check if the thing's centre overlaps the grid tile.
- var grid = MapManager.GetGrid(xform.GridUid!.Value);
+ var grid = Comp<MapGridComponent>(xform.GridUid!.Value);
var tile = grid.GetTileRef(xform.Coordinates);
var conveyorBounds = Lookup.GetLocalBounds(tile, grid.TileSize);
return;
}
- var mapGrid = _mapMan.GetGrid(gridId.Value);
+ var mapGrid = Comp<MapGridComponent>(gridId.Value);
var tile = mapGrid.GetTileRef(location);
if (!IsRCDStillValid(uid, comp, args.Event.User, args.Event.Target, mapGrid, tile, args.Event.StartingMode))
return;
}
- var mapGrid = _mapMan.GetGrid(gridId.Value);
+ var mapGrid = Comp<MapGridComponent>(gridId.Value);
var tile = mapGrid.GetTileRef(location);
var snapPos = mapGrid.TileIndicesFor(location);
using Robust.Shared.Audio;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
using Robust.Shared.Network;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Events;
{
[Dependency] private readonly IGameTiming _timing = default!;
[Dependency] private readonly INetManager _netMan = default!;
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly ITileDefinitionManager _tileDefMan = default!;
[Dependency] protected readonly IRobustRandom Random = default!;
[Dependency] private readonly SharedAudioSystem _audioSystem = default!;
{
if (!args.PlaySound ||
!TryComp<TransformComponent>(uid, out var xform) ||
- !_mapManager.TryGetGrid(xform.GridUid, out var grid))
+ !TryComp<MapGridComponent>(xform.GridUid, out var grid))
{
return;
}
[UsedImplicitly]
public abstract class SharedSubFloorHideSystem : EntitySystem
{
- [Dependency] protected readonly IMapManager MapManager = default!;
[Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
[Dependency] private readonly SharedAmbientSoundSystem _ambientSoundSystem = default!;
[Dependency] protected readonly SharedAppearanceSystem Appearance = default!;
if (args.NewTile.Tile.IsEmpty)
return; // Anything that was here will be unanchored anyways.
- UpdateTile(MapManager.GetGrid(args.NewTile.GridUid), args.NewTile.GridIndices);
+ UpdateTile(Comp<MapGridComponent>(args.NewTile.GridUid), args.NewTile.GridIndices);
}
/// <summary>
if (!Resolve(uid, ref component, ref xform))
return;
- if (xform.Anchored && MapManager.TryGetGrid(xform.GridUid, out var grid))
+ if (xform.Anchored && TryComp<MapGridComponent>(xform.GridUid, out var grid))
component.IsUnderCover = HasFloorCover(grid, grid.TileIndicesFor(xform.Coordinates));
else
component.IsUnderCover = false;
}
}
}
- _mapManager.TryGetGrid(location.EntityId, out var mapGrid);
+ TryComp<MapGridComponent>(location.EntityId, out var mapGrid);
foreach (var currentTile in component.OutputTiles)
{
projects / space-station-14.git / commitdiff