Merge branch 'dev' of github.com:MSWS/TTT into dev

TTT/CS2/Items/Station/DamageStation.cs

@@ -50,14 +50,15 @@ public class DamageStation(IServiceProvider provider)
         && !Roles.GetRoles(m.ApiPlayer).Any(r => r is TraitorRole))
      .ToList();
 
+    // accumulate contributions per player: ApiPlayer -> list of (stationInfo, damage, gamePlayer)
+    var playerDamageMap =
+      new Dictionary<IOnlinePlayer, List<(StationInfo info, int damage,
+        CCSPlayerController gamePlayer)>>();
+
     foreach (var (prop, info) in Props) {
       if (_Config.TotalHealthGiven != 0 && Math.Abs(info.HealthGiven)
-        > Math.Abs(_Config.TotalHealthGiven)) {
-        toRemove.Add(prop);
-        continue;
-      }
-
-      if (!prop.IsValid || prop.AbsOrigin == null) {
+        > Math.Abs(_Config.TotalHealthGiven) || !prop.IsValid
+        || prop.AbsOrigin == null) {
         toRemove.Add(prop);
         continue;
       }
@@ -78,30 +79,69 @@ public class DamageStation(IServiceProvider provider)
         var damageAmount =
           Math.Abs((int)Math.Floor(_Config.HealthIncrements * healthScale));
 
-        var dmgEvent = new PlayerDamagedEvent(player,
-          info.Owner as IOnlinePlayer, damageAmount) { Weapon = $"[{Name}]" };
+        if (damageAmount <= 0) continue;
 
-        bus.Dispatch(dmgEvent);
-
-        damageAmount = dmgEvent.DmgDealt;
-
-        if (player.Health + damageAmount <= 0) {
-          killedWithStation[player.Id] = info;
-          var playerDeath = new PlayerDeathEvent(player)
-           .WithKiller(info.Owner as IOnlinePlayer)
-           .WithWeapon($"[{Name}]");
-          bus.Dispatch(playerDeath);
+        if (!playerDamageMap.TryGetValue(player, out var list)) {
+          list                    = [];
+          playerDamageMap[player] = list;
         }
 
-        gamePlayer.EmitSound("Player.DamageFall", SELF(gamePlayer.Slot), 0.2f);
-        player.Health    -= damageAmount;
-        info.HealthGiven += damageAmount;
+        list.Add((info, damageAmount, gamePlayer));
       }
     }
 
+    // Apply accumulated damage per player once
+    applyDamage(playerDamageMap);
+
+    // remove invalid/expired props
     foreach (var prop in toRemove) Props.Remove(prop);
   }
 
+  private void applyDamage(
+    Dictionary<IOnlinePlayer, List<(StationInfo info, int damage,
+      CCSPlayerController gamePlayer)>> playerDamageMap) {
+    foreach (var kv in playerDamageMap) {
+      var player   = kv.Key;
+      var contribs = kv.Value;
+
+      var totalDamage = contribs.Sum(c => c.damage);
+
+      if (totalDamage <= 0) continue;
+
+      // choose the station that contributed the most damage to attribute the kill to
+      var dominantInfo = contribs.OrderByDescending(c => c.damage).First().info;
+      var gamePlayer   = contribs.First().gamePlayer;
+
+      // dispatch single PlayerDamagedEvent with total damage
+      var dmgEvent = new PlayerDamagedEvent(player,
+        dominantInfo.Owner as IOnlinePlayer, totalDamage) {
+        Weapon = $"[{Name}]"
+      };
+
+      bus.Dispatch(dmgEvent);
+
+      totalDamage = dmgEvent.DmgDealt;
+
+      // if this will kill the player, attribute death to the dominant station
+      if (player.Health - totalDamage <= 0) {
+        killedWithStation[player.Id] = dominantInfo;
+        var playerDeath = new PlayerDeathEvent(player)
+         .WithKiller(dominantInfo.Owner as IOnlinePlayer)
+         .WithWeapon($"[{Name}]");
+        bus.Dispatch(playerDeath);
+      }
+
+      gamePlayer.EmitSound("Player.DamageFall", SELF(gamePlayer.Slot), 0.2f);
+
+      // apply damage to player's health
+      player.Health -= totalDamage;
+
+      // update each station's HealthGiven by its own contribution
+      foreach (var (info, damage, _) in contribs) info.HealthGiven += damage;
+    }
+  }
+
+
   private static RecipientFilter SELF(int slot) {
     return new RecipientFilter(slot);
   }

TTT/CS2/Items/Station/HealthStation.cs

@@ -30,6 +30,28 @@ public class HealthStation(IServiceProvider provider)
   override protected void onInterval() {
     var players  = Utilities.GetPlayers();
     var toRemove = new List<CPhysicsPropMultiplayer>();
+
+    // build per-player potential heal contributions and gather props to remove
+    var perPlayerContrib = BuildPerPlayerContributions(players, toRemove);
+
+    // apply the accumulated heals in a single pass per player
+    applyAccumulatedHeals(perPlayerContrib);
+
+    // remove invalid/expired props
+    foreach (var prop in toRemove) Props.Remove(prop);
+  }
+
+  /// <summary>
+  /// Scan all props and build a map: Player -> list of (StationInfo, potentialHeal).
+  /// Also fills toRemove for invalid/expired props.
+  /// </summary>
+  private
+    Dictionary<CCSPlayerController, List<(StationInfo info, int potential)>>
+    BuildPerPlayerContributions(IReadOnlyList<CCSPlayerController> players,
+      List<CPhysicsPropMultiplayer> toRemove) {
+    var result =
+      new Dictionary<CCSPlayerController, List<(StationInfo, int)>>();
+
     foreach (var (prop, info) in Props) {
       if (_Config.TotalHealthGiven != 0
         && Math.Abs(info.HealthGiven) > _Config.TotalHealthGiven) {
@@ -52,19 +74,130 @@ public class HealthStation(IServiceProvider provider)
        .ToList();
 
       foreach (var (player, dist) in playerDists) {
-        var maxHp       = player.Pawn.Value?.MaxHealth ?? 100;
-        var healthScale = 1.0 - dist / _Config.MaxRange;
-        var maxHealAmo =
-          (int)Math.Ceiling(_Config.HealthIncrements * healthScale);
-        var newHealth   = Math.Min(player.GetHealth() + maxHealAmo, maxHp);
-        var healthGiven = newHealth - player.GetHealth();
-        player.SetHealth(newHealth);
-        info.HealthGiven += healthGiven;
+        var potentialHeal = ComputePotentialHeal(dist);
+        if (potentialHeal <= 0) continue;
 
-        if (healthGiven > 0) player.EmitSound("HealthShot.Pickup", null, 0.1f);
+        if (!result.TryGetValue(player, out var list)) {
+          list           = [];
+          result[player] = list;
+        }
+
+        list.Add((info, potentialHeal));
       }
     }
 
-    foreach (var prop in toRemove) Props.Remove(prop);
+    return result;
+  }
+
+  /// <summary>
+  /// Compute potential heal from a station given the distance.
+  /// Mirrors your original logic: ceil(HealthIncrements * healthScale).
+  /// </summary>
+  private int ComputePotentialHeal(double dist) {
+    var healthScale = 1.0 - dist / _Config.MaxRange;
+    return (int)Math.Ceiling(_Config.HealthIncrements * healthScale);
+  }
+
+  /// <summary>
+  /// Apply heals to each player once per tick.
+  /// Distributes the actual heal proportionally across contributing stations,
+  /// updates station.Info.HealthGiven and emits a single pickup sound if needed.
+  /// </summary>
+  private void applyAccumulatedHeals(
+    Dictionary<CCSPlayerController, List<(StationInfo info, int potential)>>
+      perPlayerContrib) {
+    foreach (var kv in perPlayerContrib) {
+      var player   = kv.Key;
+      var contribs = kv.Value;
+
+      var maxHp     = player.Pawn.Value?.MaxHealth ?? 100;
+      var currentHp = player.GetHealth();
+      if (currentHp >= maxHp) continue;
+
+      var totalPotential = contribs.Sum(c => c.potential);
+      if (totalPotential <= 0) continue;
+
+      var totalHealAvailable = Math.Min(totalPotential, maxHp - currentHp);
+      if (totalHealAvailable <= 0) continue;
+
+      var potentials = contribs.Select(c => c.potential).ToList();
+      var allocations =
+        allocateProportionalInteger(totalHealAvailable, potentials);
+
+      // safety clamp: never allocate more than a station's potential
+      for (int i = 0; i < allocations.Count; i++)
+        if (allocations[i] > potentials[i])
+          allocations[i] = potentials[i];
+
+      // if clamping reduced the total, try to redistribute remaining amount
+      var allocatedSum = allocations.Sum();
+      if (allocatedSum < totalHealAvailable) {
+        var remaining = totalHealAvailable - allocatedSum;
+        for (var i = 0; i < allocations.Count && remaining > 0; i++) {
+          var headroom = potentials[i] - allocations[i];
+          if (headroom <= 0) continue;
+          var give = Math.Min(headroom, remaining);
+          allocations[i] += give;
+          remaining      -= give;
+        }
+
+        allocatedSum = allocations.Sum();
+      }
+
+      // apply heal to player
+      var actualAllocated = Math.Min(allocatedSum, maxHp - currentHp);
+      if (actualAllocated <= 0) continue;
+
+      var newHealth = Math.Min(currentHp + actualAllocated, maxHp);
+      player.SetHealth(newHealth);
+
+      // update station HealthGiven
+      for (var i = 0; i < allocations.Count; i++) {
+        var info                            = contribs[i].info;
+        var allocated                       = allocations[i];
+        if (allocated > 0) info.HealthGiven += allocated;
+      }
+
+      // emit a single pickup sound if any heal applied
+      player.EmitSound("HealthShot.Pickup", null, 0.1f);
+    }
+  }
+
+  /// <summary>
+  /// Proportionally distribute an integer total across integer potentials.
+  /// Uses floor of shares and assigns leftover to largest fractional remainders.
+  /// Returns a list of allocations with same length as potentials.
+  /// </summary>
+  private List<int>
+    allocateProportionalInteger(int total, List<int> potentials) {
+    var allocations    = new List<int>(new int[potentials.Count]);
+    var remainders     = new List<(int idx, double rem)>();
+    var sumBase        = 0;
+    var totalPotential = potentials.Sum();
+
+    if (totalPotential <= 0) return allocations;
+
+    for (var i = 0; i < potentials.Count; i++) {
+      var potential = potentials[i];
+      var share     = (double)potential / totalPotential * total;
+      var baseAlloc = (int)Math.Floor(share);
+      var rem       = share - baseAlloc;
+      allocations[i] =  baseAlloc;
+      sumBase        += baseAlloc;
+      remainders.Add((i, rem));
+    }
+
+    var leftover = total - sumBase;
+    if (leftover <= 0) return allocations;
+
+    remainders = remainders.OrderByDescending(r => r.rem).ToList();
+    var idx = 0;
+    while (leftover > 0 && idx < remainders.Count) {
+      allocations[remainders[idx].idx] += 1;
+      leftover--;
+      idx++;
+    }
+
+    return allocations;
   }
 }

TTT/CS2/Items/Tripwire/TripwireMovementListener.cs

@@ -101,8 +101,8 @@ public class TripwireMovementListener(IServiceProvider provider)
     instance.TripwireProp.EmitSound("Flashbang.ExplodeDistant");
 
     foreach (var player in Finder.GetOnline()) {
-      if (dealTripwireDamage(instance, player, out var gamePlayer)) continue;
-      gamePlayer?.EmitSound("Player.BurnDamage");
+      if (!dealTripwireDamage(instance, player, out var gamePlayer)) continue;
+      gamePlayer.EmitSound("Player.BurnDamage");
     }
   }
 

TTT/CS2/Listeners/WardenTagAssigner.cs

@@ -4,8 +4,10 @@ using CounterStrikeSharp.API.Modules.Utils;
 using JetBrains.Annotations;
 using Microsoft.Extensions.DependencyInjection;
 using TTT.API.Events;
+using TTT.API.Game;
 using TTT.API.Player;
 using TTT.CS2.ThirdParties.eGO;
+using TTT.Game.Events.Game;
 using TTT.Game.Events.Player;
 using TTT.Game.Listeners;
 using TTT.Game.Roles;
@@ -24,31 +26,41 @@ public class WardenTagAssigner(IServiceProvider provider)
   public void OnRoleAssign(PlayerRoleAssignEvent ev) {
     var maul = EgoApi.MAUL.Get();
     if (maul == null) return;
-    Server.NextWorldUpdate(() => {
-      var gamePlayer = converter.GetPlayer(ev.Player);
-      if (gamePlayer == null) return;
+    if (ev.Role is not DetectiveRole) return;
+    var gamePlayer = converter.GetPlayer(ev.Player);
+    if (gamePlayer == null) return;
 
-      Task.Run(async () => {
-        if (ev.Role is DetectiveRole) {
-          var oldTag = await maul.getTagService().GetTag(gamePlayer.SteamID);
-          var oldTagColor =
-            await maul.getTagService().GetTagColor(gamePlayer.SteamID);
-          oldTags[ev.Player.Id] = (oldTag, oldTagColor);
-        }
+    Task.Run(async () => {
+      var oldTag = await maul.getTagService().GetTag(gamePlayer.SteamID);
+      var oldTagColor =
+        await maul.getTagService().GetTagColor(gamePlayer.SteamID);
+      if (oldTag != "[DETECTIVE]")
+        oldTags[ev.Player.Id] = (oldTag, oldTagColor);
 
-        await Server.NextWorldUpdateAsync(() => {
-          if (ev.Role is DetectiveRole) {
-            maul.getTagService().SetTag(gamePlayer, "[DETECTIVE]", false);
-            maul.getTagService()
-             .SetTagColor(gamePlayer, ChatColors.DarkBlue, false);
-          } else if (oldTags.TryGetValue(ev.Player.Id, out var oldTag)) {
-            maul.getTagService().SetTag(gamePlayer, oldTag.Item1, false);
-            maul.getTagService().SetTagColor(gamePlayer, oldTag.Item2, false);
-
-            oldTags.Remove(ev.Player.Id);
-          }
-        });
+      await Server.NextWorldUpdateAsync(() => {
+        maul.getTagService().SetTag(gamePlayer, "[DETECTIVE]", false);
+        maul.getTagService()
+         .SetTagColor(gamePlayer, ChatColors.DarkBlue, false);
       });
     });
   }
+
+  [UsedImplicitly]
+  [EventHandler]
+  public void OnGameEnd(GameStateUpdateEvent ev) {
+    if (ev.NewState != State.FINISHED) return;
+    var maul = EgoApi.MAUL.Get();
+    if (maul == null) return;
+
+    foreach (var (playerId, (oldTag, oldTagColor)) in oldTags) {
+      var apiPlayer = Finder.GetPlayerById(playerId);
+      if (apiPlayer == null) continue;
+      var csPlayer = converter.GetPlayer(apiPlayer);
+      if (csPlayer == null || !csPlayer.IsValid) continue;
+      maul.getTagService().SetTag(csPlayer, oldTag, false);
+      maul.getTagService().SetTagColor(csPlayer, oldTagColor, false);
+    }
+
+    oldTags.Clear();
+  }
 }

TTT/Shop/Shop.csproj

@@ -7,12 +7,6 @@
     <RootNamespace>TTT.Shop</RootNamespace>
   </PropertyGroup>
 
-  <ItemGroup>
-    <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions">
-      <HintPath>..\..\..\..\..\..\.nuget\packages\microsoft.extensions.dependencyinjection.abstractions\8.0.0\lib\net8.0\Microsoft.Extensions.DependencyInjection.Abstractions.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-
   <ItemGroup>
     <ProjectReference Include="..\API\API.csproj"/>
     <ProjectReference Include="..\Game\Game.csproj"/>

TTT/SpecialRound/Events/SpecialRoundEvent.cs

@@ -0,0 +1,8 @@
+using SpecialRoundAPI;
+using TTT.API.Events;
+
+namespace SpecialRound.Events;
+
+public abstract class SpecialRoundEvent(AbstractSpecialRound round) : Event {
+  public AbstractSpecialRound Round { get; } = round;
+}

TTT/SpecialRound/Events/SpecialRoundStartEvent.cs

@@ -0,0 +1,6 @@
+using SpecialRoundAPI;
+
+namespace SpecialRound.Events;
+
+public class SpecialRoundStartEvent(AbstractSpecialRound round)
+  : SpecialRoundEvent(round) { }

TTT/SpecialRound/SpecialRound.csproj

@@ -7,7 +7,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\SpecialRoundAPI\SpecialRoundAPI\SpecialRoundAPI.csproj"/>
     <ProjectReference Include="..\API\API.csproj"/>
     <ProjectReference Include="..\CS2\CS2.csproj"/>
     <ProjectReference Include="..\Game\Game.csproj"/>

TTT/SpecialRound/SpecialRoundCollection.cs

@@ -9,6 +9,7 @@ public static class SpecialRoundCollection {
   public static void AddSpecialRounds(this IServiceCollection services) {
     services.AddModBehavior<ISpecialRoundStarter, SpecialRoundStarter>();
     services.AddModBehavior<ISpecialRoundTracker, SpecialRoundTracker>();
+    services.AddModBehavior<SpecialRoundSoundNotifier>();
 
     services.AddModBehavior<SpeedRound>();
     services.AddModBehavior<BhopRound>();

TTT/SpecialRound/SpecialRoundSoundNotifier.cs

@@ -0,0 +1,17 @@
+using CounterStrikeSharp.API;
+using JetBrains.Annotations;
+using SpecialRound.Events;
+using TTT.API.Events;
+using TTT.Game.Listeners;
+
+namespace SpecialRound;
+
+public class SpecialRoundSoundNotifier(IServiceProvider provider)
+  : BaseListener(provider) {
+  [UsedImplicitly]
+  [EventHandler]
+  public void OnSpecialRoundStart(SpecialRoundStartEvent ev) {
+    foreach (var player in Utilities.GetPlayers())
+      player.EmitSound("UI.XP.Star.Spend", null, 0.8f);
+  }
+}

TTT/SpecialRound/SpecialRoundStarter.cs

@@ -1,6 +1,7 @@
 using CounterStrikeSharp.API.Core;
 using JetBrains.Annotations;
 using Microsoft.Extensions.DependencyInjection;
+using SpecialRound.Events;
 using SpecialRound.lang;
 using SpecialRoundAPI;
 using TTT.API;
@@ -32,10 +33,14 @@ public class SpecialRoundStarter(IServiceProvider provider)
   public AbstractSpecialRound?
     TryStartSpecialRound(AbstractSpecialRound? round) {
     round ??= getSpecialRound();
+
+    var roundStart = new SpecialRoundStartEvent(round);
+    Bus.Dispatch(roundStart);
+
     Messenger.MessageAll(Locale[RoundMsgs.SPECIAL_ROUND_STARTED(round)]);
     Messenger.MessageAll(Locale[round.Description]);
 
-    round?.ApplyRoundEffects();
+    round.ApplyRoundEffects();
     tracker.CurrentRound           = round;
     tracker.RoundsSinceLastSpecial = 0;
     return round;