CmdrBuilds / Readme

Author: ipax77

src/dsstats.maui/dsstats.builder/README.md

@@ -0,0 +1,36 @@
+
+# dsstats builder
+
+A tool to automatically build units in the Direct Strike Tutorial map (StarCraft II) based on replay data.
+
+## Features
+* Automatically places units according to replay information
+* Uses simulated keyboard and mouse input
+* Helps recreate builds for training or analysis
+
+## Getting Started
+1. **Close all other applications.**
+2. Launch the Direct Strike Tutorial map in StarCraft II.
+3. Assign hotkeys:
+    * Set Team 1's worker (top player) to hotkey 1
+    * Set Team 2's worker (bottom player) to hotkey 2
+4. **Do not move the workers!**
+    * For accurate unit placement, workers must remain at the center of their designated build zones.
+5. Open dsstats, load the replay you want to test, open the desired build, and click "Build". (Screenshot TODO)
+6. Switch back to StarCraft II and do not touch your mouse or keyboard until the build is complete.
+7. Ensure no other application is in focus, as dsstats sends automated mouse and keyboard inputs that may interfere with active windows.
+
+## How It Works
+* Parses replay files to extract unit placement data
+* Maps unit positions to screen coordinates
+* Simulates precise keyboard and mouse inputs to replicate builds
+
+## TODO
+* top map build area corners
+* check terran build
+* check protoss build
+* build hidden units (Lurker, Widowmine)
+* ability/upgrades
+* test other screen resolutions
+* team 2 build / test
+* Commanders builds

src/dsstats.maui/dsstats.builder/dsstats.builder/BuildArea.cs

@@ -17,41 +17,79 @@ public class BuildArea
     ];
     private Dictionary<string, HashSet<RlPoint>> units = [];
 
-    public List<InputEvent> GetBuildEvents(ScreenArea screenArea)
+    public List<InputEvent> GetBuildEvents(ScreenArea screenArea, CmdrBuild build)
     {
-        // hardcoded unitmap for now
-        Dictionary<string, char> UnitNameBuildMap = new()
-        {
-            { "Zergling", 'q' },
-            { "Baneling", 'w' }
-        };
-
         List<InputEvent> events = [];
         var allUnits = units.SelectMany(unit =>
-            unit.Value.Select(pos => new { UnitName = unit.Key, Position = pos }))
+            unit.Value
+                .OrderBy(o => o.X).ThenBy(t => t.Y)
+                .Select(pos => new BuildUnit(unit.Key, pos)))
             .ToList();
 
         if (allUnits.Count == 0)
         {
             return events;
         }
 
-        // NOTE: This is a nearest-neighbor search, which is O(n^2).
-        // For a very large number of units, a more advanced spatial data structure
-        // like a k-d tree or a quadtree would be more performant.
-        var currentPos = GetCenter(); // Start from the center of the build area
-        while (allUnits.Count != 0)
-        {
-            var nearest = allUnits.OrderBy(u => u.Position.DistanceTo(currentPos)).First();
-            allUnits.Remove(nearest);
-            currentPos = nearest.Position;
+        List<BuildUnit> topUnits = [];
+        List<BuildUnit> centerUnits = [];
+        List<BuildUnit> bottomUnits = [];
 
-            var unitChar = UnitNameBuildMap[nearest.UnitName];
-            var screenPos = screenArea.GetScreenPosition(nearest.Position);
+        foreach (var unit in allUnits)
+        {
 
-            if (screenPos.Y < 15 || screenPos.Y > 1140) continue; // Skip scrolling for now
+            var screenPos = screenArea.GetScreenPosition(unit.Pos);
+            if (screenPos.Y <= 15)
+            {
+                topUnits.Add(new(unit.UnitName, screenPos));
+            }
+            else if (screenPos.Y >= 1140)
+            {
+                bottomUnits.Add(new(unit.UnitName, screenPos));
+            }
+            else
+            {
+                centerUnits.Add(new(unit.UnitName, screenPos));
+            }
+        }
 
-            events.AddRange(DsBuilder.BuildUnit(unitChar, screenPos.X, screenPos.Y));
+        foreach (var centerUnit in centerUnits)
+        {
+            var unitChar = build.GetUnitChar(centerUnit.UnitName);
+            if (unitChar is null)
+            {
+                continue;
+            }
+            events.AddRange(DsBuilder.BuildUnit(unitChar.Value, centerUnit.Pos.X, centerUnit.Pos.Y));
+        }
+        if (topUnits.Count > 0)
+        {
+            events.AddRange(DsBuilder.ScrollY(Convert.ToInt32(250 * screenArea._scaleY), screenArea.GetCenter()));
+            foreach (var topUnit in topUnits)
+            {
+                var unitChar = build.GetUnitChar(topUnit.UnitName);
+                if (unitChar is null)
+                {
+                    continue;
+                }
+                events.AddRange(DsBuilder.BuildUnit(unitChar.Value, topUnit.Pos.X, topUnit.Pos.Y + Convert.ToInt32(125 * screenArea._scaleY)));
+            }
+        }
+        if (bottomUnits.Count > 0)
+        {
+            Console.WriteLine($"bottom units: {bottomUnits.Count}");
+            events.AddRange(DsBuilder.ScrollCenter());
+            events.Add(new(InputType.KeyPress, 0, 0, 0x51, 5)); // Build Menu
+            events.AddRange(DsBuilder.ScrollY(Convert.ToInt32(-500 * screenArea._scaleY), screenArea.GetCenter()));
+            foreach (var bottomUnit in bottomUnits)
+            {
+                var unitChar = build.GetUnitChar(bottomUnit.UnitName);
+                if (unitChar is null)
+                {
+                    continue;
+                }
+                events.AddRange(DsBuilder.BuildUnit(unitChar.Value, bottomUnit.Pos.X, bottomUnit.Pos.Y - Convert.ToInt32(300 * screenArea._scaleY)));
+            }
         }
 
         return events;
@@ -173,3 +211,4 @@ private static bool IsOnEdge(RlPoint p, RlPoint a, RlPoint b)
     }
 }
 
+internal sealed record BuildUnit(string UnitName, RlPoint Pos);

src/dsstats.maui/dsstats.builder/dsstats.builder/Builds/CmdrBuild.cs

@@ -0,0 +1,45 @@
+using dsstats.shared;
+
+namespace dsstats.builder;
+
+public abstract class CmdrBuild
+{
+    protected Dictionary<string, char> UnitMap = [];
+    protected Dictionary<string, char> UpgradeMap = [];
+    protected Dictionary<string, char> AbilityMap = [];
+
+    public virtual char? GetUnitChar(string unitName)
+    {
+        return UnitMap.TryGetValue(unitName, out var c)
+            ? c
+            : null;
+    }
+
+    public virtual char? GetUpgradeChar(string upgradeName)
+    {
+        return UpgradeMap.TryGetValue(upgradeName, out var c)
+            ? c
+            : null;
+    }
+
+    public virtual char? GetAbilityChar(string abilityName)
+    {
+        return AbilityMap.TryGetValue(abilityName, out var c)
+            ? c
+            : null;
+    }
+}
+
+public static class CmdrBuildFactory
+{
+    public static CmdrBuild? Create(Commander commander)
+    {
+        return commander switch
+        {
+            Commander.Protoss => new ProtossBuild(),
+            Commander.Terran => new TerranBuild(),
+            Commander.Zerg => new ZergBuild(),
+            _ => null
+        };
+    }
+}

src/dsstats.maui/dsstats.builder/dsstats.builder/Builds/ProtossBuild.cs

@@ -0,0 +1,68 @@
+namespace dsstats.builder;
+
+public class ProtossBuild : CmdrBuild
+{
+    public ProtossBuild()
+    {
+        UnitMap = new Dictionary<string, char>
+        {
+            // Q-menu units
+            { "Zealot", 'q' },
+            { "Stalker", 'w' },
+            { "Adept", 'e' },
+            { "Sentry", 'r' },
+            { "HighTemplar", 't' },
+            { "DarkTemplar", 'a' },
+            { "Immortal", 's' },
+            { "Colossus", 'd' },
+            { "Disruptor", 'f' },
+            { "Archon", 'g' },
+            { "Phoenix", 'z' },
+            { "VoidRay", 'x' },
+            { "Oracle", 'c' },
+            { "Tempest", 'v' },
+            { "Carrier", 'b' },
+            { "Mothership", 'n' },
+        };
+
+        AbilityMap = new Dictionary<string, char>
+        {
+            // W-menu: abilities and tech
+            { "Charge", 'q' },
+            { "Blink", 'w' },
+            { "ResonatingGlaives", 'e' },
+            { "GuardianShield", 'r' },
+            { "PsionicStorm", 't' },
+            { "ShadowStride", 'a' },
+            { "Barrier", 's' },
+            { "ExtendedThermalLance", 'd' },
+            { "PurificationNova", 'f' },
+            { "GravitonBeam", 'g' },
+            { "FluxVanes", 'z' },
+            { "Revelation", 'x' },
+            { "TectonicDestabilizers", 'c' },
+            { "InterceptorLaunchSpeed", 'v' },
+            { "MassRecall", 'b' },
+        };
+
+        UpgradeMap = new Dictionary<string, char>
+        {
+            // Forge + Cyber Core + Fleet Beacon
+            { "GroundWeaponsLevel1", 'a' },
+            { "GroundWeaponsLevel2", 'a' },
+            { "GroundWeaponsLevel3", 'a' },
+            { "GroundArmorLevel1", 's' },
+            { "GroundArmorLevel2", 's' },
+            { "GroundArmorLevel3", 's' },
+            { "ShieldsLevel1", 'd' },
+            { "ShieldsLevel2", 'd' },
+            { "ShieldsLevel3", 'd' },
+            { "AirWeaponsLevel1", 'f' },
+            { "AirWeaponsLevel2", 'f' },
+            { "AirWeaponsLevel3", 'f' },
+            { "AirArmorLevel1", 'g' },
+            { "AirArmorLevel2", 'g' },
+            { "AirArmorLevel3", 'g' },
+        };
+    }
+}

src/dsstats.maui/dsstats.builder/dsstats.builder/Builds/TerranBuild.cs

@@ -0,0 +1,65 @@
+namespace dsstats.builder;
+
+public class TerranBuild : CmdrBuild
+{
+    public TerranBuild()
+    {
+        UnitMap = new Dictionary<string, char>
+        {
+            // Q-menu
+            { "Marine", 'q' },
+            { "Marauder", 'w' },
+            { "Reaper", 'e' },
+            { "Ghost", 'r' },
+            { "Hellion", 't' },
+            { "Hellbat", 'a' },
+            { "SiegeTank", 's' },
+            { "WidowMine", 'd' },
+            { "Cyclone", 'f' },
+            { "Thor", 'g' },
+            { "Viking", 'z' },
+            { "Medivac", 'x' },
+            { "Banshee", 'c' },
+            { "Raven", 'v' },
+            { "Battlecruiser", 'b' },
+        };
+
+        AbilityMap = new Dictionary<string, char>
+        {
+            // W-menu (upgrades & abilities)
+            { "Stimpack", 'q' },
+            { "ConcussiveShells", 'w' },
+            { "CloakingField", 'e' },
+            { "DrillingClaws", 'r' },
+            { "InfernalPreigniter", 't' }, // Hellion upgrade
+            { "SmartServos", 'a' },        // Viking/Thor transform speed
+            { "HighImpactPayload", 's' },  // Thor mode toggle
+            { "HyperflightRotors", 'd' },  // Banshee speed
+            { "AdvancedBallistics", 'f' }, // Raven range
+            { "WeaponRefit", 'g' },        // Battlecruiser Yamato
+        };
+
+        UpgradeMap = new Dictionary<string, char>
+        {
+            // Main armory upgrades
+            { "InfantryWeaponsLevel1", 'a' },
+            { "InfantryWeaponsLevel2", 'a' },
+            { "InfantryWeaponsLevel3", 'a' },
+            { "InfantryArmorLevel1", 's' },
+            { "InfantryArmorLevel2", 's' },
+            { "InfantryArmorLevel3", 's' },
+            { "VehicleWeaponsLevel1", 'd' },
+            { "VehicleWeaponsLevel2", 'd' },
+            { "VehicleWeaponsLevel3", 'd' },
+            { "ShipWeaponsLevel1", 'f' },
+            { "ShipWeaponsLevel2", 'f' },
+            { "ShipWeaponsLevel3", 'f' },
+            { "VehiclePlatingLevel1", 'g' },
+            { "VehiclePlatingLevel2", 'g' },
+            { "VehiclePlatingLevel3", 'g' },
+            { "ShipPlatingLevel1", 'h' },
+            { "ShipPlatingLevel2", 'h' },
+            { "ShipPlatingLevel3", 'h' },
+        };
+    }
+}

src/dsstats.maui/dsstats.builder/dsstats.builder/Builds/ZergBuild.cs

@@ -0,0 +1,60 @@
+namespace dsstats.builder;
+
+public class ZergBuild : CmdrBuild
+{
+    public ZergBuild()
+    {
+        UnitMap = new Dictionary<string, char>
+            {
+                { "Zergling", 'q' },
+                { "Baneling", 'w' },
+                { "Roach", 'e' },
+                { "Queen", 'r' },
+                { "Overseer", 't' },
+                { "Hydralisk", 'a' },
+                { "Mutalisk", 's' },
+                { "Corruptor", 'd' },
+                { "Infestor", 'f' },
+                { "Swarmhost", 'g' },
+                { "Viper", 'z' },
+                { "Ultralisk", 'x' },
+                { "Broodloard", 'c' },
+            };
+
+        AbilityMap = new Dictionary<string, char>
+            {
+                { "MetabolikBoost", 'q' },
+                { "AdrenalGlands", 'w' },
+                { "CentrifugalHooks", 'e' },
+                { "GlialReconstitution", 'r' },
+                { "TunnelingClaws", 't' },
+                { "GroovedSpines", 'a' },
+                { "SeismicSpines", 's' },
+                { "AdaptiveTalons", 'd' },
+                { "NeuralParasite", 'g' },
+                { "ChitinousPlating", 'z' },
+                { "AnabolicSynthesis", 'x' },
+                { "MuscularAugments", 'c' },
+                { "PneumatizedCarapace", 'v' },
+            };
+
+        UpgradeMap = new Dictionary<string, char>
+            {
+                { "MeleeAttacksLevel1", 'a' },
+                { "MeleeAttacksLevel2", 'a' },
+                { "MeleeAttacksLevel3", 'a' },
+                { "GroundCarapaceLevel1", 's' },
+                { "GroundCarapaceLevel2", 's' },
+                { "GroundCarapaceLevel3", 's' },
+                { "MissileAttacksLevel1", 'd' },
+                { "MissileAttacksLevel2", 'd' },
+                { "MissileAttacksLevel3", 'd' },
+                { "FlyerAttacksLevel1", 'f' },
+                { "FlyerAttacksLevel2", 'f' },
+                { "FlyerAttacksLevel3", 'f' },
+                { "FlyerCarapaceLevel1", 'g' },
+                { "FlyerCarapaceLevel2", 'g' },
+                { "FlyerCarapaceLevel3", 'g' },
+            };
+    }
+}