Complete Phase 3: Tactile Junction Overhaul and Stat Ceiling Enforcement

Author: DerekGooding

Mythril.Blazor/Components/CharacterDisplay.razor

@@ -13,7 +13,18 @@
     <div class="character-controls d-flex flex-column gap-1">
         @if (assignedCadences.Any())
         {
-            <button class="btn btn-xs btn-outline-primary" data-testid="junction-toggle" @onclick="ToggleJunctionMenu">Junction</button>
+            <div class="btn-group btn-group-xs w-100">
+                <button class="btn btn-xs @(_isRemovalMode ? "btn-danger" : "btn-outline-danger")" 
+                        title="Remove Junctions" 
+                        @onclick="ToggleRemovalMode">
+                    <span class="material-icons" style="font-size: 14px;">link_off</span>
+                </button>
+                <button class="btn btn-xs @(_showJunctionMenu ? "btn-primary" : "btn-outline-primary")" 
+                        title="Junction Menu"
+                        @onclick="ToggleJunctionMenu">
+                    <span class="material-icons" style="font-size: 14px;">menu</span>
+                </button>
+            </div>
 
             @if (resourceManager.CanAutoQuest(Character))
             {
@@ -61,8 +72,9 @@
                         bool canJunction = CanJunction(stat);
 
                         <span @key="stat.Name" 
-                              class="stat-badge @(junction != null ? "junctioned" : "") @(isHovered ? "hovered" : "") @(canJunction ? "can-junction" : "locked")" 
+                              class="stat-badge @(junction != null ? "junctioned" : "") @(isHovered ? "hovered" : "") @(canJunction ? "can-junction" : "locked") @(_isRemovalMode && junction != null ? "removal-target" : "")" 
                               title="@stat.Description @(junction != null ? $"(J: {junction.Magic.Name})" : "")"
+                              @onclick="() => { if(_isRemovalMode && junction != null) ClearJunction(stat); }"
                               @ondragenter="() => HandleStatDragEnter(stat)"
                               @ondragleave="HandleStatDragLeave"
                               @ondragover:preventDefault
@@ -71,7 +83,7 @@
                             @if (delta != 0)
                             {
                                 <span class="stat-delta @(delta > 0 ? "text-success" : "text-danger")">
-                                    @(delta > 0 ? "+" : "")@delta
+                                    @(delta > 0 ? "↑" : "↓")@Math.Abs(delta)
                                 </span>
                             }
                         </span>

Mythril.Blazor/Components/CharacterDisplay.razor.cs

@@ -40,6 +40,7 @@ public partial class CharacterDisplay : IDisposable
     public EventCallback<Cadence> OnUnequip { get; set; }
 
     private bool _showJunctionMenu = false;
+    private bool _isRemovalMode = false;
 
     protected override void OnInitialized()
     {
@@ -61,18 +62,20 @@ private int GetPredictionDelta(Stat stat)
         if (DragDropService.HoveredTarget?.character.Name != Character.Name || DragDropService.HoveredTarget?.stat.Name != stat.Name)
             return 0;
 
-        if (DragDropService.Data is not ItemQuantity spell || spell.Item.ItemType != ItemType.Spell)
-            return 0;
+        Item? draggedMagic = null;
+        if (DragDropService.Data is ItemQuantity iq && iq.Item.ItemType == ItemType.Spell) draggedMagic = iq.Item;
+        if (DragDropService.Data is Item i && i.ItemType == ItemType.Spell) draggedMagic = i;
 
-        if (!CanJunction(stat))
+        if (draggedMagic == null || !CanJunction(stat))
             return 0;
 
+        Item activeMagic = (Item)draggedMagic;
         int currentVal = JunctionManager.GetStatValue(Character, stat.Name);
 
         // Calculate what it WOULD be
         int newVal = 10;
-        int qty = resourceManager.Inventory.GetQuantity(spell.Item);
-        var augments = ContentHost.GetContent<StatAugments>()[spell.Item];
+        int qty = resourceManager.Inventory.GetQuantity(activeMagic);
+        var augments = ContentHost.GetContent<StatAugments>()[activeMagic];
         var augment = augments.FirstOrDefault(a => a.Stat.Name == stat.Name);
         if (augment.Stat.Name != null)
         {
@@ -83,12 +86,19 @@ private int GetPredictionDelta(Stat stat)
             newVal += qty / 10;
         }
 
+        newVal = Math.Min(255, newVal);
+
         return newVal - currentVal;
     }
 
+
     private void HandleStatDragEnter(Stat stat)
     {
-        if (DragDropService.Data is ItemQuantity spell && spell.Item.ItemType == ItemType.Spell && CanJunction(stat))
+        bool isSpell = false;
+        if (DragDropService.Data is ItemQuantity iq && iq.Item.ItemType == ItemType.Spell) isSpell = true;
+        if (DragDropService.Data is Item i && i.ItemType == ItemType.Spell) isSpell = true;
+
+        if (isSpell && CanJunction(stat))
         {
             DragDropService.SetHoveredTarget(Character, stat);
         }
@@ -101,15 +111,35 @@ private void HandleStatDragLeave()
 
     private void HandleStatDrop(Stat stat)
     {
-        if (DragDropService.Data is ItemQuantity spell && spell.Item.ItemType == ItemType.Spell && CanJunction(stat))
+        Item? droppedMagic = null;
+        if (DragDropService.Data is ItemQuantity iq && iq.Item.ItemType == ItemType.Spell) droppedMagic = iq.Item;
+        if (DragDropService.Data is Item i && i.ItemType == ItemType.Spell) droppedMagic = i;
+
+        if (droppedMagic != null && CanJunction(stat))
         {
-            JunctionManager.JunctionMagic(Character, stat, spell.Item, resourceManager.UnlockedAbilities);
+            JunctionManager.JunctionMagic(Character, stat, (Item)droppedMagic, resourceManager.UnlockedAbilities);
             DragDropService.ClearHoveredTarget();
             DragDropService.Data = null;
         }
     }
 
-    private void ToggleJunctionMenu() => _showJunctionMenu = !_showJunctionMenu;
+    private void ToggleJunctionMenu() 
+    {
+        _showJunctionMenu = !_showJunctionMenu;
+        if (_showJunctionMenu) _isRemovalMode = false;
+    }
+
+    private void ToggleRemovalMode()
+    {
+        _isRemovalMode = !_isRemovalMode;
+        if (_isRemovalMode) _showJunctionMenu = false;
+    }
+
+    private void ClearJunction(Stat stat)
+    {
+        JunctionManager.JunctionMagic(Character, stat, new Item(), resourceManager.UnlockedAbilities);
+        StateHasChanged();
+    }
 
     private void ToggleAutoQuest()
     {

Mythril.Blazor/Components/CharacterDisplay.razor.css

@@ -57,6 +57,18 @@
     opacity: 0.5;
     cursor: not-allowed;
 }
+.stat-badge.removal-target {
+    border: 1px dashed #dc3545;
+    cursor: pointer;
+    animation: pulse-red 2s infinite;
+}
+
+@keyframes pulse-red {
+    0% { background-color: rgba(220, 53, 69, 0.1); }
+    50% { background-color: rgba(220, 53, 69, 0.3); }
+    100% { background-color: rgba(220, 53, 69, 0.1); }
+}
+
 .stat-delta {
     font-weight: bold;
     margin-left: 2px;

Mythril.Data/JunctionManager.cs

@@ -103,7 +103,7 @@ public int GetStatValue(Character character, string statName)
             }
         }
 
-        return baseValue;
+        return Math.Min(255, baseValue);
     }
 
     public void RestoreAssignment(Cadence cadence, Character character)

Mythril.Tests/JunctionOverhaulTests.cs

@@ -0,0 +1,90 @@
+using Bunit;
+using Microsoft.Extensions.DependencyInjection;
+using Mythril.Blazor.Components;
+using Mythril.Data;
+using System.Linq;
+
+namespace Mythril.Tests;
+
+[TestClass]
+public class JunctionOverhaulTests : BunitTestBase
+{
+    [TestMethod]
+    public void StatValue_EnforcesCeiling()
+    {
+        // Arrange
+        var character = new Character("Hero");
+        var stat = Stats.All.First(s => s.Name == "Strength");
+        var magic = new Item("Ultimate Magic", "OP", ItemType.Spell);
+        
+        // Increase capacity to allow reaching 255
+        InventoryManager.MagicCapacity = 10000;
+        InventoryManager.Add(magic, 10000);
+        
+        // Setup junction
+        JunctionManager.Junctions.Add(new Junction(character, stat, magic));
+
+        // Act
+        int val = JunctionManager.GetStatValue(character, "Strength");
+
+        // Assert
+        Assert.AreEqual(255, val, "Stat should be capped at 255");
+    }
+
+    [TestMethod]
+    public void CharacterDisplay_RemovalMode_TogglesCorrectly()
+    {
+        // Arrange
+        var character = new Character("Hero");
+        var cadence = new Cadence("Warrior", "Desc", []);
+        JunctionManager.AssignCadence(cadence, character, []);
+
+        var cut = RenderComponent<CharacterDisplay>(p => p
+            .Add(cp => cp.Character, character)
+        );
+
+        // Act - Click removal button (link_off icon)
+        var removalBtn = cut.Find("button[title='Remove Junctions']");
+        removalBtn.Click();
+
+        // Assert
+        Assert.IsTrue(removalBtn.ClassList.Contains("btn-danger"));
+        
+        // Act - Toggle menu should turn off removal
+        var menuBtn = cut.Find("button[title='Junction Menu']");
+        menuBtn.Click();
+        
+        // Assert
+        Assert.IsFalse(removalBtn.ClassList.Contains("btn-danger"));
+    }
+
+    [TestMethod]
+    public void CharacterDisplay_ShowsDeltaPreview()
+    {
+        // Arrange
+        var character = new Character("Hero");
+        var stat = Stats.All.First(s => s.Name == "Strength");
+        var magic = new Item("Fire", "Burn", ItemType.Spell);
+        
+        InventoryManager.MagicCapacity = 100;
+        InventoryManager.Add(magic, 50); // 50 / 10 = +5 Strength
+
+        // Ensure CanJunction returns true
+        var cadence = new Cadence("Warrior", "Desc", [new CadenceUnlock("Warrior", new CadenceAbility("J-Str", "Desc"), [])]);
+        JunctionManager.AssignCadence(cadence, character, ["Warrior:J-Str"]);
+        ResourceManager.UnlockedAbilities.Add("Warrior:J-Str");
+
+        // Mock dragging the item
+        DragDropService.Data = magic;
+        DragDropService.SetHoveredTarget(character, stat);
+
+        var cut = RenderComponent<CharacterDisplay>(p => p
+            .Add(cp => cp.Character, character)
+        );
+
+        // Act & Assert
+        var delta = cut.Find(".stat-delta");
+        Assert.IsTrue(delta.TextContent.Contains("↑5"));
+        Assert.IsTrue(delta.ClassList.Contains("text-success"));
+    }
+}

README.md

@@ -22,7 +22,7 @@ Mythril is an RPG-inspired web application built with **.NET 10** and **Blazor W
 
 ### Key Systems
 - **Character Core**: Modular system where characters share baseline stats (**Strength, Vitality, Magic, Speed**), differentiated by assigned Cadences and junctioned magic. Features immersive visual feedback for task completion and per-character equipment management.
-- **Junctioning**: Assign magic items to character stats to gain powerful bonuses, inspired by classic RPG mechanics.
+- **Junctioning**: Assign magic items to character stats to gain powerful bonuses. Features a tactile drag-and-drop system from the inventory directly onto character stats, complete with predictive effect previews and a specialized removal tool.
 - **Cadence System**: Progression mechanic where `Cadences` provide `CadenceAbilities`. Unlocking is performed by dragging ability nodes directly onto characters.
 - **Journal System**: Persistent historical log tracking the last 50 completed tasks, providing transparency into character activities and resource gains.
 - **Quest & Progression**: Real-time asynchronous tick system managing quests, durations, and rewards, with offline progress continuity and interconnected world unlocks.
@@ -36,28 +36,22 @@ Mythril is an RPG-inspired web application built with **.NET 10** and **Blazor W
 - **CI/CD**: GitHub Actions for automated deployment and health monitoring.
 
 ## 🚀 Recent Updates (March 4, 2026)
+- **Tactile Junction Overhaul**: Transitioned to a pure drag-from-inventory model for Junctioning. Added color-coded stat delta previews (↑/↓) and a dedicated "Link Off" removal tool.
+- **Stat Ceiling Enforcement**: Implemented a global **255** maximum cap for all character stats to ensure long-term game balance.
+- **Tier II Multi-Tasking & Automation**: Expanded character capacity to a 3rd task slot via **Logistics II** and enabled automation for the 2nd slot with **AutoQuest II** (Scholar cadence).
 - **Historical Journal**: Integrated a new Journal tab that tracks task completion history across sessions, including character names and specific rewards.
 - **Task Sorting**: Added a duration-based sorting toggle to the Locations panel, allowing players to easily prioritize tasks based on their playstyle.
 - **Requirement Iconography**: Implemented standardized icons (🛡️ for stats, 📦 for items, 🔑 for prerequisites) across all quest and ability cards for improved readability.
-- **Cadence Completion Tracking**: Implemented a progress counter and checkmark system for Cadences, similar to Location tracking. Users can now see how many abilities have been unlocked for each job at a glance.
-- **Location Completion Tracking**: Added a quest counter to location expanders, showing progress on one-time quests. A green checkmark now appears when all unique tasks in a region are finished.
-- **Logistics I Ability**: Implemented a new progression tier allowing characters to perform two tasks simultaneously. Features automated task cancellation and cost refunding when the ability is lost.
-- **Location Gating System**: Refactored the world map to gate major biomes (Whispering Woods, Ancient Ruins, etc.) behind prerequisite story quests, improving early-game focus and sense of discovery.
-- **Refined Workshop Reactivity**: Optimized the refinement UI to ensure immediate visual updates when new abilities are learned, powered by reactive parameter binding.
-- **Auto-Quest Slot Restriction**: Balanced the Auto-Quest I ability to specifically target only the primary task slot, adding strategic depth to multi-tasking.
-- **Monolith Prevention Refactor**: Decomposed the `ResourceManager` into specialized partial classes (`State`, `Discovery`, `Inventory`, `Quests`, `Journal`, `Rewards`) to maintain a lean, maintainable architecture below the 250-line file limit.
-- **Persistence Layer Upgrade**: Enhanced the save system to preserve task slot assignments and discovered location names across sessions.
-- **UI Streamlining**: Restacked header controls vertically and cleaned up instructional text across all main panels for a more focused gameplay experience.
+- **Monolith Prevention Refactor**: Decomposed the `ResourceManager` into specialized partial classes (`State`, `Discovery`, `Inventory`, `Quests`, `Journal`, `Rewards`, `Logistics`) to maintain a lean, maintainable architecture.
 
 ## ⚖️ Quality Assurance & Health
 We maintain project health through a custom automated suite (`scripts/check_health.py`) which runs on every commit:
 - **Monolith Prevention**: Strict 250-line limit for source files (excluding tools).
-- **Game Graph Simulation**: Integrated Fixed-Point Iteration engine that mathematically verifies every quest and resource is attainable from a fresh start. Prevents "logic orphans" and provides estimated optimal completion times for the endgame.
-- **Automated Balancing**: The reachability simulation is part of the health suite. If a content change makes a quest mathematically impossible (e.g. required stat cannot be reached), the build fails.
+- **Game Graph Simulation**: Integrated Fixed-Point Iteration engine that mathematically verifies every quest and resource is attainable from a fresh start.
+- **Automated Balancing**: The reachability simulation is part of the health suite. If a content change makes a quest mathematically impossible, the build fails.
 - **Coverage**: Mandatory 70% overall line coverage; 25% per-file minimum.
 - **Razor Integrity**: All interactive components must have bUnit tests, `@key` usage in loops, and `data-testid` anchors.
 - **Documentation Integrity**: Automated staleness tracking via local file modification times.
-- **Feedback Integrity**: Monitoring of pending user feedback and runtime errors in `docs/feedback/`.
 
 ### 🛡️ Health Shield Guide
 All badges are automatically updated by `scripts/check_health.py` on every commit: