using Content.Server.Salvage;
using Content.Shared.CCVar;
using Content.Shared.Dataset;
+using Content.Shared.Maps;
using Content.Shared.Movement.Components;
using Content.Shared.Parallax.Biomes;
using Content.Shared.Physics;
[Dependency] private readonly MetaDataSystem _metadata = default!;
[Dependency] private readonly RestrictedRangeSystem _restricted = default!;
[Dependency] private readonly SharedMapSystem _maps = default!;
+ [Dependency] private readonly TileSystem _tile = default!;
[ValidatePrototypeId<DatasetPrototype>]
private const string PlanetNames = "names_borer";
{
for (var y = -2; y <= 2; y++)
{
- tiles.Add((new Vector2i(x, y) + origin, new Tile(tileDef.TileId, variant: random.NextByte(tileDef.Variants))));
+ tiles.Add((new Vector2i(x, y) + origin, new Tile(tileDef.TileId, variant: _tile.PickVariant((ContentTileDefinition) tileDef, random))));
}
}
foundNoise = true;
noiseFill = true;
var tileDef = _tileDefManager[layer.Tile];
- var variant = rand.NextByte(tileDef.Variants);
+ var variant = _tile.PickVariant((ContentTileDefinition) tileDef, rand);
tiles.Add((node, new Tile(tileDef.TileId, variant: variant)));
roomTiles.Add(node);
using System.Threading.Tasks;
using Content.Server.NodeContainer;
using Content.Shared.Doors.Components;
+using Content.Shared.Maps;
using Content.Shared.Physics;
using Content.Shared.Procedural;
using Content.Shared.Procedural.PostGeneration;
if (!_anchorable.TileFree(grid, neighbor, DungeonSystem.CollisionLayer, DungeonSystem.CollisionMask))
continue;
- tiles.Add((neighbor, _tileDefManager.GetVariantTile(tileDef, random)));
+ tiles.Add((neighbor, _tile.GetVariantTile((ContentTileDefinition) tileDef, random)));
}
foreach (var index in dungeon.CorridorExteriorTiles)
if (!_anchorable.TileFree(grid, index, DungeonSystem.CollisionLayer, DungeonSystem.CollisionMask))
continue;
- tiles.Add((index, _tileDefManager.GetVariantTile(tileDef, random)));
+ tiles.Add((index, _tile.GetVariantTile((ContentTileDefinition)tileDef, random)));
}
grid.SetTiles(tiles);
isValid = true;
// Entrance wew
- grid.SetTile(tile, _tileDefManager.GetVariantTile(tileDef, random));
+ grid.SetTile(tile, _tile.GetVariantTile((ContentTileDefinition) tileDef, random));
ClearDoor(dungeon, grid, tile);
var gridCoords = grid.GridTileToLocal(tile);
// Need to offset the spawn to avoid spawning in the room.
continue;
}
- grid.SetTile(nearTile.GridIndices, _tileDefManager.GetVariantTile(tileDef, random));
+ grid.SetTile(nearTile.GridIndices, _tile.GetVariantTile((ContentTileDefinition) tileDef, random));;
}
break;
{
var neighbor = tile + dirVec * j;
- tiles.Add((neighbor, _tileDefManager.GetVariantTile(tileDef, random)));
+ tiles.Add((neighbor, _tile.GetVariantTile((ContentTileDefinition) tileDef, random)));
index++;
takenTiles.Add(neighbor);
}
{
var tile = validTiles[j];
var gridPos = grid.GridTileToLocal(tile);
- grid.SetTile(tile, _tileDefManager.GetVariantTile(tileDef, random));
+ grid.SetTile(tile, _tile.GetVariantTile((ContentTileDefinition) tileDef, random));
_entManager.SpawnEntities(gridPos, gen.Entities);
}
{
foreach (var entrance in room.Entrances)
{
- setTiles.Add((entrance, _tileDefManager.GetVariantTile(tileDef, random)));
+ setTiles.Add((entrance, _tile.GetVariantTile((ContentTileDefinition) tileDef, random)));
}
}
foreach (var tile in corridorTiles)
{
- setTiles.Add((tile, _tileDefManager.GetVariantTile(tileDef, random)));
+ setTiles.Add((tile, _tile.GetVariantTile((ContentTileDefinition) tileDef, random)));
}
grid.SetTiles(setTiles);
if (!dungeon.RoomExteriorTiles.Contains(neighbor))
continue;
- tiles.Add((neighbor, _tileDefManager.GetVariantTile(tileDef, random)));
+ tiles.Add((neighbor, _tile.GetVariantTile((ContentTileDefinition) tileDef, random)));
spawnPositions.Add(neighbor);
}
}
for (var x = -width + 1; x < width; x++)
{
var weh = tile + neighborDir.ToIntVec() * x;
- grid.SetTile(weh, _tileDefManager.GetVariantTile(tileDef, random));
+ grid.SetTile(weh, _tile.GetVariantTile((ContentTileDefinition) tileDef, random));
var coords = grid.GridTileToLocal(weh);
_entManager.SpawnEntities(coords, gen.Entities);
continue;
width--;
- grid.SetTile(node, _tileDefManager.GetVariantTile(tileDef, random));
+ grid.SetTile(node, _tile.GetVariantTile((ContentTileDefinition) tileDef, random));
if (gen.EdgeEntities != null && nodeDistances.Count - i <= 2)
{
if (!random.Prob(gen.Prob) || !checkedTiles.Add(neighbor))
continue;
- grid.SetTile(neighbor, _tileDefManager.GetVariantTile(tileDef, random));
+ grid.SetTile(neighbor, _tile.GetVariantTile((ContentTileDefinition) tileDef, random));
var gridPos = grid.GridTileToLocal(neighbor);
var protoNames = EntitySpawnCollection.GetSpawns(gen.Spawns, random);
using Robust.Shared.CPUJob.JobQueues;
using Content.Server.Decals;
using Content.Shared.Construction.EntitySystems;
+using Content.Shared.Maps;
using Content.Shared.Procedural;
using Content.Shared.Procedural.DungeonGenerators;
using Content.Shared.Procedural.PostGeneration;
private readonly DecalSystem _decals;
private readonly DungeonSystem _dungeon;
private readonly EntityLookupSystem _lookup;
+ private readonly TileSystem _tile;
private readonly SharedMapSystem _maps;
private readonly SharedTransformSystem _transform;
private EntityQuery<TagComponent> _tagQuery;
DecalSystem decals,
DungeonSystem dungeon,
EntityLookupSystem lookup,
+ TileSystem tile,
SharedTransformSystem transform,
DungeonConfigPrototype gen,
MapGridComponent grid,
_decals = decals;
_dungeon = dungeon;
_lookup = lookup;
+ _tile = tile;
_maps = _entManager.System<SharedMapSystem>();
_transform = transform;
_tagQuery = _entManager.GetEntityQuery<TagComponent>();
using System.Numerics;
using Content.Shared.Decals;
+using Content.Shared.Maps;
using Content.Shared.Procedural;
using Content.Shared.Random.Helpers;
using Content.Shared.Whitelist;
// but place 1 nanometre off grid and fail the add.
if (!_maps.TryGetTileRef(gridUid, grid, tilePos, out var tileRef) || tileRef.Tile.IsEmpty)
{
- _maps.SetTile(gridUid, grid, tilePos, _tileDefManager.GetVariantTile(FallbackTileId, _random));
+ _maps.SetTile(gridUid, grid, tilePos, _tile.GetVariantTile((ContentTileDefinition) _tileDefManager[FallbackTileId], _random.GetRandom()));
}
var result = _decals.TryAddDecal(
[Dependency] private readonly AnchorableSystem _anchorable = default!;
[Dependency] private readonly DecalSystem _decals = default!;
[Dependency] private readonly EntityLookupSystem _lookup = default!;
+ [Dependency] private readonly TileSystem _tile = default!;
[Dependency] private readonly MapLoaderSystem _loader = default!;
[Dependency] private readonly SharedMapSystem _maps = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
_decals,
this,
_lookup,
+ _tile,
_transform,
gen,
grid,
_decals,
this,
_lookup,
+ _tile,
_transform,
gen,
grid,
/// <summary>
/// This controls what variants the `variantize` command is allowed to use.
/// </summary>
- [DataField("placementVariants")] public float[] PlacementVariants { get; set; } = new [] { 1f };
+ [DataField("placementVariants")] public float[] PlacementVariants { get; set; } = { 1f };
[DataField("thermalConductivity")] public float ThermalConductivity = 0.04f;
/// Returns a weighted pick of a tile variant.
/// </summary>
public byte PickVariant(ContentTileDefinition tile)
+ {
+ return PickVariant(tile, _robustRandom.GetRandom());
+ }
+
+ /// <summary>
+ /// Returns a weighted pick of a tile variant.
+ /// </summary>
+ public byte PickVariant(ContentTileDefinition tile, int seed)
+ {
+ var rand = new System.Random(seed);
+ return PickVariant(tile, rand);
+ }
+
+ /// <summary>
+ /// Returns a weighted pick of a tile variant.
+ /// </summary>
+ public byte PickVariant(ContentTileDefinition tile, System.Random random)
{
var variants = tile.PlacementVariants;
var sum = variants.Sum();
var accumulated = 0f;
- var rand = _robustRandom.NextFloat() * sum;
+ var rand = random.NextFloat() * sum;
for (byte i = 0; i < variants.Length; ++i)
{
throw new InvalidOperationException($"Invalid weighted variantize tile pick for {tile.ID}!");
}
+ /// <summary>
+ /// Returns a tile with a weighted random variant.
+ /// </summary>
+ public Tile GetVariantTile(ContentTileDefinition tile, System.Random random)
+ {
+ return new Tile(tile.TileId, variant: PickVariant(tile, random));
+ }
+
+ /// <summary>
+ /// Returns a tile with a weighted random variant.
+ /// </summary>
+ public Tile GetVariantTile(ContentTileDefinition tile, int seed)
+ {
+ var rand = new System.Random(seed);
+ return new Tile(tile.TileId, variant: PickVariant(tile, rand));
+ }
+
public bool PryTile(Vector2i indices, EntityUid gridId)
{
var grid = Comp<MapGridComponent>(gridId);
[Dependency] protected readonly IPrototypeManager ProtoManager = default!;
[Dependency] private readonly ISerializationManager _serManager = default!;
[Dependency] protected readonly ITileDefinitionManager TileDefManager = default!;
+ [Dependency] private readonly TileSystem _tile = default!;
protected const byte ChunkSize = 8;
// Pick a variant tile if they're available as well
if (variantCount > 1)
{
- var variantValue = (noise.GetNoise(indices.X * 8, indices.Y * 8, variantCount) + 1f) / 2f;
- variant = (byte) Pick(variantCount, variantValue);
-
- if (variants != null)
- {
- variant = variants[variant];
- }
+ var variantValue = (noise.GetNoise(indices.X * 8, indices.Y * 8, variantCount) + 1f) * 100;
+ variant = _tile.PickVariant(tileDef, (int) variantValue);
}
tile = new Tile(tileDef.TileId, 0, variant);
[Dependency] private readonly SharedPopupSystem _popup = default!;
[Dependency] private readonly SharedStackSystem _stackSystem = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
+ [Dependency] private readonly TileSystem _tile = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
private static readonly Vector2 CheckRange = new(1f, 1f);
{
_adminLogger.Add(LogType.Tile, LogImpact.Low, $"{ToPrettyString(user):actor} placed tile {_tileDefinitionManager[tileId].Name} at {ToPrettyString(gridUid)} {location}");
- // TODO: Proper predicted RNG.
- var variant = (byte) (_timing.CurTick.Value % ((ContentTileDefinition) _tileDefinitionManager[tileId]).Variants);
+ var random = new System.Random((int) _timing.CurTick.Value);
+ var variant = _tile.PickVariant((ContentTileDefinition) _tileDefinitionManager[tileId], random);
mapGrid.SetTile(location.Offset(new Vector2(offset, offset)), new Tile(tileId, 0, variant));
_audio.PlayPredicted(placeSound, location, user);
# Fill layer
- !type:BiomeTileLayer
threshold: -1
- variants:
- - 0
- tile: FloorAsteroidSand
- - !type:BiomeTileLayer
- threshold: 0.80
- noise:
- seed: 1
- noiseType: OpenSimplex2
- frequency: 2
tile: FloorAsteroidSand
# Grass
# Fill basalt
- !type:BiomeTileLayer
threshold: -1
- variants:
- - 0
tile: FloorBasalt
# Snow
# Fill chromite
- !type:BiomeTileLayer
threshold: -1
- variants:
- - 0
- tile: FloorChromite
- - !type:BiomeTileLayer
- threshold: 0.25
- noise:
- seed: 1
- noiseType: OpenSimplex2
- frequency: 2
tile: FloorChromite
# Caves
- !type:BiomeTileLayer
threshold: -1.0
tile: FloorAsteroidSand
- variants:
- - 0
- - !type:BiomeTileLayer
- threshold: 0.5
- noise:
- seed: 1
- noiseType: OpenSimplex2
- frequency: 2
- tile: FloorAsteroidSand
# Asteroid
- type: biomeTemplate
- !type:BiomeTileLayer
threshold: -1.0
tile: FloorAsteroidSand
- variants:
- - 0
- - !type:BiomeTileLayer
- threshold: 0.5
- noise:
- seed: 1
- noiseType: OpenSimplex2
- frequency: 2
- tile: FloorAsteroidSand
projects / space-station-14.git / commitdiff