From e27316800a1da4c8784c7ee1276f665da2e4305c Mon Sep 17 00:00:00 2001 From: chillu Date: Thu, 8 Aug 2024 23:23:18 +0200 Subject: [PATCH] feat: multi callback unit and effect units support in recipes --- .../Creation/Generation/ModifierGenerator.cs | 4 +- .../Core/Modifier/Creation/Recipe/EffectOn.cs | 28 ++++- .../Creation/Recipe/ModifierEffectsCreator.cs | 117 ++++++++++++++---- .../Creation/Recipe/ModifierRecipe.cs | 84 ++++++------- .../Creation/Recipe/ModifierRecipeData.cs | 12 +- ModifierExamples.md | 37 +++--- README.md | 34 ++--- 7 files changed, 200 insertions(+), 116 deletions(-) diff --git a/ModiBuff/ModiBuff/Core/Modifier/Creation/Generation/ModifierGenerator.cs b/ModiBuff/ModiBuff/Core/Modifier/Creation/Generation/ModifierGenerator.cs index 2260b16..abaf4c7 100644 --- a/ModiBuff/ModiBuff/Core/Modifier/Creation/Generation/ModifierGenerator.cs +++ b/ModiBuff/ModiBuff/Core/Modifier/Creation/Generation/ModifierGenerator.cs @@ -85,8 +85,8 @@ public ModifierGenerator(in ModifierRecipeData data) _timeComponentCount++; _modifierEffectsCreator = new ModifierEffectsCreator(data.EffectWrappers, data.RemoveEffectWrapper, - data.DispelRegisterWrapper, data.CallbackUnitRegisterWrapper, data.CallbackEffectRegisterWrappers, - data.CallbackEffectUnitsRegisterWrapper); + data.DispelRegisterWrapper, data.CallbackUnitRegisterWrappers, data.CallbackEffectRegisterWrappers, + data.CallbackEffectUnitsRegisterWrappers); if (HasApplyChecks) { diff --git a/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/EffectOn.cs b/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/EffectOn.cs index a083569..1258779 100644 --- a/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/EffectOn.cs +++ b/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/EffectOn.cs @@ -13,9 +13,15 @@ public enum EffectOn CallbackUnit = 16, CallbackEffect = 32, CallbackEffectUnits = 64, - CallbackEffect2 = 128, - CallbackEffect3 = 256, - CallbackEffect4 = 512, + CallbackUnit2 = 128, + CallbackUnit3 = 256, + CallbackUnit4 = 512, + CallbackEffect2 = 1024, + CallbackEffect3 = 2048, + CallbackEffect4 = 4096, + CallbackEffectUnits2 = 8192, + CallbackEffectUnits3 = 16384, + CallbackEffectUnits4 = 32768, } public static class EffectOnExtensions @@ -25,6 +31,14 @@ public static class EffectOnExtensions public static class EffectOnCallbackEffectData { + public static readonly EffectOn[] AllCallbackUnitData = + { + EffectOn.CallbackUnit, + EffectOn.CallbackUnit2, + EffectOn.CallbackUnit3, + EffectOn.CallbackUnit4, + }; + public static readonly EffectOn[] AllCallbackEffectData = { EffectOn.CallbackEffect, @@ -32,5 +46,13 @@ public static class EffectOnCallbackEffectData EffectOn.CallbackEffect3, EffectOn.CallbackEffect4, }; + + public static readonly EffectOn[] AllCallbackEffectUnitsData = + { + EffectOn.CallbackEffectUnits, + EffectOn.CallbackEffectUnits2, + EffectOn.CallbackEffectUnits3, + EffectOn.CallbackEffectUnits4, + }; } } \ No newline at end of file diff --git a/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierEffectsCreator.cs b/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierEffectsCreator.cs index 97cf784..607e2f6 100644 --- a/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierEffectsCreator.cs +++ b/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierEffectsCreator.cs @@ -12,18 +12,18 @@ public sealed class ModifierEffectsCreator private readonly EffectWrapper[] _savableEffectsWrappers; private readonly EffectWrapper _removeEffectWrapper; private readonly EffectWrapper _dispelRegisterWrapper; - private readonly EffectWrapper _callbackUnitRegisterWrapper; + private readonly EffectWrapper[] _callbackUnitRegisterWrappers; private readonly EffectWrapper[] _callbackEffectRegisterWrappers; - private readonly EffectWrapper _callbackEffectUnitsRegisterWrapper; + private readonly EffectWrapper[] _callbackEffectUnitsRegisterWrappers; private IRevertEffect[] _revertEffects; private IEffect[] _initEffects; private IEffect[] _intervalEffects; private IEffect[] _durationEffects; private IStackEffect[] _stackEffects; - private IEffect[] _callbackUnitEffects; + private IEffect[][] _callbackUnitEffects; private IEffect[][] _callbackEffectEffects; - private IEffect[] _callbackEffectUnitsEffects; + private IEffect[][] _callbackEffectUnitsEffects; private int _revertEffectsIndex, _initEffectsIndex, @@ -33,22 +33,28 @@ public sealed class ModifierEffectsCreator _callbackUnitEffectsIndex, _callbackEffectEffectsIndex, _callbackEffectUnitsEffectsIndex, + _callbackUnitEffectsIndex2, + _callbackUnitEffectsIndex3, + _callbackUnitEffectsIndex4, _callbackEffectEffectsIndex2, _callbackEffectEffectsIndex3, - _callbackEffectEffectsIndex4; + _callbackEffectEffectsIndex4, + _callbackEffectUnitsEffectsIndex2, + _callbackEffectUnitsEffectsIndex3, + _callbackEffectUnitsEffectsIndex4; public ModifierEffectsCreator(List effectWrappers, EffectWrapper removeEffectWrapper, - EffectWrapper dispelRegisterWrapper, EffectWrapper callbackUnitRegisterWrapper, - EffectWrapper[] callbackEffectRegisterWrappers, EffectWrapper callbackEffectUnitsRegisterWrapper) + EffectWrapper dispelRegisterWrapper, EffectWrapper[] callbackUnitRegisterWrappers, + EffectWrapper[] callbackEffectRegisterWrappers, EffectWrapper[] callbackEffectUnitsRegisterWrappers) { var effectsWithModifierInfoWrappers = new List(); var savableEffectsWrappers = new List(); _effectWrappers = effectWrappers.ToArray(); _removeEffectWrapper = removeEffectWrapper; _dispelRegisterWrapper = dispelRegisterWrapper; - _callbackUnitRegisterWrapper = callbackUnitRegisterWrapper; + _callbackUnitRegisterWrappers = callbackUnitRegisterWrappers; _callbackEffectRegisterWrappers = callbackEffectRegisterWrappers; - _callbackEffectUnitsRegisterWrapper = callbackEffectUnitsRegisterWrapper; + _callbackEffectUnitsRegisterWrappers = callbackEffectUnitsRegisterWrappers; for (int i = 0; i < _effectWrappers.Length; i++) { @@ -76,12 +82,24 @@ public ModifierEffectsCreator(List effectWrappers, EffectWrapper _callbackEffectEffectsIndex++; if ((effectWrapper.EffectOn & EffectOn.CallbackEffectUnits) != 0) _callbackEffectUnitsEffectsIndex++; + if ((effectWrapper.EffectOn & EffectOn.CallbackUnit2) != 0) + _callbackUnitEffectsIndex2++; + if ((effectWrapper.EffectOn & EffectOn.CallbackUnit3) != 0) + _callbackUnitEffectsIndex3++; + if ((effectWrapper.EffectOn & EffectOn.CallbackUnit4) != 0) + _callbackUnitEffectsIndex4++; if ((effectWrapper.EffectOn & EffectOn.CallbackEffect2) != 0) _callbackEffectEffectsIndex2++; if ((effectWrapper.EffectOn & EffectOn.CallbackEffect3) != 0) _callbackEffectEffectsIndex3++; if ((effectWrapper.EffectOn & EffectOn.CallbackEffect4) != 0) _callbackEffectEffectsIndex4++; + if ((effectWrapper.EffectOn & EffectOn.CallbackEffectUnits2) != 0) + _callbackEffectUnitsEffectsIndex2++; + if ((effectWrapper.EffectOn & EffectOn.CallbackEffectUnits3) != 0) + _callbackEffectUnitsEffectsIndex3++; + if ((effectWrapper.EffectOn & EffectOn.CallbackEffectUnits4) != 0) + _callbackEffectUnitsEffectsIndex4++; } _effectsWithModifierInfoWrappers = effectsWithModifierInfoWrappers.ToArray(); @@ -115,16 +133,24 @@ public SyncedModifierEffects Create(int genId) _stackEffectsIndex = 0; } - if (_callbackUnitEffectsIndex > 0) - { - _callbackUnitEffects = new IEffect[_callbackUnitEffectsIndex]; - _callbackUnitEffectsIndex = 0; - } + if (_callbackUnitEffectsIndex > 0 || _callbackUnitEffectsIndex2 > 0 || + _callbackUnitEffectsIndex3 > 0 || _callbackUnitEffectsIndex4 > 0) + _callbackUnitEffects = new IEffect[4][]; if (_callbackEffectEffectsIndex > 0 || _callbackEffectEffectsIndex2 > 0 || _callbackEffectEffectsIndex3 > 0 || _callbackEffectEffectsIndex4 > 0) _callbackEffectEffects = new IEffect[4][]; + if (_callbackEffectUnitsEffectsIndex > 0 || _callbackEffectUnitsEffectsIndex2 > 0 || + _callbackEffectUnitsEffectsIndex3 > 0 || _callbackEffectUnitsEffectsIndex4 > 0) + _callbackEffectUnitsEffects = new IEffect[4][]; + + if (_callbackUnitEffectsIndex > 0) + { + _callbackUnitEffects[0] = new IEffect[_callbackUnitEffectsIndex]; + _callbackUnitEffectsIndex = 0; + } + if (_callbackEffectEffectsIndex > 0) { _callbackEffectEffects[0] = new IEffect[_callbackEffectEffectsIndex]; @@ -133,10 +159,28 @@ public SyncedModifierEffects Create(int genId) if (_callbackEffectUnitsEffectsIndex > 0) { - _callbackEffectUnitsEffects = new IEffect[_callbackEffectUnitsEffectsIndex]; + _callbackEffectUnitsEffects[0] = new IEffect[_callbackEffectUnitsEffectsIndex]; _callbackEffectUnitsEffectsIndex = 0; } + if (_callbackUnitEffectsIndex2 > 0) + { + _callbackUnitEffects[1] = new IEffect[_callbackUnitEffectsIndex2]; + _callbackUnitEffectsIndex2 = 0; + } + + if (_callbackUnitEffectsIndex3 > 0) + { + _callbackUnitEffects[2] = new IEffect[_callbackUnitEffectsIndex3]; + _callbackUnitEffectsIndex3 = 0; + } + + if (_callbackUnitEffectsIndex4 > 0) + { + _callbackUnitEffects[3] = new IEffect[_callbackUnitEffectsIndex4]; + _callbackUnitEffectsIndex4 = 0; + } + if (_callbackEffectEffectsIndex2 > 0) { _callbackEffectEffects[1] = new IEffect[_callbackEffectEffectsIndex2]; @@ -155,6 +199,24 @@ public SyncedModifierEffects Create(int genId) _callbackEffectEffectsIndex4 = 0; } + if (_callbackEffectUnitsEffectsIndex2 > 0) + { + _callbackEffectUnitsEffects[1] = new IEffect[_callbackEffectUnitsEffectsIndex2]; + _callbackEffectUnitsEffectsIndex2 = 0; + } + + if (_callbackEffectUnitsEffectsIndex3 > 0) + { + _callbackEffectUnitsEffects[2] = new IEffect[_callbackEffectUnitsEffectsIndex3]; + _callbackEffectUnitsEffectsIndex3 = 0; + } + + if (_callbackEffectUnitsEffectsIndex4 > 0) + { + _callbackEffectUnitsEffects[3] = new IEffect[_callbackEffectUnitsEffectsIndex4]; + _callbackEffectUnitsEffectsIndex4 = 0; + } + if (_revertEffectsIndex > 0) { _revertEffects = new IRevertEffect[_revertEffectsIndex]; @@ -183,17 +245,29 @@ public SyncedModifierEffects Create(int genId) if ((effectOn & EffectOn.Stack) != 0) _stackEffects[_stackEffectsIndex++] = (IStackEffect)effect; if ((effectOn & EffectOn.CallbackUnit) != 0) - _callbackUnitEffects[_callbackUnitEffectsIndex++] = effect; + _callbackUnitEffects[0][_callbackUnitEffectsIndex++] = effect; if ((effectOn & EffectOn.CallbackEffect) != 0) _callbackEffectEffects[0][_callbackEffectEffectsIndex++] = effect; if ((effectOn & EffectOn.CallbackEffectUnits) != 0) - _callbackEffectUnitsEffects[_callbackEffectUnitsEffectsIndex++] = effect; + _callbackEffectUnitsEffects[0][_callbackEffectUnitsEffectsIndex++] = effect; + if ((effectOn & EffectOn.CallbackUnit2) != 0) + _callbackUnitEffects[1][_callbackUnitEffectsIndex2++] = effect; + if ((effectOn & EffectOn.CallbackUnit3) != 0) + _callbackUnitEffects[2][_callbackUnitEffectsIndex3++] = effect; + if ((effectOn & EffectOn.CallbackUnit4) != 0) + _callbackUnitEffects[3][_callbackUnitEffectsIndex4++] = effect; if ((effectOn & EffectOn.CallbackEffect2) != 0) _callbackEffectEffects[1][_callbackEffectEffectsIndex2++] = effect; if ((effectOn & EffectOn.CallbackEffect3) != 0) _callbackEffectEffects[2][_callbackEffectEffectsIndex3++] = effect; if ((effectOn & EffectOn.CallbackEffect4) != 0) _callbackEffectEffects[3][_callbackEffectEffectsIndex4++] = effect; + if ((effectOn & EffectOn.CallbackEffectUnits2) != 0) + _callbackEffectUnitsEffects[1][_callbackEffectUnitsEffectsIndex2++] = effect; + if ((effectOn & EffectOn.CallbackEffectUnits3) != 0) + _callbackEffectUnitsEffects[2][_callbackEffectUnitsEffectsIndex3++] = effect; + if ((effectOn & EffectOn.CallbackEffectUnits4) != 0) + _callbackEffectUnitsEffects[3][_callbackEffectUnitsEffectsIndex4++] = effect; } EffectStateInfo effectStateInfo = default; @@ -217,13 +291,14 @@ public SyncedModifierEffects Create(int genId) //Set the effects arrays on our special effects (callback, event, remove-revert) //No need to reset manually special wrappers manually //Since they're always fed to effectWrappers, that we reset at the end - _callbackUnitRegisterWrapper?.GetEffectAs().SetEffects(_callbackUnitEffects); + for (int i = 0; i < _callbackUnitRegisterWrappers?.Length; i++) + _callbackUnitRegisterWrappers[i].GetEffectAs().SetEffects(_callbackUnitEffects[i]); for (int i = 0; i < _callbackEffectRegisterWrappers?.Length; i++) _callbackEffectRegisterWrappers[i].GetEffectAs() .SetEffects(_callbackEffectEffects[i]); - - _callbackEffectUnitsRegisterWrapper?.GetEffectAs() - .SetEffects(_callbackEffectUnitsEffects); + for (int i = 0; i < _callbackEffectUnitsRegisterWrappers?.Length; i++) + _callbackEffectUnitsRegisterWrappers[i].GetEffectAs() + .SetEffects(_callbackEffectUnitsEffects[i]); if (_removeEffectWrapper != null && _revertEffects != null) _removeEffectWrapper.GetEffectAs().SetRevertibleEffects(_revertEffects); diff --git a/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierRecipe.cs b/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierRecipe.cs index 773de42..94d5a66 100644 --- a/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierRecipe.cs +++ b/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierRecipe.cs @@ -29,9 +29,9 @@ public sealed partial class ModifierRecipe : IModifierRecipe, IEquatable _callbackUnitRegisterWrappers; private readonly List _callbackEffectRegisterWrappers; - private EffectWrapper _callbackEffectUnitsRegisterWrapper; + private readonly List _callbackEffectUnitsRegisterWrappers; private readonly List _effectWrappers; @@ -69,7 +69,9 @@ public ModifierRecipe(int id, string name, string displayName, string descriptio _tag = (TagType)Config.DefaultTag; _effectWrappers = new List(3); + _callbackUnitRegisterWrappers = new List(); _callbackEffectRegisterWrappers = new List(); + _callbackEffectUnitsRegisterWrappers = new List(); _saveInstructions = new List { new SaveInstruction.Initialize(name, displayName, description) }; @@ -413,20 +415,13 @@ public ModifierRecipe ModifierAction(ModifierAction modifierAction, EffectOn eff /// /// Registers a callback register effect to a unit, will trigger all /// effects when is triggered. - /// Only ONE CallbackUnit can be registered per modifier. /// public ModifierRecipe CallbackUnit(TCallbackUnit callbackType) { - if (_callbackUnitRegisterWrapper != null) - { - Logger.LogError("[ModiBuff] Multiple CallbackUnit effects registered, " + - "only one is allowed per modifier, ignoring."); - return this; - } - var effect = new CallbackUnitRegisterEffect(callbackType); - _callbackUnitRegisterWrapper = new EffectWrapper(effect, EffectOn.Init); - _effectWrappers.Add(_callbackUnitRegisterWrapper); + var wrapper = new EffectWrapper(effect, EffectOn.Init); + _callbackUnitRegisterWrappers.Add(wrapper); + _effectWrappers.Add(wrapper); _saveInstructions.Add(new SaveInstruction.CallbackUnit((int)(object)callbackType)); return this; } @@ -509,22 +504,15 @@ public ModifierRecipe CallbackEffect(TCallbackEffec /// Special callbacks, all EffectOn. effects will /// trigger when is triggered. /// Supports custom callback signatures (beside . - /// Only ONE CallbackEffect can be registered per modifier. /// Allows to store the target and source when registering the callback, for further access. /// public ModifierRecipe CallbackEffectUnits(TCallbackEffect callbackType, Func> @event) { - if (_callbackEffectUnitsRegisterWrapper != null) - { - Logger.LogError("[ModiBuff] Multiple CallbackEffectUnits effects registered, " + - "only one is allowed per modifier, ignoring."); - return this; - } - var effect = new CallbackEffectRegisterEffectUnits(callbackType, @event); - _callbackEffectUnitsRegisterWrapper = new EffectWrapper(effect, EffectOn.Init); - _effectWrappers.Add(_callbackEffectUnitsRegisterWrapper); + var wrapper = new EffectWrapper(effect, EffectOn.Init); + _callbackEffectUnitsRegisterWrappers.Add(wrapper); + _effectWrappers.Add(wrapper); return this; } @@ -569,11 +557,11 @@ public IModifierGenerator CreateModifierGenerator() _dispelRegisterWrapper?.GetEffectAs().UpdateDispelType(dispel); var data = new ModifierRecipeData(Id, Name, _effectWrappers, finalRemoveEffectWrapper, - _dispelRegisterWrapper, _callbackUnitRegisterWrapper, _callbackEffectRegisterWrappers.ToArray(), - _callbackEffectUnitsRegisterWrapper, _hasApplyChecks, _applyCheckList, _hasEffectChecks, - _effectCheckList, _applyFuncCheckList, _effectFuncCheckList, _isAura, _tag, _oneTimeInit, _interval, - _duration, _refreshDuration, _refreshInterval, _whenStackEffect, _maxStacks, _everyXStacks, - _singleStackTime, _independentStackTime); + _dispelRegisterWrapper, _callbackUnitRegisterWrappers.ToArray(), + _callbackEffectRegisterWrappers.ToArray(), _callbackEffectUnitsRegisterWrappers.ToArray(), + _hasApplyChecks, _applyCheckList, _hasEffectChecks, _effectCheckList, _applyFuncCheckList, + _effectFuncCheckList, _isAura, _tag, _oneTimeInit, _interval, _duration, _refreshDuration, + _refreshInterval, _whenStackEffect, _maxStacks, _everyXStacks, _singleStackTime, _independentStackTime); return new ModifierGenerator(in data); } @@ -650,11 +638,10 @@ private void Validate() + Name + " id: " + Id); } - ValidateCallbacks(EffectOn.CallbackUnit, _callbackUnitRegisterWrapper); - for (int i = 0; i < _callbackEffectRegisterWrappers.Count; i++) - ValidateCallbacks(EffectOnCallbackEffectData.AllCallbackEffectData[i], - _callbackEffectRegisterWrappers[i]); - ValidateCallbacks(EffectOn.CallbackEffectUnits, _callbackEffectUnitsRegisterWrapper); + ValidateCallbacks(EffectOnCallbackEffectData.AllCallbackUnitData, _callbackUnitRegisterWrappers); + ValidateCallbacks(EffectOnCallbackEffectData.AllCallbackEffectData, _callbackEffectRegisterWrappers); + ValidateCallbacks(EffectOnCallbackEffectData.AllCallbackEffectUnitsData, + _callbackEffectUnitsRegisterWrappers); if (_effectWrappers.Exists(w => w.GetEffect() is ApplierEffect applierEffect && applierEffect.HasApplierType)) @@ -712,22 +699,27 @@ void ValidateTimeAction(EffectOn effectOn, float actionTimer) } } - void ValidateCallbacks(EffectOn effectOn, EffectWrapper callbackWrapper) + void ValidateCallbacks(EffectOn[] effectOns, IList callbackWrappers) { - if (WrappersHaveFlag(effectOn) && callbackWrapper == null) + for (int i = 0; i < effectOns.Length; i++) { - validRecipe = false; - Logger.LogError( - $"[ModiBuff] Effects on {effectOn.ToString()} set, but no callback registration type set, " + - "for modifier: " + Name + " id: " + Id); - } - - if (callbackWrapper != null && NoWrappersHaveFlag(effectOn)) - { - validRecipe = false; - Logger.LogError( - $"[ModiBuff] {effectOn.ToString()} registration type set, but no effects on callback set, " + - "for modifier: " + Name + " id: " + Id); + var effectOn = effectOns[i]; + var callbackWrapper = callbackWrappers.Count > i ? callbackWrappers[i] : null; + if (WrappersHaveFlag(effectOn) && callbackWrapper == null) + { + validRecipe = false; + Logger.LogError( + $"[ModiBuff] Effects on {effectOn.ToString()} set, but no callback registration type set, " + + "for modifier: " + Name + " id: " + Id); + } + + if (callbackWrapper != null && NoWrappersHaveFlag(effectOn)) + { + validRecipe = false; + Logger.LogError( + $"[ModiBuff] {effectOn.ToString()} registration type set, but no effects on callback set, " + + "for modifier: " + Name + " id: " + Id); + } } } } diff --git a/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierRecipeData.cs b/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierRecipeData.cs index b77e1ee..7407e22 100644 --- a/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierRecipeData.cs +++ b/ModiBuff/ModiBuff/Core/Modifier/Creation/Recipe/ModifierRecipeData.cs @@ -10,9 +10,9 @@ public readonly struct ModifierRecipeData public readonly List EffectWrappers; public readonly EffectWrapper RemoveEffectWrapper; public readonly EffectWrapper DispelRegisterWrapper; - public readonly EffectWrapper CallbackUnitRegisterWrapper; + public readonly EffectWrapper[] CallbackUnitRegisterWrappers; public readonly EffectWrapper[] CallbackEffectRegisterWrappers; - public readonly EffectWrapper CallbackEffectUnitsRegisterWrapper; + public readonly EffectWrapper[] CallbackEffectUnitsRegisterWrappers; public readonly bool HasApplyChecks; public readonly List ApplyCheckList; public readonly bool HasEffectChecks; @@ -34,8 +34,8 @@ public readonly struct ModifierRecipeData public ModifierRecipeData(int id, string name, List effectWrappers, EffectWrapper removeEffectWrapper, EffectWrapper dispelRegisterWrapper, - EffectWrapper callbackUnitRegisterWrapper, EffectWrapper[] callbackEffectRegisterWrappers, - EffectWrapper callbackEffectUnitsRegisterWrapper, bool hasApplyChecks, List applyCheckList, + EffectWrapper[] callbackUnitRegisterWrappers, EffectWrapper[] callbackEffectRegisterWrappers, + EffectWrapper[] callbackEffectUnitsRegisterWrappers, bool hasApplyChecks, List applyCheckList, bool hasEffectChecks, List effectCheckList, List> applyFuncCheckList, List> effectFuncCheckList, bool isAura, TagType tag, bool oneTimeInit, float interval, float duration, bool refreshDuration, bool refreshInterval, WhenStackEffect whenStackEffect, int maxStacks, @@ -46,9 +46,9 @@ public ModifierRecipeData(int id, string name, List effectWrapper EffectWrappers = effectWrappers; RemoveEffectWrapper = removeEffectWrapper; DispelRegisterWrapper = dispelRegisterWrapper; - CallbackUnitRegisterWrapper = callbackUnitRegisterWrapper; + CallbackUnitRegisterWrappers = callbackUnitRegisterWrappers; CallbackEffectRegisterWrappers = callbackEffectRegisterWrappers; - CallbackEffectUnitsRegisterWrapper = callbackEffectUnitsRegisterWrapper; + CallbackEffectUnitsRegisterWrappers = callbackEffectUnitsRegisterWrappers; HasApplyChecks = hasApplyChecks; ApplyCheckList = applyCheckList; HasEffectChecks = hasEffectChecks; diff --git a/ModifierExamples.md b/ModifierExamples.md index 85a7513..397fa7f 100644 --- a/ModifierExamples.md +++ b/ModifierExamples.md @@ -1,20 +1,23 @@ # Modifier Examples -> Important: If you're not using the master branch, it might be smart to go to the correct versions, they'll have the most accurate modifier recipes. +> Important: If you're not using the master branch, it might be smart to go to the correct versions, they'll have the +> most accurate modifier recipes. > [V0.2.0](https://github.com/Chillu1/ModiBuff/blob/0.2.0/ModifierExamples.md) > [V0.1.2](https://github.com/Chillu1/ModiBuff/blob/0.1.2/ModifierExamples.md) - [Basic Recipes](#basic-recipes) - [Conditional Recipes](#conditional-recipes) -- [Event Recipes](#event-recipes) - [Callback Recipes](#callback-recipes) - [Modifier Action Recipes](#modifier-action-recipes) - [Advanced Recipes](#advanced-recipes) - [Centralized Effect](#centralized-effect) [//]: # (TODO Recipe examples for usual game mechanics) + [//]: # (DoT, InitDoTSeparateDmg, OnXStacks, StackableDamage, StunEverySecondFor0.2Seconds) + [//]: # ("Absoultely crazy modifiers": applying appliers on events, X stacks, etc) + [//]: # (Meta, Post, Stack modifiers) > Important: Damage being the default effect is just an example, it makes it easier to understand. @@ -125,7 +128,8 @@ Add("StunEveryTwoStacks") .Stack(WhenStackEffect.EveryXStacks, value: -1, maxStacks: -1, everyXStacks: 2); ``` -Init Damage. With 1 second linger. Won't work again if applied within 1 second, aka "global cooldown", shared between all X modifier +Init Damage. With 1 second linger. Won't work again if applied within 1 second, aka "global cooldown", shared between +all X modifier instaces. ```csharp @@ -314,38 +318,38 @@ Add("InitDamage_CostMana") .Effect(new DamageEffect(5), EffectOn.Init); ``` -## Event Recipes +## Callback Recipes Thorns on hit (deal 5 damage to attacker) ```csharp Add("ThornsOnHitEvent") - .Effect(new DamageEffect(5, targeting: Targeting.SourceTarget), EffectOn.Event) - .Event(EffectOnEvent.WhenAttacked); + .Effect(new DamageEffect(5, targeting: Targeting.SourceTarget), EffectOn.CallbackUnit) + .CallbackUnit(CallbackUnitType.WhenAttacked); ``` Add damage on kill ```csharp Add("AddDamage_OnKill_Event") - .Effect(new AddDamageEffect(5, targeting: Targeting.SourceTarget), EffectOn.Event) - .Event(EffectOnEvent.OnKill); + .Effect(new AddDamageEffect(5, targeting: Targeting.SourceTarget), EffectOn.CallbackUnit) + .CallbackUnit(CallbackUnitType.OnKill); ``` Damage attacker on death ```csharp Add("Damage_OnDeath_Event") - .Effect(new DamageEffect(5, targeting: Targeting.SourceTarget), EffectOn.Event) - .Event(EffectOnEvent.WhenKilled); + .Effect(new DamageEffect(5, targeting: Targeting.SourceTarget), EffectOn.CallbackUnit) + .CallbackUnit(CallbackUnitType.WhenKilled); ``` Attack self when attacked ```csharp Add("AttackSelf_OnHit_Event") - .Effect(new SelfAttackActionEffect(), EffectOn.Event) - .Event(EffectOnEvent.WhenAttacked); + .Effect(new SelfAttackActionEffect(), EffectOn.CallbackUnit) + .CallbackUnit(CallbackUnitType.WhenAttacked); ``` When attacked, add damage to all attackers, for 1 second (refreshes) @@ -356,12 +360,10 @@ Add("AddDamage") .Effect(new AddDamageEffect(5, EffectState.IsRevertible), EffectOn.Init) .Remove(1).Refresh(); Add("AddDamageToAllAttackers_OnHit_Event") - .Effect(new ApplierEffect("AddDamage", targeting: Targeting.SourceTarget), EffectOn.Event) - .Event(EffectOnEvent.WhenAttacked); + .Effect(new ApplierEffect("AddDamage", targeting: Targeting.SourceTarget), EffectOn.CallbackUnit) + .CallbackUnit(CallbackUnitType.WhenAttacked); ``` -## Callback Recipes - Add damage on init, remove and revert it if we take a strong hit (damage >= 50% max hp) ```csharp @@ -660,7 +662,8 @@ Add("Poison") .Remove(5).Refresh(); ``` -Heal per poison stack on poison damage tick effect. There's two ways to achieve this, first is by manually using the stack effect. +Heal per poison stack on poison damage tick effect. There's two ways to achieve this, first is by manually using the +stack effect. The second is by setting up custom stack logic with modifier action based on when the poison damage effect is triggered. ```csharp diff --git a/README.md b/README.md index 3081010..e30b566 100644 --- a/README.md +++ b/README.md @@ -69,11 +69,10 @@ This library solves that, but also allows for more complex and deeper modifiers * Interval * Duration * Stack - * Event (ex. When Attacked/Cast/Killed/Healed/Stunned/Silenced, On Attack/Cast/Kill/Heal) * Callbacks (any user logic, support mutable and serializable state inside) - * Unit callbacks + * Unit callbacks/events (ex. When Attacked/Cast/Killed/Healed/Stunned/Silenced, On Attack/Cast/Kill/Heal) * Effect callbacks - * Event/Custom signature callbacks + * Custom signature callbacks * Effect implementation examples * Damage (& self damage) * Heal @@ -508,25 +507,18 @@ Add("InitDamage_ChargesCooldown") .Effect(new DamageEffect(5), EffectOn.Init); ``` -### Event - -Events are a way to call effects on certain unit events. -Examples of this are: When Attacked, When Killed, On Attack, On Kill, On Cast, etc. +### Callback -Some common examples of this are: thorns, restore health on cast, add damage on kill. +> After commit [259cb86](https://github.com/Chillu1/ModiBuff/commit/259cb86a59b4bbd81da55b5a24c79b1ea6e3be1a), events +> were removed, and replaced entirely with callbacks. They're entirely the same. -In this example we deal 5 damage to a unit that attacks us. +Callbacks are a way to call effects on certain unit events. +Examples of some are: When Attacked, When Killed, On Attack, On Kill, On Cast, etc. -```csharp -Add("ThornsOnHitEvent") - .Effect(new DamageEffect(5, targeting: Targeting.SourceTarget), EffectOn.CallbackUnit) - .CallbackUnit(CallbackUnitType.WhenAttacked); -``` - -### Callback +Some common examples of this are: thorns, restore health on cast, add damage on kill. -Callbacks work like events, but have extra functionality, like being able to remove the modifier on callback, -using data sent through the event, and having mutable serializable state inside it. +Callbacks are the most powerful tool to use together with game logic, they can use data sent through the event, +and have mutable serializable state inside it. Callbacks are a way to add logic that can be triggered on any user/game-based action. This is particularly useful for removing modifiers on certain non-standard cases. @@ -850,7 +842,7 @@ This behaviour can be changed by using CustomStack logic. Modifier stack action a future release. The most usual usage of this is to trigger the stack action on a custom case. -It's a way to glue callback/event logic to stacking behaviour. +It's a way to glue callback logic to stacking behaviour. Here we dispel all status effects if the unit has been stunned 4 times. @@ -946,8 +938,8 @@ should be used. Currently for aura modifiers it has to be implemented directly into the unit. An example of this can be found in `CoreUnits.Unit.AddAuraModifier(int)`. -This is also the case for unit events, like `OnKill`, `OnAttack`, `WhenDeath`, etc. -Through `IEventOwner.AddEffectEvent(IEffect, EffectOnEvent)`. +This is also the case for unit callbacks, like `OnKill`, `OnAttack`, `WhenDeath`, etc. +Through `ICallbackUnitRegistrable.RegisterCallbacks(TCallbackUnit, IEffect[])`. ## Effect