diff --git a/Content.Server/_CP14/Demiplane/CP14DemiplanSystem.Connections.cs b/Content.Server/_CP14/Demiplane/CP14DemiplanSystem.Connections.cs new file mode 100644 index 0000000000..70d5cc5ddc --- /dev/null +++ b/Content.Server/_CP14/Demiplane/CP14DemiplanSystem.Connections.cs @@ -0,0 +1,118 @@ +using Content.Shared._CP14.Demiplane.Components; +using Robust.Shared.Random; + +namespace Content.Server._CP14.Demiplane; + +public sealed partial class CP14DemiplaneSystem +{ + private void InitConnections() + { + SubscribeLocalEvent(OnRiftInit); + SubscribeLocalEvent(OnRiftShutdown); + } + + private void OnRiftInit(Entity rift, ref MapInitEvent args) + { + var map = Transform(rift).MapUid; + if (TryComp(map, out var demiplan)) // In demiplan + { + if (rift.Comp.TryAutoLinkToMap) + rift.Comp.Demiplan = (map.Value, demiplan); + + if (rift.Comp.ActiveTeleport) + AddDemiplanRandomEntryPoint((map.Value, demiplan), rift); + } + else if (rift.Comp.Demiplan is not null) //We out of demiplan + { + if (rift.Comp.ActiveTeleport) + AddDemiplanRandomExitPoint(rift.Comp.Demiplan.Value, rift); + } + } + + private void OnRiftShutdown(Entity rift, ref ComponentShutdown args) + { + if (rift.Comp.Demiplan is null) + return; + + RemoveDemiplanRandomEntryPoint(rift.Comp.Demiplan, rift); + RemoveDemiplanRandomExitPoint(rift.Comp.Demiplan, rift); + } + + /// + ///Add a position in the real world where you can get out of this demiplan + /// + private void AddDemiplanRandomExitPoint(Entity demiplan, + Entity exitPoint) + { + if (demiplan.Comp.ExitPoints.Contains(exitPoint)) + return; + + demiplan.Comp.ExitPoints.Add(exitPoint); + exitPoint.Comp.Demiplan = demiplan; + } + + /// + /// Removing the demiplan exit point, one of which the player can exit to + /// + private void RemoveDemiplanRandomExitPoint(Entity? demiplan, + Entity exitPoint) + { + if (demiplan is not null && demiplan.Value.Comp.ExitPoints.Contains(exitPoint)) + { + demiplan.Value.Comp.ExitPoints.Remove(exitPoint); + exitPoint.Comp.Demiplan = null; + } + + if (exitPoint.Comp.DeleteAfterDisconnect) + QueueDel(exitPoint); + } + + /// + /// Add a position within the demiplan that can be entered into the demiplan + /// + private void AddDemiplanRandomEntryPoint(Entity demiplan, + Entity entryPoint) + { + if (demiplan.Comp.EntryPoints.Contains(entryPoint)) + return; + + demiplan.Comp.EntryPoints.Add(entryPoint); + entryPoint.Comp.Demiplan = demiplan; + } + + private void RemoveDemiplanRandomEntryPoint(Entity? demiplan, + Entity entryPoint) + { + if (demiplan is not null && demiplan.Value.Comp.EntryPoints.Contains(entryPoint)) + { + demiplan.Value.Comp.EntryPoints.Remove(entryPoint); + entryPoint.Comp.Demiplan = null; + } + + if (entryPoint.Comp.DeleteAfterDisconnect) + QueueDel(entryPoint); + } + + public bool TryGetDemiplanEntryPoint(Entity demiplan, out Entity? entryPoint) + { + entryPoint = null; + + if (demiplan.Comp.EntryPoints.Count == 0) + return false; + + entryPoint = _random.Pick(demiplan.Comp.EntryPoints); + return true; + } + + public bool TryGetDemiplanExitPoint(Entity demiplan, + out Entity? exitPoint) + { + exitPoint = null; + + if (demiplan.Comp.ExitPoints.Count == 0) + return false; + + exitPoint = _random.Pick(demiplan.Comp.ExitPoints); + return true; + } +} diff --git a/Content.Server/_CP14/Demiplane/CP14DemiplanSystem.Generation.cs b/Content.Server/_CP14/Demiplane/CP14DemiplanSystem.Generation.cs new file mode 100644 index 0000000000..b216dca34e --- /dev/null +++ b/Content.Server/_CP14/Demiplane/CP14DemiplanSystem.Generation.cs @@ -0,0 +1,121 @@ +using System.Threading; +using Content.Server._CP14.Demiplane.Components; +using Content.Server._CP14.Demiplane.Jobs; +using Content.Shared._CP14.Demiplane.Components; +using Content.Shared._CP14.Demiplane.Prototypes; +using Content.Shared.Interaction.Events; +using Robust.Shared.CPUJob.JobQueues; +using Robust.Shared.CPUJob.JobQueues.Queues; +using Robust.Shared.Map; +using Robust.Shared.Prototypes; +using Robust.Shared.Random; + +namespace Content.Server._CP14.Demiplane; + +public sealed partial class CP14DemiplaneSystem +{ + private readonly JobQueue _expeditionQueue = new(); + private readonly List<(CP14SpawnRandomDemiplaneJob Job, CancellationTokenSource CancelToken)> _expeditionJobs = new(); + private const double JobMaxTime = 0.002; + + private void InitGeneration() + { + SubscribeLocalEvent(GeneratorMapInit); + SubscribeLocalEvent(GeneratorUsedInHand); + } + + private void UpdateGeneration(float frameTime) + { + _expeditionQueue.Process(); + + foreach (var (job, cancelToken) in _expeditionJobs.ToArray()) + { + switch (job.Status) + { + case JobStatus.Finished: + _expeditionJobs.Remove((job, cancelToken)); + break; + } + } + } + + /// + /// Generates a new random demiplane based on the specified parameters + /// + public void SpawnRandomDemiplane(ProtoId location, out Entity demiplan, out MapId mapId) + { + var mapUid = _mapSystem.CreateMap(out mapId, runMapInit: false); + var demiComp = EntityManager.EnsureComponent(mapUid); + demiplan = (mapUid, demiComp); + + var cancelToken = new CancellationTokenSource(); + var job = new CP14SpawnRandomDemiplaneJob( + JobMaxTime, + EntityManager, + _logManager, + _mapManager, + _proto, + _dungeon, + _metaData, + _mapSystem, + mapUid, + mapId, + location, + _random.Next(-10000, 10000), + cancelToken.Token); + + _expeditionJobs.Add((job, cancelToken)); + _expeditionQueue.EnqueueJob(job); + } + + private void GeneratorUsedInHand(Entity generator, ref UseInHandEvent args) + { + if (generator.Comp.LocationConfig is null) + return; + + SpawnRandomDemiplane(generator.Comp.LocationConfig.Value, out var demiplane, out var mapId); + + //TEST + EnsureComp(demiplane); + + var tempRift = EntityManager.Spawn("CP14DemiplaneTimedRadiusPassway"); + var tempRift2 = EntityManager.Spawn("CP14DemiplanRiftCore"); + _transform.SetCoordinates(tempRift, Transform(args.User).Coordinates); + _transform.SetCoordinates(tempRift2, Transform(args.User).Coordinates); + + var connection = EnsureComp(tempRift); + var connection2 = EnsureComp(tempRift2); + AddDemiplanRandomExitPoint(demiplane, (tempRift, connection)); + AddDemiplanRandomExitPoint(demiplane, (tempRift2, connection2)); + + QueueDel(generator); //wtf its crash debug build? + } + + private void GeneratorMapInit(Entity generator, ref MapInitEvent args) + { + // Here, a unique Demiplan config should be generated based on the CP14DemiplanGeneratorDataComponent + + //Location generation + HashSet suitableConfigs = new(); + foreach (var locationConfig in _proto.EnumeratePrototypes()) + { + suitableConfigs.Add(locationConfig); + } + + if (suitableConfigs.Count == 0) + { + Log.Error("Expedition mission generation failed: No suitable location configs."); + QueueDel(generator); + return; + } + + var selectedConfig = _random.Pick(suitableConfigs); + generator.Comp.LocationConfig = selectedConfig; + + //Modifier generation + + //Scenario generation + + //ETC generation + } +} diff --git a/Content.Server/_CP14/Demiplane/CP14DemiplaneSystem.cs b/Content.Server/_CP14/Demiplane/CP14DemiplaneSystem.cs new file mode 100644 index 0000000000..f37697fe81 --- /dev/null +++ b/Content.Server/_CP14/Demiplane/CP14DemiplaneSystem.cs @@ -0,0 +1,124 @@ +using Content.Server.Flash; +using Content.Server.Procedural; +using Content.Shared._CP14.Demiplane; +using Content.Shared._CP14.Demiplane.Components; +using Robust.Server.Audio; +using Robust.Shared.Map; +using Robust.Shared.Prototypes; +using Robust.Shared.Random; + +namespace Content.Server._CP14.Demiplane; + +public sealed partial class CP14DemiplaneSystem : CP14SharedDemiplaneSystem +{ + [Dependency] private readonly IPrototypeManager _proto = default!; + [Dependency] private readonly IRobustRandom _random = default!; + [Dependency] private readonly ILogManager _logManager = default!; + [Dependency] private readonly IMapManager _mapManager = default!; + [Dependency] private readonly DungeonSystem _dungeon = default!; + [Dependency] private readonly MetaDataSystem _metaData = default!; + [Dependency] private readonly SharedMapSystem _mapSystem = default!; + [Dependency] private readonly SharedTransformSystem _transform = default!; + [Dependency] private readonly AudioSystem _audio = default!; + [Dependency] private readonly FlashSystem _flash = default!; + + public override void Initialize() + { + base.Initialize(); + + InitGeneration(); + InitConnections(); + + SubscribeLocalEvent(OnDemiplanShutdown); + } + + public override void Update(float frameTime) + { + base.Update(frameTime); + + UpdateGeneration(frameTime); + } + + /// + /// Teleports the entity inside the demiplane, to one of the random entry points. + /// + /// The demiplane the entity will be teleported to + /// The entity to be teleported + /// + public bool TryTeleportIntoDemiplane(Entity demiplane, EntityUid? entity) + { + if (entity is null) + return false; + + if (!TryGetDemiplanEntryPoint(demiplane, out var entryPoint) || entryPoint is null) + { + Log.Error($"{entity} cant get in demiplane {demiplane}: no active entry points!"); + return false; + } + + var targetCoord = Transform(entryPoint.Value).Coordinates; + _flash.Flash(entity.Value, null, null, 3000f, 0.5f); + _transform.SetCoordinates(entity.Value, targetCoord); + _audio.PlayGlobal(demiplane.Comp.ArrivalSound, entity.Value); + + + var ev = new CP14DemiplanEntityEnterEvent(entity.Value); + RaiseLocalEvent(demiplane, ev); + + return true; + } + + /// + /// Teleports an entity from the demiplane to the real world, to one of the random exit points in the real world. + /// + /// The demiplane from which the entity will be teleported + /// An entity that will be teleported into the real world. This entity must be in the demiplane, otherwise the function will not work. + /// + public bool TryTeleportOutDemiplane(Entity demiplane, EntityUid? entity) + { + if (entity is null) + return false; + + if (Transform(entity.Value).MapUid != demiplane.Owner) + return false; + + if (!TryGetDemiplanExitPoint(demiplane, out var connection) || connection is null) + { + Log.Error($"{entity} cant get out of demiplane {demiplane}: no active connections!"); + return false; + } + + var targetCoord = Transform(connection.Value).Coordinates; + _flash.Flash(entity.Value, null, null, 3000f, 0.5f); + _transform.SetCoordinates(entity.Value, targetCoord); + _audio.PlayGlobal(demiplane.Comp.DepartureSound, entity.Value); + + var ev = new CP14DemiplanEntityLeaveEvent(entity.Value); + RaiseLocalEvent(demiplane, ev); + + return true; + } + + private void OnDemiplanShutdown(Entity demiplane, ref ComponentShutdown args) + { + //We stop asynchronous generation of a demiplane early if for some reason this demiplane is deleted before generation is complete + foreach (var (job, cancelToken) in _expeditionJobs.ToArray()) + { + if (job.DemiplaneMapUid == demiplane.Owner) + { + cancelToken.Cancel(); + _expeditionJobs.Remove((job, cancelToken)); + } + } + + foreach (var exit in demiplane.Comp.ExitPoints) + { + RemoveDemiplanRandomExitPoint(demiplane, exit); + } + + foreach (var entry in demiplane.Comp.EntryPoints) + { + RemoveDemiplanRandomEntryPoint(demiplane, entry); + } + } +} diff --git a/Content.Server/_CP14/Demiplane/Components/CP14DemiplaneGeneratorDataComponent.cs b/Content.Server/_CP14/Demiplane/Components/CP14DemiplaneGeneratorDataComponent.cs new file mode 100644 index 0000000000..3ac74d7901 --- /dev/null +++ b/Content.Server/_CP14/Demiplane/Components/CP14DemiplaneGeneratorDataComponent.cs @@ -0,0 +1,17 @@ +using Content.Shared._CP14.Demiplane.Components; +using Content.Shared._CP14.Demiplane.Prototypes; +using Robust.Shared.Prototypes; + +namespace Content.Server._CP14.Demiplane.Components; + +/// +/// Stores the data needed to generate a new demiplane +/// +[RegisterComponent, Access(typeof(CP14DemiplaneSystem))] +public sealed partial class CP14DemiplaneGeneratorDataComponent : Component +{ + [DataField] + public ProtoId? LocationConfig; + + //Generation settings +} diff --git a/Content.Server/_CP14/Demiplane/Jobs/CP14SpawnRandomDemiplaneJob.cs b/Content.Server/_CP14/Demiplane/Jobs/CP14SpawnRandomDemiplaneJob.cs new file mode 100644 index 0000000000..1ddc894b15 --- /dev/null +++ b/Content.Server/_CP14/Demiplane/Jobs/CP14SpawnRandomDemiplaneJob.cs @@ -0,0 +1,104 @@ +using System.Threading; +using System.Threading.Tasks; +using Content.Server.Atmos.EntitySystems; +using Content.Server.Procedural; +using Content.Shared._CP14.Demiplane.Prototypes; +using Content.Shared.Atmos; +using Content.Shared.Gravity; +using Robust.Shared.CPUJob.JobQueues; +using Robust.Shared.Map; +using Robust.Shared.Prototypes; + +namespace Content.Server._CP14.Demiplane.Jobs; + +public sealed class CP14SpawnRandomDemiplaneJob : Job +{ + private readonly IEntityManager _entManager; + //private readonly IGameTiming _timing; + private readonly IMapManager _mapManager; + private readonly IPrototypeManager _prototypeManager; + //private readonly AnchorableSystem _anchorable; + private readonly DungeonSystem _dungeon; + private readonly MetaDataSystem _metaData; + //private readonly SharedTransformSystem _xforms; + private readonly SharedMapSystem _map; + + private readonly ProtoId _config; + private readonly int _seed; + + public readonly EntityUid DemiplaneMapUid; + private readonly MapId _demiplaneMapId; + + private readonly ISawmill _sawmill; + + public CP14SpawnRandomDemiplaneJob( + double maxTime, + IEntityManager entManager, + ILogManager logManager, + IMapManager mapManager, + IPrototypeManager protoManager, + DungeonSystem dungeon, + MetaDataSystem metaData, + SharedMapSystem map, + EntityUid demiplaneMapUid, + MapId demiplaneMapId, + ProtoId config, + int seed, + CancellationToken cancellation = default) : base(maxTime, cancellation) + { + _entManager = entManager; + _mapManager = mapManager; + _prototypeManager = protoManager; + _dungeon = dungeon; + _metaData = metaData; + _map = map; + DemiplaneMapUid = demiplaneMapUid; + _demiplaneMapId = demiplaneMapId; + _config = config; + _seed = seed; + + _sawmill = logManager.GetSawmill("cp14_expedition_job"); + } + + protected override async Task Process() + { + _sawmill.Debug("cp14_expedition", $"Spawning expedition mission with seed {0}"); + var grid = _mapManager.CreateGridEntity(DemiplaneMapUid); + + MetaDataComponent? metadata = null; + + _metaData.SetEntityName(DemiplaneMapUid, "TODO: MAP Expedition name generation"); + _metaData.SetEntityName(grid, "TODO: GRID Expedition name generation"); + + //Spawn island config + var expeditionConfig = _prototypeManager.Index(_config); + var locationConfig = _prototypeManager.Index(expeditionConfig.LocationConfig); + _dungeon.GenerateDungeon(locationConfig, + grid, + grid, + Vector2i.Zero, + _seed); //Not async, because dont work with biomespawner boilerplate + + //Add map components + _entManager.AddComponents(DemiplaneMapUid, expeditionConfig.Components); + + //Setup gravity + var gravity = _entManager.EnsureComponent(DemiplaneMapUid); + gravity.Enabled = true; + _entManager.Dirty(DemiplaneMapUid, gravity, metadata); + + // Setup default atmos + var moles = new float[Atmospherics.AdjustedNumberOfGases]; + moles[(int) Gas.Oxygen] = 21.824779f; + moles[(int) Gas.Nitrogen] = 82.10312f; + var mixture = new GasMixture(moles, Atmospherics.T20C); + _entManager.System().SetMapAtmosphere(DemiplaneMapUid, false, mixture); + + _mapManager.DoMapInitialize(_demiplaneMapId); + _mapManager.SetMapPaused(_demiplaneMapId, false); + + //Dungeon + + return true; + } +} diff --git a/Content.Server/_CP14/DemiplaneTraveling/CP14DemiplaneTravelingSystem.cs b/Content.Server/_CP14/DemiplaneTraveling/CP14DemiplaneTravelingSystem.cs new file mode 100644 index 0000000000..4dbab64676 --- /dev/null +++ b/Content.Server/_CP14/DemiplaneTraveling/CP14DemiplaneTravelingSystem.cs @@ -0,0 +1,133 @@ +using Content.Server._CP14.Demiplane; +using Content.Server.Mind; +using Content.Shared._CP14.Demiplane; +using Content.Shared._CP14.Demiplane.Components; +using Content.Shared._CP14.DemiplaneTraveling; +using Content.Shared.Ghost; +using Content.Shared.Movement.Pulling.Components; +using Robust.Shared.Random; +using Robust.Shared.Timing; + +namespace Content.Server._CP14.DemiplaneTraveling; + +public sealed partial class CP14DemiplaneTravelingSystem : EntitySystem +{ + [Dependency] private readonly CP14DemiplaneSystem _demiplan = default!; + [Dependency] private readonly IGameTiming _timing = default!; + [Dependency] private readonly EntityLookupSystem _lookup = default!; + [Dependency] private readonly MindSystem _mind = default!; + [Dependency] private readonly IRobustRandom _random = default!; + + public override void Initialize() + { + base.Initialize(); + + SubscribeLocalEvent(RadiusMapInit); + SubscribeLocalEvent(OnOpenRiftInteractDoAfter); + } + + public override void Update(float frameTime) + { + base.Update(frameTime); + + //Radius passway + var query = EntityQueryEnumerator(); + while (query.MoveNext(out var uid, out var passway, out var rift)) + { + if (_timing.CurTime < passway.NextTimeTeleport) + continue; + + passway.NextTimeTeleport = _timing.CurTime + passway.Delay; + + HashSet teleportedEnts = new(); + var nearestEnts = _lookup.GetEntitiesInRange(uid, passway.Radius); + foreach (var ent in nearestEnts) + { + if (HasComp(ent)) + continue; + + if (!_mind.TryGetMind(ent, out var mindId, out var mind)) + continue; + + teleportedEnts.Add(ent); + } + + while (teleportedEnts.Count > passway.MaxEntities) + { + teleportedEnts.Remove(_random.Pick(teleportedEnts)); + } + + var map = Transform(uid).MapUid; + if (TryComp(map, out var demiplan)) + { + if (!_demiplan.TryGetDemiplanExitPoint((map.Value, demiplan), out _)) + break; + + foreach (var ent in teleportedEnts) //We in demiplan, tp OUT + { + if (TryComp(ent, out var puller)) + _demiplan.TryTeleportOutDemiplane((map.Value, demiplan), puller.Pulling); + + _demiplan.TryTeleportOutDemiplane((map.Value, demiplan), ent); + } + } + else + { + if (rift.Demiplan is not null) + { + if (!_demiplan.TryGetDemiplanEntryPoint(rift.Demiplan.Value, out _)) + break; + + foreach (var ent in teleportedEnts) //We out demiplan, tp IN + { + if (TryComp(ent, out var puller)) + _demiplan.TryTeleportIntoDemiplane(rift.Demiplan.Value, puller.Pulling); + + _demiplan.TryTeleportIntoDemiplane(rift.Demiplan.Value, ent); + } + } + } + QueueDel(uid); + } + } + + private void RadiusMapInit(Entity radiusPassWay, ref MapInitEvent args) + { + radiusPassWay.Comp.NextTimeTeleport = _timing.CurTime + radiusPassWay.Comp.Delay; + } + + private void OnOpenRiftInteractDoAfter(Entity passWay, ref CP14DemiplanPasswayUseDoAfter args) + { + if (args.Cancelled || args.Handled) + return; + + var used = false; + var map = Transform(passWay).MapUid; + if (TryComp(map, out var demiplan)) + { + if (TryComp(args.User, out var puller)) + _demiplan.TryTeleportOutDemiplane((map.Value, demiplan), puller.Pulling); + + used = _demiplan.TryTeleportOutDemiplane((map.Value, demiplan), args.User); + } + else + { + if (TryComp(passWay, out var exitPoint) && exitPoint.Demiplan is not null) + { + if (TryComp(args.User, out var puller)) + _demiplan.TryTeleportIntoDemiplane(exitPoint.Demiplan.Value, puller.Pulling); + + used = _demiplan.TryTeleportIntoDemiplane(exitPoint.Demiplan.Value, args.User); + } + } + + if (passWay.Comp.MaxUse > 0 && used) + { + passWay.Comp.MaxUse--; + if (passWay.Comp.MaxUse == 0) + QueueDel(passWay); + } + + args.Handled = true; + } +} diff --git a/Content.Shared/_CP14/DayCycle/Components/CP14DayCycleComponent.cs b/Content.Shared/_CP14/DayCycle/Components/CP14DayCycleComponent.cs index 5924b49617..4a2dbb2c39 100644 --- a/Content.Shared/_CP14/DayCycle/Components/CP14DayCycleComponent.cs +++ b/Content.Shared/_CP14/DayCycle/Components/CP14DayCycleComponent.cs @@ -47,6 +47,12 @@ public sealed partial class CP14DayCycleComponent : Component [DataDefinition, NetSerializable, Serializable] public readonly partial record struct DayCycleEntry() { + public DayCycleEntry(Color _color, TimeSpan _duration, string _period) : this() + { + Color = _color; + Duration = _duration; + Period = _period; + } /// /// The color of the world's lights at the beginning of this time of day /// diff --git a/Content.Shared/_CP14/Demiplane/CP14SharedDemiplanSytem.cs b/Content.Shared/_CP14/Demiplane/CP14SharedDemiplanSytem.cs new file mode 100644 index 0000000000..88d22115aa --- /dev/null +++ b/Content.Shared/_CP14/Demiplane/CP14SharedDemiplanSytem.cs @@ -0,0 +1,92 @@ +using Content.Shared._CP14.Demiplane.Components; +using Content.Shared._CP14.DemiplaneTraveling; +using Content.Shared.DoAfter; +using Content.Shared.Interaction; +using Robust.Shared.Player; +using Robust.Shared.Serialization; + +namespace Content.Shared._CP14.Demiplane; + +public abstract partial class CP14SharedDemiplaneSystem : EntitySystem +{ + [Dependency] private readonly SharedDoAfterSystem _doAfter = default!; + public override void Initialize() + { + base.Initialize(); + + SubscribeLocalEvent(OnDemiplanPasswayInteract); + + SubscribeLocalEvent(OnEntityEnter); + SubscribeLocalEvent(OnEntityLeave); + } + + private void OnEntityLeave(Entity ent, ref CP14DemiplanEntityLeaveEvent args) + { + //это можно легко абузить, если игроки найдут способ выходить из + //демиплана другим способом. Лучше добавлять на игроков компонент, и тречить все смены карт у этого компонента + if (ent.Comp.Players.Contains(args.Player)) + { + ent.Comp.Players.Remove(args.Player); + if (ent.Comp.Players.Count == 0) + { + QueueDel(ent); + } + } + } + + private void OnEntityEnter(Entity ent, ref CP14DemiplanEntityEnterEvent args) + { + if (!TryComp(args.Player, out var actor)) + return; + + ent.Comp.Players.Add(args.Player); + } + + private void OnDemiplanPasswayInteract(Entity passway, ref InteractHandEvent args) + { + _doAfter.TryStartDoAfter(new DoAfterArgs(EntityManager, + args.User, + passway.Comp.DoAfter, + new CP14DemiplanPasswayUseDoAfter(), + args.Target, + args.Target) + { + BreakOnDamage = true, + BreakOnMove = true, + BreakOnHandChange = true, + NeedHand = true, + MovementThreshold = 0.2f, + }); + } +} + +[Serializable, NetSerializable] +public sealed partial class CP14DemiplanPasswayUseDoAfter : SimpleDoAfterEvent +{ +} + +/// +/// Is invoked on the demiplane when new players enter. This only applies to rift entrances, any other methods will not be taken into account. +/// +public sealed class CP14DemiplanEntityEnterEvent : EntityEventArgs +{ + public EntityUid Player; + + public CP14DemiplanEntityEnterEvent(EntityUid player) + { + Player = player; + } +} + +/// +/// Is invoked on the demiplane when some players left. This only applies to rift entrances, any other methods will not be taken into account. +/// +public sealed class CP14DemiplanEntityLeaveEvent : EntityEventArgs +{ + public EntityUid Player; + + public CP14DemiplanEntityLeaveEvent(EntityUid player) + { + Player = player; + } +} diff --git a/Content.Shared/_CP14/Demiplane/Components/CP14DemiplaneComponent.cs b/Content.Shared/_CP14/Demiplane/Components/CP14DemiplaneComponent.cs new file mode 100644 index 0000000000..cd9425f50a --- /dev/null +++ b/Content.Shared/_CP14/Demiplane/Components/CP14DemiplaneComponent.cs @@ -0,0 +1,38 @@ +using Robust.Shared.Audio; + +namespace Content.Shared._CP14.Demiplane.Components; + +/// +/// Designates this entity as holding a demiplane. +/// +[RegisterComponent, Access(typeof(CP14SharedDemiplaneSystem))] +public sealed partial class CP14DemiplaneComponent : Component +{ + /// + /// All entities in the real world that are connected to this demiplane + /// + [ViewVariables(VVAccess.ReadOnly)] + [DataField] + public HashSet> ExitPoints = new(); + + /// + /// All entities in the demiplane in which the objects entered in the demiplane appear + /// + [ViewVariables(VVAccess.ReadOnly)] + [DataField] + public HashSet> EntryPoints = new(); + + /// + /// The sound of entering a demiplane, played locally to the player who entered it. + /// Consider more as an intro sound “You have entered the demiplane. Good luck.” + /// + [DataField("arrivalSound")] + public SoundSpecifier ArrivalSound = new SoundCollectionSpecifier("CP14DemiplaneIntro"); + + /// + /// The sound of exiting the demiplane, played locally to the player who exited the demiplane. + /// Consider it more as an ending sound + /// + [DataField("departureSound")] + public SoundSpecifier DepartureSound = new SoundCollectionSpecifier("CP14DemiplaneIntro"); +} diff --git a/Content.Shared/_CP14/Demiplane/Components/CP14DemiplaneDestroyWithoutPlayersComponent.cs b/Content.Shared/_CP14/Demiplane/Components/CP14DemiplaneDestroyWithoutPlayersComponent.cs new file mode 100644 index 0000000000..a4884caf43 --- /dev/null +++ b/Content.Shared/_CP14/Demiplane/Components/CP14DemiplaneDestroyWithoutPlayersComponent.cs @@ -0,0 +1,11 @@ +namespace Content.Shared._CP14.Demiplane.Components; + +/// +/// Automatically deletes the demiplane if everyone who entered it, exited back out, or died. +/// +[RegisterComponent, Access(typeof(CP14SharedDemiplaneSystem))] +public sealed partial class CP14DemiplaneDestroyWithoutPlayersComponent : Component +{ + [DataField] + public HashSet Players = new(); +} diff --git a/Content.Shared/_CP14/Demiplane/Components/CP14DemiplaneRiftComponent.cs b/Content.Shared/_CP14/Demiplane/Components/CP14DemiplaneRiftComponent.cs new file mode 100644 index 0000000000..c1ead654a8 --- /dev/null +++ b/Content.Shared/_CP14/Demiplane/Components/CP14DemiplaneRiftComponent.cs @@ -0,0 +1,29 @@ +namespace Content.Shared._CP14.Demiplane.Components; + +/// +/// An entity that is the link between the demiplane and the real world. Depending on whether it is in the real world or in the demiplane +/// +[RegisterComponent, Access(typeof(CP14SharedDemiplaneSystem))] +public sealed partial class CP14DemiplaneRiftComponent : Component +{ + [ViewVariables(VVAccess.ReadOnly)] + [DataField] + public Entity? Demiplan; + + /// + /// Checks if the map on which this rift is initialized is a demiplane to automatically bind to it. QoL thing. + /// + [ViewVariables(VVAccess.ReadOnly)] + [DataField] + public bool TryAutoLinkToMap = true; + + /// + /// will this rift become one of the random entry or exit points of the demiplane + /// + [ViewVariables(VVAccess.ReadOnly)] + [DataField] + public bool ActiveTeleport = true; + + [DataField] + public bool DeleteAfterDisconnect = true; +} diff --git a/Content.Shared/_CP14/Demiplane/Prototypes/CP14DemiplaneLocationPrototype.cs b/Content.Shared/_CP14/Demiplane/Prototypes/CP14DemiplaneLocationPrototype.cs new file mode 100644 index 0000000000..abc9bcd069 --- /dev/null +++ b/Content.Shared/_CP14/Demiplane/Prototypes/CP14DemiplaneLocationPrototype.cs @@ -0,0 +1,25 @@ +using Content.Shared.Procedural; +using Robust.Shared.Prototypes; + +namespace Content.Shared._CP14.Demiplane.Prototypes; + +/// +/// procedural location template. The answer to the question “Where” as far as the combinatorics of the expedition is concerned. +/// +[Prototype("cp14DemiplaneLocation")] +public sealed partial class CP14DemiplaneLocationPrototype : IPrototype +{ + [IdDataField] public string ID { get; } = default!; + + [DataField(required: true)] + public ProtoId LocationConfig; + + [DataField] + public ComponentRegistry Components = new(); + + //Player faced description + + //Tier restriction + + //Some abstract restriction? +} diff --git a/Content.Shared/_CP14/DemiplaneTraveling/CP14DemiplaneRadiusTimedPasswayComponent.cs b/Content.Shared/_CP14/DemiplaneTraveling/CP14DemiplaneRadiusTimedPasswayComponent.cs new file mode 100644 index 0000000000..072327a9fa --- /dev/null +++ b/Content.Shared/_CP14/DemiplaneTraveling/CP14DemiplaneRadiusTimedPasswayComponent.cs @@ -0,0 +1,20 @@ +namespace Content.Shared._CP14.DemiplaneTraveling; + +/// +/// teleports a certain number of entities between demiplanes with a delay +/// +[RegisterComponent] +public sealed partial class CP14DemiplaneRadiusTimedPasswayComponent : Component +{ + [DataField] + public int MaxEntities = 3; + + [DataField] + public TimeSpan Delay = TimeSpan.FromSeconds(10f); + + [DataField] + public float Radius = 3f; + + [DataField] + public TimeSpan NextTimeTeleport = TimeSpan.Zero; +} diff --git a/Content.Shared/_CP14/DemiplaneTraveling/CP14DemiplaneRiftOpenedComponent.cs b/Content.Shared/_CP14/DemiplaneTraveling/CP14DemiplaneRiftOpenedComponent.cs new file mode 100644 index 0000000000..5f3f532cfa --- /dev/null +++ b/Content.Shared/_CP14/DemiplaneTraveling/CP14DemiplaneRiftOpenedComponent.cs @@ -0,0 +1,17 @@ +namespace Content.Shared._CP14.DemiplaneTraveling; + +/// +/// if located on an entity with a CP14DemiplanRiftComponent, allows users to move through that rift via an interaction with doAfter +/// +[RegisterComponent] +public sealed partial class CP14DemiplaneRiftOpenedComponent : Component +{ + /// + /// The number of teleportations this teleporter can make before disappearing. Use the negative number to make infinite. + /// + [DataField] + public int MaxUse = -1; + + [DataField] + public float DoAfter = 4f; +} diff --git a/CrystallPunk14.sln.DotSettings b/CrystallPunk14.sln.DotSettings index 6d429f32ee..cdf8b7469c 100644 --- a/CrystallPunk14.sln.DotSettings +++ b/CrystallPunk14.sln.DotSettings @@ -666,6 +666,8 @@ public $TYPE$ $NAME$; True True True + True + True True True True diff --git a/Resources/Audio/_CP14/Ambience/Demiplane/attributions.yml b/Resources/Audio/_CP14/Ambience/Demiplane/attributions.yml new file mode 100644 index 0000000000..c9252e0f92 --- /dev/null +++ b/Resources/Audio/_CP14/Ambience/Demiplane/attributions.yml @@ -0,0 +1,14 @@ +- files: ["intro1.ogg"] + license: "CC-BY-4.0" + copyright: 'by PatrickLieberkind of Freesound.org' + source: "https://freesound.org/people/PatrickLieberkind/sounds/414266/" + +- files: ["intro2.ogg"] + license: "CC0-1.0" + copyright: 'by DneproMan of Freesound.org.' + source: "https://freesound.org/people/DneproMan/sounds/256830/" + +- files: ["intro3.ogg", "intro4.ogg"] + license: "CC0-1.0" + copyright: 'by Lumamorph of Freesound.org.' + source: "https://freesound.org/people/Lumamorph/sounds/634320/" \ No newline at end of file diff --git a/Resources/Audio/_CP14/Ambience/Demiplane/intro1.ogg b/Resources/Audio/_CP14/Ambience/Demiplane/intro1.ogg new file mode 100644 index 0000000000..6e8289ed40 Binary files /dev/null and b/Resources/Audio/_CP14/Ambience/Demiplane/intro1.ogg differ diff --git a/Resources/Audio/_CP14/Ambience/Demiplane/intro2.ogg b/Resources/Audio/_CP14/Ambience/Demiplane/intro2.ogg new file mode 100644 index 0000000000..0e1ce55541 Binary files /dev/null and b/Resources/Audio/_CP14/Ambience/Demiplane/intro2.ogg differ diff --git a/Resources/Audio/_CP14/Ambience/Demiplane/intro3.ogg b/Resources/Audio/_CP14/Ambience/Demiplane/intro3.ogg new file mode 100644 index 0000000000..fbd127efb5 Binary files /dev/null and b/Resources/Audio/_CP14/Ambience/Demiplane/intro3.ogg differ diff --git a/Resources/Audio/_CP14/Ambience/Demiplane/intro4.ogg b/Resources/Audio/_CP14/Ambience/Demiplane/intro4.ogg new file mode 100644 index 0000000000..6600ab3d48 Binary files /dev/null and b/Resources/Audio/_CP14/Ambience/Demiplane/intro4.ogg differ diff --git a/Resources/Maps/_CP14/Dungeon/grassland_island_exterior.yml b/Resources/Maps/_CP14/Dungeon/grassland_island_exterior.yml new file mode 100644 index 0000000000..dc0f9690fa --- /dev/null +++ b/Resources/Maps/_CP14/Dungeon/grassland_island_exterior.yml @@ -0,0 +1,319 @@ +meta: + format: 6 + postmapinit: false +tilemap: + 0: Space + 9: CP14FloorFoundation + 13: CP14FloorGrass + 14: CP14FloorGrassLight + 15: CP14FloorGrassTall + 10: CP14FloorOakWoodPlanksBig + 12: CP14FloorOakWoodPlanksBroken + 11: CP14FloorOakWoodPlanksCruciform + 2: FloorAsteroidSand + 6: FloorAsteroidSandUnvariantized + 5: FloorAsteroidTile + 8: FloorBrokenWood + 82: FloorShuttleOrange + 1: FloorShuttlePurple + 89: FloorSteel + 7: FloorWood + 3: Plating + 4: PlatingAsteroid +entities: +- proto: "" + entities: + - uid: 1 + components: + - type: MetaData + - type: Transform + - type: Map + mapPaused: True + - type: PhysicsMap + - type: GridTree + - type: MovedGrids + - type: Broadphase + - type: OccluderTree + - type: MapGrid + chunks: + -1,-1: + ind: -1,-1 + tiles: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAA + version: 6 + 0,0: + ind: 0,0 + tiles: CQAAAAAACQAAAAAACQAAAAAACQAAAAAACQAAAAAADQAAAAAADQAAAAAADQAAAAAADQAAAAAADQAAAAAADgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACQAAAAAACwAAAAAACgAAAAAACwAAAAAACQAAAAAADgAAAAAADgAAAAAADgAAAAAADQAAAAAADQAAAAAADQAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACQAAAAAACgAAAAAACgAAAAAACgAAAAAADAAAAAAADwAAAAAADwAAAAAADgAAAAAADgAAAAAADgAAAAAADQAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACQAAAAAACgAAAAAACwAAAAAACwAAAAAACQAAAAAADwAAAAAADwAAAAAADwAAAAAADwAAAAAADwAAAAAADQAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACQAAAAAACQAAAAAACQAAAAAACQAAAAAACQAAAAAADgAAAAAADgAAAAAADgAAAAAADQAAAAAADQAAAAAADgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAA + version: 6 + 0,1: + ind: 0,1 + tiles: CgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAA + version: 6 + 0,-1: + ind: 0,-1 + tiles: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAA + version: 6 + -1,0: + ind: -1,0 + tiles: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAA + version: 6 + -1,1: + ind: -1,1 + tiles: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAA + version: 6 + 1,-1: + ind: 1,-1 + tiles: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAA + version: 6 + 1,0: + ind: 1,0 + tiles: CgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAACgAAAAAACgAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAA + version: 6 + 1,1: + ind: 1,1 + tiles: CgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAA + version: 6 + -1,2: + ind: -1,2 + tiles: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + version: 6 + 0,2: + ind: 0,2 + tiles: AQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + version: 6 + 1,2: + ind: 1,2 + tiles: AQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + version: 6 + 2,-1: + ind: 2,-1 + tiles: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + version: 6 + 2,0: + ind: 2,0 + tiles: CgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAACgAAAAAACgAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + version: 6 + 2,1: + ind: 2,1 + tiles: AQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + version: 6 + 2,2: + ind: 2,2 + tiles: AQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + version: 6 + - type: Gravity + gravityShakeSound: !type:SoundPathSpecifier + path: /Audio/Effects/alert.ogg + - type: DecalGrid + chunkCollection: + version: 2 + nodes: [] + - type: LoadedMap + - type: SpreaderGrid + - type: GridPathfinding + - type: RadiationGridResistance +- proto: CP14BarrelWater + entities: + - uid: 12 + components: + - type: Transform + pos: 1.5020437,1.6221794 + parent: 1 +- proto: CP14FenceWoodSmallCorner + entities: + - uid: 26 + components: + - type: Transform + pos: 10.5,0.5 + parent: 1 + - uid: 33 + components: + - type: Transform + rot: 1.5707963267948966 rad + pos: 10.5,4.5 + parent: 1 +- proto: CP14FenceWoodSmallStraight + entities: + - uid: 21 + components: + - type: Transform + rot: 3.141592653589793 rad + pos: 6.5,4.5 + parent: 1 + - uid: 22 + components: + - type: Transform + pos: 6.5,0.5 + parent: 1 + - uid: 23 + components: + - type: Transform + rot: 3.141592653589793 rad + pos: 5.5,4.5 + parent: 1 + - uid: 24 + components: + - type: Transform + pos: 5.5,0.5 + parent: 1 + - uid: 25 + components: + - type: Transform + pos: 7.5,0.5 + parent: 1 + - uid: 28 + components: + - type: Transform + rot: 1.5707963267948966 rad + pos: 10.5,1.5 + parent: 1 +- proto: CP14SpawnerExpeditionLootCommon + entities: + - uid: 2 + components: + - type: Transform + pos: 9.5,3.5 + parent: 1 + - uid: 5 + components: + - type: Transform + pos: 2.5,3.5 + parent: 1 + - uid: 32 + components: + - type: Transform + pos: 1.5,3.5 + parent: 1 + - uid: 34 + components: + - type: Transform + pos: 6.5,1.5 + parent: 1 +- proto: CP14TableWooden + entities: + - uid: 4 + components: + - type: Transform + rot: 1.5707963267948966 rad + pos: 1.5,3.5 + parent: 1 + - uid: 19 + components: + - type: Transform + rot: 1.5707963267948966 rad + pos: 2.5,3.5 + parent: 1 +- proto: CP14TableWoodenFrame + entities: + - uid: 3 + components: + - type: Transform + rot: 1.5707963267948966 rad + pos: 3.5,3.5 + parent: 1 +- proto: CP14WallmountTorch + entities: + - uid: 30 + components: + - type: Transform + rot: 1.5707963267948966 rad + pos: 5.5,3.5 + parent: 1 + - type: Fixtures + fixtures: {} + - uid: 35 + components: + - type: Transform + rot: -1.5707963267948966 rad + pos: 3.5,1.5 + parent: 1 + - type: Fixtures + fixtures: {} +- proto: CP14WallWooden + entities: + - uid: 6 + components: + - type: Transform + pos: 4.5,4.5 + parent: 1 + - uid: 7 + components: + - type: Transform + pos: 4.5,0.5 + parent: 1 + - uid: 8 + components: + - type: Transform + pos: 0.5,0.5 + parent: 1 + - uid: 9 + components: + - type: Transform + pos: 0.5,3.5 + parent: 1 + - uid: 11 + components: + - type: Transform + pos: 0.5,4.5 + parent: 1 + - uid: 14 + components: + - type: Transform + pos: 0.5,1.5 + parent: 1 + - uid: 15 + components: + - type: Transform + pos: 3.5,0.5 + parent: 1 + - uid: 16 + components: + - type: Transform + pos: 4.5,1.5 + parent: 1 + - uid: 17 + components: + - type: Transform + pos: 1.5,0.5 + parent: 1 + - uid: 27 + components: + - type: Transform + pos: 0.5,2.5 + parent: 1 + - uid: 29 + components: + - type: Transform + pos: 2.5,0.5 + parent: 1 + - uid: 31 + components: + - type: Transform + pos: 4.5,3.5 + parent: 1 +- proto: CP14WindowWooden + entities: + - uid: 10 + components: + - type: Transform + rot: -1.5707963267948966 rad + pos: 1.5,4.5 + parent: 1 + - uid: 13 + components: + - type: Transform + pos: 3.5,4.5 + parent: 1 + - uid: 18 + components: + - type: Transform + pos: 2.5,4.5 + parent: 1 +- proto: CP14WoodenDoor + entities: + - uid: 20 + components: + - type: Transform + rot: -1.5707963267948966 rad + pos: 4.5,2.5 + parent: 1 +... diff --git a/Resources/Maps/_CP14/tavern.yml b/Resources/Maps/_CP14/tavern.yml index a9ba5340c0..858d5030aa 100644 --- a/Resources/Maps/_CP14/tavern.yml +++ b/Resources/Maps/_CP14/tavern.yml @@ -84229,7 +84229,7 @@ entities: - type: Transform pos: 31.23764,34.036747 parent: 1 -- proto: WallPlastitaniumIndestructible +- proto: CP14WallStoneIndestructable entities: - uid: 4 components: diff --git a/Resources/Prototypes/_CP14/Entities/Markers/Spawners/Random/Loot/spawners.yml b/Resources/Prototypes/_CP14/Entities/Markers/Spawners/Random/Loot/spawners.yml new file mode 100644 index 0000000000..aa173f9cfe --- /dev/null +++ b/Resources/Prototypes/_CP14/Entities/Markers/Spawners/Random/Loot/spawners.yml @@ -0,0 +1,110 @@ +- type: entity + parent: MarkerBase + id: CP14SpawnerExpeditionLootCommon + name: Expedition common loot spawner + categories: [ ForkFiltered ] + components: + - type: Sprite + layers: + - state: green + - sprite: _CP14/Objects/Materials/copper_bar.rsi + state: bar_3 + - type: EntityTableSpawner + table: !type:NestedSelector + prob: 1.0 + tableId: CP14TableExpeditionLootCommon + +- type: entityTable + id: CP14TableExpeditionLootCommon + table: !type:GroupSelector + children: + # Common + - !type:GroupSelector + weight: 75 + children: + - id: CP14Wallet + - !type:GroupSelector + children: + - id: CP14SilverCoin1 + weight: 0.1 + - id: CP14CopperCoin + weight: 0.1 + - id: CP14CopperCoin5 + weight: 0.5 + - id: CP14CopperCoin1 + weight: 1 + - id: CP14Wheat + - !type:GroupSelector + children: + - id: CP14DyeRed + - id: CP14DyeYellow + - id: CP14DyeBlue + - id: CP14DyeGreen + - id: CP14DyePurple + - id: CP14DyeBlack + - !type:GroupSelector + children: + - id: CP14SeedWheat + - id: CP14SeedPumpkin + - id: CP14SeedCabbage + - id: CP14SeedCucumber + - id: CP14SeedTomato + - !type:GroupSelector + children: + - id: CP14BloodFlower + - id: CP14AgaricMushroom + - id: CP14WildSage + - id: CP14QuartzShard + - id: CP14BlueAmanita + - id: CP14Dayflin + - id: CP14CopperBar1 + - id: CP14IronBar1 + - id: CP14EnergyCrystalSmall + - id: CP14Bucket + - id: CP14OldLantern + - id: CP14Scissors + - id: CP14BaseSharpeningStone + - id: CP14Rope + weight: 2 + # Rare + - !type:GroupSelector + weight: 25 + children: + - !type:GroupSelector + children: + - id: CP14VialSmallBloodFlowerSap + - id: CP14VialSmallAgaricMushroom + - id: CP14VialSmallGroundQuartz + - id: CP14VialSmallWildSage + - id: CP14VialSmallBlueAmanita + - id: CP14VialTinyChromiumSlime + - id: CP14VialTinyLumiMushroom + - !type:GroupSelector + children: + - id: CP14ChromiumSlime + - id: CP14LumiMushroom + - id: CP14SilverCoin5 + - id: CP14GoldBar1 + - id: CP14EnergyCrystalMedium + +- type: entityTable + id: CP14TableBureaucracy + table: !type:GroupSelector + children: + # Common + - !type:GroupSelector + weight: 75 + children: + - id: CP14Paper + # Rare + - !type:GroupSelector + weight: 20 + children: + - id: CP14PaperFolderBlue + - id: CP14PaperFolderRed + - id: CP14PenFeather + # Very rare + - !type:GroupSelector + weight: 5 + children: + - id: CP14Inkwell \ No newline at end of file diff --git a/Resources/Prototypes/_CP14/Entities/Mobs/NPC/dinosaurs.yml b/Resources/Prototypes/_CP14/Entities/Mobs/NPC/dinosaurs.yml index 8e6954f70c..7ebe0689c2 100644 --- a/Resources/Prototypes/_CP14/Entities/Mobs/NPC/dinosaurs.yml +++ b/Resources/Prototypes/_CP14/Entities/Mobs/NPC/dinosaurs.yml @@ -88,3 +88,4 @@ volume: -8 variation: 0.125 - type: SoundWhileAlive + - type: FloorOcclusion diff --git a/Resources/Prototypes/_CP14/Entities/Mobs/Species/zombie.yml b/Resources/Prototypes/_CP14/Entities/Mobs/Species/zombie.yml index 339aa1b591..ee3639c739 100644 --- a/Resources/Prototypes/_CP14/Entities/Mobs/Species/zombie.yml +++ b/Resources/Prototypes/_CP14/Entities/Mobs/Species/zombie.yml @@ -95,6 +95,7 @@ type: StrippableBoundUserInterface - type: InventorySlots - type: ContainerContainer + - type: FloorOcclusion - type: Inventory templateId: CP14Partial femaleDisplacements: diff --git a/Resources/Prototypes/_CP14/Entities/Objects/Economy/wallet.yml b/Resources/Prototypes/_CP14/Entities/Objects/Economy/wallet.yml index 152da77fa4..764055aee8 100644 --- a/Resources/Prototypes/_CP14/Entities/Objects/Economy/wallet.yml +++ b/Resources/Prototypes/_CP14/Entities/Objects/Economy/wallet.yml @@ -3,6 +3,7 @@ description: A small wallet, handy for storing coins. id: CP14Wallet parent: BaseStorageItem + suffix: Empty categories: [ ForkFiltered ] components: - type: Sprite diff --git a/Resources/Prototypes/_CP14/Entities/Structures/Walls/natural.yml b/Resources/Prototypes/_CP14/Entities/Structures/Walls/natural.yml index b382535eeb..c82316b327 100644 --- a/Resources/Prototypes/_CP14/Entities/Structures/Walls/natural.yml +++ b/Resources/Prototypes/_CP14/Entities/Structures/Walls/natural.yml @@ -32,6 +32,20 @@ min: 2 max: 3 +- type: entity + id: CP14WallStoneIndestructable + name: dense rock + parent: CP14BaseWall + suffix: Undestructable + description: An extremely durable stone. Your tools don't seem to be enough to break through it. + components: + - type: Sprite + sprite: _CP14/Structures/Walls/Natural/cave_stone_strong.rsi + - type: Icon + sprite: _CP14/Structures/Walls/Natural/cave_stone_strong.rsi + - type: IconSmooth + base: wall + - type: entity id: CP14WallDirt name: earth wall diff --git a/Resources/Prototypes/_CP14/Entities/subdimensionGenTEST.yml b/Resources/Prototypes/_CP14/Entities/subdimensionGenTEST.yml new file mode 100644 index 0000000000..a107e0b1d5 --- /dev/null +++ b/Resources/Prototypes/_CP14/Entities/subdimensionGenTEST.yml @@ -0,0 +1,105 @@ +- type: entity + parent: BaseItem + id: CP14BaseSubdimensionalKey + abstract: true + categories: [ ForkFiltered ] + name: demiplan key + description: The core that connects the real world to the demiplane. Use it to open a temporary passage to the other world. + components: + - type: Sprite + drawdepth: Effects + sprite: /Textures/_CP14/Structures/Dungeon/demiplan_rift_core.rsi + layers: + - state: core + shader: unshaded + +- type: entity + id: CP14SubdimensionalKey + parent: CP14BaseSubdimensionalKey + components: + - type: CP14DemiplaneGeneratorData + - type: CP14DemiplaneRift + - type: Sprite + state: key1 + +- type: entity + id: CP14DemiplanRiftCore + categories: [ ForkFiltered ] + name: demiplan rift core + description: A subtle connection between the real world and the demiplane where the adventurers went. Sooner or later they will return from there. + components: + - type: CP14DemiplaneRift + - type: Transform + anchored: True + - type: Clickable + - type: Physics + canCollide: false + bodyType: Static + - type: Sprite + drawdepth: Effects + sprite: /Textures/_CP14/Structures/Dungeon/demiplan_rift_core.rsi + layers: + - state: core + shader: unshaded + - state: pulse + shader: unshaded + - type: PointLight + radius: 2 + energy: 2 + color: "#371c5c" + netsync: false + +- type: entity + id: CP14DemiplaneTimedRadiusPassway + parent: CP14DemiplanRiftCore + name: pulsating demiplane rift + description: This rift is gaining strength, and will trap all nearby creatures in a demiplane in a second! + components: + - type: CP14DemiplaneRift + activeTeleport: false + - type: CP14DemiplaneRadiusTimedPassway + maxEntities: 3 + delay: 4 + - type: Sprite + drawdepth: Effects + sprite: /Textures/_CP14/Structures/Dungeon/demiplan_rift.rsi + layers: + - state: pulse + shader: unshaded + - type: PointLight + radius: 8 + - type: SingularityDistortion + falloffPower: 1.5 + intensity: 50 + +- type: entity + id: CP14DemiplanePassway + parent: CP14DemiplanRiftCore + name: demiplane rift + description: A gap in space that allows you to travel between world and demiplanes. + components: + - type: CP14DemiplaneRiftOpened + - type: CP14DemiplaneRift + activeTeleport: false + - type: Sprite + drawdepth: Effects + sprite: /Textures/_CP14/Structures/Dungeon/demiplan_rift.rsi + layers: + - state: anom + shader: unshaded + - type: SingularityDistortion + falloffPower: 1.5 + intensity: 50 + +- type: entity + parent: MarkerBase + id: CP14DemiplaneEntryPointMarker + name: demiplane entry point + categories: [ ForkFiltered ] + components: + - type: Sprite + layers: + - state: green + - sprite: /Textures/_CP14/Structures/Dungeon/demiplan_rift.rsi + state: pulse + - type: CP14DemiplaneRift \ No newline at end of file diff --git a/Resources/Prototypes/_CP14/Procedural/Demiplane/T1_Caves/config.yml b/Resources/Prototypes/_CP14/Procedural/Demiplane/T1_Caves/config.yml new file mode 100644 index 0000000000..b3d978904a --- /dev/null +++ b/Resources/Prototypes/_CP14/Procedural/Demiplane/T1_Caves/config.yml @@ -0,0 +1,159 @@ +- type: cp14DemiplaneLocation + id: T1Caves + locationConfig: CP14ExpeditionCaves + components: + - type: CP14WeatherController + entries: + - visuals: CP14Mist + +- type: dungeonConfig + id: CP14ExpeditionCaves + layers: + # Masks (from center to border!) + - !type:PrototypeDunGen + proto: CP14ExpeditionCavesFloorMaskBorder + - !type:PrototypeDunGen + proto: CP14ExpeditionCavesFloorMaskStone + - !type:PrototypeDunGen + proto: CP14ExpeditionCavesFloorMaskAir + # Exterior rooms + #here + # Biome Spawner fills (from border to center!) order is very important! For inexplicable reasons, only a certain sequence works! + - !type:PrototypeDunGen + proto: CP14ExpeditionCavesFillBorder + - !type:PrototypeDunGen + proto: CP14ExpeditionCavesFillAir + - !type:PrototypeDunGen + proto: CP14ExpeditionCavesFillCave + # Ore and resources + - !type:OreDunGen + replacement: CP14WallStone + entity: CP14WallStoneGoldOre + count: 10 + minGroupSize: 10 + maxGroupSize: 15 + - !type:OreDunGen + replacement: CP14WallStone + entity: CP14WallStoneIronOre + count: 10 + minGroupSize: 10 + maxGroupSize: 15 + - !type:OreDunGen + replacement: CP14WallStone + entity: CP14WallStoneCopperOre + count: 10 + minGroupSize: 10 + maxGroupSize: 15 + # Mobs + - !type:MobsDunGen + minCount: 5 + maxCount: 10 + groups: + - id: CP14SpawnMobUndeadZombie + amount: 1 + # Enter and Exit + - !type:MobsDunGen + minCount: 1 + maxCount: 2 + groups: + - id: CP14DemiplaneEntryPointMarker + amount: 1 + - !type:MobsDunGen + minCount: 2 + maxCount: 2 + groups: + - id: CP14DemiplanePassway + amount: 1 + # Loot + - !type:EntityTableDunGen + minCount: 10 + maxCount: 25 + table: !type:NestedSelector + tableId: CP14TableExpeditionLootCommon + +- type: dungeonConfig + id: CP14ExpeditionCavesFloorMaskAir + layers: + - !type:NoiseDistanceDunGen + size: 80, 80 + distanceConfig: !type:DunGenEuclideanSquaredDistance + blendWeight: 0.5 + layers: + - tile: CP14FloorGrass + threshold: 0.50 + noise: + frequency: 0.030 + noiseType: OpenSimplex2 + fractalType: FBm + octaves: 5 + lacunarity: 2 + gain: 0.5 + +- type: dungeonConfig + id: CP14ExpeditionCavesFloorMaskStone + layers: + - !type:NoiseDistanceDunGen + size: 120, 120 + distanceConfig: !type:DunGenEuclideanSquaredDistance + blendWeight: 0.9 + layers: + - tile: CP14FloorSand + threshold: 0.50 + noise: + frequency: 0.010 + noiseType: OpenSimplex2 + fractalType: FBm + octaves: 5 + lacunarity: 2 + gain: 0.5 + +- type: dungeonConfig + id: CP14ExpeditionCavesFloorMaskBorder + layers: + - !type:NoiseDistanceDunGen + size: 130, 130 + distanceConfig: !type:DunGenEuclideanSquaredDistance + blendWeight: 1 + layers: + - tile: CP14FloorBase + threshold: 0.50 + noise: + frequency: 0.010 + noiseType: OpenSimplex2 + fractalType: FBm + octaves: 5 + lacunarity: 2 + gain: 0.5 + +- type: dungeonConfig + id: CP14ExpeditionCavesFillAir + reserveTiles: true + data: + entities: + Fill: CP14BiomeSpawnerCaveEmpty + layers: + - !type:FillGridDunGen + allowedTiles: + - CP14FloorGrass + +- type: dungeonConfig + id: CP14ExpeditionCavesFillCave + reserveTiles: true + data: + entities: + Fill: CP14BiomeSpawnerCave + layers: + - !type:FillGridDunGen + allowedTiles: + - CP14FloorSand + +- type: dungeonConfig + id: CP14ExpeditionCavesFillBorder + reserveTiles: true + data: + entities: + Fill: CP14WallStoneIndestructable + layers: + - !type:FillGridDunGen + allowedTiles: + - CP14FloorBase \ No newline at end of file diff --git a/Resources/Prototypes/_CP14/Procedural/Demiplane/T1_Grassland_island/config.yml b/Resources/Prototypes/_CP14/Procedural/Demiplane/T1_Grassland_island/config.yml new file mode 100644 index 0000000000..f3545dacf7 --- /dev/null +++ b/Resources/Prototypes/_CP14/Procedural/Demiplane/T1_Grassland_island/config.yml @@ -0,0 +1,179 @@ +- type: cp14DemiplaneLocation + id: T1GrasslandIsland + locationConfig: CP14ExpeditionGrasslandIsland + components: + - type: MapLight + ambientLightColor: "#BFEEFFFF" + - type: CP14MapFloorOccluder + - type: Parallax + parallax: CP14Ocean + - type: CP14WeatherController + entries: + - visuals: CP14Rain + - visuals: CP14Storm + - visuals: CP14Mist + - type: CP14DayCycle + timeEntries: + - duration: 80 + color: '#754A4AFF' + - duration: 80 + color: '#E0BA87FF' + - duration: 80 + color: '#BFEEFFFF' + - period: Night + duration: 80 + color: '#385163FF' + - period: Night + duration: 80 + color: '#060D12FF' + - period: Night + duration: 80 + color: '#000000FF' + - period: Night + duration: 80 + color: '#000000FF' + - duration: 80 + color: '#120906FF' + +- type: dungeonConfig + id: CP14ExpeditionGrasslandIsland + layers: + # Masks (from center to border!) + - !type:PrototypeDunGen + proto: CP14ExpeditionGrasslandIslandFloorMaskSand + - !type:PrototypeDunGen + proto: CP14ExpeditionGrasslandIslandFloorMaskGrass + - !type:PrototypeDunGen + proto: CP14ExpeditionGrasslandIslandFloorMaskStone + # Exterior rooms + - !type:EntityTableDunGen + minCount: 1 + maxCount: 2 + table: + id: CP14GrasslandIslandExteriorRoomSpawner + # Biome Spawner fills (from border to center!) order is very important! For inexplicable reasons, only a certain sequence works! + - !type:PrototypeDunGen + proto: CP14ExpeditionGrasslandIslandFillGrassland + - !type:PrototypeDunGen + proto: CP14ExpeditionGrasslandIslandFillCave + # Ore and resources + - !type:OreDunGen + replacement: CP14WallStone + entity: CP14WallStoneGoldOre + count: 10 + minGroupSize: 10 + maxGroupSize: 15 + - !type:OreDunGen + replacement: CP14WallStone + entity: CP14WallStoneIronOre + count: 10 + minGroupSize: 10 + maxGroupSize: 15 + - !type:OreDunGen + replacement: CP14WallStone + entity: CP14WallStoneCopperOre + count: 10 + minGroupSize: 10 + maxGroupSize: 15 + # Mobs + - !type:MobsDunGen + minCount: 2 + maxCount: 5 + groups: + - id: CP14SpawnMobDinoYumkaraptor + amount: 1 + # Enter and Exit + - !type:MobsDunGen + minCount: 1 + maxCount: 2 + groups: + - id: CP14DemiplaneEntryPointMarker + amount: 1 + - !type:MobsDunGen + minCount: 2 + maxCount: 2 + groups: + - id: CP14DemiplanePassway + amount: 1 + # Loot + - !type:EntityTableDunGen + minCount: 5 + maxCount: 20 + table: !type:NestedSelector + tableId: CP14TableExpeditionLootCommon + +- type: dungeonConfig + id: CP14ExpeditionGrasslandIslandFloorMaskStone + layers: + - !type:NoiseDistanceDunGen + size: 80, 80 + distanceConfig: !type:DunGenEuclideanSquaredDistance + blendWeight: 0.5 + layers: + - tile: CP14FloorBase + threshold: 0.50 + noise: + frequency: 0.010 + noiseType: OpenSimplex2 + fractalType: FBm + octaves: 5 + lacunarity: 2 + gain: 0.5 + +- type: dungeonConfig + id: CP14ExpeditionGrasslandIslandFloorMaskGrass + layers: + - !type:NoiseDistanceDunGen + size: 120, 120 + distanceConfig: !type:DunGenEuclideanSquaredDistance + blendWeight: 0.6 + layers: + - tile: CP14FloorGrass + threshold: 0.50 + noise: + frequency: 0.010 + noiseType: OpenSimplex2 + fractalType: FBm + octaves: 5 + lacunarity: 2 + gain: 0.5 + +- type: dungeonConfig + id: CP14ExpeditionGrasslandIslandFloorMaskSand + layers: + - !type:NoiseDistanceDunGen + size: 130, 130 + distanceConfig: !type:DunGenEuclideanSquaredDistance + blendWeight: 0.7 + layers: + - tile: CP14FloorSand + threshold: 0.50 + noise: + frequency: 0.010 + noiseType: OpenSimplex2 + fractalType: FBm + octaves: 5 + lacunarity: 2 + gain: 0.5 + +- type: dungeonConfig + id: CP14ExpeditionGrasslandIslandFillGrassland + reserveTiles: true + data: + entities: + Fill: CP14BiomeSpawnerGrassland + layers: + - !type:FillGridDunGen + allowedTiles: + - CP14FloorGrass + +- type: dungeonConfig + id: CP14ExpeditionGrasslandIslandFillCave + reserveTiles: true + data: + entities: + Fill: CP14BiomeSpawnerCave + layers: + - !type:FillGridDunGen + allowedTiles: + - CP14FloorBase \ No newline at end of file diff --git a/Resources/Prototypes/_CP14/Procedural/Demiplane/T1_Grassland_island/exterier.yml b/Resources/Prototypes/_CP14/Procedural/Demiplane/T1_Grassland_island/exterier.yml new file mode 100644 index 0000000000..0535b7266a --- /dev/null +++ b/Resources/Prototypes/_CP14/Procedural/Demiplane/T1_Grassland_island/exterier.yml @@ -0,0 +1,23 @@ +- type: Tag + id: CP14GrasslandIsland + +- type: entity + id: CP14GrasslandIslandExteriorRoomSpawner + categories: [ ForkFiltered ] + parent: BaseRoomMarker + name: Grassland island exterior room spawner + components: + - type: RoomFill + size: 11,5 + roomWhitelist: + tags: + - CP14GrasslandIsland + +# 11x5 +- type: dungeonRoom + id: CP14GrasslandIslandExterior_11x5_a + size: 11,5 + atlas: /Maps/_CP14/Dungeon/grassland_island_exterior.yml + offset: 0,0 + tags: + - CP14GrasslandIsland \ No newline at end of file diff --git a/Resources/Prototypes/_CP14/Procedural/biome_template_caves.yml b/Resources/Prototypes/_CP14/Procedural/biome_template_caves.yml index 57e67f7341..fe77c0142d 100644 --- a/Resources/Prototypes/_CP14/Procedural/biome_template_caves.yml +++ b/Resources/Prototypes/_CP14/Procedural/biome_template_caves.yml @@ -3,7 +3,7 @@ layers: - !type:BiomeTileLayer threshold: -1.0 - tile: CP14FloorBase + tile: CP14FloorBase - type: biomeTemplate id: CP14CavesFloor @@ -46,20 +46,6 @@ layers: - !type:BiomeMetaLayer template: CP14CavesFloor - # Lakes start - - !type:BiomeEntityLayer - allowedTiles: - - CP14FloorBase - threshold: 0.8 - noise: - seed: 14 - noiseType: OpenSimplex2 - fractalType: FBm - frequency: 0.01 - domainWarpType: OpenSimplex2 - domainWarpAmp: 150 - entities: - - CP14FloorWater #Walls - !type:BiomeEntityLayer threshold: -0.75 @@ -75,37 +61,17 @@ - CP14FloorBase entities: - CP14WallStone - #Ores + # Lakes - !type:BiomeEntityLayer - threshold: 0.7 - noise: - seed: 10 - noiseType: OpenSimplex2 - fractalType: FBm - frequency: 3 allowedTiles: - CP14FloorBase - entities: - - CP14WallStoneGoldOre - - !type:BiomeEntityLayer - threshold: 0.6 + threshold: 0.8 noise: - seed: 15 + seed: 14 noiseType: OpenSimplex2 fractalType: FBm - frequency: 3 - allowedTiles: - - CP14FloorBase + frequency: 0.01 + domainWarpType: OpenSimplex2 + domainWarpAmp: 150 entities: - - CP14WallStoneIronOre - - !type:BiomeEntityLayer - threshold: 0.5 - noise: - seed: 20 - noiseType: OpenSimplex2 - fractalType: FBm - frequency: 3 - allowedTiles: - - CP14FloorBase - entities: - - CP14WallStoneCopperOre \ No newline at end of file + - CP14FloorWater \ No newline at end of file diff --git a/Resources/Prototypes/_CP14/Procedural/biome_template_grasslands.yml b/Resources/Prototypes/_CP14/Procedural/biome_template_grasslands.yml index 1991f03e88..cf9f6fee10 100644 --- a/Resources/Prototypes/_CP14/Procedural/biome_template_grasslands.yml +++ b/Resources/Prototypes/_CP14/Procedural/biome_template_grasslands.yml @@ -314,49 +314,6 @@ seed: 14 frequency: 0.02 fractalType: None - # River start - - !type:BiomeTileLayer - tile: CP14FloorDirt - threshold: 0.93 - noise: - seed: 3 - noiseType: OpenSimplex2 - frequency: 0.003 - lacunarity: 1.50 - gain: 0.12 - fractalType: Ridged - octaves: 1 - - !type:BiomeEntityLayer - allowedTiles: - - CP14FloorDirt - - CP14FloorGrass - threshold: 0.91 - noise: - seed: 3 - noiseType: OpenSimplex2 - frequency: 0.003 - lacunarity: 1.50 - gain: 0.12 - fractalType: Ridged - octaves: 1 - entities: - - CP14RandomSpawnerGatherAgaricShroom - - !type:BiomeEntityLayer - allowedTiles: - - CP14FloorDirt - - CP14FloorSand - threshold: 0.93 - noise: - seed: 3 - noiseType: OpenSimplex2 - frequency: 0.003 - lacunarity: 1.50 - gain: 0.12 - fractalType: Ridged - octaves: 1 - entities: - - CP14FloorWater - # River end # Lakes start - !type:BiomeTileLayer tile: CP14FloorSand diff --git a/Resources/Prototypes/_CP14/SoundCollections/lobby.yml b/Resources/Prototypes/_CP14/SoundCollections/lobby.yml deleted file mode 100644 index 6544d3f831..0000000000 --- a/Resources/Prototypes/_CP14/SoundCollections/lobby.yml +++ /dev/null @@ -1,6 +0,0 @@ -- type: soundCollection - id: CP14LobbyMusic - files: - - /Audio/_CP14/Lobby/crystal.ogg - - /Audio/_CP14/Lobby/eldermourne.ogg - - /Audio/_CP14/Lobby/arcane_winds.ogg \ No newline at end of file diff --git a/Resources/Prototypes/_CP14/SoundCollections/music.yml b/Resources/Prototypes/_CP14/SoundCollections/music.yml new file mode 100644 index 0000000000..d7eb455722 --- /dev/null +++ b/Resources/Prototypes/_CP14/SoundCollections/music.yml @@ -0,0 +1,14 @@ +- type: soundCollection + id: CP14LobbyMusic + files: + - /Audio/_CP14/Lobby/crystal.ogg + - /Audio/_CP14/Lobby/eldermourne.ogg + - /Audio/_CP14/Lobby/arcane_winds.ogg + +- type: soundCollection + id: CP14DemiplaneIntro + files: + - /Audio/_CP14/Ambience/Demiplane/intro1.ogg + - /Audio/_CP14/Ambience/Demiplane/intro2.ogg + - /Audio/_CP14/Ambience/Demiplane/intro3.ogg + - /Audio/_CP14/Ambience/Demiplane/intro4.ogg \ No newline at end of file diff --git a/Resources/Prototypes/_CP14/audio_music.yml b/Resources/Prototypes/_CP14/audio_music.yml index edbee084bf..ea9e199bca 100644 --- a/Resources/Prototypes/_CP14/audio_music.yml +++ b/Resources/Prototypes/_CP14/audio_music.yml @@ -1,12 +1,12 @@ # 4 Priority - Special - type: ambientMusic - id: CP14Ritual + id: CP14Magic sound: params: volume: -12 collection: CP14AmbienceMagic - rules: NearRitual + rules: NearMagic priority: 4 # 3 Priority - Departments @@ -76,7 +76,7 @@ - !type:AlwaysTrueRule - type: rules - id: NearRitual + id: NearMagic rules: - !type:NearbyEntitiesRule count: 1 @@ -84,6 +84,7 @@ components: - CP14MagicRitualPhase - CP14MagicRitual + - CP14DemiplanPassway range: 6 - type: rules diff --git a/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift.rsi/anom.png b/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift.rsi/anom.png new file mode 100644 index 0000000000..d8a74d7f9c Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift.rsi/anom.png differ diff --git a/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift.rsi/meta.json b/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift.rsi/meta.json new file mode 100644 index 0000000000..4f02c929a9 --- /dev/null +++ b/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift.rsi/meta.json @@ -0,0 +1,34 @@ +{ + "version": 1, + "license": "CC0-1.0", + "copyright": "Created by TheShuEd (github) for ss14", + "size": { + "x": 32, + "y": 48 + }, + "states": [ + { + "name": "anom", + "delays": [ + [ + 0.25625, + 0.25625, + 0.25625 + ] + ] + }, + { + "name": "pulse", + "delays": [ + [ + 0.15625, + 0.15625, + 0.15625, + 0.15625, + 0.15625, + 0.15625 + ] + ] + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift.rsi/pulse.png b/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift.rsi/pulse.png new file mode 100644 index 0000000000..81a8c92378 Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift.rsi/pulse.png differ diff --git a/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift_core.rsi/core.png b/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift_core.rsi/core.png new file mode 100644 index 0000000000..d37b98aa15 Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift_core.rsi/core.png differ diff --git a/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift_core.rsi/meta.json b/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift_core.rsi/meta.json new file mode 100644 index 0000000000..94ffa2be6e --- /dev/null +++ b/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift_core.rsi/meta.json @@ -0,0 +1,25 @@ +{ + "version": 1, + "license": "CC0-1.0", + "copyright": "Created by TheShuEd (github) for ss14", + "size": { + "x": 32, + "y": 32 + }, + "states": [ + { + "name": "core" + }, + { + "name": "pulse", + "delays": [ + [ + 0.15625, + 0.15625, + 0.15625, + 0.15625 + ] + ] + } + ] +} diff --git a/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift_core.rsi/pulse.png b/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift_core.rsi/pulse.png new file mode 100644 index 0000000000..c9e239e515 Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Dungeon/demiplan_rift_core.rsi/pulse.png differ diff --git a/Resources/Textures/_CP14/Structures/Dungeon/rift.rsi/meta.json b/Resources/Textures/_CP14/Structures/Dungeon/rift.rsi/meta.json new file mode 100644 index 0000000000..42e243199f --- /dev/null +++ b/Resources/Textures/_CP14/Structures/Dungeon/rift.rsi/meta.json @@ -0,0 +1,14 @@ +{ + "version": 1, + "license": "CLA", + "copyright": "by TheShuEd (discord)", + "size": { + "x": 48, + "y": 48 + }, + "states": [ + { + "name": "rift" + } + ] +} diff --git a/Resources/Textures/_CP14/Structures/Dungeon/rift.rsi/rift.png b/Resources/Textures/_CP14/Structures/Dungeon/rift.rsi/rift.png new file mode 100644 index 0000000000..9767658633 Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Dungeon/rift.rsi/rift.png differ diff --git a/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/full.png b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/full.png new file mode 100644 index 0000000000..63a364f755 Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/full.png differ diff --git a/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/meta.json b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/meta.json new file mode 100644 index 0000000000..1736fe4906 --- /dev/null +++ b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/meta.json @@ -0,0 +1,46 @@ +{ + "version": 1, + "size": { + "x": 32, + "y": 64 + }, + "license": "CLA", + "copyright": "Created by TheShuEd (Discord) for CrystallPunk14", + "states": [ + { + "name": "wall0", + "directions": 4 + }, + { + "name": "wall1", + "directions": 4 + }, + { + "name": "wall2", + "directions": 4 + }, + { + "name": "wall3", + "directions": 4 + }, + { + "name": "wall4", + "directions": 4 + }, + { + "name": "wall5", + "directions": 4 + }, + { + "name": "wall6", + "directions": 4 + }, + { + "name": "wall7", + "directions": 4 + }, + { + "name": "full" + } + ] +} \ No newline at end of file diff --git a/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall0.png b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall0.png new file mode 100644 index 0000000000..6ad7f9d9fe Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall0.png differ diff --git a/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall1.png b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall1.png new file mode 100644 index 0000000000..44736f335f Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall1.png differ diff --git a/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall2.png b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall2.png new file mode 100644 index 0000000000..513a4827bf Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall2.png differ diff --git a/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall3.png b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall3.png new file mode 100644 index 0000000000..e8cbc3e2b4 Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall3.png differ diff --git a/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall4.png b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall4.png new file mode 100644 index 0000000000..d358944195 Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall4.png differ diff --git a/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall5.png b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall5.png new file mode 100644 index 0000000000..ed7fda486a Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall5.png differ diff --git a/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall6.png b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall6.png new file mode 100644 index 0000000000..39fdf1ad8f Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall6.png differ diff --git a/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall7.png b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall7.png new file mode 100644 index 0000000000..9f1b8d1373 Binary files /dev/null and b/Resources/Textures/_CP14/Structures/Walls/Natural/cave_stone_strong.rsi/wall7.png differ