PW changes - attacker charges always spent, separate passive recharge maximum + owner faction in API. fix #3043

Author: Licho1

Shared/LobbyClient/Protocol/Messages.cs

@@ -715,6 +715,9 @@ public class VoteOption
             /// key that identifies this attack slot. Clients must echo it back in <see cref="PwJoinPlanet"/>.
             /// </summary>
             public string AttackerFaction { get; set; }
+            /// <summary>Faction shortcut of the planet's current owner, or null for neutral planets. Lets the
+            /// lobby surface "you own this", "ally owns this", "neutral" hints during attack/defense pick.</summary>
+            public string OwnerFaction { get; set; }
             /// <summary>Average PW-WHR of the projected attacker squad (top-TeamSize volunteers). 0 when none.</summary>
             public int AttackerAvgWhr { get; set; }
             /// <summary>Average PW-WHR of the projected defender squad. Null in AttackCollect phase or when no volunteers.</summary>
@@ -782,6 +785,9 @@ public class PwStatus
         public int MinLevel { get; set; }
         public int AttackerPhaseMinutes { get; set; }
         public int DefenderPhaseMinutes { get; set; }
+        /// <summary>Server's configured max attack charges. Lobby renders X/Max in the charges UI;
+        /// before this field existed Chobby hardcoded 2 as the fallback default.</summary>
+        public int MaxAttackCharges { get; set; }
     }
 
     [Message(Origin.Server)]

Zero-K.info/Controllers/PlanetwarsAdminController.cs

@@ -366,10 +366,12 @@ public ActionResult StartGalaxy(int galaxyID)
                 gal.EndMessage = null;
                 db.SaveChanges();
 
-                var maxCharges = DynamicConfig.Instance.PwAttackChargesMax;
+                // Seed everyone at the passive recharge limit, not the absolute max — defending as the very
+                // first PW action of the new galaxy then has a tangible reward (stockpiling above passive cap).
+                var initialCharges = Math.Min(DynamicConfig.Instance.PwAttackChargesPassiveLimit, DynamicConfig.Instance.PwAttackChargesMax);
                 db.Accounts.Where(x => x.FactionID != null).Update(x => new Account()
                 {
-                    PwAttackCharges = maxCharges,
+                    PwAttackCharges = initialCharges,
                     PwLastChargeChange = null,
                 });
             }

ZkData/Ef/DynamicConfig.cs

@@ -49,6 +49,9 @@ public class DynamicConfig
         [Description("PlanetWars: minutes a player must be idle (no spend/gain) before their next +1 passive charge, up to max. Every charge gain or loss resets this clock, so the average regen rate is at most 1 charge per this many minutes.")]
         public int PwAttackChargesCooldownMinutes { get; set; } = 60;
 
+        [Description("PlanetWars: cap on charges obtainable through passive idle recharge. Players may exceed this via active grants (e.g. defense rewards) and keep what they have, but the recharge tick will not push them above this value. Should be <= PwAttackChargesMax.")]
+        public int PwAttackChargesPassiveLimit { get; set; } = 1;
+
         [Description("PlanetWars: fraction of enemy bomber IP damage also applied to the bomber's own faction. 0 disables self-damage.")]
         public double PwBomberSelfIpRate { get; set; } = 0.5;
 

ZkData/Migrations/202604271235020_AddPwAttackChargesPassiveLimit.Designer.cs

@@ -0,0 +1,18 @@
+namespace ZkData.Migrations
+{
+    using System;
+    using System.Data.Entity.Migrations;
+    
+    public partial class AddPwAttackChargesPassiveLimit : DbMigration
+    {
+        public override void Up()
+        {
+            AddColumn("dbo.DynamicConfigs", "PwAttackChargesPassiveLimit", c => c.Int(nullable: false, defaultValue: 1));
+        }
+        
+        public override void Down()
+        {
+            DropColumn("dbo.DynamicConfigs", "PwAttackChargesPassiveLimit");
+        }
+    }
+}

ZkData/Migrations/202604271235020_AddPwAttackChargesPassiveLimit.cs

@@ -515,6 +515,10 @@
     <Compile Include="Migrations\202604251056090_AddPwChargesWallclock.Designer.cs">
       <DependentUpon>202604251056090_AddPwChargesWallclock.cs</DependentUpon>
     </Compile>
+    <Compile Include="Migrations\202604271235020_AddPwAttackChargesPassiveLimit.cs" />
+    <Compile Include="Migrations\202604271235020_AddPwAttackChargesPassiveLimit.Designer.cs">
+      <DependentUpon>202604271235020_AddPwAttackChargesPassiveLimit.cs</DependentUpon>
+    </Compile>
     <Compile Include="SpringFilesUnitsyncAttempt.cs" />
     <Compile Include="SteamWebApi.cs" />
     <Compile Include="UserLanguageNoteAttribute.cs" />
@@ -981,6 +985,9 @@
     <EmbeddedResource Include="Migrations\202604251056090_AddPwChargesWallclock.resx">
       <DependentUpon>202604251056090_AddPwChargesWallclock.cs</DependentUpon>
     </EmbeddedResource>
+    <EmbeddedResource Include="Migrations\202604271235020_AddPwAttackChargesPassiveLimit.resx">
+      <DependentUpon>202604271235020_AddPwAttackChargesPassiveLimit.cs</DependentUpon>
+    </EmbeddedResource>
     <EmbeddedResource Include="ZkDataResources.resx">
       <Generator>ResXFileCodeGenerator</Generator>
       <LastGenOutput>ZkDataResources.Designer.cs</LastGenOutput>

ZkData/Migrations/202604271235020_AddPwAttackChargesPassiveLimit.resx

@@ -129,6 +129,13 @@ private async void TimerOnElapsed(object sender, ElapsedEventArgs elapsedEventAr
                             RunSquadFormation();
                             if (FormedSquads.Any())
                             {
+                                // Charge spend happens here, the moment squads are formed — every attacker in
+                                // a FormedSquad has irrevocably committed (see disconnect locking above), so
+                                // there is no path that gives the charge back. LaunchAllBattles no longer
+                                // touches charges.
+                                var attackerNames = FormedSquads.SelectMany(s => s.Attackers).Distinct().ToList();
+                                if (attackerNames.Count > 0) await SpendAttackCharges(attackerNames);
+
                                 Phase = PwPhase.DefendCollect;
                                 PhaseStartTime = DateTime.UtcNow;
                                 UpdateLobby();
@@ -447,15 +454,15 @@ private int AvgTopNWhr(IEnumerable<string> names, int slots)
 
         private async Task LaunchAllBattles()
         {
-            // charges are spent only for attackers whose squad reached a confirmed outcome — either
-            // the Spring battle successfully started, or it was a concede. Battles that fail to start
-            // (StartGame returned false, or setup threw) refund the commitment.
-            var attackerNamesToChargeSpend = new List<string>();
+            // Charges are spent at end of AttackCollect (squad formation), not here. By the time we launch,
+            // the commitment is final regardless of whether StartGame succeeds or the squad concedes.
 
             // one battle per squad — no merging across attacker factions (each (planet, attacker-faction) is its own slot)
             foreach (var squad in FormedSquads.ToList())
             {
-                squad.Attackers = squad.Attackers.Where(x => server.ConnectedUsers.ContainsKey(x)).ToList();
+                // Attackers are locked at squad formation; we do NOT drop disconnected ones — they keep their
+                // slot in the Spring script and can reconnect into the running battle. Defenders are looser —
+                // a defender who disconnected after RunDefenderAssignment is dropped here.
                 squad.Defenders = squad.Defenders.Where(x => server.ConnectedUsers.ContainsKey(x)).ToList();
 
                 if (squad.Attackers.Count == 0) continue;
@@ -474,7 +481,6 @@ private async Task LaunchAllBattles()
 
                         if (await battle.StartGame())
                         {
-                            attackerNamesToChargeSpend.AddRange(squad.Attackers);
                             var attackerFactionShortcut = GetFactionShortcut(squad.AttackerFactionID) ?? "?";
                             var text = $"Battle for planet {squad.Name} ({attackerFactionShortcut} attacks) 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);
@@ -492,15 +498,12 @@ private async Task LaunchAllBattles()
                 }
                 else
                 {
-                    // concede — zero defenders. Attackers still "attacked", so charge applies.
-                    attackerNamesToChargeSpend.AddRange(squad.Attackers);
+                    // concede — zero defenders. Charge was already spent at end of AttackCollect.
                     RecordPlanetwarsLoss(squad);
                 }
             }
 
             FormedSquads.Clear();
-
-            if (attackerNamesToChargeSpend.Count > 0) await SpendAttackCharges(attackerNamesToChargeSpend);
         }
 
         private async Task SpendAttackCharges(List<string> playerNames)
@@ -738,11 +741,12 @@ public async Task OnUserDisconnected(string name)
                 }
                 else if (Phase == PwPhase.DefendCollect)
                 {
+                    // Attackers are locked at squad formation: a disconnect must NOT release them, otherwise
+                    // they could reconnect and switch into a defense slot (or simply dodge their charge spend).
+                    // They stay in squad.Attackers and are carried into the launched Spring battle so they can
+                    // reconnect into the running game.
                     foreach (var squad in FormedSquads)
-                    {
                         changed |= squad.DefenderVotes.RemoveAll(x => x == name) > 0;
-                        changed |= squad.Attackers.RemoveAll(x => x == name) > 0;
-                    }
                     if (changed) UpdateDefendersFullTime();
                 }
 
@@ -767,6 +771,7 @@ private sealed class OptionSnapshot
             public int PlanetId;
             public int? AttackerFactionId;
             public string AttackerFactionShortcut;
+            public string OwnerFactionShortcut;
             public string PlanetName;
             public string Map;
             public int IconSize;
@@ -808,6 +813,7 @@ private LobbySnapshot ComputeLobbySnapshot(PwPhase phase)
                         PlanetId = opt.PlanetID,
                         AttackerFactionId = opt.AttackerFactionID,
                         AttackerFactionShortcut = GetFactionShortcut(opt.AttackerFactionID),
+                        OwnerFactionShortcut = GetFactionShortcut(opt.OwnerFactionID),
                         PlanetName = opt.Name,
                         Map = opt.Map,
                         IconSize = opt.IconSize,
@@ -841,6 +847,7 @@ private LobbySnapshot ComputeLobbySnapshot(PwPhase phase)
                         PlanetId = squad.PlanetID,
                         AttackerFactionId = squad.AttackerFactionID,
                         AttackerFactionShortcut = GetFactionShortcut(squad.AttackerFactionID),
+                        OwnerFactionShortcut = GetFactionShortcut(squad.OwnerFactionID),
                         PlanetName = squad.Name,
                         Map = squad.Map,
                         IconSize = squad.IconSize,
@@ -904,6 +911,7 @@ private PwMatchCommand StampLobbyCommand(LobbySnapshot snapshot, PwPhase phase,
                         PlayerIsAttacker = playerName != null && s.AttackerNames.Contains(playerName),
                         PlayerIsDefender = false,
                         AttackerFaction = s.AttackerFactionShortcut,
+                        OwnerFaction = s.OwnerFactionShortcut,
                         AttackerAvgWhr = s.AttackerAvgWhr,
                         DefenderAvgWhr = null,
                         WinChance = null,
@@ -938,6 +946,7 @@ private PwMatchCommand StampLobbyCommand(LobbySnapshot snapshot, PwPhase phase,
                             PlayerIsAttacker = playerIsAttacker,
                             PlayerIsDefender = playerName != null && s.DefenderNames.Contains(playerName),
                             AttackerFaction = s.AttackerFactionShortcut,
+                            OwnerFaction = s.OwnerFactionShortcut,
                             AttackerAvgWhr = s.AttackerAvgWhr,
                             DefenderAvgWhr = s.DefenderAvgWhr,
                             WinChance = s.WinChance,
@@ -1184,8 +1193,12 @@ public void RemoveFromRunningBattles(int battleID)
         public static PwAttackCharges BuildPwAttackCharges(Account account)
         {
             var max = DynamicConfig.Instance.PwAttackChargesMax;
+            // Passive recharge stops at PwAttackChargesPassiveLimit; charges above that come only from active
+            // grants (e.g. defense rewards). Show NextRechargeTime only while the player is still under the
+            // passive cap — once they're at or above it, no passive tick is coming.
+            var passiveLimit = Math.Min(DynamicConfig.Instance.PwAttackChargesPassiveLimit, max);
             DateTime? nextRechargeTime = null;
-            if (max > 0 && account.PwAttackCharges < max && account.PwLastChargeChange != null)
+            if (max > 0 && account.PwAttackCharges < passiveLimit && account.PwLastChargeChange != null)
                 nextRechargeTime = account.PwLastChargeChange.Value.AddMinutes(DynamicConfig.Instance.PwAttackChargesCooldownMinutes).CeilingToMinute();
             return new PwAttackCharges
             {
@@ -1219,6 +1232,12 @@ private async Task ProcessChargeRecharge()
             {
                 var max = DynamicConfig.Instance.PwAttackChargesMax;
                 if (max <= 0) return;
+                // Passive recharge tops out at PwAttackChargesPassiveLimit (clamped to max). Active grants
+                // (defense rewards) can push players above this and they keep what they have, but no idle
+                // tick will. Default of 1 means a player who logged off at 0 wakes up tomorrow with one
+                // charge — enough to attack OR to incentivise defending to stockpile more.
+                var passiveLimit = Math.Min(DynamicConfig.Instance.PwAttackChargesPassiveLimit, max);
+                if (passiveLimit <= 0) return;
                 var cooldownMinutes = DynamicConfig.Instance.PwAttackChargesCooldownMinutes;
                 // +35s offset: displayed nextRechargeTime is rounded up to a full minute. Bumping the
                 // eligibility window forward absorbs ≤1min jitter between the recharge check and the
@@ -1230,11 +1249,11 @@ private async Task ProcessChargeRecharge()
                 {
                     bumped = db.Accounts.Where(a =>
                         a.FactionID != null &&
-                        a.PwAttackCharges < max &&
+                        a.PwAttackCharges < passiveLimit &&
                         a.PwLastChargeChange != null &&
                         a.PwLastChargeChange <= threshold).ToList();
 
-                    foreach (var acc in bumped) acc.GrantPwAttackCharge(max);
+                    foreach (var acc in bumped) acc.GrantPwAttackCharge(passiveLimit);
 
                     if (bumped.Count > 0) db.SaveChanges();
                 }
@@ -1285,6 +1304,7 @@ private static PwStatus GeneratePwStatus()
                 PlanetWarsNextModeTime = MiscVar.PlanetWarsNextModeTime,
                 AttackerPhaseMinutes = GlobalConst.PlanetWarsMinutesToAttack,
                 DefenderPhaseMinutes = GlobalConst.PlanetWarsMinutesToAccept,
+                MaxAttackCharges = DynamicConfig.Instance.PwAttackChargesMax,
             };
         }