From 68ffe42dbb98437732c1d5a67d3c47b8610e3115 Mon Sep 17 00:00:00 2001
From: rhailrake <49613070+rhailrake@users.noreply.github.com>
Date: Thu, 4 May 2023 13:43:03 +0600
Subject: [PATCH] [feat]jukebox (#9)

---
 Content.Client/Entry/EntryPoint.cs            |   3 +
 Content.Client/IoC/ClientContentIoC.cs        |   2 +
 Content.Client/Options/UI/Tabs/AudioTab.xaml  |  13 +
 .../Options/UI/Tabs/AudioTab.xaml.cs          |  16 +
 Content.Client/White/CheZaHuetaSystem.cs      |  10 +
 .../Jukebox/ClientJukeboxSongsSyncManager.cs  |  11 +
 Content.Client/White/Jukebox/JukeboxBUI.cs    |  70 +++++
 Content.Client/White/Jukebox/JukeboxMenu.xaml |  29 ++
 .../White/Jukebox/JukeboxMenu.xaml.cs         | 100 +++++++
 .../White/Jukebox/JukeboxSongEntry.xaml       |  13 +
 .../White/Jukebox/JukeboxSongEntry.xaml.cs    |  25 ++
 Content.Client/White/Jukebox/JukeboxSystem.cs | 277 ++++++++++++++++++
 .../White/Jukebox/TapeCreatorBUI.cs           |  51 ++++
 .../White/Jukebox/TapeCreatorMenu.xaml        |  16 +
 .../White/Jukebox/TapeCreatorMenu.xaml.cs     | 125 ++++++++
 .../White/Jukebox/TapeCreatorSystem.cs        |  41 +++
 Content.Server/Entry/EntryPoint.cs            |   2 +
 Content.Server/IoC/ServerContentIoC.cs        |   2 +
 Content.Server/White/Jukebox/JukeboxSystem.cs | 207 +++++++++++++
 .../Jukebox/ServerJukeboxSongsSyncManager.cs  |  60 ++++
 .../White/Jukebox/TapeCreatorSystem.cs        | 181 ++++++++++++
 .../White/Jukebox/JukeboxBUIMessagess.cs      |  20 ++
 .../Jukebox/JukeboxComponentsAndStuff.cs      | 133 +++++++++
 .../White/Jukebox/JukeboxSharedSystem.cs      |  37 +++
 .../White/Jukebox/JukeboxSongsSyncManager.cs  |  29 ++
 Content.Shared/White/Jukebox/TapeComponent.cs |  17 ++
 .../White/Jukebox/TapeCreatorComponent.cs     |  29 ++
 Content.Shared/White/WhiteCVars.cs            |  13 +
 .../Audio/White/Jukebox/Tapes/tape_fall.ogg   | Bin 0 -> 11549 bytes
 .../White/JukeboxAndStuff/jukebox_stuff.yml   |  52 ++++
 .../White/JukeboxAndStuff/tapes.yml           |  27 ++
 Resources/Prototypes/tags.yml                 |   3 +
 .../Interface/VerbIcons/remove_tape.png       | Bin 0 -> 973 bytes
 .../Devices/jukeboxStuff/tape.rsi/meta.json   |  12 +
 .../Devices/jukeboxStuff/tape.rsi/tape.png    | Bin 0 -> 656 bytes
 35 files changed, 1626 insertions(+)
 create mode 100644 Content.Client/White/CheZaHuetaSystem.cs
 create mode 100644 Content.Client/White/Jukebox/ClientJukeboxSongsSyncManager.cs
 create mode 100644 Content.Client/White/Jukebox/JukeboxBUI.cs
 create mode 100644 Content.Client/White/Jukebox/JukeboxMenu.xaml
 create mode 100644 Content.Client/White/Jukebox/JukeboxMenu.xaml.cs
 create mode 100644 Content.Client/White/Jukebox/JukeboxSongEntry.xaml
 create mode 100644 Content.Client/White/Jukebox/JukeboxSongEntry.xaml.cs
 create mode 100644 Content.Client/White/Jukebox/JukeboxSystem.cs
 create mode 100644 Content.Client/White/Jukebox/TapeCreatorBUI.cs
 create mode 100644 Content.Client/White/Jukebox/TapeCreatorMenu.xaml
 create mode 100644 Content.Client/White/Jukebox/TapeCreatorMenu.xaml.cs
 create mode 100644 Content.Client/White/Jukebox/TapeCreatorSystem.cs
 create mode 100644 Content.Server/White/Jukebox/JukeboxSystem.cs
 create mode 100644 Content.Server/White/Jukebox/ServerJukeboxSongsSyncManager.cs
 create mode 100644 Content.Server/White/Jukebox/TapeCreatorSystem.cs
 create mode 100644 Content.Shared/White/Jukebox/JukeboxBUIMessagess.cs
 create mode 100644 Content.Shared/White/Jukebox/JukeboxComponentsAndStuff.cs
 create mode 100644 Content.Shared/White/Jukebox/JukeboxSharedSystem.cs
 create mode 100644 Content.Shared/White/Jukebox/JukeboxSongsSyncManager.cs
 create mode 100644 Content.Shared/White/Jukebox/TapeComponent.cs
 create mode 100644 Content.Shared/White/Jukebox/TapeCreatorComponent.cs
 create mode 100644 Resources/Audio/White/Jukebox/Tapes/tape_fall.ogg
 create mode 100644 Resources/Prototypes/White/JukeboxAndStuff/jukebox_stuff.yml
 create mode 100644 Resources/Prototypes/White/JukeboxAndStuff/tapes.yml
 create mode 100644 Resources/Textures/Interface/VerbIcons/remove_tape.png
 create mode 100644 Resources/Textures/Objects/Devices/jukeboxStuff/tape.rsi/meta.json
 create mode 100644 Resources/Textures/Objects/Devices/jukeboxStuff/tape.rsi/tape.png

diff --git a/Content.Client/Entry/EntryPoint.cs b/Content.Client/Entry/EntryPoint.cs
index c45ca75acd..cbbcf93041 100644
--- a/Content.Client/Entry/EntryPoint.cs
+++ b/Content.Client/Entry/EntryPoint.cs
@@ -22,6 +22,7 @@ using Content.Client.Stylesheets;
 using Content.Client.Viewport;
 using Content.Client.Voting;
 using Content.Client.White.JoinQueue;
+using Content.Client.White.Jukebox;
 using Content.Client.White.Sponsors;
 using Content.Shared.Ame;
 using Content.Client.White.Stalin;
@@ -78,6 +79,7 @@ namespace Content.Client.Entry
         [Dependency] private readonly SponsorsManager _sponsorsManager = default!;
         [Dependency] private readonly JoinQueueManager _queueManager = default!;
         [Dependency] private readonly StalinManager _stalinManager = default!;
+        [Dependency] private readonly ClientJukeboxSongsSyncManager _jukeboxSyncManager = default!;
         //WD-EDIT
 
         public override void Init()
@@ -183,6 +185,7 @@ namespace Content.Client.Entry
             //WD-EDIT
             _sponsorsManager.Initialize();
             _queueManager.Initialize();
+            _jukeboxSyncManager.Initialize();
             //WD-EDIT
 
             _baseClient.RunLevelChanged += (_, args) =>
diff --git a/Content.Client/IoC/ClientContentIoC.cs b/Content.Client/IoC/ClientContentIoC.cs
index 1b87016c3f..c0e3529064 100644
--- a/Content.Client/IoC/ClientContentIoC.cs
+++ b/Content.Client/IoC/ClientContentIoC.cs
@@ -18,6 +18,7 @@ using Content.Shared.Administration.Logs;
 using Content.Client.Guidebook;
 using Content.Client.Replay;
 using Content.Client.White.JoinQueue;
+using Content.Client.White.Jukebox;
 using Content.Client.White.Sponsors;
 using Content.Client.White.Stalin;
 using Content.Shared.Administration.Managers;
@@ -53,6 +54,7 @@ namespace Content.Client.IoC
             IoCManager.Register<JoinQueueManager>();
             IoCManager.Register<SponsorsManager>();
             IoCManager.Register<StalinManager>();
+            IoCManager.Register<ClientJukeboxSongsSyncManager>();
             //WD-EDIT
         }
     }
diff --git a/Content.Client/Options/UI/Tabs/AudioTab.xaml b/Content.Client/Options/UI/Tabs/AudioTab.xaml
index 638c2d0e1b..f9766e3e3c 100644
--- a/Content.Client/Options/UI/Tabs/AudioTab.xaml
+++ b/Content.Client/Options/UI/Tabs/AudioTab.xaml
@@ -74,6 +74,19 @@
                     <Label Name="TtsVolumeLabel" MinSize="48 0" Align="Right" />
                     <Control MinSize="4 0"/>
                 </BoxContainer>
+                <BoxContainer Orientation="Horizontal" Margin="5 0 0 0">
+                    <Label Text="{Loc 'ui-options-jukebox-volume'}" HorizontalExpand="True" />
+                    <Control MinSize="8 0" />
+                    <Slider Name="JukeboxVolumeSlider"
+                            MinValue="25"
+                            MaxValue="200"
+                            HorizontalExpand="True"
+                            MinSize="80 0"
+                            Rounded="True" />
+                    <Control MinSize="8 0" />
+                    <Label Name="JukeboxVolumeLabel" MinSize="48 0" Align="Right" />
+                    <Control MinSize="4 0"/>
+                </BoxContainer>
                 <BoxContainer Orientation="Horizontal" Margin="5 0 0 0">
                     <Label Text="{Loc 'ui-options-lobby-volume'}" HorizontalExpand="True" />
                     <Control MinSize="8 0" />
diff --git a/Content.Client/Options/UI/Tabs/AudioTab.xaml.cs b/Content.Client/Options/UI/Tabs/AudioTab.xaml.cs
index 189abbbd8f..57dc576924 100644
--- a/Content.Client/Options/UI/Tabs/AudioTab.xaml.cs
+++ b/Content.Client/Options/UI/Tabs/AudioTab.xaml.cs
@@ -39,6 +39,7 @@ namespace Content.Client.Options.UI.Tabs
             LobbyVolumeSlider.OnValueChanged += OnLobbyVolumeSliderChanged;
             TtsVolumeSlider.OnValueChanged += OnTtsVolumeSliderChanged;
             InterfaceVolumeSlider.OnValueChanged += OnInterfaceVolumeSliderChanged;
+            JukeboxVolumeSlider.OnValueChanged += OnJukeboxVolumeSliderChanged;
             LobbyMusicCheckBox.OnToggled += OnLobbyMusicCheckToggled;
             RestartSoundsCheckBox.OnToggled += OnRestartSoundsCheckToggled;
             EventMusicCheckBox.OnToggled += OnEventMusicCheckToggled;
@@ -63,6 +64,7 @@ namespace Content.Client.Options.UI.Tabs
 
             //WD-EDIT
             TtsVolumeSlider.OnValueChanged -= OnTtsVolumeSliderChanged;
+            JukeboxVolumeSlider.OnValueChanged -= OnJukeboxVolumeSliderChanged;
             //WD-EDIT
 
             base.Dispose(disposing);
@@ -76,6 +78,13 @@ namespace Content.Client.Options.UI.Tabs
         }
         //TTS-End
 
+        //JUKEBOX
+        private void OnJukeboxVolumeSliderChanged(Range obj)
+        {
+            UpdateChanges();
+        }
+        //JUKEBOX
+
         private void OnLobbyVolumeSliderChanged(Range obj)
         {
             UpdateChanges();
@@ -150,6 +159,7 @@ namespace Content.Client.Options.UI.Tabs
 
             //WD-EDIT
             _cfg.SetCVar(WhiteCVars.TtsVolume, LV100ToDB(TtsVolumeSlider.Value));
+            _cfg.SetCVar(WhiteCVars.JukeboxVolume, LV100ToDB(JukeboxVolumeSlider.Value));
             //WD-EDIT
 
             _cfg.SaveToFile();
@@ -179,6 +189,7 @@ namespace Content.Client.Options.UI.Tabs
 
             //WD-EDIT
             TtsVolumeSlider.Value = DBToLV100(_cfg.GetCVar(WhiteCVars.TtsVolume));
+            JukeboxVolumeSlider.Value = DBToLV100(_cfg.GetCVar(WhiteCVars.JukeboxVolume));
             //WD-EDIT
 
 
@@ -222,6 +233,8 @@ namespace Content.Client.Options.UI.Tabs
             //WD-EDIT
             var isTtsVolumeSame =
                 Math.Abs(TtsVolumeSlider.Value - DBToLV100(_cfg.GetCVar(WhiteCVars.TtsVolume))) < 0.01f;
+            var isJukeboxVolumeSame =
+                Math.Abs(JukeboxVolumeSlider.Value - DBToLV100(_cfg.GetCVar(WhiteCVars.JukeboxVolume))) < 0.01f;
             //WD-EDIT
 
             var isRestartSoundsSame = RestartSoundsCheckBox.Pressed == _cfg.GetCVar(CCVars.RestartSoundsEnabled);
@@ -230,6 +243,7 @@ namespace Content.Client.Options.UI.Tabs
             var isEverythingSame = isMasterVolumeSame && isMidiVolumeSame && isAmbientVolumeSame && isAmbientMusicVolumeSame && isAmbientSoundsSame && isLobbySame && isRestartSoundsSame && isEventSame
                 && isAdminSoundsSame && isLobbyVolumeSame && isInterfaceVolumeSame;
             isEverythingSame = isEverythingSame && isTtsVolumeSame; //WD-EDIT
+            isEverythingSame = isEverythingSame && isTtsVolumeSame && isJukeboxVolumeSame; //WD-EDIT
             ApplyButton.Disabled = isEverythingSame;
             ResetButton.Disabled = isEverythingSame;
             MasterVolumeLabel.Text =
@@ -249,6 +263,8 @@ namespace Content.Client.Options.UI.Tabs
             //WD-EDIT
             TtsVolumeLabel.Text =
                 Loc.GetString("ui-options-volume-percent", ("volume", TtsVolumeSlider.Value / 100));
+            JukeboxVolumeLabel.Text =
+                Loc.GetString("ui-options-volume-percent", ("volume", JukeboxVolumeSlider.Value / 100));
             //WD-EDIT
         }
     }
diff --git a/Content.Client/White/CheZaHuetaSystem.cs b/Content.Client/White/CheZaHuetaSystem.cs
new file mode 100644
index 0000000000..d40e2459ab
--- /dev/null
+++ b/Content.Client/White/CheZaHuetaSystem.cs
@@ -0,0 +1,10 @@
+namespace Content.Client.White;
+
+//Система со смешным названием, чье предназначение заключается лишь в одном - отправке нетворк ивентов.
+public sealed class CheZaHuetaSystem : EntitySystem
+{
+    public void SendNetMessage(EntityEventArgs message)
+    {
+        RaiseNetworkEvent(message);
+    }
+}
diff --git a/Content.Client/White/Jukebox/ClientJukeboxSongsSyncManager.cs b/Content.Client/White/Jukebox/ClientJukeboxSongsSyncManager.cs
new file mode 100644
index 0000000000..685d10492f
--- /dev/null
+++ b/Content.Client/White/Jukebox/ClientJukeboxSongsSyncManager.cs
@@ -0,0 +1,11 @@
+using Content.Shared.White.Jukebox;
+
+namespace Content.Client.White.Jukebox;
+
+public sealed class ClientJukeboxSongsSyncManager : JukeboxSongsSyncManager
+{
+    public override void OnSongUploaded(JukeboxSongUploadNetMessage message)
+    {
+        ContentRoot.AddOrUpdateFile(message.RelativePath!, message.Data);
+    }
+}
diff --git a/Content.Client/White/Jukebox/JukeboxBUI.cs b/Content.Client/White/Jukebox/JukeboxBUI.cs
new file mode 100644
index 0000000000..7e5cda8b49
--- /dev/null
+++ b/Content.Client/White/Jukebox/JukeboxBUI.cs
@@ -0,0 +1,70 @@
+using Content.Shared.Popups;
+using Content.Shared.White.Jukebox;
+using Robust.Client.GameObjects;
+using Robust.Client.UserInterface.Controls;
+
+namespace Content.Client.White.Jukebox;
+
+public sealed class JukeboxBUI : BoundUserInterface
+{
+    [Dependency] private readonly EntityManager _entityManager = default!;
+    private readonly SharedPopupSystem _sharedPopupSystem = default!;
+
+    private JukeboxMenu? _window;
+    public JukeboxBUI(ClientUserInterfaceComponent owner, Enum uiKey) : base(owner, uiKey)
+    {
+        IoCManager.InjectDependencies(this);
+        _sharedPopupSystem = _entityManager.System<SharedPopupSystem>();
+
+        var uid = owner.Owner;
+
+        if (!_entityManager.TryGetComponent<JukeboxComponent>(uid, out var jukeboxComponent))
+        {
+            _sharedPopupSystem.PopupEntity($"Тут нет JukeboxComponent, звоните кодерам", uid);
+            return;
+        }
+
+        _window = new JukeboxMenu(jukeboxComponent);
+        _window.RepeatButton.OnToggled += OnRepeatButtonToggled;
+        _window.StopButton.OnPressed += OnStopButtonPressed;
+        _window.EjectButton.OnPressed += OnEjectButtonPressed;
+    }
+
+    private void OnEjectButtonPressed(BaseButton.ButtonEventArgs obj)
+    {
+        SendMessage(new JukeboxEjectRequest());
+    }
+
+    private void OnStopButtonPressed(BaseButton.ButtonEventArgs obj)
+    {
+        SendMessage(new JukeboxStopRequest());
+    }
+
+    private void OnRepeatButtonToggled(BaseButton.ButtonToggledEventArgs obj)
+    {
+        SendMessage(new JukeboxRepeatToggled(obj.Pressed));
+    }
+
+
+    protected override void Open()
+    {
+        base.Open();
+
+        if (_window == null)
+        {
+            Close();
+            return;
+        }
+
+        _window.OpenCentered();
+        _window.OnClose += Close;
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        if (!disposing) return;
+
+        _window?.Dispose();
+    }
+}
diff --git a/Content.Client/White/Jukebox/JukeboxMenu.xaml b/Content.Client/White/Jukebox/JukeboxMenu.xaml
new file mode 100644
index 0000000000..7cd3a88745
--- /dev/null
+++ b/Content.Client/White/Jukebox/JukeboxMenu.xaml
@@ -0,0 +1,29 @@
+<DefaultWindow xmlns="https://spacestation14.io" MinSize="600 700" Name="BoomBoxWindow" Title="Альфа-Шкварки">
+    <BoxContainer Orientation="Vertical" HorizontalExpand="True" VerticalExpand="True">
+        <Label Name="CurrenSongLabel" HorizontalAlignment="Center" HorizontalExpand="True"></Label>
+        <BoxContainer Orientation="Horizontal" HorizontalAlignment="Center">
+            <Button Access="Internal" Name="StopButton" Text="Остановить" HorizontalAlignment="Right"></Button>
+            <Button Access="Internal" Name="RepeatButton" Text="Повторять" HorizontalAlignment="Right" ToggleMode="True"></Button>
+            <Button Access="Internal" Name="EjectButton" Text="Извлечь"></Button>
+        </BoxContainer>
+
+        <TabContainer VerticalExpand="True" HorizontalExpand="True">
+            <!-- <ScrollContainer Name="DefaultSongsTab"
+                             HScrollEnabled="False">
+                <BoxContainer Name="DefaultSongsContainer"
+                              Orientation="Vertical"
+                              Margin="2 2 0 0"
+                              HorizontalExpand="True">
+                </BoxContainer>
+            </ScrollContainer> -->
+            <ScrollContainer Name="TapeSongsTab"
+                             HScrollEnabled="False">
+                <BoxContainer Name="TapeSongsContainer"
+                              Orientation="Vertical"
+                              Margin="2 2 0 0"
+                              HorizontalExpand="True">
+                </BoxContainer>
+            </ScrollContainer>
+        </TabContainer>
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/White/Jukebox/JukeboxMenu.xaml.cs b/Content.Client/White/Jukebox/JukeboxMenu.xaml.cs
new file mode 100644
index 0000000000..959a969a6d
--- /dev/null
+++ b/Content.Client/White/Jukebox/JukeboxMenu.xaml.cs
@@ -0,0 +1,100 @@
+using System.Linq;
+using Content.Shared.White.Jukebox;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Timing;
+using TerraFX.Interop.Windows;
+
+namespace Content.Client.White.Jukebox;
+
+[GenerateTypedNameReferences]
+public sealed partial class JukeboxMenu : DefaultWindow
+{
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+    private readonly JukeboxSystem _jukeboxSystem = default!;
+
+    private readonly JukeboxComponent _component;
+
+    private List<JukeboxSongEntry> _defaultSongsEntries = new();
+    private List<JukeboxSongEntry> _tapeSongsEntries = new();
+
+    public JukeboxMenu(JukeboxComponent component)
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        _jukeboxSystem = _entityManager.System<JukeboxSystem>();
+
+        _component = component;
+
+        /*TabContainer.SetTabTitle(DefaultSongsTab, "Прямо с завода");*/
+        TabContainer.SetTabTitle(TapeSongsTab, "Песенки с кассеты");
+
+        /*PopulateDefaultSongsContainer(DefaultSongsContainer);*/
+        PopulateTapeSongsContainer(TapeSongsContainer);
+    }
+
+    protected override void FrameUpdate(FrameEventArgs args)
+    {
+        CurrenSongLabel.Text = _component.PlayingSongData == null ? "..." : _component.PlayingSongData.SongName!;
+
+        RepeatButton.Pressed = _component.Repeating;
+
+        base.FrameUpdate(args);
+    }
+
+    private void PopulateDefaultSongsContainer(BoxContainer defaultSongsContainer)
+    {
+        var tapes = _component.DefaultSongsContainer.ContainedEntities.ToList();
+
+        foreach (var tapeUid in tapes)
+        {
+            if (_entityManager.TryGetComponent<TapeComponent>(tapeUid, out var tape))
+            {
+                foreach (var song in tape.Songs)
+                {
+                    var songEntry = new JukeboxSongEntry(song, RequestSongPlay);
+
+                    _defaultSongsEntries.Add(songEntry);
+                }
+            }
+        }
+
+        _defaultSongsEntries.Sort((x,y ) => string.Compare(x.Name!, y.Name!, StringComparison.Ordinal));
+
+        foreach (var defaultSongsEntry in _defaultSongsEntries)
+        {
+            defaultSongsContainer.AddChild(defaultSongsEntry);
+        }
+    }
+
+    private void PopulateTapeSongsContainer(BoxContainer tapeSongsContainer)
+    {
+        var tapes = _component.TapeContainer.ContainedEntities.ToList();
+
+        foreach (var tapeUid in tapes)
+        {
+            if (_entityManager.TryGetComponent<TapeComponent>(tapeUid, out var tape))
+            {
+                foreach (var song in tape.Songs)
+                {
+                    var songEntry = new JukeboxSongEntry(song, RequestSongPlay);
+
+                    _tapeSongsEntries.Add(songEntry);
+                }
+            }
+        }
+
+        foreach (var tapeSongsEntry in _tapeSongsEntries)
+        {
+            tapeSongsContainer.AddChild(tapeSongsEntry);
+        }
+    }
+
+    private void RequestSongPlay(JukeboxSong song)
+    {
+        _jukeboxSystem.RequestSongToPlay(_component, song);
+    }
+}
diff --git a/Content.Client/White/Jukebox/JukeboxSongEntry.xaml b/Content.Client/White/Jukebox/JukeboxSongEntry.xaml
new file mode 100644
index 0000000000..ac1a618eed
--- /dev/null
+++ b/Content.Client/White/Jukebox/JukeboxSongEntry.xaml
@@ -0,0 +1,13 @@
+<Control xmlns="https://spacestation14.io"
+         xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client">
+    <PanelContainer MaxHeight="32" HorizontalExpand="True" Margin="2 2 2 2">
+        <PanelContainer.PanelOverride>
+            <gfx:StyleBoxFlat BackgroundColor="#7B7E7E"></gfx:StyleBoxFlat>
+        </PanelContainer.PanelOverride>
+
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True" >
+            <Label Name="SongNameLabel" HorizontalAlignment="Left" HorizontalExpand="True"></Label>
+            <Button Name="PlaySongButton" HorizontalAlignment="Right" Text="Запустить"></Button>
+        </BoxContainer>
+    </PanelContainer>
+</Control>
diff --git a/Content.Client/White/Jukebox/JukeboxSongEntry.xaml.cs b/Content.Client/White/Jukebox/JukeboxSongEntry.xaml.cs
new file mode 100644
index 0000000000..928f5607ad
--- /dev/null
+++ b/Content.Client/White/Jukebox/JukeboxSongEntry.xaml.cs
@@ -0,0 +1,25 @@
+using Content.Shared.White.Jukebox;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.XAML;
+
+namespace Content.Client.White.Jukebox;
+
+[GenerateTypedNameReferences]
+public sealed partial class JukeboxSongEntry : Control
+{
+    public JukeboxSong? Song { get; private set; }
+
+    private JukeboxSongEntry()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+    }
+
+    public JukeboxSongEntry(JukeboxSong song, Action<JukeboxSong> callback) : this()
+    {
+        Song = song;
+        SongNameLabel.Text = Song.SongName;
+        PlaySongButton.OnPressed += _ => callback.Invoke(Song);
+    }
+}
diff --git a/Content.Client/White/Jukebox/JukeboxSystem.cs b/Content.Client/White/Jukebox/JukeboxSystem.cs
new file mode 100644
index 0000000000..5fe5f541f3
--- /dev/null
+++ b/Content.Client/White/Jukebox/JukeboxSystem.cs
@@ -0,0 +1,277 @@
+using System.Resources;
+using Content.Shared.GameTicking;
+using Content.Shared.Interaction.Events;
+using Content.Shared.White;
+using Content.Shared.White.Jukebox;
+using Robust.Client.Audio;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Physics;
+using Robust.Client.Player;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Audio;
+using Robust.Shared.Configuration;
+using Robust.Shared.ContentPack;
+using Robust.Shared.GameStates;
+using Robust.Shared.Utility;
+
+namespace Content.Client.White.Jukebox;
+
+public sealed class JukeboxSystem : EntitySystem
+{
+
+    [Dependency] private readonly SharedAudioSystem _audioSystem = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IResourceCache _resource = default!;
+    [Dependency] private readonly IConfigurationManager _cfg = default!;
+
+
+
+
+    private readonly Dictionary<JukeboxComponent, JukeboxAudio> _playingJukeboxes = new();
+
+    private float _maxAudioRange;
+    private float _jukeboxVolume;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        _cfg.OnValueChanged(WhiteCVars.MaxJukeboxSoundRange, range => _maxAudioRange = range, true);
+        _cfg.OnValueChanged(WhiteCVars.JukeboxVolume, volume => JukeboxVolumeChanged(volume), true);
+
+        SubscribeLocalEvent<JukeboxComponent, ComponentHandleState>(OnStateChanged);
+        SubscribeLocalEvent<JukeboxComponent, ComponentRemove>(OnComponentRemoved);
+        SubscribeNetworkEvent<RoundRestartCleanupEvent>(OnRoundRestart);
+        SubscribeNetworkEvent<TickerJoinLobbyEvent>(JoinLobby);
+        SubscribeNetworkEvent<JukeboxStopPlaying>(OnStopPlaying);
+    }
+
+    private void JukeboxVolumeChanged(float volume)
+    {
+        _jukeboxVolume = volume;
+
+        CleanUp();
+    }
+
+    private void JoinLobby(TickerJoinLobbyEvent ev)
+    {
+        CleanUp();
+    }
+
+    private void OnRoundRestart(RoundRestartCleanupEvent ev)
+    {
+        CleanUp();
+    }
+
+    private void OnComponentRemoved(EntityUid uid, JukeboxComponent component, ComponentRemove args)
+    {
+        if (!_playingJukeboxes.TryGetValue(component, out var playingData)) return;
+        playingData.PlayingStream.Stop();
+        _playingJukeboxes.Remove(component);
+    }
+
+    private void OnStopPlaying(JukeboxStopPlaying ev)
+    {
+        if (!ev.JukeboxUid.HasValue) return;
+        if(!TryComp<JukeboxComponent>(ev.JukeboxUid, out var jukeboxComponent)) return;
+
+        if(!_playingJukeboxes.TryGetValue(jukeboxComponent, out var jukeboxAudio)) return;
+
+        jukeboxAudio.PlayingStream.Stop();
+        _playingJukeboxes.Remove(jukeboxComponent);
+    }
+
+    public void RequestSongToPlay(JukeboxComponent component, JukeboxSong jukeboxSong)
+    {
+        if (!_resource.TryGetResource<AudioResource>((ResPath) jukeboxSong.SongPath!, out var songResource))
+        {
+            return;
+        }
+
+        RaiseNetworkEvent(new JukeboxRequestSongPlay()
+        {
+            Jukebox = component.Owner,
+            SongName = jukeboxSong.SongName,
+            SongPath = jukeboxSong.SongPath,
+            SongDuration = (float)songResource.AudioStream.Length.TotalSeconds
+        });
+
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var localPlayerEntity = _playerManager.LocalPlayer!.ControlledEntity;
+        if(!localPlayerEntity.HasValue) return;
+
+        ProcessJukeboxes();
+    }
+
+    private void OnStateChanged(EntityUid uid, JukeboxComponent component, ref ComponentHandleState args)
+    {
+        if (args.Current is JukeboxComponentState state)
+        {
+            component.Repeating = state.Playing;
+            component.Volume = state.Volume;
+            component.PlayingSongData = state.SongData;
+        }
+    }
+
+    private void ProcessJukeboxes()
+    {
+        var jukeboxes = EntityQuery<JukeboxComponent, TransformComponent>();
+        var playerXform = Comp<TransformComponent>(_playerManager.LocalPlayer!.ControlledEntity!.Value);
+
+        foreach (var (jukeboxComponent, jukeboxXform) in jukeboxes)
+        {
+
+            if(jukeboxXform.MapID != playerXform.MapID) continue;
+            if ((jukeboxXform.MapPosition.Position - playerXform.MapPosition.Position).Length > _maxAudioRange) continue;
+
+            if (_playingJukeboxes.TryGetValue(jukeboxComponent, out var jukeboxAudio))
+            {
+                if (jukeboxAudio.PlayingStream.Done)
+                {
+                    HandleDoneStream(jukeboxAudio, jukeboxComponent);
+                    return;
+                }
+
+                if (jukeboxAudio.SongData.SongPath != jukeboxComponent.PlayingSongData?.SongPath)
+                {
+                    HandleSongChanged(jukeboxAudio, jukeboxComponent);
+                    return;
+                }
+            }
+            else
+            {
+                if (jukeboxComponent.PlayingSongData == null)
+                {
+                    SetBarsLayerVisible(jukeboxComponent, false);
+                    continue;
+                }
+
+                var stream = TryCreateStream(jukeboxComponent);
+
+                if (stream == null)
+                {
+                    return;
+                }
+
+                _playingJukeboxes.Add(jukeboxComponent, stream);
+                SetBarsLayerVisible(jukeboxComponent, true);
+            }
+        }
+    }
+
+    private void HandleSongChanged(JukeboxAudio jukeboxAudio, JukeboxComponent jukeboxComponent)
+    {
+        jukeboxAudio.PlayingStream.Stop();
+
+        if (jukeboxComponent.PlayingSongData != null && jukeboxComponent.PlayingSongData.SongPath == jukeboxAudio.SongData.SongPath)
+        {
+            var newStream = TryCreateStream(jukeboxComponent);
+            if(newStream == null) return;
+
+            _playingJukeboxes[jukeboxComponent] = newStream;
+            SetBarsLayerVisible(jukeboxComponent, true);
+        }
+        else
+        {
+            _playingJukeboxes.Remove(jukeboxComponent);
+            SetBarsLayerVisible(jukeboxComponent, false);
+        }
+    }
+
+    private void HandleDoneStream(JukeboxAudio jukeboxAudio, JukeboxComponent jukeboxComponent)
+    {
+        if (!jukeboxComponent.Repeating)
+        {
+            jukeboxAudio.PlayingStream.Stop();
+            _playingJukeboxes.Remove(jukeboxComponent);
+            SetBarsLayerVisible(jukeboxComponent, false);
+            return;
+        }
+
+        if(jukeboxComponent.PlayingSongData == null) return;
+
+
+        var newStream = TryCreateStream(jukeboxComponent);
+
+        if (newStream == null)
+        {
+            _playingJukeboxes.Remove(jukeboxComponent);
+            SetBarsLayerVisible(jukeboxComponent, false);
+        }
+        else
+        {
+
+            _playingJukeboxes[jukeboxComponent] = newStream;
+            SetBarsLayerVisible(jukeboxComponent, true);
+        }
+    }
+
+    private JukeboxAudio? TryCreateStream(JukeboxComponent jukeboxComponent)
+    {
+        if (jukeboxComponent.PlayingSongData == null) return null;
+
+        var resourcePath = jukeboxComponent.PlayingSongData.SongPath!;
+        var localSession = _playerManager.LocalPlayer!.Session;
+
+        if(!_resource.TryGetResource<AudioResource>((ResPath) resourcePath, out var audio))
+            return null!;
+
+        if (audio!.AudioStream.Length.TotalSeconds < jukeboxComponent.PlayingSongData!.PlaybackPosition)
+        {
+            return null!;
+        }
+
+        var audioParams = new AudioParams
+        {
+            PlayOffsetSeconds = jukeboxComponent.PlayingSongData.PlaybackPosition,
+            Volume = _jukeboxVolume,
+            MaxDistance = _maxAudioRange
+        };
+
+        AudioSystem.PlayingStream? playingStream = null!;
+
+        playingStream = _audioSystem.PlayEntity(resourcePath.ToString()!, localSession, jukeboxComponent.Owner, audioParams) as AudioSystem.PlayingStream;
+
+        if (playingStream == null)
+            return null!;
+
+        return new JukeboxAudio(playingStream, audio!, jukeboxComponent.PlayingSongData);
+    }
+
+    private class JukeboxAudio
+    {
+        public PlayingSongData SongData { get; }
+        public AudioSystem.PlayingStream PlayingStream { get; }
+        public AudioResource AudioStream { get; }
+
+        public JukeboxAudio(AudioSystem.PlayingStream playingStream, AudioResource audioStream, PlayingSongData songData)
+        {
+            PlayingStream = playingStream;
+            AudioStream = audioStream;
+            SongData = songData;
+        }
+    }
+
+    private void SetBarsLayerVisible(JukeboxComponent jukeboxComponent, bool visible)
+    {
+        var spriteComponent = Comp<SpriteComponent>(jukeboxComponent.Owner);
+        spriteComponent.LayerMapTryGet("bars", out var layer);
+        spriteComponent.LayerSetVisible(layer, visible);
+    }
+
+    private void CleanUp()
+    {
+        foreach (var playingJukebox in _playingJukeboxes.Values)
+        {
+            playingJukebox.PlayingStream.Stop();
+        }
+
+        _playingJukeboxes.Clear();
+    }
+}
diff --git a/Content.Client/White/Jukebox/TapeCreatorBUI.cs b/Content.Client/White/Jukebox/TapeCreatorBUI.cs
new file mode 100644
index 0000000000..047b7b568f
--- /dev/null
+++ b/Content.Client/White/Jukebox/TapeCreatorBUI.cs
@@ -0,0 +1,51 @@
+using Content.Shared.Popups;
+using Content.Shared.White.Jukebox;
+using Robust.Client.GameObjects;
+
+namespace Content.Client.White.Jukebox;
+
+public sealed class TapeCreatorBUI : BoundUserInterface
+{
+    [Dependency] private readonly EntityManager _entityManager = default!;
+    private readonly SharedPopupSystem _sharedPopupSystem = default!;
+
+    private TapeCreatorMenu? _window;
+
+    public TapeCreatorBUI(ClientUserInterfaceComponent owner, Enum uiKey) : base(owner, uiKey)
+    {
+        IoCManager.InjectDependencies(this);
+        _sharedPopupSystem = _entityManager.System<SharedPopupSystem>();
+
+        var uid = owner.Owner;
+
+        if (!_entityManager.TryGetComponent<TapeCreatorComponent>(uid, out var tapeCreatorComponent))
+        {
+            _sharedPopupSystem.PopupEntity($"Тут нет TapeCreatorComponent, звоните кодерам", uid);
+            return;
+        }
+
+        _window = new TapeCreatorMenu(tapeCreatorComponent);
+    }
+
+    protected override void Open()
+    {
+        base.Open();
+
+        if (_window == null)
+        {
+            Close();
+            return;
+        }
+
+        _window.OpenCentered();
+        _window.OnClose += Close;
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        if (!disposing) return;
+
+        _window?.Dispose();
+    }
+}
diff --git a/Content.Client/White/Jukebox/TapeCreatorMenu.xaml b/Content.Client/White/Jukebox/TapeCreatorMenu.xaml
new file mode 100644
index 0000000000..519000ee87
--- /dev/null
+++ b/Content.Client/White/Jukebox/TapeCreatorMenu.xaml
@@ -0,0 +1,16 @@
+<DefaultWindow xmlns="https://spacestation14.io" MinSize="200 300" Title="Мысль">
+    <BoxContainer Orientation="Vertical" HorizontalExpand="True" VerticalExpand="True">
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="True" SetHeight="30">
+            <Label Text="Осталось циклов записи: "></Label>
+            <Label Name="CoinsLabel" Text="0"></Label>
+        </BoxContainer>
+        <BoxContainer Orientation="Vertical" SeparationOverride="5">
+            <BoxContainer Orientation="Horizontal" HorizontalExpand="True" SetHeight="30">
+                <Label Text="Название"></Label>
+                <LineEdit Name="SongNameField" MinWidth="200"></LineEdit>
+                <Button Name="LoadSongButton" Access="Internal" Text="Загрузить песню"></Button>
+            </BoxContainer>
+            <Button Name="UploadSong" Access="Internal" Text="Записать мозговую активность" MinHeight="50" HorizontalExpand="True"></Button>
+        </BoxContainer>
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/White/Jukebox/TapeCreatorMenu.xaml.cs b/Content.Client/White/Jukebox/TapeCreatorMenu.xaml.cs
new file mode 100644
index 0000000000..b000b30b51
--- /dev/null
+++ b/Content.Client/White/Jukebox/TapeCreatorMenu.xaml.cs
@@ -0,0 +1,125 @@
+using System.Text.RegularExpressions;
+using Content.Shared.CCVar;
+using Content.Shared.Popups;
+using Content.Shared.White;
+using Content.Shared.White.Jukebox;
+using JetBrains.Annotations;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Configuration;
+using Robust.Shared.Network;
+using Robust.Shared.Timing;
+using Robust.Shared.Utility;
+
+namespace Content.Client.White.Jukebox;
+
+[GenerateTypedNameReferences]
+public sealed partial class TapeCreatorMenu : DefaultWindow
+{
+    [Dependency] private readonly EntityManager _entityManager = default!;
+    [Dependency] private readonly IFileDialogManager _fileDialogManager = default!;
+    [Dependency] private readonly IConfigurationManager _cfg = default!;
+    private readonly CheZaHuetaSystem _huetaSystem = default!;
+    private readonly SharedPopupSystem _popupSystem = default!;
+
+    private bool _fileDialogOpened;
+    private double _maxFileSize;
+    private double _currentFileSize;
+    private readonly List<byte> _songBytes = new();
+    private TapeCreatorComponent _component;
+
+    private const double BytesToMegabytes = 0.000001d;
+
+    public TapeCreatorMenu(TapeCreatorComponent component)
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        _huetaSystem = _entityManager.System<CheZaHuetaSystem>();
+        _popupSystem = _entityManager.System<SharedPopupSystem>();
+
+        _cfg.OnValueChanged(WhiteCVars.MaxJukeboxSongSizeInMB, x => _maxFileSize = x, true);
+
+        _component = component;
+
+        LoadSongButton.OnPressed += TryLoadSong;
+        UploadSong.OnPressed += OnUploadButtonPressed;
+    }
+
+    private void OnUploadButtonPressed(BaseButton.ButtonEventArgs obj)
+    {
+        if(!CanUploadSong()) return;
+
+        var input = SongNameField.Text;
+
+        string pattern = @"[^a-zA-Zа-яА-Я ]+";
+        string replacement = "";
+
+        var songName = Regex.Replace(input, pattern, replacement);
+        songName = Regex.Replace(songName, @"\s+", " ");
+
+        var songBytes = _songBytes;
+
+        var msg = new JukeboxSongUploadRequest()
+        {
+            SongName = songName,
+            SongBytes = songBytes,
+            TapeCreatorUid = _component.Owner
+        };
+
+        _huetaSystem.SendNetMessage(msg);
+
+        _currentFileSize = 0;
+        _songBytes.Clear();
+        SongNameField.Clear();
+
+        _popupSystem.PopupEntity("Внимание. Начинается запись мозговой активности.", _component.Owner);
+    }
+
+    private async void TryLoadSong(BaseButton.ButtonEventArgs obj)
+    {
+        var fileFilter = new FileDialogFilters(new FileDialogFilters.Group("ogg"));
+
+        var file = await _fileDialogManager.OpenFile(fileFilter);
+
+        if (Disposed) return;
+
+        if(file == null) return;
+
+        _currentFileSize = file.Length * BytesToMegabytes;
+
+        if (_currentFileSize > _maxFileSize)
+        {
+            _popupSystem.PopupEntity($"Лимит активности мозговых волн превышен на {_currentFileSize - _maxFileSize} мегахрюков", _component.Owner);
+            return;
+        }
+
+        //TODO: Песня слишком длинная пиздец
+
+        _songBytes.AddRange(file.CopyToArray());
+    }
+
+    protected override void FrameUpdate(FrameEventArgs args)
+    {
+        base.FrameUpdate(args);
+
+        CoinsLabel.Text = _component.CoinBalance.ToString();
+
+        if (CanUploadSong())
+        {
+            UploadSong.Disabled = false;
+        }
+        else
+        {
+            UploadSong.Disabled = true;
+        }
+    }
+
+    private bool CanUploadSong()
+    {
+        return SongNameField.Text.Length > 0 && _songBytes.Count > 0 && _component.CoinBalance > 0 && _component.InsertedTape.HasValue && !_component.Recording;
+    }
+}
diff --git a/Content.Client/White/Jukebox/TapeCreatorSystem.cs b/Content.Client/White/Jukebox/TapeCreatorSystem.cs
new file mode 100644
index 0000000000..82db73a62e
--- /dev/null
+++ b/Content.Client/White/Jukebox/TapeCreatorSystem.cs
@@ -0,0 +1,41 @@
+ using Content.Shared.White.Jukebox;
+ using Robust.Client.GameObjects;
+ using Robust.Shared.GameStates;
+
+ namespace Content.Client.White.Jukebox;
+
+public sealed class TapeCreatorSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<TapeCreatorComponent, ComponentHandleState>(OnStateChanged);
+        SubscribeLocalEvent<TapeComponent, ComponentHandleState>(OnTapeStateChanged);
+    }
+
+    private void OnTapeStateChanged(EntityUid uid, TapeComponent component, ref ComponentHandleState args)
+    {
+        if (args.Current is not TapeComponentState state) return;
+
+        component.Songs = state.Songs;
+    }
+
+    private void OnStateChanged(EntityUid uid, TapeCreatorComponent component, ref ComponentHandleState args)
+    {
+        if (args.Current is not TapeCreatorComponentState state) return;
+
+        component.Recording = state.Recording;
+        component.CoinBalance = state.CoinBalance;
+        component.InsertedTape = state.InsertedTape;
+
+        SetTapeLayerVisible(component, state.InsertedTape.HasValue);
+    }
+
+    private void SetTapeLayerVisible(TapeCreatorComponent component, bool visible)
+    {
+        var spriteComponent = Comp<SpriteComponent>(component.Owner);
+        spriteComponent.LayerMapTryGet("tape", out var layer);
+        spriteComponent.LayerSetVisible(layer, visible);
+    }
+}
+
diff --git a/Content.Server/Entry/EntryPoint.cs b/Content.Server/Entry/EntryPoint.cs
index 8ace3d8001..18d44c5ff2 100644
--- a/Content.Server/Entry/EntryPoint.cs
+++ b/Content.Server/Entry/EntryPoint.cs
@@ -31,6 +31,7 @@ using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 using Content.Server.UtkaIntegration;
 using Content.Server.White.JoinQueue;
+using Content.Server.White.Jukebox;
 using Content.Server.White.Sponsors;
 using Content.Server.White.Stalin;
 using Content.Server.White.TTS;
@@ -113,6 +114,7 @@ namespace Content.Server.Entry
             IoCManager.Resolve<JoinQueueManager>().Initialize();
             IoCManager.Resolve<TTSManager>().Initialize();
             IoCManager.Resolve<StalinManager>().Initialize();
+            IoCManager.Resolve<ServerJukeboxSongsSyncManager>().Initialize();
             //WD-EDIT
 
             _voteManager.Initialize();
diff --git a/Content.Server/IoC/ServerContentIoC.cs b/Content.Server/IoC/ServerContentIoC.cs
index 7b3be4e694..5851d2651a 100644
--- a/Content.Server/IoC/ServerContentIoC.cs
+++ b/Content.Server/IoC/ServerContentIoC.cs
@@ -21,6 +21,7 @@ using Content.Server.Voting.Managers;
 using Content.Server.Worldgen.Tools;
 using Content.Server.UtkaIntegration;
 using Content.Server.White.JoinQueue;
+using Content.Server.White.Jukebox;
 using Content.Server.White.Sponsors;
 using Content.Server.White.Stalin;
 using Content.Server.White.TTS;
@@ -71,6 +72,7 @@ namespace Content.Server.IoC
             IoCManager.Register<UtkaTCPWrapper>();
             IoCManager.Register<TTSManager>();
             IoCManager.Register<StalinManager>();
+            IoCManager.Register<ServerJukeboxSongsSyncManager>();
             // WD-EDIT
         }
     }
diff --git a/Content.Server/White/Jukebox/JukeboxSystem.cs b/Content.Server/White/Jukebox/JukeboxSystem.cs
new file mode 100644
index 0000000000..df9f4455a4
--- /dev/null
+++ b/Content.Server/White/Jukebox/JukeboxSystem.cs
@@ -0,0 +1,207 @@
+using System.Linq;
+using Content.Shared.GameTicking;
+using Content.Shared.Hands.EntitySystems;
+using Content.Shared.Interaction;
+using Content.Shared.Verbs;
+using Content.Shared.White.Jukebox;
+using Robust.Server.GameObjects;
+using Robust.Server.GameStates;
+using Robust.Shared.Containers;
+using Robust.Shared.ContentPack;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Content.Server.White.Jukebox;
+
+public sealed class JukeboxSystem : EntitySystem
+{
+    [Dependency] private readonly AudioSystem _audioSystem = default!;
+    [Dependency] private readonly IResourceManager _resourceManager = default!;
+    [Dependency] private readonly SharedContainerSystem _containerSystem = default!;
+    [Dependency] private readonly SharedHandsSystem _handsSystem = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly PVSOverrideSystem _pvsOverrideSystem = default!;
+
+
+    private readonly List<JukeboxComponent> _playingJukeboxes = new();
+
+    private float _updateTimerDefaultTime = 1f;
+    private float _updateTimer;
+
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeNetworkEvent<JukeboxRequestSongPlay>(OnSongRequestPlay);
+        SubscribeLocalEvent<JukeboxComponent, InteractUsingEvent>(OnInteract);
+        SubscribeLocalEvent<JukeboxComponent, ComponentGetState>(OnGetState);
+        SubscribeLocalEvent<JukeboxComponent, JukeboxStopRequest>(OnRequestStop);
+        SubscribeLocalEvent<JukeboxComponent, JukeboxRepeatToggled>(OnRepeatToggled);
+        SubscribeLocalEvent<JukeboxComponent, JukeboxEjectRequest>(OnEjectRequest);
+        SubscribeLocalEvent<JukeboxComponent, GetVerbsEvent<Verb>>(OnGetVerb);
+        SubscribeLocalEvent<JukeboxComponent, ComponentInit>(OnInit);
+        SubscribeLocalEvent<RoundRestartCleanupEvent>(OnRoundRestart);
+    }
+
+    private void OnInit(EntityUid uid, JukeboxComponent component, ComponentInit args)
+    {
+        _pvsOverrideSystem.AddGlobalOverride(uid);
+    }
+
+    private void OnRoundRestart(RoundRestartCleanupEvent ev)
+    {
+        _playingJukeboxes.Clear();
+    }
+
+    private void OnEjectRequest(EntityUid uid, JukeboxComponent component, JukeboxEjectRequest args)
+    {
+        if(component.PlayingSongData != null) return;
+
+        var containedEntities = component.TapeContainer.ContainedEntities;
+
+        if (containedEntities.Count > 0)
+        {
+            _containerSystem.EmptyContainer(component.TapeContainer, true).ToList();
+        }
+    }
+
+    private void OnGetVerb(EntityUid uid, JukeboxComponent jukeboxComponent, GetVerbsEvent<Verb> ev)
+    {
+        if (ev.Hands == null) return;
+        if (jukeboxComponent.PlayingSongData != null) return;
+        if (jukeboxComponent.TapeContainer.ContainedEntities.Count == 0) return;
+
+        var removeTapeVerb = new Verb()
+        {
+            Text = "Вытащить касету",
+            Priority = 10000,
+            Icon = new SpriteSpecifier.Texture(new ResPath("/Textures/Interface/VerbIcons/remove_tape.png")),
+            Act = () =>
+            {
+                var tapes = jukeboxComponent.TapeContainer.ContainedEntities.ToList();
+                _containerSystem.EmptyContainer(jukeboxComponent.TapeContainer, true);
+
+                foreach (var tape in tapes)
+                {
+                    _handsSystem.PickupOrDrop(ev.User, tape);
+                }
+            }
+        };
+
+        ev.Verbs.Add(removeTapeVerb);
+    }
+
+    private void OnRepeatToggled(EntityUid uid, JukeboxComponent component, JukeboxRepeatToggled args)
+    {
+        component.Repeating = args.NewState;
+        Dirty(component);
+    }
+
+    private void OnRequestStop(EntityUid uid, JukeboxComponent component, JukeboxStopRequest args)
+    {
+        component.PlayingSongData = null;
+        Dirty(component);
+    }
+
+
+    private void OnInteract(EntityUid uid, JukeboxComponent component, InteractUsingEvent args)
+    {
+        if(component.PlayingSongData != null) return;
+
+        if (TryComp<TapeComponent>(args.Used, out var tape))
+        {
+            var containedEntities = component.TapeContainer.ContainedEntities;
+
+            if (containedEntities.Count >= 1)
+            {
+                var removedTapes = _containerSystem.EmptyContainer(component.TapeContainer, true).ToList();
+                component.TapeContainer.Insert(args.Used);
+
+                foreach (var tapeUid in removedTapes)
+                {
+                    _handsSystem.PickupOrDrop(args.User, tapeUid);
+                }
+            }
+            else
+            {
+                component.TapeContainer.Insert(args.Used);
+            }
+        }
+    }
+
+    private void OnSongRequestPlay(JukeboxRequestSongPlay msg, EntitySessionEventArgs args)
+    {
+        var jukebox = Comp<JukeboxComponent>(msg.Jukebox!.Value);
+        jukebox.Repeating = true;
+
+        var songData = new PlayingSongData()
+        {
+            SongName = msg.SongName,
+            SongPath = msg.SongPath,
+            ActualSongLengthSeconds = msg.SongDuration,
+            PlaybackPosition = 0f
+        };
+        jukebox.PlayingSongData = songData;
+
+        _playingJukeboxes.Add(jukebox);
+
+        Dirty(jukebox);
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        if (_updateTimer <= _updateTimerDefaultTime)
+        {
+            _updateTimer += frameTime;
+            return;
+        }
+
+        ProcessPlayingJukeboxes(frameTime);
+    }
+
+    private void ProcessPlayingJukeboxes(float frameTime)
+    {
+        for (int i = _playingJukeboxes.Count - 1; i >= 0; i--)
+        {
+            var playingJukeboxData = _playingJukeboxes[i];
+
+            if (playingJukeboxData.PlayingSongData == null)
+            {
+                _playingJukeboxes.RemoveAt(i);
+                continue;
+            }
+
+            playingJukeboxData.PlayingSongData.PlaybackPosition += _updateTimer;
+
+            if (playingJukeboxData.PlayingSongData.PlaybackPosition >= playingJukeboxData.PlayingSongData.ActualSongLengthSeconds)
+            {
+                if (playingJukeboxData.Repeating)
+                {
+                    playingJukeboxData.PlayingSongData.PlaybackPosition = 0;
+                }
+                else
+                {
+                    RaiseNetworkEvent(new JukeboxStopPlaying());
+                    _playingJukeboxes.RemoveAt(i);
+                }
+            }
+
+            Dirty(playingJukeboxData);
+        }
+
+        _updateTimer = 0;
+    }
+
+    private void OnGetState(EntityUid uid, JukeboxComponent component, ref ComponentGetState args)
+    {
+        args.State = new JukeboxComponentState()
+        {
+            SongData = component.PlayingSongData,
+            Playing = component.Repeating,
+            Volume = component.Volume
+        };
+    }
+}
diff --git a/Content.Server/White/Jukebox/ServerJukeboxSongsSyncManager.cs b/Content.Server/White/Jukebox/ServerJukeboxSongsSyncManager.cs
new file mode 100644
index 0000000000..07a8c59de3
--- /dev/null
+++ b/Content.Server/White/Jukebox/ServerJukeboxSongsSyncManager.cs
@@ -0,0 +1,60 @@
+using Content.Shared.White.Jukebox;
+using Robust.Shared.Network;
+using Robust.Shared.Utility;
+
+namespace Content.Server.White.Jukebox;
+
+public sealed class ServerJukeboxSongsSyncManager : JukeboxSongsSyncManager
+{
+    [Dependency] private readonly INetManager _netManager = default!;
+    public override void Initialize()
+    {
+        base.Initialize();
+        _netManager.Connected += OnClientConnected;
+    }
+
+    private void OnClientConnected(object? sender, NetChannelArgs e)
+    {
+        foreach (var (path, data) in ContentRoot.GetAllFiles())
+        {
+            var msg = new JukeboxSongUploadNetMessage
+            {
+                RelativePath = path,
+                Data = data
+            };
+
+            e.Channel.SendMessage(msg);
+        }
+    }
+
+    public (string songName, ResPath path) SyncSongData(string songName, List<byte> bytes)
+    {
+        if (ContentRoot.TryGetFile(new ResPath(songName + ".ogg"), out _))
+        {
+            songName += "a";
+        }
+
+        var msg = new JukeboxSongUploadNetMessage()
+        {
+            Data = bytes.ToArray(),
+            RelativePath = new ResPath(songName + ".ogg")
+        };
+
+        OnSongUploaded(msg);
+        var path = new ResPath($"{Prefix}/{songName}.ogg");
+        return (songName, path);
+
+    }
+
+
+    public override void OnSongUploaded(JukeboxSongUploadNetMessage message)
+    {
+
+        ContentRoot.AddOrUpdateFile(message.RelativePath, message.Data);
+
+        foreach (var channel in _netManager.Channels)
+        {
+            channel.SendMessage(message);
+        }
+    }
+}
diff --git a/Content.Server/White/Jukebox/TapeCreatorSystem.cs b/Content.Server/White/Jukebox/TapeCreatorSystem.cs
new file mode 100644
index 0000000000..edc6512d4c
--- /dev/null
+++ b/Content.Server/White/Jukebox/TapeCreatorSystem.cs
@@ -0,0 +1,181 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Content.Shared.CCVar;
+using Content.Shared.Hands.EntitySystems;
+using Content.Shared.Interaction;
+using Content.Shared.Popups;
+using Content.Shared.Tag;
+using Content.Shared.Verbs;
+using Content.Shared.White.Jukebox;
+using Robust.Shared.Configuration;
+using Robust.Shared.Containers;
+using Robust.Shared.GameStates;
+using Robust.Shared.Utility;
+
+namespace Content.Server.White.Jukebox;
+
+public sealed class TapeCreatorSystem : EntitySystem
+{
+    [Dependency] private readonly SharedPopupSystem _popupSystem = default!;
+    [Dependency] private readonly ServerJukeboxSongsSyncManager _songsSyncManager = default!;
+    [Dependency] private readonly SharedContainerSystem _containerSystem = default!;
+    [Dependency] private readonly SharedHandsSystem _handsSystem = default!;
+    [Dependency] private readonly TagSystem _tagSystem = default!;
+
+
+    private readonly int _recordTime = 25;
+
+    private static string TapeCreatorContainerName = "tape_creator_container";
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeNetworkEvent<JukeboxSongUploadRequest>(OnSongUploaded);
+        SubscribeLocalEvent<TapeCreatorComponent, ComponentInit>(OnComponentInit);
+        SubscribeLocalEvent<TapeCreatorComponent, InteractUsingEvent>(OnInteract);
+        SubscribeLocalEvent<TapeCreatorComponent, GetVerbsEvent<Verb>>(OnTapeCreatorGetVerb);
+        SubscribeLocalEvent<TapeCreatorComponent, ComponentGetState>(OnTapeCreatorStateChanged);
+        SubscribeLocalEvent<TapeComponent, ComponentGetState>(OnTapeStateChanged);
+    }
+
+    private void OnTapeCreatorGetVerb(EntityUid uid, TapeCreatorComponent component, GetVerbsEvent<Verb> ev)
+    {
+        if (component.Recording) return;
+        if (ev.Hands == null) return;
+        if (component.TapeContainer.ContainedEntities.Count == 0) return;
+
+        var removeTapeVerb = new Verb()
+        {
+            Text = "Вытащить касету",
+            Priority = 10000,
+            Icon = new SpriteSpecifier.Texture(new ResPath("/Textures/Interface/VerbIcons/remove_tape.png")),
+            Act = () =>
+            {
+                var tapes = component.TapeContainer.ContainedEntities.ToList();
+                _containerSystem.EmptyContainer(component.TapeContainer, true);
+
+                foreach (var tape in tapes)
+                {
+                    _handsSystem.PickupOrDrop(ev.User, tape);
+                }
+
+                component.InsertedTape = null;
+                Dirty(component);
+            }
+        };
+
+        ev.Verbs.Add(removeTapeVerb);
+    }
+
+    private void OnTapeStateChanged(EntityUid uid, TapeComponent component, ref ComponentGetState args)
+    {
+        args.State = new TapeComponentState()
+        {
+            Songs = component.Songs
+        };
+    }
+
+    private void OnTapeCreatorStateChanged(EntityUid uid, TapeCreatorComponent component, ref ComponentGetState args)
+    {
+        args.State = new TapeCreatorComponentState
+        {
+            Recording = component.Recording,
+            CoinBalance = component.CoinBalance,
+            InsertedTape = component.InsertedTape
+        };
+    }
+
+    private void OnComponentInit(EntityUid uid, TapeCreatorComponent component, ComponentInit args)
+    {
+        component.TapeContainer = _containerSystem.EnsureContainer<Container>(uid, TapeCreatorContainerName);
+    }
+
+    private void OnInteract(EntityUid uid, TapeCreatorComponent component, InteractUsingEvent args)
+    {
+        if(component.Recording) return;
+
+        if (TryComp<TapeComponent>(args.Used, out var tape))
+        {
+            var containedEntities = component.TapeContainer.ContainedEntities;
+
+            if (containedEntities.Count > 1)
+            {
+                var removedTapes = _containerSystem.EmptyContainer(component.TapeContainer, true).ToList();
+                component.TapeContainer.Insert(args.Used);
+
+                foreach (var tapes in removedTapes)
+                {
+                    _handsSystem.PickupOrDrop(args.User, tapes);
+                }
+            }
+            else
+            {
+                component.TapeContainer.Insert(args.Used);
+            }
+
+            component.InsertedTape = tape.Owner;
+            Dirty(component);
+            return;
+        }
+
+        if (_tagSystem.HasTag(args.Used, "TapeRecorderCoin"))
+        {
+            Del(args.Used);
+            component.CoinBalance += 1;
+            Dirty(component);
+
+            return;
+        }
+    }
+
+    private void OnSongUploaded(JukeboxSongUploadRequest ev)
+    {
+        if(!TryComp<TapeCreatorComponent>(ev.TapeCreatorUid, out var tapeCreatorComponent)) return;
+
+        if (!tapeCreatorComponent.InsertedTape.HasValue || tapeCreatorComponent.CoinBalance <= 0)
+        {
+            _popupSystem.PopupEntity("Т# %ак@ э*^о сdf{ал б2я~b? Запись была прервана.", tapeCreatorComponent.Owner);
+            return;
+        }
+
+        tapeCreatorComponent.CoinBalance -= 1;
+        tapeCreatorComponent.Recording = true;
+
+        var tapeComponent = Comp<TapeComponent>(tapeCreatorComponent.InsertedTape.Value);
+        var songData = _songsSyncManager.SyncSongData(ev.SongName, ev.SongBytes);
+
+        var song = new JukeboxSong()
+        {
+            SongName = songData.songName,
+            SongPath = songData.path
+        };
+
+        tapeComponent.Songs.Add(song);
+        _popupSystem.PopupEntity($"Запись началась, примерное время ожидания: {_recordTime} секунд", tapeCreatorComponent.Owner);
+        Dirty(ev.TapeCreatorUid);
+        Dirty(tapeComponent);
+        StartRecordDelayAsync(tapeCreatorComponent, _popupSystem, _containerSystem);
+    }
+
+    private async void StartRecordDelayAsync(TapeCreatorComponent component, SharedPopupSystem popupSystem, SharedContainerSystem containerSystem)
+    {
+        var recordTimeDelay = _recordTime * 1000 / 10;
+
+        await Task.Delay(1000);
+
+        for (int i = 0; i < 10; i++)
+        {
+            popupSystem.PopupEntity($"Запись мозговой активности выполнена на {i * 10}%", component.Owner);
+            await Task.Delay(recordTimeDelay);
+        }
+
+
+        containerSystem.EmptyContainer(component.TapeContainer, force: true).ToList();
+
+        component.Recording = false;
+        component.InsertedTape = null;
+
+        popupSystem.PopupEntity($"Запись мозговой активности завершена", component.Owner);
+        Dirty(component);
+    }
+}
diff --git a/Content.Shared/White/Jukebox/JukeboxBUIMessagess.cs b/Content.Shared/White/Jukebox/JukeboxBUIMessagess.cs
new file mode 100644
index 0000000000..f6d5167719
--- /dev/null
+++ b/Content.Shared/White/Jukebox/JukeboxBUIMessagess.cs
@@ -0,0 +1,20 @@
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.White.Jukebox;
+
+[Serializable, NetSerializable]
+public class JukeboxStopRequest : BoundUserInterfaceMessage { }
+
+
+[Serializable, NetSerializable]
+public class JukeboxRepeatToggled : BoundUserInterfaceMessage
+{
+    public bool NewState { get; }
+    public JukeboxRepeatToggled(bool newState)
+    {
+        NewState = newState;
+    }
+}
+
+[Serializable, NetSerializable]
+public class JukeboxEjectRequest : BoundUserInterfaceMessage { }
diff --git a/Content.Shared/White/Jukebox/JukeboxComponentsAndStuff.cs b/Content.Shared/White/Jukebox/JukeboxComponentsAndStuff.cs
new file mode 100644
index 0000000000..099cb3af53
--- /dev/null
+++ b/Content.Shared/White/Jukebox/JukeboxComponentsAndStuff.cs
@@ -0,0 +1,133 @@
+using System.Linq;
+using Lidgren.Network;
+using Robust.Shared.Containers;
+using Robust.Shared.GameStates;
+using Robust.Shared.Network;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.White.Jukebox;
+
+[Serializable, NetSerializable]
+public enum JukeboxUIKey : byte
+{
+    Key
+}
+
+[Serializable, NetSerializable]
+public enum TapeCreatorUIKey : byte
+{
+    Key
+}
+
+[NetworkedComponent, RegisterComponent]
+public class JukeboxComponent : Component
+{
+
+    public static string JukeboxContainerName = "jukebox_tapes";
+    public static string JukeboxDefaultSongsName = "jukebox_default_tapes";
+
+    [ViewVariables(VVAccess.ReadOnly)]
+    public Container TapeContainer = default!;
+
+    [DataField("defaultTapes")]
+    public List<string> DefaultTapes = new();
+    [ViewVariables(VVAccess.ReadOnly)]
+    public Container DefaultSongsContainer = default!;
+
+
+    [ViewVariables(VVAccess.ReadOnly)]
+    public bool Repeating { get; set; } = true;
+
+    [ViewVariables(VVAccess.ReadOnly)]
+    public float Volume { get; set; }
+
+    public PlayingSongData? PlayingSongData { get; set; }
+}
+
+public class TapeContainerComponent : Component
+{
+    public int MaxTapeCount = 1;
+    public Container TapeContainer { get; set; } = new();
+}
+
+[Serializable, NetSerializable]
+public class PlayingSongData
+{
+    public ResPath? SongPath;
+    public string? SongName;
+    public float PlaybackPosition;
+    public float ActualSongLengthSeconds;
+}
+
+[Serializable, NetSerializable]
+public class JukeboxComponentState : ComponentState
+{
+    public bool Playing { get; set; }
+
+    public PlayingSongData? SongData { get; set; }
+    public float Volume { get; set; }
+}
+
+[Serializable, NetSerializable, DataDefinition]
+public class JukeboxSong
+{
+    [DataField("songName")]
+    public string? SongName;
+    [DataField("path")]
+    public ResPath? SongPath;
+}
+
+[Serializable, NetSerializable]
+public class JukeboxRequestSongPlay : EntityEventArgs
+{
+    public string? SongName { get; set; }
+    public ResPath? SongPath { get; set; }
+    public EntityUid? Jukebox { get; set; }
+    public float SongDuration { get; set; }
+}
+
+[Serializable, NetSerializable]
+public class JukeboxRequestStop : EntityEventArgs
+{
+    public EntityUid? JukeboxUid { get; set; }
+}
+
+[Serializable, NetSerializable]
+public class JukeboxStopPlaying : EntityEventArgs
+{
+    public EntityUid? JukeboxUid { get; set; }
+}
+
+[Serializable, NetSerializable]
+public class JukeboxSongUploadRequest : EntityEventArgs
+{
+    public string SongName = string.Empty;
+    public List<byte> SongBytes = new();
+    public EntityUid TapeCreatorUid = default!;
+}
+
+public class JukeboxSongUploadNetMessage : NetMessage
+{
+    public override NetDeliveryMethod DeliveryMethod => NetDeliveryMethod.ReliableUnordered;
+    public override MsgGroups MsgGroup => MsgGroups.Command;
+
+    public ResPath RelativePath { get; set; } = ResPath.Self;
+    public byte[] Data { get; set; } = Array.Empty<byte>();
+
+    public override void ReadFromBuffer(NetIncomingMessage buffer, IRobustSerializer serializer)
+    {
+        var dataLength = buffer.ReadVariableInt32();
+        Data = buffer.ReadBytes(dataLength);
+        RelativePath = new ResPath(buffer.ReadString());
+    }
+
+    public override void WriteToBuffer(NetOutgoingMessage buffer, IRobustSerializer serializer)
+    {
+        buffer.WriteVariableInt32(Data.Length);
+        buffer.Write(Data);
+        buffer.Write(RelativePath.ToString());
+        buffer.Write(ResPath.Separator);
+    }
+}
diff --git a/Content.Shared/White/Jukebox/JukeboxSharedSystem.cs b/Content.Shared/White/Jukebox/JukeboxSharedSystem.cs
new file mode 100644
index 0000000000..52152e1e38
--- /dev/null
+++ b/Content.Shared/White/Jukebox/JukeboxSharedSystem.cs
@@ -0,0 +1,37 @@
+using Robust.Shared.Containers;
+using Robust.Shared.Network;
+
+namespace Content.Shared.White.Jukebox;
+
+public class JukeboxSharedSystem : EntitySystem
+{
+    [Dependency] private readonly SharedContainerSystem _containerSystem = default!;
+    [Dependency] private readonly INetManager _netManager = default!;
+
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<JukeboxComponent, ComponentStartup>(OnJukeboxInit);
+    }
+
+    public void OnJukeboxInit(EntityUid uid, JukeboxComponent component, ComponentStartup args)
+    {
+        component.TapeContainer = _containerSystem.EnsureContainer<Container>(uid, JukeboxComponent.JukeboxContainerName);
+        component.DefaultSongsContainer = _containerSystem.EnsureContainer<Container>(uid, JukeboxComponent.JukeboxDefaultSongsName);
+
+        if (_netManager.IsServer)
+        {
+            var transform = Transform(component.Owner);
+
+            foreach (var tapePrototype in component.DefaultTapes)
+            {
+                var tapeUid = EntityManager.SpawnEntity(tapePrototype, transform.MapPosition);
+
+                if(!TryComp<TapeComponent>(tapeUid, out _)) continue;
+
+                component.DefaultSongsContainer.Insert(tapeUid);
+            }
+        }
+    }
+}
diff --git a/Content.Shared/White/Jukebox/JukeboxSongsSyncManager.cs b/Content.Shared/White/Jukebox/JukeboxSongsSyncManager.cs
new file mode 100644
index 0000000000..4f745094f0
--- /dev/null
+++ b/Content.Shared/White/Jukebox/JukeboxSongsSyncManager.cs
@@ -0,0 +1,29 @@
+using Robust.Shared.ContentPack;
+using Robust.Shared.Network;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.White.Jukebox;
+
+public abstract class JukeboxSongsSyncManager : IDisposable
+{
+    [Dependency] private readonly INetManager _netManager = default!;
+    [Dependency] protected readonly IResourceManager ResourceManager = default!;
+
+    public static readonly ResPath Prefix = ResPath.Root / "Jukebox";
+
+    protected readonly MemoryContentRoot ContentRoot = new();
+
+    public virtual void Initialize()
+    {
+        ResourceManager.AddRoot(Prefix, ContentRoot);
+
+        _netManager.RegisterNetMessage<JukeboxSongUploadNetMessage>(OnSongUploaded);
+    }
+
+    public abstract void OnSongUploaded(JukeboxSongUploadNetMessage message);
+
+    public void Dispose()
+    {
+        ContentRoot.Dispose();
+    }
+}
diff --git a/Content.Shared/White/Jukebox/TapeComponent.cs b/Content.Shared/White/Jukebox/TapeComponent.cs
new file mode 100644
index 0000000000..78aaf5f284
--- /dev/null
+++ b/Content.Shared/White/Jukebox/TapeComponent.cs
@@ -0,0 +1,17 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.White.Jukebox;
+
+[RegisterComponent, NetworkedComponent]
+public sealed class TapeComponent : Component
+{
+    [DataField("songs")]
+    public List<JukeboxSong> Songs { get; set; } = new();
+}
+
+[Serializable, NetSerializable]
+public sealed class TapeComponentState : ComponentState
+{
+    public List<JukeboxSong> Songs { get; set; } = new();
+}
diff --git a/Content.Shared/White/Jukebox/TapeCreatorComponent.cs b/Content.Shared/White/Jukebox/TapeCreatorComponent.cs
new file mode 100644
index 0000000000..40b1a75315
--- /dev/null
+++ b/Content.Shared/White/Jukebox/TapeCreatorComponent.cs
@@ -0,0 +1,29 @@
+using Robust.Shared.Containers;
+using Robust.Shared.GameStates;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.White.Jukebox;
+
+[RegisterComponent, NetworkedComponent]
+public sealed class TapeCreatorComponent : Component
+{
+    [DataField("coins")]
+    public int CoinBalance { get; set; }
+
+    [ViewVariables(VVAccess.ReadOnly)]
+    public bool Recording { get; set; }
+
+    [ViewVariables(VVAccess.ReadOnly)]
+    public EntityUid? InsertedTape { get; set; }
+
+    [ViewVariables(VVAccess.ReadOnly)]
+    public Container TapeContainer { get; set; } = default!;
+}
+
+[Serializable, NetSerializable]
+public sealed class TapeCreatorComponentState : ComponentState
+{
+    public int CoinBalance { get; set; }
+    public bool Recording { get; set; }
+    public EntityUid? InsertedTape { get; set; }
+}
diff --git a/Content.Shared/White/WhiteCVars.cs b/Content.Shared/White/WhiteCVars.cs
index b54400d3af..257c210b06 100644
--- a/Content.Shared/White/WhiteCVars.cs
+++ b/Content.Shared/White/WhiteCVars.cs
@@ -158,6 +158,19 @@ public sealed class WhiteCVars
     public static readonly CVarDef<float> BwoinkVolume =
         CVarDef.Create("white.admin.bwoinkVolume", 0f, CVar.CLIENTONLY | CVar.ARCHIVE);
 
+    /*
+    * Jukebox
+     */
+
+    public static readonly CVarDef<float> MaxJukeboxSongSizeInMB = CVarDef.Create("white.max_jukebox_song_size",
+        3.5f, CVar.SERVER | CVar.REPLICATED | CVar.ARCHIVE);
+
+    public static readonly CVarDef<float> MaxJukeboxSoundRange = CVarDef.Create("white.max_jukebox_sound_range", 20f,
+        CVar.SERVER | CVar.REPLICATED | CVar.ARCHIVE);
+
+    public static readonly CVarDef<float> JukeboxVolume =
+        CVarDef.Create("white.jukebox_volume", 0f, CVar.CLIENTONLY | CVar.ARCHIVE);
+
 
      /*
     * Chat
diff --git a/Resources/Audio/White/Jukebox/Tapes/tape_fall.ogg b/Resources/Audio/White/Jukebox/Tapes/tape_fall.ogg
new file mode 100644
index 0000000000000000000000000000000000000000..d1741b50db77d486b333b67eb3871c31ce810939
GIT binary patch
literal 11549
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

literal 0
HcmV?d00001

diff --git a/Resources/Prototypes/White/JukeboxAndStuff/jukebox_stuff.yml b/Resources/Prototypes/White/JukeboxAndStuff/jukebox_stuff.yml
new file mode 100644
index 0000000000..188c4d5bef
--- /dev/null
+++ b/Resources/Prototypes/White/JukeboxAndStuff/jukebox_stuff.yml
@@ -0,0 +1,52 @@
+- type: entity
+  parent: BaseItem
+  id: Jukebox
+  name: jukebox
+  description: Альфа-Шкварки
+  suffix: Empty
+  components:
+    - type: Jukebox
+    - type: Sprite
+      sprite: White/Objects/Devices/jukebox.rsi
+      layers:
+        - state: boombox
+        - state: boombox_working_overlay
+          map: ["bars"]
+      netsync: false
+    - type: Item
+      sprite: White/Objects/Devices/jukebox.rsi
+      heldPrefix: boombox
+      size: 500
+    - type: UserInterface
+      interfaces:
+        - key: enum.JukeboxUIKey.Key
+          type: JukeboxBUI
+    - type: ActivatableUI
+      key: enum.JukeboxUIKey.Key
+
+- type: entity
+  parent: BaseItem
+  id: TapeRecorder
+  name: tape recorder
+  suffix: Empty
+  components:
+    - type: TapeCreator
+      coins: 3
+    - type: Sprite
+      scale: 0.7, 0.7
+      sprite: White/Objects/Devices/tapeRecorder.rsi
+      layers:
+        - state: base
+        - state: tape
+          map: ["tape"]
+          visible: false
+      netsync: false
+    - type: Item
+      sprite: White/Objects/Devices/tapeRecorder.rsi
+      heldPrefix: tapeRecorder
+    - type: UserInterface
+      interfaces:
+        - key: enum.TapeCreatorUIKey.Key
+          type: TapeCreatorBUI
+    - type: ActivatableUI
+      key: enum.TapeCreatorUIKey.Key
diff --git a/Resources/Prototypes/White/JukeboxAndStuff/tapes.yml b/Resources/Prototypes/White/JukeboxAndStuff/tapes.yml
new file mode 100644
index 0000000000..58e80657e5
--- /dev/null
+++ b/Resources/Prototypes/White/JukeboxAndStuff/tapes.yml
@@ -0,0 +1,27 @@
+- type: entity
+  parent: BaseItem
+  id: BaseTape
+  name: baseTape
+  abstract: true
+  noSpawn: true
+  description: это база
+  suffix: Empty
+  components:
+    - type: Tape
+    - type: Sprite
+      sprite: Objects/Devices/jukeboxStuff/tape.rsi
+      layers:
+        - state: tape
+      netsync: false
+    - type: Item
+      sprite: Objects/Devices/jukeboxStuff/tape.rsi
+      heldPrefix: tape
+    - type: EmitSoundOnLand
+      sound:
+        path: /Audio/White/Jukebox/Tapes/tape_fall.ogg
+
+- type: entity
+  parent: BaseTape
+  id: TapeEmpty
+  name: Old tape
+  description: Ligma balls
diff --git a/Resources/Prototypes/tags.yml b/Resources/Prototypes/tags.yml
index c37b9e6ec5..9f2275bf47 100644
--- a/Resources/Prototypes/tags.yml
+++ b/Resources/Prototypes/tags.yml
@@ -1197,3 +1197,6 @@
   id: Crystal
 
 # WHITE END
+
+- type: Tag
+  id: TapeRecorderCoin
diff --git a/Resources/Textures/Interface/VerbIcons/remove_tape.png b/Resources/Textures/Interface/VerbIcons/remove_tape.png
new file mode 100644
index 0000000000000000000000000000000000000000..bc2cb0b47313d7b37b80005150bd7e4c5eee66cb
GIT binary patch
literal 973
zcmV;;12X)HP)<h;3K|Lk000e1NJLTq002M$002M;1^@s6s%dfF0004QX+uL$X=7sm
z04R}lk-JMmVHn1LYB$Od$|0)3!J<JS3ZgL#a<K+A$ZFB!E%0(UM~P?+S{j6gsHNM`
ze^6`CS`Y+95Yg7&Z3#KOUj|C(clgfx<N3bl<vq^<dnl*n&9)iH7fMDr81O8`mOY)X
zI2giB2YqqP)aN5}QChCAdu*!S`Bksh_nNMrWXjaQ)+Icp=|)LdrXjRm(iQIryR~dQ
zDSRaCGh{&FYo#Y@{GvEh;}69~G&~D-)zgz{;6wv!StBnzChX1U%G%#N>Pwud!eT_~
zpzL8x!UPH6Awiina+L5(El6g~edE8r1&ZR)<gK%TA&v}L@%lt9OV^atwCE{$a%`yF
z|L19@Cnsv%odIZnwygIN=-h>B#j?JSEvtG0jwiS*)cr-tY5G(2N?r3Ff@=%Tuj*Q2
z4=%Q0;8Bko@n6Xy+n!Ft+Zpu6p#K)SS87@PopbsC(M|b9H?V&IqjKN1`UCIpXaWqM
zZG!*+010qNS#tmY4`BcR4`BhQKc{H`00HYsL_t(|0qt4Ql7k=&)SLTJ{V@I1o^*~5
zG7ADth?4M946tOEBx;=|!S?!Zf-X$6)aH(Rxc7Xt@VZxDWYd_uCo3UBcL7r5r9|i|
zz!iB35xNObO1`%UT?D8l-%|v30b0rT5`k5KZ^`!%flUA^^4ub@2tZAqQ-mK6uJzXh
z(0cNoH%krh;PG#1ZRq(<U?~uvlD2D$0Bt88^R)<w714HW5uokFjjt(iR$wlDJUuTP
z=gNxUIA__$M12JOBHi|Vf4?TL>xzaSXWO>z?enrMr|*%@2qRz=;^9f9IKjI>$sZDT
zyL+_y3?m>^ZuCB^0VSkM6feP%o?{VEa{_nE`;_lB(WyQH)C(|75o}G*W&u$C#ZJ`Z
zBEs`FE?kFCmIASp4jkE>y`~`yWUIjp=aLAJb0{|!I)eJSwYf2bm9mitkOF^#-2`~T
zDRKHp5&^ktpBuX(mRp+}yTT2}Nd$0!$RT74H!tZU3}h?8LUTx;11KE}o#n!Hdo&9`
zbsGwaO7zK6K*D*7J=F_Pl>(f(NO77i7#0CFsvU*zGyRALl9!zi;1?YinXzxBaOxvK
zy#TdE@Dy2hDvB;8TN)I=e@jb!PHNdma*gMMe1M<E(8N(~>T7@rFluNUFH@jQfj?0x
vl&8mnpUwaP01jnXNoGw=04e|g00;m8000000Mb*F00000NkvXXu0mjf<Seq*

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Objects/Devices/jukeboxStuff/tape.rsi/meta.json b/Resources/Textures/Objects/Devices/jukeboxStuff/tape.rsi/meta.json
new file mode 100644
index 0000000000..bfea7fee91
--- /dev/null
+++ b/Resources/Textures/Objects/Devices/jukeboxStuff/tape.rsi/meta.json
@@ -0,0 +1,12 @@
+{
+    "version": 1,
+    "license": "CC-BY-SA-3.0",
+    "copyright": "Taken from infinity baystation 12, https://github.com/infinitystation/Baystation12/blob/073f678cdce92edb8fcd55f9ffc9f0523bf31506/icons/obj/radio.dmi",
+    "size": {
+        "x": 14,
+        "y": 8
+    },
+    "states" : [
+        {"name": "tape"}
+    ]
+}
diff --git a/Resources/Textures/Objects/Devices/jukeboxStuff/tape.rsi/tape.png b/Resources/Textures/Objects/Devices/jukeboxStuff/tape.rsi/tape.png
new file mode 100644
index 0000000000000000000000000000000000000000..d4217cb792b80bb04e3e94c99128bbfc81d338e0
GIT binary patch
literal 656
zcmV;B0&o3^P)<h;3K|Lk000e1NJLTq000gE000OG1^@s6$q~-X0004QX+uL$X=7sm
z04R}lk-bX-aTv!xYGRb(P(wt6gGGZv6hzPx2Dw;+8f3NT`4*gd+$kZgK}&<s5ViC+
z^dHn3v=#(G5k$1L_qK#w&#9n<KF9B#58vPOeR%FUu!mJ8Z}iMVzEIL5p`dp)zUFnk
z<G_ZKIs6I5(3YZ$F}lXjqtr?~1gu`&>pDh%Ds3oW>lL0+G`%D&(-7V&X%_DZ4=K4s
zO87+BugieKx0ar4@SDZi27g(s$07@0w|aWBZJcalC8y_wCxm@@wX8JfvA)EeF04c)
zkH{ItAVP>BUXqmAM5RPPazS?1**97DEmIVaB5#cfx;V1r#OoKeEM3!*Goq*EQK?va
z|G!ToGd<Pl?hb<U)igiHz_kyxs%ie7nr7_`94~NPX!(n>r`d1Ot1ZoU44xghylH94
z1Gw6S;b$$OC+d<zjy;osj|&)x!{9yitv7bnyyyH0V%zeI?%?nU#--k~@drVsXebZT
z?j8UD010qNS#tmY4`BcR4`BhQKc{H`006E@L_t&-8DmsYG5F8I!ou+9&mRU50I@*;
zA0H$KRL8;~DlHFIOf2#G=|cu4n90Oy0;vP(VFKCs>Fp~p<`ouYIDK?K1BiACDFS0;
zF_=1#9!3oflmF}-oL~#3)wJ<i{PfmUu>8*--x*jy)`|*?fdxLleT`QmA5`7*hj$@?
z1M(~>0PIwLe#!qJO)M;IV7+W?Yz*JNeF5`9>|eirF@R_g0I@;f&!1lm0J*+Nn7*IN
q+W-In4rN$LW=%~1DgXcg2mk;800000(o>TF0000<MNUMnLSTYa%pV&7

literal 0
HcmV?d00001