make another functions & add some cool light on spawn effect

lib/character/behaviors/effects.lua

@@ -39,7 +39,7 @@ function behavior:addEffect(effect, stacks)
     self.effectsPriority[#self.effectsPriority + 1] = effect
     self.effectsStacks[effect] = stacks
     print("[Effects]: мы применили эффект!!")
-    effect:afterBirth()
+    effect:afterBirth(self.owner)
 end
 
 --- должен вызываться в начале хода
@@ -55,7 +55,10 @@ end
 --- должен вызываться в конце хода
 function behavior:afterTurn()
     for i, ef in pairs(self.effectsPriority) do
-        ef:afterTurn()
+        local task1 = ef:afterTurn(self.owner)
+        if task1 then
+            task1(function() end)
+        end
     end
 end
 

lib/effectbook.lua

@@ -1,5 +1,6 @@
 local task = require "lib.utils.task"
 local effect = require "lib.spell.effect"
+local easing = require "lib.utils.easing"
 
 local bleeding = effect.new({
     tag = "bleeding",
@@ -10,6 +11,19 @@ local bleeding = effect.new({
         if not stats or not sprite then return end
         stats:dealDamage(2)
         return task.wait({ sprite:animate("hurt") })
+    end,
+    afterBirth = function(owner)
+        local light = require "lib/character/character".spawn("Light Effect")
+        light:addBehavior {
+            Tree.behaviors.light.new { color = Vec3 { 1, 0., 0. }, intensity = 4 },
+            Tree.behaviors.positioned.new(owner:has(Tree.behaviors.positioned).position + Vec3 { 0.5, 0.5 }),
+        }
+
+        return task.wait({ task.chain(task.tween(light:has(Tree.behaviors.light) --[[@as LightBehavior]],
+            { intensity = 1, color = Vec3 { 1, 0., 0. } }, 800, easing.easeInCubic), function()
+            light:die()
+            return task.fromValue()
+        end) })
     end
 })
 

lib/spell/effect.lua

@@ -3,39 +3,70 @@
 local effect = {}
 effect.__index = effect
 
-function effect:beforeBirth() end
+--- @alias EffectFunc fun(owner: Character): Task<nil>|nil
+--- @alias EffectDamageFunc fun(owner: Character, damage: integer): Task<nil>|nil
+--- @alias EffectRegenFunc fun(owner: Character, amountHp: integer): Task<nil>|nil
+--- @alias EffectData { tag: string, [string]: EffectFunc|EffectDamageFunc|EffectRegenFunc }
 
-function effect:afterBirth() end
+--- @param owner Character
+--- @return Task<nil>|nil
+function effect:beforeBirth(owner) end
 
-function effect:beforeDeath() end
+--- @param owner Character
+--- @return Task<nil>|nil
+function effect:afterBirth(owner) end
 
-function effect:afterDeath() end
+--- @param owner Character
+--- @return Task<nil>|nil
+function effect:beforeDeath(owner) end
+
+--- @param owner Character
+--- @return Task<nil>|nil
+function effect:afterDeath(owner) end
 
 --- пока что это единственный метод, который работает
 --- @param owner Character
 --- @return Task<nil>|nil
 function effect:beforeTurn(owner) end
 
-function effect:afterTurn() end
+--- @param owner Character
+--- @return Task<nil>|nil
+function effect:afterTurn(owner) end
 
-function effect:beforeCast() end
+--- @param owner Character
+--- @return Task<nil>|nil
+function effect:beforeCast(owner) end
 
-function effect:afterCast() end
+--- @param owner Character
+--- @return Task<nil>|nil
+function effect:afterCast(owner) end
 
+--- @param owner Character
 --- @param damage integer
-function effect:beforeAttack(damage) end
+--- @return Task<nil>|nil
+function effect:beforeAttack(owner, damage) end
 
-function effect:afterAttack() end
+--- @param owner Character
+--- @return Task<nil>|nil
+function effect:afterAttack(owner) end
 
+--- @param owner Character
 --- @param damage integer
-function effect:beforeDamage(damage) end
+--- @return Task<nil>|nil
+function effect:beforeDamage(owner, damage) end
 
-function effect:afterDamage() end
+--- @param owner Character
+--- @return Task<nil>|nil
+function effect:afterDamage(owner) end
 
+--- @param owner Character
 --- @param amountHp integer кол-во хп для регена
-function effect:beforeRegeneration(amountHp) end
+--- @return Task<nil>|nil
+function effect:beforeRegeneration(owner, amountHp) end
 
-function effect:afterRegeneration() end
+--- @param owner Character
+--- @return Task<nil>|nil
+function effect:afterRegeneration(owner) end
 
 --- @param other Effect
 --- @return Effect|nil
@@ -46,22 +77,84 @@ function effect:update(dt) end
 function effect:draw() end
 
 --- @todo переделать дату и прочее
---- @param data {tag: string, beforeBirth: fun(owner: Character)?, beforeDeath: fun(owner: Character)?, beforeTurn: (fun(owner: Character): Task<nil>|nil), afterTurn: (fun(owner: Character): Task<nil>|nil), sum: fun(owner: Character)?}
+-- --- @param data {tag: string, beforeBirth: fun(owner: Character)?, beforeDeath: fun(owner: Character)?, beforeTurn: (fun(owner: Character): Task<nil>|nil), afterTurn: (fun(owner: Character): Task<nil>|nil), sum: fun(owner: Character)?}
+--- @param data EffectData
 --- @return Effect
 local function new(data)
     local newEffect = setmetatable({
-        tag = data.tag,
+        tag = data.tag
-        beforeBirth = data.beforeBirth,
-        beforeDeath = data.beforeDeath,
-        -- beforeTurn = data.beforeTurn,
-        afterTurn = data.afterTurn,
-        sum = data.sum
     }, effect)
 
+    function newEffect:beforeBirth(owner)
+        if not data.beforeBirth then return end
+        return data.beforeBirth(owner)
+    end
+
+    function newEffect:afterBirth(owner)
+        if not data.afterBirth then return end
+        return data.afterBirth(owner)
+    end
+
+    function newEffect:beforeDeath(owner)
+        if not data.beforeDeath then return end
+        return data.beforeDeath(owner)
+    end
+
+    function newEffect:afterDeath(owner)
+        if not data.afterDeath then return end
+        return data.afterDeath(owner)
+    end
+
     function newEffect:beforeTurn(owner)
+        if not data.beforeTurn then return end
         return data.beforeTurn(owner)
     end
 
+    function newEffect:afterTurn(owner)
+        if not data.afterTurn then return end
+        return data.afterTurn(owner)
+    end
+
+    function newEffect:beforeCast(owner)
+        if not data.beforeCast then return end
+        return data.beforeCast(owner)
+    end
+
+    function newEffect:afterCast(owner)
+        if not data.afterCast then return end
+        return data.afterCast(owner)
+    end
+
+    function newEffect:beforeAttack(owner, damage)
+        if not data.beforeAttack then return end
+        return data.beforeAttack(owner, damage)
+    end
+
+    function newEffect:afterAttack(owner)
+        if not data.afterAttack then return end
+        return data.afterAttack(owner)
+    end
+
+    function newEffect:beforeDamage(owner, damage)
+        if not data.beforeDamage then return end
+        return data.beforeDamage(owner, damage)
+    end
+
+    function newEffect:afterDamage(owner)
+        if not data.afterDamage then return end
+        return data.afterDamage(owner)
+    end
+
+    function newEffect:beforeRegeneration(owner, amountHp)
+        if not data.beforeRegeneration then return end
+        return data.beforeRegeneration(owner, amountHp)
+    end
+
+    function newEffect:afterRegeneration(owner)
+        if not data.afterRegeneration then return end
+        return data.afterRegeneration(owner)
+    end
+
     return newEffect
 end