--- /dev/null
+using Content.Shared.Materials;
+
+namespace Content.Client.Materials;
+
+/// <inheritdoc/>
+public sealed class MaterialReclaimerSystem : SharedMaterialReclaimerSystem
+{
+
+}
+++ /dev/null
-using Content.Shared.Conveyor;
-using Content.Shared.Recycling;
-using JetBrains.Annotations;
-using Robust.Client.GameObjects;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Serialization.Manager.Attributes;
-
-namespace Content.Client.Recycling
-{
- [UsedImplicitly]
- public sealed class RecyclerVisualizer : AppearanceVisualizer
- {
- [DataField("state_on")]
- private string _stateOn = "grinder-o1";
-
- [DataField("state_off")]
- private string _stateOff = "grinder-o0";
-
- [Obsolete("Subscribe to your component being initialised instead.")]
- public override void InitializeEntity(EntityUid entity)
- {
- base.InitializeEntity(entity);
-
- var entMan = IoCManager.Resolve<IEntityManager>();
- if (!entMan.TryGetComponent(entity, out SpriteComponent? sprite) ||
- !entMan.TryGetComponent(entity, out AppearanceComponent? appearance))
- {
- return;
- }
-
- UpdateAppearance(appearance, sprite);
- }
-
- [Obsolete("Subscribe to AppearanceChangeEvent instead.")]
- public override void OnChangeData(AppearanceComponent component)
- {
- base.OnChangeData(component);
-
- var entities = IoCManager.Resolve<IEntityManager>();
- if (!entities.TryGetComponent(component.Owner, out SpriteComponent? sprite))
- {
- return;
- }
-
- UpdateAppearance(component, sprite);
- }
-
- private void UpdateAppearance(AppearanceComponent component, SpriteComponent sprite)
- {
- var state = _stateOff;
- if (component.TryGetData(ConveyorVisuals.State, out ConveyorState conveyorState) && conveyorState != ConveyorState.Off)
- {
- state = _stateOn;
- }
-
- if (component.TryGetData(RecyclerVisuals.Bloody, out bool bloody) && bloody)
- {
- state += "bld";
- }
-
- sprite.LayerSetState(RecyclerVisualLayers.Main, state);
- }
- }
-
- public enum RecyclerVisualLayers : byte
- {
- Main
- }
-}
using Robust.Shared.Map;
using Robust.Shared.Prototypes;
using System;
-using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
+using Content.Shared.Chemistry.Reagent;
using Content.Shared.Construction.Components;
+using Content.Shared.FixedPoint;
+using Content.Shared.Materials;
namespace Content.IntegrationTests.Tests;
[Test]
public async Task NoMaterialArbitrage()
{
- // TODO check lathe resource prices?
- // I CBF doing that atm because I know that will probably fail for most lathe recipies.
-
- await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings() {NoClient = true});
+ await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings {NoClient = true});
var server = pairTracker.Pair.Server;
var testMap = await PoolManager.CreateTestMap(pairTracker);
var compFact = server.ResolveDependency<IComponentFactory>();
var constructionName = compFact.GetComponentName(typeof(ConstructionComponent));
+ var compositionName = compFact.GetComponentName(typeof(PhysicalCompositionComponent));
+ var materialName = compFact.GetComponentName(typeof(MaterialComponent));
var destructibleName = compFact.GetComponentName(typeof(DestructibleComponent));
- var stackName = compFact.GetComponentName(typeof(StackComponent));
// construct inverted lathe recipe dictionary
Dictionary<string, LatheRecipePrototype> latheRecipes = new();
{
var materials = new Dictionary<string, int>();
var graph = protoManager.Index<ConstructionGraphPrototype>(comp.Graph);
+ if (graph.Start == null)
+ continue;
+
if (!graph.TryPath(graph.Start, comp.Node, out var path) || path.Length == 0)
continue;
var edge = cur.GetEdge(node.Name);
cur = node;
+ if (edge == null)
+ continue;
+
foreach (var step in edge.Steps)
{
- if (step is MaterialConstructionGraphStep materialStep)
- materials[materialStep.MaterialPrototypeId] = materialStep.Amount + materials.GetValueOrDefault(materialStep.MaterialPrototypeId);
+ if (step is not MaterialConstructionGraphStep materialStep)
+ continue;
+
+ var stackProto = protoManager.Index<StackPrototype>(materialStep.MaterialPrototypeId);
+ var spawnProto = protoManager.Index<EntityPrototype>(stackProto.Spawn);
+
+ if (!spawnProto.Components.TryGetValue(materialName, out var matreg))
+ continue;
+
+ var mat = (MaterialComponent) matreg.Component;
+ foreach (var (matId, amount) in mat.Materials)
+ {
+ materials[matId] = materialStep.Amount * amount + materials.GetValueOrDefault(matId);
+ }
}
}
constructionMaterials.Add(id, materials);
spawnedEnts[key] = spawnedEnts.GetValueOrDefault(key) + value.Max;
var spawnProto = protoManager.Index<EntityPrototype>(key);
- if (!spawnProto.Components.TryGetValue(stackName, out var reg))
+
+ // get the amount of each material included in the entity
+ if (!spawnProto.Components.TryGetValue(materialName, out var matreg))
continue;
+ var mat = (MaterialComponent) matreg.Component;
- var stack = (StackComponent) reg.Component;
- spawnedMats[stack.StackTypeId] = value.Max + spawnedMats.GetValueOrDefault(stack.StackTypeId);
+ foreach (var (matId, amount) in mat.Materials)
+ {
+ spawnedMats[matId] = value.Max * amount + spawnedMats.GetValueOrDefault(matId);
+ }
}
}
}
continue;
var spawnProto = protoManager.Index<EntityPrototype>(spawnCompletion.Prototype);
- if (!spawnProto.Components.TryGetValue(stackName, out var reg))
- continue;
- var stack = (StackComponent) reg.Component;
+ if (!spawnProto.Components.TryGetValue(materialName, out var matreg))
+ continue;
- materials[stack.StackTypeId] = spawnCompletion.Amount + materials.GetValueOrDefault(stack.StackTypeId);
+ var mat = (MaterialComponent) matreg.Component;
+ foreach (var (matId, amount) in mat.Materials)
+ {
+ materials[matId] = spawnCompletion.Amount * amount + materials.GetValueOrDefault(matId);
+ }
}
}
deconstructionMaterials.Add(id, materials);
}
- // This is functionally the same loop as before, but now testinng deconstruction rather than destruction.
+ // This is functionally the same loop as before, but now testing deconstruction rather than destruction.
// This is pretty braindead. In principle construction graphs can have loops and whatnot.
Assert.Multiple(async () =>
}
});
+ // create phyiscal composition dictionary
+ // this doesn't account for the chemicals in the composition
+ Dictionary<string, PhysicalCompositionComponent> physicalCompositions = new();
+ foreach (var proto in protoManager.EnumeratePrototypes<EntityPrototype>())
+ {
+ if (proto.NoSpawn || proto.Abstract)
+ continue;
+
+ if (!proto.Components.TryGetValue(compositionName, out var composition))
+ continue;
+
+ var comp = (PhysicalCompositionComponent) composition.Component;
+ physicalCompositions.Add(proto.ID, comp);
+ }
+
+ // This is functionally the same loop as before, but now testing composition rather than destruction or deconstruction.
+ // This doesn't take into account chemicals generated when deconstructing. Maybe it should.
+ Assert.Multiple(async () =>
+ {
+ foreach (var (id, compositionComponent) in physicalCompositions)
+ {
+ // Check cargo sell price
+ var materialPrice = await GetDeconstructedPrice(compositionComponent.MaterialComposition);
+ var chemicalPrice = await GetChemicalCompositionPrice(compositionComponent.ChemicalComposition);
+ var sumPrice = materialPrice + chemicalPrice;
+ var price = await GetPrice(id);
+ if (sumPrice > 0 && price > 0)
+ Assert.LessOrEqual(sumPrice, price, $"{id} increases in price after decomposed into raw materials");
+
+ // Check lathe production
+ if (latheRecipes.TryGetValue(id, out var recipe))
+ {
+ foreach (var (matId, amount) in recipe.RequiredMaterials)
+ {
+ var actualAmount = SharedLatheSystem.AdjustMaterial(amount, recipe.ApplyMaterialDiscount, multiplier);
+ if (compositionComponent.MaterialComposition.TryGetValue(matId, out var numSpawned))
+ Assert.LessOrEqual(numSpawned, actualAmount, $"The physical composition of {id} has more {matId} than required to produce via an (upgraded) lathe.");
+ }
+ }
+
+ // Check construction.
+ if (constructionMaterials.TryGetValue(id, out var constructionMats))
+ {
+ foreach (var (matId, amount) in constructionMats)
+ {
+ if (compositionComponent.MaterialComposition.TryGetValue(matId, out var numSpawned))
+ Assert.LessOrEqual(numSpawned, amount, $"The physical composition of {id} has more {matId} than required to construct it.");
+ }
+ }
+ }
+ });
+
await server.WaitPost(() => mapManager.DeleteMap(testMap.MapId));
await pairTracker.CleanReturnAsync();
double price = 0;
foreach (var (id, num) in mats)
{
- var matProto = protoManager.Index<StackPrototype>(id).Spawn;
- price += num * await GetPrice(matProto);
+ var matProto = protoManager.Index<MaterialPrototype>(id);
+ price += num * matProto.Price;
+ }
+ return price;
+ }
+
+
+ async Task<double> GetChemicalCompositionPrice(Dictionary<string, FixedPoint2> mats)
+ {
+ double price = 0;
+ foreach (var (id, num) in mats)
+ {
+ var reagentProto = protoManager.Index<ReagentPrototype>(id);
+ price += num.Double() * reagentProto.PricePerUnit;
}
return price;
}
{
double price = 0;
- if (TryComp<MaterialComponent>(uid, out var material) && !HasComp<StackPriceComponent>(uid))
+ if (TryComp<MaterialComponent>(uid, out var material))
{
var matPrice = GetMaterialPrice(material);
if (TryComp<StackComponent>(uid, out var stack))
{
double price = 0;
- if (prototype.Components.TryGetValue(_factory.GetComponentName(typeof(MaterialComponent)), out var materials) &&
- !prototype.Components.ContainsKey(_factory.GetComponentName(typeof(StackPriceComponent))))
+ if (prototype.Components.TryGetValue(_factory.GetComponentName(typeof(MaterialComponent)), out var materials))
{
var materialsComp = (MaterialComponent) materials.Component;
var matPrice = GetMaterialPrice(materialsComp);
var price = 0.0;
if (TryComp<StackPriceComponent>(uid, out var stackPrice) &&
- TryComp<StackComponent>(uid, out var stack))
+ TryComp<StackComponent>(uid, out var stack) &&
+ !HasComp<MaterialComponent>(uid)) // don't double count material prices
{
price += stack.Count * stackPrice.Price;
}
var price = 0.0;
if (prototype.Components.TryGetValue(_factory.GetComponentName(typeof(StackPriceComponent)), out var stackpriceProto) &&
- prototype.Components.TryGetValue(_factory.GetComponentName(typeof(StackComponent)), out var stackProto))
+ prototype.Components.TryGetValue(_factory.GetComponentName(typeof(StackComponent)), out var stackProto) &&
+ !prototype.Components.ContainsKey(_factory.GetComponentName(typeof(MaterialComponent))))
{
var stackPrice = (StackPriceComponent) stackpriceProto.Component;
var stack = (StackComponent) stackProto.Component;
--- /dev/null
+using System.Linq;
+using Content.Server.Chemistry.Components.SolutionManager;
+using Content.Server.Chemistry.EntitySystems;
+using Content.Server.Construction;
+using Content.Server.Fluids.EntitySystems;
+using Content.Server.GameTicking;
+using Content.Server.Nutrition.Components;
+using Content.Server.Players;
+using Content.Server.Popups;
+using Content.Server.Power.Components;
+using Content.Server.Stack;
+using Content.Server.Wires;
+using Content.Shared.Body.Systems;
+using Content.Shared.Chemistry.Components;
+using Content.Shared.FixedPoint;
+using Content.Shared.IdentityManagement;
+using Content.Shared.Interaction;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Materials;
+using Robust.Server.GameObjects;
+using Robust.Shared.Player;
+using Robust.Shared.Utility;
+
+namespace Content.Server.Materials;
+
+/// <inheritdoc/>
+public sealed class MaterialReclaimerSystem : SharedMaterialReclaimerSystem
+{
+ [Dependency] private readonly AppearanceSystem _appearance = default!;
+ [Dependency] private readonly GameTicker _ticker = default!;
+ [Dependency] private readonly MaterialStorageSystem _materialStorage = default!;
+ [Dependency] private readonly PopupSystem _popup = default!;
+ [Dependency] private readonly SolutionContainerSystem _solutionContainer = default!;
+ [Dependency] private readonly SharedBodySystem _body = default!; //bobby
+ [Dependency] private readonly SpillableSystem _spillable = default!;
+ [Dependency] private readonly StackSystem _stack = default!;
+
+ /// <inheritdoc/>
+ public override void Initialize()
+ {
+ base.Initialize();
+
+ SubscribeLocalEvent<MaterialReclaimerComponent, ComponentStartup>(OnStartup);
+ SubscribeLocalEvent<MaterialReclaimerComponent, RefreshPartsEvent>(OnRefreshParts);
+ SubscribeLocalEvent<MaterialReclaimerComponent, UpgradeExamineEvent>(OnUpgradeExamine);
+ SubscribeLocalEvent<MaterialReclaimerComponent, PowerChangedEvent>(OnPowerChanged);
+ SubscribeLocalEvent<MaterialReclaimerComponent, InteractUsingEvent>(OnInteractUsing,
+ before: new []{typeof(WiresSystem), typeof(SolutionTransferSystem)});
+ SubscribeLocalEvent<MaterialReclaimerComponent, SuicideEvent>(OnSuicide);
+ SubscribeLocalEvent<ActiveMaterialReclaimerComponent, PowerChangedEvent>(OnActivePowerChanged);
+ }
+ private void OnStartup(EntityUid uid, MaterialReclaimerComponent component, ComponentStartup args)
+ {
+ component.OutputSolution = _solutionContainer.EnsureSolution(uid, component.SolutionContainerId);
+ }
+
+ private void OnUpgradeExamine(EntityUid uid, MaterialReclaimerComponent component, UpgradeExamineEvent args)
+ {
+ args.AddPercentageUpgrade(Loc.GetString("material-reclaimer-upgrade-process-rate"), component.MaterialProcessRate / component.BaseMaterialProcessRate);
+ }
+
+ private void OnRefreshParts(EntityUid uid, MaterialReclaimerComponent component, RefreshPartsEvent args)
+ {
+ var rating = args.PartRatings[component.MachinePartProcessRate] - 1;
+ component.MaterialProcessRate = component.BaseMaterialProcessRate * MathF.Pow(component.PartRatingProcessRateMultiplier, rating);
+ Dirty(component);
+ }
+
+ private void OnPowerChanged(EntityUid uid, MaterialReclaimerComponent component, ref PowerChangedEvent args)
+ {
+ AmbientSound.SetAmbience(uid, args.Powered);
+ component.Powered = args.Powered;
+ Dirty(component);
+ }
+
+ private void OnInteractUsing(EntityUid uid, MaterialReclaimerComponent component, InteractUsingEvent args)
+ {
+ if (args.Handled)
+ return;
+
+ // if we're trying to get a solution out of the reclaimer, don't destroy it
+ if (component.OutputSolution.Contents.Any())
+ {
+ if (TryComp<SolutionContainerManagerComponent>(args.Used, out var managerComponent) &&
+ managerComponent.Solutions.Any(s => s.Value.AvailableVolume > 0))
+ {
+ if (TryComp<DrinkComponent>(args.Used, out var drink) &&
+ !drink.Opened)
+ return;
+
+ if (TryComp<SolutionTransferComponent>(args.Used, out var transfer) &&
+ transfer.CanReceive)
+ return;
+ }
+ }
+
+ args.Handled = TryStartProcessItem(uid, args.Used, component, args.User);
+ }
+
+ private void OnSuicide(EntityUid uid, MaterialReclaimerComponent component, SuicideEvent args)
+ {
+ if (args.Handled)
+ return;
+
+ args.SetHandled(SuicideKind.Bloodloss);
+ var victim = args.Victim;
+ if (TryComp(victim, out ActorComponent? actor) &&
+ actor.PlayerSession.ContentData()?.Mind is { } mind)
+ {
+ _ticker.OnGhostAttempt(mind, false);
+ if (mind.OwnedEntity is { Valid: true } entity)
+ {
+ _popup.PopupEntity(Loc.GetString("recycler-component-suicide-message"), entity);
+ }
+ }
+
+ _popup.PopupEntity(Loc.GetString("recycler-component-suicide-message-others", ("victim", Identity.Entity(victim, EntityManager))),
+ victim,
+ Filter.PvsExcept(victim, entityManager: EntityManager), true);
+
+ _body.GibBody(victim, true);
+ _appearance.SetData(uid, RecyclerVisuals.Bloody, true);
+ }
+
+ private void OnActivePowerChanged(EntityUid uid, ActiveMaterialReclaimerComponent component, ref PowerChangedEvent args)
+ {
+ if (!args.Powered)
+ TryFinishProcessItem(uid, null, component);
+ }
+
+ /// <inheritdoc/>
+ public override bool TryFinishProcessItem(EntityUid uid, MaterialReclaimerComponent? component = null, ActiveMaterialReclaimerComponent? active = null)
+ {
+ if (!Resolve(uid, ref component, ref active, false))
+ return false;
+
+ if (!base.TryFinishProcessItem(uid, component, active))
+ return false;
+
+ if (active.ReclaimingContainer.ContainedEntities.FirstOrNull() is not { } item)
+ return false;
+
+ active.ReclaimingContainer.Remove(item);
+ Dirty(component);
+
+ // scales the output if the process was interrupted.
+ var completion = 1f - Math.Clamp((float) Math.Round((active.EndTime - Timing.CurTime) / active.Duration),
+ 0f, 1f);
+ Reclaim(uid, item, completion, component);
+
+ return true;
+ }
+
+ /// <inheritdoc/>
+ public override void Reclaim(EntityUid uid,
+ EntityUid item,
+ float completion = 1f,
+ MaterialReclaimerComponent? component = null)
+ {
+ if (!Resolve(uid, ref component))
+ return;
+
+ var xform = Transform(uid);
+
+ SpawnMaterialsFromComposition(uid, item, completion * component.Efficiency, xform: xform);
+ SpawnChemicalsFromComposition(uid, item, completion, component, xform);
+
+ if (CanGib(uid, item, component))
+ {
+ _body.GibBody(item, true);
+ _appearance.SetData(uid, RecyclerVisuals.Bloody, true);
+ }
+
+ QueueDel(item);
+ }
+
+ private void SpawnMaterialsFromComposition(EntityUid reclaimer,
+ EntityUid item,
+ float efficiency,
+ MaterialStorageComponent? storage = null,
+ TransformComponent? xform = null,
+ PhysicalCompositionComponent? composition = null)
+ {
+ if (!Resolve(reclaimer, ref storage, ref xform, false))
+ return;
+
+ if (!Resolve(item, ref composition, false))
+ return;
+
+ foreach (var (material, amount) in composition.MaterialComposition)
+ {
+ var outputAmount = (int) (amount * efficiency);
+ _materialStorage.TryChangeMaterialAmount(reclaimer, material, outputAmount, storage);
+ }
+
+ foreach (var (storedMaterial, storedAmount) in storage.Storage)
+ {
+ var stacks = _materialStorage.SpawnMultipleFromMaterial(storedAmount, storedMaterial,
+ xform.Coordinates,
+ out var materialOverflow);
+ var amountConsumed = storedAmount - materialOverflow;
+ _materialStorage.TryChangeMaterialAmount(reclaimer, storedMaterial, -amountConsumed, storage);
+ foreach (var stack in stacks)
+ {
+ _stack.TryMergeToContacts(stack);
+ }
+ }
+ }
+
+ private void SpawnChemicalsFromComposition(EntityUid reclaimer,
+ EntityUid item,
+ float efficiency,
+ MaterialReclaimerComponent? reclaimerComponent = null,
+ TransformComponent? xform = null,
+ PhysicalCompositionComponent? composition = null)
+ {
+ if (!Resolve(reclaimer, ref reclaimerComponent, ref xform))
+ return;
+
+ var overflow = new Solution();
+ var totalChemicals = new Dictionary<string, FixedPoint2>();
+
+ if (Resolve(item, ref composition, false))
+ {
+ foreach (var (key, value) in composition.ChemicalComposition)
+ {
+ totalChemicals[key] = totalChemicals.GetValueOrDefault(key) + value;
+ }
+ }
+
+ // if the item we inserted has reagents, add it in.
+ if (TryComp<SolutionContainerManagerComponent>(item, out var solutionContainer))
+ {
+ foreach (var solution in solutionContainer.Solutions.Values)
+ {
+ foreach (var quantity in solution.Contents)
+ {
+ totalChemicals[quantity.ReagentId] =
+ totalChemicals.GetValueOrDefault(quantity.ReagentId) + quantity.Quantity;
+ }
+ }
+ }
+
+ foreach (var (reagent, amount) in totalChemicals)
+ {
+ var outputAmount = amount * efficiency * reclaimerComponent.Efficiency;
+ _solutionContainer.TryAddReagent(reclaimer, reclaimerComponent.OutputSolution, reagent, outputAmount,
+ out var accepted);
+ var overflowAmount = outputAmount - accepted;
+ if (overflowAmount > 0)
+ {
+ overflow.AddReagent(reagent, overflowAmount);
+ }
+ }
+
+ if (overflow.Volume > 0)
+ {
+ _spillable.SpillAt(reclaimer, overflow, reclaimerComponent.PuddleId, transformComponent: xform);
+ }
+ }
+}
return false;
if (!base.TryInsertMaterialEntity(user, toInsert, receiver, component))
return false;
- _audio.PlayPvs(component.InsertingSound, component.Owner);
- _popup.PopupEntity(Loc.GetString("machine-insert-item", ("user", user), ("machine", component.Owner),
- ("item", toInsert)), component.Owner);
+ _audio.PlayPvs(component.InsertingSound, receiver);
+ _popup.PopupEntity(Loc.GetString("machine-insert-item", ("user", user), ("machine", receiver),
+ ("item", toInsert)), receiver);
QueueDel(toInsert);
// Logging
/// 1 biomass = 1 biomass in its stack,
/// but 100 plasma = 1 sheet of plasma, etc.
/// </summary>
- [PublicAPI]
public List<EntityUid> SpawnMultipleFromMaterial(int amount, string material, EntityCoordinates coordinates)
{
+ return SpawnMultipleFromMaterial(amount, material, coordinates, out _);
+ }
+
+ /// <summary>
+ /// Spawn an amount of a material in stack entities.
+ /// Note the 'amount' is material dependent.
+ /// 1 biomass = 1 biomass in its stack,
+ /// but 100 plasma = 1 sheet of plasma, etc.
+ /// </summary>
+ public List<EntityUid> SpawnMultipleFromMaterial(int amount, string material, EntityCoordinates coordinates, out int overflowMaterial)
+ {
+ overflowMaterial = 0;
if (!_prototypeManager.TryIndex<MaterialPrototype>(material, out var stackType))
{
Logger.Error("Failed to index material prototype " + material);
return new List<EntityUid>();
}
- return SpawnMultipleFromMaterial(amount, stackType, coordinates);
+ return SpawnMultipleFromMaterial(amount, stackType, coordinates, out overflowMaterial);
}
/// <summary>
/// 1 biomass = 1 biomass in its stack,
/// but 100 plasma = 1 sheet of plasma, etc.
/// </summary>
+ [PublicAPI]
public List<EntityUid> SpawnMultipleFromMaterial(int amount, MaterialPrototype materialProto, EntityCoordinates coordinates)
{
+ return SpawnMultipleFromMaterial(amount, materialProto, coordinates, out _);
+ }
+
+ /// <summary>
+ /// Spawn an amount of a material in stack entities.
+ /// Note the 'amount' is material dependent.
+ /// 1 biomass = 1 biomass in its stack,
+ /// but 100 plasma = 1 sheet of plasma, etc.
+ /// </summary>
+ public List<EntityUid> SpawnMultipleFromMaterial(int amount, MaterialPrototype materialProto, EntityCoordinates coordinates, out int overflowMaterial)
+ {
+ overflowMaterial = 0;
+
if (amount <= 0)
return new List<EntityUid>();
var materialPerStack = material.Materials[materialProto.ID];
var amountToSpawn = amount / materialPerStack;
+ overflowMaterial = amount - amountToSpawn * materialPerStack;
return _stackSystem.SpawnMultiple(materialProto.StackEntity, amountToSpawn, coordinates);
}
}
using Content.Server.MachineLinking.Events;
using Content.Server.MachineLinking.System;
+using Content.Server.Materials;
using Content.Server.Power.Components;
-using Content.Server.Recycling;
-using Content.Server.Recycling.Components;
using Content.Shared.Conveyor;
using Content.Shared.Maps;
using Content.Shared.Physics;
public sealed class ConveyorController : SharedConveyorController
{
[Dependency] private readonly FixtureSystem _fixtures = default!;
- [Dependency] private readonly RecyclerSystem _recycler = default!;
+ [Dependency] private readonly MaterialReclaimerSystem _materialReclaimer = default!;
[Dependency] private readonly SignalLinkerSystem _signalSystem = default!;
[Dependency] private readonly SharedBroadphaseSystem _broadphase = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
if (TryComp<PhysicsComponent>(uid, out var physics))
_broadphase.RegenerateContacts(physics);
- if (TryComp<RecyclerComponent>(uid, out var recycler))
- {
- if (component.State != ConveyorState.Off)
- _recycler.EnableRecycler(recycler);
- else
- _recycler.DisableRecycler(recycler);
- }
+ _materialReclaimer.SetReclaimerEnabled(uid, component.State != ConveyorState.Off);
UpdateAppearance(uid, component);
Dirty(component);
+++ /dev/null
-using Robust.Shared.Prototypes;
-using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
-
-namespace Content.Server.Recycling.Components
-{
- [RegisterComponent, Access(typeof(RecyclerSystem))]
- public sealed class RecyclableComponent : Component
- {
- /// <summary>
- /// The prototype that will be spawned on recycle.
- /// </summary>
- [DataField("prototype", customTypeSerializer:typeof(PrototypeIdSerializer<EntityPrototype>))] public string? Prototype;
-
- /// <summary>
- /// The amount of things that will be spawned on recycle.
- /// </summary>
- [DataField("amount")] public int Amount = 1;
-
- /// <summary>
- /// Whether this is "safe" to recycle or not.
- /// If this is false, the recycler's safety must be disabled to recycle it.
- /// </summary>
- [DataField("safe")]
- public bool Safe { get; set; } = true;
- }
-}
+++ /dev/null
-using Content.Shared.Recycling;
-using Robust.Shared.Audio;
-
-namespace Content.Server.Recycling.Components
-{
- // TODO: Add sound and safe beep
- [RegisterComponent]
- [Access(typeof(RecyclerSystem))]
- public sealed class RecyclerComponent : Component
- {
- [Dependency] private readonly IEntityManager _entMan = default!;
-
- [DataField("enabled")]
- public bool Enabled;
-
- /// <summary>
- /// The percentage of material that will be recovered
- /// </summary>
- [ViewVariables(VVAccess.ReadWrite)]
- [DataField("efficiency")]
- internal float Efficiency = 0.25f;
-
- /// <summary>
- /// Default sound to play when recycling
- /// </summary>
- [ViewVariables(VVAccess.ReadWrite)] [DataField("sound")]
- public SoundSpecifier? Sound = new SoundPathSpecifier("/Audio/Effects/saw.ogg");
-
- // Ratelimit sounds to avoid spam
- public TimeSpan LastSound;
-
- public int ItemsProcessed;
- }
-}
+++ /dev/null
-using Content.Server.Audio;
-using Content.Server.Body.Systems;
-using Content.Server.GameTicking;
-using Content.Server.Players;
-using Content.Server.Popups;
-using Content.Server.Power.Components;
-using Content.Server.Power.EntitySystems;
-using Content.Server.Recycling.Components;
-using Content.Shared.Audio;
-using Content.Shared.Body.Components;
-using Content.Shared.Emag.Components;
-using Content.Shared.Emag.Systems;
-using Content.Shared.Examine;
-using Content.Shared.IdentityManagement;
-using Content.Shared.Interaction.Events;
-using Content.Shared.Recycling;
-using Content.Shared.Tag;
-using Robust.Server.GameObjects;
-using Robust.Shared.Audio;
-using Robust.Shared.Physics.Events;
-using Robust.Shared.Player;
-using Robust.Shared.Timing;
-
-namespace Content.Server.Recycling
-{
- public sealed class RecyclerSystem : EntitySystem
- {
- [Dependency] private readonly IGameTiming _timing = default!;
- [Dependency] private readonly AmbientSoundSystem _ambience = default!;
- [Dependency] private readonly BodySystem _bodySystem = default!;
- [Dependency] private readonly GameTicker _ticker = default!;
- [Dependency] private readonly PopupSystem _popup = default!;
- [Dependency] private readonly TagSystem _tags = default!;
- [Dependency] private readonly AudioSystem _soundSystem = default!;
- [Dependency] private readonly SharedAppearanceSystem _appearanceSystem = default!;
-
- private const string RecyclerColliderName = "brrt";
-
- private const float RecyclerSoundCooldown = 0.8f;
-
- public override void Initialize()
- {
- SubscribeLocalEvent<RecyclerComponent, ExaminedEvent>(OnExamined);
- SubscribeLocalEvent<RecyclerComponent, StartCollideEvent>(OnCollide);
- SubscribeLocalEvent<RecyclerComponent, GotEmaggedEvent>(OnEmagged);
- SubscribeLocalEvent<RecyclerComponent, SuicideEvent>(OnSuicide);
- SubscribeLocalEvent<RecyclerComponent, PowerChangedEvent>(OnPowerChanged);
- }
-
- private void OnExamined(EntityUid uid, RecyclerComponent component, ExaminedEvent args)
- {
- args.PushMarkup(Loc.GetString("recycler-count-items", ("items", component.ItemsProcessed)));
- }
-
- private void OnSuicide(EntityUid uid, RecyclerComponent component, SuicideEvent args)
- {
- if (args.Handled) return;
- args.SetHandled(SuicideKind.Bloodloss);
- var victim = args.Victim;
- if (TryComp(victim, out ActorComponent? actor) &&
- actor.PlayerSession.ContentData()?.Mind is { } mind)
- {
- _ticker.OnGhostAttempt(mind, false);
- if (mind.OwnedEntity is { Valid: true } entity)
- {
- _popup.PopupEntity(Loc.GetString("recycler-component-suicide-message"), entity);
- }
- }
-
- _popup.PopupEntity(Loc.GetString("recycler-component-suicide-message-others", ("victim", Identity.Entity(victim, EntityManager))),
- victim,
- Filter.PvsExcept(victim, entityManager: EntityManager), true);
-
- if (TryComp<BodyComponent?>(victim, out var body))
- {
- _bodySystem.GibBody(victim, true, body);
- }
-
- Bloodstain(component);
- }
-
- public void EnableRecycler(RecyclerComponent component)
- {
- if (component.Enabled) return;
-
- component.Enabled = true;
-
- if (TryComp(component.Owner, out ApcPowerReceiverComponent? apcPower))
- {
- _ambience.SetAmbience(component.Owner, apcPower.Powered);
- }
- else
- {
- _ambience.SetAmbience(component.Owner, true);
- }
-
- }
-
- public void DisableRecycler(RecyclerComponent component)
- {
- if (!component.Enabled) return;
-
- component.Enabled = false;
- _ambience.SetAmbience(component.Owner, false);
- }
-
- private void OnPowerChanged(EntityUid uid, RecyclerComponent component, ref PowerChangedEvent args)
- {
- if (component.Enabled)
- {
- _ambience.SetAmbience(uid, args.Powered);
- }
- }
-
- private void OnCollide(EntityUid uid, RecyclerComponent component, ref StartCollideEvent args)
- {
- if (component.Enabled && args.OurFixture.ID != RecyclerColliderName)
- return;
-
- if (TryComp(uid, out ApcPowerReceiverComponent? apcPower))
- {
- if (!apcPower.Powered)
- return;
- }
-
- Recycle(component, args.OtherFixture.Body.Owner);
- }
-
- private void Recycle(RecyclerComponent component, EntityUid entity)
- {
- RecyclableComponent? recyclable = null;
-
- // Can only recycle things that are tagged trash or recyclable... And also check the safety of the thing to recycle.
- if (!_tags.HasAnyTag(entity, "Trash", "Recyclable") &&
- (!TryComp(entity, out recyclable) || !recyclable.Safe && !HasComp<EmaggedComponent>(component.Owner)))
- {
- return;
- }
-
- // TODO: Prevent collision with recycled items
-
- // Mobs are a special case!
- if (CanGib(component, entity))
- {
- _bodySystem.GibBody(entity, true, Comp<BodyComponent>(entity));
- Bloodstain(component);
- return;
- }
-
- if (recyclable == null)
- QueueDel(entity);
- else
- Recycle(recyclable, component.Efficiency);
-
- if (component.Sound != null && (_timing.CurTime - component.LastSound).TotalSeconds > RecyclerSoundCooldown)
- {
- _soundSystem.PlayPvs(component.Sound, component.Owner, AudioHelpers.WithVariation(0.01f).WithVolume(-3));
- component.LastSound = _timing.CurTime;
- }
-
- component.ItemsProcessed++;
- }
-
- private bool CanGib(RecyclerComponent component, EntityUid entity)
- {
- return HasComp<BodyComponent>(entity) && HasComp<EmaggedComponent>(component.Owner) &&
- this.IsPowered(component.Owner, EntityManager);
- }
-
- public void Bloodstain(RecyclerComponent component)
- {
- if (EntityManager.TryGetComponent(component.Owner, out AppearanceComponent? appearance))
- {
- _appearanceSystem.SetData(component.Owner, RecyclerVisuals.Bloody, true, appearance);
- }
- }
-
- private void Recycle(RecyclableComponent component, float efficiency = 1f)
- {
- if (!string.IsNullOrEmpty(component.Prototype))
- {
- var xform = Transform(component.Owner);
-
- for (var i = 0; i < Math.Max(component.Amount * efficiency, 1); i++)
- {
- Spawn(component.Prototype, xform.Coordinates);
- }
- }
-
- QueueDel(component.Owner);
- }
-
- private void OnEmagged(EntityUid uid, RecyclerComponent component, ref GotEmaggedEvent args)
- {
- // no fancy conditions
- args.Handled = true;
- }
- }
-}
[DataField("partRatingMaterialUseMultiplier")]
public float PartRatingMaterialUseMultiplier = DefaultPartRatingMaterialUseMultiplier;
- public const float DefaultPartRatingMaterialUseMultiplier = 0.75f;
+ public const float DefaultPartRatingMaterialUseMultiplier = 0.85f;
#endregion
}
--- /dev/null
+using Robust.Shared.Containers;
+using Robust.Shared.GameStates;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+
+namespace Content.Shared.Materials;
+
+/// <summary>
+/// Tracker component for the process of reclaiming entities
+/// <seealso cref="MaterialReclaimerComponent"/>
+/// </summary>
+[RegisterComponent, NetworkedComponent, Access(typeof(SharedMaterialReclaimerSystem))]
+public sealed class ActiveMaterialReclaimerComponent : Component
+{
+ /// <summary>
+ /// Container used to store the item currently being reclaimed
+ /// </summary>
+ [ViewVariables(VVAccess.ReadWrite)]
+ public Container ReclaimingContainer = default!;
+
+ /// <summary>
+ /// When the reclaiming process ends.
+ /// </summary>
+ [DataField("endTime", customTypeSerializer: typeof(TimeOffsetSerializer)), ViewVariables(VVAccess.ReadWrite)]
+ public TimeSpan EndTime;
+
+ /// <summary>
+ /// The length of the reclaiming process.
+ /// Used for calculations.
+ /// </summary>
+ [DataField("duration"), ViewVariables(VVAccess.ReadWrite)]
+ public TimeSpan Duration;
+}
--- /dev/null
+namespace Content.Shared.Materials;
+
+/// <summary>
+/// Valid items that collide with an entity with this component
+/// will begin to be reclaimed.
+/// <seealso cref="MaterialReclaimerComponent"/>
+/// </summary>
+[RegisterComponent]
+public sealed class CollideMaterialReclaimerComponent : Component
+{
+ /// <summary>
+ /// The fixture that starts reclaiming on collision.
+ /// </summary>
+ [DataField("fixtureId")]
+ public string FixtureId = "brrt";
+}
--- /dev/null
+using Content.Shared.Chemistry.Components;
+using Content.Shared.Construction.Prototypes;
+using Content.Shared.Whitelist;
+using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
+
+namespace Content.Shared.Materials;
+
+/// <summary>
+/// This is a machine that handles converting entities
+/// into the raw materials and chemicals that make them up.
+/// </summary>
+[RegisterComponent, NetworkedComponent, Access(typeof(SharedMaterialReclaimerSystem))]
+public sealed class MaterialReclaimerComponent : Component
+{
+ /// <summary>
+ /// Whether or not the machine has power. We put it here
+ /// so we can network and predict it.
+ /// </summary>
+ [DataField("powered"), ViewVariables(VVAccess.ReadWrite)]
+ public bool Powered;
+
+ /// <summary>
+ /// An "enable" toggle for things like interfacing with machine linking
+ /// </summary>
+ [DataField("enabled"), ViewVariables(VVAccess.ReadWrite)]
+ public bool Enabled = true;
+
+ /// <summary>
+ /// How efficiently the materials are reclaimed.
+ /// In practice, a multiplier per material when calculating the output of the reclaimer.
+ /// </summary>
+ [DataField("efficiency"), ViewVariables(VVAccess.ReadWrite)]
+ public float Efficiency = 1f;
+
+ /// <summary>
+ /// Whether or not the process
+ /// speed scales with the amount of materials being processed
+ /// or if it's just <see cref="MinimumProcessDuration"/>
+ /// </summary>
+ [DataField("scaleProcessSpeed")]
+ public bool ScaleProcessSpeed = true;
+
+ /// <summary>
+ /// How quickly it takes to consume X amount of materials per second.
+ /// For example, with a rate of 50, an entity with 100 total material takes 2 seconds to process.
+ /// </summary>
+ [DataField("baseMaterialProcessRate"), ViewVariables(VVAccess.ReadWrite)]
+ public float BaseMaterialProcessRate = 100f;
+
+ /// <summary>
+ /// How quickly it takes to consume X amount of materials per second.
+ /// For example, with a rate of 50, an entity with 100 total material takes 2 seconds to process.
+ /// </summary>
+ [DataField("materialProcessRate"), ViewVariables(VVAccess.ReadWrite)]
+ public float MaterialProcessRate = 100f;
+
+ /// <summary>
+ /// Machine part whose rating modifies <see cref="MaterialProcessRate"/>
+ /// </summary>
+ [DataField("machinePartProcessRate", customTypeSerializer: typeof(PrototypeIdSerializer<MachinePartPrototype>)), ViewVariables(VVAccess.ReadWrite)]
+ public string MachinePartProcessRate = "Manipulator";
+
+ /// <summary>
+ /// How much the machine part quality affects the <see cref="MaterialProcessRate"/>
+ /// </summary>
+ [DataField("partRatingProcessRateMultiplier"), ViewVariables(VVAccess.ReadWrite)]
+ public float PartRatingProcessRateMultiplier = 1.5f;
+
+ /// <summary>
+ /// The minimum amount fo time it can take to process an entity.
+ /// this value supercedes the calculated one using <see cref="MaterialProcessRate"/>
+ /// </summary>
+ [DataField("minimumProcessDuration"), ViewVariables(VVAccess.ReadWrite)]
+ public TimeSpan MinimumProcessDuration = TimeSpan.FromSeconds(0.5f);
+
+ /// <summary>
+ /// The id of our output solution
+ /// </summary>
+ [DataField("solutionContainerId"), ViewVariables(VVAccess.ReadWrite)]
+ public string SolutionContainerId = "output";
+
+ /// <summary>
+ /// The prototype for the puddle
+ /// </summary>
+ [DataField("puddleId", customTypeSerializer: typeof(PrototypeIdSerializer<EntityPrototype>)), ViewVariables(VVAccess.ReadWrite)]
+ public string PuddleId = "PuddleSmear";
+
+ /// <summary>
+ /// The solution itself.
+ /// </summary>
+ [ViewVariables(VVAccess.ReadWrite)]
+ public Solution OutputSolution = default!;
+
+ /// <summary>
+ /// a whitelist for what entities can be inserted into this reclaimer
+ /// </summary>
+ [DataField("whitelist")]
+ public EntityWhitelist? Whitelist;
+
+ /// <summary>
+ /// a blacklist for what entities cannot be inserted into this reclaimer
+ /// </summary>
+ [DataField("blacklist")]
+ public EntityWhitelist? Blacklist;
+
+ /// <summary>
+ /// The sound played when something is being processed.
+ /// </summary>
+ [DataField("sound")]
+ public SoundSpecifier? Sound;
+
+ /// <summary>
+ /// whether or not we cut off the sound early when the reclaiming ends.
+ /// </summary>
+ [DataField("cutOffSound")]
+ public bool CutOffSound = true;
+
+ /// <summary>
+ /// When the next sound will be allowed to be played. Used to prevent spam.
+ /// </summary>
+ [DataField("nextSound", customTypeSerializer: typeof(TimeOffsetSerializer))]
+ public TimeSpan NextSound;
+
+ /// <summary>
+ /// Minimum time inbetween each <see cref="Sound"/>
+ /// </summary>
+ [DataField("soundCooldown")]
+ public TimeSpan SoundCooldown = TimeSpan.FromSeconds(0.8f);
+
+ public IPlayingAudioStream? Stream;
+
+ /// <summary>
+ /// A counter of how many items have been processed
+ /// </summary>
+ /// <remarks>
+ /// I saw this on the recycler and i'm porting it because it's cute af
+ /// </remarks>
+ [DataField("itemsProcessed")]
+ public int ItemsProcessed;
+}
+
+[Serializable, NetSerializable]
+public sealed class MaterialReclaimerComponentState : ComponentState
+{
+ public bool Powered;
+
+ public bool Enabled;
+
+ public float MaterialProcessRate;
+
+ public int ItemsProcessed;
+
+ public MaterialReclaimerComponentState(bool powered, bool enabled, float materialProcessRate, int itemsProcessed)
+ {
+ Powered = powered;
+ Enabled = enabled;
+ MaterialProcessRate = materialProcessRate;
+ ItemsProcessed = itemsProcessed;
+ }
+}
+
+[NetSerializable, Serializable]
+public enum RecyclerVisuals
+{
+ Bloody
+}
+
+public enum RecyclerVisualLayers : byte
+{
+ Main,
+ Bloody
+}
[DataField("storage", customTypeSerializer: typeof(PrototypeIdDictionarySerializer<int, MaterialPrototype>))]
public Dictionary<string, int> Storage { get; set; } = new();
+ /// <summary>
+ /// Whether or not interacting with the materialstorage inserts the material in hand.
+ /// </summary>
+ [DataField("insertOnInteract")]
+ public bool InsertOnInteract = true;
+
/// <summary>
/// How much material the storage can store in total.
/// </summary>
--- /dev/null
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.FixedPoint;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.Dictionary;
+
+namespace Content.Shared.Materials;
+
+/// <summary>
+/// This is used for assigning an innate material/chemical composition to an entity.
+/// These aren't materials per se, but rather the materials which "make up" an entity.
+/// This also isn't something that should exist simultaneously with <see cref="MaterialComponent"/>.
+/// </summary>
+/// <remarks>
+/// The reason for duel material/chemical is for the eventual
+/// combination of the two systems.
+/// </remarks>
+[RegisterComponent]
+public sealed class PhysicalCompositionComponent : Component
+{
+ /// <summary>
+ /// The materials that "make up" this entity
+ /// </summary>
+ [DataField("materialComposition", customTypeSerializer: typeof(PrototypeIdDictionarySerializer<int, MaterialPrototype>))]
+ public Dictionary<string, int> MaterialComposition = new();
+
+ /// <summary>
+ /// The chemicals that "make up" this entity
+ /// </summary>
+ [DataField("chemicalComposition", customTypeSerializer: typeof(PrototypeIdDictionarySerializer<FixedPoint2, ReagentPrototype>))]
+ public Dictionary<string, FixedPoint2> ChemicalComposition = new();
+}
--- /dev/null
+using System.Linq;
+using Content.Shared.Administration.Logs;
+using Content.Shared.Audio;
+using Content.Shared.Body.Components;
+using Content.Shared.Database;
+using Content.Shared.Emag.Components;
+using Content.Shared.Emag.Systems;
+using Content.Shared.Examine;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Stacks;
+using Robust.Shared.Containers;
+using Robust.Shared.GameStates;
+using Robust.Shared.Physics.Events;
+using Robust.Shared.Timing;
+
+namespace Content.Shared.Materials;
+
+/// <summary>
+/// Handles interactions and logic related to <see cref="MaterialReclaimerComponent"/>,
+/// <see cref="CollideMaterialReclaimerComponent"/>, and <see cref="ActiveMaterialReclaimerComponent"/>.
+/// </summary>
+public abstract class SharedMaterialReclaimerSystem : EntitySystem
+{
+ [Dependency] private readonly ISharedAdminLogManager _adminLog = default!;
+ [Dependency] protected readonly IGameTiming Timing = default!;
+ [Dependency] protected readonly SharedAmbientSoundSystem AmbientSound = default!;
+ [Dependency] private readonly SharedAudioSystem _audio = default!;
+ [Dependency] private readonly SharedContainerSystem _container = default!;
+
+ public const string ActiveReclaimerContainerId = "active-material-reclaimer-container";
+
+ /// <inheritdoc/>
+ public override void Initialize()
+ {
+ SubscribeLocalEvent<MaterialReclaimerComponent, ComponentGetState>(OnGetState);
+ SubscribeLocalEvent<MaterialReclaimerComponent, ComponentHandleState>(OnHandleState);
+ SubscribeLocalEvent<MaterialReclaimerComponent, EntityUnpausedEvent>(OnUnpaused);
+ SubscribeLocalEvent<MaterialReclaimerComponent, ExaminedEvent>(OnExamined);
+ SubscribeLocalEvent<MaterialReclaimerComponent, GotEmaggedEvent>(OnEmagged);
+ SubscribeLocalEvent<CollideMaterialReclaimerComponent, StartCollideEvent>(OnCollide);
+ SubscribeLocalEvent<ActiveMaterialReclaimerComponent, ComponentStartup>(OnActiveStartup);
+ SubscribeLocalEvent<ActiveMaterialReclaimerComponent, EntityUnpausedEvent>(OnActiveUnpaused);
+ }
+
+ private void OnGetState(EntityUid uid, MaterialReclaimerComponent component, ref ComponentGetState args)
+ {
+ args.State = new MaterialReclaimerComponentState(component.Powered,
+ component.Enabled,
+ component.MaterialProcessRate,
+ component.ItemsProcessed);
+ }
+
+ private void OnHandleState(EntityUid uid, MaterialReclaimerComponent component, ref ComponentHandleState args)
+ {
+ if (args.Current is not MaterialReclaimerComponentState state)
+ return;
+ component.Powered = state.Powered;
+ component.Enabled = state.Enabled;
+ component.MaterialProcessRate = state.MaterialProcessRate;
+ component.ItemsProcessed = state.ItemsProcessed;
+ }
+
+ private void OnUnpaused(EntityUid uid, MaterialReclaimerComponent component, ref EntityUnpausedEvent args)
+ {
+ component.NextSound += args.PausedTime;
+ }
+
+ private void OnExamined(EntityUid uid, MaterialReclaimerComponent component, ExaminedEvent args)
+ {
+ args.PushMarkup(Loc.GetString("recycler-count-items", ("items", component.ItemsProcessed)));
+ }
+
+ private void OnEmagged(EntityUid uid, MaterialReclaimerComponent component, ref GotEmaggedEvent args)
+ {
+ args.Handled = true;
+ }
+
+ private void OnCollide(EntityUid uid, CollideMaterialReclaimerComponent component, ref StartCollideEvent args)
+ {
+ if (args.OurFixture.ID != component.FixtureId)
+ return;
+ if (!TryComp<MaterialReclaimerComponent>(uid, out var reclaimer))
+ return;
+ TryStartProcessItem(uid, args.OtherFixture.Body.Owner, reclaimer);
+ }
+
+ private void OnActiveStartup(EntityUid uid, ActiveMaterialReclaimerComponent component, ComponentStartup args)
+ {
+ component.ReclaimingContainer = _container.EnsureContainer<Container>(uid, ActiveReclaimerContainerId);
+ }
+
+ private void OnActiveUnpaused(EntityUid uid, ActiveMaterialReclaimerComponent component, ref EntityUnpausedEvent args)
+ {
+ component.EndTime += args.PausedTime;
+ }
+
+ /// <summary>
+ /// Tries to start processing an item via a <see cref="MaterialReclaimerComponent"/>.
+ /// </summary>
+ public bool TryStartProcessItem(EntityUid uid, EntityUid item, MaterialReclaimerComponent? component = null, EntityUid? user = null)
+ {
+ if (!Resolve(uid, ref component))
+ return false;
+
+ if (!CanStart(uid, component))
+ return false;
+
+ if (component.Whitelist != null && !component.Whitelist.IsValid(item) ||
+ HasComp<MobStateComponent>(item) && !CanGib(uid, item, component)) // whitelist? We be gibbing, boy!
+ return false;
+
+ if (component.Blacklist != null && component.Blacklist.IsValid(item))
+ return false;
+
+ if (user != null)
+ {
+ _adminLog.Add(LogType.Action, LogImpact.High,
+ $"{ToPrettyString(user.Value):player} destroyed {ToPrettyString(item)} in the material reclaimer, {ToPrettyString(uid)}");
+ }
+
+ if (Timing.CurTime > component.NextSound)
+ component.Stream = _audio.PlayPvs(component.Sound, uid);
+ component.NextSound = Timing.CurTime + component.SoundCooldown;
+
+ var duration = GetReclaimingDuration(uid, item, component);
+ // if it's instant, don't bother with all the active comp stuff.
+ if (duration == TimeSpan.Zero)
+ {
+ Reclaim(uid, item, 1, component);
+ return true;
+ }
+
+ var active = EnsureComp<ActiveMaterialReclaimerComponent>(uid);
+ active.Duration = duration;
+ active.EndTime = Timing.CurTime + duration;
+ active.ReclaimingContainer.Insert(item);
+ return true;
+ }
+
+ /// <summary>
+ /// Finishes processing an item, freeing up the the reclaimer.
+ /// </summary>
+ /// <remarks>
+ /// This doesn't reclaim the entity itself, but rather ends the formal
+ /// process started with <see cref="ActiveMaterialReclaimerComponent"/>.
+ /// The actual reclaiming happens in <see cref="Reclaim"/>
+ /// </remarks>
+ public virtual bool TryFinishProcessItem(EntityUid uid, MaterialReclaimerComponent? component = null, ActiveMaterialReclaimerComponent? active = null)
+ {
+ if (!Resolve(uid, ref component, ref active, false))
+ return false;
+
+ RemCompDeferred(uid, active);
+ return true;
+ }
+
+ /// <summary>
+ /// Spawns the materials and chemicals associated
+ /// with an entity. Also deletes the item.
+ /// </summary>
+ public virtual void Reclaim(EntityUid uid,
+ EntityUid item,
+ float completion = 1f,
+ MaterialReclaimerComponent? component = null)
+ {
+ if (!Resolve(uid, ref component))
+ return;
+
+ component.ItemsProcessed++;
+ if (component.CutOffSound)
+ component.Stream?.Stop();
+
+ Dirty(component);
+ }
+
+ /// <summary>
+ /// Sets the Enabled field on the reclaimer.
+ /// </summary>
+ public void SetReclaimerEnabled(EntityUid uid, bool enabled, MaterialReclaimerComponent? component = null)
+ {
+ if (!Resolve(uid, ref component, false))
+ return;
+ component.Enabled = enabled;
+ AmbientSound.SetAmbience(uid, enabled && component.Powered);
+ Dirty(component);
+ }
+
+ /// <summary>
+ /// Whether or not the specified reclaimer can currently
+ /// begin reclaiming another entity.
+ /// </summary>
+ public bool CanStart(EntityUid uid, MaterialReclaimerComponent component)
+ {
+ if (HasComp<ActiveMaterialReclaimerComponent>(uid))
+ return false;
+
+ return component.Powered && component.Enabled;
+ }
+
+ /// <summary>
+ /// Whether or not the reclaimer satisfies the conditions
+ /// allowing it to gib/reclaim a living creature.
+ /// </summary>
+ public bool CanGib(EntityUid uid, EntityUid victim, MaterialReclaimerComponent component)
+ {
+ return component.Powered &&
+ component.Enabled &&
+ HasComp<BodyComponent>(victim) &&
+ HasComp<EmaggedComponent>(uid);
+ }
+
+ /// <summary>
+ /// Gets the duration of processing a specified entity.
+ /// Processing is calculated from the sum of the materials within the entity.
+ /// It does not regard the chemicals within it.
+ /// </summary>
+ public TimeSpan GetReclaimingDuration(EntityUid reclaimer,
+ EntityUid item,
+ MaterialReclaimerComponent? reclaimerComponent = null,
+ PhysicalCompositionComponent? compositionComponent = null)
+ {
+ if (!Resolve(reclaimer, ref reclaimerComponent))
+ return TimeSpan.Zero;
+
+ if (!reclaimerComponent.ScaleProcessSpeed ||
+ !Resolve(item, ref compositionComponent, false))
+ return reclaimerComponent.MinimumProcessDuration;
+
+ var materialSum = compositionComponent.MaterialComposition.Values.Sum();
+ materialSum *= CompOrNull<StackComponent>(item)?.Count ?? 1;
+ var duration = TimeSpan.FromSeconds(materialSum / reclaimerComponent.MaterialProcessRate);
+ if (duration < reclaimerComponent.MinimumProcessDuration)
+ duration = reclaimerComponent.MinimumProcessDuration;
+ return duration;
+ }
+
+ /// <inheritdoc/>
+ public override void Update(float frameTime)
+ {
+ base.Update(frameTime);
+ var query = EntityQueryEnumerator<ActiveMaterialReclaimerComponent, MaterialReclaimerComponent>();
+ while (query.MoveNext(out var uid, out var active, out var reclaimer))
+ {
+ if (Timing.CurTime < active.EndTime)
+ continue;
+ TryFinishProcessItem(uid, reclaimer, active);
+ }
+ }
+}
private void OnInteractUsing(EntityUid uid, MaterialStorageComponent component, InteractUsingEvent args)
{
- if (args.Handled)
+ if (args.Handled || !component.InsertOnInteract)
return;
args.Handled = TryInsertMaterialEntity(args.User, args.Used, uid, component);
}
+++ /dev/null
-using Robust.Shared.Serialization;
-
-namespace Content.Shared.Recycling
-{
- [NetSerializable, Serializable]
- public enum RecyclerVisuals
- {
- Bloody
- }
-}
- files: ["anomaly_generator.ogg"]
license: "CC0-1.0"
copyright: "Created by steaq, converted Mono and .ogg by EmoGarbage"
- source: "https://freesound.org/people/steaq/sounds/509249/"
\ No newline at end of file
+ source: "https://freesound.org/people/steaq/sounds/509249/"
+
+- files: ["crushing.ogg"]
+ license: "CC-BY-4.0"
+ copyright: "Created by juskiddink, converted Mono and .ogg by EmoGarbage"
+ source: "https://freesound.org/people/juskiddink/sounds/66956/"
\ No newline at end of file
materials-plastic = plastic
materials-wood = wood
materials-uranium = uranium
+
+# Material Reclaimer
+material-reclaimer-upgrade-process-rate = process rate
\ No newline at end of file
- type: Tag
tags:
- Trash
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 25
- type: entity
id: LeftArmBorg
tags:
- Trash
- BorgArm
- - type: Recyclable
- type: entity
id: RightArmBorg
tags:
- Trash
- BorgArm
- - type: Recyclable
- SheetPlastic
- SheetRGlass
- SheetGlass1
+ - MaterialReclaimerMachineCircuitboard
# Electromagnetic Theory Technology Tree
- type: Clothing
slots: [belt]
quickEquip: false
+ - type: PhysicalComposition
+ materialComposition:
+ Cloth: 50
+ - type: StaticPrice
+ price: 25
- type: entity
abstract: true
sprite: Clothing/Head/Misc/cone.rsi
- type: Clothing
sprite: Clothing/Head/Misc/cone.rsi
+ - type: PhysicalComposition #you can't just pass up some free plastic!
+ materialComposition:
+ Plastic: 100
- type: entity
parent: ClothingHeadBase
- type: FlashImmunity
- type: IdentityBlocker
- type: EyeProtection
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 500
+ Glass: 100
+ - type: StaticPrice
+ price: 50
- type: entity
parent: WeldingMaskBase
- type: Tag
tags:
- PetWearable
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 50
+ Plastic: 100
- type: entity
parent: ClothingMaskBase
sprintModifier: 0.75
- type: Item
size: 100
+ - type: Tag
+ tags:
+ - WhitelistChameleon
+ - HighRiskItem
- type: ExplosionResistance
damageCoefficient: 0.1
- type: ToggleableClothing
sprintModifier: 1
enabled: false
- type: NoSlip
+ - type: Tag
+ tags:
+ - WhitelistChameleon
+ - HighRiskItem
- type: StaticPrice
price: 750
tags:
- Trash
- CannotSuicide
- - type: Recyclable
- type: Respirator
damage:
types:
tags:
- Trash
- CannotSuicide
- - type: Recyclable
- type: Respirator
damage:
types:
noRot: true
drawdepth: Mobs
netsync: false
- - type: Recyclable
- safe: false
- type: Faction
factions:
- SimpleNeutral
- type: Polymorphable
- type: Pullable
- type: Buckle
- - type: Recyclable
- safe: false
- type: StandingState
- type: Alerts
- type: NameIdentifier
- type: Pullable
- type: Examiner
- type: Puller
- - type: Recyclable
- safe: false
- type: StandingState
- type: Alerts
- type: Tag
spawned:
- id: FoodMeat
amount: 5
- # - type: Recyclable Turns out turning off recycler safeties without considering the instagib is a bad idea
- # safe: false
- type: Speech
speechSounds: Alto
- type: Vocal
damage:
types:
Blunt: 5
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 25
# Transformable container - normal glass
- type: entity
- type: Tag
tags:
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: entity
types:
Blunt: 0
- type: ItemCooldown
- - type: Recyclable
- type: SpaceGarbage
- type: TrashOnEmpty
solution: drink
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 50 #reduce, reuse, recycle
- type: entity
parent: DrinkCanBaseFull
- type: SolutionContainerVisuals
maxFillLevels: 3
fillBaseName: icon-
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 25
- type: entity
parent: DrinkBaseMug
components:
- type: Sprite
sprite: Objects/Consumable/Drinks/mug_metal.rsi
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 25
- type: entity
parent: DrinkBaseMug
- type: Drink
- type: Sprite
sprite: Objects/Consumable/Drinks/shinyflask.rsi
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 50
- type: entity
parent: DrinkBase
interfaces:
- key: enum.TransferAmountUiKey.Key
type: TransferAmountBoundUserInterface
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 50
- type: entity
parent: DrinkGlassBase
- type: Tag
tags:
- Trash
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 100
- type: SpaceGarbage
# Containers
- type: Tag
tags:
- Trash
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 50
- type: SpaceGarbage
- type: StaticPrice
price: 0
- type: Tag
tags:
- Trash
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 100
- type: SpaceGarbage
- type: entity
- type: Tag
tags:
- Trash
- - type: Recyclable
- type: SpaceGarbage
# Small Plate
- type: Tag
tags:
- Trash
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 100
- type: SpaceGarbage
Blunt: 3
- type: Damageable
damageContainer: Inorganic
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 100
- type: entity
abstract: true
- type: Tag
tags:
- Trash
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 100
# Tins
# Need something that you can open these tins with. I suggest a prying or cutting tool.
tags:
- Egg
- Trash
- - type: Recyclable
- type: SpaceGarbage
# Egg
flavors:
- food
- type: Food
- - type: Recyclable
- type: SpaceGarbage
- type: Sprite
netsync: false
- type: Tag
tags:
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: Tag
tags:
- Raw
+ - HighRiskItem
- type: Sprite
state: corgi
- type: SolutionContainerManager
Quantity: 4
- type: Extractable
grindableSolutionName: food
- - type: Recyclable
- type: SpaceGarbage
- type: entity
- type: Tag
tags:
- Trash
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 100
- type: SpaceGarbage
- type: StaticPrice
price: 0
- type: Tag
tags:
- Trash
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Plastic: 50
- type: SpaceGarbage
- type: entity
tags:
- Cigarette
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: Clothing
sprite: Objects/Consumable/Smokeables/Cigarettes/cigarette.rsi
tags:
- Cigarette
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: Clothing
sprite: Objects/Consumable/Smokeables/Cannabis/joint.rsi
tags:
- Cigarette
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: Clothing
sprite: Objects/Consumable/Smokeables/Cannabis/blunt.rsi
tags:
- CigPack
- Trash
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 50
- type: SpaceGarbage
- type: Storage
capacity: 6
tags:
- RollingPaper
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: entity
tags:
- CigFilter
- Trash
- - type: Recyclable
- type: entity
id: CigaretteFilter1
- type: Tag
tags:
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: StaticPrice
price: 5
bowl_slot: !type:ContainerSlot
- type: ItemSlots
- type: SmokingPipe
- bowl_slot:
+ bowl_slot:
name: Bowl
whitelist:
tags:
- Smokable
- insertSound:
+ insertSound:
path: /Audio/Weapons/Guns/Empty/empty.ogg
- ejectSound:
+ ejectSound:
path: /Audio/Weapons/Guns/Empty/empty.ogg
- type: SolutionContainerManager
solutions:
- type: Tag
tags:
- Trash
- - type: Recyclable
- type: SpaceGarbage
- DroneUsable
- type: StaticPrice
price: 100
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 400
+ chemicalComposition:
+ Silicon: 20
+
materialRequirements:
CableMV: 5
CableHV: 5
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 200
+ chemicalComposition:
+ Silicon: 20
- type: entity
parent: BaseMachineCircuitboard
Capacitor: 1
materialRequirements:
CableHV: 5
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 200
+ chemicalComposition:
+ Silicon: 20
- type: entity
id: ThrusterMachineCircuitboard
Capacitor: 2
materialRequirements:
CableHV: 10
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 200
+ chemicalComposition:
+ Silicon: 20
- type: entity
id: ReagentGrinderMachineCircuitboard
DefaultPrototype: CryostasisBeaker
ExamineName: Cryostasis Beaker
+- type: entity
+ id: MaterialReclaimerMachineCircuitboard
+ parent: BaseMachineCircuitboard
+ name: material reclaimer machine board
+ components:
+ - type: Sprite
+ state: supply
+ - type: MachineBoard
+ prototype: MaterialReclaimer
+ requirements:
+ Manipulator: 2
+ materialRequirements:
+ Steel: 5
+ Plastic: 5
+
- type: entity
id: OreProcessorMachineCircuitboard
parent: BaseMachineCircuitboard
materialRequirements:
Steel: 10
Plasma: 5
-
+
- type: entity
id: BoozeDispenserMachineCircuitboard
parent: BaseMachineCircuitboard
- type: entity
id: TelecomServerCircuitboard
parent: BaseMachineCircuitboard
- name: telecommunication server machine board
+ name: telecommunication server machine board
description: A machine printed circuit board for an telecommunication server.
components:
- type: MachineBoard
- DroneUsable
- type: StaticPrice
price: 100
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 400
+ chemicalComposition:
+ Silicon: 20
- type: entity
parent: BaseComputerCircuitboard
prototype: ComputerCargoOrders
- type: StaticPrice
price: 750
+ - type: Tag
+ tags:
+ - DroneUsable
+ - HighRiskItem
- type: entity
parent: BaseComputerCircuitboard
prototype: ComputerId
- type: StaticPrice
price: 750
+ - type: Tag
+ tags:
+ - DroneUsable
+ - HighRiskItem
- type: entity
parent: BaseComputerCircuitboard
- DroneUsable
- type: StaticPrice
price: 100
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 200
+ chemicalComposition:
+ Silicon: 20
sprite: Objects/Misc/module.rsi
state: charger_APC
netsync: false
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 50
+ chemicalComposition:
+ Silicon: 20
# Wallmount Substation
- type: entity
layers:
- state: icon
- type: HandTeleporter
+ - type: Tag
+ tags:
+ - HighRiskItem
- Write
- Crayon
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: UserInterface
interfaces:
damage:
types:
Blunt: 0
+ - type: PhysicalComposition
+ materialComposition:
+ Cloth: 100
+ - type: StaticPrice
+ price: 5
- type: entity
parent: BasePlushie
- type: Sprite
state: narplush
-
- type: entity
parent: BasePlushie
id: PlushieCarp
- type: entity
parent: BaseItem
+ id: BaseFigurine
+ name: figurine
+ description: A small miniature.
+ abstract: true
+ components:
+ - type: Sprite
+ sprite: Objects/Fun/toys.rsi
+ netsync: false
+ - type: PhysicalComposition
+ materialComposition:
+ Plastic: 100
+ - type: StaticPrice
+ price: 10
+
+- type: entity
+ parent: BaseFigurine
id: ToyAi
name: AI toy
description: A scaled-down toy AI core.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: AI
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyNuke
name: nuke toy
description: A plastic model of a Nuclear Fission Explosive. No uranium included... probably.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: nuketoy
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyAssistant # TODO rename but needs map changes
name: passenger toy
description: Grey tide world wide!
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: doll
- type: Item
sprite: Objects/Fun/toys.rsi
heldPrefix: doll
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyGriffin
name: griffin toy
description: An action figure modeled after 'The Griffin', criminal mastermind.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: griffinprize
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyHonk
name: H.O.N.K. toy
description: Mini-Mecha action figure! 'Mecha No. 6/12' is written on the back.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: honkprize
- type: entity
path: /Audio/Items/Toys/ian.ogg
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyMarauder
name: marauder toy
description: Mini-Mecha action figure! 'Mecha No. 7/12' is written on the back.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: marauderprize
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyMauler
name: mauler toy
description: Mini-Mecha action figure! 'Mecha No. 9/12' is written on the back.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: maulerprize
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyGygax
name: gygax toy
description: Mini-Mecha action figure! 'Mecha No. 4/12' is written on the back.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: gygaxtoy
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyOdysseus
name: odysseus toy
description: Mini-Mecha action figure! 'Mecha No. 10/12' is written on the back.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: odysseusprize
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyOwlman
name: owl toy
description: An action figure modeled after 'The Owl', defender of justice.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: owlprize
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyDeathRipley
name: deathripley toy
description: Mini-Mecha action figure! 'Mecha No. 3/12' is written on the back.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: deathripleytoy
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyPhazon
name: phazon toy
description: Mini-Mecha action figure! 'Mecha No. 11/12' is written on the back.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: phazonprize
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyFireRipley
name: fire ripley
description: Mini-Mecha action figure! 'Mecha No. 2/12' is written on the back.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: fireripleytoy
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyReticence
name: reticence toy
description: Mini-Mecha action figure! 'Mecha No. 12/12' is written on the back.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: reticenceprize
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyRipley
name: ripley toy
description: Mini-Mecha action figure! 'Mecha No. 1/12' is written on the back.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: ripleytoy
-
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToySeraph
name: seraph toy
description: Mini-Mecha action figure! 'Mecha No. 8/12' is written on the back.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: seraphprize
-
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToyDurand
name: durand toy
description: Mini-Mecha action figure! 'Mecha No. 5/12' is written on the back.
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: durandprize
### Help i'm sorting these and my previous self let this message here to taunt me aaaaa
- type: entity
- parent: BaseItem
+ parent: BaseFigurine
id: ToySkeleton
name: skeleton toy
description: Spooked ya!
components:
- type: Sprite
- sprite: Objects/Fun/toys.rsi
state: skeletonprize
## Toyweapons
available:
- enum.DamageStateVisualLayers.Base:
base: Sixteen
- - type: StaticPrice
- price: 3
- type: entity
parent: BaseItem
- type: Material
materials:
Glass: 100
- - type: StackPrice
- price: 5
- type: Stack
stackType: Glass
- type: Sprite
- type: Tag
tags:
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: Damageable
damageContainer: Inorganic
node: boxcardboard
containers:
- entity_storage
+ - type: PhysicalComposition
+ materialComposition:
+ Cardboard: 100
+ - type: StaticPrice
+ price: 10
- type: Tag
tags:
- Trash
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 50
- type: SpaceGarbage
- type: WarpPoint
follow: true
location: nuke disk
+ - type: Tag
+ tags:
+ - HighRiskItem
- type: entity
name: nuclear authentication disk
components:
- type: Item
size: 2
- - type: Recyclable
- type: Tag
tags:
- Trash
+ - type: PhysicalComposition
+ materialComposition:
+ Plastic: 25
- type: entity
name: broken zipties
- type: Sprite
sprite: Objects/Misc/cablecuffs.rsi
state: cuff-broken
- color: forestgreen
\ No newline at end of file
+ color: forestgreen
heldPrefix: gold
- type: PresetIdCard
job: Captain
+ - type: Tag
+ tags:
+ - WhitelistChameleon
+ - HighRiskItem
- type: entity
parent: IDCardStandard
- state: idzookeeper
- type: PresetIdCard
job: Zookeeper
-
+
- type: entity
parent: IDCardStandard
id: DetectiveIDCard
- state: idcentcom
- type: Item
heldPrefix: gold
-
+
- type: entity
parent: IDCardStandard
- Trash
- type: Appearance
- type: PaperVisuals
- - type: Recyclable
- type: entity
name: office paper
sprite: Objects/Misc/bureaucracy.rsi
heldPrefix: pen
size: 2
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 25
- type: entity
name: Cybersun pen
- type: Tag
tags:
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: entity
- type: Tag
tags:
- Trash
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 25
- type: SpaceGarbage
- type: entity
- !type:SpawnEntitiesBehavior
spawn:
SheetSteel:
- min: 5
- max: 5
+ min: 2
+ max: 2
SheetGlass:
- min: 5
- max: 5
+ min: 2
+ max: 2
- type: StaticPrice
price: 50
delay: 0.5
- type: StaticPrice
price: 750
+ - type: Tag
+ tags:
+ - HighRiskItem
- type: entity
name: gorlex hypospray
- type: Tag
tags:
- Trash
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Plastic: 50
- type: SpaceGarbage
- type: StaticPrice
price: 75 # These are limited supply items.
- DroneUsable
- type: StaticPrice
price: 80
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 400
+ Glass: 100
tags:
- Bottle
- Trash
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Glass: 25
- type: SpaceGarbage
- type: Sprite
sprite: Objects/Specific/Chemistry/bottle.rsi
- type: Tag
tags:
- Bucket
+ - type: PhysicalComposition
+ materialComposition:
+ Plastic: 50
tags:
- Flare
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: ExpendableLight
spentName: expendable-light-spent-flare-name
damage:
types:
Blunt: 10
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 400
+ - type: StaticPrice
+ price: 20
- type: entity
parent: GasTankBase
damage:
types:
Blunt: 5
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 100
- type: entity
parent: EmergencyOxygenTank
id: GlowstickBase
description: Useful for raves and emergencies.
components:
- - type: Recyclable
- type: SpaceGarbage
- type: ExpendableLight
spentName: expendable-light-spent-green-glowstick-name
- type: Item
sprite: Objects/Tanks/Jetpacks/captain.rsi
size: 30
+ - type: Tag
+ tags:
+ - HighRiskItem
# Filled captain
- type: entity
sprite: Objects/Tanks/Jetpacks/void.rsi
slots:
- Back
- - suitStorage
+ - suitStorage
# Filled void
- type: entity
tags:
- Matchstick
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: Sprite
netsync: false
- type: Tag
tags:
- Trash
- - type: Recyclable
- type: SpaceGarbage
- type: Item
sprite: Objects/Tools/wirecutters.rsi
- type: LatticeCutting
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 100
- type: StaticPrice
price: 40
available:
- enum.DamageStateVisualLayers.Base:
screwdriver: Rainbow
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 100
- type: StaticPrice
price: 40
- Anchoring
useSound:
path: /Audio/Items/ratchet.ogg
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 100
- type: StaticPrice
price: 40
useSound:
path: /Audio/Items/crowbar.ogg
- type: TilePrying
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 100
- type: StaticPrice
price: 40
- type: Tag
tags:
- DroneUsable
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 100
+ Plastic: 100
- type: StaticPrice
price: 60
path: /Audio/Items/drill_use.ogg
changeSound:
path: /Audio/Items/change_drill.ogg
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 300
+ Plastic: 100
- type: StaticPrice
price: 100
quickEquip: false
slots:
- Belt
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 600
+ Plastic: 100
- type: StaticPrice
price: 100
- type: Item
sprite: Objects/Tools/rcd.rsi
heldPrefix: ammo
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 100
+ Plastic: 100
- type: StaticPrice
price: 60
Blunt: 10
- type: Item
sprite: Objects/Tools/shovel.rsi
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 100
+ Wood: 50
+ - type: StaticPrice
+ price: 25
- type: entity
name: omnitool
color: orange
- type: Appearance
- type: RequiresEyeProtection
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 200
- type: StaticPrice
price: 40
- type: IgnitionSource
- Cartridge
- type: Item
size: 1
- - type: Recyclable
- type: SpaceGarbage
- type: Tag
tags:
- BulletFoam
+ - Trash
- type: Ammo
- type: Sprite
sprite: Objects/Fun/toys.rsi
layers:
- state: foamdart
- - type: Recyclable
\ No newline at end of file
steps: 5
zeroVisible: true
- type: Appearance
+ - type: Tag
+ tags:
+ - HighRiskItem
- type: StaticPrice
price: 750
- DawInstrumentMachineCircuitboard
- CloningConsoleComputerCircuitboard
- StasisBedMachineCircuitboard
+ - MaterialReclaimerMachineCircuitboard
- OreProcessorMachineCircuitboard
- RipleyCentralElectronics
- RipleyPeripheralsElectronics
--- /dev/null
+- type: entity
+ parent: [ BaseMachinePowered, ConstructibleMachine ]
+ id: MaterialReclaimer
+ name: material reclaimer
+ description: Cannot reclaim immaterial things, like motivation.
+ components:
+ - type: Sprite
+ sprite: Structures/Machines/material_reclaimer.rsi
+ snapCardinals: true
+ netsync: false
+ layers:
+ - state: icon
+ map: ["enum.LatheVisualLayers.IsRunning"]
+ - state: gear-active
+ map: ["enum.DamageStateVisualLayers.Base"]
+ - state: unlit
+ shader: unshaded
+ map: ["enum.PowerDeviceVisualLayers.Powered"]
+ - state: fill-6
+ map: ["enum.SolutionContainerLayers.Fill"]
+ visible: false
+ - state: panel
+ map: ["enum.WiresVisualLayers.MaintenancePanel"]
+ - type: Appearance
+ - type: SolutionContainerVisuals
+ maxFillLevels: 6
+ fillBaseName: fill-
+ - type: WiresVisuals
+ - type: GenericVisualizer
+ visuals:
+ enum.PowerDeviceVisuals.Powered:
+ enum.DamageStateVisualLayers.Base:
+ True: { state: gear-active}
+ False: { state: gear-idle }
+ enum.PowerDeviceVisualLayers.Powered:
+ True: { visible: true }
+ False: { visible: false }
+ - type: LitOnPowered
+ - type: PointLight
+ radius: 1.5
+ energy: 1.6
+ enabled: false
+ color: "#da824d"
+ mask: /Textures/Effects/LightMasks/cone.png
+ autoRot: true
+ offset: "0, 0.4"
+ castShadows: false
+ - type: PowerSwitch
+ - type: Destructible
+ thresholds:
+ - trigger:
+ !type:DamageTrigger
+ damage: 100
+ behaviors:
+ - !type:ChangeConstructionNodeBehavior
+ node: machineFrame
+ - !type:DoActsBehavior
+ acts: ["Destruction"]
+ - type: Machine
+ board: MaterialReclaimerMachineCircuitboard
+ - type: Wires
+ BoardName: "reclaimer"
+ LayoutId: Reclaimer
+ - type: MaterialReclaimer
+ whitelist:
+ components:
+ - PhysicalComposition
+ - SpaceGarbage
+ tags:
+ - Trash
+ - Recyclable
+ blacklist:
+ components:
+ - Material
+ - PDA
+ - IdCard
+ tags:
+ - HighRiskItem
+ sound:
+ path: /Audio/Ambience/Objects/crushing.ogg
+ params:
+ volume: 5
+ maxdistance: 5
+ loop: true
+ - type: MaterialStorage
+ insertOnInteract: false
+ - type: ContainerContainer
+ containers:
+ active-material-reclaimer-container: !type:Container
+ machine_board: !type:Container
+ machine_parts: !type:Container
+ - type: SolutionContainerManager
+ solutions:
+ output:
+ maxVol: 100
+ - type: DrainableSolution
+ solution: output
+ - type: ExaminableSolution
+ solution: output
+ - type: StaticPrice
+ price: 500
sound:
# TODO: https://freesound.org/people/derjuli/sounds/448133/ CC-NC-
path: /Audio/Ambience/Objects/circular_saw.ogg
- - type: Physics
- type: Fixtures
fixtures:
- shape:
!type:PhysShapeAabb
- bounds: "-0.2,-0.2,0.2,0.2"
+ bounds: "-0.15,-0.15,0.15,0.15"
id: brrt
hard: false
layer:
layers:
- state: grinder-o0
map: ["enum.RecyclerVisualLayers.Main"]
+ - state: grinder-o0bld
+ map: ["enum.RecyclerVisualLayers.Bloody"]
+ visible: false
- type: Appearance
+ - type: GenericVisualizer
visuals:
- - type: RecyclerVisualizer
- state_on: grinder-o1
- state_off: grinder-o0
- - type: Recycler
+ enum.RecyclerVisuals.Bloody:
+ enum.RecyclerVisualLayers.Main:
+ True: { visible: false }
+ False: { visible: true }
+ enum.RecyclerVisualLayers.Bloody:
+ True: { visible: true }
+ False: { visible: false }
+ enum.ConveyorVisuals.State:
+ enum.RecyclerVisualLayers.Main:
+ Forward: { state: grinder-o1 }
+ Reverse: { state: grinder-o1 }
+ Off: { state: grinder-o0 }
+ enum.RecyclerVisualLayers.Bloody:
+ Forward: { state: grinder-o1bld }
+ Reverse: { state: grinder-o1bld }
+ Off: { state: grinder-o0bld }
+ - type: CollideMaterialReclaimer
+ - type: MaterialReclaimer
+ enabled: false
+ efficiency: 0.25
+ scaleProcessSpeed: false #instant!
+ minimumProcessDuration: 0
+ whitelist:
+ components:
+ - PhysicalComposition
+ - SpaceGarbage
+ tags:
+ - Trash
+ - Recyclable
+ blacklist:
+ components:
+ - Material
+ - PDA
+ - IdCard
+ - HumanoidAppearance
+ tags:
+ - HighRiskItem
+ sound:
+ path: /Audio/Effects/saw.ogg
+ params:
+ volume: -3
+ cutOffSound: false
+ - type: SolutionContainerManager
+ solutions:
+ output:
+ maxVol: 0 #exists only for the overflow stuff on material reclaimer
+ - type: MaterialStorage
- type: Conveyor
- type: Rotatable
\ No newline at end of file
- MachineMask
layer:
- MachineLayer
- - type: Recyclable
+ - type: PhysicalComposition
+ materialComposition:
+ Steel: 500
- type: StaticPrice
price: 60
graph: WindowDirectional
node: windowDirectional
- type: StaticPrice
- price: 5
+ price: 10
- type: entity
id: WindowTintedDirectional
state: tinted_window
- type: Occluder
boundingBox: "-0.5,-0.5,0.5,-0.3"
- - type: StaticPrice
- price: 5
- type: entity
id: WindowFrostedDirectional
- type: Icon
sprite: Structures/Windows/directional.rsi
state: frosted_window
- - type: StaticPrice
- price: 5
name: materials-cardboard
icon: { sprite: /Textures/Objects/Materials/materials.rsi, state: cardboard }
color: "#70736c"
- price: 0.05
+ price: 0.005
- type: material
id: Cloth
Glass: 900
Gold: 100
+- type: latheRecipe
+ id: MaterialReclaimerMachineCircuitboard
+ result: MaterialReclaimerMachineCircuitboard
+ completetime: 4
+ materials:
+ Steel: 100
+ Glass: 900
+
- type: latheRecipe
id: OreProcessorMachineCircuitboard
result: OreProcessorMachineCircuitboard
result: Bucket
completetime: 2
materials:
- Steel: 100
+ Plastic: 100
- type: latheRecipe
id: WetFloorSign
- type: Tag
id: HidesHair # for headwear.
+- type: Tag
+ id: HighRiskItem
+
- type: Tag
id: Hoe
--- /dev/null
+{
+ "version": 1,
+ "license": "CC0-1.0",
+ "copyright": "Created by EmoGarbage404 (github) for Space Station 14",
+ "size": {
+ "x": 32,
+ "y": 32
+ },
+ "states": [
+ {
+ "name": "fill-1"
+ },
+ {
+ "name": "fill-2"
+ },
+ {
+ "name": "fill-3"
+ },
+ {
+ "name": "fill-4"
+ },
+ {
+ "name": "fill-5"
+ },
+ {
+ "name": "fill-6"
+ },
+ {
+ "name": "gear-active",
+ "delays": [
+ [
+ 0.25,
+ 0.25,
+ 0.25
+ ]
+ ]
+ },
+ {
+ "name": "gear-idle"
+ },
+ {
+ "name": "icon"
+ },
+ {
+ "name": "panel"
+ },
+ {
+ "name": "unlit",
+ "delays": [
+ [
+ 0.1,
+ 1.0
+ ]
+ ]
+ }
+ ]
+}
projects / space-station-14.git / commitdiff
