From 306bd79503c50f423a4b7a913b699420aff96fc2 Mon Sep 17 00:00:00 2001
From: Kill_Me_I_Noobs <118206719+Vonsant@users.noreply.github.com>
Date: Fri, 6 Dec 2024 17:43:52 +0300
Subject: [PATCH] Port TapeRecorder (#129)
---
.../TapeRecorder/TapeRecorderSystem.cs | 24 +
.../Ui/TapeRecorderBoundUserInterface.cs | 64 +++
.../TapeRecorder/Ui/TapeRecorderWindow.xaml | 23 +
.../Ui/TapeRecorderWindow.xaml.cs | 133 ++++++
.../TapeRecorder/TapeRecorderSystem.cs | 132 ++++++
.../Components/ActiveTapeRecorderComponent.cs | 9 +
.../Components/TapeCassetteComponent.cs | 72 +++
.../Components/TapeRecorderComponent.cs | 124 +++++
.../TapeRecorder/Events/TapeRecorderEvents.cs | 50 +++
.../TapeRecorder/SharedTapeRecorderSystem.cs | 422 ++++++++++++++++++
.../TapeCassetteRecordedMessage.cs | 51 +++
.../Audio/Items/Taperecorder/attributions.yml | 17 +
.../Items/Taperecorder/taperecorder_play.ogg | Bin 0 -> 11670 bytes
.../Taperecorder/taperecorder_rewind.ogg | Bin 0 -> 13159 bytes
.../Items/Taperecorder/taperecorder_stop.ogg | Bin 0 -> 7395 bytes
.../en-US/taperecorder/taperecorder.ftl | 26 ++
.../catalog/fills/boxes/security.ftl | 2 +
.../objects/devices/tape_recorder.ftl | 4 +
.../entities/objects/misc/paper.ftl | 1 +
.../ru-RU/taperecorder/taperecorder.ftl | 26 ++
.../Catalog/Fills/Boxes/security.yml | 23 +
.../Catalog/Fills/Lockers/security.yml | 1 +
.../Objects/Devices/tape_recorder.yml | 88 ++++
.../Entities/Objects/Misc/paper.yml | 6 +
.../Entities/Structures/Machines/lathe.yml | 2 +
Resources/Prototypes/Recipes/Lathes/misc.yml | 18 +
.../Roles/Jobs/Wildcards/reporter.yml | 8 +-
.../Devices/cassette_tapes.rsi/meta.json | 17 +
.../cassette_tapes.rsi/tape_greyscale.png | Bin 0 -> 423 bytes
.../cassette_tapes.rsi/tape_ribbonoverlay.png | Bin 0 -> 449 bytes
.../Devices/tape_recorder.rsi/inhand-left.png | Bin 0 -> 491 bytes
.../tape_recorder.rsi/inhand-right.png | Bin 0 -> 487 bytes
.../Devices/tape_recorder.rsi/meta.json | 58 +++
.../tape_recorder.rsi/taperecorder_empty.png | Bin 0 -> 581 bytes
.../tape_recorder.rsi/taperecorder_idle.png | Bin 0 -> 597 bytes
.../taperecorder_playing.png | Bin 0 -> 955 bytes
.../taperecorder_recording.png | Bin 0 -> 934 bytes
.../taperecorder_rewinding.png | Bin 0 -> 887 bytes
.../Objects/Storage/boxes.rsi/meta.json | 3 +
.../Objects/Storage/boxes.rsi/recorder.png | Bin 0 -> 189 bytes
40 files changed, 1401 insertions(+), 3 deletions(-)
create mode 100644 Content.Client/TapeRecorder/TapeRecorderSystem.cs
create mode 100644 Content.Client/TapeRecorder/Ui/TapeRecorderBoundUserInterface.cs
create mode 100644 Content.Client/TapeRecorder/Ui/TapeRecorderWindow.xaml
create mode 100644 Content.Client/TapeRecorder/Ui/TapeRecorderWindow.xaml.cs
create mode 100644 Content.Server/TapeRecorder/TapeRecorderSystem.cs
create mode 100644 Content.Shared/TapeRecorder/Components/ActiveTapeRecorderComponent.cs
create mode 100644 Content.Shared/TapeRecorder/Components/TapeCassetteComponent.cs
create mode 100644 Content.Shared/TapeRecorder/Components/TapeRecorderComponent.cs
create mode 100644 Content.Shared/TapeRecorder/Events/TapeRecorderEvents.cs
create mode 100644 Content.Shared/TapeRecorder/SharedTapeRecorderSystem.cs
create mode 100644 Content.Shared/TapeRecorder/TapeCassetteRecordedMessage.cs
create mode 100644 Resources/Audio/Items/Taperecorder/attributions.yml
create mode 100644 Resources/Audio/Items/Taperecorder/taperecorder_play.ogg
create mode 100644 Resources/Audio/Items/Taperecorder/taperecorder_rewind.ogg
create mode 100644 Resources/Audio/Items/Taperecorder/taperecorder_stop.ogg
create mode 100644 Resources/Locale/en-US/taperecorder/taperecorder.ftl
create mode 100644 Resources/Locale/ru-RU/ss14-ru/prototypes/entities/objects/devices/tape_recorder.ftl
create mode 100644 Resources/Locale/ru-RU/taperecorder/taperecorder.ftl
create mode 100644 Resources/Prototypes/Entities/Objects/Devices/tape_recorder.yml
create mode 100644 Resources/Textures/Objects/Devices/cassette_tapes.rsi/meta.json
create mode 100644 Resources/Textures/Objects/Devices/cassette_tapes.rsi/tape_greyscale.png
create mode 100644 Resources/Textures/Objects/Devices/cassette_tapes.rsi/tape_ribbonoverlay.png
create mode 100644 Resources/Textures/Objects/Devices/tape_recorder.rsi/inhand-left.png
create mode 100644 Resources/Textures/Objects/Devices/tape_recorder.rsi/inhand-right.png
create mode 100644 Resources/Textures/Objects/Devices/tape_recorder.rsi/meta.json
create mode 100644 Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_empty.png
create mode 100644 Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_idle.png
create mode 100644 Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_playing.png
create mode 100644 Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_recording.png
create mode 100644 Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_rewinding.png
create mode 100644 Resources/Textures/Objects/Storage/boxes.rsi/recorder.png
diff --git a/Content.Client/TapeRecorder/TapeRecorderSystem.cs b/Content.Client/TapeRecorder/TapeRecorderSystem.cs
new file mode 100644
index 00000000000..c228ea356c2
--- /dev/null
+++ b/Content.Client/TapeRecorder/TapeRecorderSystem.cs
@@ -0,0 +1,24 @@
+using Content.Shared.TapeRecorder;
+
+namespace Content.Client.TapeRecorder;
+
+///
+/// Required for client side prediction stuff
+///
+public sealed class TapeRecorderSystem : SharedTapeRecorderSystem
+{
+ private TimeSpan _lastTickTime = TimeSpan.Zero;
+
+ public override void Update(float frameTime)
+ {
+ if (!Timing.IsFirstTimePredicted)
+ return;
+
+ //We need to know the exact time period that has passed since the last update to ensure the tape position is sync'd with the server
+ //Since the client can skip frames when lagging, we cannot use frameTime
+ var realTime = (float) (Timing.CurTime - _lastTickTime).TotalSeconds;
+ _lastTickTime = Timing.CurTime;
+
+ base.Update(realTime);
+ }
+}
\ No newline at end of file
diff --git a/Content.Client/TapeRecorder/Ui/TapeRecorderBoundUserInterface.cs b/Content.Client/TapeRecorder/Ui/TapeRecorderBoundUserInterface.cs
new file mode 100644
index 00000000000..33df6267480
--- /dev/null
+++ b/Content.Client/TapeRecorder/Ui/TapeRecorderBoundUserInterface.cs
@@ -0,0 +1,64 @@
+using Content.Shared.TapeRecorder.Components;
+using Content.Shared.TapeRecorder.Events;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+
+namespace Content.Client.TapeRecorder.Ui;
+
+public sealed class TapeRecorderBoundUserInterface(EntityUid owner, Enum uiKey) : BoundUserInterface(owner, uiKey)
+{
+ [Dependency] private readonly IEntityManager _entMan = default!;
+
+ [ViewVariables]
+ private TapeRecorderWindow? _window;
+
+ [ViewVariables]
+ private TimeSpan _printCooldown;
+
+ protected override void Open()
+ {
+ base.Open();
+
+ _window = new(_entMan, Owner);
+ _window.OnClose += Close;
+ _window.OnModeChanged += ChangeMode;
+ _window.OnPrintTranscript += PrintTranscript;
+ _window.OpenCentered();
+ }
+
+ private void ChangeMode(TapeRecorderMode mode)
+ {
+ SendMessage(new ChangeModeTapeRecorderMessage(mode));
+ }
+
+ private void PrintTranscript()
+ {
+ SendMessage(new PrintTapeRecorderMessage());
+
+ _window?.UpdatePrint(true);
+
+ Timer.Spawn(_printCooldown, () =>
+ {
+ _window?.UpdatePrint(false);
+ });
+ }
+
+ protected override void UpdateState(BoundUserInterfaceState state)
+ {
+ base.UpdateState(state);
+
+ if (state is not TapeRecorderState cast)
+ return;
+
+ _printCooldown = cast.PrintCooldown;
+
+ _window?.UpdateState(cast);
+ }
+
+ protected override void Dispose(bool disposing)
+ {
+ base.Dispose(disposing);
+ if (disposing)
+ _window?.Dispose();
+ }
+}
diff --git a/Content.Client/TapeRecorder/Ui/TapeRecorderWindow.xaml b/Content.Client/TapeRecorder/Ui/TapeRecorderWindow.xaml
new file mode 100644
index 00000000000..0e22a7815fe
--- /dev/null
+++ b/Content.Client/TapeRecorder/Ui/TapeRecorderWindow.xaml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Content.Client/TapeRecorder/Ui/TapeRecorderWindow.xaml.cs b/Content.Client/TapeRecorder/Ui/TapeRecorderWindow.xaml.cs
new file mode 100644
index 00000000000..e387261d58b
--- /dev/null
+++ b/Content.Client/TapeRecorder/Ui/TapeRecorderWindow.xaml.cs
@@ -0,0 +1,133 @@
+using Content.Client.UserInterface.Controls;
+using Content.Shared.Shuttles.Components;
+using Content.Shared.TapeRecorder.Components;
+using Content.Shared.TapeRecorder.Events;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Timing;
+
+namespace Content.Client.TapeRecorder.Ui;
+
+[GenerateTypedNameReferences]
+public sealed partial class TapeRecorderWindow : FancyWindow
+{
+ private IEntityManager _entMan;
+
+ private EntityUid _owner;
+ private bool _onCooldown;
+ private bool _hasCasette;
+ private TapeRecorderMode _mode = TapeRecorderMode.Stopped;
+
+ private RadioOptions _options = default!;
+ private bool _updating;
+
+ public Action? OnModeChanged;
+ public Action? OnPrintTranscript;
+
+ public TapeRecorderWindow(IEntityManager entMan, EntityUid owner)
+ {
+ RobustXamlLoader.Load(this);
+ IoCManager.InjectDependencies(this);
+
+ _entMan = entMan;
+
+ _owner = owner;
+
+ _options = new RadioOptions(RadioOptionsLayout.Horizontal);
+ Buttons.AddChild(_options);
+ _options.FirstButtonStyle = "OpenRight";
+ _options.LastButtonStyle = "OpenLeft";
+ _options.ButtonStyle = "OpenBoth";
+ foreach (var mode in Enum.GetValues())
+ {
+ var name = mode.ToString().ToLower();
+ _options.AddItem(Loc.GetString($"tape-recorder-menu-{name}-button"), mode);
+ }
+
+ _options.OnItemSelected += args =>
+ {
+ if (_updating) // don't tell server to change mode to the mode it told us
+ return;
+ args.Button.Select(args.Id);
+ var mode = args.Button.SelectedValue;
+ OnModeChanged?.Invoke(mode);
+ };
+
+ PrintButton.OnPressed += _ => OnPrintTranscript?.Invoke();
+
+ SetEnabled(TapeRecorderMode.Recording, false);
+ SetEnabled(TapeRecorderMode.Playing, false);
+ SetEnabled(TapeRecorderMode.Rewinding, false);
+ }
+
+ private void SetSlider(float maxTime, float currentTime)
+ {
+ PlaybackSlider.Disabled = true;
+ PlaybackSlider.MaxValue = maxTime;
+ PlaybackSlider.Value = currentTime;
+ }
+
+ public void UpdatePrint(bool disabled)
+ {
+ PrintButton.Disabled = disabled;
+ _onCooldown = disabled;
+ }
+
+ public void UpdateState(TapeRecorderState state)
+ {
+ if (!_entMan.TryGetComponent(_owner, out var comp))
+ return;
+
+ _mode = comp.Mode; // TODO: update UI on handling state instead of adding UpdateUI to everything
+ _hasCasette = state.HasCasette;
+
+ _updating = true;
+
+ CassetteLabel.Text = _hasCasette
+ ? Loc.GetString("tape-recorder-menu-cassette-label", ("cassetteName", state.CassetteName))
+ : Loc.GetString("tape-recorder-menu-no-cassette-label");
+
+ // Select the currently used mode
+ _options.SelectByValue(_mode);
+
+ // When tape is ejected or a button can't be used, disable it
+ // Server will change to paused once a tape is inactive
+ var tapeLeft = state.CurrentTime < state.MaxTime;
+ SetEnabled(TapeRecorderMode.Recording, tapeLeft);
+ SetEnabled(TapeRecorderMode.Playing, tapeLeft);
+ SetEnabled(TapeRecorderMode.Rewinding, state.CurrentTime > float.Epsilon);
+
+ if (state.HasCasette)
+ SetSlider(state.MaxTime, state.CurrentTime);
+
+ _updating = false;
+ }
+
+ private void SetEnabled(TapeRecorderMode mode, bool condition)
+ {
+ _options.SetItemDisabled((int) mode, !(_hasCasette && condition));
+ }
+
+ protected override void FrameUpdate(FrameEventArgs args)
+ {
+ base.FrameUpdate(args);
+
+ if (!_entMan.HasComponent(_owner))
+ return;
+
+ if (!_entMan.TryGetComponent(_owner, out var comp))
+ return;
+
+ if (_mode != comp.Mode)
+ {
+ _mode = comp.Mode;
+ _options.SelectByValue(_mode);
+ }
+
+ var speed = _mode == TapeRecorderMode.Rewinding
+ ? -comp.RewindSpeed
+ : 1f;
+ PlaybackSlider.Value += args.DeltaSeconds * speed;
+ }
+}
\ No newline at end of file
diff --git a/Content.Server/TapeRecorder/TapeRecorderSystem.cs b/Content.Server/TapeRecorder/TapeRecorderSystem.cs
new file mode 100644
index 00000000000..f6e8b7ee77d
--- /dev/null
+++ b/Content.Server/TapeRecorder/TapeRecorderSystem.cs
@@ -0,0 +1,132 @@
+using Content.Server.Chat.Systems;
+using Content.Server.Hands.Systems;
+using Content.Server.Speech;
+using Content.Server.Speech.Components;
+using Content.Shared.Chat;
+using Content.Shared.Paper;
+using Content.Shared.Speech;
+using Content.Shared.TapeRecorder;
+using Content.Shared.TapeRecorder.Components;
+using Content.Shared.TapeRecorder.Events;
+using Robust.Server.Audio;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+using System.Text;
+
+namespace Content.Server.TapeRecorder;
+
+public sealed class TapeRecorderSystem : SharedTapeRecorderSystem
+{
+ [Dependency] private readonly ChatSystem _chat = default!;
+ [Dependency] private readonly HandsSystem _hands = default!;
+ [Dependency] private readonly IPrototypeManager _proto = default!;
+ [Dependency] private readonly PaperSystem _paper = default!;
+
+ public override void Initialize()
+ {
+ base.Initialize();
+
+ SubscribeLocalEvent(OnListen);
+ SubscribeLocalEvent(OnPrintMessage);
+ }
+
+ ///
+ /// Given a time range, play all messages on a tape within said range, [start, end).
+ /// Split into this system as shared does not have ChatSystem access
+ ///
+ protected override void ReplayMessagesInSegment(Entity ent, TapeCassetteComponent tape, float segmentStart, float segmentEnd)
+ {
+ var voice = EnsureComp(ent);
+ var speech = EnsureComp(ent);
+
+ foreach (var message in tape.RecordedData)
+ {
+ if (message.Timestamp < tape.CurrentPosition || message.Timestamp >= segmentEnd)
+ continue;
+
+ //Change the voice to match the speaker
+ voice.NameOverride = message.Name ?? ent.Comp.DefaultName;
+ // TODO: mimic the exact string chosen when the message was recorded
+ var verb = message.Verb ?? SharedChatSystem.DefaultSpeechVerb;
+ speech.SpeechVerb = _proto.Index(verb);
+ //Play the message
+ _chat.TrySendInGameICMessage(ent, message.Message, InGameICChatType.Speak, false);
+ }
+ }
+
+ ///
+ /// Whenever someone speaks within listening range, record it to tape
+ ///
+ private void OnListen(Entity ent, ref ListenEvent args)
+ {
+ // mode should never be set when it isn't active but whatever
+ if (ent.Comp.Mode != TapeRecorderMode.Recording || !HasComp(ent))
+ return;
+
+ // No feedback loops
+ if (args.Source == ent.Owner)
+ return;
+
+ if (!TryGetTapeCassette(ent, out var cassette))
+ return;
+
+ // TODO: Handle "Someone" when whispering from far away, needs chat refactor
+
+ //Handle someone using a voice changer
+ var nameEv = new TransformSpeakerNameEvent(args.Source, Name(args.Source));
+ RaiseLocalEvent(args.Source, nameEv);
+
+ //Add a new entry to the tape
+ var verb = _chat.GetSpeechVerb(args.Source, args.Message);
+ var name = nameEv.VoiceName;
+ cassette.Comp.Buffer.Add(new TapeCassetteRecordedMessage(cassette.Comp.CurrentPosition, name, verb, args.Message));
+ }
+
+ private void OnPrintMessage(Entity ent, ref PrintTapeRecorderMessage args)
+ {
+ var (uid, comp) = ent;
+
+ if (comp.CooldownEndTime > Timing.CurTime)
+ return;
+
+ if (!TryGetTapeCassette(ent, out var cassette))
+ return;
+
+ var text = new StringBuilder();
+ var paper = Spawn(comp.PaperPrototype, Transform(ent).Coordinates);
+
+ // Sorting list by time for overwrite order
+ // TODO: why is this needed? why wouldn't it be stored in order
+ var data = cassette.Comp.RecordedData;
+ data.Sort((x,y) => x.Timestamp.CompareTo(y.Timestamp));
+
+ // Looking if player's entity exists to give paper in its hand
+ var player = args.Actor;
+ if (Exists(player))
+ _hands.PickupOrDrop(player, paper, checkActionBlocker: false);
+
+ if (!TryComp(paper, out var paperComp))
+ return;
+
+ Audio.PlayPvs(comp.PrintSound, ent);
+
+ text.AppendLine(Loc.GetString("tape-recorder-print-start-text"));
+ text.AppendLine();
+ foreach (var message in cassette.Comp.RecordedData)
+ {
+ var name = message.Name ?? ent.Comp.DefaultName;
+ var time = TimeSpan.FromSeconds((double) message.Timestamp);
+
+ text.AppendLine(Loc.GetString("tape-recorder-print-message-text",
+ ("time", time.ToString(@"hh\:mm\:ss")),
+ ("source", name),
+ ("message", message.Message)));
+ }
+ text.AppendLine();
+ text.Append(Loc.GetString("tape-recorder-print-end-text"));
+
+ _paper.SetContent((paper, paperComp), text.ToString());
+
+ comp.CooldownEndTime = Timing.CurTime + comp.PrintCooldown;
+ }
+}
diff --git a/Content.Shared/TapeRecorder/Components/ActiveTapeRecorderComponent.cs b/Content.Shared/TapeRecorder/Components/ActiveTapeRecorderComponent.cs
new file mode 100644
index 00000000000..24f0f9d9249
--- /dev/null
+++ b/Content.Shared/TapeRecorder/Components/ActiveTapeRecorderComponent.cs
@@ -0,0 +1,9 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.TapeRecorder.Components;
+
+///
+/// Added to tape records that are updating, winding or rewinding the tape.
+///
+[RegisterComponent, NetworkedComponent]
+public sealed partial class ActiveTapeRecorderComponent : Component;
\ No newline at end of file
diff --git a/Content.Shared/TapeRecorder/Components/TapeCassetteComponent.cs b/Content.Shared/TapeRecorder/Components/TapeCassetteComponent.cs
new file mode 100644
index 00000000000..9ff69db9026
--- /dev/null
+++ b/Content.Shared/TapeRecorder/Components/TapeCassetteComponent.cs
@@ -0,0 +1,72 @@
+using Content.Shared.Whitelist;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.TapeRecorder.Components;
+
+// TODO: add things client needs for ui to networked state
+[RegisterComponent, NetworkedComponent, Access(typeof(SharedTapeRecorderSystem))]
+[AutoGenerateComponentState]
+public sealed partial class TapeCassetteComponent : Component
+{
+ ///
+ /// A list of all recorded voice, containing timestamp, name and spoken words
+ ///
+ [DataField]
+ public List RecordedData = new();
+
+ ///
+ /// The current position within the tape we are at, in seconds
+ /// Only dirtied when the tape recorder is stopped
+ ///
+ [DataField, AutoNetworkedField]
+ public float CurrentPosition = 0f;
+
+ ///
+ /// Maximum capacity of this tape
+ ///
+ [DataField]
+ public TimeSpan MaxCapacity = TimeSpan.FromSeconds(120);
+
+ ///
+ /// How long to spool the tape after it was damaged
+ ///
+ [DataField]
+ public TimeSpan RepairDelay = TimeSpan.FromSeconds(3);
+
+ ///
+ /// When an entry is damaged, the chance of each character being corrupted.
+ ///
+ [DataField]
+ public float CorruptionChance = 0.25f;
+
+ //Locale references
+ [DataField]
+ public LocId TextUnintelligable = "tape-recorder-voice-unintelligible";
+
+ [DataField]
+ public LocId TextCorruptionCharacter = "tape-recorder-message-corruption";
+
+ [DataField]
+ public LocId TextExamine = "tape-cassette-position";
+
+ [DataField]
+ public LocId TextDamaged = "tape-cassette-damaged";
+
+ ///
+ /// Temporary storage for all heard messages that need processing
+ ///
+ [DataField]
+ public List Buffer = new();
+
+ ///
+ /// Whitelist for tools that can be used to respool a damaged tape.
+ ///
+ [DataField(required: true)]
+ public EntityWhitelist RepairWhitelist = new();
+}
+
+///
+/// Removed from the cassette when damaged to prevent it being played until repaired
+///
+[RegisterComponent, NetworkedComponent]
+public sealed partial class FitsInTapeRecorderComponent : Component;
\ No newline at end of file
diff --git a/Content.Shared/TapeRecorder/Components/TapeRecorderComponent.cs b/Content.Shared/TapeRecorder/Components/TapeRecorderComponent.cs
new file mode 100644
index 00000000000..46b9eab89a4
--- /dev/null
+++ b/Content.Shared/TapeRecorder/Components/TapeRecorderComponent.cs
@@ -0,0 +1,124 @@
+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.Utility;
+
+namespace Content.Shared.TapeRecorder.Components;
+
+[RegisterComponent, NetworkedComponent, Access(typeof(SharedTapeRecorderSystem))]
+[AutoGenerateComponentState, AutoGenerateComponentPause]
+public sealed partial class TapeRecorderComponent : Component
+{
+ ///
+ /// The current tape recorder mode, controls what using the item will do
+ ///
+ [DataField, AutoNetworkedField]
+ public TapeRecorderMode Mode = TapeRecorderMode.Stopped;
+
+ ///
+ /// Paper that will spawn when printing transcript
+ ///
+ [DataField]
+ public EntProtoId PaperPrototype = "TapeRecorderTranscript";
+
+ ///
+ /// How fast can this tape recorder rewind
+ /// Acts as a multiplier for the frameTime
+ ///
+ [DataField]
+ public float RewindSpeed = 3f;
+
+ [DataField(customTypeSerializer: typeof(TimeOffsetSerializer)), AutoPausedField]
+ public TimeSpan CooldownEndTime = TimeSpan.Zero;
+
+ ///
+ /// Cooldown of print button
+ ///
+ [DataField]
+ public TimeSpan PrintCooldown = TimeSpan.FromSeconds(4);
+
+ ///
+ /// Default name as fallback if a message doesn't have one.
+ ///
+ [DataField]
+ public LocId DefaultName = "tape-recorder-voice-unknown";
+
+ ///
+ /// Sound on print transcript
+ ///
+ [DataField]
+ public SoundSpecifier PrintSound = new SoundPathSpecifier("/Audio/Machines/diagnoser_printing.ogg")
+ {
+ Params = AudioParams.Default.WithVolume(-2f).WithMaxDistance(3f)
+ };
+
+ ///
+ /// What sound is used when play mode is activated
+ ///
+ [DataField]
+ public SoundSpecifier PlaySound = new SoundPathSpecifier("/Audio/Items/Taperecorder/taperecorder_play.ogg")
+ {
+ Params = AudioParams.Default.WithVolume(-2f).WithMaxDistance(3f)
+ };
+
+ ///
+ /// What sound is used when stop mode is activated
+ ///
+ [DataField]
+ public SoundSpecifier StopSound = new SoundPathSpecifier("/Audio/Items/Taperecorder/taperecorder_stop.ogg")
+ {
+ Params = AudioParams.Default.WithVolume(-2f).WithMaxDistance(3f)
+ };
+
+ ///
+ /// What sound is used when rewind mode is activated
+ ///
+ [DataField]
+ public SoundSpecifier RewindSound = new SoundPathSpecifier("/Audio/Items/Taperecorder/taperecorder_rewind.ogg")
+ {
+ Params = AudioParams.Default.WithVolume(-2f).WithMaxDistance(3f)
+ };
+
+ //Locale references
+ [DataField]
+ public LocId TextCantEject = "tape-recorder-locked";
+
+ [DataField]
+ public LocId TextModePlaying = "tape-recorder-playing";
+
+ [DataField]
+ public LocId TextModeRecording = "tape-recorder-recording";
+
+ [DataField]
+ public LocId TextModeRewinding = "tape-recorder-rewinding";
+
+ [DataField]
+ public LocId TextModeStopped = "tape-recorder-stopped";
+
+ [DataField]
+ public LocId TextModeEmpty = "tape-recorder-empty";
+}
+
+[Serializable, NetSerializable]
+public enum TapeRecorderVisuals : byte
+{
+ Mode,
+ TapeInserted
+}
+
+[Serializable, NetSerializable]
+public enum TapeRecorderMode : byte
+{
+ Stopped,
+ Recording,
+ Playing,
+ Rewinding
+}
+
+[Serializable, NetSerializable]
+public enum TapeRecorderUIKey : byte
+{
+ Key
+}
\ No newline at end of file
diff --git a/Content.Shared/TapeRecorder/Events/TapeRecorderEvents.cs b/Content.Shared/TapeRecorder/Events/TapeRecorderEvents.cs
new file mode 100644
index 00000000000..dfd5edcaf31
--- /dev/null
+++ b/Content.Shared/TapeRecorder/Events/TapeRecorderEvents.cs
@@ -0,0 +1,50 @@
+using Content.Shared.DoAfter;
+using Content.Shared.TapeRecorder.Components;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.TapeRecorder.Events;
+
+[Serializable, NetSerializable]
+public sealed partial class TapeCassetteRepairDoAfterEvent : SimpleDoAfterEvent;
+
+[Serializable, NetSerializable]
+public sealed class ChangeModeTapeRecorderMessage : BoundUserInterfaceMessage
+{
+ public TapeRecorderMode Mode;
+
+ public ChangeModeTapeRecorderMessage(TapeRecorderMode mode)
+ {
+ Mode = mode;
+ }
+}
+
+[Serializable, NetSerializable]
+public sealed class PrintTapeRecorderMessage : BoundUserInterfaceMessage;
+
+[Serializable, NetSerializable]
+public sealed class TapeRecorderState : BoundUserInterfaceState
+{
+ // TODO: check the itemslot on client instead of putting easy casette stuff in the state
+ public bool HasCasette;
+ public bool HasData;
+ public float CurrentTime;
+ public float MaxTime;
+ public string CassetteName;
+ public TimeSpan PrintCooldown;
+
+ public TapeRecorderState(
+ bool hasCasette,
+ bool hasData,
+ float currentTime,
+ float maxTime,
+ string cassetteName,
+ TimeSpan printCooldown)
+ {
+ HasCasette = hasCasette;
+ HasData = hasData;
+ CurrentTime = currentTime;
+ MaxTime = maxTime;
+ CassetteName = cassetteName;
+ PrintCooldown = printCooldown;
+ }
+}
diff --git a/Content.Shared/TapeRecorder/SharedTapeRecorderSystem.cs b/Content.Shared/TapeRecorder/SharedTapeRecorderSystem.cs
new file mode 100644
index 00000000000..b5b8fb25872
--- /dev/null
+++ b/Content.Shared/TapeRecorder/SharedTapeRecorderSystem.cs
@@ -0,0 +1,422 @@
+using Content.Shared.Containers.ItemSlots;
+using Content.Shared.Damage;
+using Content.Shared.Destructible;
+using Content.Shared.DoAfter;
+using Content.Shared.Examine;
+using Content.Shared.Interaction;
+using Content.Shared.Labels.Components;
+using Content.Shared.Popups;
+using Content.Shared.Tag;
+using Content.Shared.TapeRecorder.Components;
+using Content.Shared.TapeRecorder.Events;
+using Content.Shared.Toggleable;
+using Content.Shared.UserInterface;
+using Content.Shared.Whitelist;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Containers;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+
+namespace Content.Shared.TapeRecorder;
+
+public abstract class SharedTapeRecorderSystem : EntitySystem
+{
+ [Dependency] private readonly EntityWhitelistSystem _whitelist = default!;
+ [Dependency] protected readonly IGameTiming Timing = default!;
+ [Dependency] private readonly IRobustRandom _random = default!;
+ [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+ [Dependency] protected readonly SharedAudioSystem Audio = default!;
+ [Dependency] private readonly SharedDoAfterSystem _doAfter = default!;
+ [Dependency] private readonly ItemSlotsSystem _slots = default!;
+ [Dependency] private readonly SharedPopupSystem _popup = default!;
+ [Dependency] private readonly SharedUserInterfaceSystem _ui = default!;
+
+ protected const string SlotName = "cassette_tape";
+
+ public override void Initialize()
+ {
+ base.Initialize();
+
+ SubscribeLocalEvent(OnCassetteRemoveAttempt);
+ SubscribeLocalEvent(OnCassetteRemoved);
+ SubscribeLocalEvent(OnCassetteInserted);
+ SubscribeLocalEvent(OnRecorderExamined);
+ SubscribeLocalEvent(OnChangeModeMessage);
+ SubscribeLocalEvent(OnUIOpened);
+
+ SubscribeLocalEvent(OnTapeExamined);
+ SubscribeLocalEvent(OnDamagedChanged);
+ SubscribeLocalEvent(OnInteractingWithCassette);
+ SubscribeLocalEvent(OnTapeCassetteRepair);
+ }
+
+ ///
+ /// Process active tape recorder modes
+ ///
+ public override void Update(float frameTime)
+ {
+ base.Update(frameTime);
+
+ var query = EntityQueryEnumerator();
+ while (query.MoveNext(out var uid, out _, out var comp))
+ {
+ var ent = (uid, comp);
+ if (!TryGetTapeCassette(uid, out var tape))
+ {
+ SetMode(ent, TapeRecorderMode.Stopped);
+ continue;
+ }
+
+ var continuing = comp.Mode switch
+ {
+ TapeRecorderMode.Recording => ProcessRecordingTapeRecorder(ent, frameTime),
+ TapeRecorderMode.Playing => ProcessPlayingTapeRecorder(ent, frameTime),
+ TapeRecorderMode.Rewinding => ProcessRewindingTapeRecorder(ent, frameTime),
+ _ => false
+ };
+
+ if (continuing)
+ continue;
+
+ SetMode(ent, TapeRecorderMode.Stopped);
+ Dirty(tape); // make sure clients have the right value once it's stopped
+ }
+ }
+
+ private void OnUIOpened(Entity ent, ref AfterActivatableUIOpenEvent args)
+ {
+ UpdateUI(ent);
+ }
+
+ ///
+ /// UI message when choosing between recorder modes
+ ///
+ private void OnChangeModeMessage(Entity ent, ref ChangeModeTapeRecorderMessage args)
+ {
+ SetMode(ent, args.Mode);
+ }
+
+ ///
+ /// Update the tape position and overwrite any messages between the previous and new position
+ ///
+ /// The tape recorder to process
+ /// Number of seconds that have passed since the last call
+ /// True if the tape recorder should continue in the current mode, False if it should switch to the Stopped mode
+ private bool ProcessRecordingTapeRecorder(Entity ent, float frameTime)
+ {
+ if (!TryGetTapeCassette(ent, out var tape))
+ return false;
+
+ var currentTime = tape.Comp.CurrentPosition + frameTime;
+
+ //'Flushed' in this context is a mark indicating the message was not added between the last update and this update
+ //Remove any flushed messages in the segment we just recorded over (ie old messages)
+ tape.Comp.RecordedData.RemoveAll(x => x.Timestamp > tape.Comp.CurrentPosition && x.Timestamp <= currentTime);
+
+ tape.Comp.RecordedData.AddRange(tape.Comp.Buffer);
+
+ tape.Comp.Buffer.Clear();
+
+ //Update the tape's current time
+ tape.Comp.CurrentPosition = (float) Math.Min(currentTime, tape.Comp.MaxCapacity.TotalSeconds);
+
+ //If we have reached the end of the tape - stop
+ return tape.Comp.CurrentPosition < tape.Comp.MaxCapacity.TotalSeconds;
+ }
+
+ ///
+ /// Update the tape position and play any messages with timestamps between the previous and new position
+ ///
+ /// The tape recorder to process
+ /// Number of seconds that have passed since the last call
+ /// True if the tape recorder should continue in the current mode, False if it should switch to the Stopped mode
+ private bool ProcessPlayingTapeRecorder(Entity ent, float frameTime)
+ {
+ if (!TryGetTapeCassette(ent, out var tape))
+ return false;
+
+ //Get the segment of the tape to be played
+ //And any messages within that time period
+ var currentTime = tape.Comp.CurrentPosition + frameTime;
+
+ ReplayMessagesInSegment(ent, tape.Comp, tape.Comp.CurrentPosition, currentTime);
+
+ //Update the tape's position
+ tape.Comp.CurrentPosition = (float) Math.Min(currentTime, tape.Comp.MaxCapacity.TotalSeconds);
+
+ //Stop when we reach the end of the tape
+ return tape.Comp.CurrentPosition < tape.Comp.MaxCapacity.TotalSeconds;
+ }
+
+ ///
+ /// Update the tape position in reverse
+ ///
+ /// The tape recorder to process
+ /// Number of seconds that have passed since the last call
+ /// True if the tape recorder should continue in the current mode, False if it should switch to the Stopped mode
+ private bool ProcessRewindingTapeRecorder(Entity ent, float frameTime)
+ {
+ if (!TryGetTapeCassette(ent, out var tape))
+ return false;
+
+ //Calculate how far we have rewound
+ var rewindTime = frameTime * ent.Comp.RewindSpeed;
+ //Update the current time, clamp to 0
+ tape.Comp.CurrentPosition = Math.Max(0, tape.Comp.CurrentPosition - rewindTime);
+
+ //If we have reached the beginning of the tape, stop
+ return tape.Comp.CurrentPosition >= float.Epsilon;
+ }
+
+ ///
+ /// Plays messages back on the server.
+ /// Does nothing on the client.
+ ///
+ protected virtual void ReplayMessagesInSegment(Entity ent, TapeCassetteComponent tape, float segmentStart, float segmentEnd)
+ {
+ }
+
+ ///
+ /// Start repairing a damaged tape when using a screwdriver or pen on it
+ ///
+ protected void OnInteractingWithCassette(Entity ent, ref InteractUsingEvent args)
+ {
+ //Is the tape damaged?
+ if (HasComp(ent))
+ return;
+
+ //Are we using a valid repair tool?
+ if (_whitelist.IsWhitelistFail(ent.Comp.RepairWhitelist, args.Used))
+ return;
+
+ _doAfter.TryStartDoAfter(new DoAfterArgs(EntityManager, args.User, ent.Comp.RepairDelay, new TapeCassetteRepairDoAfterEvent(), ent, target: ent, used: args.Used)
+ {
+ BreakOnMove = true,
+ NeedHand = true
+ });
+ }
+
+ ///
+ /// Repair a damaged tape
+ ///
+ protected void OnTapeCassetteRepair(Entity ent, ref TapeCassetteRepairDoAfterEvent args)
+ {
+ if (args.Handled || args.Cancelled || args.Args.Target == null)
+ return;
+
+ //Cant repair if not damaged
+ if (HasComp(ent))
+ return;
+
+ _appearance.SetData(ent, ToggleVisuals.Toggled, false);
+ AddComp(ent);
+ args.Handled = true;
+ }
+
+ ///
+ /// When the cassette has been damaged, corrupt and entry and unspool it
+ ///
+ protected void OnDamagedChanged(Entity ent, ref DamageChangedEvent args)
+ {
+ if (args.DamageDelta == null || args.DamageDelta.GetTotal() < 5)
+ return;
+
+ _appearance.SetData(ent, ToggleVisuals.Toggled, true);
+
+ RemComp(ent);
+ CorruptRandomEntry(ent);
+ }
+
+ protected void OnTapeExamined(Entity ent, ref ExaminedEvent args)
+ {
+ if (!args.IsInDetailsRange)
+ return;
+
+ if (!HasComp(ent))
+ {
+ args.PushMarkup(Loc.GetString(ent.Comp.TextDamaged));
+ return;
+ }
+
+ var positionPercentage = Math.Floor(ent.Comp.CurrentPosition / ent.Comp.MaxCapacity.TotalSeconds * 100);
+ var tapePosMsg = Loc.GetString(ent.Comp.TextExamine, ("position", positionPercentage));
+ args.PushMarkup(tapePosMsg);
+ }
+
+ protected void OnRecorderExamined(Entity ent, ref ExaminedEvent args)
+ {
+ if (!args.IsInDetailsRange)
+ return;
+
+ //Check if we have a tape cassette inserted
+ if (!TryGetTapeCassette(ent, out var tape))
+ {
+ args.PushMarkup(Loc.GetString(ent.Comp.TextModeEmpty));
+ return;
+ }
+
+ args.PushMarkup(Loc.GetString(ent.Comp.Mode switch
+ {
+ TapeRecorderMode.Playing => ent.Comp.TextModePlaying,
+ TapeRecorderMode.Stopped => ent.Comp.TextModeStopped,
+ TapeRecorderMode.Recording => ent.Comp.TextModeRecording,
+ TapeRecorderMode.Rewinding => ent.Comp.TextModeRewinding,
+ _ => ""
+ }));
+
+ OnTapeExamined(tape, ref args);
+ }
+
+ ///
+ /// Prevent removing the tape cassette while the recorder is active
+ ///
+ protected void OnCassetteRemoveAttempt(Entity ent, ref ItemSlotEjectAttemptEvent args)
+ {
+ if (!HasComp(ent))
+ return;
+
+ args.Cancelled = true;
+ }
+
+ protected void OnCassetteRemoved(Entity ent, ref EntRemovedFromContainerMessage args)
+ {
+ SetMode(ent, TapeRecorderMode.Stopped);
+ UpdateAppearance(ent);
+ UpdateUI(ent);
+ }
+
+ protected void OnCassetteInserted(Entity ent, ref EntInsertedIntoContainerMessage args)
+ {
+ UpdateAppearance(ent);
+ UpdateUI(ent);
+ }
+
+ ///
+ /// Update the appearance of the tape recorder.
+ ///
+ /// The tape recorder to update
+ protected void UpdateAppearance(Entity ent)
+ {
+ var hasCassette = TryGetTapeCassette(ent, out _);
+ _appearance.SetData(ent, TapeRecorderVisuals.Mode, ent.Comp.Mode);
+ _appearance.SetData(ent, TapeRecorderVisuals.TapeInserted, hasCassette);
+ }
+
+ ///
+ /// Choose a random recorded entry on the cassette and replace some of the text with hashes
+ ///
+ ///
+ protected void CorruptRandomEntry(TapeCassetteComponent tape)
+ {
+ if (tape.RecordedData.Count == 0)
+ return;
+
+ var entry = _random.Pick(tape.RecordedData);
+
+ var corruption = Loc.GetString(tape.TextCorruptionCharacter);
+
+ var corruptedMessage = new StringBuilder();
+ foreach (var character in entry.Message)
+ {
+ if (_random.Prob(tape.CorruptionChance))
+ corruptedMessage.Append(corruption);
+ else
+ corruptedMessage.Append(character);
+ }
+
+ entry.Name = Loc.GetString(tape.TextUnintelligable);
+ entry.Message = corruptedMessage.ToString();
+ }
+
+ ///
+ /// Set the tape recorder mode and dirty if it is different from the previous mode
+ ///
+ /// The tape recorder to update
+ /// The new mode
+ private void SetMode(Entity ent, TapeRecorderMode mode)
+ {
+ if (mode == ent.Comp.Mode)
+ return;
+
+ if (mode == TapeRecorderMode.Stopped)
+ {
+ RemComp(ent);
+ }
+ else
+ {
+ // can't play without a tape in it...
+ if (!TryGetTapeCassette(ent, out _))
+ return;
+
+ EnsureComp(ent);
+ }
+
+ var sound = ent.Comp.Mode switch
+ {
+ TapeRecorderMode.Stopped => ent.Comp.StopSound,
+ TapeRecorderMode.Rewinding => ent.Comp.RewindSound,
+ _ => ent.Comp.PlaySound
+ };
+ Audio.PlayPvs(sound, ent);
+
+ ent.Comp.Mode = mode;
+ Dirty(ent);
+
+ UpdateUI(ent);
+ }
+
+ protected bool TryGetTapeCassette(EntityUid ent, [NotNullWhen(true)] out Entity tape)
+ {
+ if (_slots.GetItemOrNull(ent, SlotName) is not {} cassette)
+ {
+ tape = default!;
+ return false;
+ }
+
+ if (!TryComp(cassette, out var comp))
+ {
+ tape = default!;
+ return false;
+ }
+
+ tape = new(cassette, comp);
+ return true;
+ }
+
+ private void UpdateUI(Entity ent)
+ {
+ var (uid, comp) = ent;
+ if (!_ui.IsUiOpen(uid, TapeRecorderUIKey.Key))
+ return;
+
+ var hasCassette = TryGetTapeCassette(ent, out var tape);
+ var hasData = false;
+ var currentTime = 0f;
+ var maxTime = 0f;
+ var cassetteName = Loc.GetString("tape-recorder-menu-cassette-unnamed");
+ var cooldown = comp.PrintCooldown;
+
+ if (hasCassette)
+ {
+ hasData = tape.Comp.RecordedData.Count > 0;
+ currentTime = tape.Comp.CurrentPosition;
+ maxTime = (float) tape.Comp.MaxCapacity.TotalSeconds;
+
+ if (TryComp(tape, out var labelComp))
+ if (labelComp.CurrentLabel != null)
+ cassetteName = labelComp.CurrentLabel;
+ }
+
+ var state = new TapeRecorderState(
+ hasCassette,
+ hasData,
+ currentTime,
+ maxTime,
+ cassetteName,
+ cooldown);
+
+ _ui.SetUiState(uid, TapeRecorderUIKey.Key, state);
+ }
+}
diff --git a/Content.Shared/TapeRecorder/TapeCassetteRecordedMessage.cs b/Content.Shared/TapeRecorder/TapeCassetteRecordedMessage.cs
new file mode 100644
index 00000000000..b583939ff6d
--- /dev/null
+++ b/Content.Shared/TapeRecorder/TapeCassetteRecordedMessage.cs
@@ -0,0 +1,51 @@
+using Content.Shared.Speech;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.TapeRecorder;
+
+///
+/// Every chat event recorded on a tape is saved in this format
+///
+[ImplicitDataDefinitionForInheritors]
+public sealed partial class TapeCassetteRecordedMessage : IComparable
+{
+ ///
+ /// Number of seconds since the start of the tape that this event was recorded at
+ ///
+ [DataField(required: true)]
+ public float Timestamp = 0;
+
+ ///
+ /// The name of the entity that spoke
+ ///
+ [DataField]
+ public string? Name;
+
+ ///
+ /// The verb used for this message.
+ ///
+ [DataField]
+ public ProtoId? Verb;
+
+ ///
+ /// What was spoken
+ ///
+ [DataField]
+ public string Message = string.Empty;
+
+ public TapeCassetteRecordedMessage(float timestamp, string name, ProtoId verb, string message)
+ {
+ Timestamp = timestamp;
+ Name = name;
+ Verb = verb;
+ Message = message;
+ }
+
+ public int CompareTo(TapeCassetteRecordedMessage? other)
+ {
+ if (other == null)
+ return 0;
+
+ return (int) (Timestamp - other.Timestamp);
+ }
+}
diff --git a/Resources/Audio/Items/Taperecorder/attributions.yml b/Resources/Audio/Items/Taperecorder/attributions.yml
new file mode 100644
index 00000000000..3a72021c08f
--- /dev/null
+++ b/Resources/Audio/Items/Taperecorder/attributions.yml
@@ -0,0 +1,17 @@
+- files:
+ - "taperecorder_play.ogg"
+ license: "CC0-1.0"
+ copyright: "Taken from cassette tape deck open, close +tape handling.aif by kyles. Converted from Aiff to Ogg."
+ source: "https://freesound.org/people/kyles/sounds/450525/"
+
+- files:
+ - "taperecorder_stop.ogg"
+ license: "CC-BY-4.0"
+ copyright: "Taken from Pressing Stop on An Old Tape Machine by djlprojects. Converted from Mp3 to Ogg."
+ source: "https://freesound.org/people/djlprojects/sounds/392889/"
+
+- files:
+ - "taperecorder_rewind.ogg"
+ license: "CC-BY-NC-4.0"
+ copyright: "Taken from CassetteRewind.flac by acclivity. Converted from Flac to Ogg."
+ source: "https://freesound.org/people/acclivity/sounds/23393/"
\ No newline at end of file
diff --git a/Resources/Audio/Items/Taperecorder/taperecorder_play.ogg b/Resources/Audio/Items/Taperecorder/taperecorder_play.ogg
new file mode 100644
index 0000000000000000000000000000000000000000..1bf4d7a3bd63a14b3786fe9ec237b912335b8c38
GIT binary patch
literal 11670
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
lGfzW^N+O`QM$
literal 0
HcmV?d00001
diff --git a/Resources/Locale/en-US/taperecorder/taperecorder.ftl b/Resources/Locale/en-US/taperecorder/taperecorder.ftl
new file mode 100644
index 00000000000..705a3e4527d
--- /dev/null
+++ b/Resources/Locale/en-US/taperecorder/taperecorder.ftl
@@ -0,0 +1,26 @@
+cassette-repair-start = You start winding the tape back into {THE($item)}.
+cassette-repair-finish = You manage to wind the tape back into {THE($item)}.
+tape-cassette-position = The cassette is about [color=green]{$position}%[/color] the way through.
+tape-cassette-damaged = The cassette is unspooled, use a pen or screwdriver to repair it.
+tape-recorder-playing = The tape recorder is in [color=green]playback[/color] mode.
+tape-recorder-stopped = The tape recorder is stopped.
+tape-recorder-empty = The tape recorder is empty.
+tape-recorder-recording = The tape recorder is in [color=red]recording[/color] mode.
+tape-recorder-rewinding = The tape recorder is in [color=yellow]rewinding[/color] mode.
+tape-recorder-locked = Cant eject while the tape recorder is running.
+tape-recorder-voice-unknown = Unknown
+tape-recorder-voice-unintelligible = Unintelligible
+tape-recorder-message-corruption = #
+tape-recorder-menu-title = Tape Recorder
+tape-recorder-menu-controls-label = Controls:
+tape-recorder-menu-stopped-button = Pause
+tape-recorder-menu-recording-button = Record
+tape-recorder-menu-playing-button = Playback
+tape-recorder-menu-rewinding-button = Rewind
+tape-recorder-menu-print-button = Print record transcript
+tape-recorder-menu-cassette-label = Cassette tape: {$cassetteName}
+tape-recorder-menu-no-cassette-label = Cassette tape is not inserted
+tape-recorder-menu-cassette-unnamed = Unnamed
+tape-recorder-print-start-text = [bold]Start of recorded transcript[/bold]
+tape-recorder-print-message-text = [bold][{$time}] {$source}: [/bold] {$message}
+tape-recorder-print-end-text = [bold]End of recorded transcript[/bold]
\ No newline at end of file
diff --git a/Resources/Locale/ru-RU/ss14-ru/prototypes/catalog/fills/boxes/security.ftl b/Resources/Locale/ru-RU/ss14-ru/prototypes/catalog/fills/boxes/security.ftl
index 18108cd83a1..7e41c6630f1 100644
--- a/Resources/Locale/ru-RU/ss14-ru/prototypes/catalog/fills/boxes/security.ftl
+++ b/Resources/Locale/ru-RU/ss14-ru/prototypes/catalog/fills/boxes/security.ftl
@@ -8,3 +8,5 @@ ent-BoxZiptie = коробка стяжек
.desc = Полная коробка кабельных стяжек.
ent-BoxForensicPad = коробка криминалистических пластинок
.desc = Коробка криминалистических пластинок.
+ent-BoxTapeRecorder = коробка с диктофоном
+ .desc = Коробка с разноцветными кассетами и одним диктофоном.
\ No newline at end of file
diff --git a/Resources/Locale/ru-RU/ss14-ru/prototypes/entities/objects/devices/tape_recorder.ftl b/Resources/Locale/ru-RU/ss14-ru/prototypes/entities/objects/devices/tape_recorder.ftl
new file mode 100644
index 00000000000..9cda0069659
--- /dev/null
+++ b/Resources/Locale/ru-RU/ss14-ru/prototypes/entities/objects/devices/tape_recorder.ftl
@@ -0,0 +1,4 @@
+ent-TapeRecorder = диктофон
+ .desc = Всё, что будет записано, будет использовано против вас в суде.
+ent-CassetteTape = кассетная лента
+ .desc = Магнитная лента, которая может вместить до двух минут диалогов с каждой стороны.
\ No newline at end of file
diff --git a/Resources/Locale/ru-RU/ss14-ru/prototypes/entities/objects/misc/paper.ftl b/Resources/Locale/ru-RU/ss14-ru/prototypes/entities/objects/misc/paper.ftl
index 0c47231fe9f..c0a01bdf307 100644
--- a/Resources/Locale/ru-RU/ss14-ru/prototypes/entities/objects/misc/paper.ftl
+++ b/Resources/Locale/ru-RU/ss14-ru/prototypes/entities/objects/misc/paper.ftl
@@ -63,3 +63,4 @@ ent-AllTraitorCodesPaper = реестр кодовых слов Синдикат
.suffix = Адмемы
ent-Envelope = конверт
.desc = Небольшой конверт для защиты от посторонних глаз ваших конфиденциальных документов.
+ent-TapeRecorderTranscript = расшифровка записи
diff --git a/Resources/Locale/ru-RU/taperecorder/taperecorder.ftl b/Resources/Locale/ru-RU/taperecorder/taperecorder.ftl
new file mode 100644
index 00000000000..354cc73d92a
--- /dev/null
+++ b/Resources/Locale/ru-RU/taperecorder/taperecorder.ftl
@@ -0,0 +1,26 @@
+cassette-repair-start = Вы начинаете втягивать ленту обратно в {THE($item)}.
+cassette-repair-finish = Вам удалось намотать ленту обратно в {THE($item)}.
+tape-cassette-position = Кассета проиграна примерно на [color=green]{$position}%[/color].
+tape-cassette-damaged = Кассета размотана. Используйте ручку или отвертку, чтобы намотать ленту обратно.
+tape-recorder-playing = Диктофон находится в режиме [color=green]воспроизведения[/color].
+tape-recorder-stopped = Диктофон остановлен.
+tape-recorder-empty = Диктофон пуст.
+tape-recorder-recording = Диктофон находится в режиме [color=red]записи[/color].
+tape-recorder-rewinding = Диктофон находится в режиме [color=yellow]перемотки[/color].
+tape-recorder-locked = Нельзя извлечь кассету, пока диктофон работает.
+tape-recorder-voice-unknown = Неизвестно
+tape-recorder-voice-unintelligible = Неразборчиво
+tape-recorder-message-corruption = #
+tape-recorder-menu-title = Диктофон
+tape-recorder-menu-controls-label = Управление:
+tape-recorder-menu-stopped-button = Пауза
+tape-recorder-menu-recording-button = Запись
+tape-recorder-menu-playing-button = Воспроизвести
+tape-recorder-menu-rewinding-button = Перемотать
+tape-recorder-menu-print-button = Распечатать расшифровку
+tape-recorder-menu-cassette-label = Кассетная лента: {$cassetteName}
+tape-recorder-menu-no-cassette-label = Кассета не вставлена
+tape-recorder-menu-cassette-unnamed = Название не установлено
+tape-recorder-print-start-text = [bold]Начало записи расшифровки[/bold]
+tape-recorder-print-message-text = [bold][{$time}] {$source}: [/bold] {$message}
+tape-recorder-print-end-text = [bold]Конец записи расшифровки[/bold]
\ No newline at end of file
diff --git a/Resources/Prototypes/Catalog/Fills/Boxes/security.yml b/Resources/Prototypes/Catalog/Fills/Boxes/security.yml
index c43118eff6f..667876affae 100644
--- a/Resources/Prototypes/Catalog/Fills/Boxes/security.yml
+++ b/Resources/Prototypes/Catalog/Fills/Boxes/security.yml
@@ -81,3 +81,26 @@
layers:
- state: box_security
- state: forensic
+
+- type: entity
+ name: tape recorder box
+ parent: BoxCardboard
+ id: BoxTapeRecorder
+ description: A box with colorful cassette tapes and a tape recorder.
+ components:
+ - type: StorageFill
+ contents:
+ - id: CassetteTape
+ amount: 1
+ - id: CassetteTape
+ amount: 1
+ - id: CassetteTape
+ amount: 1
+ - id: CassetteTape
+ amount: 1
+ - id: TapeRecorder
+ amount: 1
+ - type: Sprite
+ layers:
+ - state: box_security
+ - state: recorder
diff --git a/Resources/Prototypes/Catalog/Fills/Lockers/security.yml b/Resources/Prototypes/Catalog/Fills/Lockers/security.yml
index 61b0c737108..e7293bd36f5 100644
--- a/Resources/Prototypes/Catalog/Fills/Lockers/security.yml
+++ b/Resources/Prototypes/Catalog/Fills/Lockers/security.yml
@@ -157,6 +157,7 @@
- id: HoloprojectorSecurity
- id: BoxEvidenceMarkers
- id: HandLabeler
+ - id: BoxTapeRecorder
- type: entity
id: ClosetBombFilled
diff --git a/Resources/Prototypes/Entities/Objects/Devices/tape_recorder.yml b/Resources/Prototypes/Entities/Objects/Devices/tape_recorder.yml
new file mode 100644
index 00000000000..52a7c47d881
--- /dev/null
+++ b/Resources/Prototypes/Entities/Objects/Devices/tape_recorder.yml
@@ -0,0 +1,88 @@
+- type: entity
+ parent: BaseItem
+ id: TapeRecorder
+ name: tape recorder
+ description: Anything said into this device can and will be used against you in a court of space law.
+ components:
+ - type: Sprite
+ sprite: Objects/Devices/tape_recorder.rsi
+ layers:
+ - state: taperecorder_empty
+ - state: taperecorder_idle
+ map: ["tape"]
+ visible: false
+ - type: Item
+ size: Small
+ - type: TapeRecorder
+ - type: ActiveListener
+ range: 4
+ - type: UseDelay
+ delay: 1
+ - type: Speech
+ - type: ItemSlots
+ slots:
+ cassette_tape:
+ priority: 4
+ whitelist:
+ components:
+ - FitsInTapeRecorder
+ - type: ContainerContainer
+ containers:
+ cassette_tape: !type:ContainerSlot
+ - type: Appearance
+ - type: GenericVisualizer
+ visuals:
+ enum.TapeRecorderVisuals.Mode:
+ tape:
+ Stopped: { state: "taperecorder_idle" }
+ Playing: { state: "taperecorder_playing" }
+ Recording: { state: "taperecorder_recording" }
+ Rewinding: { state: "taperecorder_rewinding" }
+ enum.TapeRecorderVisuals.TapeInserted:
+ tape:
+ True: { visible: true }
+ False: { visible: false }
+ - type: ActivatableUI
+ key: enum.TapeRecorderUIKey.Key
+ inHandsOnly: true
+ requireActiveHand: false
+ - type: UserInterface
+ interfaces:
+ enum.TapeRecorderUIKey.Key:
+ type: TapeRecorderBoundUserInterface
+
+- type: entity
+ parent: BaseItem
+ id: CassetteTape
+ name: cassette tape
+ description: A magnetic tape that can hold up to two minutes of content on either side.
+ components:
+ - type: Sprite
+ sprite: Objects/Devices/cassette_tapes.rsi
+ layers:
+ - state: tape_greyscale
+ map: [ "enum.DamageStateVisualLayers.Base" ]
+ - state: tape_ribbonoverlay
+ map: [ "enum.ToggleVisuals.Layer" ]
+ visible: false
+ - type: Item
+ size: Tiny
+ - type: Damageable
+ - type: TapeCassette
+ maxCapacity: 180
+ repairWhitelist:
+ tags:
+ - Screwdriver
+ - Write
+ - type: FitsInTapeRecorder
+ - type: Appearance
+ - type: GenericVisualizer
+ visuals:
+ enum.ToggleVisuals.Toggled:
+ enum.ToggleVisuals.Layer:
+ True: { visible: true }
+ False: { visible: false }
+ - type: RandomSprite
+ available:
+ - enum.DamageStateVisualLayers.Base:
+ tape_greyscale: Rainbow
diff --git a/Resources/Prototypes/Entities/Objects/Misc/paper.yml b/Resources/Prototypes/Entities/Objects/Misc/paper.yml
index 8f994fdea3b..dad550153e5 100644
--- a/Resources/Prototypes/Entities/Objects/Misc/paper.yml
+++ b/Resources/Prototypes/Entities/Objects/Misc/paper.yml
@@ -706,3 +706,9 @@
- !type:EmptyAllContainersBehaviour
- !type:DoActsBehavior
acts: [ "Destruction" ]
+
+- type: entity
+ parent: Paper
+ id: TapeRecorderTranscript
+ name: record transcript
+ # TODO: could have a unique sprite in the future
diff --git a/Resources/Prototypes/Entities/Structures/Machines/lathe.yml b/Resources/Prototypes/Entities/Structures/Machines/lathe.yml
index 68656f3c3aa..55d881d1a95 100644
--- a/Resources/Prototypes/Entities/Structures/Machines/lathe.yml
+++ b/Resources/Prototypes/Entities/Structures/Machines/lathe.yml
@@ -201,6 +201,8 @@
- WetFloorSign
- ClothingHeadHatCone
- FreezerElectronics
+ - CassetteTape
+ - TapeRecorder
- PlantAnalyzer # Corvax-Next-PlantAnalyzer
- type: EmagLatheRecipes
emagStaticRecipes:
diff --git a/Resources/Prototypes/Recipes/Lathes/misc.yml b/Resources/Prototypes/Recipes/Lathes/misc.yml
index 7dc77997839..eb27525c376 100644
--- a/Resources/Prototypes/Recipes/Lathes/misc.yml
+++ b/Resources/Prototypes/Recipes/Lathes/misc.yml
@@ -237,3 +237,21 @@
completetime: 3
materials:
Plastic: 200
+
+- type: latheRecipe
+ id: CassetteTape
+ result: CassetteTape
+ category: Tools
+ completetime: 2
+ materials:
+ Steel: 50
+ Plastic: 150
+
+- type: latheRecipe
+ id: TapeRecorder
+ result: TapeRecorder
+ category: Tools
+ completetime: 3
+ materials:
+ Steel: 250
+ Plastic: 250
\ No newline at end of file
diff --git a/Resources/Prototypes/Roles/Jobs/Wildcards/reporter.yml b/Resources/Prototypes/Roles/Jobs/Wildcards/reporter.yml
index d0a35990d70..eefd3d75272 100644
--- a/Resources/Prototypes/Roles/Jobs/Wildcards/reporter.yml
+++ b/Resources/Prototypes/Roles/Jobs/Wildcards/reporter.yml
@@ -16,6 +16,8 @@
shoes: ClothingShoesColorWhite
id: ReporterPDA
ears: ClothingHeadsetService
- #storage:
- #back:
- #- Stuff
+ storage:
+ back:
+ - TapeRecorder
+ - CassetteTape
+ - CassetteTape
diff --git a/Resources/Textures/Objects/Devices/cassette_tapes.rsi/meta.json b/Resources/Textures/Objects/Devices/cassette_tapes.rsi/meta.json
new file mode 100644
index 00000000000..5e081519e4c
--- /dev/null
+++ b/Resources/Textures/Objects/Devices/cassette_tapes.rsi/meta.json
@@ -0,0 +1,17 @@
+{
+ "version": 1,
+ "license": "CC-BY-SA-3.0",
+ "copyright": "Taken from tgstation at https://github.com/tgstation/tgstation/commit/92dc954ab5317b370e98dd070ad60ba8c3e8a6e9",
+ "size": {
+ "x": 32,
+ "y": 32
+ },
+ "states": [
+ {
+ "name": "tape_greyscale"
+ },
+ {
+ "name": "tape_ribbonoverlay"
+ }
+ ]
+}
diff --git a/Resources/Textures/Objects/Devices/cassette_tapes.rsi/tape_greyscale.png b/Resources/Textures/Objects/Devices/cassette_tapes.rsi/tape_greyscale.png
new file mode 100644
index 0000000000000000000000000000000000000000..9c0c99e09a220d886e1ef190ab8d7ddad213f58e
GIT binary patch
literal 423
zcmV;Y0a*TtP)oxU#PquA;_|NAvsjA9HAIv$U7xm*X?lR!Y)1S2
zp4)kze;b2R;P5m}`Fy!tP6L3BMrQ+}EK6FgR^&L2QdJd0yuS4;N}@u*6&yftpG^<}N_m|q3E*U!8t;z>wR4mV+5v37
zpX!3?c%;$*>>ymz)>b+-0W(7gfTwgS{3op=xFq6|fVTc-08YdfoY3#~9@a_%*ywT~
z5#)i9b{CKZ9-~qMmjl`)5u`PZK45E>qCx3YN--%KSF11eNi<+OL>c(yMVaEZ(FmBJ
r!1V5C>-A&=IFVQInV)7~0(IgBju{f?B3xN300000NkvXXu0mjf#Z|S&
literal 0
HcmV?d00001
diff --git a/Resources/Textures/Objects/Devices/tape_recorder.rsi/inhand-left.png b/Resources/Textures/Objects/Devices/tape_recorder.rsi/inhand-left.png
new file mode 100644
index 0000000000000000000000000000000000000000..c0a8da3279dfac7b43c6ebeb7184cc6b479b3036
GIT binary patch
literal 491
zcmV2I!NE;LY>QeD>>#2J
zPFkAAV}V*vdg
zz<}Qa=9>xt;G$mxs7@x{AFj@LA`lS~5fKp)5fKp)5mA6Beh(NQpBRcoqc6{nGj>zG
zdDrn-EI9hWB7hOUapjsp)u9Otj
z^I#PZP^(>IduLa+c1BN5foUTpGno|>t$l<;Ay*1jtya#v_7U8gUXYe>P`7R5@&$Z`
ze|Wfu(V@tXJ5TX*PkKT?c%JWV|D7pgUMimJHf&qX+P-mUWWrj*gm{h
zQ_~HTvD%`vlb?>O?;)G5jN@A
zH!BY{@r%dm|JDV!-Kjoj`}|&t2ZIt6ROMfrH+}QBJ%9SMgW2}()H$#~JmH11`BQ5q
zh61}4tQkJO`(k6}ed={^K?3zte!MyG#7K^^aoXTI+yw0z85^bW$Ejm
zK!JeO;ja6i%l|r+aM*)U+hJ)D3s9!R<;$y+8}IiYdDH6ZTNSr_wZ@4xPwplC{bGE;
zC|9y1F}vE`%1`*{B}TW!7Xx+)AE_yceNw#IphrYzdFS7~u^->M1J(WfaOc>sW6OBN
z;_hSyCmrG>P$|#}aMP(A+EM
zS)5FA&v{;aT^4&jxcH~(l+*1y)?7cbU0gxK$v<$xm#T%izwb-@j#X-wnBCFwZ+1BE
X*U6d9Hy`%^Bap$<)z4*}Q$iB}z31E$
literal 0
HcmV?d00001
diff --git a/Resources/Textures/Objects/Devices/tape_recorder.rsi/meta.json b/Resources/Textures/Objects/Devices/tape_recorder.rsi/meta.json
new file mode 100644
index 00000000000..46b8a14a38e
--- /dev/null
+++ b/Resources/Textures/Objects/Devices/tape_recorder.rsi/meta.json
@@ -0,0 +1,58 @@
+{
+ "version": 1,
+ "license": "CC-BY-SA-3.0",
+ "copyright": "Taken from tgstation at https://github.com/tgstation/tgstation/commit/92dc954ab5317b370e98dd070ad60ba8c3e8a6e9",
+ "size": {
+ "x": 32,
+ "y": 32
+ },
+ "states": [
+ {
+ "name": "taperecorder_idle"
+ },
+ {
+ "name": "inhand-right",
+ "directions": 4
+ },
+ {
+ "name": "inhand-left",
+ "directions": 4
+ },
+ {
+ "name": "taperecorder_recording",
+ "delays": [
+ [
+ 0.1,
+ 0.1,
+ 0.1,
+ 0.1
+ ]
+ ]
+ },
+ {
+ "name": "taperecorder_playing",
+ "delays": [
+ [
+ 0.1,
+ 0.1,
+ 0.1,
+ 0.1
+ ]
+ ]
+ },
+ {
+ "name": "taperecorder_rewinding",
+ "delays": [
+ [
+ 0.1,
+ 0.1,
+ 0.1,
+ 0.1
+ ]
+ ]
+ },
+ {
+ "name": "taperecorder_empty"
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_empty.png b/Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_empty.png
new file mode 100644
index 0000000000000000000000000000000000000000..5e8e0ab3e064f4f45227f6d48ad082964be3418f
GIT binary patch
literal 581
zcmV-L0=oT)P)AAg
zVr5|^{sAisvF(a~z=91Ts8r+qC{faf8l-7t+%q!LDdA3Y5lO$znK^TE?{ChWbI%mu
zkCg++0ptL<0h|>crAU&#jFH%LS(b5n5X=(_K$~}T_ac0C`DNTeFo5dXDt6VN@Ir8B
zV10E3QelzK7rBqA*5Pug)^4}sGKcO-f+j|1AU;0Hxk!GQ;Qd>HJeOvj}W&
z;`Zj|9fCHWZ)?Kx;UmU4*5=ND+wI26+J??IJvo8C!Tt}i(Y+JE;^bP_a2G5r&fy_0
zV{~j>y{E!UCX>ik!rO4SSVB)Kh3NH`*dpZB3){S_Z;)z33HW!!6rmB7l$PT1EXW-%
z9N<0{gTrb6eE>>5$z(R;Fn9!4x#M>MGR1QUWd$%iG@`qwvp-#05&9PAxz^(bI6pl`
zXM3y8M@6)83%p*h&ace^^{8gwp59)o0igh-s+wAaLKm_v=5WNeF1xO?k@OUZ_k4Is%mFX;L!)ik|;s!`1pV_<*sZ)>Ue!3;y*4MG1
zw^n>MFdGbY0i~S2bEef4iA0bOW8wk`Ux%ot6`oisNa4R^X%NEofBuSd06(Qyf~&cR
TJLsK+00000NkvXXu0mjfgu4YU
literal 0
HcmV?d00001
diff --git a/Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_idle.png b/Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_idle.png
new file mode 100644
index 0000000000000000000000000000000000000000..d495533369508a6a56e0ada03def7ed0437721b6
GIT binary patch
literal 597
zcmV-b0;>IqP)WN44
zAR-U)Cn!(6Z0!>-%JqQ~a<|rH-K|UQ#ae0GH0DgLwl&rnW|G=(P3JfBJ)QHJneWUw
zk@#bU073vE0BQhDY8o5IFhTn;obPtKaeizLlN5kVUQttzhuiC*{f^BhWM*e@RX$4#
zLHz{QmY2Z9#tC{6iWt6CsZ=<#T%!2d4Mjl_YdYNf7J?cenw#8cGzxnCBcnJv*x_q3
z`FL3orcYkbMKLZlfKI2w(#pD^H`LpMmiE?G(Vvq0i>wYVY$6WO;sI#1WL9LUY=V}SzapWkw2loWDB8QuNS=T
zTMPJFt_);kWy9&Tf9W^wZeXgQgs-()EodIUC;*qs1*I~HhX`zm))h+pMAQIY&nvgy
z-$2dX9a;DNTcXF@9Ilg>uU|bL=>dqydQVaw*!pC%*$@tKq5^oZ-jMgn()1xNHX!@Rv1o?FvFR}mqaF^2G29>61;udb
z3mHJ-*GleSYGQ2DAS$E&mZydK?T0GHKVby5sxaLU_1FaJ&MkrKJy%^
zsvmDzU)q4;GpF#ZwgzSQN-gW1`yIFyiC}i}yYf3hjM3nrc>z@D|JUz;mo>F``>w&V
zwrYsqyjuoeLp?aSeBqM00umvsFKqxV`?l8Rg!KbiSs42f02j3EPkQnbo`bBuv;l=@
z&&PW}e{gt1ePM16u52f`@Or)f^nk7EEAIg*si|0+4}+7nvlP}HR|u`P<|(fX%kkrKv{iZ14f2}xPJAbWsQD`t%air
za_LL0fb#Nk%m2rIi<|q#cW@vu2=^fuRKuY!Y(QSV2lMl@3G1but$1H}&fIsq-B7*!
zx%7n%SX^90X68ZjB-U?~tNc7qQNeIWy;CdcXf6css^UR$YtCB~^QyaN87#E!wGuipy8
z=4b<8bF=}lIobf&9Blw>jy6E_K%EcJ`2d{{(D?wJ55S-KJVDc$-tP8o&j)ypy5nOp
z75M~d186iwvq2hZ?tB0ZXX!&1!s-IB
z=L2ZjuP!entaIlBXxZ;*K7i))M4|~TcRt`v-Rt=3Q;|pK7pW|fX)Xf(AW6@QE{CQ(D?wJ577Alkz;i}fC-%sU_u)J
dn`3(eeghO%28JmZ$w>eJ002ovPDHLkV1mS+!L$GX
literal 0
HcmV?d00001
diff --git a/Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_recording.png b/Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_recording.png
new file mode 100644
index 0000000000000000000000000000000000000000..e5fda908c8c9b123236688cf39eb7c349d6065a8
GIT binary patch
literal 934
zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=oCO|{#S9F5M?jcysy3fA0|Rq}
zr;B4q#hkZM=e}Gbx+^!7yE92_qJ-{}
zj&JW4nH~DWF1XW!L-^0s#~FUl`ZaaW$n)|vpZIcavt&-q`JLwPFCN`3f98&Pv0lye
z_jAkd)xNK>epryf_yCSMxC3_nPuO+j>8*mk(;ezUoIU++&n2dSTi?Hx+&<=gH_xZGw~2eoH}^kVw`EUwI$i9+kCVYSr3|E`
zL(#nvHEds}ub(wPra=54kNLq@Vkg2_)Q=_aD0#RhwWlm8`(Pl;&L2yS6a+XT
z{>{JHJ^Of%X+twG+-61Di;30UJQjbh#(nYfJ2u~b)&$J`7xU*3la8+L!ZkVbcXr&F
zxMA1-I7V?`^sq+wsrEj9n_0nI`f_LWTaS!#af!)c;uCz9E|7}(6J**jZ~Mwq&-x_K
zoISgcq2|E@aiN57w@qUGGbir+a?9(hwxM6$L!KYIJ93%D_t$Cjv^#S%pkW28z~9VU
z>>Z%QhFkO11Ip8W1mBFkG3n=$^vXvMln7dWB5
z;4dTBkFE9&Q(_Q~Oj-Ah-N5lT^NamdKI;Vst
E0DqvmiU0rr
literal 0
HcmV?d00001
diff --git a/Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_rewinding.png b/Resources/Textures/Objects/Devices/tape_recorder.rsi/taperecorder_rewinding.png
new file mode 100644
index 0000000000000000000000000000000000000000..3e82112584a0771587d6c84efe963ee9ec87a709
GIT binary patch
literal 887
zcmV--1Bm>IP)+b
zC3;gxK?IS4WqwR)SrcI?%a09)oW{D^Aa>67zVm%KRL>8_*?8VP|7QA7T~1)N&0!*4NUmTk$QT+F1qQWL#tu
zWa=|5Dk-aoTdh_oxpv*S#byNn#54_?p%7f*2&Tf@LK`4UpXm$$fWx_VjE#-y#`*?_
zu)OdI0N@Ho@Zv%Ps$afkO>L?^a|23COY!F2v~KKS?|rD9H