Blood Cult DLC 1: Make It an Actually Playable Game (Mode)

Content.Client/ListViewSelector/ListViewSelectorBUI.cs

@@ -84,7 +84,7 @@ private void PopulateWindow(List<ListViewSelectorEntry> items)
         {
             var itemName = item.Name;
             var itemDesc = item.Description;
-            if (_prototypeManager.TryIndex(item.Id, out var itemPrototype))
+            if (_prototypeManager.TryIndex(item.Id, out var itemPrototype, false))
             {
                 itemName = itemPrototype.Name;
                 itemDesc = itemPrototype.Description;

Content.Client/WhiteDream/BloodCult/PhaseShift/PhaseShiftSystem.cs

@@ -0,0 +1,5 @@
+using Content.Shared.WhiteDream.BloodCult.Constructs.PhaseShift;
+
+namespace Content.Client.WhiteDream.BloodCult.PhaseShift;
+
+public sealed class PhaseShiftSystem : SharedPhaseShiftSystem;

Content.Client/WhiteDream/BloodCult/Runes/UI/RuneDrawerBUI.cs

@@ -1,5 +1,4 @@
-using System.Linq;
-using System.Numerics;
+using System.Numerics;
 using Content.Client.UserInterface.Controls;
 using Content.Shared.WhiteDream.BloodCult.Runes;
 using JetBrains.Annotations;
@@ -23,71 +22,72 @@ public sealed class RuneDrawerBUI : BoundUserInterface
     [Dependency] private readonly IInputManager _inputManager = default!;
 
     private readonly SpriteSystem _spriteSystem;
-
-    private RadialMenu? _menu;
+    private readonly RadialMenu _menu;
 
     public RuneDrawerBUI(EntityUid owner, Enum uiKey) : base(owner, uiKey)
     {
         _spriteSystem = _entManager.System<SpriteSystem>();
+        _menu = new()
+        {
+            HorizontalExpand = true,
+            VerticalExpand = true,
+            BackButtonStyleClass = "RadialMenuBackButton",
+            CloseButtonStyleClass = "RadialMenuCloseButton"
+        };
     }
 
     protected override void Open()
     {
-        _menu = FormMenu();
         _menu.OnClose += Close;
         _menu.OpenCenteredAt(_inputManager.MouseScreenPosition.Position / _displayManager.ScreenSize);
     }
 
     protected override void Dispose(bool disposing)
     {
         base.Dispose(disposing);
-        if (disposing)
-            _menu?.Dispose();
+        _menu.Close();
     }
 
-    private RadialMenu FormMenu()
+    protected override void UpdateState(BoundUserInterfaceState state)
     {
-        var menu = new RadialMenu
-        {
-            HorizontalExpand = true,
-            VerticalExpand = true,
-            BackButtonStyleClass = "RadialMenuBackButton",
-            CloseButtonStyleClass = "RadialMenuCloseButton"
-        };
-
-        if (!_entManager.HasComponent<RuneDrawerComponent>(Owner))
-            return menu;
+        if (state is RuneDrawerMenuState runeDrawerState)
+            FillMenu(runeDrawerState.AvailalbeRunes);
+    }
 
-        var runeSelectorArray = _protoManager.EnumeratePrototypes<RuneSelectorPrototype>().OrderBy(r => r.ID).ToArray();
+    private void FillMenu(List<ProtoId<RuneSelectorPrototype>>? runes = null)
+    {
+        if (runes is null)
+            return;
 
-        var mainContainer = new RadialContainer
+        var container = new RadialContainer
         {
-            Radius = 36f / (runeSelectorArray.Length == 1
-                ? 1
-                : MathF.Sin(MathF.PI / runeSelectorArray.Length))
+            Radius = 48f + 24f * MathF.Log(runes.Count)
         };
 
-        foreach (var runeSelector in runeSelectorArray)
+        _menu.AddChild(container);
+
+        foreach (var runeSelector in runes)
         {
-            if (!_protoManager.TryIndex(runeSelector.Prototype, out var proto))
+            if (!_protoManager.TryIndex(runeSelector, out var runeSelectorProto) ||
+                !_protoManager.TryIndex(runeSelectorProto.Prototype, out var runeProto))
                 continue;
 
             var itemSize = new Vector2(64f, 64f);
             var button = new RadialMenuTextureButton
             {
-                ToolTip = Loc.GetString(proto.Name),
+                ToolTip = Loc.GetString(runeProto.Name),
                 StyleClasses = { "RadialMenuButton" },
                 SetSize = itemSize
             };
 
-            var runeIcon = _spriteSystem.Frame0(proto);
+            var runeIcon = _spriteSystem.Frame0(runeProto);
             var runeScale = itemSize / runeIcon.Size;
 
             var texture = new TextureRect
             {
                 VerticalAlignment = Control.VAlignment.Center,
                 HorizontalAlignment = Control.HAlignment.Center,
-                Texture = _spriteSystem.Frame0(proto),
+                Texture = _spriteSystem.Frame0(runeProto),
                 TextureScale = runeScale
             };
 
@@ -99,10 +99,7 @@ private RadialMenu FormMenu()
                 Close();
             };
 
-            mainContainer.AddChild(button);
+            container.AddChild(button);
         }
-
-        menu.AddChild(mainContainer);
-        return menu;
     }
 }

Content.Server/WhiteDream/BloodCult/BloodRites/BloodRitesAuraComponent.cs

@@ -51,6 +51,9 @@ public sealed partial class BloodRitesAuraComponent : Component
     [DataField]
     public FixedPoint2 TotalHealing = 20;
 
+    [DataField]
+    public float PuddleConsumeRadius = 0.5f;
+
     [DataField]
     public SoundSpecifier BloodRitesAudio = new SoundPathSpecifier(
         new ResPath("/Audio/WhiteDream/BloodCult/rites.ogg"),

Content.Server/WhiteDream/BloodCult/BloodRites/BloodRitesSystem.cs

@@ -10,7 +10,9 @@
 using Content.Shared.Damage.Prototypes;
 using Content.Shared.DoAfter;
 using Content.Shared.Examine;
+using Content.Shared.Fluids.Components;
 using Content.Shared.Interaction;
+using Content.Shared.Interaction.Events;
 using Content.Shared.Mobs;
 using Content.Shared.Mobs.Components;
 using Content.Shared.UserInterface;
@@ -34,6 +36,7 @@ public sealed class BloodRitesSystem : EntitySystem
     [Dependency] private readonly DamageableSystem _damageable = default!;
     [Dependency] private readonly DoAfterSystem _doAfter = default!;
     [Dependency] private readonly HandsSystem _handsSystem = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
     [Dependency] private readonly TransformSystem _transform = default!;
     [Dependency] private readonly PopupSystem _popup = default!;
     [Dependency] private readonly SharedSolutionContainerSystem _solutionContainer = default!;
@@ -52,6 +55,8 @@ public override void Initialize()
 
         SubscribeLocalEvent<BloodRitesAuraComponent, BeforeActivatableUIOpenEvent>(BeforeUiOpen);
         SubscribeLocalEvent<BloodRitesAuraComponent, BloodRitesMessage>(OnRitesMessage);
+
+        SubscribeLocalEvent<BloodRitesAuraComponent, DroppedEvent>(OnDropped);
     }
 
     private void OnExamining(Entity<BloodRitesAuraComponent> rites, ref ExaminedEvent args) =>
@@ -83,19 +88,16 @@ private void OnAfterInteract(Entity<BloodRitesAuraComponent> rites, ref AfterInt
             return;
         }
 
-        if (!TryComp(args.Target, out SolutionContainerManagerComponent? solutionContainer)) // please send help
-            return;
-
-        foreach (var (_, solution) in _solutionContainer.EnumerateSolutions((args.Target.Value, solutionContainer)))
+        if (HasComp<PuddleComponent>(args.Target))
         {
-            // I don't think something will ever have more than 1000 blood units in it's solution...
-            rites.Comp.StoredBlood += solution.Comp.Solution.RemoveReagent(_bloodProto, 1000);
-            _solutionContainer.UpdateChemicals(solution);
-            break;
+            ConsumePuddles(args.Target.Value, rites);
+            args.Handled = true;
+        }
+        else if (TryComp(args.Target, out SolutionContainerManagerComponent? solutionContainer))
+        {
+            ConsumeBloodFromSolution((args.Target.Value, solutionContainer), rites);
+            args.Handled = true;
         }
-
-        _audio.PlayPvs(rites.Comp.BloodRitesAudio, rites);
-        args.Handled = true;
     }
 
     private void OnDoAfter(Entity<BloodRitesAuraComponent> rites, ref BloodRitesExtractDoAfterEvent args)
@@ -154,6 +156,8 @@ private void OnRitesMessage(Entity<BloodRitesAuraComponent> rites, ref BloodRite
         _handsSystem.TryPickup(args.Actor, ent);
     }
 
+    private void OnDropped(Entity<BloodRitesAuraComponent> rites, ref DroppedEvent args) => QueueDel(rites);
+
     private bool Heal(Entity<BloodRitesAuraComponent> rites, EntityUid user, Entity<DamageableComponent> target)
     {
         if (target.Comp.TotalDamage == 0)
@@ -234,4 +238,36 @@ Entity<BloodstreamComponent> target
         rites.Comp.StoredBlood -= bloodCost;
         return true;
     }
+
+    private void ConsumePuddles(EntityUid origin, Entity<BloodRitesAuraComponent> rites)
+    {
+        var coords = Transform(origin).Coordinates;
+
+        var lookup = _lookup.GetEntitiesInRange<PuddleComponent>(
+            coords,
+            rites.Comp.PuddleConsumeRadius,
+            LookupFlags.Uncontained);
+
+        foreach (var puddle in lookup)
+        {
+            if (!TryComp(puddle, out SolutionContainerManagerComponent? solutionContainer))
+                continue;
+            ConsumeBloodFromSolution((puddle, solutionContainer), rites);
+        }
+
+        _audio.PlayPvs(rites.Comp.BloodRitesAudio, rites);
+    }
+
+    private void ConsumeBloodFromSolution(
+        Entity<SolutionContainerManagerComponent?> ent,
+        Entity<BloodRitesAuraComponent> rites
+    )
+    {
+        foreach (var (_, solution) in _solutionContainer.EnumerateSolutions(ent))
+        {
+            rites.Comp.StoredBlood += solution.Comp.Solution.RemoveReagent(_bloodProto, 1000);
+            _solutionContainer.UpdateChemicals(solution);
+            break;
+        }
+    }
 }

Content.Server/WhiteDream/BloodCult/ConstructActionsSystem.cs

@@ -0,0 +1,67 @@
+using Content.Server.WhiteDream.BloodCult.Constructs.PhaseShift;
+using Content.Shared.StatusEffect;
+using Content.Shared.WhiteDream.BloodCult.Spells;
+using Robust.Server.Audio;
+using Robust.Server.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using PhaseShiftedComponent = Content.Shared.WhiteDream.BloodCult.Constructs.PhaseShift.PhaseShiftedComponent;
+
+namespace Content.Server.WhiteDream.BloodCult;
+
+public sealed class ConstructActionsSystem : EntitySystem
+{
+    [Dependency] private readonly ITileDefinitionManager _tileDef = default!;
+
+    [Dependency] private readonly AudioSystem _audio = default!;
+    [Dependency] private readonly MapSystem _mapSystem = default!;
+    [Dependency] private readonly TransformSystem _transform = default!;
+    [Dependency] private readonly StatusEffectsSystem _statusEffects = default!;
+
+    private const string CultTileSpawnEffect = "CultTileSpawnEffect";
+
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<PlaceTileEntityEvent>(OnPlaceTileEntityEvent);
+        SubscribeLocalEvent<PhaseShiftEvent>(OnPhaseShift);
+    }
+
+    private void OnPlaceTileEntityEvent(PlaceTileEntityEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        if (args.Entity is { } entProtoId)
+            Spawn(entProtoId, args.Target);
+
+        if (args.TileId is { } tileId)
+        {
+            if (_transform.GetGrid(args.Target) is not { } grid || !TryComp(grid, out MapGridComponent? mapGrid))
+                return;
+
+            var tileDef = _tileDef[tileId];
+            var tile = new Tile(tileDef.TileId);
+
+            _mapSystem.SetTile(grid, mapGrid, args.Target, tile);
+            Spawn(CultTileSpawnEffect, args.Target);
+        }
+
+        if (args.Audio is { } audio)
+            _audio.PlayPvs(audio, args.Target);
+
+        args.Handled = true;
+    }
+
+    private void OnPhaseShift(PhaseShiftEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        if (_statusEffects.TryAddStatusEffect<PhaseShiftedComponent>(
+            args.Performer,
+            args.StatusEffectId,
+            args.Duration,
+            false))
+            args.Handled = true;
+    }
+}

Content.Server/WhiteDream/BloodCult/Constructs/ConstructSystem.cs

@@ -1,4 +1,5 @@
-using Content.Server.WhiteDream.BloodCult.Gamerule;
+using Content.Server.Actions;
+using Content.Server.WhiteDream.BloodCult.Gamerule;
 using Content.Shared.WhiteDream.BloodCult;
 using Content.Shared.WhiteDream.BloodCult.Constructs;
 using Robust.Server.GameObjects;
@@ -7,13 +8,14 @@ namespace Content.Server.WhiteDream.BloodCult.Constructs;
 
 public sealed class ConstructSystem : EntitySystem
 {
+    [Dependency] private readonly ActionsSystem _actions = default!;
     [Dependency] private readonly AppearanceSystem _appearanceSystem = default!;
 
     public override void Initialize()
     {
         base.Initialize();
 
-        SubscribeLocalEvent<ConstructComponent, ComponentStartup>(OnComponentStartup);
+        SubscribeLocalEvent<ConstructComponent, MapInitEvent>(OnMapInit);
         SubscribeLocalEvent<ConstructComponent, ComponentShutdown>(OnComponentShutdown);
     }
 
@@ -37,23 +39,28 @@ public override void Update(float frameTime)
         }
     }
 
-    private void OnComponentStartup(Entity<ConstructComponent> ent, ref ComponentStartup args)
+    private void OnMapInit(Entity<ConstructComponent> construct, ref MapInitEvent args)
     {
-        _appearanceSystem.SetData(ent, ConstructVisualsState.Transforming, true);
-        ent.Comp.Transforming = true;
-        var cultistRule = EntityManager.EntityQueryEnumerator<BloodCultRuleComponent>();
-        while (cultistRule.MoveNext(out _, out var rule))
+        foreach (var actionId in construct.Comp.Actions)
         {
-            rule.Constructs.Add(ent);
+            var action = _actions.AddAction(construct, actionId);
+            construct.Comp.ActionEntities.Add(action);
         }
+
+        _appearanceSystem.SetData(construct, ConstructVisualsState.Transforming, true);
+        construct.Comp.Transforming = true;
+        var cultistRule = EntityManager.EntityQueryEnumerator<BloodCultRuleComponent>();
+        while (cultistRule.MoveNext(out _, out var rule))
+            rule.Constructs.Add(construct);
     }
 
-    private void OnComponentShutdown(Entity<ConstructComponent> ent, ref ComponentShutdown args)
+    private void OnComponentShutdown(Entity<ConstructComponent> construct, ref ComponentShutdown args)
     {
+        foreach (var actionEntity in construct.Comp.ActionEntities)
+            _actions.RemoveAction(actionEntity);
+
         var cultistRule = EntityManager.EntityQueryEnumerator<BloodCultRuleComponent>();
         while (cultistRule.MoveNext(out _, out var rule))
-        {
-            rule.Constructs.Remove(ent);
-        }
+            rule.Constructs.Remove(construct);
     }
 }