heroes-of-nerevelon/lib/spell/effect.lua

local utils = require "lib.utils.utils"
local task = require "lib.utils.task"

--- @class Effect
--- @field tag string
local effect = {}
effect.__index = effect

--- Предполагается, что в каждую функцию будет передаваться `Character` и параметр `intensity`, который отвечает за силу спелла
--- @alias EffectFunc fun(owner: Character, intensity: integer): Task<nil>
--- @alias EffectStatementFunc fun(owner: Character, intensity: integer): Task<nil>, boolean
--- @alias EffectDamageFunc fun(owner: Character, intensity: integer, damage: integer): Task<nil>, integer
--- @alias EffectRegenFunc fun(owner: Character, intensity: integer, amountHp: integer): Task<nil>, integer
--- @alias EffectData { tag: string, [string]: EffectFunc|EffectStatementFunc|EffectDamageFunc|EffectRegenFunc }

--- @param owner Character
--- @param intensity integer
--- @return Task<nil>, boolean
function effect:beforeBirth(owner, intensity) return task.wait {}, true end

--- @param owner Character
--- @param intensity integer
--- @return Task<nil>
function effect:afterBirth(owner, intensity) return task.wait {} end

--- @param owner Character
--- @param intensity integer
--- @return Task<nil>, boolean
function effect:beforeDeath(owner, intensity) return task.wait {}, true end

--- @param owner Character
--- @param intensity integer
--- @return Task<nil>
function effect:afterDeath(owner, intensity) return task.wait {} end

--- @param owner Character
--- @param intensity integer
--- @return Task<nil>, boolean
function effect:beforeTurn(owner, intensity) return task.wait {}, true end

--- @param owner Character
--- @param intensity integer
--- @return Task<nil>
function effect:afterTurn(owner, intensity) return task.wait {} end

--- @param owner Character
--- @param intensity integer
--- @return Task<nil>, boolean
function effect:beforeCast(owner, intensity) return task.wait {}, true end

--- @param owner Character
--- @param intensity integer
--- @return Task<nil>
function effect:afterCast(owner, intensity) return task.wait {} end

--- @param owner Character
--- @param intensity integer
--- @param damage integer
--- @return Task<nil>, integer
function effect:beforeAttack(owner, intensity, damage) return task.wait {}, damage end

--- @param owner Character
--- @param intensity integer
--- @return Task<nil>
function effect:afterAttack(owner, intensity) return task.wait {} end

--- @param owner Character
--- @param intensity integer
--- @param damage integer
--- @return Task<nil>, integer
function effect:beforeDamage(owner, intensity, damage) return task.wait {}, damage end

--- @param owner Character
--- @param intensity integer
--- @return Task<nil>
function effect:afterDamage(owner, intensity) return task.wait {} end

--- @param owner Character
--- @param intensity integer
--- @param amountHp integer кол-во хп для регена
--- @return Task<nil>, integer
function effect:beforeRegeneration(owner, intensity, amountHp) return task.wait {}, amountHp end

--- @param owner Character
--- @param intensity integer
--- @return Task<nil>
function effect:afterRegeneration(owner, intensity) return task.wait {} end

--- @param other Effect
--- @return Effect|nil
function effect:sum(other) end

function effect:update(dt) end

function effect:draw() end

--- дип сравнение эффектов
--- @param other Effect
--- @return boolean
function effect:__eq(other)
    return utils.deepComprasion(self, other)
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 EffectData
--- @return Effect
local function new(data)
    local newEffect = setmetatable({
        tag = data.tag
    }, effect)

    function newEffect:beforeBirth(owner, intensity)
        if not data.beforeBirth then return end
        local task, statement = data.beforeBirth(owner, intensity)
        return task, statement
    end

    function newEffect:afterBirth(owner, intensity)
        if not data.afterBirth then return end
        return data.afterBirth(owner, intensity)
    end

    function newEffect:beforeDeath(owner, intensity)
        if not data.beforeDeath then return end
        local task, statement = data.beforeBirth(owner, intensity)
        return task, statement
    end

    function newEffect:afterDeath(owner, intensity)
        if not data.afterDeath then return end
        return data.afterDeath(owner, intensity)
    end

    function newEffect:beforeTurn(owner, intensity)
        if not data.beforeTurn then return end
        local task, statement = data.beforeBirth(owner, intensity)
        return task, statement
    end

    function newEffect:afterTurn(owner, intensity)
        if not data.afterTurn then return end
        return data.afterTurn(owner, intensity)
    end

    function newEffect:beforeCast(owner, intensity)
        if not data.beforeCast then return end
        local task, statement = data.beforeBirth(owner, intensity)
        return task, statement
    end

    function newEffect:afterCast(owner, intensity)
        if not data.afterCast then return end
        return data.afterCast(owner, intensity)
    end

    function newEffect:beforeAttack(owner, intensity, damage)
        if not data.beforeAttack then return end
        local task, newDamage = data.beforeDamage(owner, intensity, damage)
        return task, newDamage
    end

    function newEffect:afterAttack(owner, intensity)
        if not data.afterAttack then return end
        return data.afterAttack(owner, intensity)
    end

    function newEffect:beforeDamage(owner, intensity, damage)
        if not data.beforeDamage then return end
        local task, newDamage = data.beforeDamage(owner, intensity, damage)
        return task, newDamage
    end

    function newEffect:afterDamage(owner, intensity)
        if not data.afterDamage then return end
        return data.afterDamage(owner, intensity)
    end

    function newEffect:beforeRegeneration(owner, intensity, amountHp)
        if not data.beforeRegeneration then return end
        local task, newAmountHp = data.beforeRegeneration(owner, intensity, amountHp)
        return task, newAmountHp
    end

    function newEffect:afterRegeneration(owner, intensity)
        if not data.afterRegeneration then return end
        return data.afterRegeneration(owner, intensity)
    end

    --- дип сравнение эффектов
    --- @param other Effect
    --- @return boolean
    function newEffect:__eq(other)
        return utils.deepComparison(self, other)
    end

    return newEffect
end

return { new = new }