feat: Refactor Poison system, implement Darkglow & Parasitic effects (#2385)

## Summary

- Refactors the poison system to separate `Index` (globally unique ID) from `Level` (tier within a family), enabling multiple poison families (Standard, Darkglow, Parasitic) to coexist without collisions
- Implements Darkglow and Parasitic poison special effects from Mondain's Legacy: Darkglow boosts damage by 10% when attacker is ranged, Parasitic heals the attacker for damage dealt in melee range
- Fixes several bugs: `Register()` crashing on duplicate `Level` values across families, `IncreaseLevel()` crossing family boundaries, `InfectiousStrike` and `NinjaWeapons` stripping poison family via level-based lookups, and `ArchCure`/`CleansingWinds` using raw `Level + 1` instead of `IncreaseLevel()`

## Changes

**`Projects/Server/Poison.cs`** — Adds `PoisonFamily` enum and abstract `Family` property. Adds `Index` as unique identifier. Fixes `Register()` to check `Index` uniqueness (not `Level`) and validate the new poison's name (not the existing one's). Fixes `IncreaseLevel()` to use `Index + 1`, naturally respecting family boundaries via Index gaps. Replaces linear name lookup with `Dictionary`-based `PoisonsByName`.

**`Projects/UOContent/Misc/Poison.cs`** — Adds `family` parameter to `PoisonImpl`. Implements Darkglow effect (10% damage boost when `From` >1 tile, cliloc 1072850) and Parasitic effect (heals `From` for damage dealt within 1 tile, cliloc 1060203) in `PoisonTimer.OnTick()`. Renames `m_` fields to `_` convention.

**`Projects/UOContent/Misc/PoisonKinds.cs`** — New file. Moves poison registration out of `PoisonImpl` into `PoisonKinds.Configure()`. Adds `PoisonFamily` to Darkglow/Parasitic registrations. Provides extension properties (`Lesser`, `Deadly`, `LesserDarkglow`, etc.), `GetPoison(int level)` (standard-only), `GetPoisonByFamilyAndLevel()`, and `IsDarkglow`/`IsParasitic` instance helpers.

**`Projects/UOContent/Items/Weapons/Abilities/InfectiousStrike.cs`** — Family-aware poison scaling: Darkglow caps at Deadly (Poisoning/33.3), Parasitic caps at Lethal (Poisoning/25), Standard unchanged. Level bump uses `IncreaseLevel()` with family boundary check.

**`Projects/UOContent/Items/Skill Items/Ninjitsu/NinjaWeapons.cs`** — EvilOmen level bump uses `Poison.IncreaseLevel()` instead of `Poison.GetPoison(Level + 1)`.

**`Projects/UOContent/Spells/Fourth/ArchCure.cs`** and **`CleansingWindsSpell.cs`** — Replace `poison.Level + 1` with `Poison.IncreaseLevel(poison).Level` for family-safe cure chance calculation.

**`Projects/Server/Serialization/SerializationExtensions.cs`** — Serializes/deserializes `Index` instead of `Level`.

**`DarkglowPotion.cs`** / **`ParasiticPotion.cs`** — Point to actual Darkglow/Parasitic poisons instead of placeholder `Greater`.

**`PotionKeg.cs`** / **`BasePotion.cs`** — Adds Darkglow, Parasitic, Invisibility, and FlintsPungentBrew to `PotionEffect` enum and keg label support.

## Test plan

- [ ] `dotnet build` compiles cleanly (verified, 0 warnings 0 errors)
- [ ] Verify `PoisonKinds.Configure()` registers all poisons without throwing (Register bug fix)
- [ ] Standard poison behavior unchanged — PoisonField, PoisonSpell, SerpentArrow, SavageShaman, TrappableContainer all use `GetPoison(int level)` which now correctly filters to Standard family
- [ ] Darkglow: poison tick deals +10% damage when attacker is >1 tile away, sends "Darkglow poison increases your damage!" message
- [ ] Parasitic: poison tick heals attacker for damage dealt when within 1 tile, sends heal message
- [ ] InfectiousStrike preserves poison family and respects family-specific skill scaling
- [ ] EvilOmen + NinjaWeapons level bump stays within poison family
- [ ] ArchCure/CleansingWinds cure chance calculations work correctly across all poison families
- [ ] Serialization round-trips correctly using Index
This commit is contained in:
Kamron Batman 2026-03-21 21:27:22 -07:00 • committed by GitHub
parent 3bb38bcb5b
commit 992bc95164
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
12 changed files with 316 additions and 205 deletions

View file

@ -6,157 +6,156 @@ using Server.Spells;
using Server.Spells.Necromancy;
using Server.Spells.Ninjitsu;
namespace Server
namespace Server;
public class PoisonImpl : Poison
{
public class PoisonImpl : Poison
private readonly int _count;
private readonly TimeSpan _delay;
private readonly TimeSpan _interval;
private readonly int _maximum;
private readonly int _messageInterval;
private readonly int _minimum;
private readonly double _scalar;
public PoisonImpl(
string name, int index, int level, int min, int max, double percent, double delay, double interval, int count,
int messageInterval, PoisonFamily family = PoisonFamily.Standard
) : base(index)
{
private readonly int m_Count;
Name = name;
Level = level;
Family = family;
_minimum = min;
_maximum = max;
_scalar = percent * 0.01;
_delay = TimeSpan.FromSeconds(delay);
_interval = TimeSpan.FromSeconds(interval);
_count = count;
_messageInterval = messageInterval;
}
// Timers
private readonly TimeSpan m_Delay;
private readonly TimeSpan m_Interval;
private readonly int m_Maximum;
private readonly int m_MessageInterval;
public override string Name { get; }
// Info
public override int Level { get; }
// Damage
private readonly int m_Minimum;
private readonly double m_Scalar;
public override PoisonFamily Family { get; }
public PoisonImpl(
string name, int level, int min, int max, double percent, double delay, double interval, int count,
int messageInterval
)
public override Timer ConstructTimer(Mobile m) => new PoisonTimer(m, this);
public class PoisonTimer : Timer
{
private readonly Mobile _mobile;
private readonly PoisonImpl _poison;
private int _index;
private int _lastDamage;
public PoisonTimer(Mobile m, PoisonImpl p) : base(p._delay, p._interval)
{
Name = name;
Level = level;
m_Minimum = min;
m_Maximum = max;
m_Scalar = percent * 0.01;
m_Delay = TimeSpan.FromSeconds(delay);
m_Interval = TimeSpan.FromSeconds(interval);
m_Count = count;
m_MessageInterval = messageInterval;
From = m;
_mobile = m;
_poison = p;
}
public override string Name { get; }
public Mobile From{ get; set; }
public override int Level { get; }
[CallPriority(10)]
public static void Configure()
protected override void OnTick()
{
if (Core.AOS)
if ((Core.AOS && _poison.Level < 4 &&
TransformationSpellHelper.UnderTransformation(_mobile, typeof(VampiricEmbraceSpell)) ||
_poison.Level < 3 && OrangePetals.UnderEffect(_mobile) ||
AnimalForm.UnderTransformation(_mobile, typeof(Unicorn))) && _mobile.CurePoison(_mobile))
{
Register(new PoisonImpl("Lesser", 0, 4, 16, 7.5, 3.0, 2.25, 10, 4));
Register(new PoisonImpl("Regular", 1, 8, 18, 10.0, 3.0, 3.25, 10, 3));
Register(new PoisonImpl("Greater", 2, 12, 20, 15.0, 3.0, 4.25, 10, 2));
Register(new PoisonImpl("Deadly", 3, 16, 30, 30.0, 3.0, 5.25, 15, 2));
Register(new PoisonImpl("Lethal", 4, 20, 50, 35.0, 3.0, 5.25, 20, 2));
}
else
{
Register(new PoisonImpl("Lesser", 0, 4, 26, 2.500, 3.5, 3.0, 10, 2));
Register(new PoisonImpl("Regular", 1, 5, 26, 3.125, 3.5, 3.0, 10, 2));
Register(new PoisonImpl("Greater", 2, 6, 26, 6.250, 3.5, 3.0, 10, 2));
Register(new PoisonImpl("Deadly", 3, 7, 26, 12.500, 3.5, 4.0, 10, 2));
Register(new PoisonImpl("Lethal", 4, 9, 26, 25.000, 3.5, 5.0, 10, 2));
}
}
public static Poison IncreaseLevel(Poison oldPoison)
{
var newPoison = oldPoison == null ? null : GetPoison(oldPoison.Level + 1);
return newPoison ?? oldPoison;
}
public override Timer ConstructTimer(Mobile m) => new PoisonTimer(m, this);
public class PoisonTimer : Timer
{
private readonly Mobile m_Mobile;
private readonly PoisonImpl m_Poison;
private int m_Index;
private int m_LastDamage;
public PoisonTimer(Mobile m, PoisonImpl p) : base(p.m_Delay, p.m_Interval)
{
From = m;
m_Mobile = m;
m_Poison = p;
}
public Mobile From { get; set; }
protected override void OnTick()
{
if (Core.AOS && m_Poison.Level < 4 &&
TransformationSpellHelper.UnderTransformation(m_Mobile, typeof(VampiricEmbraceSpell)) ||
m_Poison.Level < 3 && OrangePetals.UnderEffect(m_Mobile) ||
AnimalForm.UnderTransformation(m_Mobile, typeof(Unicorn)))
if (Core.SA)
{
if (m_Mobile.CurePoison(m_Mobile))
{
// * You feel yourself resisting the effects of the poison *
m_Mobile.LocalOverheadMessage(MessageType.Emote, 0x3F, 1114441);
// * ~1_NAME~ seems resistant to the poison *
m_Mobile.NonlocalOverheadMessage(MessageType.Emote, 0x3F, 1114442, m_Mobile.Name);
Stop();
return;
}
}
if (m_Index++ == m_Poison.m_Count)
{
m_Mobile.SendLocalizedMessage(502136); // The poison seems to have worn off.
m_Mobile.Poison = null;
Stop();
return;
}
int damage;
if (!Core.AOS && m_LastDamage != 0 && Utility.RandomBool())
{
damage = m_LastDamage;
// * You feel yourself resisting the effects of the poison *
_mobile.LocalOverheadMessage(MessageType.Emote, 0x3F, 1114441);
}
else
{
damage = 1 + (int)(m_Mobile.Hits * m_Poison.m_Scalar);
if (damage < m_Poison.m_Minimum)
{
damage = m_Poison.m_Minimum;
}
else if (damage > m_Poison.m_Maximum)
{
damage = m_Poison.m_Maximum;
}
m_LastDamage = damage;
_mobile.LocalOverheadMessage(
MessageType.Emote,
0x3F,
true,
"* You feel yourself resisting the effects of the poison *"
);
}
From?.DoHarmful(m_Mobile, true);
(m_Mobile as IHonorTarget)?.ReceivedHonorContext?.OnTargetPoisoned();
AOS.Damage(m_Mobile, From, damage, 0, 0, 0, 100, 0);
// OSI: randomly revealed between first and third damage tick, guessing 60% chance
if (Utility.RandomDouble() < 0.40)
if (Core.SA)
{
m_Mobile.RevealingAction();
// * ~1_NAME~ seems resistant to the poison *
_mobile.NonlocalOverheadMessage(MessageType.Emote, 0x3F, 1114442, _mobile.Name);
}
else
{
_mobile.LocalOverheadMessage(
MessageType.Emote,
0x3F,
true,
$"* {_mobile.Name} seems resistant to the poison *"
);
}
if (m_Index % m_Poison.m_MessageInterval == 0)
{
m_Mobile.OnPoisoned(From, m_Poison, m_Poison);
}
Stop();
return;
}
if (_index++ == _poison._count)
{
_mobile.SendLocalizedMessage(502136); // The poison seems to have worn off.
_mobile.Poison = null;
Stop();
return;
}
int damage;
if (!Core.AOS && _lastDamage != 0 && Utility.RandomBool())
{
damage = _lastDamage;
}
else
{
damage = 1 + (int)(_mobile.Hits * _poison._scalar);
damage = Math.Clamp(damage, _poison._minimum, _poison._maximum);
_lastDamage = damage;
}
// Darkglow: 10% damage boost when attacker is more than 1 tile away
if (_poison.Family == PoisonFamily.Darkglow && From != null && From.Map == _mobile.Map &&
!From.InRange(_mobile, 1))
{
damage = (int)(damage * 1.1);
// Darkglow poison increases your damage!
From.SendLocalizedMessage(1072850);
}
From?.DoHarmful(_mobile, true);
(_mobile as IHonorTarget)?.ReceivedHonorContext?.OnTargetPoisoned();
AOS.Damage(_mobile, From, damage, 0, 0, 0, 100, 0);
// Parasitic: heals attacker for damage dealt when within 1 tile
if (_poison.Family == PoisonFamily.Parasitic && From != null && From.Map == _mobile.Map &&
From.InRange(_mobile, 1))
{
From.Heal(damage);
// You have had ~1_HEALED_AMOUNT~ hit points healed.
From.SendLocalizedMessage(1060203, damage.ToString());
}
// OSI: randomly revealed between first and third damage tick, guessing 60% chance
if (Utility.RandomDouble() < 0.40)
{
_mobile.RevealingAction();
}
if (_index % _poison._messageInterval == 0)
{
_mobile.OnPoisoned(From, _poison, _poison);
}
}
}

View file

@ -0,0 +1,109 @@
namespace Server;
public static class PoisonKinds
{
private static Poison _lesser;
private static Poison _regular;
private static Poison _greater;
private static Poison _deadly;
private static Poison _lethal;
private static Poison _lesserDarkglow;
private static Poison _regularDarkglow;
private static Poison _greaterDarkglow;
private static Poison _deadlyDarkglow;
private static Poison _lesserParasitic;
private static Poison _regularParasitic;
private static Poison _greaterParasitic;
private static Poison _deadlyParasitic;
private static Poison _lethalParasitic;
extension(Poison poison)
{
public static Poison Lesser => _lesser ??= Poison.GetPoison("Lesser");
public static Poison Regular => _regular ??= Poison.GetPoison("Regular");
public static Poison Greater => _greater ??= Poison.GetPoison("Greater");
public static Poison Deadly => _deadly ??= Poison.GetPoison("Deadly");
public static Poison Lethal => _lethal ??= Poison.GetPoison("Lethal");
public static Poison LesserDarkglow => _lesserDarkglow ??= Poison.GetPoison("LesserDarkglow");
public static Poison RegularDarkglow => _regularDarkglow ??= Poison.GetPoison("RegularDarkglow");
public static Poison GreaterDarkglow => _greaterDarkglow ??= Poison.GetPoison("GreaterDarkglow");
public static Poison DeadlyDarkglow => _deadlyDarkglow ??= Poison.GetPoison("DeadlyDarkglow");
public static Poison LesserParasitic => _lesserParasitic ??= Poison.GetPoison("LesserParasitic");
public static Poison RegularParasitic => _regularParasitic ??= Poison.GetPoison("RegularParasitic");
public static Poison GreaterParasitic => _greaterParasitic ??= Poison.GetPoison("GreaterParasitic");
public static Poison DeadlyParasitic => _deadlyParasitic ??= Poison.GetPoison("DeadlyParasitic");
public static Poison LethalParasitic => _lethalParasitic ??= Poison.GetPoison("LethalParasitic");
public bool IsDarkglow => poison.Family == PoisonFamily.Darkglow;
public bool IsParasitic => poison.Family == PoisonFamily.Parasitic;
public static Poison GetPoison(int level)
{
for (var i = 0; i < Poison.Poisons.Count; ++i)
{
var p = Poison.Poisons[i];
if (p.Family == PoisonFamily.Standard && p.Level == level)
{
return p;
}
}
return null;
}
public static Poison GetPoisonByFamilyAndLevel(PoisonFamily family, int level)
{
for (var i = 0; i < Poison.Poisons.Count; ++i)
{
var p = Poison.Poisons[i];
if (p.Family == family && p.Level == level)
{
return p;
}
}
return null;
}
}
[CallPriority(10)]
public static void Configure()
{
if (Core.AOS)
{
Poison.Register(new PoisonImpl("Lesser", 0, 0, 4, 16, 7.5, 3.0, 2.25, 10, 4));
Poison.Register(new PoisonImpl("Regular", 1, 1, 8, 18, 10.0, 3.0, 3.25, 10, 3));
Poison.Register(new PoisonImpl("Greater", 2, 2, 12, 20, 15.0, 3.0, 4.25, 10, 2));
Poison.Register(new PoisonImpl("Deadly", 3, 3, 16, 30, 30.0, 3.0, 5.25, 15, 2));
Poison.Register(new PoisonImpl("Lethal", 4, 4, 20, 50, 35.0, 3.0, 5.25, 20, 2));
}
else
{
Poison.Register(new PoisonImpl("Lesser", 0, 0, 4, 26, 2.5, 3.5, 3.0, 10, 2));
Poison.Register(new PoisonImpl("Regular", 1, 1, 5, 26, 3.125, 3.5, 3.0, 10, 2));
Poison.Register(new PoisonImpl("Greater", 2, 2, 6, 26, 6.25, 3.5, 3.0, 10, 2));
Poison.Register(new PoisonImpl("Deadly", 3, 3, 7, 26, 12.5, 3.5, 4.0, 10, 2));
Poison.Register(new PoisonImpl("Lethal", 4, 4, 9 , 26, 25.0, 3.5, 5.0, 10, 2));
}
if (Core.ML)
{
Poison.Register(new PoisonImpl("LesserDarkglow", 10, 0, 4, 16, 7.5, 3.0, 2.25, 10, 4, PoisonFamily.Darkglow));
Poison.Register(new PoisonImpl("RegularDarkglow", 11, 1, 8, 18, 10.0, 3.0, 3.25, 10, 3, PoisonFamily.Darkglow));
Poison.Register(new PoisonImpl("GreaterDarkglow", 12, 2, 12, 20, 15.0, 3.0, 4.25, 10, 2, PoisonFamily.Darkglow));
Poison.Register(new PoisonImpl("DeadlyDarkglow", 13, 3, 16, 30, 30.0, 3.0, 5.25, 15, 2, PoisonFamily.Darkglow));
Poison.Register(new PoisonImpl("LesserParasitic", 20, 0, 4, 16, 7.5, 3.0, 2.25, 10, 4, PoisonFamily.Parasitic));
Poison.Register(new PoisonImpl("RegularParasitic", 21, 1, 8, 18, 10.0, 3.0, 3.25, 10, 3, PoisonFamily.Parasitic));
Poison.Register(new PoisonImpl("GreaterParasitic", 22, 2, 12, 20, 15.0, 3.0, 4.25, 10, 2, PoisonFamily.Parasitic));
Poison.Register(new PoisonImpl("DeadlyParasitic", 23, 3, 16, 30, 30.0, 3.0, 5.25, 15, 2, PoisonFamily.Parasitic));
Poison.Register(new PoisonImpl("LethalParasitic", 24, 4, 20, 50, 35.0, 3.0, 5.25, 20, 2, PoisonFamily.Parasitic));
}
}
}