Csharp rewrite (#4)

* Implement BeamComponent in C# and enhance marketplace button functionality

* Add core game components including ConfigFileHandler, GameManager, SaveSystem, and UIManager

* cleanup

* Add new components: CanPickUpComponent, CollapsableComponent, DestroyableComponent, EffectInflictorComponent, StatusEffectComponent, and StatusEffectDataResource

* Add new components: EnemyDeathComponent, EnemyWaveTriggerComponent, and ExitDoorComponent

* Add new components: ExplosiveComponent, FadeAwayComponent, FireEffectComponent, FlipComponent, GravityMotionComponent, LaunchComponent, and update PlatformMovement with LastDirection property

* Add new components: HealComponent, HitComponent, HomingMissileMotionComponent, LeverComponent, and TriggerLeverComponent

* Refactor GameManager session state handling and add new components: CanBeLaunchedComponent, IceEffectComponent, JumpPadComponent, KillPlayerOutOfScreenComponent, KnockbackComponent, LifetimeComponent, MagneticSkillComponent, OutOfScreenComponent, PeriodicShootingComponent, PlayerDeathComponent, ProgressiveDamageComponent, ProjectileComponent, ProjectileInitComponent, RequirementComponent, ScoreComponent, ShipMovementComponent, ShipShooterComponent, and SideToSideMovementComponent

* Add new components: CannotStompComponent, SkillUnlockedComponent, SpaceshipEnterComponent, SpaceshipExitComponent, SpinComponent, StompDamageComponent, StraightMotionComponent, TerrainHitFx, TooltipComponent, TrailComponent, and UnlockOnRequirementComponent

* Add new components: BrickThrowComponent, BulletComponent, CageComponent, ChaseLevelComponent, CleanupComponent, and ThrowInputResource classes; implement game saving and loading logic in SaveSystem

* Add audio settings management and platform movement component

* Add ChargeProgressBar, Credits, and GameOverScreen components for UI management

* Add UID files for ConfigFileHandler, GameManager, SaveSystem, and UIManager components

* Add README.md file with game description and features; include project license and contribution guidelines

* Add Hud component for UI management; display health, coins, and lives

* Add MainMenu and Marketplace components; implement game management and skill unlocking features

* Add PauseMenu, SettingsMenu, and SkillButton components; enhance game management and UI functionality

scripts/UI/AudioSettings.cs

@@ -0,0 +1,102 @@
+using Godot;
+using Mr.BrickAdventures.Autoloads;
+
+namespace Mr.BrickAdventures.scripts.UI;
+
+public partial class AudioSettings : Node
+{
+    [Export] public Slider MasterVolumeSlider { get; set; }
+    [Export] public Slider MusicVolumeSlider { get; set; }
+    [Export] public Slider SfxVolumeSlider { get; set; }
+    [Export] public Control AudioSettingsControl { get; set; }
+    [Export] public float MuteThreshold { get; set; } = -20f;
+    
+    private UIManager _uiManager;
+    private ConfigFileHandler _configFileHandler;
+
+    public override void _Ready()
+    {
+        _uiManager = GetNode<UIManager>("/root/UIManager");
+        _configFileHandler = GetNode<ConfigFileHandler>("/root/ConfigFileHandler");
+        Initialize();
+        MasterVolumeSlider.ValueChanged += OnMasterVolumeChanged;
+        MusicVolumeSlider.ValueChanged += OnMusicVolumeChanged;
+        SfxVolumeSlider.ValueChanged += OnSfxVolumeChanged;
+    }
+    
+    public override void _UnhandledInput(InputEvent @event)
+    {
+        if (!@event.IsActionReleased("ui_cancel")) return;
+        if (!_uiManager.IsScreenOnTop(AudioSettingsControl)) return;
+        
+        SaveSettings();
+        _uiManager.PopScreen();
+    }
+
+    private void OnSfxVolumeChanged(double value)
+    {
+        AudioServer.SetBusVolumeDb(AudioServer.GetBusIndex("sfx"), (float)value);
+        HandleMute(AudioServer.GetBusIndex("sfx"), (float)value);
+    }
+
+    private void OnMusicVolumeChanged(double value)
+    {
+        AudioServer.SetBusVolumeDb(AudioServer.GetBusIndex("music"), (float)value);
+        HandleMute(AudioServer.GetBusIndex("music"), (float)value);
+    }
+
+    private void OnMasterVolumeChanged(double value)
+    {
+        AudioServer.SetBusVolumeDb(AudioServer.GetBusIndex("Master"), (float)value);
+        HandleMute(AudioServer.GetBusIndex("Master"), (float)value);
+    }
+
+    private void Initialize()
+    {
+        var volumeDb = AudioServer.GetBusVolumeDb(AudioServer.GetBusIndex("Master"));
+        MasterVolumeSlider.Value = volumeDb;
+        MasterVolumeSlider.MinValue = MuteThreshold;
+        MasterVolumeSlider.MaxValue = 0f;
+        
+        var musicVolumeDb = AudioServer.GetBusVolumeDb(AudioServer.GetBusIndex("music"));
+        MusicVolumeSlider.Value = musicVolumeDb;
+        MusicVolumeSlider.MinValue = MuteThreshold;
+        MusicVolumeSlider.MaxValue = 0f;
+        
+        var sfxVolumeDb = AudioServer.GetBusVolumeDb(AudioServer.GetBusIndex("sfx"));
+        SfxVolumeSlider.Value = sfxVolumeDb;
+        SfxVolumeSlider.MinValue = MuteThreshold;
+        SfxVolumeSlider.MaxValue = 0f;
+    }
+
+    private void HandleMute(int busIndex, float value)
+    {
+        AudioServer.SetBusMute(busIndex, value <= MuteThreshold);
+    }
+
+    private void SaveSettings()
+    {
+        var settingsConfig = _configFileHandler.SettingsConfig;
+        settingsConfig.SetValue("audio_settings", "master_volume", MasterVolumeSlider.Value);
+        settingsConfig.SetValue("audio_settings", "music_volume", MusicVolumeSlider.Value);
+        settingsConfig.SetValue("audio_settings", "sfx_volume", SfxVolumeSlider.Value);
+        settingsConfig.SetValue("audio_settings", "mute_threshold", MuteThreshold);
+        settingsConfig.Save(ConfigFileHandler.SettingsPath);
+    }
+
+    private void LoadSettings()
+    {
+        var settingsConfig = _configFileHandler.SettingsConfig;
+        if (!settingsConfig.HasSection("audio_settings")) return;
+        
+        var masterVolume = (float)settingsConfig.GetValue("audio_settings", "master_volume", MasterVolumeSlider.Value);
+        var musicVolume = (float)settingsConfig.GetValue("audio_settings", "music_volume", MusicVolumeSlider.Value);
+        var sfxVolume = (float)settingsConfig.GetValue("audio_settings", "sfx_volume", SfxVolumeSlider.Value);
+        var muteThreshold = (float)settingsConfig.GetValue("audio_settings", "mute_threshold", MuteThreshold);
+        
+        MasterVolumeSlider.Value = masterVolume;
+        MusicVolumeSlider.Value = musicVolume;
+        SfxVolumeSlider.Value = sfxVolume;
+        MuteThreshold = muteThreshold;
+    }
+}

scripts/UI/AudioSettings.cs.uid

@@ -0,0 +1 @@
+uid://g61qqsymqfxd

scripts/UI/ChargeProgressBar.cs

@@ -0,0 +1,81 @@
+using Godot;
+using Mr.BrickAdventures.scripts.components;
+using Mr.BrickAdventures.scripts.Resources;
+
+namespace Mr.BrickAdventures.scripts.UI;
+
+public partial class ChargeProgressBar : Node
+{
+    [Export] public ProgressBar ProgressBar { get; set; }
+    [Export] public BrickThrowComponent ThrowComponent { get; set; }
+    
+    private ChargeThrowInputResource _throwInput;
+
+    public override void _Ready()
+    {
+        Owner.ChildEnteredTree += OnNodeEntered;   
+        ProgressBar.Hide();
+        SetupDependencies();
+    }
+
+    private void OnNodeEntered(Node node)
+    {
+        if (node is not BrickThrowComponent throwComponent || ThrowComponent != null) return;
+        ThrowComponent = throwComponent;
+        SetupDependencies();
+    }
+
+    private void SetupDependencies()
+    {
+        if (ThrowComponent.ThrowInputBehavior is ChargeThrowInputResource throwInput)
+        {
+            _throwInput = throwInput;
+        }
+        else
+        {
+            _throwInput = null;
+        }
+        
+        if (_throwInput == null)
+        {
+            return;
+        }
+
+        if (!_throwInput.SupportsCharging())
+        {
+            ProgressBar.Hide();
+            return;
+        }
+        
+        SetupProgressBar();
+        
+        _throwInput.ChargeStarted += OnChargeStarted;
+        _throwInput.ChargeStopped += OnChargeStopped;
+        _throwInput.ChargeUpdated += OnChargeUpdated;
+    }
+
+    private void SetupProgressBar()
+    {
+        ProgressBar.MinValue = _throwInput.MinPower;
+        ProgressBar.MaxValue = _throwInput.MaxPower;
+        ProgressBar.Value = _throwInput.MinPower;
+        ProgressBar.Step = 0.01f;
+        ProgressBar.Hide();
+    }
+
+    private void OnChargeStarted()
+    {
+        ProgressBar.Show();
+    }
+
+    private void OnChargeStopped()
+    {
+        ProgressBar.Hide();
+    }
+
+    private void OnChargeUpdated(float chargeRatio)
+    {
+        ProgressBar.Value = chargeRatio;
+        ProgressBar.Show();
+    }
+}

scripts/UI/ChargeProgressBar.cs.uid

@@ -0,0 +1 @@
+uid://dev2q1228otm2

scripts/UI/Credits.cs

@@ -0,0 +1,23 @@
+using Godot;
+using Mr.BrickAdventures.Autoloads;
+
+namespace Mr.BrickAdventures.scripts.UI;
+
+public partial class Credits : Control
+{
+    private UIManager _uiManager;
+
+    public override void _Ready()
+    {
+        _uiManager = GetNode<UIManager>("/root/UIManager");
+    }
+
+    public override void _UnhandledInput(InputEvent @event)
+    {
+        if (!@event.IsActionPressed("ui_cancel")) return;
+        if (_uiManager != null && _uiManager.IsScreenOnTop(this))
+        {
+            _uiManager.PopScreen();
+        }
+    }
+}

scripts/UI/Credits.cs.uid

@@ -0,0 +1 @@
+uid://daevj4uootmcw

scripts/UI/GameOverScreen.cs

@@ -0,0 +1,39 @@
+using Godot;
+using Mr.BrickAdventures.Autoloads;
+
+namespace Mr.BrickAdventures.scripts.UI;
+
+public partial class GameOverScreen : Node
+{
+    [Export] public Control GameOverPanel { get; set; }
+    [Export] public Button RestartButton { get; set; }
+    [Export] public Button MainMenuButton { get; set; }
+    [Export] public PackedScene MainMenuScene { get; set; }
+    
+    private GameManager _gameManager;
+
+    public override void _Ready()
+    {
+        _gameManager = GetNode<GameManager>("/root/GameManager");
+        RestartButton.Pressed += OnRestartClicked;
+        MainMenuButton.Pressed += OnMainMenuClicked; 
+    }
+
+    private void OnMainMenuClicked()
+    {
+        _gameManager.ResetPlayerState();
+        GetTree().ChangeSceneToPacked(MainMenuScene);
+    }
+
+    private void OnRestartClicked()
+    {
+        _gameManager.RestartGame();
+    }
+
+    public void OnPlayerDeath()
+    {
+        if (_gameManager == null || _gameManager.GetLives() != 0) return;
+        
+        GameOverPanel.Show();
+    }
+}

scripts/UI/GameOverScreen.cs.uid

@@ -0,0 +1 @@
+uid://u4qfsx4w72dv

scripts/UI/Hud.cs

@@ -0,0 +1,43 @@
+using Godot;
+using Mr.BrickAdventures.Autoloads;
+using Mr.BrickAdventures.scripts.components;
+
+namespace Mr.BrickAdventures.scripts.UI;
+
+public partial class Hud : Node
+{
+    [Export] public HealthComponent Health { get; set; }
+    [Export] public Label CoinsLabel { get; set; }
+    [Export] public ProgressBar HealthBar { get; set; }
+    [Export] public Label LivesLabel { get; set; }
+
+    private GameManager _gameManager;
+
+    public override void _Ready()
+    {
+        _gameManager = GetNode<GameManager>("/root/GameManager");
+    }
+
+    public override void _Process(double delta)
+    {
+        SetHealthBar();
+        SetLivesLabel();
+        SetCoinsLabel();
+    }
+
+    private void SetCoinsLabel()
+    {
+        CoinsLabel.Text = Tr("COINS_LABEL") + ": " + _gameManager.GetCoins();
+    }
+
+    private void SetLivesLabel()
+    {
+        LivesLabel.Text = Tr("LIVES_LABEL") + ": " + _gameManager.GetLives();
+    }
+
+    private void SetHealthBar()
+    {
+        HealthBar.Value = Health.Health;
+        HealthBar.MaxValue = Health.MaxHealth;
+    }
+}

scripts/UI/Hud.cs.uid

@@ -0,0 +1 @@
+uid://wfj674u4486f

scripts/UI/MainMenu.cs

@@ -0,0 +1,67 @@
+using Godot;
+using Mr.BrickAdventures.Autoloads;
+
+namespace Mr.BrickAdventures.scripts.UI;
+
+public partial class MainMenu : Node
+{
+    [Export] public Control MainMenuControl { get; set; }
+    [Export] public Button NewGameButton { get; set; }
+    [Export] public Button ContinueButton { get; set; }
+    [Export] public Button SettingsButton { get; set; }
+    [Export] public Button CreditsButton { get; set; }
+    [Export] public Button ExitButton { get; set; }
+    [Export] public Label VersionLabel { get; set; }
+    [Export] public Control SettingsControl { get; set; }
+    [Export] public Control CreditsControl { get; set; }
+    
+    private SaveSystem _saveSystem;
+    private GameManager _gameManager;
+    private UIManager _uiManager;
+
+    public override void _Ready()
+    {
+        _saveSystem = GetNode<SaveSystem>("/root/SaveSystem");
+        _gameManager = GetNode<GameManager>("/root/GameManager");
+        _uiManager = GetNode<UIManager>("/root/UIManager");
+
+        NewGameButton.Pressed += OnNewGamePressed;
+        ContinueButton.Pressed += OnContinuePressed;
+        SettingsButton.Pressed += OnSettingsPressed;
+        CreditsButton.Pressed += OnCreditsPressed;
+        ExitButton.Pressed += OnExitPressed;
+
+        VersionLabel.Text = $"v. {ProjectSettings.GetSetting("application/config/version")}";
+        ContinueButton.Disabled = !_saveSystem.CheckSaveExists();
+
+        if (_saveSystem.CheckSaveExists())
+            ContinueButton.GrabFocus();
+        else
+            NewGameButton.GrabFocus();
+    }
+
+    private void OnExitPressed()
+    {
+        _gameManager.QuitGame();
+    }
+
+    private void OnCreditsPressed()
+    {
+        _uiManager.PushScreen(CreditsControl);
+    }
+
+    private void OnSettingsPressed()
+    {
+        _uiManager.PushScreen(SettingsControl);
+    }
+
+    private void OnContinuePressed()
+    {
+        _gameManager.ContinueGame();
+    }
+
+    private void OnNewGamePressed()
+    {
+        _gameManager.StartNewGame();
+    }
+}

scripts/UI/MainMenu.cs.uid

@@ -0,0 +1 @@
+uid://bna3ggr6n7ycr

scripts/UI/Marketplace.cs

@@ -0,0 +1,142 @@
+using System.Collections.Generic;
+using Godot;
+using Godot.Collections;
+using Mr.BrickAdventures.Autoloads;
+using Mr.BrickAdventures.scripts.components;
+using Mr.BrickAdventures.scripts.Resources;
+
+namespace Mr.BrickAdventures.scripts.UI;
+
+public partial class Marketplace : Node
+{
+    [Export] public Array<SkillData> Skills { get; set; } = [];
+    [Export] public GridContainer ToUnlockGrid { get; set; }
+    [Export] public GridContainer UnlockedGrid { get; set; }
+    [Export] public Font Font { get; set; }
+    [Export] public SkillUnlockedComponent SkillUnlockedComponent { get; set; }
+    [Export] public Array<Node> ComponentsToDisable { get; set; } = [];
+    [Export] public PackedScene MarketplaceButtonScene { get; set; }
+    [Export] public PackedScene SkillButtonScene { get; set; }
+    
+    private GameManager _gameManager;
+    private readonly List<Button> _unlockButtons = [];
+    private readonly List<SkillButton> _skillButtons = [];
+
+    public override void _Ready()
+    {
+        var skillsToUnlock = new List<SkillData>();
+        
+        foreach (var skill in Skills) skillsToUnlock.Add(skill);
+
+        foreach (var skill in skillsToUnlock) CreateUpgradeButton(skill);
+
+        var unlockedSkills = _gameManager.GetUnlockedSkills();
+        foreach (var skill in unlockedSkills) CreateSkillButton(skill);
+        
+        SkillUnlockedComponent.SkillUnlocked += OnSkillUnlocked;
+    }
+
+    public override void _ExitTree()
+    {
+        SkillUnlockedComponent.SkillUnlocked -= OnSkillUnlocked;
+    }
+
+    public override void _Input(InputEvent @event)
+    {
+        var root = Owner as Control;
+
+        if (!@event.IsActionPressed("show_marketplace")) return;
+        
+        if (root != null && root.IsVisible())
+        {
+            root.Hide();
+            foreach (var c in ComponentsToDisable) c.ProcessMode = ProcessModeEnum.Inherit;
+        }
+        else
+        {
+            root?.Show();
+            foreach (var c in ComponentsToDisable) c.ProcessMode = ProcessModeEnum.Disabled;
+        }
+    }
+
+    private string GetButtonText(SkillData skill)
+    {
+        return $"{Tr(skill.Name)} {skill.Cost}";
+    }
+
+    private void OnSkillUnlocked(SkillData skill)
+    {
+        if (_skillButtons.Count == 0) CreateSkillButton(skill);
+
+        foreach (var btn in _skillButtons)
+        {
+            if (btn.Data.IsActive)
+                btn.Activate();
+            else
+                btn.Deactivate();
+        }
+    }
+
+    private void CreateSkillButton(SkillData skill)
+    {
+        var button = SkillButtonScene.Instantiate<SkillButton>();
+        button.Data = skill;
+        button.Setup();
+        button.Pressed += () => OnSkillButtonPressed(button);
+        button.Activate();
+        
+        _skillButtons.Add(button);
+        UnlockedGrid.AddChild(button);
+        UnlockedGrid.QueueSort();
+    }
+
+    private void CreateUpgradeButton(SkillData skill)
+    {
+        var button = MarketplaceButtonScene.Instantiate<MarketplaceButton>();
+        button.Text = GetButtonText(skill);
+        button.Data = skill;
+        button.Icon = skill.Icon;
+        button.Pressed += () => OnUpgradeButtonPressed(skill);
+        
+        _unlockButtons.Add(button);
+        UnlockedGrid.AddChild(button);
+        UnlockedGrid.QueueSort();
+    }
+
+    private void OnUpgradeButtonPressed(SkillData skill)
+    {
+        if (_gameManager.IsSkillUnlocked(skill))
+        {
+            if (skill.Level < skill.MaxLevel)
+            {
+                SkillUnlockedComponent.TryUpgradeSkill(skill);
+                if (!skill.IsActive) SkillUnlockedComponent.SkillManager.ToggleSkillActivation(skill);
+            }
+            else
+            {
+                SkillUnlockedComponent.SkillManager.ToggleSkillActivation(skill);
+            }
+        }
+        else
+        {
+            SkillUnlockedComponent.TryUnlockSkill(skill);
+        }
+    }
+
+    private void RemoveButton(SkillData skill)
+    {
+        foreach (var node in ToUnlockGrid.GetChildren())
+        {
+            var child = (Button)node;
+            if (child.Text != GetButtonText(skill)) continue;
+            
+            child.QueueFree();
+            break;
+        }
+    }
+
+    private void OnSkillButtonPressed(SkillButton button)
+    {
+        SkillUnlockedComponent.SkillManager.ToggleSkillActivation(button.Data);
+    }
+}

scripts/UI/Marketplace.cs.uid

@@ -0,0 +1 @@
+uid://bnc16gndpl87i

scripts/UI/MarketplaceButton.cs

@@ -0,0 +1,62 @@
+using Godot;
+using Mr.BrickAdventures.Autoloads;
+using Mr.BrickAdventures.scripts.components;
+using Mr.BrickAdventures.scripts.Resources;
+
+namespace Mr.BrickAdventures.scripts.UI;
+
+public partial class MarketplaceButton : Button
+{
+    [Export] public SkillData Data { get; set; }
+    [Export] public Texture2D UnlockedSkillIcon { get; set; }
+    [Export] public Texture2D LockedSkillIcon { get; set; }
+    [Export] public Container SkillLevelContainer { get; set; }
+    
+    private GameManager _gameManager;
+    private SkillUnlockedComponent _skillUnlockedComponent;
+
+    public override void _Ready()
+    {
+        _gameManager = GetNode<GameManager>("/root/GameManager");
+        
+        Setup();
+        var player = _gameManager.Player;
+
+        var skillUnlockerComponent = player?.GetNodeOrNull<SkillUnlockedComponent>("SkillUnlockerComponent");
+        if (skillUnlockerComponent == null) return;
+        
+        skillUnlockerComponent.SkillUnlocked += OnSkillUnlock;
+    }
+
+    public override void _ExitTree()
+    {
+        _skillUnlockedComponent.SkillUnlocked -= OnSkillUnlock;
+    }
+
+    private void Setup()
+    {
+        if (Data == null) return;
+        
+        for (var i = 0; i < Data.MaxLevel; i++)
+        {
+            var icon = new TextureRect()
+            {
+                Texture = i < Data.Level ? UnlockedSkillIcon : LockedSkillIcon,
+            };
+            SkillLevelContainer.AddChild(icon);
+        }
+    }
+
+    private void OnSkillUnlock(SkillData skill)
+    {
+        if (skill.Name != Data.Name) return;
+
+        for (var i = 0; i < Data.MaxLevel; i++)
+        {
+            var icon = SkillLevelContainer.GetChildOrNull<TextureRect>(i);
+            if (icon == null) continue;
+            icon.Texture = i < Data.Level ? UnlockedSkillIcon : LockedSkillIcon;
+            Disabled = i >= Data.Level;
+        }
+    }
+}

scripts/UI/MarketplaceButton.cs.uid

@@ -0,0 +1 @@
+uid://vokgv56bjpf1

scripts/UI/PauseMenu.cs

@@ -0,0 +1,67 @@
+using Godot;
+using Mr.BrickAdventures.Autoloads;
+
+namespace Mr.BrickAdventures.scripts.UI;
+
+public partial class PauseMenu : Node
+{
+    [Export] public Control PauseMenuControl { get; set; }
+    [Export] public Control SettingsControl { get; set; }
+    [Export] public Button ResumeButton { get; set; }
+    [Export] public Button MainMenuButton { get; set; }
+    [Export] public Button QuitButton { get; set; }
+    [Export] public Button SettingsButton { get; set; }
+    [Export] public PackedScene MainMenuScene { get; set; }
+
+    private GameManager _gameManager;
+    private UIManager _uiManager;
+
+    public override void _Ready()
+    {
+        _gameManager = GetNode<GameManager>("/root/GameManager");
+        _uiManager = GetNode<UIManager>("/root/UIManager");
+
+        ResumeButton.Pressed += OnResumePressed;
+        MainMenuButton.Pressed += OnMainMenuPressed;
+        QuitButton.Pressed += OnQuitPressed;
+        SettingsButton.Pressed += OnSettingsPressed;
+
+        PauseMenuControl.Hide();
+    }
+
+    public override void _UnhandledInput(InputEvent @event)
+    {
+        if (!@event.IsActionPressed("pause")) return;
+        if (_uiManager.IsVisibleOnStack(PauseMenuControl))
+            OnResumePressed();
+        else
+        {
+            _uiManager.PushScreen(PauseMenuControl);
+            _gameManager.PauseGame();
+        }
+    }
+
+    private void OnSettingsPressed()
+    {
+        _uiManager.PushScreen(SettingsControl);
+        _gameManager.PauseGame();
+    }
+
+    private void OnQuitPressed()
+    {
+        _gameManager.QuitGame();
+    }
+
+    private void OnMainMenuPressed()
+    {
+        _gameManager.ResumeGame();
+        _gameManager.ResetCurrentSessionState();
+        GetTree().ChangeSceneToPacked(MainMenuScene);
+    }
+
+    private void OnResumePressed()
+    {
+        _uiManager.PopScreen();
+        _gameManager.ResumeGame();
+    }
+}

scripts/UI/PauseMenu.cs.uid

@@ -0,0 +1 @@
+uid://cakgxndurgfa3

scripts/UI/SettingsMenu.cs

@@ -0,0 +1,60 @@
+using Godot;
+using Mr.BrickAdventures.Autoloads;
+
+namespace Mr.BrickAdventures.scripts.UI;
+
+public partial class SettingsMenu : Node
+{
+    [Export] public Control InputSettingsControl { get; set; }
+    [Export] public Control AudioSettingsControl { get; set; }
+    [Export] public Control DisplaySettingsControl { get; set; }
+    [Export] public Control GameplaySettingsControl { get; set; }
+    [Export] public Control SettingsMenuControl { get; set; }
+    [Export] public Button InputSettingsButton { get; set; }
+    [Export] public Button AudioSettingsButton { get; set; }
+    [Export] public Button DisplaySettingsButton { get; set; }
+    [Export] public Button GameplaySettingsButton { get; set; }
+    
+    private UIManager _uiManager;
+    
+    public override void _Ready()
+    {
+        _uiManager = GetNode<UIManager>("/root/UIManager");
+        
+        InputSettingsButton.Pressed += OnInputSettingsPressed;
+        AudioSettingsButton.Pressed += OnAudioSettingsPressed;
+        DisplaySettingsButton.Pressed += OnDisplaySettingsPressed;
+        GameplaySettingsButton.Pressed += OnGameplaySettingsPressed;
+        
+        InputSettingsControl.Hide();
+        AudioSettingsControl.Hide();
+        DisplaySettingsControl.Hide();
+        GameplaySettingsControl.Hide();
+    }
+
+    public override void _UnhandledInput(InputEvent @event)
+    {
+        if (!@event.IsActionPressed("ui_cancel")) return;
+        if (_uiManager.IsScreenOnTop(SettingsMenuControl)) _uiManager.PopScreen();
+    }
+
+    private void OnInputSettingsPressed()
+    {
+        _uiManager.PushScreen(InputSettingsControl);
+    }
+
+    private void OnAudioSettingsPressed()
+    {
+        _uiManager.PushScreen(AudioSettingsControl);
+    }
+
+    private void OnDisplaySettingsPressed()
+    {
+        _uiManager.PushScreen(DisplaySettingsControl);
+    }
+
+    private void OnGameplaySettingsPressed()
+    {
+        _uiManager.PushScreen(GameplaySettingsControl);
+    }
+}

scripts/UI/SettingsMenu.cs.uid

@@ -0,0 +1 @@
+uid://i8j47qnrytuo

scripts/UI/SkillButton.cs

@@ -0,0 +1,25 @@
+using Godot;
+using Mr.BrickAdventures.scripts.Resources;
+
+namespace Mr.BrickAdventures.scripts.UI;
+
+public partial class SkillButton : Button
+{
+    [Export] public SkillData Data { get; set; }
+
+    public void Setup()
+    {
+        Icon = Data?.Icon;
+        Text = Tr(Data?.Name) ?? string.Empty;
+    }
+
+    public void Activate()
+    {
+        Set("theme_override_colors/font_color", new Color("#49aa10"));
+    }
+
+    public void Deactivate()
+    {
+        Set("theme_override_colors/font_color", new Color("#ffffff"));
+    }
+}

scripts/UI/SkillButton.cs.uid

@@ -0,0 +1 @@
+uid://bw8dlgq86jrtt