public sealed class TestMapData
{
public EntityUid MapUid { get; set; }
- public Entity<MapGridComponent> Grid;
- public MapId MapId;
+ public EntityUid GridUid { get; set; }
+ public MapId MapId { get; set; }
+ public MapGridComponent MapGrid { get; set; } = default!;
public EntityCoordinates GridCoords { get; set; }
public MapCoordinates MapCoords { get; set; }
public TileRef Tile { get; set; }
public EntityUid CMapUid { get; set; }
public EntityUid CGridUid { get; set; }
public EntityCoordinates CGridCoords { get; set; }
-}
+}
\ No newline at end of file
#nullable enable
using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Robust.Shared.GameObjects;
using Robust.Shared.Map;
/// <summary>
/// Creates a map, a grid, and a tile, and gives back references to them.
/// </summary>
- [MemberNotNull(nameof(TestMap))]
- public async Task<TestMapData> CreateTestMap(bool initialized = true, string tile = "Plating")
+ public async Task<TestMapData> CreateTestMap()
{
- var mapData = new TestMapData();
- TestMap = mapData;
await Server.WaitIdleAsync();
var tileDefinitionManager = Server.ResolveDependency<ITileDefinitionManager>();
+ var mapData = new TestMapData();
TestMap = mapData;
await Server.WaitPost(() =>
{
- mapData.MapUid = Server.System<SharedMapSystem>().CreateMap(out mapData.MapId, runMapInit: initialized);
- mapData.Grid = Server.MapMan.CreateGridEntity(mapData.MapId);
- mapData.GridCoords = new EntityCoordinates(mapData.Grid, 0, 0);
- var plating = tileDefinitionManager[tile];
+ mapData.MapId = Server.MapMan.CreateMap();
+ mapData.MapUid = Server.MapMan.GetMapEntityId(mapData.MapId);
+ var mapGrid = Server.MapMan.CreateGridEntity(mapData.MapId);
+ mapData.MapGrid = mapGrid;
+ mapData.GridUid = mapGrid.Owner; // Fixing this requires an engine PR.
+ mapData.GridCoords = new EntityCoordinates(mapData.GridUid, 0, 0);
+ var plating = tileDefinitionManager["Plating"];
var platingTile = new Tile(plating.TileId);
- mapData.Grid.Comp.SetTile(mapData.GridCoords, platingTile);
+ mapData.MapGrid.SetTile(mapData.GridCoords, platingTile);
mapData.MapCoords = new MapCoordinates(0, 0, mapData.MapId);
- mapData.Tile = mapData.Grid.Comp.GetAllTiles().First();
+ mapData.Tile = mapData.MapGrid.GetAllTiles().First();
});
- TestMap = mapData;
if (!Settings.Connected)
return mapData;
await RunTicksSync(10);
mapData.CMapUid = ToClientUid(mapData.MapUid);
- mapData.CGridUid = ToClientUid(mapData.Grid);
+ mapData.CGridUid = ToClientUid(mapData.GridUid);
mapData.CGridCoords = new EntityCoordinates(mapData.CGridUid, 0, 0);
- TestMap = mapData;
return mapData;
}
var guid = Guid.NewGuid();
- await pair.CreateTestMap();
- var coordinates = pair.TestMap.GridCoords;
+ var testMap = await pair.CreateTestMap();
+ var coordinates = testMap.GridCoords;
await server.WaitPost(() =>
{
var entity = sEntities.SpawnEntity(null, coordinates);
DeviceNetworkComponent networkComponent1 = null;
DeviceNetworkComponent networkComponent2 = null;
WiredNetworkComponent wiredNetworkComponent = null;
- var grid = testMap.Grid.Comp;
+ var grid = testMap.MapGrid;
var testValue = "test";
var payload = new NetworkPayload
await using var pair = await PoolManager.GetServerClient();
var server = pair.Server;
+
+ var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var componentFactory = server.ResolveDependency<IComponentFactory>();
+ var tileDefinitionManager = server.ResolveDependency<ITileDefinitionManager>();
+ var mapSystem = entityManager.System<SharedMapSystem>();
var logmill = server.ResolveDependency<ILogManager>().GetSawmill("EntityTest");
- await pair.CreateTestMap();
+ Entity<MapGridComponent> grid = default!;
+
+ await server.WaitPost(() =>
+ {
+ // Create a one tile grid to stave off the grid 0 monsters
+ var mapId = mapManager.CreateMap();
+
+ mapManager.AddUninitializedMap(mapId);
+
+ grid = mapManager.CreateGridEntity(mapId);
+
+ var tileDefinition = tileDefinitionManager["Plating"];
+ var tile = new Tile(tileDefinition.TileId);
+ var coordinates = new EntityCoordinates(grid.Owner, Vector2.Zero);
+
+ mapSystem.SetTile(grid.Owner, grid.Comp!, coordinates, tile);
+
+ mapManager.DoMapInitialize(mapId);
+ });
+
await server.WaitRunTicks(5);
- var testLocation = pair.TestMap.GridCoords;
await server.WaitAssertion(() =>
{
Assert.Multiple(() =>
{
+ var testLocation = new EntityCoordinates(grid.Owner, Vector2.Zero);
foreach (var type in componentFactory.AllRegisteredTypes)
{
var server = pair.Server;
var testMap = await pair.CreateTestMap();
- var grid = testMap.Grid.Comp;
var entitySystemManager = server.ResolveDependency<IEntitySystemManager>();
var spillSystem = entitySystemManager.GetEntitySystem<PuddleSystem>();
+ MapGridComponent grid = null;
+
// Remove all tiles
await server.WaitPost(() =>
{
+ grid = testMap.MapGrid;
+
foreach (var tile in grid.GetAllTiles())
{
grid.SetTile(tile.GridIndices, Tile.Empty);
/// </summary>
protected async Task AddGravity(EntityUid? uid = null)
{
- var target = uid ?? MapData.Grid;
+ var target = uid ?? MapData.GridUid;
await Server.WaitPost(() =>
{
var gravity = SEntMan.EnsureComponent<GravityComponent>(target);
await Pair.CreateTestMap();
PlayerCoords = SEntMan.GetNetCoordinates(MapData.GridCoords.Offset(new Vector2(0.5f, 0.5f)).WithEntityId(MapData.MapUid, Transform, SEntMan));
TargetCoords = SEntMan.GetNetCoordinates(MapData.GridCoords.Offset(new Vector2(1.5f, 0.5f)).WithEntityId(MapData.MapUid, Transform, SEntMan));
- await SetTile(Plating, grid: MapData.Grid.Comp);
+ await SetTile(Plating, grid: MapData.MapGrid);
// Get player data
var sPlayerMan = Server.ResolveDependency<Robust.Server.Player.IPlayerManager>();
for (var i = -Tiles; i <= Tiles; i++)
{
- await SetTile(Plating, SEntMan.GetNetCoordinates(pCoords.Offset(new Vector2(i, 0))), MapData.Grid.Comp);
+ await SetTile(Plating, SEntMan.GetNetCoordinates(pCoords.Offset(new Vector2(i, 0))), MapData.MapGrid);
}
AssertGridCount(1);
var mapManager = server.ResolveDependency<IMapManager>();
var entityMan = server.ResolveDependency<IEntityManager>();
var prototypeMan = server.ResolveDependency<IPrototypeManager>();
+ var tileDefinitionManager = server.ResolveDependency<ITileDefinitionManager>();
var seriMan = server.ResolveDependency<ISerializationManager>();
var compFact = server.ResolveDependency<IComponentFactory>();
var prototypes = new List<EntityPrototype>();
+ MapGridComponent grid = default!;
EntityUid uid;
+ MapId mapId = default;
- await pair.CreateTestMap(false, "FloorSteel"); // Wires n such disable ambiance while under the floor
- var mapId = pair.TestMap.MapId;
- var grid = pair.TestMap.Grid;
+ //Build up test environment
+ await server.WaitPost(() =>
+ {
+ // Create a one tile grid to stave off the grid 0 monsters
+ mapId = mapManager.CreateMap();
+
+ mapManager.AddUninitializedMap(mapId);
+
+ grid = mapManager.CreateGrid(mapId);
+
+ var tileDefinition = tileDefinitionManager["FloorSteel"]; // Wires n such disable ambiance while under the floor
+ var tile = new Tile(tileDefinition.TileId);
+ var coordinates = grid.Owner.ToCoordinates();
+
+ grid.SetTile(coordinates, tile);
+ });
await server.WaitRunTicks(5);
await server.WaitAssertion(() =>
{
- entManager.DeleteEntity(map.Grid);
+ entManager.DeleteEntity(map.GridUid);
var grid1 = mapManager.CreateGridEntity(mapId);
var grid2 = mapManager.CreateGridEntity(mapId);
var grid1Ent = grid1.Owner;
// Spawn shuttle and affirm no valid docks.
await server.WaitAssertion(() =>
{
- entManager.DeleteEntity(map.Grid);
+ entManager.DeleteEntity(map.GridUid);
Assert.That(entManager.System<MapLoaderSystem>().TryLoad(otherMap.MapId, "/Maps/Shuttles/emergency.yml", out var rootUids));
shuttle = rootUids[0];
// Remove grid
await SetTile(null);
await SetTile(null, PlayerCoords);
- Assert.That(MapData.Grid.Comp.Deleted);
+ Assert.That(MapData.MapGrid.Deleted);
AssertGridCount(0);
// Place Lattice
// Remove grid
await SetTile(null);
await SetTile(null, PlayerCoords);
- Assert.That(MapData.Grid.Comp.Deleted);
+ Assert.That(MapData.MapGrid.Deleted);
AssertGridCount(0);
// Space -> Lattice
using Robust.Shared.Configuration;
using Robust.Shared.Enums;
using Robust.Shared.Map;
-using Robust.Shared.Map.Components;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
var aabbs = EntityQuery<StationDataComponent>().SelectMany(x =>
x.Grids.Select(x =>
- xformQuery.GetComponent(x).WorldMatrix.TransformBox(Comp<MapGridComponent>(x).LocalAABB)))
+ xformQuery.GetComponent(x).WorldMatrix.TransformBox(_mapManager.GetGridComp(x).LocalAABB)))
.ToArray();
var aabb = aabbs[0];
+// ReSharper disable once RedundantUsingDirective
+// Used to warn the player in big red letters in debug mode
+
using System.Linq;
using Content.Server.Administration;
using Content.Server.GameTicking;
using Content.Shared.Administration;
using Content.Shared.CCVar;
-using Robust.Server.GameObjects;
-using Robust.Server.Maps;
+using Robust.Server.Player;
using Robust.Shared.Configuration;
using Robust.Shared.Console;
using Robust.Shared.ContentPack;
using Robust.Shared.Map;
+using Robust.Shared.Utility;
namespace Content.Server.Mapping
{
sealed class MappingCommand : IConsoleCommand
{
[Dependency] private readonly IEntityManager _entities = default!;
- [Dependency] private readonly IMapManager _map = default!;
- [Dependency] private readonly IConfigurationManager _cfg = default!;
public string Command => "mapping";
public string Description => Loc.GetString("cmd-mapping-desc");
shell.WriteError(Loc.GetString("cmd-mapping-warning"));
#endif
+ var mapManager = IoCManager.Resolve<IMapManager>();
MapId mapId;
- string? toLoad = null;
- var mapSys = _entities.System<SharedMapSystem>();
// Get the map ID to use
if (args.Length is 1 or 2)
{
+
if (!int.TryParse(args[0], out var intMapId))
{
shell.WriteError(Loc.GetString("cmd-mapping-failure-integer", ("arg", args[0])));
return;
}
- if (_map.MapExists(mapId))
+ if (mapManager.MapExists(mapId))
{
shell.WriteError(Loc.GetString("cmd-mapping-exists", ("mapId", mapId)));
return;
}
- // either load a map or create a new one.
- if (args.Length <= 1)
- {
- mapSys.CreateMap(mapId, runMapInit: false);
- }
- else
- {
- var loadOptions = new MapLoadOptions {StoreMapUids = true};
- _entities.System<MapLoaderSystem>().TryLoad(mapId, args[1], out _, loadOptions);
- }
+ }
+ else
+ {
+ mapId = mapManager.NextMapId();
+ }
- // was the map actually created or did it fail somehow?
- if (!_map.MapExists(mapId))
- {
- shell.WriteError(Loc.GetString("cmd-mapping-error"));
- return;
- }
+ string? toLoad = null;
+ // either load a map or create a new one.
+ if (args.Length <= 1)
+ {
+ shell.ExecuteCommand($"addmap {mapId} false");
}
else
{
- mapSys.CreateMap(out mapId, runMapInit: false);
+ toLoad = CommandParsing.Escape(args[1]);
+ shell.ExecuteCommand($"loadmap {mapId} \"{toLoad}\" 0 0 0 true");
+ }
+
+ // was the map actually created?
+ if (!mapManager.MapExists(mapId))
+ {
+ shell.WriteError(Loc.GetString("cmd-mapping-error"));
+ return;
}
// map successfully created. run misc helpful mapping commands
shell.ExecuteCommand("aghost");
}
+ var cfg = IoCManager.Resolve<IConfigurationManager>();
+
// don't interrupt mapping with events or auto-shuttle
shell.ExecuteCommand("sudo cvar events.enabled false");
shell.ExecuteCommand("sudo cvar shuttle.auto_call_time 0");
- if (_cfg.GetCVar(CCVars.AutosaveEnabled))
+ if (cfg.GetCVar(CCVars.AutosaveEnabled))
shell.ExecuteCommand($"toggleautosave {mapId} {toLoad ?? "NEWMAP"}");
shell.ExecuteCommand($"tp 0 0 {mapId}");
shell.RemoteExecuteCommand("mappingclientsidesetup");
- _map.SetMapPaused(mapId, true);
+ mapManager.SetMapPaused(mapId, true);
if (args.Length == 2)
shell.WriteLine(Loc.GetString("cmd-mapping-success-load",("mapId",mapId),("path", args[1])));
_dungeon,
_metaData,
_transform,
- _mapSystem,
station,
coordinatesDisk,
missionParams,
{
[Dependency] private readonly IChatManager _chat = default!;
[Dependency] private readonly IConfigurationManager _configurationManager = default!;
+ [Dependency] private readonly IEntityManager _entManager = default!;
[Dependency] private readonly IGameTiming _timing = default!;
[Dependency] private readonly ILogManager _logManager = default!;
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly RadioSystem _radioSystem = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
- [Dependency] private readonly SharedMapSystem _mapSystem = default!;
[Dependency] private readonly ShuttleSystem _shuttle = default!;
[Dependency] private readonly ShuttleConsoleSystem _shuttleConsoles = default!;
[Dependency] private readonly StationSystem _station = default!;
private readonly DungeonSystem _dungeon;
private readonly MetaDataSystem _metaData;
private readonly SharedTransformSystem _xforms;
- private readonly SharedMapSystem _map;
public readonly EntityUid Station;
public readonly EntityUid? CoordinatesDisk;
DungeonSystem dungeon,
MetaDataSystem metaData,
SharedTransformSystem xform,
- SharedMapSystem map,
EntityUid station,
EntityUid? coordinatesDisk,
SalvageMissionParams missionParams,
_dungeon = dungeon;
_metaData = metaData;
_xforms = xform;
- _map = map;
Station = station;
CoordinatesDisk = coordinatesDisk;
_missionParams = missionParams;
protected override async Task<bool> Process()
{
_sawmill.Debug("salvage", $"Spawning salvage mission with seed {_missionParams.Seed}");
- var mapUid = _map.CreateMap(out var mapId, runMapInit: false);
+ var mapId = _mapManager.CreateMap();
+ var mapUid = _mapManager.GetMapEntityId(mapId);
+ _mapManager.AddUninitializedMap(mapId);
MetaDataComponent? metadata = null;
var grid = _entManager.EnsureComponent<MapGridComponent>(mapUid);
var random = new Random(_missionParams.Seed);
-Subproject commit f5a6e52c7fefa568296d52aab9b894e1a8bd9122
+Subproject commit 19010597553d15f5ca239497ac66eab876ecc720
projects / space-station-14.git / commitdiff