Data-oriented Construction System (#2152)

- Powerful
- Data-oriented
- Approved by PJB
- Powered by node graphs and AI pathfinding
- Coded by the same nerd who brought you atmos

Co-authored-by: Exp <theexp111@gmail.com>

Content.Client/Construction/ConstructionMenu.cs

@@ -1,20 +1,28 @@
-using System;
+#nullable enable
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Content.Client.GameObjects.EntitySystems;
+using Content.Client.Utility;
 using Content.Shared.Construction;
+using Content.Shared.GameObjects.Components;
 using Content.Shared.GameObjects.Components.Interactable;
+using Content.Shared.Materials;
+using Microsoft.CodeAnalysis.Options;
 using Robust.Client.Graphics;
 using Robust.Client.Interfaces.Placement;
 using Robust.Client.Interfaces.ResourceManagement;
 using Robust.Client.Placement;
 using Robust.Client.ResourceManagement;
+using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.Utility;
 using Robust.Shared.Enums;
+using Robust.Shared.GameObjects.Systems;
 using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.Localization;
 using Robust.Shared.Maths;
 using Robust.Shared.Prototypes;
 
@@ -25,376 +33,424 @@ namespace Content.Client.Construction
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
         [Dependency] private readonly IResourceCache _resourceCache = default!;
         [Dependency] private readonly IEntitySystemManager _systemManager = default!;
+        [Dependency] private readonly IPlacementManager _placementManager = default!;
 
-        private readonly Button BuildButton;
-        private readonly Button EraseButton;
-        private readonly LineEdit SearchBar;
-        private readonly Tree RecipeList;
-        private readonly TextureRect InfoIcon;
-        private readonly Label InfoLabel;
-        private readonly ItemList StepList;
+        protected override Vector2? CustomSize => (720, 320);
 
-        private CategoryNode RootCategory;
+        private ConstructionPrototype? _selected;
+        private string[] _categories = Array.Empty<string>();
 
-        // This list is flattened in such a way that the top most deepest category is first.
-        private List<CategoryNode> FlattenedCategories;
-        private readonly PlacementManager Placement;
-
-        protected override Vector2? CustomSize => (500, 350);
+        private readonly ItemList _recipes;
+        private readonly ItemList _stepList;
+        private readonly Button _buildButton;
+        private readonly Button _eraseButton;
+        private readonly LineEdit _searchBar;
+        private readonly OptionButton _category;
+        private readonly TextureRect _targetTexture;
+        private readonly RichTextLabel _targetName;
+        private readonly RichTextLabel _targetDescription;
 
         public ConstructionMenu()
         {
             IoCManager.InjectDependencies(this);
-            Placement = (PlacementManager) IoCManager.Resolve<IPlacementManager>();
-            Placement.PlacementChanged += OnPlacementChanged;
+
+            _placementManager.PlacementChanged += PlacementChanged;
 
             Title = "Construction";
 
-            var hSplitContainer = new HSplitContainer();
+            var hbox = new HBoxContainer() {SizeFlagsHorizontal = SizeFlags.FillExpand};
 
-            // Left side
-            var recipes = new VBoxContainer {CustomMinimumSize = new Vector2(150.0f, 0.0f)};
-            SearchBar = new LineEdit {PlaceHolder = "Search"};
-            RecipeList = new Tree {SizeFlagsVertical = SizeFlags.FillExpand, HideRoot = true};
-            recipes.AddChild(SearchBar);
-            recipes.AddChild(RecipeList);
-            hSplitContainer.AddChild(recipes);
+            var recipeContainer = new VBoxContainer() {SizeFlagsHorizontal = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.45f};
 
-            // Right side
-            var guide = new VBoxContainer();
-            var info = new HBoxContainer();
-            InfoIcon = new TextureRect();
-            InfoLabel = new Label
-            {
-                SizeFlagsHorizontal = SizeFlags.FillExpand, SizeFlagsVertical = SizeFlags.ShrinkCenter
-            };
-            info.AddChild(InfoIcon);
-            info.AddChild(InfoLabel);
-            guide.AddChild(info);
+            var searchContainer = new HBoxContainer() {SizeFlagsVertical = SizeFlags.FillExpand, SizeFlagsHorizontal = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.1f};
+            _searchBar = new LineEdit() {PlaceHolder = "Search", SizeFlagsHorizontal = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.6f};
+            _category = new OptionButton() {SizeFlagsHorizontal = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.4f};
 
-            var stepsLabel = new Label
-            {
-                SizeFlagsHorizontal = SizeFlags.ShrinkCenter,
-                SizeFlagsVertical = SizeFlags.ShrinkCenter,
-                Text = "Steps"
-            };
-            guide.AddChild(stepsLabel);
+            _recipes = new ItemList() {SelectMode = ItemList.ItemListSelectMode.Single, SizeFlagsVertical = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.9f};
 
-            StepList = new ItemList
-            {
-                SizeFlagsVertical = SizeFlags.FillExpand, SelectMode = ItemList.ItemListSelectMode.None
-            };
-            guide.AddChild(StepList);
+            var spacer = new Control() {SizeFlagsHorizontal = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.05f};
 
-            var buttonsContainer = new HBoxContainer();
-            BuildButton = new Button
-            {
-                SizeFlagsHorizontal = SizeFlags.FillExpand,
-                TextAlign = Label.AlignMode.Center,
-                Text = "Build!",
-                Disabled = true,
-                ToggleMode = true
-            };
-            EraseButton = new Button
-            {
-                TextAlign = Label.AlignMode.Center, Text = "Clear Ghosts", ToggleMode = true
-            };
-            buttonsContainer.AddChild(BuildButton);
-            buttonsContainer.AddChild(EraseButton);
-            guide.AddChild(buttonsContainer);
+            var stepsContainer = new VBoxContainer() {SizeFlagsHorizontal = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.45f};
+            var targetContainer = new HBoxContainer() {Align = BoxContainer.AlignMode.Center, SizeFlagsVertical = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.25f};
+            _targetTexture = new TextureRect() {SizeFlagsHorizontal = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.15f, Stretch = TextureRect.StretchMode.KeepCentered};
+            var targetInfoContainer = new VBoxContainer() {SizeFlagsHorizontal = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.85f};
+            _targetName = new RichTextLabel() {SizeFlagsVertical = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.1f};
+            _targetDescription = new RichTextLabel() {SizeFlagsVertical = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.9f};
 
-            hSplitContainer.AddChild(guide);
-            Contents.AddChild(hSplitContainer);
+            _stepList = new ItemList() {SizeFlagsVertical = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.75f, SelectMode = ItemList.ItemListSelectMode.None};
 
-            BuildButton.OnToggled += OnBuildToggled;
-            EraseButton.OnToggled += OnEraseToggled;
-            SearchBar.OnTextChanged += OnTextEntered;
-            RecipeList.OnItemSelected += OnItemSelected;
+            var buttonContainer = new VBoxContainer() {SizeFlagsVertical = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.1f};
+            _buildButton = new Button() {Disabled = true, ToggleMode = true, Text = Loc.GetString("Place construction ghost"), SizeFlagsVertical = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.5f};
 
-            PopulatePrototypeList();
-            PopulateTree();
+            var eraseContainer = new HBoxContainer() {SizeFlagsVertical = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.5f};
+            _eraseButton = new Button() {Text = Loc.GetString("Eraser Mode"), ToggleMode = true, SizeFlagsHorizontal = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.7f};
+            var clearButton = new Button() {Text = Loc.GetString("Clear All"), SizeFlagsHorizontal = SizeFlags.FillExpand, SizeFlagsStretchRatio = 0.3f};
+
+            recipeContainer.AddChild(searchContainer);
+            recipeContainer.AddChild(_recipes);
+
+            searchContainer.AddChild(_searchBar);
+            searchContainer.AddChild(_category);
+
+            targetInfoContainer.AddChild(_targetName);
+            targetInfoContainer.AddChild(_targetDescription);
+
+            targetContainer.AddChild(_targetTexture);
+            targetContainer.AddChild(targetInfoContainer);
+
+            stepsContainer.AddChild(targetContainer);
+            stepsContainer.AddChild(_stepList);
+
+            eraseContainer.AddChild(_eraseButton);
+            eraseContainer.AddChild(clearButton);
+
+            buttonContainer.AddChild(_buildButton);
+            buttonContainer.AddChild(eraseContainer);
+
+            stepsContainer.AddChild(buttonContainer);
+
+            hbox.AddChild(recipeContainer);
+            hbox.AddChild(spacer);
+            hbox.AddChild(stepsContainer);
+            Contents.AddChild(hbox);
+
+            _recipes.OnItemSelected += RecipeSelected;
+            _recipes.OnItemDeselected += RecipeDeselected;
+
+            _searchBar.OnTextChanged += SearchTextChanged;
+            _category.OnItemSelected += CategorySelected;
+
+            _buildButton.OnToggled += BuildButtonToggled;
+            clearButton.OnPressed += ClearAllButtonPressed;
+            _eraseButton.OnToggled += EraseButtonToggled;
+
+            PopulateCategories();
+            PopulateAll();
+        }
+
+        private void PlacementChanged(object? sender, EventArgs e)
+        {
+            _buildButton.Pressed = false;
+            _eraseButton.Pressed = false;
+        }
+
+        private void PopulateAll()
+        {
+            foreach (var recipe in _prototypeManager.EnumeratePrototypes<ConstructionPrototype>())
+            {
+                _recipes.Add(GetItem(recipe, _recipes));
+            }
+        }
+
+        private static ItemList.Item GetItem(ConstructionPrototype recipe, ItemList itemList)
+        {
+            return new ItemList.Item(itemList)
+            {
+                Metadata = recipe,
+                Text = recipe.Name,
+                Icon = recipe.Icon.Frame0(),
+                TooltipEnabled = true,
+                TooltipText = recipe.Description,
+            };
+        }
+
+        private void PopulateBy(string search, string category)
+        {
+            _recipes.Clear();
+
+            foreach (var recipe in _prototypeManager.EnumeratePrototypes<ConstructionPrototype>())
+            {
+                if (!string.IsNullOrEmpty(search))
+                {
+                    if (!recipe.Name.ToLowerInvariant().Contains(search.Trim().ToLowerInvariant()))
+                        continue;
+                }
+
+                if (!string.IsNullOrEmpty(category) && category != Loc.GetString("All"))
+                {
+                    if (recipe.Category != category)
+                        continue;
+                }
+
+                _recipes.Add(GetItem(recipe, _recipes));
+            }
+        }
+
+        private void PopulateCategories()
+        {
+            var uniqueCategories = new HashSet<string>();
+
+            // hard-coded to show all recipes
+            uniqueCategories.Add(Loc.GetString("All"));
+
+            foreach (var prototype in _prototypeManager.EnumeratePrototypes<ConstructionPrototype>())
+            {
+                var category = Loc.GetString(prototype.Category);
+
+                if (!string.IsNullOrEmpty(category))
+                    uniqueCategories.Add(category);
+            }
+
+            _category.Clear();
+
+            var array = uniqueCategories.ToArray();
+            Array.Sort(array);
+
+            for (var i = 0; i < array.Length; i++)
+            {
+                var category = array[i];
+                _category.AddItem(category, i);
+            }
+
+            _categories = array;
+        }
+
+        private void PopulateInfo(ConstructionPrototype prototype)
+        {
+            ClearInfo();
+
+            var isItem = prototype.Type == ConstructionType.Item;
+
+            _buildButton.Disabled = false;
+            _buildButton.Text = Loc.GetString(!isItem ? "Place construction ghost" : "Craft");
+            _targetName.SetMessage(prototype.Name);
+            _targetDescription.SetMessage(prototype.Description);
+            _targetTexture.Texture = prototype.Icon.Frame0();
+
+            if (!_prototypeManager.TryIndex(prototype.Graph, out ConstructionGraphPrototype graph))
+                return;
+
+            var startNode = graph.Nodes[prototype.StartNode];
+            var targetNode = graph.Nodes[prototype.TargetNode];
+
+            var path = graph.Path(startNode.Name, targetNode.Name);
+
+            var current = startNode;
+
+            var stepNumber = 1;
+
+            Texture? GetTextureForStep(ConstructionGraphStep step)
+            {
+                switch (step)
+                {
+                    case MaterialConstructionGraphStep materialStep:
+                        switch (materialStep.Material)
+                        {
+                            case StackType.Metal:
+                                return _resourceCache.GetTexture("/Textures/Objects/Materials/sheets.rsi/metal.png");
+
+                            case StackType.Glass:
+                                return _resourceCache.GetTexture("/Textures/Objects/Materials/sheets.rsi/glass.png");
+
+                            case StackType.Plasteel:
+                                return _resourceCache.GetTexture("/Textures/Objects/Materials/sheets.rsi/plasteel.png");
+
+                            case StackType.Phoron:
+                                return _resourceCache.GetTexture("/Textures/Objects/Materials/sheets.rsi/phoron.png");
+
+                            case StackType.Cable:
+                                return _resourceCache.GetTexture("/Textures/Objects/Tools/cables.rsi/coil-30.png");
+
+                        }
+                        break;
+
+                    case ToolConstructionGraphStep toolStep:
+                        switch (toolStep.Tool)
+                        {
+                            case ToolQuality.Anchoring:
+                                return _resourceCache.GetTexture("/Textures/Objects/Tools/wrench.rsi/icon.png");
+                            case ToolQuality.Prying:
+                                return _resourceCache.GetTexture("/Textures/Objects/Tools/crowbar.rsi/icon.png");
+                            case ToolQuality.Screwing:
+                                return _resourceCache.GetTexture("/Textures/Objects/Tools/screwdriver.rsi/screwdriver-map.png");
+                            case ToolQuality.Cutting:
+                                return _resourceCache.GetTexture("/Textures/Objects/Tools/wirecutters.rsi/cutters-map.png");
+                            case ToolQuality.Welding:
+                                return _resourceCache.GetTexture("/Textures/Objects/Tools/welder.rsi/welder.png");
+                            case ToolQuality.Multitool:
+                                return _resourceCache.GetTexture("/Textures/Objects/Tools/multitool.rsi/multitool.png");
+                        }
+
+                        break;
+
+                    case ComponentConstructionGraphStep componentStep:
+                        return componentStep.Icon?.Frame0();
+
+                    case PrototypeConstructionGraphStep prototypeStep:
+                        return prototypeStep.Icon?.Frame0();
+
+                    case NestedConstructionGraphStep _:
+                        return null;
+                }
+
+                return null;
+            }
+
+            foreach (var node in path)
+            {
+                var edge = current.GetEdge(node.Name);
+                var firstNode = current == startNode;
+
+                if (firstNode)
+                {
+                    _stepList.AddItem(isItem
+                        ? Loc.GetString($"{stepNumber++}. To craft this item, you need:")
+                        : Loc.GetString($"{stepNumber++}. To build this, first you need:"));
+                }
+
+                foreach (var step in edge.Steps)
+                {
+                    var icon = GetTextureForStep(step);
+
+                    switch (step)
+                    {
+                        case MaterialConstructionGraphStep materialStep:
+                            _stepList.AddItem(
+                                !firstNode
+                                    ? Loc.GetString(
+                                        "{0}. Add {1}x {2}.", stepNumber++, materialStep.Amount, materialStep.Material)
+                                    : Loc.GetString("      {0}x {1}", materialStep.Amount, materialStep.Material), icon);
+
+                            break;
+
+                        case ToolConstructionGraphStep toolStep:
+                            _stepList.AddItem(Loc.GetString("{0}. Use a {1}.", stepNumber++, toolStep.Tool.GetToolName()), icon);
+                            break;
+
+                        case PrototypeConstructionGraphStep prototypeStep:
+                            _stepList.AddItem(Loc.GetString("{0}. Add {1}.", stepNumber++, prototypeStep.Name), icon);
+                            break;
+
+                        case ComponentConstructionGraphStep componentStep:
+                            _stepList.AddItem(Loc.GetString("{0}. Add {1}.", stepNumber++, componentStep.Name), icon);
+                            break;
+
+                        case NestedConstructionGraphStep nestedStep:
+                            var parallelNumber = 1;
+                            _stepList.AddItem(Loc.GetString("{0}. In parallel...", stepNumber++));
+
+                            foreach (var steps in nestedStep.Steps)
+                            {
+                                var subStepNumber = 1;
+
+                                foreach (var subStep in steps)
+                                {
+                                    icon = GetTextureForStep(subStep);
+
+                                    switch (subStep)
+                                    {
+                                        case MaterialConstructionGraphStep materialStep:
+                                            if (!isItem)
+                                                _stepList.AddItem(Loc.GetString("    {0}.{1}.{2}. Add {3}x {4}.", stepNumber, parallelNumber, subStepNumber++, materialStep.Amount, materialStep.Material), icon);
+                                            break;
+
+                                        case ToolConstructionGraphStep toolStep:
+                                            _stepList.AddItem(Loc.GetString("    {0}.{1}.{2}. Use a {3}.", stepNumber, parallelNumber, subStepNumber++, toolStep.Tool.GetToolName()), icon);
+                                            break;
+
+                                        case PrototypeConstructionGraphStep prototypeStep:
+                                            _stepList.AddItem(Loc.GetString("    {0}.{1}.{2}. Add {3}.", stepNumber, parallelNumber, subStepNumber++, prototypeStep.Name), icon);
+                                            break;
+
+                                        case ComponentConstructionGraphStep componentStep:
+                                            _stepList.AddItem(Loc.GetString("    {0}.{1}.{2}. Add {3}.", stepNumber, parallelNumber, subStepNumber++, componentStep.Name), icon);
+                                            break;
+                                    }
+                                }
+
+                                parallelNumber++;
+                            }
+
+                            break;
+                    }
+                }
+
+                current = node;
+            }
+        }
+
+        private void ClearInfo()
+        {
+            _buildButton.Disabled = true;
+            _targetName.SetMessage(string.Empty);
+            _targetDescription.SetMessage(string.Empty);
+            _targetTexture.Texture = null;
+            _stepList.Clear();
+        }
+
+        private void RecipeSelected(ItemList.ItemListSelectedEventArgs obj)
+        {
+            _selected = (ConstructionPrototype) obj.ItemList[obj.ItemIndex].Metadata!;
+            PopulateInfo(_selected);
+        }
+
+        private void RecipeDeselected(ItemList.ItemListDeselectedEventArgs obj)
+        {
+            _selected = null;
+            ClearInfo();
+        }
+
+        private void CategorySelected(OptionButton.ItemSelectedEventArgs obj)
+        {
+            _category.SelectId(obj.Id);
+            PopulateBy(_searchBar.Text, _categories[obj.Id]);
+        }
+
+        private void SearchTextChanged(LineEdit.LineEditEventArgs obj)
+        {
+            PopulateBy(_searchBar.Text, _categories[_category.SelectedId]);
+        }
+
+        private void BuildButtonToggled(BaseButton.ButtonToggledEventArgs args)
+        {
+            if (args.Pressed)
+            {
+                if (_selected == null) return;
+
+                var constructSystem = EntitySystem.Get<ConstructionSystem>();
+
+                if (_selected.Type == ConstructionType.Item)
+                {
+                    constructSystem.TryStartItemConstruction(_selected.ID);
+                    _buildButton.Pressed = false;
+                    return;
+                }
+
+                _placementManager.BeginPlacing(new PlacementInformation()
+                {
+                    IsTile = false,
+                    PlacementOption = _selected.PlacementMode,
+                }, new ConstructionPlacementHijack(constructSystem, _selected));
+            }
+            else
+            {
+                _placementManager.Clear();
+            }
+
+            _buildButton.Pressed = args.Pressed;
+        }
+
+        private void EraseButtonToggled(BaseButton.ButtonToggledEventArgs args)
+        {
+            if (args.Pressed) _placementManager.Clear();
+            _placementManager.ToggleEraserHijacked(new ConstructionPlacementHijack(_systemManager.GetEntitySystem<ConstructionSystem>(), null));
+            _eraseButton.Pressed = args.Pressed;
+        }
+
+        private void ClearAllButtonPressed(BaseButton.ButtonEventArgs obj)
+        {
+            var constructionSystem = EntitySystem.Get<ConstructionSystem>();
+
+            constructionSystem.ClearAllGhosts();
         }
 
-        /// <inheritdoc />
         protected override void Dispose(bool disposing)
         {
             base.Dispose(disposing);
 
             if (disposing)
             {
-                Placement.PlacementChanged -= OnPlacementChanged;
-            }
-        }
-
-        private void OnItemSelected()
-        {
-            var prototype = (ConstructionPrototype) RecipeList.Selected.Metadata;
-
-            if (prototype == null)
-            {
-                InfoLabel.Text = "";
-                InfoIcon.Texture = null;
-                StepList.Clear();
-                BuildButton.Disabled = true;
-            }
-            else
-            {
-                BuildButton.Disabled = false;
-                InfoLabel.Text = prototype.Description;
-                InfoIcon.Texture = prototype.Icon.Frame0();
-
-                StepList.Clear();
-
-                foreach (var forward in prototype.Stages.Select(a => a.Forward))
-                {
-                    if (forward == null)
-                    {
-                        continue;
-                    }
-
-                    Texture icon;
-                    string text;
-                    switch (forward)
-                    {
-                        case ConstructionStepMaterial mat:
-                            switch (mat.Material)
-                            {
-                                case ConstructionStepMaterial.MaterialType.Metal:
-                                    icon = _resourceCache.GetResource<TextureResource>(
-                                        "/Textures/Objects/Materials/sheet_metal.png");
-                                    text = $"Metal x{mat.Amount}";
-                                    break;
-                                case ConstructionStepMaterial.MaterialType.Glass:
-                                    icon = _resourceCache.GetResource<TextureResource>(
-                                        "/Textures/Objects/Materials/sheet_glass.png");
-                                    text = $"Glass x{mat.Amount}";
-                                    break;
-                                case ConstructionStepMaterial.MaterialType.Cable:
-                                    icon = _resourceCache.GetResource<TextureResource>(
-                                        "/Textures/Objects/Tools/cable_coil.png");
-                                    text = $"Cable Coil x{mat.Amount}";
-                                    break;
-                                default:
-                                    throw new NotImplementedException();
-                            }
-
-                            break;
-                        case ConstructionStepTool tool:
-                            switch (tool.ToolQuality)
-                            {
-                                case ToolQuality.Anchoring:
-                                    icon = _resourceCache.GetResource<TextureResource>("/Textures/Objects/Tools/wrench.rsi/icon.png");
-                                    text = "Wrench";
-                                    break;
-                                case ToolQuality.Prying:
-                                    icon = _resourceCache.GetResource<TextureResource>("/Textures/Objects/Tools/crowbar.rsi/icon.png");
-                                    text = "Crowbar";
-                                    break;
-                                case ToolQuality.Screwing:
-                                    icon = _resourceCache.GetResource<TextureResource>(
-                                        "/Textures/Objects/Tools/screwdriver.rsi/screwdriver-map.png");
-                                    text = "Screwdriver";
-                                    break;
-                                case ToolQuality.Welding:
-                                    icon = _resourceCache.GetResource<RSIResource>("/Textures/Objects/tools.rsi")
-                                        .RSI["welder"].Frame0;
-                                    text = $"Welding tool ({tool.Amount} fuel)";
-                                    break;
-                                case ToolQuality.Cutting:
-                                    icon = _resourceCache.GetResource<TextureResource>(
-                                        "/Textures/Objects/Tools/wirecutters.rsi/cutters-map.png");
-                                    text = "Wirecutters";
-                                    break;
-                                default:
-                                    throw new NotImplementedException();
-                            }
-
-                            break;
-                        default:
-                            throw new NotImplementedException();
-                    }
-
-                    StepList.AddItem(text, icon, false);
-                }
-            }
-        }
-
-        private void OnTextEntered(LineEdit.LineEditEventArgs args)
-        {
-            var str = args.Text;
-            PopulateTree(string.IsNullOrWhiteSpace(str) ? null : str.ToLowerInvariant());
-        }
-
-        private void OnBuildToggled(BaseButton.ButtonToggledEventArgs args)
-        {
-            if (args.Pressed)
-            {
-                var prototype = (ConstructionPrototype) RecipeList.Selected.Metadata;
-                if (prototype == null)
-                {
-                    return;
-                }
-
-                if (prototype.Type == ConstructionType.Item)
-                {
-                    var constructSystem = _systemManager.GetEntitySystem<ConstructionSystem>();
-                    constructSystem.TryStartItemConstruction(prototype.ID);
-                    BuildButton.Pressed = false;
-                    return;
-                }
-
-                Placement.BeginHijackedPlacing(
-                    new PlacementInformation
-                    {
-                        IsTile = false,
-                        PlacementOption = prototype.PlacementMode
-                    },
-                    new ConstructionPlacementHijack(_systemManager.GetEntitySystem<ConstructionSystem>(), prototype));
-            }
-            else
-            {
-                Placement.Clear();
-            }
-            BuildButton.Pressed = args.Pressed;
-        }
-
-        private void OnEraseToggled(BaseButton.ButtonToggledEventArgs args)
-        {
-            if (args.Pressed) Placement.Clear();
-            Placement.ToggleEraserHijacked(new ConstructionPlacementHijack(_systemManager.GetEntitySystem<ConstructionSystem>(), null));
-            EraseButton.Pressed = args.Pressed;
-        }
-
-        private void OnPlacementChanged(object sender, EventArgs e)
-        {
-            BuildButton.Pressed = false;
-            EraseButton.Pressed = false;
-        }
-
-        private void PopulatePrototypeList()
-        {
-            RootCategory = new CategoryNode("", null);
-            var count = 1;
-
-            foreach (var prototype in _prototypeManager.EnumeratePrototypes<ConstructionPrototype>())
-            {
-                var currentNode = RootCategory;
-
-                foreach (var category in prototype.CategorySegments)
-                {
-                    if (!currentNode.ChildCategories.TryGetValue(category, out var subNode))
-                    {
-                        count++;
-                        subNode = new CategoryNode(category, currentNode);
-                        currentNode.ChildCategories.Add(category, subNode);
-                    }
-
-                    currentNode = subNode;
-                }
-
-                currentNode.Prototypes.Add(prototype);
-            }
-
-            // Do a pass to sort the prototype lists and flatten the hierarchy.
-            void Recurse(CategoryNode node)
-            {
-                // I give up we're using recursion to flatten this.
-                // There probably IS a way to do it.
-                // I'm too stupid to think of what that way is.
-                foreach (var child in node.ChildCategories.Values)
-                {
-                    Recurse(child);
-                }
-
-                node.Prototypes.Sort(ComparePrototype);
-                FlattenedCategories.Add(node);
-                node.FlattenedIndex = FlattenedCategories.Count - 1;
-            }
-
-            FlattenedCategories = new List<CategoryNode>(count);
-            Recurse(RootCategory);
-        }
-
-        private void PopulateTree(string searchTerm = null)
-        {
-            RecipeList.Clear();
-
-            var categoryItems = new Tree.Item[FlattenedCategories.Count];
-            categoryItems[RootCategory.FlattenedIndex] = RecipeList.CreateItem();
-
-            // Yay more recursion.
-            Tree.Item ItemForNode(CategoryNode node)
-            {
-                if (categoryItems[node.FlattenedIndex] != null)
-                {
-                    return categoryItems[node.FlattenedIndex];
-                }
-
-                var item = RecipeList.CreateItem(ItemForNode(node.Parent));
-                item.Text = node.Name;
-                item.Selectable = false;
-                categoryItems[node.FlattenedIndex] = item;
-                return item;
-            }
-
-            foreach (var node in FlattenedCategories)
-            {
-                foreach (var prototype in node.Prototypes)
-                {
-                    if (searchTerm != null)
-                    {
-                        var found = false;
-                        // TODO: don't run ToLowerInvariant() constantly.
-                        if (prototype.Name.ToLowerInvariant().IndexOf(searchTerm, StringComparison.Ordinal) != -1)
-                        {
-                            found = true;
-                        }
-                        else
-                        {
-                            foreach (var keyw in prototype.Keywords.Concat(prototype.CategorySegments))
-                            {
-                                // TODO: don't run ToLowerInvariant() constantly.
-                                if (keyw.ToLowerInvariant().IndexOf(searchTerm, StringComparison.Ordinal) != -1)
-                                {
-                                    found = true;
-                                    break;
-                                }
-                            }
-                        }
-
-                        if (!found)
-                        {
-                            continue;
-                        }
-                    }
-
-                    var subItem = RecipeList.CreateItem(ItemForNode(node));
-                    subItem.Text = prototype.Name;
-                    subItem.Metadata = prototype;
-                }
-            }
-        }
-
-        private static int ComparePrototype(ConstructionPrototype x, ConstructionPrototype y)
-        {
-            return string.Compare(x.Name, y.Name, StringComparison.Ordinal);
-        }
-
-        private class CategoryNode
-        {
-            public readonly string Name;
-            public readonly CategoryNode Parent;
-
-            public readonly SortedDictionary<string, CategoryNode>
-                ChildCategories = new SortedDictionary<string, CategoryNode>();
-
-            public readonly List<ConstructionPrototype> Prototypes = new List<ConstructionPrototype>();
-            public int FlattenedIndex = -1;
-
-            public CategoryNode(string name, CategoryNode parent)
-            {
-                Name = name;
-                Parent = parent;
+                _placementManager.PlacementChanged -= PlacementChanged;
             }
         }
     }

Content.Client/GameObjects/Components/Construction/ConstructionGhostComponent.cs

@@ -1,8 +1,9 @@
 using Content.Shared.Construction;
 using Content.Shared.GameObjects.EntitySystems;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.IoC;
 using Robust.Shared.Localization;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
 
@@ -11,6 +12,8 @@ namespace Content.Client.GameObjects.Components.Construction
     [RegisterComponent]
     public class ConstructionGhostComponent : Component, IExamine
     {
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
         public override string Name => "ConstructionGhost";
 
         [ViewVariables] public ConstructionPrototype Prototype { get; set; }
@@ -18,8 +21,13 @@ namespace Content.Client.GameObjects.Components.Construction
 
         void IExamine.Examine(FormattedMessage message, bool inDetailsRange)
         {
-            message.AddText(Loc.GetString("Building: {0}\n", Prototype.Name));
-            EntitySystem.Get<SharedConstructionSystem>().DoExamine(message, Prototype, 0, inDetailsRange);
+            message.AddMarkup(Loc.GetString("Building: [color=cyan]{0}[/color]\n", Prototype.Name));
+
+            if (!_prototypeManager.TryIndex(Prototype.Graph, out ConstructionGraphPrototype graph)) return;
+            var startNode = graph.Nodes[Prototype.StartNode];
+            var path = graph.Path(Prototype.StartNode, Prototype.TargetNode);
+            var edge = startNode.GetEdge(path[0].Name);
+            edge.Steps[0].DoExamine(message, inDetailsRange);
         }
     }
 }

Content.Client/GameObjects/Components/ReinforcedWallComponent.cs

@@ -1,4 +1,5 @@
 using Content.Client.GameObjects.Components.IconSmoothing;
+using Content.Shared.GameObjects.Components;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Serialization;
 using Robust.Shared.ViewVariables;
@@ -35,6 +36,7 @@ namespace Content.Client.GameObjects.Components
             Sprite.LayerSetDirOffset(ReinforcedCornerLayers.NW, DirectionOffset.Flip);
             Sprite.LayerMapSet(ReinforcedCornerLayers.SW, Sprite.AddLayerState(state0));
             Sprite.LayerSetDirOffset(ReinforcedCornerLayers.SW, DirectionOffset.Clockwise);
+            Sprite.LayerMapSet(ReinforcedWallVisualLayers.Deconstruction, Sprite.AddBlankLayer());
         }
 
         internal override void CalculateNewSprite()

Content.Client/GameObjects/Components/ReinforcedWallVisualizer.cs

@@ -0,0 +1,42 @@
+using Content.Shared.GameObjects.Components;
+using JetBrains.Annotations;
+using Robust.Client.GameObjects;
+using Robust.Client.Interfaces.GameObjects.Components;
+
+namespace Content.Client.GameObjects.Components
+{
+    [UsedImplicitly]
+    public class ReinforcedWallVisualizer : AppearanceVisualizer
+    {
+        public override void OnChangeData(AppearanceComponent component)
+        {
+            base.OnChangeData(component);
+
+            if (component.TryGetData(ReinforcedWallVisuals.DeconstructionStage, out int stage))
+            {
+                SetDeconstructionStage(component, stage);
+            }
+        }
+
+        public void SetDeconstructionStage(AppearanceComponent component, int stage)
+        {
+            var entity = component.Owner;
+
+            if (!entity.TryGetComponent(out ISpriteComponent sprite)) return;
+
+            if (stage < 0)
+            {
+                sprite.LayerSetVisible(ReinforcedWallVisualLayers.Deconstruction, false);
+                return;
+            }
+
+            sprite.LayerSetVisible(ReinforcedWallVisualLayers.Deconstruction, true);
+            sprite.LayerSetState(ReinforcedWallVisualLayers.Deconstruction, $"reinf_construct-{stage}");
+        }
+    }
+
+    public enum ReinforcedWallVisualLayers
+    {
+        Deconstruction,
+    }
+}

Content.Client/GameObjects/Components/StackComponent.cs

@@ -11,6 +11,7 @@ using Robust.Shared.ViewVariables;
 namespace Content.Client.GameObjects.Components
 {
     [RegisterComponent]
+    [ComponentReference(typeof(SharedStackComponent))]
     public class StackComponent : SharedStackComponent, IItemStatus
     {
         [ViewVariables(VVAccess.ReadWrite)] private bool _uiUpdateNeeded;

Content.Client/GameObjects/Components/WindowComponent.cs

@@ -1,4 +1,5 @@
 using Content.Client.GameObjects.EntitySystems;
+using Content.Shared.GameObjects.Components;
 using Robust.Client.GameObjects;
 using Robust.Client.Interfaces.GameObjects.Components;
 using Robust.Shared.GameObjects;
@@ -9,10 +10,9 @@ using static Content.Client.GameObjects.Components.IconSmoothing.IconSmoothCompo
 namespace Content.Client.GameObjects.Components
 {
     [RegisterComponent]
-    public sealed class WindowComponent : Component
+    [ComponentReference(typeof(SharedWindowComponent))]
+    public sealed class WindowComponent : SharedWindowComponent
     {
-        public override string Name => "Window";
-
         private string _stateBase;
         private ISpriteComponent _sprite;
         private SnapGridComponent _snapGrid;

Content.Client/GameObjects/EntitySystems/ConstructionSystem.cs

@@ -5,6 +5,7 @@ using Content.Client.UserInterface;
 using Content.Shared.Construction;
 using Content.Shared.GameObjects.EntitySystems;
 using Content.Shared.Input;
+using Content.Shared.Utility;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
 using Robust.Client.GameObjects.EntitySystems;
@@ -152,11 +153,20 @@ namespace Content.Client.GameObjects.EntitySystems
         /// </summary>
         public void SpawnGhost(ConstructionPrototype prototype, EntityCoordinates loc, Direction dir)
         {
-            if (GhostPresent(loc))
+            var user = _playerManager.LocalPlayer?.ControlledEntity;
+
+            // This InRangeUnobstructed should probably be replaced with "is there something blocking us in that tile?"
+            if (user == null || GhostPresent(loc) || !user.InRangeUnobstructed(loc, 20f, ignoreInsideBlocker:prototype.CanBuildInImpassable))
             {
                 return;
             }
 
+            foreach (var condition in prototype.Conditions)
+            {
+                if (!condition.Condition(user, loc, dir))
+                    return;
+            }
+
             var ghost = _entityManager.SpawnEntity("constructionghost", loc);
             var comp = ghost.GetComponent<ConstructionGhostComponent>();
             comp.Prototype = prototype;
@@ -204,7 +214,7 @@ namespace Content.Client.GameObjects.EntitySystems
         }
 
         /// <summary>
-        /// Removes a construction ghost entity with the given ID.
+        ///     Removes a construction ghost entity with the given ID.
         /// </summary>
         public void ClearGhost(int ghostId)
         {
@@ -214,5 +224,18 @@ namespace Content.Client.GameObjects.EntitySystems
                 _ghosts.Remove(ghostId);
             }
         }
+
+        /// <summary>
+        ///     Removes all construction ghosts.
+        /// </summary>
+        public void ClearAllGhosts()
+        {
+            foreach (var (_, ghost) in _ghosts)
+            {
+                ghost.Owner.Delete();
+            }
+
+            _ghosts.Clear();
+        }
     }
 }

Content.Client/GameObjects/EntitySystems/DoAfter/DoAfterSystem.cs

@@ -131,7 +131,12 @@ namespace Content.Client.GameObjects.EntitySystems.DoAfter
 
                 if (doAfter.BreakOnTargetMove)
                 {
-                    var targetEntity = _entityManager.GetEntity(doAfter.TargetUid);
+                    if (!_entityManager.TryGetEntity(doAfter.TargetUid, out var targetEntity))
+                    {
+                        // Cancel if the target entity doesn't exist.
+                        doAfterComponent.Cancel(id, currentTime);
+                        continue;
+                    }
 
                     if (targetEntity.Transform.Coordinates != doAfter.TargetGrid)
                     {

Content.Client/IgnoredComponents.cs

@@ -179,6 +179,8 @@
             "Butcherable",
             "Rehydratable",
             "Headset",
+            "ComputerBoard",
+            "BreakableConstruction",
         };
     }
 }