send full pw match list to all with per-viewer CanSelectForBattle/PlayerIsAttacker flags

previously DefendCollect hid the attacked planet from attackers themselves (their
faction filtered out), so they only got a one-shot PwAttackingPlanet and no live
defender-count / deadline updates. now the matchmaker broadcasts every attacked
planet to every PW user and tags each option with two per-viewer bools so chobby
can render attacker/defender/spectator states off a single payload. no names or
rosters are added to the payload.

Author: Licho1

Shared/LobbyClient/Protocol/Messages.cs

@@ -702,6 +702,8 @@ public class VoteOption
             public List<string> StructureImages { get; set; }
             public int IconSize { get; set; }
             public string PlanetName { get; set; }
+            public bool CanSelectForBattle { get; set; }
+            public bool PlayerIsAttacker { get; set; }
         }
     }
 

ZkLobbyServer/SpringieInterface/PlanetWarsMatchMaker.cs

@@ -630,19 +630,35 @@ public async Task OnUserDisconnected(string name)
 
         // ===================== LOBBY COMMANDS =====================
 
-        public PwMatchCommand GenerateLobbyCommand(string playerFaction = null)
+        public PwMatchCommand GenerateLobbyCommand(string playerName = null, string playerFaction = null)
         {
             PwMatchCommand command = null;
             try
             {
                 if (MiscVar.PlanetWarsMode != PlanetWarsModes.Running)
                     return new PwMatchCommand(PwMatchCommand.ModeType.Clear);
 
+                int? playerFactionId = null;
+                if (playerFaction != null)
+                {
+                    var fac = factions.FirstOrDefault(f => f.Shortcut == playerFaction);
+                    playerFactionId = fac?.FactionID;
+                }
+
                 if (Phase == PwPhase.AttackCollect)
                 {
+                    var canAttack = playerFactionId != null && playerFactionId == AttackingFaction.FactionID;
+                    var options = AttackOptions.Select(x =>
+                    {
+                        var v = x.ToVoteOption(PwMatchCommand.ModeType.Attack);
+                        v.CanSelectForBattle = canAttack;
+                        v.PlayerIsAttacker = playerName != null && x.Attackers.Contains(playerName);
+                        return v;
+                    }).ToList();
+
                     command = new PwMatchCommand(PwMatchCommand.ModeType.Attack)
                     {
-                        Options = AttackOptions.Select(x => x.ToVoteOption(PwMatchCommand.ModeType.Attack)).ToList(),
+                        Options = options,
                         Deadline = GetAttackDeadline(),
                         DeadlineSeconds = (int)GetAttackDeadline().Subtract(DateTime.UtcNow).TotalSeconds,
                         AttackerFaction = AttackingFaction.Shortcut
@@ -658,27 +674,18 @@ public PwMatchCommand GenerateLobbyCommand(string playerFaction = null)
                             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;
-                    }
-
-                    // aggregate per planet, filtered to planets this player can defend
+                    // aggregate per planet — send all planets, flag which ones the viewer can act on
                     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;
-
                         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;
 
+                        var playerIsAttacker = playerName != null && squads.Any(s => s.Attackers.Contains(playerName));
+                        var canDefend = playerFactionId != null && defFactionCache[planetId].Any(f => f.FactionID == playerFactionId);
+
                         options.Add(new PwMatchCommand.VoteOption
                         {
                             PlanetID = first.PlanetID,
@@ -688,7 +695,9 @@ public PwMatchCommand GenerateLobbyCommand(string playerFaction = null)
                             StructureImages = first.StructureImages,
                             PlanetImage = first.PlanetImage,
                             Count = volunteered,
-                            Needed = totalNeeded
+                            Needed = totalNeeded,
+                            CanSelectForBattle = canDefend && !playerIsAttacker,
+                            PlayerIsAttacker = playerIsAttacker
                         });
                     }
 
@@ -916,24 +925,17 @@ public void RemoveFromRunningBattles(int 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());
-            }
+            // per-player: flags (CanSelectForBattle / PlayerIsAttacker) depend on the viewer
+            foreach (var conus in server.ConnectedUsers.Values.Where(x => x.User.CanUserPlanetWars()))
+                await conus.SendCommand(GenerateLobbyCommand(conus.Name, conus.User.Faction));
             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));
+            return conus.SendCommand(GenerateLobbyCommand(conus.Name, conus.User.Faction));
         }
 
         private void SaveStateToDb()