v1.2.3.b2 - Part 2

## GENERAL
- Added a css_entity admin command to check whether an entity with a given index/handle exists (prints the designer name to chat or console).
- Added a TakeDamage post-hook (OnTakeDamagePost) alongside the existing pre-hook, so skills can now react after damage has actually been applied, not just before.
- Added CreateMolotovProjectile (new CMolotovProjectile_CreateFunc signature) and CreateTrackedChicken entity helpers.
- Added a weapon_mp7 → weapon_mp5sd fallback mapping.
- Added class for KillfeedIcons

## SKILL IMPROVEMENTS
- Aimbot:
  -- Only forces a headshot hitgroup once (skips if it's already a head or an invalid hitgroup), and now restores the original hitgroup value in the new post-damage hook instead of leaving it overwritten.
- Tripwire:
  -- Reduced the default wire width from 1.5 to 0.7.

## NEW SKILLS:
- Berserker: You deal more damage and move faster as your health gets lower.
- Blast Shot: Press Attack2 with the MP5 to fire an HE grenade.
- Demon Eye: You deal damage to every enemy you are looking at.
- Fire Rain: Throw a decoy to call down a rain of Molotovs.
- Flashlight: Click [css_useSkill] to turn the flashlight on or off; its light can blind enemies.
- Healing Chicken: Your chickens heal you while you are nearby.
- Jetkick: Select a player to jetkick - every shot they fire knocks them backwards until disabled.
- Last Gasp: After you die, you deal damage to the enemy who killed you.
- Take Ammo: Click [css_useSkill] to take the active weapon's magazine from a random enemy.
- Team Teleport: Press [css_useSkill] to teleport to the teammate you're looking at.

jRandomSkills - SRC Files/src/player/skills/Berserker.cs

@@ -0,0 +1,123 @@
+using CounterStrikeSharp.API;
+using CounterStrikeSharp.API.Core;
+using CounterStrikeSharp.API.Modules.Memory.DynamicFunctions;
+using CounterStrikeSharp.API.Modules.Utils;
+using src.utils;
+using System.Collections.Concurrent;
+using static src.jRandomSkills;
+
+namespace src.player.skills
+{
+    public class Berserker : ISkill
+    {
+        private const Skills skillName = Skills.Berserker;
+        public static readonly ConcurrentDictionary<uint, int> jumpedPlayers = [];
+
+        public static void LoadSkill()
+        {
+            SkillUtils.RegisterSkill(skillName, SkillsInfo.GetValue<string>(skillName, "color"), false);
+        }
+
+        public static void NewRound()
+        {
+            jumpedPlayers.Clear();
+        }
+
+        private static float CalculateNewVelocity(CCSPlayerPawn pawn, float maxValue)
+        {
+            if (pawn!.Health <= 0) return 1f;
+
+            float healthPercentage = pawn.MaxHealth > 0
+                ? Math.Clamp((float)pawn.Health / pawn.MaxHealth, 0f, 1f)
+                : 0f;
+
+            float newValue = 1f + (maxValue - 1f) * (1f - healthPercentage);
+            return Math.Max(1, Math.Min(maxValue, newValue));
+        }
+
+        public static void OnTakeDamage(DynamicHook h)
+        {
+            CEntityInstance param = h.GetParam<CEntityInstance>(0);
+            CTakeDamageInfo param2 = h.GetParam<CTakeDamageInfo>(1);
+
+            if (param == null || param.Entity == null || param2 == null || param2.Attacker == null || param2.Attacker.Value == null)
+                return;
+
+            CCSPlayerPawn attackerPawn = new(param2.Attacker.Value.Handle);
+            CCSPlayerPawn victimPawn = new(param.Handle);
+
+            if (attackerPawn.DesignerName != "player" || victimPawn.DesignerName != "player")
+                return;
+
+            if (attackerPawn == null || attackerPawn.Controller?.Value == null || victimPawn == null || victimPawn.Controller?.Value == null)
+                return;
+
+            CCSPlayerController attacker = PlayerManager.GetPlayerEvent(attackerPawn.Controller.Value.As<CCSPlayerController>())!;
+
+            var playerInfo = PlayerManager.GetPlayerByIndex(attacker!.Index);
+            if (playerInfo == null) return;
+
+            if (playerInfo.Skill == skillName)
+            {
+                float damageMultiplier = CalculateNewVelocity(attackerPawn, SkillsInfo.GetValue<float>(skillName, "maxDamageVelocity"));
+                param2.Damage *= damageMultiplier;
+            }
+        }
+
+        public static void PlayerJump(EventPlayerJump @event)
+        {
+            var player = PlayerManager.GetPlayerEvent(@event.Userid);
+            if (player == null || !player.IsValid) return;
+            if (!jumpedPlayers.TryGetValue(player.Index, out _)) return;
+            jumpedPlayers.AddOrUpdate(player.Index, Server.TickCount + 20, (k, v) => Server.TickCount + 20);
+        }
+
+        public static void EnableSkill(CCSPlayerController player)
+        {
+            var playerPawn = player.PlayerPawn.Value;
+            var playerInfo = PlayerManager.GetPlayerByIndex(player!.Index);
+            if (playerPawn == null || playerInfo == null) return;
+            jumpedPlayers.TryAdd(player.Index, 0);
+        }
+
+        public static void DisableSkill(CCSPlayerController player)
+        {
+            var playerPawn = player.PlayerPawn.Value;
+            if (playerPawn == null) return;
+            playerPawn.VelocityModifier = 1;
+            jumpedPlayers.TryRemove(player.Index, out _);
+        }
+
+        public static void OnTick()
+        {
+            foreach (var player in PlayerManager.GetTickPlayers())
+            {
+                if (!Instance.IsPlayerValid(player)) continue;
+
+                var playerInfo = PlayerManager.GetPlayerByIndex(player!.Index);
+                if (playerInfo?.Skill != skillName) continue;
+
+                var playerPawn = player.PlayerPawn?.Value;
+                if (playerPawn == null || playerPawn.VelocityModifier == 0) continue;
+
+                var buttons = player.Buttons;
+                float newSpeedVelocity = CalculateNewVelocity(playerPawn, SkillsInfo.GetValue<float>(skillName, "maxSpeedVelocity"));
+
+                if (buttons.HasFlag(PlayerButtons.Moveleft) || buttons.HasFlag(PlayerButtons.Moveright) || buttons.HasFlag(PlayerButtons.Forward) || buttons.HasFlag(PlayerButtons.Back))
+                    playerPawn.VelocityModifier = newSpeedVelocity;
+
+                if (jumpedPlayers.TryGetValue(player.Index, out var time) && time > Server.TickCount)
+                    continue;
+
+                if (!((PlayerFlags)player.Flags).HasFlag(PlayerFlags.FL_ONGROUND))
+                    playerPawn.AbsVelocity.Z = Math.Min(playerPawn.AbsVelocity.Z, 10);
+            }
+        }
+
+        public class SkillConfig(Skills skill = skillName, bool active = true, string color = "#cc2929", CsTeam onlyTeam = CsTeam.None, bool disableOnFreezeTime = false, bool needsTeammates = false, string requiredPermission = "", float? hudDuration = null, float? descriptionHudDuration = null, int maxPerServer = -1, Rarity rarity = Rarity.Common, float maxSpeedVelocity = 2f, float maxDamageVelocity = 2f) : SkillsInfo.DefaultSkillInfo(skill, active, color, onlyTeam, disableOnFreezeTime, needsTeammates, requiredPermission, hudDuration, descriptionHudDuration, maxPerServer, rarity)
+        {
+            public float MaxSpeedVelocity { get; set; } = maxSpeedVelocity;
+            public float MaxDamageVelocity { get; set; } = maxDamageVelocity;
+        }
+    }
+}