Luck/Intelligence Rework

-- Determines the percentage modifier per each point in a stat
function CalcStatCurve(stat, breakpoints)
    if #breakpoints == 0 then
        return 0
    end

    for _, segment in ipairs(breakpoints) do
        if segment.endStat - segment.startStat == 0 then
            return 0
        end

        if stat >= segment.startStat and stat <= segment.endStat then
            return segment.startValue + ((stat - segment.startStat) / (segment.endStat - segment.startStat)) *
            (segment.endValue - segment.startValue)
        end
    end

    if stat > breakpoints[#breakpoints].endStat then
        return breakpoints[#breakpoints].endValue
    end

    return breakpoints[1].startValue
end

function BS_CALC_GetResistRate(bIsPredict, bIsEffectLuck, bIsFriendlyAction, luck, baseLuck, resistRate)
    local rate = resistRate;

    if bIsEffectLuck == false then
        return rate
    end

    if bIsFriendlyAction then
        rate = resistRate - 0.25 * luck / 1000;
    else
        local breakpoints = {
            { startStat = 0, endStat = 60, startValue = 0.8, endValue = 1.1 },
            { startStat = 60, endStat = 140, startValue = 1.1, endValue = 1.2 },
            { startStat = 140, endStat = 999, startValue = 1.2, endValue = 1.4 }
        }

        local luckWeight = math.min(CalcStatCurve(luck, breakpoints), 1.4);
        rate = math.min(resistRate * luckWeight, 1);
    end

    return rate
end

-- Randomized damage rate
function BS_CALC_GetRandomRate(bIsPlayer, luck)
    local randRate = 1

    if bIsPlayer == true then
        local rangeMin = math.min(CalcStatCurve(luck, breakpoints), 1.12)
        local rangeMax = 1.2
        local breakpoints = {
            {startStat = 0, endStat = 60, startValue = 0.8, endValue = 1.0},
            {startStat = 60, endStat = 140, startValue = 1.0, endValue = 1.1},
            {startStat = 140, endStat = 320, startValue = 1.1, endValue = 1.12},
        }

        randRate = rangeMin + math.random() * (rangeMax - rangeMin)
    else
        local rangeMinMonster = 0.9
        local rangeMaxMonster = 1.1

        randRate = rangeMinMonster + math.random() * (rangeMaxMonster - rangeMinMonster)
    end

    randRate = math.floor(randRate * 100000) / 100000

    return randRate
end

function BS_CALC_GetIntelligenceBonus(intel)
    local breakpoints = {
        {startStat = 0, endStat = 40, startValue = 1.0, endValue = 1.1},
        {startStat = 40, endStat = 180, startValue = 1.1, endValue = 1.3},
        {startStat = 180, endStat = 850, startValue = 1.3, endValue = 1.5},
    }
    local intelMultiplier = math.min(CalcStatCurve(intel, breakpoints), 1.5);

   return intelMultiplier
 end

function BS_CALC_GetBaseCriticalRate(isFighter, jobCriticalRate, luck, baseLuck)
    local minCrit = 1 / 64
    local maxCrit = jobCriticalRate
    local critRate = minCrit

    if isFighter then
        local level = ConvertBaseLuckToLevel(baseLuck)
        local levelBonus = math.min(level / 2560, 0.025)
        local breakpoints = {
            { startStat = 0, endStat = 60, startValue = 0, endValue = 0.15 },
            { startStat = 60, endStat = 140, startValue = 0.15, endValue = 0.2 },
            { startStat = 140, endStat = 900, startValue = 0.2, endValue = 1 }
        }

        local luckWeight = CalcStatCurve(luck, breakpoints) + levelBonus
        critRate = math.max(minCrit, minCrit + (maxCrit - minCrit) * luckWeight)
        critRate = math.min(critRate, 0.5)

        return critRate
    end

    local breakpoints = {
        { startStat = 0, endStat = 60, startValue = 0, endValue = 0.1 },
        { startStat = 60, endStat = 140, startValue = 0.1, endValue = 0.2 },
        { startStat = 140, endStat = 900, startValue = 0.2, endValue = 1 }
    }

    local luckWeight = CalcStatCurve(luck, breakpoints)
    critRate = math.max(minCrit, minCrit + (maxCrit - minCrit) * luckWeight)
    critRate = math.min(critRate, 0.25)

    return critRate
end