diff --git a/.idea/.idea.Zero-K/.idea/projectSettingsUpdater.xml b/.idea/.idea.Zero-K/.idea/projectSettingsUpdater.xml
index 64af657f5c..ef20cb08cd 100644
--- a/.idea/.idea.Zero-K/.idea/projectSettingsUpdater.xml
+++ b/.idea/.idea.Zero-K/.idea/projectSettingsUpdater.xml
@@ -2,6 +2,7 @@
 <project version="4">
   <component name="RiderProjectSettingsUpdater">
     <option name="singleClickDiffPreview" value="1" />
+    <option name="unhandledExceptionsIgnoreList" value="1" />
     <option name="vcsConfiguration" value="3" />
   </component>
 </project>
\ No newline at end of file
diff --git a/Fixer/Program.cs b/Fixer/Program.cs
index 70ab686d4a..a76099d181 100644
--- a/Fixer/Program.cs
+++ b/Fixer/Program.cs
@@ -431,17 +431,22 @@ private static void TestPwMatchMaker()
         {
             var server = new global::ZkLobbyServer.ZkLobbyServer("", new PlanetwarsEventCreator());
             var mm = server.PlanetWarsMatchMaker;
-            mm.ChallengeTime = DateTime.Now;
             mm.AttackerSideCounter = 1;
-            //mm.ResetAttackOptions();
-            mm.GenerateLobbyCommand();
-            mm.Challenge = mm.AttackOptions[3];
-            mm.Challenge.OwnerFactionID = 2;
-            mm.Challenge.PlanetID = 4375;
-            mm.GetDefendingFactions(mm.Challenge);
             mm.GenerateLobbyCommand();
 
-            //mm.Challenge = 
+            // simulate defend phase with a formed squad
+            if (mm.AttackOptions.Count > 3)
+            {
+                var opt = mm.AttackOptions[3];
+                opt.OwnerFactionID = 2;
+                opt.PlanetID = 4375;
+                mm.FormedSquads.Add(opt);
+                mm.Phase = PwPhase.DefendCollect;
+                mm.PhaseStartTime = DateTime.UtcNow;
+                mm.GetDefendingFactions(opt);
+                mm.GenerateLobbyCommand();
+            }
+
             Global.Server.PlanetWarsMatchMaker.GenerateLobbyCommand();
         }
 
diff --git a/Shared/PlasmaShared/GlobalConst.cs b/Shared/PlasmaShared/GlobalConst.cs
index ae1e4dbf56..aec6c31ff6 100644
--- a/Shared/PlasmaShared/GlobalConst.cs
+++ b/Shared/PlasmaShared/GlobalConst.cs
@@ -210,8 +210,8 @@ static void SetMode(ModeType newMode)
         public const int PostVoteHideThreshold = -6;
         public const bool OnlyAdminsSeePostVoters = false;
         public const int PlanetWarsMinutesToAttackIfNoOption = 2;
-        public const int PlanetWarsMinutesToAttack = 20;
-        public const int PlanetWarsMinutesToAccept = 5;
+        public const int PlanetWarsMinutesToAttack = 5;
+        public const int PlanetWarsMinutesToAccept = 10;
         public const int PlanetWarsDropshipsStayForMinutes = 2*60;
         public const int PlanetWarsMaxTeamsize = 4;
         public const double PlanetWarsDefenderWinKillCcMultiplier = 0.2;
diff --git a/Shared/PlasmaShared/Utils.cs b/Shared/PlasmaShared/Utils.cs
index 249f1dc81f..24baf9a709 100644
--- a/Shared/PlasmaShared/Utils.cs
+++ b/Shared/PlasmaShared/Utils.cs
@@ -537,12 +537,18 @@ public static Thread SafeThread(Action action)
 
 
         public static U Get<T, U>(this IDictionary<T, U> dict, T key)
-    where U : class
         {
             U val = default(U);
             if (key != null) dict.TryGetValue(key, out val);
             return val;
         }
+        
+        public static U GetOrDefault<T, U>(this IDictionary<T, U> dict, T key, U defaultValue)
+        {
+            U val = defaultValue;
+            if (key != null) dict.TryGetValue(key, out val);
+            return val;
+        }
 
 
         public static List<T> Shuffle<T>(this IEnumerable<T> source)
diff --git a/Zero-K.info/Views/Planetwars/PwMatchMaker.cshtml b/Zero-K.info/Views/Planetwars/PwMatchMaker.cshtml
index 4815f8dfa5..85ce5ba16c 100644
--- a/Zero-K.info/Views/Planetwars/PwMatchMaker.cshtml
+++ b/Zero-K.info/Views/Planetwars/PwMatchMaker.cshtml
@@ -13,8 +13,8 @@
     }
     else
     {
-        PwMatchCommand.VoteOption opt = pw.Options.First();
-        text = string.Format("{0} attacks planet {2}, {1} defends", pw.AttackerFaction, string.Join(",", pw.DefenderFactions), opt.PlanetName);
+        var planetNames = string.Join(", ", pw.Options.Select(o => o.PlanetName));
+        text = string.Format("{0} attacks {2}, {1} defends", pw.AttackerFaction, string.Join(",", pw.DefenderFactions), planetNames);
     }
 
     bool canClick = (pw.Mode == PwMatchCommand.ModeType.Attack && pw.AttackerFaction == Global.Account.Faction.Shortcut) || (pw.Mode == PwMatchCommand.ModeType.Defend && pw.DefenderFactions.Contains(Global.Account.Faction.Shortcut));
diff --git a/ZeroKLobby/Notifications/PwBar.cs b/ZeroKLobby/Notifications/PwBar.cs
index 7c1abd5296..c346b9df17 100644
--- a/ZeroKLobby/Notifications/PwBar.cs
+++ b/ZeroKLobby/Notifications/PwBar.cs
@@ -82,23 +82,26 @@ void UpdateGui()
                     }
                     else if (pw.Mode == PwMatchCommand.ModeType.Defend)
                     {
-                        PwMatchCommand.VoteOption opt = pw.Options.First();
-                        headerLabel.Text = string.Format("{0} attacks planet {2}, {1} defends",
+                        headerLabel.Text = string.Format("{0} attacks, {1} defends",
                             pw.AttackerFaction,
-                            string.Join(",", pw.DefenderFactions),
-                            opt.PlanetName);
+                            string.Join(",", pw.DefenderFactions));
 
                         foreach (Button c in pnl.Controls.OfType<Button>().ToList()) pnl.Controls.Remove(c);
 
-                        var but = new Button { Text = string.Format("{0} [{1}/{2}]", opt.PlanetName, opt.Count, opt.Needed), AutoSize = true };
-                        Program.ToolTip.SetMap(but, opt.Map);
-
-                        if (pw.DefenderFactions.Contains(tas.MyUser.Faction)) // NOTE this is for cases where nightwatch self faction info is delayed
+                        foreach (PwMatchCommand.VoteOption opt in pw.Options)
                         {
-                            AddButtonClick(opt, but);
+                            Program.Downloader.GetResource(DownloadType.MAP, opt.Map);
+
+                            var but = new Button { Text = string.Format("{0} [{1}/{2}]", opt.PlanetName, opt.Count, opt.Needed), AutoSize = true };
+                            Program.ToolTip.SetMap(but, opt.Map);
+
+                            if (pw.DefenderFactions.Contains(tas.MyUser.Faction))
+                            {
+                                AddButtonClick(opt, but);
+                            }
+                            else but.Enabled = false;
+                            pnl.Controls.Add(but);
                         }
-                        else but.Enabled = false;
-                        pnl.Controls.Add(but);
                     }
 
                     Program.NotifySection.AddBar(this);
diff --git a/ZkData/Ef/WHR/RatingSystems.cs b/ZkData/Ef/WHR/RatingSystems.cs
index 2dd5a5d224..2820b52fe2 100644
--- a/ZkData/Ef/WHR/RatingSystems.cs
+++ b/ZkData/Ef/WHR/RatingSystems.cs
@@ -37,7 +37,7 @@ public static void Init()
                         {
                             int battles = 0;
                             data.Database.CommandTimeout = 240;
-                            for (int month = 5*12; month > 0; month--)
+                            for (int month = 10*12; month > 0; month--)
                             {
                                 DateTime minStartTime = DateTime.Now.AddMonths(-month);
                                 DateTime maxStartTime = DateTime.Now.AddMonths(-month + 1);
diff --git a/ZkLobbyServer/SpringieInterface/BattleResultHandler.cs b/ZkLobbyServer/SpringieInterface/BattleResultHandler.cs
index 6ec45d6319..3523a01eb4 100644
--- a/ZkLobbyServer/SpringieInterface/BattleResultHandler.cs
+++ b/ZkLobbyServer/SpringieInterface/BattleResultHandler.cs
@@ -184,7 +184,7 @@ private static void ProcessPlanetWars(SpringBattleContext result, ZkLobbyServer.
                 if (winNum > 1) winNum = null;
             }
 
-            PlanetWarsTurnHandler.EndTurn(result.LobbyStartContext.Map,
+            PlanetWarsTurnHandler.ProcessBattleResult(result.LobbyStartContext.Map,
                 result.OutputExtras,
                 db,
                 winNum,
diff --git a/ZkLobbyServer/SpringieInterface/PlanetWarsMatchMaker.cs b/ZkLobbyServer/SpringieInterface/PlanetWarsMatchMaker.cs
index dae6ac55a0..6ad331bff0 100644
--- a/ZkLobbyServer/SpringieInterface/PlanetWarsMatchMaker.cs
+++ b/ZkLobbyServer/SpringieInterface/PlanetWarsMatchMaker.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
@@ -8,6 +8,7 @@
 using LobbyClient;
 using Newtonsoft.Json;
 using PlasmaShared;
+using Ratings;
 using ZkData;
 using ZkLobbyServer;
 
@@ -20,13 +21,11 @@ public class PlanetWarsMatchMaker : PlanetWarsMatchMakerState
     {
         private readonly List<Faction> factions;
 
-
-        private int missedDefenseCount = 0;
-        private int missedDefenseFactionID = 0;
         private ZkLobbyServer.ZkLobbyServer server;
-
+        private DateTime? defendersFullTime; // set when total defenders >= total attacker slots
 
         private Timer timer;
+
         /// <summary>
         ///     Faction that should attack this turn
         /// </summary>
@@ -35,18 +34,16 @@ public class PlanetWarsMatchMaker : PlanetWarsMatchMakerState
 
         public PlanetWarsMatchMaker(ZkLobbyServer.ZkLobbyServer server)
         {
-            
             this.server = server;
             AttackOptions = new List<AttackOption>();
+            FormedSquads = new List<AttackOption>();
+            DefenderVotes = new Dictionary<int, List<string>>();
             RunningBattles = new Dictionary<int, AttackOption>();
 
-
             var db = new ZkDataContext();
-
             var gal = db.Galaxies.FirstOrDefault(x => x.IsDefault);
             if (gal == null) return;
 
-
             factions = db.Factions.Where(x => !x.IsDeleted).ToList();
 
             PlanetWarsMatchMakerState dbState = null;
@@ -62,16 +59,24 @@ public PlanetWarsMatchMaker(ZkLobbyServer.ZkLobbyServer server)
             if (dbState != null)
             {
                 AttackerSideCounter = dbState.AttackerSideCounter;
-                AttackOptions = dbState.AttackOptions;
-                Challenge = dbState.Challenge;
-                ChallengeTime = dbState.ChallengeTime;
+                AttackOptions = dbState.AttackOptions ?? new List<AttackOption>();
+                Phase = dbState.Phase;
+                PhaseStartTime = dbState.PhaseStartTime;
+                FormedSquads = dbState.FormedSquads ?? new List<AttackOption>();
+                DefenderVotes = dbState.DefenderVotes ?? new Dictionary<int, List<string>>();
                 AttackerSideChangeTime = dbState.AttackerSideChangeTime;
-                RunningBattles = dbState.RunningBattles;
+                RunningBattles = dbState.RunningBattles ?? new Dictionary<int, AttackOption>();
+
+                // sanity: if PhaseStartTime is in the future or too old, reset to now
+                if (PhaseStartTime > DateTime.UtcNow || PhaseStartTime < DateTime.UtcNow.AddHours(-1))
+                    PhaseStartTime = DateTime.UtcNow;
             }
             else
             {
                 AttackerSideCounter = gal.AttackerSideCounter;
                 AttackerSideChangeTime = gal.AttackerSideChangeTime ?? DateTime.UtcNow;
+                Phase = PwPhase.AttackCollect;
+                PhaseStartTime = DateTime.UtcNow;
             }
 
             timer = new Timer(1045);
@@ -80,339 +85,665 @@ public PlanetWarsMatchMaker(ZkLobbyServer.ZkLobbyServer server)
             timer.Start();
         }
 
-        private async Task AcceptChallenge()
+
+        // ===================== TIMER / STATE MACHINE =====================
+
+        private PlanetWarsModes? lastPlanetWarsMode;
+
+        private async void TimerOnElapsed(object sender, ElapsedEventArgs elapsedEventArgs)
         {
-            if (missedDefenseFactionID == Challenge.OwnerFactionID)
+            try
             {
-                missedDefenseCount = 0;
-                missedDefenseFactionID = 0;
-            }
+                timer.Stop();
 
-            // only really start if attackers are present, otherwise missed battle opportunity basically
-            Challenge.Attackers = Challenge.Attackers.Where(x => server.ConnectedUsers.ContainsKey(x)).ToList();
-            Challenge.Defenders = Challenge.Defenders.Where(x => server.ConnectedUsers.ContainsKey(x)).ToList();
-            if (Challenge.Attackers.Any() || Challenge.Defenders.Any())
-            {
-                var battle = new PlanetWarsServerBattle(server, Challenge);
-                await server.AddBattle(battle);
-                RunningBattles[battle.BattleID] = Challenge;
+                // auto change PW mode based on time
+                if (MiscVar.PlanetWarsNextModeTime != null && MiscVar.PlanetWarsNextModeTime < DateTime.UtcNow && MiscVar.PlanetWarsNextMode != null)
+                {
+                    MiscVar.PlanetWarsMode = MiscVar.PlanetWarsNextMode ?? PlanetWarsModes.AllOffline;
+                    MiscVar.PlanetWarsNextMode = null;
+                    MiscVar.PlanetWarsNextModeTime = null;
+
+                    using (var db = new ZkDataContext())
+                    {
+                        db.Events.Add(server.PlanetWarsEventCreator.CreateEvent("PlanetWars changed status to {0}", MiscVar.PlanetWarsMode.Description()));
+                        db.SaveChanges();
+                    }
+                }
+
+                if (MiscVar.PlanetWarsMode != lastPlanetWarsMode)
+                {
+                    server.Broadcast(GeneratePwStatus());
+                    UpdateLobby();
+                    lastPlanetWarsMode = MiscVar.PlanetWarsMode;
+                }
+
+                if (MiscVar.PlanetWarsMode != PlanetWarsModes.Running) return;
 
-                // also join in lobby
-                foreach (var usr in Challenge.Attackers.Union(Challenge.Defenders)) await server.ForceJoinBattle(usr, battle);
+                // clean up stale running battles (e.g. if Spring process crashed)
+                var staleBattleIds = RunningBattles.Keys.Where(id => !server.Battles.ContainsKey(id)).ToList();
+                foreach (var id in staleBattleIds) RunningBattles.Remove(id);
 
-                if (await battle.StartGame())
+                switch (Phase)
                 {
+                    case PwPhase.AttackCollect:
+                        if (DateTime.UtcNow > GetAttackDeadline())
+                        {
+                            RunSquadFormation();
+                            if (FormedSquads.Any())
+                            {
+                                // transition to defend
+                                Phase = PwPhase.DefendCollect;
+                                PhaseStartTime = DateTime.UtcNow;
+                                UpdateLobby();
+                            }
+                            else
+                            {
+                                // nobody attacked, skip to next faction
+                                AttackerSideCounter++;
+                                ResetAttackOptions();
+                            }
+                        }
+                        break;
 
-                    var text =
-                        $"Battle for planet {Challenge.Name} starts on zk://@join_player:{Challenge.Attackers.FirstOrDefault()}  Roster: {string.Join(",", Challenge.Attackers)} vs {string.Join(",", Challenge.Defenders)}";
+                    case PwPhase.DefendCollect:
+                        UpdateDefendersFullTime();
 
-                    foreach (var fac in factions) await server.GhostChanSay(fac.Shortcut, text);
+                        if (DateTime.UtcNow > GetEffectiveDefendDeadline())
+                        {
+                            defendersFullTime = null;
+                            RunDefenderAssignment();
+                            await LaunchAllBattles();
+                            RunGalaxyTick();
+                            AttackerSideCounter++;
+                            ResetAttackOptions();
+                        }
+                        break;
                 }
-                else await server.RemoveBattle(battle);
             }
-
-            AttackerSideCounter++;
-            ResetAttackOptions();
+            catch (Exception ex)
+            {
+                Trace.TraceError("PlanetWars timer error: {0}", ex);
+            }
+            finally
+            {
+                timer.Start();
+            }
         }
 
-        /// <summary>
-        ///     Invoked from web page
-        /// </summary>
-        /// <param name="planet"></param>
-        public void AddAttackOption(Planet planet)
+
+        // ===================== SQUAD FORMATION (PIERCING) =====================
+
+        private void RunSquadFormation()
         {
-            try
+            FormedSquads.Clear();
+
+            // collect all attackers still connected, grouped by planet
+            var playerPlanet = new Dictionary<string, AttackOption>(); // player -> their chosen option
+            foreach (var opt in AttackOptions)
             {
-                if (MiscVar.PlanetWarsMode != PlanetWarsModes.Running) return;
+                opt.Attackers = opt.Attackers.Where(x => server.ConnectedUsers.ContainsKey(x)).ToList();
+                foreach (var name in opt.Attackers)
+                    playerPlanet[name] = opt;
+            }
 
-                if (!AttackOptions.Any(x => x.PlanetID == planet.PlanetID) && (Challenge == null) &&
-                    (planet.OwnerFactionID != AttackingFaction.FactionID))
+            if (!playerPlanet.Any()) return;
+
+            // look up PW-WHR and PW-Rank for each player
+            var playerWhr = new Dictionary<string, double>();
+            var playerRoleOrder = new Dictionary<string, int>(); // lower = higher faction rank
+            using (var db = new ZkDataContext())
+            {
+                foreach (var name in playerPlanet.Keys.ToList())
                 {
-                    InternalAddOption(planet);
-                    UpdateLobby();
+                    var user = server.ConnectedUsers.Get(name)?.User;
+                    if (user == null) { playerPlanet.Remove(name); continue; }
+
+                    playerWhr[name] = GetPlayerWhr(name);
+
+                    // PW-Rank: faction role DisplayOrder, lower = higher rank. No role = int.MaxValue
+                    var account = db.Accounts.Find(user.AccountID);
+                    var factionRole = account?.AccountRolesByAccountID
+                        .Where(r => r.RoleType != null && !r.RoleType.IsClanOnly && r.RoleType.RestrictFactionID == AttackingFaction.FactionID)
+                        .Select(r => r.RoleType.DisplayOrder)
+                        .OrderBy(x => x)
+                        .Cast<int?>()
+                        .FirstOrDefault();
+                    playerRoleOrder[name] = factionRole ?? int.MaxValue;
                 }
             }
-            catch (Exception ex)
+
+            var pool = new HashSet<string>(playerPlanet.Keys);
+
+            // Pass 1: while any planet has >= TeamSize players, form squads from top WHR
+            bool formed;
+            do
             {
-                Trace.TraceError("PlanetWars error adding option {0}: {1}", planet, ex);
+                formed = false;
+                foreach (var opt in AttackOptions)
+                {
+                    var available = opt.Attackers.Where(pool.Contains).OrderByDescending(x => playerWhr.Get(x)).ToList();
+                    while (available.Count >= opt.TeamSize)
+                    {
+                        var squad = CreateSquadFromOption(opt);
+                        squad.Attackers = available.Take(opt.TeamSize).ToList();
+                        FormedSquads.Add(squad);
+                        foreach (var p in squad.Attackers) pool.Remove(p);
+                        available = available.Skip(opt.TeamSize).ToList();
+                        formed = true;
+                    }
+                }
+            } while (formed); // repeat in case removing players from one planet frees up nothing, but be safe
+
+            // Pass 2: piercing — top PW-Rank player pulls others to their planet
+            while (pool.Count > 0)
+            {
+                // find top PW-Rank player (lowest DisplayOrder, tiebreak by WHR desc)
+                var leader = pool
+                    .OrderBy(x => playerRoleOrder.GetOrDefault(x, int.MaxValue))
+                    .ThenByDescending(x => playerWhr.Get(x))
+                    .First();
+
+                var leaderOption = playerPlanet[leader];
+                if (pool.Count < leaderOption.TeamSize)
+                    break; // not enough players for any squad
+
+                var fillers = pool
+                    .Where(x => x != leader)
+                    .OrderByDescending(x => playerWhr.Get(x))
+                    .Take(leaderOption.TeamSize - 1)
+                    .ToList();
+
+                if (fillers.Count < leaderOption.TeamSize - 1)
+                    break; // not enough
+
+                var squad = CreateSquadFromOption(leaderOption);
+                squad.Attackers = new List<string> { leader };
+                squad.Attackers.AddRange(fillers);
+                FormedSquads.Add(squad);
+
+                pool.Remove(leader);
+                foreach (var p in fillers) pool.Remove(p);
             }
+
+            AttackOptions.Clear();
+
+            // initialize defender votes for attacked planets
+            DefenderVotes.Clear();
+            foreach (var planetId in FormedSquads.Select(s => s.PlanetID).Distinct())
+                DefenderVotes[planetId] = new List<string>();
+
+            // notify attackers
+            foreach (var squad in FormedSquads)
+                server.Broadcast(squad.Attackers, new PwAttackingPlanet() { PlanetID = squad.PlanetID });
         }
 
-        public PwMatchCommand GenerateLobbyCommand()
+        private AttackOption CreateSquadFromOption(AttackOption source)
         {
-            PwMatchCommand command = null;
-            try
+            return new AttackOption
             {
-                if (MiscVar.PlanetWarsMode != PlanetWarsModes.Running) return new PwMatchCommand(PwMatchCommand.ModeType.Clear);
+                PlanetID = source.PlanetID,
+                Map = source.Map,
+                Name = source.Name,
+                OwnerFactionID = source.OwnerFactionID,
+                TeamSize = source.TeamSize,
+                PlanetImage = source.PlanetImage,
+                IconSize = source.IconSize,
+                StructureImages = source.StructureImages,
+                Attackers = new List<string>(),
+                Defenders = new List<string>()
+            };
+        }
 
-                if (Challenge == null)
-                    command = new PwMatchCommand(PwMatchCommand.ModeType.Attack)
-                    {
-                        Options = AttackOptions.Select(x => x.ToVoteOption(PwMatchCommand.ModeType.Attack)).ToList(),
-                        Deadline = GetAttackDeadline(),
-                        DeadlineSeconds = (int)GetAttackDeadline().Subtract(DateTime.UtcNow).TotalSeconds,
-                        AttackerFaction = AttackingFaction.Shortcut
-                    };
-                else
-                    command = new PwMatchCommand(PwMatchCommand.ModeType.Defend)
-                    {
-                        Options = new List<PwMatchCommand.VoteOption> { Challenge.ToVoteOption(PwMatchCommand.ModeType.Defend) },
-                        Deadline = GetAcceptDeadline(),
-                        DeadlineSeconds = (int)GetAcceptDeadline().Subtract(DateTime.UtcNow).TotalSeconds,
-                        AttackerFaction = AttackingFaction.Shortcut,
-                        DefenderFactions = GetDefendingFactions(Challenge).Select(x => x.Shortcut).ToList()
-                    };
+
+        // ===================== DEFENDER ASSIGNMENT =====================
+
+        private void RunDefenderAssignment()
+        {
+            // look up defender WHR
+            var defenderWhr = new Dictionary<string, double>();
+            foreach (var kv in DefenderVotes)
+            {
+                foreach (var name in kv.Value)
+                {
+                    if (defenderWhr.ContainsKey(name)) continue;
+                    if (!server.ConnectedUsers.ContainsKey(name)) continue;
+                    defenderWhr[name] = GetPlayerWhr(name);
+                }
             }
-            catch (Exception ex)
+
+            // per-planet: assign defenders, overflow to pool
+            var floatingPool = new List<string>();
+            var assignedDefenders = new Dictionary<int, List<string>>(); // planetID -> assigned defender names
+            var attackedPlanetIds = FormedSquads.Select(s => s.PlanetID).Distinct().ToList();
+
+            foreach (var planetId in attackedPlanetIds)
             {
-                Trace.TraceError("PlanetWars {0}: {1}", nameof(GenerateLobbyCommand), ex);
+                var totalSlotsNeeded = FormedSquads.Where(s => s.PlanetID == planetId).Sum(s => s.TeamSize);
+                var volunteers = (DefenderVotes.ContainsKey(planetId) ? DefenderVotes[planetId] : new List<string>())
+                    .Where(x => server.ConnectedUsers.ContainsKey(x) && defenderWhr.ContainsKey(x))
+                    .OrderByDescending(x => defenderWhr[x])
+                    .ToList();
+
+                if (volunteers.Count > totalSlotsNeeded)
+                {
+                    assignedDefenders[planetId] = volunteers.Take(totalSlotsNeeded).ToList();
+                    floatingPool.AddRange(volunteers.Skip(totalSlotsNeeded));
+                }
+                else
+                {
+                    assignedDefenders[planetId] = volunteers;
+                }
             }
-            return command;
-        }
 
-        private async Task JoinPlanet(string name, int planetId)
-        {
-            try
+            // floating pool fills unfilled slots on other planets (WHR order, respecting faction eligibility)
+            floatingPool = floatingPool.OrderByDescending(x => defenderWhr.Get(x)).ToList();
+
+            // cache defending factions per planet and defender faction IDs
+            var planetDefendingFactions = new Dictionary<int, List<Faction>>();
+            foreach (var pid in attackedPlanetIds)
+                planetDefendingFactions[pid] = GetDefendingFactions(FormedSquads.First(s => s.PlanetID == pid));
+
+            var defenderFactionId = new Dictionary<string, int?>();
+            using (var db = new ZkDataContext())
             {
-                var user = server.ConnectedUsers.Get(name)?.User;
-                if (user != null)
+                foreach (var name in floatingPool)
                 {
-                    var faction = factions.First(x => x.Shortcut == user.Faction);
-                    if (faction == AttackingFaction) await JoinPlanetAttack(planetId, name);
-                    else if ((Challenge != null) && GetDefendingFactions(Challenge).Any(y=>y.FactionID == faction.FactionID)) await JoinPlanetDefense(planetId, name);
+                    var user = server.ConnectedUsers.Get(name)?.User;
+                    if (user != null) defenderFactionId[name] = db.Accounts.Find(user.AccountID)?.FactionID;
                 }
             }
-            catch (Exception ex)
+
+            foreach (var planetId in attackedPlanetIds)
             {
-                Trace.TraceError("PlanetWars {0} {1} {2} : {3}", nameof(JoinPlanet), name, planetId, ex);
+                var totalSlotsNeeded = FormedSquads.Where(s => s.PlanetID == planetId).Sum(s => s.TeamSize);
+                var assigned = assignedDefenders[planetId];
+                var deficit = totalSlotsNeeded - assigned.Count;
+                if (deficit > 0 && floatingPool.Count > 0)
+                {
+                    var allowedFactionIds = planetDefendingFactions[planetId].Select(f => f.FactionID).ToHashSet();
+                    var eligible = floatingPool.Where(x => defenderFactionId.ContainsKey(x) && defenderFactionId[x].HasValue && allowedFactionIds.Contains(defenderFactionId[x].Value)).ToList();
+                    var toAdd = eligible.Take(deficit).ToList();
+                    assigned.AddRange(toAdd);
+                    foreach (var p in toAdd) floatingPool.Remove(p);
+                }
             }
-        }
 
-        public async Task OnJoinPlanet(ConnectedUser conus, PwJoinPlanet args)
-        {
-            if (MiscVar.PlanetWarsMode == PlanetWarsModes.Running)
+            // slice defenders into squads: sort squads by avg attacker WHR desc, assign best defenders to best attackers
+            foreach (var planetId in attackedPlanetIds)
             {
-                if (conus.User.CanUserPlanetWars()) await JoinPlanet(conus.Name, args.PlanetID);
+                var squadsForPlanet = FormedSquads
+                    .Where(s => s.PlanetID == planetId)
+                    .OrderByDescending(s => s.Attackers.Average(a => GetPlayerWhr(a))) // sort by attacker strength
+                    .ToList();
+
+                var defenders = assignedDefenders.ContainsKey(planetId)
+                    ? assignedDefenders[planetId].OrderByDescending(x => defenderWhr.Get(x)).ToList()
+                    : new List<string>();
+
+                int idx = 0;
+                foreach (var squad in squadsForPlanet)
+                {
+                    var count = Math.Min(squad.TeamSize, defenders.Count - idx);
+                    if (count > 0)
+                    {
+                        squad.Defenders = defenders.Skip(idx).Take(count).ToList();
+                        idx += count;
+                    }
+                    // else: no defenders at all for this squad (concede)
+                }
             }
         }
 
-        public async Task OnLoginAccepted(ConnectedUser connectedUser)
+        private double GetPlayerWhr(string name)
         {
-            await connectedUser.SendCommand(GeneratePwStatus());
-
-            if (MiscVar.PlanetWarsMode == PlanetWarsModes.Running)
-            {
-                var u = connectedUser.User;
-                if (u.CanUserPlanetWars()) await UpdateLobby(u.Name);
-            }
+            var user = server.ConnectedUsers.Get(name)?.User;
+            if (user == null) return 0;
+            return RatingSystems.GetRatingSystem(RatingCategory.Planetwars).GetPlayerRating(user.AccountID).LadderElo;
         }
 
-        public async Task OnUserDisconnected(string name)
+
+        // ===================== LAUNCH BATTLES =====================
+
+        private async Task LaunchAllBattles()
         {
-            try
+            foreach (var squad in FormedSquads)
             {
-                if (MiscVar.PlanetWarsMode == PlanetWarsModes.Running)
+                // filter to still-connected
+                squad.Attackers = squad.Attackers.Where(x => server.ConnectedUsers.ContainsKey(x)).ToList();
+                squad.Defenders = squad.Defenders.Where(x => server.ConnectedUsers.ContainsKey(x)).ToList();
+
+                if (squad.Defenders.Count > 0 && squad.Attackers.Count > 0)
                 {
-                    if (Challenge == null)
+                    // battle (may be uneven)
+                    try
                     {
-                        if (AttackOptions.Count > 0)
+                        var battle = new PlanetWarsServerBattle(server, squad);
+                        await server.AddBattle(battle);
+                        RunningBattles[battle.BattleID] = squad;
+
+                        foreach (var usr in squad.Attackers.Union(squad.Defenders))
+                            await server.ForceJoinBattle(usr, battle);
+
+                        if (await battle.StartGame())
                         {
-                            var sumRemoved = 0;
-                            foreach (var aop in AttackOptions) sumRemoved += aop.Attackers.RemoveAll(x => x == name);
-                            if (sumRemoved > 0) await UpdateLobby();
+                            var text = $"Battle for planet {squad.Name} starts on zk://@join_player:{squad.Attackers.FirstOrDefault()}  Roster: {string.Join(",", squad.Attackers)} vs {string.Join(",", squad.Defenders)}";
+                            foreach (var fac in factions) await server.GhostChanSay(fac.Shortcut, text);
+                        }
+                        else
+                        {
+                            await server.RemoveBattle(battle);
+                            RunningBattles.Remove(battle.BattleID);
                         }
                     }
-                    else
+                    catch (Exception ex)
                     {
-                        var userName = name;
-                        if (Challenge.Defenders.RemoveAll(x => x == userName) > 0) await UpdateLobby();
+                        Trace.TraceError("PlanetWars LaunchBattle error: {0}", ex);
                     }
                 }
+                else if (squad.Attackers.Count > 0)
+                {
+                    // concede - zero defenders
+                    RecordPlanetwarsLoss(squad);
+                }
+                // else: no attackers left, skip entirely
+            }
+
+            FormedSquads.Clear();
+            DefenderVotes.Clear();
+        }
+
+
+        // ===================== GALAXY TICK =====================
+
+        private void RunGalaxyTick()
+        {
+            try
+            {
+                var text = new StringBuilder();
+                using (var db = new ZkDataContext())
+                {
+                    PlanetWarsTurnHandler.ProcessGalaxyTick(db, text, server.PlanetWarsEventCreator, server);
+                }
             }
             catch (Exception ex)
             {
-                Trace.TraceError("PlanetWars OnUserDisconnected: {0}", ex);
+                Trace.TraceError("PlanetWars galaxy tick error: {0}", ex);
             }
         }
 
 
-        public void RemoveFromRunningBattles(int battleID)
-        {
-            RunningBattles.Remove(battleID);
-        }
+        // ===================== PLAYER ACTIONS =====================
 
-        private async Task UpdateLobby()
+        public async Task OnJoinPlanet(ConnectedUser conus, PwJoinPlanet args)
         {
-            await
-                server.Broadcast(server.ConnectedUsers.Values.Where(x => x.User.CanUserPlanetWars()), GenerateLobbyCommand());
-            SaveStateToDb();
+            if (MiscVar.PlanetWarsMode == PlanetWarsModes.Running)
+            {
+                if (conus.User.CanUserPlanetWars()) await JoinPlanet(conus.Name, args.PlanetID);
+            }
         }
 
-        private Task UpdateLobby(string player)
+        private async Task JoinPlanet(string name, int planetId)
         {
-            return server.ConnectedUsers.Get(player)?.SendCommand(GenerateLobbyCommand());
-        }
+            try
+            {
+                var user = server.ConnectedUsers.Get(name)?.User;
+                if (user == null) return;
 
-        private DateTime GetAcceptDeadline() 
-        {
-            return ChallengeTime.Value.AddMinutes(GlobalConst.PlanetWarsMinutesToAccept);
+                var faction = factions.FirstOrDefault(x => x.Shortcut == user.Faction);
+                if (faction == null) return;
+
+                if (Phase == PwPhase.AttackCollect && faction == AttackingFaction)
+                    await JoinPlanetAttack(planetId, name);
+                else if (Phase == PwPhase.DefendCollect && faction != AttackingFaction)
+                    await JoinPlanetDefense(planetId, name);
+            }
+            catch (Exception ex)
+            {
+                Trace.TraceError("PlanetWars {0} {1} {2} : {3}", nameof(JoinPlanet), name, planetId, ex);
+            }
         }
 
-        private DateTime GetAttackDeadline()
+        private async Task JoinPlanetAttack(int targetPlanetId, string userName)
         {
-            var extra = 0;
-            if (AttackOptions.Count == 0)
+            var attackOption = AttackOptions.Find(x => x.PlanetID == targetPlanetId);
+            if (attackOption == null) return;
+
+            var conus = server.ConnectedUsers.Get(userName);
+            var user = conus?.User;
+            if (user == null) return;
+
+            using (var db = new ZkDataContext())
             {
-                return AttackerSideChangeTime.AddMinutes(GlobalConst.PlanetWarsMinutesToAttackIfNoOption);
-            }
+                var account = db.Accounts.Find(user.AccountID);
+                if (account == null || account.FactionID != AttackingFaction.FactionID || !account.CanPlayerPlanetWars()) return;
 
-            if (missedDefenseFactionID == AttackingFaction.FactionID) extra = Math.Min(missedDefenseCount * GlobalConst.PlanetWarsMinutesToAttack, 60);
+                // remove from other options
+                foreach (var aop in AttackOptions.Where(x => x.PlanetID != targetPlanetId))
+                    aop.Attackers.RemoveAll(x => x == userName);
 
-            return AttackerSideChangeTime.AddMinutes(GlobalConst.PlanetWarsMinutesToAttack + extra);
+                // add to this option (no cap — it's a vote, squad formation handles sizing)
+                if (!attackOption.Attackers.Contains(userName))
+                {
+                    attackOption.Attackers.Add(user.Name);
+                    await server.GhostChanSay(user.Faction, $"{userName} joins attack on {attackOption.Name}");
+                    await conus.SendCommand(new PwJoinPlanetSuccess() { PlanetID = targetPlanetId });
+                    await UpdateLobby();
+                }
+            }
         }
 
-        public List<Faction> GetDefendingFactions(AttackOption target)
+        private async Task JoinPlanetDefense(int targetPlanetId, string userName)
         {
-            if (target.OwnerFactionID != null)
+            if (!DefenderVotes.ContainsKey(targetPlanetId)) return;
+
+            var conus = server.ConnectedUsers.Get(userName);
+            var user = conus?.User;
+            if (user == null) return;
+
+            using (var db = new ZkDataContext())
             {
-                var ret = new List<Faction>();
-                ret.Add(factions.Find(x => x.FactionID == target.OwnerFactionID));
+                var account = db.Accounts.Find(user.AccountID);
+                if (account == null || !account.CanPlayerPlanetWars()) return;
+
+                // check this user's faction can defend this specific planet
+                var squadsOnPlanet = FormedSquads.Where(s => s.PlanetID == targetPlanetId).ToList();
+                if (!squadsOnPlanet.Any()) return;
+                var defendingFactions = GetDefendingFactions(squadsOnPlanet.First());
+                if (!defendingFactions.Any(f => f.FactionID == account.FactionID))
+                {
+                    await server.GhostChanSay(user.Faction, $"{userName} cannot defend {squadsOnPlanet.First().Name} (not owner or allied)");
+                    return;
+                }
 
-                // add allies as defenders
-                using (var db = new ZkDataContext())
+                // remove from other planets
+                foreach (var kv in DefenderVotes)
+                    kv.Value.RemoveAll(x => x == userName);
+
+                // add to this planet
+                if (!DefenderVotes[targetPlanetId].Contains(userName))
                 {
-                    var planet = db.Planets.Find(target.PlanetID);
-                    foreach (var of in db.Factions.Where(x=>!x.IsDeleted && x.FactionID != target.OwnerFactionID && x.FactionID != AttackingFaction.FactionID))
-                    {
-                        if (of.GaveTreatyRight(planet, x=>x.EffectBalanceSameSide == true)) ret.Add(factions.First(x=>x.FactionID == of.FactionID));
-                    }
+                    DefenderVotes[targetPlanetId].Add(userName);
+                    UpdateDefendersFullTime();
+                    await server.GhostChanSay(user.Faction, $"{userName} joins defense of {squadsOnPlanet.First().Name}");
+                    await conus.SendCommand(new PwJoinPlanetSuccess() { PlanetID = targetPlanetId });
+                    await UpdateLobby();
                 }
-                return ret;
             }
-
-            return factions.Where(x => x != AttackingFaction).ToList();
         }
 
-        private void InternalAddOption(Planet planet)
+
+        // ===================== CONNECTION EVENTS =====================
+
+        public async Task OnLoginAccepted(ConnectedUser connectedUser)
         {
-            AttackOptions.Add(new AttackOption
+            await connectedUser.SendCommand(GeneratePwStatus());
+
+            if (MiscVar.PlanetWarsMode == PlanetWarsModes.Running)
             {
-                PlanetID = planet.PlanetID,
-                Map = planet.Resource.InternalName,
-                OwnerFactionID = planet.OwnerFactionID,
-                Name = planet.Name,
-                TeamSize = planet.TeamSize,
-                PlanetImage = planet.Resource?.MapPlanetWarsIcon,
-                IconSize = planet.Resource?.PlanetWarsIconSize ?? 0,
-                StructureImages = planet.PlanetStructures.Select(x => x.IsActive ? x.StructureType.MapIcon : x.StructureType.DisabledMapIcon).ToList()
-            });
+                var u = connectedUser.User;
+                if (u.CanUserPlanetWars()) await UpdateLobby(u.Name);
+            }
         }
 
-        private async Task JoinPlanetAttack(int targetPlanetId, string userName)
+        public async Task OnUserDisconnected(string name)
         {
-            var attackOption = AttackOptions.Find(x => x.PlanetID == targetPlanetId);
-            if (attackOption != null)
+            try
             {
-                var conus = server.ConnectedUsers.Get(userName);
-                var user = conus?.User;
-                if (user != null)
-                    using (var db = new ZkDataContext())
-                    {
-                        var account = db.Accounts.Find(user.AccountID);
-                        if ((account != null) && (account.FactionID == AttackingFaction.FactionID) && account.CanPlayerPlanetWars())
-                        {
-                            // remove existing user from other options
-                            foreach (var aop in AttackOptions.Where(x => x.PlanetID != targetPlanetId)) aop.Attackers.RemoveAll(x => x == userName);
+                if (MiscVar.PlanetWarsMode != PlanetWarsModes.Running) return;
 
-                            // add user to this option
-                            if (attackOption.Attackers.Count < attackOption.TeamSize && !attackOption.Attackers.Contains(userName))
-                            {
-                                attackOption.Attackers.Add(user.Name);
-                                await server.GhostChanSay(user.Faction, $"{userName} joins attack on {attackOption.Name}");
+                bool changed = false;
+                if (Phase == PwPhase.AttackCollect)
+                {
+                    foreach (var aop in AttackOptions)
+                        changed |= aop.Attackers.RemoveAll(x => x == name) > 0;
+                }
+                else if (Phase == PwPhase.DefendCollect)
+                {
+                    // remove from defender votes
+                    foreach (var kv in DefenderVotes)
+                        changed |= kv.Value.RemoveAll(x => x == name) > 0;
 
-                                await conus.SendCommand(new PwJoinPlanetSuccess() { PlanetID = targetPlanetId });
+                    // also remove from formed squads (attacker who disconnected after squad formation)
+                    foreach (var squad in FormedSquads)
+                        changed |= squad.Attackers.RemoveAll(x => x == name) > 0;
 
-                                if (attackOption.Attackers.Count >= attackOption.TeamSize) await StartChallenge(attackOption);
-                                else await UpdateLobby();
-                            }
-                        }
+                    if (changed) UpdateDefendersFullTime();
+                }
 
-                    }
+                if (changed) await UpdateLobby();
+            }
+            catch (Exception ex)
+            {
+                Trace.TraceError("PlanetWars OnUserDisconnected: {0}", ex);
             }
         }
 
-        private async Task JoinPlanetDefense(int targetPlanetID, string userName)
+
+        // ===================== LOBBY COMMANDS =====================
+
+        public PwMatchCommand GenerateLobbyCommand(string playerFaction = null)
         {
-            if ((Challenge != null) && (Challenge.PlanetID == targetPlanetID) && (Challenge.Defenders.Count < Challenge.TeamSize))
+            PwMatchCommand command = null;
+            try
             {
-                var conus = server.ConnectedUsers.Get(userName);
-                var user = conus?.User;
-                if (user != null)
+                if (MiscVar.PlanetWarsMode != PlanetWarsModes.Running)
+                    return new PwMatchCommand(PwMatchCommand.ModeType.Clear);
+
+                if (Phase == PwPhase.AttackCollect)
                 {
-                    var db = new ZkDataContext();
-                    var account = db.Accounts.Find(user.AccountID);
-                    if ((account != null) && GetDefendingFactions(Challenge).Any(y => y.FactionID == account.FactionID) &&
-                        account.CanPlayerPlanetWars())
-                        if (!Challenge.Defenders.Any(y => y == user.Name))
-                        {
-                            Challenge.Defenders.Add(user.Name);
+                    command = new PwMatchCommand(PwMatchCommand.ModeType.Attack)
+                    {
+                        Options = AttackOptions.Select(x => x.ToVoteOption(PwMatchCommand.ModeType.Attack)).ToList(),
+                        Deadline = GetAttackDeadline(),
+                        DeadlineSeconds = (int)GetAttackDeadline().Subtract(DateTime.UtcNow).TotalSeconds,
+                        AttackerFaction = AttackingFaction.Shortcut
+                    };
+                }
+                else if (Phase == PwPhase.DefendCollect)
+                {
+                    // build defending factions cache per planet
+                    var defFactionCache = new Dictionary<int, List<Faction>>();
+                    foreach (var planetId in FormedSquads.Select(s => s.PlanetID).Distinct())
+                    {
+                        if (!defFactionCache.ContainsKey(planetId))
+                            defFactionCache[planetId] = GetDefendingFactions(FormedSquads.First(s => s.PlanetID == planetId));
+                    }
+
+                    // resolve player's faction ID for filtering
+                    int? playerFactionId = null;
+                    if (playerFaction != null)
+                    {
+                        var fac = factions.FirstOrDefault(f => f.Shortcut == playerFaction);
+                        playerFactionId = fac?.FactionID;
+                    }
 
-                            await server.GhostChanSay(user.Faction, $"{userName} joins defense of {Challenge.Name}");
+                    // aggregate per planet, filtered to planets this player can defend
+                    var options = new List<PwMatchCommand.VoteOption>();
+                    foreach (var planetId in FormedSquads.Select(s => s.PlanetID).Distinct())
+                    {
+                        // skip planets this player's faction cannot defend
+                        if (playerFactionId != null && !defFactionCache[planetId].Any(f => f.FactionID == playerFactionId))
+                            continue;
 
-                            await conus.SendCommand(new PwJoinPlanetSuccess() { PlanetID = targetPlanetID });
+                        var squads = FormedSquads.Where(s => s.PlanetID == planetId).ToList();
+                        var first = squads.First();
+                        var totalNeeded = squads.Sum(s => s.TeamSize);
+                        var volunteered = DefenderVotes.ContainsKey(planetId) ? DefenderVotes[planetId].Count : 0;
 
-                            if (Challenge.Defenders.Count >= Challenge.TeamSize) await AcceptChallenge();
-                            else await UpdateLobby();
-                        }
+                        options.Add(new PwMatchCommand.VoteOption
+                        {
+                            PlanetID = first.PlanetID,
+                            PlanetName = first.Name,
+                            Map = first.Map,
+                            IconSize = first.IconSize,
+                            StructureImages = first.StructureImages,
+                            PlanetImage = first.PlanetImage,
+                            Count = volunteered,
+                            Needed = totalNeeded
+                        });
+                    }
+
+                    var allDefFactions = defFactionCache.Values
+                        .SelectMany(f => f.Select(x => x.Shortcut))
+                        .Distinct()
+                        .ToList();
+
+                    var effectiveDeadline = GetEffectiveDefendDeadline();
+                    command = new PwMatchCommand(PwMatchCommand.ModeType.Defend)
+                    {
+                        Options = options,
+                        Deadline = effectiveDeadline,
+                        DeadlineSeconds = (int)effectiveDeadline.Subtract(DateTime.UtcNow).TotalSeconds,
+                        AttackerFaction = AttackingFaction.Shortcut,
+                        DefenderFactions = allDefFactions
+                    };
                 }
             }
+            catch (Exception ex)
+            {
+                Trace.TraceError("PlanetWars {0}: {1}", nameof(GenerateLobbyCommand), ex);
+            }
+            return command;
         }
 
-        private void RecordPlanetwarsLoss(AttackOption option)
-        {
-            if (option.OwnerFactionID != null)
-                if (option.OwnerFactionID == missedDefenseFactionID)
-                {
-                    missedDefenseCount++;
-                }
-                else
-                {
-                    missedDefenseCount = 0;
-                    missedDefenseFactionID = option.OwnerFactionID.Value;
-                }
 
-            var message = string.Format("{0} won because nobody tried to defend", AttackingFaction.Name);
-            foreach (var fac in factions) server.GhostChanSay(fac.Shortcut, message);
+        // ===================== ATTACK OPTIONS =====================
 
-            var text = new StringBuilder();
+        /// <summary>
+        ///     Invoked from web page
+        /// </summary>
+        public void AddAttackOption(Planet planet)
+        {
             try
             {
-                var db = new ZkDataContext();
-                var playerIds = option.Attackers.Select(x => x).Union(option.Defenders.Select(x => x)).ToList();
+                if (MiscVar.PlanetWarsMode != PlanetWarsModes.Running) return;
+                if (Phase != PwPhase.AttackCollect) return;
 
-                PlanetWarsTurnHandler.EndTurn(option.Map,
-                    null,
-                    db,
-                    0,
-                    db.Accounts.Where(x => playerIds.Contains(x.Name) && (x.Faction != null)).ToList(),
-                    text,
-                    null,
-                    db.Accounts.Where(x => option.Attackers.Contains(x.Name) && (x.Faction != null)).ToList(),
-                    server.PlanetWarsEventCreator, server);
+                if (!AttackOptions.Any(x => x.PlanetID == planet.PlanetID) &&
+                    (planet.OwnerFactionID != AttackingFaction.FactionID))
+                {
+                    InternalAddOption(planet);
+                    UpdateLobby();
+                }
             }
             catch (Exception ex)
             {
-                Trace.TraceError(ex.ToString());
-                text.Append(ex);
+                Trace.TraceError("PlanetWars error adding option {0}: {1}", planet, ex);
             }
         }
 
         private void ResetAttackOptions()
         {
             AttackOptions.Clear();
+            FormedSquads.Clear();
+            DefenderVotes.Clear();
+            Phase = PwPhase.AttackCollect;
+            PhaseStartTime = DateTime.UtcNow;
             AttackerSideChangeTime = DateTime.UtcNow;
-            Challenge = null;
-            ChallengeTime = null;
+
+            // TODO re-enable to prevent attacking planets with running battles
+            // var contestedPlanetIds = RunningBattles.Values.Select(x => x.PlanetID).ToHashSet();
+            var contestedPlanetIds = new HashSet<int>();
 
             using (var db = new ZkDataContext())
             {
@@ -424,13 +755,11 @@ private void ResetAttackOptions()
                         .OrderByDescending(x => x.PlanetFactions.Where(y => y.FactionID == AttackingFaction.FactionID).Sum(y => y.Dropships))
                         .ThenByDescending(x => x.PlanetFactions.Where(y => y.FactionID == AttackingFaction.FactionID).Sum(y => y.Influence))
                         .ToList();
-                // list of planets by attacker's influence
 
                 foreach (var planet in planets)
                 {
-                    if (planet.CanMatchMakerPlay(attacker))
+                    if (planet.CanMatchMakerPlay(attacker) && !contestedPlanetIds.Contains(planet.PlanetID))
                     {
-                        // pick only those where you can actually attack atm
                         InternalAddOption(planet);
                         cnt--;
                     }
@@ -439,100 +768,174 @@ private void ResetAttackOptions()
 
                 if (!AttackOptions.Any(y => y.TeamSize == 2))
                 {
-                    var planet = planets.FirstOrDefault(x => (x.TeamSize == 2) && x.CanMatchMakerPlay(attacker));
+                    var planet = planets.FirstOrDefault(x => (x.TeamSize == 2) && x.CanMatchMakerPlay(attacker) && !contestedPlanetIds.Contains(x.PlanetID));
                     if (planet != null) InternalAddOption(planet);
                 }
             }
 
             UpdateLobby();
-
             server.GhostChanSay(AttackingFaction.Shortcut, "It's your turn! Select a planet to attack");
         }
 
-        private void SaveStateToDb()
+        private void InternalAddOption(Planet planet)
         {
-            var db = new ZkDataContext();
-            var gal = db.Galaxies.First(x => x.IsDefault);
-
-            gal.MatchMakerState = JsonConvert.SerializeObject((PlanetWarsMatchMakerState)this);
-
-            gal.AttackerSideCounter = AttackerSideCounter;
-            gal.AttackerSideChangeTime = AttackerSideChangeTime;
-            db.SaveChanges();
+            AttackOptions.Add(new AttackOption
+            {
+                PlanetID = planet.PlanetID,
+                Map = planet.Resource.InternalName,
+                OwnerFactionID = planet.OwnerFactionID,
+                Name = planet.Name,
+                TeamSize = planet.TeamSize,
+                PlanetImage = planet.Resource?.MapPlanetWarsIcon,
+                IconSize = planet.Resource?.PlanetWarsIconSize ?? 0,
+                StructureImages = planet.PlanetStructures.Select(x => x.IsActive ? x.StructureType.MapIcon : x.StructureType.DisabledMapIcon).ToList()
+            });
         }
 
 
-        private async Task StartChallenge(AttackOption attackOption)
-        {
-            Challenge = attackOption;
-            ChallengeTime = DateTime.UtcNow;
-            AttackOptions.Clear();
-            await UpdateLobby();
-            await server.Broadcast(attackOption.Attackers, new PwAttackingPlanet() { PlanetID = attackOption.PlanetID });
-        }
-
-        private PlanetWarsModes? lastPlanetWarsMode;
+        // ===================== HELPERS =====================
 
-        private void TimerOnElapsed(object sender, ElapsedEventArgs elapsedEventArgs)
+        public List<Faction> GetDefendingFactions(AttackOption target)
         {
-            try
+            if (target.OwnerFactionID != null)
             {
-                timer.Stop();
+                var ret = new List<Faction>();
+                ret.Add(factions.Find(x => x.FactionID == target.OwnerFactionID));
 
-                // auto change PW mode based on time
-                if (MiscVar.PlanetWarsNextModeTime != null && MiscVar.PlanetWarsNextModeTime < DateTime.UtcNow && MiscVar.PlanetWarsNextMode != null)
+                using (var db = new ZkDataContext())
                 {
-                    MiscVar.PlanetWarsMode = MiscVar.PlanetWarsNextMode ?? PlanetWarsModes.AllOffline;
-
-                    MiscVar.PlanetWarsNextMode = null;
-                    MiscVar.PlanetWarsNextModeTime = null;
-
-                    using (var db = new ZkDataContext())
+                    var planet = db.Planets.Find(target.PlanetID);
+                    foreach (var of in db.Factions.Where(x => !x.IsDeleted && x.FactionID != target.OwnerFactionID && x.FactionID != AttackingFaction.FactionID))
                     {
-                        db.Events.Add(server.PlanetWarsEventCreator.CreateEvent("PlanetWars changed status to {0}", MiscVar.PlanetWarsMode.Description()));
-                        db.SaveChanges();
+                        if (of.GaveTreatyRight(planet, x => x.EffectBalanceSameSide == true))
+                            ret.Add(factions.First(x => x.FactionID == of.FactionID));
                     }
                 }
+                return ret;
+            }
 
+            return factions.Where(x => x != AttackingFaction).ToList();
+        }
 
-                if (MiscVar.PlanetWarsMode != lastPlanetWarsMode)
+        private void RecordPlanetwarsLoss(AttackOption option)
+        {
+            var message = $"{AttackingFaction.Name} won {option.Name} because nobody tried to defend";
+            foreach (var fac in factions) server.GhostChanSay(fac.Shortcut, message);
+
+            try
+            {
+                using (var db = new ZkDataContext())
                 {
-                    server.Broadcast(GeneratePwStatus());
-                    UpdateLobby();
-                    lastPlanetWarsMode = MiscVar.PlanetWarsMode;
+                    var playerIds = option.Attackers.Union(option.Defenders).ToList();
+
+                    PlanetWarsTurnHandler.ProcessBattleResult(option.Map,
+                        null,
+                        db,
+                        0,
+                        db.Accounts.Where(x => playerIds.Contains(x.Name) && (x.Faction != null)).ToList(),
+                        new StringBuilder(),
+                        null,
+                        db.Accounts.Where(x => option.Attackers.Contains(x.Name) && (x.Faction != null)).ToList(),
+                        server.PlanetWarsEventCreator, server);
                 }
+            }
+            catch (Exception ex)
+            {
+                Trace.TraceError("PlanetWars RecordLoss error: {0}", ex);
+            }
+        }
 
-                if (MiscVar.PlanetWarsMode != PlanetWarsModes.Running) return;
+        private DateTime GetAttackDeadline()
+        {
+            if (AttackOptions.Count == 0)
+                return PhaseStartTime.AddMinutes(GlobalConst.PlanetWarsMinutesToAttackIfNoOption);
 
-                if (Challenge == null)
-                {
-                    // attack timer
-                    if (DateTime.UtcNow > GetAttackDeadline())
-                    {
-                        AttackerSideCounter++;
-                        ResetAttackOptions();
-                    }
-                }
-                else
+            return PhaseStartTime.AddMinutes(GlobalConst.PlanetWarsMinutesToAttack);
+        }
+
+        private DateTime GetDefendDeadline()
+        {
+            return PhaseStartTime.AddMinutes(GlobalConst.PlanetWarsMinutesToAccept);
+        }
+
+        /// <summary>
+        /// Effective defend deadline accounting for the 30s early cutoff when enough defenders join.
+        /// </summary>
+        private DateTime GetEffectiveDefendDeadline()
+        {
+            var deadline = GetDefendDeadline();
+            if (defendersFullTime != null)
+            {
+                var earlyDeadline = defendersFullTime.Value.AddSeconds(30);
+                if (earlyDeadline < deadline) deadline = earlyDeadline;
+            }
+            return deadline;
+        }
+
+        /// <summary>
+        /// Check if every attacked planet has enough direct defender volunteers and set/clear the 30s countdown.
+        /// Each planet must independently have volunteers >= its slots — overflow across factions is not counted.
+        /// </summary>
+        private void UpdateDefendersFullTime()
+        {
+            var allFull = FormedSquads.Any(); // at least one squad exists
+            foreach (var planetId in FormedSquads.Select(s => s.PlanetID).Distinct())
+            {
+                var slotsNeeded = FormedSquads.Where(s => s.PlanetID == planetId).Sum(s => s.TeamSize);
+                var volunteered = DefenderVotes.ContainsKey(planetId) ? DefenderVotes[planetId].Count : 0;
+                if (volunteered < slotsNeeded)
                 {
-                    // accept timer
-                    if (DateTime.UtcNow > GetAcceptDeadline())
-                        if ((Challenge.Defenders.Count >= Challenge.Attackers.Count - 1) && (Challenge.Defenders.Count > 0)) AcceptChallenge();
-                        else
-                        {
-                            RecordPlanetwarsLoss(Challenge);
-                            AttackerSideCounter++;
-                            ResetAttackOptions();
-                        }
+                    allFull = false;
+                    break;
                 }
             }
-            catch (Exception ex)
+
+            if (allFull)
             {
-                Trace.TraceError("PlanetWars timer error: {0}", ex);
+                if (defendersFullTime == null) defendersFullTime = DateTime.UtcNow;
             }
-            finally
+            else
             {
-                timer.Start();
+                defendersFullTime = null;
+            }
+        }
+
+        public void RemoveFromRunningBattles(int battleID)
+        {
+            RunningBattles.Remove(battleID);
+        }
+
+        private async Task UpdateLobby()
+        {
+            if (Phase == PwPhase.DefendCollect)
+            {
+                // send per-player filtered options (only planets they can defend)
+                foreach (var conus in server.ConnectedUsers.Values.Where(x => x.User.CanUserPlanetWars()))
+                    await conus.SendCommand(GenerateLobbyCommand(conus.User.Faction));
+            }
+            else
+            {
+                await server.Broadcast(server.ConnectedUsers.Values.Where(x => x.User.CanUserPlanetWars()), GenerateLobbyCommand());
+            }
+            SaveStateToDb();
+        }
+
+        private Task UpdateLobby(string player)
+        {
+            var conus = server.ConnectedUsers.Get(player);
+            if (conus == null) return Task.CompletedTask;
+            return conus.SendCommand(GenerateLobbyCommand(conus.User.Faction));
+        }
+
+        private void SaveStateToDb()
+        {
+            using (var db = new ZkDataContext())
+            {
+                var gal = db.Galaxies.First(x => x.IsDefault);
+                gal.MatchMakerState = JsonConvert.SerializeObject((PlanetWarsMatchMakerState)this);
+                gal.AttackerSideCounter = AttackerSideCounter;
+                gal.AttackerSideChangeTime = AttackerSideChangeTime;
+                db.SaveChanges();
             }
         }
 
@@ -547,10 +950,12 @@ private static PwStatus GeneratePwStatus()
             };
         }
 
+
+        // ===================== NESTED TYPES =====================
+
         public class AttackOption
         {
             public List<string> Attackers { get; set; }
-
             public List<string> Defenders { get; set; }
             public string Map { get; set; }
             public string Name { get; set; }
@@ -559,8 +964,6 @@ public class AttackOption
             public int TeamSize { get; set; }
             public List<string> StructureImages { get; set; } = new List<string>();
             public int IconSize { get; set; }
-
-
             public string PlanetImage { get; set; }
 
             public AttackOption()
@@ -571,7 +974,7 @@ public AttackOption()
 
             public PwMatchCommand.VoteOption ToVoteOption(PwMatchCommand.ModeType mode)
             {
-                var opt = new PwMatchCommand.VoteOption
+                return new PwMatchCommand.VoteOption
                 {
                     PlanetID = PlanetID,
                     PlanetName = Name,
@@ -582,10 +985,7 @@ public PwMatchCommand.VoteOption ToVoteOption(PwMatchCommand.ModeType mode)
                     Count = mode == PwMatchCommand.ModeType.Attack ? Attackers.Count : Defenders.Count,
                     Needed = TeamSize
                 };
-
-                return opt;
             }
-
         }
     }
-}
\ No newline at end of file
+}
diff --git a/ZkLobbyServer/SpringieInterface/PlanetWarsMatchMakerState.cs b/ZkLobbyServer/SpringieInterface/PlanetWarsMatchMakerState.cs
index 20eea4a597..908500af26 100644
--- a/ZkLobbyServer/SpringieInterface/PlanetWarsMatchMakerState.cs
+++ b/ZkLobbyServer/SpringieInterface/PlanetWarsMatchMakerState.cs
@@ -1,22 +1,38 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
 namespace ZeroKWeb
 {
+    public enum PwPhase
+    {
+        AttackCollect = 0,
+        DefendCollect = 1
+    }
+
     public class PlanetWarsMatchMakerState
     {
         /// <summary>
-        ///     Possible attack options
+        ///     Possible attack options / planets to vote on
         /// </summary>
         public List<PlanetWarsMatchMaker.AttackOption> AttackOptions { get; set; }
         public DateTime AttackerSideChangeTime { get; set; }
         public int AttackerSideCounter { get; set; }
-        public PlanetWarsMatchMaker.AttackOption Challenge { get; set; }
 
-        public DateTime? ChallengeTime { get; set; }
+        public PwPhase Phase { get; set; }
+        public DateTime PhaseStartTime { get; set; }
+
+        /// <summary>
+        ///     Formed attack squads after squad formation runs. Each is an AttackOption with Attackers filled.
+        /// </summary>
+        public List<PlanetWarsMatchMaker.AttackOption> FormedSquads { get; set; } = new List<PlanetWarsMatchMaker.AttackOption>();
+
+        /// <summary>
+        ///     Defender volunteers per planet during DefendCollect phase. Key = PlanetID, Value = list of player names.
+        /// </summary>
+        public Dictionary<int, List<string>> DefenderVotes { get; set; } = new Dictionary<int, List<string>>();
 
         public Dictionary<int, PlanetWarsMatchMaker.AttackOption> RunningBattles { get; set; } = new Dictionary<int, PlanetWarsMatchMaker.AttackOption>();
         public PlanetWarsMatchMakerState() { }
     }
-}
\ No newline at end of file
+}
diff --git a/ZkLobbyServer/SpringieInterface/PlanetWarsTurnHandler.cs b/ZkLobbyServer/SpringieInterface/PlanetWarsTurnHandler.cs
index b24adcd1e4..03572f3b49 100644
--- a/ZkLobbyServer/SpringieInterface/PlanetWarsTurnHandler.cs
+++ b/ZkLobbyServer/SpringieInterface/PlanetWarsTurnHandler.cs
@@ -12,16 +12,18 @@ public static class PlanetWarsTurnHandler
 {
 
     /// <summary>
-    /// Process planet wars turn
+    /// Process planet wars turn - legacy wrapper calling both per-battle and per-turn processing
     /// </summary>
-    /// <param name="mapName"></param>
-    /// <param name="extraData"></param>
-    /// <param name="db"></param>
-    /// <param name="winNum">0 = attacker wins, 1 = defender wins</param>
-    /// <param name="players"></param>
-    /// <param name="text"></param>
-    /// <param name="sb"></param>
     public static void EndTurn(string mapName, List<string> extraData, ZkDataContext db, int? winNum, List<Account> players, StringBuilder text, SpringBattle sb, List<Account> attackers, IPlanetwarsEventCreator eventCreator, ZkLobbyServer.ZkLobbyServer server)
+    {
+        ProcessBattleResult(mapName, extraData, db, winNum, players, text, sb, attackers, eventCreator, server);
+        ProcessGalaxyTick(db, text, eventCreator, server, mapName, sb);
+    }
+
+    /// <summary>
+    /// Per-battle processing: influence, metal, structures, attack points
+    /// </summary>
+    public static void ProcessBattleResult(string mapName, List<string> extraData, ZkDataContext db, int? winNum, List<Account> players, StringBuilder text, SpringBattle sb, List<Account> attackers, IPlanetwarsEventCreator eventCreator, ZkLobbyServer.ZkLobbyServer server)
     {
         if (extraData == null) extraData = new List<string>();
         Galaxy gal = db.Galaxies.Single(x => x.IsDefault);
@@ -57,8 +59,6 @@ public static void EndTurn(string mapName, List<string> extraData, ZkDataContext
         string influenceReport = "";
 
         // distribute influence
-        // save influence gains
-        // give influence to main attackers
         double planetIpDefs = planet.GetEffectiveIpDefense();
 
         double baseInfluence = GlobalConst.BaseInfluencePerBattle;
@@ -100,7 +100,7 @@ public static void EndTurn(string mapName, List<string> extraData, ZkDataContext
         if (influence < 0) influence = 0;
         influence = Math.Floor(influence * 100) / 100;
 
-        // main winner influence 
+        // main winner influence
         PlanetFaction entry = planet.PlanetFactions.FirstOrDefault(x => x.Faction == attacker);
         if (entry == null)
         {
@@ -112,7 +112,6 @@ public static void EndTurn(string mapName, List<string> extraData, ZkDataContext
 
 
         // clamping of influence
-        // gained over 100, sole owner
         if (entry.Influence >= GlobalConst.PlanetWarsMaximumIP)
         {
             entry.Influence = GlobalConst.PlanetWarsMaximumIP;
@@ -145,8 +144,6 @@ public static void EndTurn(string mapName, List<string> extraData, ZkDataContext
         }
 
 
-
-
         // distribute metal
         var attackersTotalMetal = CalculateFactionMetalGain(planet, hqStructure, attacker, GlobalConst.PlanetWarsAttackerMetal, eventCreator, db, text, sb);
         var attackerMetal = Math.Floor(attackersTotalMetal / attackers.Count);
@@ -222,7 +219,7 @@ public static void EndTurn(string mapName, List<string> extraData, ZkDataContext
             acc.PwAttackPoints += ap;
         }
 
-        // paranoia!
+        // event logging
         try
         {
             var mainEvent = eventCreator.CreateEvent("{0} attacked {1} {2} in {3} and {4}. {5}",
@@ -301,13 +298,37 @@ public static void EndTurn(string mapName, List<string> extraData, ZkDataContext
                 else planet.PlanetStructures.Remove(s);
             }
 
-            var ev = eventCreator.CreateEvent("All non-evacuated structures have been disabled on {0} planet {1}. {2}", planet.Faction, planet, sb);
-            db.Events.InsertOnSubmit(ev);
-            text.AppendLine(ev.PlainText);
+            var ev2 = eventCreator.CreateEvent("All non-evacuated structures have been disabled on {0} planet {1}. {2}", planet.Faction, planet, sb);
+            db.Events.InsertOnSubmit(ev2);
+            text.AppendLine(ev2.PlainText);
         }
 
         db.SaveChanges();
 
+        // planet ownership can change from battle influence — must check immediately
+        int? oldOwner = planet.OwnerAccountID;
+        SetPlanetOwners(eventCreator, db, sb);
+
+        // re-fetch planet after ownership update
+        planet = db.Galaxies.Single(x => x.IsDefault).Planets.Single(x => x.Resource.InternalName == mapName);
+        if (planet.OwnerAccountID != oldOwner && planet.OwnerAccountID != null)
+        {
+            text.AppendFormat("Congratulations!! Planet {0} was conquered by {1} !!  {3}/PlanetWars/Planet/{2}\n",
+                planet.Name,
+                planet.Account.Name,
+                planet.PlanetID,
+                GlobalConst.BaseSiteUrl);
+        }
+    }
+
+    /// <summary>
+    /// Per-turn galaxy-wide processing: influence spread, decay, production, VP, treaties
+    /// Called once per turn from the matchmaker after launching battles.
+    /// </summary>
+    public static void ProcessGalaxyTick(ZkDataContext db, StringBuilder text, IPlanetwarsEventCreator eventCreator, ZkLobbyServer.ZkLobbyServer server, string mapName = null, SpringBattle sb = null)
+    {
+        Galaxy gal = db.Galaxies.Single(x => x.IsDefault);
+
         gal.DecayInfluence();
         gal.SpreadInfluence();
 
@@ -361,11 +382,10 @@ public static void EndTurn(string mapName, List<string> extraData, ZkDataContext
         foreach (var fac in db.Factions.Where(x => !x.IsDeleted)) fac.ConvertExcessEnergyToMetal();
 
 
-        int? oldOwner = planet.OwnerAccountID;
         gal.Turn++;
         db.SaveChanges();
 
-        db = new ZkDataContext(); // is this needed - attempt to fix setplanetownersbeing buggy
+        db = new ZkDataContext(); // attempt to fix setplanetowners being buggy
         SetPlanetOwners(eventCreator, db, sb != null ? db.SpringBattles.Find(sb.SpringBattleID) : null);
         gal = db.Galaxies.Single(x => x.IsDefault);
 
@@ -379,22 +399,10 @@ public static void EndTurn(string mapName, List<string> extraData, ZkDataContext
             db.SaveChanges();
         }
 
-
-        planet = gal.Planets.Single(x => x.Resource.InternalName == mapName);
-        if (planet.OwnerAccountID != oldOwner && planet.OwnerAccountID != null)
-        {
-            text.AppendFormat("Congratulations!! Planet {0} was conquered by {1} !!  {3}/PlanetWars/Planet/{2}\n",
-                planet.Name,
-                planet.Account.Name,
-                planet.PlanetID,
-                GlobalConst.BaseSiteUrl);
-        }
-
         server.PublishUserProfilePlanetwarsPlayers();
-        
+
         try
         {
-
             // store history
             foreach (Planet p in gal.Planets)
             {
@@ -418,27 +426,30 @@ public static void EndTurn(string mapName, List<string> extraData, ZkDataContext
         }
 
         //rotate map
-        if (GlobalConst.RotatePWMaps)
+        if (GlobalConst.RotatePWMaps && mapName != null)
         {
             db = new ZkDataContext();
             gal = db.Galaxies.Single(x => x.IsDefault);
-            planet = gal.Planets.Single(x => x.Resource.InternalName == mapName);
-            var mapList = db.Resources.Where(x => x.MapPlanetWarsIcon != null && x.Planets.Where(p => p.GalaxyID == gal.GalaxyID).Count() == 0 && x.MapSupportLevel>=MapSupportLevel.Featured
-                                                  && x.ResourceID != planet.MapResourceID && x.MapWaterLevel == planet.Resource.MapWaterLevel).ToList();
-            if (mapList.Count > 0)
-            {
-                int r = new Random().Next(mapList.Count);
-                int resourceID = mapList[r].ResourceID;
-                Resource newMap = db.Resources.Single(x => x.ResourceID == resourceID);
-                text.AppendLine(String.Format("Map cycler - {0} maps found, selected map {1} to replace map {2}", mapList.Count, newMap.InternalName, planet.Resource.InternalName));
-                planet.Resource = newMap;
-                gal.IsDirty = true;
-            }
-            else
+            var planet2 = gal.Planets.SingleOrDefault(x => x.Resource.InternalName == mapName);
+            if (planet2 != null)
             {
-                text.AppendLine("Map cycler - no maps found");
+                var mapList = db.Resources.Where(x => x.MapPlanetWarsIcon != null && x.Planets.Where(p => p.GalaxyID == gal.GalaxyID).Count() == 0 && x.MapSupportLevel>=MapSupportLevel.Featured
+                                                      && x.ResourceID != planet2.MapResourceID && x.MapWaterLevel == planet2.Resource.MapWaterLevel).ToList();
+                if (mapList.Count > 0)
+                {
+                    int r = new Random().Next(mapList.Count);
+                    int resourceID = mapList[r].ResourceID;
+                    Resource newMap = db.Resources.Single(x => x.ResourceID == resourceID);
+                    text.AppendLine(String.Format("Map cycler - {0} maps found, selected map {1} to replace map {2}", mapList.Count, newMap.InternalName, planet2.Resource.InternalName));
+                    planet2.Resource = newMap;
+                    gal.IsDirty = true;
+                }
+                else
+                {
+                    text.AppendLine("Map cycler - no maps found");
+                }
+                db.SaveChanges();
             }
-            db.SaveChanges();
         }
     }
 
@@ -458,7 +469,7 @@ private static double CalculateFactionMetalGain(Planet planet, StructureType hq,
                 var ev = eventCreator.CreateEvent("{0} metal gain reduced by {1} because it is disconnected from {2}. {3}",
                     forFaction,
                     hq.EffectDisconnectedMetalMalus,
-                    hq.Name, 
+                    hq.Name,
                     sb);
                 db.Events.Add(ev);
                 texts.AppendLine(ev.PlainText);
@@ -507,8 +518,6 @@ private static List<int> GetEvacuatedStructureTypes(List<string> extraData, ZkDa
     /// <summary>
     /// Updates shadow influence and new owners
     /// </summary>
-    /// <param name="db"></param>
-    /// <param name="sb">optional spring batle that caused this change (for event logging)</param>
     public static void SetPlanetOwners(IPlanetwarsEventCreator eventCreator, ZkDataContext db = null, SpringBattle sb = null)
     {
         if (db == null) db = new ZkDataContext();
@@ -529,7 +538,7 @@ public static void SetPlanetOwners(IPlanetwarsEventCreator eventCreator, ZkDataC
 
             if (best == null || best.Influence < GlobalConst.InfluenceToCapturePlanet)
             {
-                // planet not capture 
+                // planet not capture
 
                 if (planet.Faction != null)
                 {
@@ -572,7 +581,7 @@ public static void SetPlanetOwners(IPlanetwarsEventCreator eventCreator, ZkDataC
                                 FirstOrDefault();
                     }
 
-                    // best with planets 
+                    // best with planets
                     if (candidate == null)
                     {
                         candidate =
@@ -587,7 +596,7 @@ public static void SetPlanetOwners(IPlanetwarsEventCreator eventCreator, ZkDataC
             // change has occured
             if (newFaction != planet.Faction)
             {
-                // disable structures 
+                // disable structures
                 foreach (PlanetStructure structure in planet.PlanetStructures.Where(x => x.StructureType.OwnerChangeDisablesThis))
                 {
                     structure.ReactivateAfterBuild();