Elf Master Tree Finishup

src/GameLogic/AttackableExtensions.cs

@@ -91,7 +91,7 @@ public static async ValueTask<HitInfo> CalculateDamageAsync(this IAttacker attac
         else
         {
             var defenseAttribute = defender.GetDefenseAttribute(attacker);
-            defense = (int)(defender.Attributes[defenseAttribute] * defender.Attributes[Stats.DefenseDecrement]);
+            defense = (int)((defender.Attributes[defenseAttribute] + defender.Attributes[Stats.GreaterDefenseBonus]) * defender.Attributes[Stats.DefenseDecrement]);
             if (defense < 0)
             {
                 defense = 0;
@@ -378,7 +378,7 @@ public static async ValueTask ApplyRegenerationAsync(this IAttackable target, Pl
             if (regeneration != null)
             {
                 var regenerationValue = player.Attributes.CreateElement(powerUpDefinition);
-                var value = skillEntry.Level == 0 ? regenerationValue.Value : regenerationValue.Value + skillEntry.CalculateValue();
+                var value = regenerationValue.Value + (skillEntry.Level == 0 ? 0 : regenerationValue.Value * skillEntry.CalculateValue() / 100);
                 target.Attributes[regeneration.CurrentAttribute] = Math.Min(
                     target.Attributes[regeneration.CurrentAttribute] + value,
                     target.Attributes[regeneration.MaximumAttribute]);

src/GameLogic/Attributes/MonsterAttributeHolder.cs

@@ -17,8 +17,8 @@ public class MonsterAttributeHolder : IAttributeSystem
         new Dictionary<AttributeDefinition, Func<AttackableNpcBase, float>>
         {
             { Stats.CurrentHealth, m => m.Health },
-            { Stats.DefensePvm, m => m.Attributes.GetValueOfAttribute(Stats.DefenseBase) + ((m as Monster)?.SummonedBy?.Attributes?[Stats.SummonedMonsterDefenseIncrease] ?? 0) },
-            { Stats.DefensePvp, m => m.Attributes.GetValueOfAttribute(Stats.DefenseBase) + ((m as Monster)?.SummonedBy?.Attributes?[Stats.SummonedMonsterDefenseIncrease] ?? 0) },
+            { Stats.DefensePvm, m => m.Attributes.GetValueOfAttribute(Stats.DefenseBase) * (1 + ((m as Monster)?.SummonedBy?.Attributes?[Stats.SummonedMonsterDefenseIncrease] ?? 0)) },
+            { Stats.DefensePvp, m => m.Attributes.GetValueOfAttribute(Stats.DefenseBase) * (1 + ((m as Monster)?.SummonedBy?.Attributes?[Stats.SummonedMonsterDefenseIncrease] ?? 0)) },
             { Stats.DamageReceiveDecrement, m => 1.0f },
             { Stats.AttackDamageIncrease, m => 1.0f },
             { Stats.MovementSpeedFactor, m => 1.0f },

src/GameLogic/Attributes/Stats.cs

@@ -1,4 +1,4 @@
-// <copyright file="Stats.cs" company="MUnique">
+// <copyright file="Stats.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -524,6 +524,12 @@ public class Stats
     /// </summary>
     public static AttributeDefinition CrossBowMasteryBonusDamage { get; } = new(new Guid("B3AF7F51-6D6B-42FB-B8FF-689D03890F3E"), "Cross Bow Mastery PvP Bonus Damage (MST)", string.Empty);
 
+    /// <summary>
+    /// Gets the extra projectiles attribute definition.
+    /// </summary>
+    /// <remarks>Can be increased by equipping certain (cross)bows and/or unlocking triple shot mastery.</remarks>
+    public static AttributeDefinition ExtraProjectiles { get; } = new(new Guid("B9E4F3C2-A1D5-4B8E-7F2C-6D3A9E1F5C8B"), "Extra Projectiles", "The number of extra projectiles shot with triple shot skill.");
+
     /// <summary>
     /// Gets elf's melee attack mode attribute definition.
     /// </summary>
@@ -554,6 +560,11 @@ public class Stats
     /// </summary>
     public static AttributeDefinition ArcheryMaxDmg { get; } = new(new Guid("EC807B7C-4004-4D13-BED2-326E13F8EFEB"), "Archery Maximum Damage", "The elf's maximum archery damage, which is added to projectile weapon attacks.");
 
+    /// <summary>
+    /// Gets the elf's greater defense buff bonus defense attribute definition.
+    /// </summary>
+    public static AttributeDefinition GreaterDefenseBonus { get; } = new(new Guid("5A7C3E9B-D1F4-4B82-8A6D-2F3E1C9B7A4D"), "Greater Defense Bonus", string.Empty);
+
     /// <summary>
     /// Gets the elf's greater damage buff bonus damage attribute definition.
     /// </summary>
@@ -729,7 +740,7 @@ public class Stats
     public static AttributeDefinition SummonedMonsterHealthIncrease { get; } = new(new Guid("7B0625C8-DA1A-4A5D-BCA5-26AACDA0BDC6"), "Summoned Monster Health Increase %", string.Empty);
 
     /// <summary>
-    /// Gets the summoned monster defense increase, absolute.
+    /// Gets the summoned monster defense increase, percentage.
     /// </summary>
     public static AttributeDefinition SummonedMonsterDefenseIncrease { get; } = new(new Guid("0D55CFCA-751F-4E66-B327-635576A9A0B3"), "Summoned Monster Defense Increase", string.Empty);
 
@@ -775,7 +786,7 @@ public class Stats
     /// <see cref="AggregateType.Multiplicate"/> values include:
     ///     <see cref="DefenseIncreaseWithEquippedShield"/>.
     /// <see cref="AggregateType.AddFinal"/> values include:
-    ///     Greater defense buff; MST bonus defense with shield (shield strengthener); MST dark horse strengthener; Jack O'Lantern Cry bonus (halved); Berserker defense reduction.
+    ///     MST bonus defense with shield (shield strengthener); MST dark horse strengthener; Jack O'Lantern Cry bonus (halved); Berserker defense reduction.
     /// </remarks>
     public static AttributeDefinition DefenseFinal { get; } = new(new Guid("0888AD48-0CC8-47CA-B6A3-99F3771AA5FC"), "Final Defense", string.Empty);
 

src/GameLogic/Player.cs

@@ -1,4 +1,4 @@
-// <copyright file="Player.cs" company="MUnique">
+// <copyright file="Player.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -1606,36 +1606,33 @@ void AddSkillPowersToResult(ICollection<PowerUpDefinition> powerUps, ref (Attrib
             var durationExtended = false;
             foreach (var powerUpDef in powerUps)
             {
-                IElement powerUp;
+                IElement powerUp = this.Attributes!.CreateElement(powerUpDef);
                 if (skillEntry.Level > 0)
                 {
-                    powerUp = this.Attributes!.CreateElement(powerUpDef);
-
                     foreach (var masterSkillEntry in GetMasterSkillEntries(skillEntry))
                     {
                         var extendsDuration = masterSkillEntry.Skill?.MasterDefinition?.ExtendsDuration ?? false;
                         if (extendsDuration && !durationExtended)
                         {
-                            durationElement = new CombinedElement(durationElement, new ConstantElement(masterSkillEntry.CalculateValue()));
-                        }
-                        else if (extendsDuration)
-                        {
-                            continue;
+                            var value = masterSkillEntry.CalculateValue();
+                            if (value < 1)
+                            {
+                                value *= 100;
+                            }
+
+                            durationElement = new CombinedElement(durationElement, new ConstantElement(value));
+                            durationElementPvp = new CombinedElement(durationElementPvp, new ConstantElement(value));
                         }
-                        else
+
+                        if (masterSkillEntry.Skill?.MasterDefinition?.TargetAttribute is not null)
                         {
-                            // Apply either for all, or just for the specified TargetAttribute of the master skill
                             powerUp = AppedMasterSkillPowerUp(masterSkillEntry, powerUpDef, powerUp);
                         }
                     }
 
                     // After the first iteration all possible duration extensions have been applied
                     durationExtended = true;
                 }
-                else
-                {
-                    powerUp = this.Attributes!.CreateElement(powerUpDef);
-                }
 
                 result[i] = (powerUpDef.TargetAttribute!, powerUp);
                 i++;
@@ -1654,15 +1651,12 @@ IEnumerable<SkillEntry> GetMasterSkillEntries(SkillEntry masterSkillEntry)
 
         IElement AppedMasterSkillPowerUp(SkillEntry masterSkillEntry, PowerUpDefinition powerUpDef, IElement powerUp)
         {
-            if (masterSkillEntry.Skill?.MasterDefinition is not { } masterSkillDefinition)
-            {
-                return powerUp;
-            }
+            var masterSkillDefinition = masterSkillEntry.Skill!.MasterDefinition!;
 
-            if (masterSkillDefinition.TargetAttribute is { } masterSkillTargetAttribute
-                && masterSkillTargetAttribute == powerUpDef.TargetAttribute)
+            if (masterSkillDefinition.TargetAttribute == powerUpDef.TargetAttribute
+                && masterSkillDefinition.Aggregation == powerUp.AggregateType)
             {
-                var additionalValue = new SimpleElement(masterSkillEntry.CalculateValue(), masterSkillEntry.Skill.MasterDefinition?.Aggregation ?? powerUp.AggregateType);
+                var additionalValue = new SimpleElement(masterSkillEntry.CalculateValue(), masterSkillDefinition.Aggregation);
                 powerUp = new CombinedElement(powerUp, additionalValue);
             }
 
@@ -1730,7 +1724,6 @@ public async ValueTask CreateSummonedMonsterAsync(MonsterDefinition definition)
         area.MaximumHealthOverride = (int)monster.Attributes[Stats.MaximumHealth];
         area.MaximumHealthOverride += (int)(monster.Attributes[Stats.MaximumHealth] * this.Attributes?[Stats.SummonedMonsterHealthIncrease] ?? 0);
 
-        // todo: Stats.SummonedMonsterDefenseIncrease
         this.Summon = (monster, intelligence);
         monster.Initialize();
         await gameMap.AddAsync(monster).ConfigureAwait(false);

src/GameLogic/PlayerActions/Skills/AreaSkillAttackAction.cs

@@ -1,4 +1,4 @@
-// <copyright file="AreaSkillAttackAction.cs" company="MUnique">
+// <copyright file="AreaSkillAttackAction.cs" company="MUnique">
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 // </copyright>
 
@@ -134,6 +134,7 @@ private static IEnumerable<IAttackable> GetTargetsInRange(Player player, Point t
                     .GetAttackablesInRange(targetAreaCenter, range)
                     .Where(a => a != player)
                     .Where(a => !a.IsAtSafezone())
+                    .Where(a => a.IsActive())
             ?? [];
 
         if (skill.AreaSkillSettings is { UseFrustumFilter: true } areaSkillSettings)
@@ -237,18 +238,22 @@ private async ValueTask PerformAutomaticHitsAsync(Player player, ushort extraTar
         var minAttacks = areaSkillSettings.MinimumNumberOfHitsPerAttack == 0 ? maxAttacks : areaSkillSettings.MinimumNumberOfHitsPerAttack;
         var currentDelay = TimeSpan.Zero;
 
-        // Order targets by distance to process nearest targets first
         var orderedTargets = targets.ToList();
         FrustumBasedTargetFilter? filter = null;
+        var extraProjectiles = 0;
         var projectileCount = 1;
         var attackRounds = areaSkillSettings.MaximumNumberOfHitsPerTarget;
 
         if (areaSkillSettings is { UseFrustumFilter: true, ProjectileCount: > 1 })
         {
+            // Order targets by distance to process nearest targets first
             orderedTargets.Sort((a, b) => player.GetDistanceTo(a).CompareTo(player.GetDistanceTo(b)));
             filter = FrustumFilters.GetOrAdd(areaSkillSettings, static s => new FrustumBasedTargetFilter(s.FrustumStartWidth, s.FrustumEndWidth, s.FrustumDistance, s.ProjectileCount));
-            projectileCount = areaSkillSettings.ProjectileCount;
+            extraProjectiles += (int)player.Attributes![Stats.ExtraProjectiles];
+            projectileCount = areaSkillSettings.ProjectileCount + extraProjectiles;
             attackRounds = 1; // One attack round per projectile
+            maxAttacks = projectileCount;
+            minAttacks = projectileCount;
 
             extraTarget = orderedTargets.FirstOrDefault(t => t.Id == extraTargetId);
             if (extraTarget is not null)
@@ -294,7 +299,7 @@ private async ValueTask PerformAutomaticHitsAsync(Player player, ushort extraTar
                     }
 
                     // For multiple projectiles, check if this specific projectile can hit the target
-                    if (filter != null && !filter.IsTargetWithinBounds(player, target, rotation, projectileIndex))
+                    if (filter != null && !filter.IsTargetWithinBounds(player, target, rotation, projectileIndex, extraProjectiles))
                     {
                         continue; // This projectile cannot hit this target
                     }
@@ -343,6 +348,11 @@ private async ValueTask PerformAutomaticHitsAsync(Player player, ushort extraTar
                             }
                         });
                     }
+
+                    if (filter != null)
+                    {
+                        break;  // This projectile has hit, so we move on to the next projectile
+                    }
                 }
 
                 currentDelay += areaSkillSettings.DelayBetweenHits;

src/GameLogic/PlayerActions/Skills/FrustumBasedTargetFilter.cs

@@ -78,16 +78,18 @@ public bool IsTargetWithinBounds(ILocateable attacker, ILocateable target, byte
     /// <param name="target">The target.</param>
     /// <param name="rotation">The rotation.</param>
     /// <param name="projectileIndex">The zero-based index of the projectile (0 to ProjectileCount-1).</param>
+    /// <param name="extraProjectiles">The number of extra projectiles, if any.</param>
     /// <returns><c>true</c> if the target is within hit bounds for the specified projectile; otherwise, <c>false</c>.</returns>
-    public bool IsTargetWithinBounds(ILocateable attacker, ILocateable target, byte rotation, int projectileIndex)
+    public bool IsTargetWithinBounds(ILocateable attacker, ILocateable target, byte rotation, int projectileIndex, int extraProjectiles = 0)
     {
         if (this.ProjectileCount <= 1)
         {
             // For single projectile, use the simple frustum check
             return this.IsTargetWithinBounds(attacker, target, rotation);
         }
 
-        if (projectileIndex < 0 || projectileIndex >= this.ProjectileCount)
+        var totalProjectiles = this.ProjectileCount + extraProjectiles;
+        if (projectileIndex < 0 || projectileIndex >= totalProjectiles)
         {
             return false;
         }
@@ -103,19 +105,19 @@ public bool IsTargetWithinBounds(ILocateable attacker, ILocateable target, byte
 
         // Divide the frustum into sections (-1 to 1 range)
         // For 3 projectiles: left (-1 to -0.33), center (-0.33 to 0.33), right (0.33 to 1)
-        var sectionWidth = 2.0 / this.ProjectileCount;
+        var sectionWidth = 2.0 / totalProjectiles;
         var sectionStart = -1.0 + (projectileIndex * sectionWidth);
         var sectionEnd = sectionStart + sectionWidth;
 
         // Add overlap so targets near boundaries can be hit by adjacent projectiles
-        var overlap = this.GetOverlap(attacker.Position, target.Position);
+        var overlap = this.GetOverlap(attacker.Position, target.Position, extraProjectiles);
         sectionStart -= overlap;
         sectionEnd += overlap;
 
         return relativePosition >= sectionStart && relativePosition <= sectionEnd;
     }
 
-    private double GetOverlap(Point attackerPos, Point targetPos)
+    private double GetOverlap(Point attackerPos, Point targetPos, int extraProjectiles = 0)
     {
         var distance = attackerPos.EuclideanDistanceTo(targetPos);
         if (distance == 0)
@@ -124,7 +126,7 @@ private double GetOverlap(Point attackerPos, Point targetPos)
         }
 
         // The overlap decreases over higher distance
-        var overlap = (1.0 / Math.Floor(distance)) / this.ProjectileCount;
+        var overlap = (1.0 / Math.Floor(distance)) / (this.ProjectileCount + extraProjectiles);
         overlap += 0.001; // Adding a small epsilon to make it slightly more tolerant in the comparisons
         return overlap;
     }

src/GameLogic/PlayerActions/Skills/SoulBarrierStrengSkillAction.cs

@@ -86,6 +86,8 @@ public override async ValueTask PerformSkillAsync(Player player, IAttackable tar
                     new ConstantElement(strengSkillLevel!.Level * 0.001f), // extra 0.1% per streng skill level
                     InputOperator.Multiply))
             ];
+
+            skillEntry.PowerUpsPvp = skillEntry.PowerUps;
         }
 
         await AttackableExtensions.ApplyMagicEffectAsync(target, player, skillEntry).ConfigureAwait(false);

src/GameLogic/SkillList.cs

@@ -19,8 +19,9 @@ public sealed class SkillList : ISkillList, IDisposable
     private const ushort DurabilityReduction1FistMasterSkillId = 578;
     private const short TwistingSlashMasterySkillId = 332;
     private const short RagefulBlowMasterySkillId = 333;
+    private const short TripleShotMasterySkillId = 418;
 
-    private readonly short[] _castedSkillsWithPassiveBoost = [TwistingSlashMasterySkillId, RagefulBlowMasterySkillId];
+    private readonly short[] _castedSkillsWithPassiveBoost = [TwistingSlashMasterySkillId, RagefulBlowMasterySkillId, TripleShotMasterySkillId];
 
     private readonly IDictionary<ushort, SkillEntry> _availableSkills;
 

src/Persistence/Initialization/Skills/GreaterDamageEffectInitializer.cs

@@ -36,11 +36,11 @@ public override void Initialize()
         magicEffect.StopByDeath = true;
         magicEffect.Duration = this.Context.CreateNew<PowerUpDefinitionValue>();
         magicEffect.Duration.ConstantValue.Value = 60; // 60 Seconds
+
+        // The buff gives 3 + (energy / 7) damage
         var powerUpDefinition = this.Context.CreateNew<PowerUpDefinition>();
         magicEffect.PowerUpDefinitions.Add(powerUpDefinition);
         powerUpDefinition.TargetAttribute = Stats.GreaterDamageBonus.GetPersistent(this.GameConfiguration);
-
-        // The buff gives 3 + (energy / 7) damage
         powerUpDefinition.Boost = this.Context.CreateNew<PowerUpDefinitionValue>();
         powerUpDefinition.Boost.ConstantValue.Value = 3f;
         powerUpDefinition.Boost.ConstantValue.AggregateType = AggregateType.AddRaw;
@@ -50,5 +50,13 @@ public override void Initialize()
         boostPerEnergy.InputOperator = InputOperator.Multiply;
         boostPerEnergy.InputOperand = 1f / 7f; // one damage per 7 energy
         powerUpDefinition.Boost.RelatedValues.Add(boostPerEnergy);
+
+        // Placeholder for AttackIncreaseStr and AttackIncreaseMastery master skills
+        var powerUpDefinition2 = this.Context.CreateNew<PowerUpDefinition>();
+        magicEffect.PowerUpDefinitions.Add(powerUpDefinition2);
+        powerUpDefinition2.TargetAttribute = Stats.GreaterDamageBonus.GetPersistent(this.GameConfiguration);
+        powerUpDefinition2.Boost = this.Context.CreateNew<PowerUpDefinitionValue>();
+        powerUpDefinition2.Boost.ConstantValue.Value = 1f;
+        powerUpDefinition2.Boost.ConstantValue.AggregateType = AggregateType.Multiplicate;
     }
 }