if not host:isHost() then return false end

config:setName("RWHUD")
local lib = config:load("AllConfig") or {
    food = {
        enabled = true,
        ringColour = vec(1, 1, 1, 1),
        pipColour = vec(1, 1, 1, 1),
        quarterColour = vec(0.75, 0.75, 0.75, 1),
        barColour = vec(1, 1, 1, 1),
        sleepRequirement = 4, -- Pips before the seperator bar
        maxValue = 7, -- Total amount of pips
        value = 0, -- How much food you have - can be quarters
        customValues = false -- uses the above 3 values for food, false is vanilla hunger bar functionality
    },
    karma = {
        enabled = true,
        colour = vec(1, 1, 1, 1),
        value = 9, --Current karma value and reinforcement
        reinforced = true,
        maxValue = 9, --Maximum karma value
        customValues = false -- uses the above 3 values for karma, false is rain world functionality
    },
    rainTimer = {
        enabled = true,
        maxValue = 12000, --Maximum time left until rain
        value = 12000, --Time left until rain
        customValues = false, -- uses the above 2 values for cycle time, false is the time left until night
        colour = vec(1, 1, 1, 1)
    },
    dangerBar = {
        enabled = true,
        value = 0, -- how much in danger you are, from 0-5
        customValues = false, -- uses the above value for threat level, false takes in nearby mobs/projectiles and calculates threat based on distance to you
        colour = vec(1, 0, 0, 1)
    },
    airBar = {
        enabled = true,
        value = 300, -- ticks left until drowning
        maxValue = 300, -- maximum ticks left until drowning
        customValues = false, -- uses the above 2 values for air, false is your current vanilla air level
        colour = vec(1, 1, 1, 1)
    },
    tempBar = {
        enabled = true,
        value = 2, -- body temperature: 2 is fine, 0 is freezing and 4 is overheating
        customValues = false, -- uses the above value for temperature, false takes the value from the Tough as Nails mod (if installed)
        overheatingColour = vec(1, 0, 0, 1),
        colour = vec(1, 1, 1, 1)
    }
}

local VanillaKarma = config:load("karmaValue") or 4
local pips = {}
local DangerPips = {}
local AirPips = {}
local RainPips = {}
local TempPips = {}
local RingTextures = {}
local FoodBar = models:newPart("FoodBar","HUD")
local Separator = FoodBar:newPart("Separator","HUD")
local Background = FoodBar:newPart("BG","HUD")
local DangerBar = models:newPart("DangerBar","HUD")
local AirBar = models:newPart("AirBar","HUD")
local KarmaDisplay = models:newPart("KarmaDisplay","HUD")
local RainDisplay = models:newPart("RainTimer", "HUD")
local TempBar = models:newPart("TempBar", "HUD")
local size = -client:getScaledWindowSize()
local ExhaustionState
local ActualFoodValue
local Gamemode
local ActualSleepReq
local ActualMaxVal
local KarmaReinforced
local TrueDangerValue = 0
local DangerBarTick = 1
local DangerBarScale = 1
local DangerPulseFrequency
local ActualTemp = 2
local bannedMobs = {"minecraft:player", "minecraft:item", "minecraft:item_frame", "minecraft:glow_item_frame", "minecraft:armor_stand",
                    "minecraft:pig", "minecraft:cow", "minecraft:sheep", "minecraft:chicken", "minecraft:frog", "minecraft:tadpole",
                    "minecraft:cod", "minecraft:salmon", "minecraft:tropical_fish", "minecraft:villager", "minecraft:wandering_trader",
                    "minecraft:squid", "minecraft:glow_squid", "minecraft:minecart",  "minecraft:chest_minecart", "minecraft:boat",
                    "minecraft:command_block_minecart", "minecraft:furnace_minecart", "minecraft:hopper_minecart", "minecraft:bee",
                    "minecraft:block_display", "minecraft:item_display", "minecraft:text_display", "minecraft:interaction", "minecraft:camel",
                    "minecraft:llama", "minecraft:trader_llama", "minecraft:allay", "minecraft:experience_orb", "minecraft:experience_bottle",
                    "minecraft:eye_of_ender", "minecraft:armadillo", "minecraft:pufferfish", "minecraft:cat", "minecraft:axolotl", "minecraft:wolf",
                    "minecraft:horse", "minecraft:donkey", "minecraft:mule", "minecraft:chest_boat", "minecraft:parrot"}
for i = 1, 14 do
    RingTextures[i] = textures:copy("RingTexture"..i,textures["HUDTextures.Full Circle"]):applyFunc(0, 0, 32, 32, function(_, x, y)
        if ((x - 15.5) ^ 2) + ((y - 15.5) ^ 2) <= i ^ 2 then return vec(0, 0, 0, 0) end
    end)
end
if lib.food.customValues then ActualSleepReq = lib.food.sleepRequirement else ActualSleepReq = 3 end
if lib.food.customValues then ActualMaxVal = lib.food.maxValue else ActualMaxVal = 10 end

local function isInList(Item, List)
    for _, Element in ipairs(List) do
        if Item == Element then return true end
    end
    return false
end

local function RemoveFromTable(item, table)
    for i, element in ipairs(table) do
        if item == element then return table.remove(table,i) end
    end
end

--get a 1x1 colour texture
local function Colour(rgba, textureName)
    return textures:newTexture(textureName,1,1):setPixel(0,0,rgba)
end

local function Parametric(radius, angle, origin)
    angle = math.map(angle, 0, 360, math.pi * 0.5, math.pi * 2.5)
    local x = origin.x + radius * -math.cos(angle)
    local y = origin.y + radius * math.sin(angle)
    return x, y
end

--wrap a number momento
local function wrap(number,min,max)
    local range = max - min
    while number < min do
      number = number + range
    end
    while number > max do
      number = number - range
    end
    return number
end

local RenderX = 40
local function RenderSeparator()
    Separator:newSprite("SepSprite"):setTexture(Colour(lib.food.barColour, "SeparatorColour")):setSize(2, 12)
    Separator:setPrimaryRenderType("EMISSIVE"):setPos(-8 - (RenderX), size.y + 41, 0):setVisible(lib.food.enabled)
    RenderX = RenderX + 14
end

local function RenderPips()
    for i = 1, ActualMaxVal do
        pips[i] = models.FoodBar:newPart("FoodPip"..i,"HUD"):setPrimaryRenderType("EMISSIVE"):setScale(0.75):setVisible(lib.food.enabled)
        for g = 1,3 do
                pips[i]:newSprite("QuarterSprite"..i.."-"..g):setTexture(textures["HUDTextures.Full Circle"], 5, 5):setDimensions(16,16):setRegion(8, 8):setUVPixels(8, 8):setColor(lib.food.quarterColour):setRot(0, 0, -90 * g - 90):setVisible(false)
        end
        pips[i]:newSprite("RingSprite"..i):setTexture(RingTextures[14], 16, 16):setColor(lib.food.ringColour):setPos(8, 8, 0)
        pips[i]:newSprite("PipSprite"..i):setTexture(textures["HUDTextures.Full Circle"], 10, 10):setColor(lib.food.pipColour):setPos(5, 5, 0):setVisible(false)
        pips[i]:setPos(-8 - (RenderX), size.y + 35, 0)
        if i == ActualSleepReq and ActualSleepReq > 0 then
            RenderX = RenderX + 12
            RenderSeparator()
        else
            RenderX = RenderX + 15
        end
    end
    if ActualFoodValue > 0 then
        for i = 1, math.floor(ActualFoodValue) do
            pips[i]:getTask("PipSprite"..i):setVisible(true)
        end
        local Quarters = (ActualFoodValue % 1) / 0.25
        if Quarters > 0 then for g = 1, Quarters do
            pips[math.floor(ActualFoodValue) + 1]:getTask("QuarterSprite"..(math.floor(ActualFoodValue + 1)).."-"..g):setVisible(true)
        end end
    end
end

local function RenderKarma()
    KarmaDisplay:removeTask()
    local KarmaUsed = lib.karma.customValues and lib.karma.value or VanillaKarma
    KarmaDisplay:setPos(-35, size.y + 35, 0):newSprite("KarmaRing"):setTexture(RingTextures[14], 32, 32):setColor(lib.karma.colour):setPos(16, 16, 0)
    if KarmaUsed > 4 and lib.karma.maxValue > 4 then
        KarmaDisplay:newSprite("KarmaFill"):setTexture(textures["HUDTextures.Karma"..KarmaUsed.."-"..lib.karma.maxValue], 32, 32):setColor(lib.karma.colour):setPos(16, 16, 0)
    else
        KarmaDisplay:newSprite("KarmaFill"):setTexture(textures["HUDTextures.Karma"..KarmaUsed], 32, 32):setColor(lib.karma.colour):setPos(16, 16, 0)
    end
    if KarmaReinforced then
        KarmaDisplay:newSprite("KarmaReinforce"):setTexture(textures["HUDTextures.KarmaReinforce"], 44, 44):setColor(lib.karma.colour):setPos(22, 22, 0)
    end
end

local function RenderRain()
    for _, pip in ipairs(RainPips) do
        pip:removeTask()
        pip:remove()
    end
    local ActualRainTime
    local ActualMaxTime
    if lib.rainTimer.customValues then
        ActualRainTime = lib.rainTimer.value
        ActualMaxTime = lib.rainTimer.maxValue
    else
        ActualRainTime = 12000 - world:getDayTime()
        ActualMaxTime = 12000
    end
    local MaxPips = ActualMaxTime / 1000
    if (player:getDimensionName() ~= "minecraft:the_nether") and (player:getDimensionName() ~= "minecraft:the_end") then
        if ActualRainTime <= 0 then return end
        for i = 1, math.floor(ActualRainTime / 1000) do
            local RainPipX, RainPipY = Parametric(KarmaReinforced and 26 or 20, (i - 1) * (360 / MaxPips), vec(-35, size.y + 35))
            RainPips[i] = models.RainTimer:newPart("RainPip"..i, "HUD"):setPos(RainPipX, RainPipY, 0)
            RainPips[i]:newSprite("RainPip"..i):setTexture(textures["HUDTextures.Full Circle"], 4, 4):setPos(2, 2, 0):setColor(lib.rainTimer.colour)
        end
        if math.floor(ActualRainTime / 1000) < ActualMaxTime / 1000 then
            local RainPipX, RainPipY = Parametric(KarmaReinforced and 26 or 20, math.floor(ActualRainTime / 1000) * (360 / MaxPips), vec(-35, size.y + 35))
            RainPips[math.floor(ActualRainTime / 1000) + 1] = models.RainTimer:newPart("RainPip"..math.floor(ActualRainTime / 1000) + 1, "HUD"):setPos(RainPipX, RainPipY, 0)
            RainPips[math.floor(ActualRainTime / 1000) + 1]:newSprite("RainPip"..math.floor(ActualRainTime / 1000) + 1):setTexture(RingTextures[10], 4, 4):setPos(2, 2, 0):setColor(lib.rainTimer.colour)
        end
    else
        for i = 1, MaxPips do
            local RainPipX, RainPipY = Parametric(KarmaReinforced and 26 or 20, (i - 1) * (360 / MaxPips), vec(-35, size.y + 35))
            RainPips[i] = models.RainTimer:newPart("RainPip"..i, "HUD"):setPos(RainPipX, RainPipY, 0)
            RainPips[i]:newSprite("RainPip"..i):setTexture(RingTextures[10], 4, 4):setPos(2, 2, 0):setColor(lib.rainTimer.colour)
        end
    end
end

local function UpdateBar()
    for _, pip in ipairs(pips) do
        pip:removeTask()
        pip:remove()
    end
    Separator:removeTask()
    Background:removeTask()
    pips = {}
    if player:isLoaded() then Gamemode = player:getGamemode() == "SURVIVAL" or player:getGamemode() == "ADVENTURE" or lib.food.customValues else Gamemode = lib.food.customValues end
    if Gamemode then
        if lib.food.customValues then ActualSleepReq = lib.food.sleepRequirement else ActualSleepReq = 3 end
        if lib.food.customValues then ActualMaxVal = lib.food.maxValue else ActualMaxVal = 10 end
        if (not lib.food.customValues) and player:isLoaded() then if player:getSaturation() == 0 then ExhaustionState = math.floor(wrap(player:getExhaustion()/2,0,2)) else ExhaustionState = 0 end else ExhaustionState = 0 end
        if lib.food.customValues then ActualFoodValue = lib.food.value else ActualFoodValue = player:getFood()/2 - ExhaustionState/4 end
        RenderX = KarmaReinforced and 64 or 58
        if ActualSleepReq == 0 then RenderX = RenderX - 3 RenderSeparator() end
        RenderPips()
    end
    for _, pip in ipairs(pips) do
        pip:setVisible(lib.food.enabled and Gamemode)
    end
end

local function RenderDangerBar()
    for _, pip in ipairs(DangerPips) do
        pip:removeTask()
        pip:remove()
    end
    DangerPips = {}
    if lib.dangerBar.customValues then TrueDangerValue = math.clamp(lib.dangerBar.value, 0, 5) end
    if TrueDangerValue > 0.05 then
        RenderX = ((size.x / 2) + math.ceil(TrueDangerValue) * 8) - 8
        for i = 1, math.floor(TrueDangerValue) do
            DangerPips[i] = models.DangerBar:newPart("DangerPip"..i,"HUD"):setPrimaryRenderType("EMISSIVE"):setScale(0.75):setVisible(lib.dangerBar.enabled):setPos(RenderX, size.y + 65, 0)
            DangerPips[i]:newSprite("DangerPipSprite"..i):setTexture(textures["HUDTextures.Full Circle"], 16, 16):setColor(lib.dangerBar.colour):setPos(DangerBarScale * 8, DangerBarScale * 8, 0):setScale(DangerBarScale, DangerBarScale, 1)
            RenderX = RenderX - 16
        end
        if TrueDangerValue < 5 then
            local LastPipScale = TrueDangerValue % 1
            DangerPips[math.floor(TrueDangerValue) + 1] = models.DangerBar:newPart("DangerPip"..math.floor(TrueDangerValue) + 1,"HUD"):setPrimaryRenderType("EMISSIVE"):setScale(0.75):setVisible(lib.dangerBar.enabled):setPos(RenderX, size.y + 65, 0)
            DangerPips[math.floor(TrueDangerValue) + 1]:newSprite("DangerPipSprite"..math.floor(TrueDangerValue) + 1):setTexture(RingTextures[math.round(math.map(LastPipScale, 0, 1, 14, 1))], 16, 16):setColor(lib.dangerBar.colour):setPos(DangerBarScale * 8, DangerBarScale * 8, 0):setScale(DangerBarScale, DangerBarScale, 1)
        end
    end
end

local function RenderAirBar()
    for _, pip in ipairs(AirPips) do
        pip:removeTask()
        pip:remove()
    end
    AirPips = {}
    local AirLevel = lib.airBar.customValues and math.map(lib.airBar.value, 0, lib.airBar.maxValue, 0, 5) or math.map(host:getAir(), 0, player:getMaxAir(), 0, 5)
    if AirLevel < 4.5 then
        RenderX = (size.x / 2) + 32
        for i = 1, 5 do
            AirPips[i] = models.AirBar:newPart("AirPip"..i,"HUD"):setPrimaryRenderType("EMISSIVE"):setScale(0.75):setVisible(lib.airBar.colour):setPos(RenderX, size.y + 80, 0)
            AirPips[i]:newSprite("AirRingSprite"..i):setTexture(RingTextures[14], 16, 16):setColor(lib.airBar.colour):setPos(8, 8, 0)
            if i < math.floor(AirLevel) + 1 then AirPips[i]:newSprite("AirPipSprite"..i):setTexture(textures["HUDTextures.Full Circle"], 16, 16):setColor(lib.airBar.colour):setPos(8, 8, 0) end
            RenderX = RenderX - 16
            if i == math.floor(AirLevel) + 1 then
                local LastPipScale = AirLevel % 1
                AirPips[i]:newSprite("AirPipSprite"..i):setTexture(RingTextures[math.round(math.map(LastPipScale, 0, 1, 14, 1))], 16, 16):setColor(lib.airBar.colour):setPos(8, 8, 0)
            end
        end
    end
end

local _health = 0
local _day = world.getDay()
function events.entity_init() 
  _health=player:getHealth()
  UpdateBar()
end

local function RenderTempBar()
    for _, pip in ipairs(TempPips) do
        pip:removeTask()
        pip:remove()
    end
    TempPips = {}
    if (1.9 > ActualTemp) or (ActualTemp > 2.1) then
        local UsedTemp = math.map(ActualTemp, 0, 4, 0, 20)
        RenderX = -64
        for i = 1, 10 do
            TempPips[i] = models.TempBar:newPart("TempPip"..i,"HUD"):setPrimaryRenderType("EMISSIVE"):setScale(0.75):setVisible(lib.tempBar.enabled):setPos(RenderX, size.y + 20, 0)
            if i > math.floor(UsedTemp) + 1 then TempPips[i]:newSprite("TempRing"..i):setTexture(RingTextures[14], 12, 12):setColor(lib.tempBar.colour):setPos(6, 6, 0) end
            if i < math.floor(UsedTemp) + 1 then TempPips[i]:newSprite("TempPipSprite"..i):setTexture(textures["HUDTextures.Full Circle"], 12, 12):setColor(lib.tempBar.colour):setPos(6, 6, 0) end
            if i < math.floor(UsedTemp) - 9 then TempPips[i]:getTask("TempPipSprite"..i):setColor(lib.tempBar.overheatingColour) end
            RenderX = RenderX - 12
            if i == math.floor(UsedTemp) + 1 then
                local LastPipScale = UsedTemp % 1
                TempPips[i]:newSprite("TempPipSprite"..i):setTexture(RingTextures[math.round(math.map(LastPipScale, 0, 1, 14, 1))], 12, 12):setColor(lib.tempBar.colour):setPos(6, 6, 0)
            end
            if i == math.floor(UsedTemp) - 9 then
                local LastPipScale = UsedTemp % 1
                TempPips[i]:getTask("TempPipSprite"..i):setColor(math.lerp(lib.tempBar.colour.xyz, lib.tempBar.overheatingColour.xyz, LastPipScale))
            end
        end
    end
end

function events.tick()
    if not lib.karma.customValues then
        local health = player:getHealth()
        if health < _health then
            if health <= 0 then
              VanillaKarma = math.clamp(VanillaKarma - 1, 0, lib.karma.maxValue)
              config:save("karmaValue", VanillaKarma)
            end
        end
        if _day < world.getDay() then
            VanillaKarma = math.clamp(VanillaKarma + 1, 0, lib.karma.maxValue)
            config:save("karmaValue", VanillaKarma)
        end
        _health = health
        _day = world.getDay()
    end
    if lib.karma.customValues then KarmaReinforced = lib.karma.reinforced else KarmaReinforced = (player:getHeldItem(false).id == "minecraft:totem_of_undying") or (player:getHeldItem(true).id == "minecraft:totem_of_undying") end

    size = -client:getScaledWindowSize()
    if (player:getSaturation() == 0) and (not lib.food.customValues) then ExhaustionState = math.floor(wrap(player:getExhaustion()/2,0,2)) else ExhaustionState = 0 end
    UpdateBar()

    local DangerValue = 0
    local PlayerPos = player:getPos()
    for _, entity in ipairs(world.getEntities(PlayerPos.x - 10, PlayerPos.y - 10, PlayerPos.z - 10, PlayerPos.x + 10, PlayerPos.y + 10, PlayerPos.z + 10)) do
        if not isInList(entity:getType(), bannedMobs) then
            if entity:getNbt()["Owner"] ~= nil then
                local PlayerUUIDInt = {client:uuidToIntArray(player:getUUID())}
                local EntityOwner = entity:getNbt()["Owner"]
                local OwnerIsPlayer = PlayerUUIDInt[1] == EntityOwner[1] and PlayerUUIDInt[2] == EntityOwner[2] and PlayerUUIDInt[3] == EntityOwner[3] and PlayerUUIDInt[4] == EntityOwner[4]
                if (not OwnerIsPlayer) and (entity:getNbt()["inGround"] == 0 or entity:getNbt()["inGround"] == nil) then
                    local DistanceToMob = PlayerPos:sub(entity:getPos()):clampLength(0, 25):length()
                    TrueDangerValue = TrueDangerValue + (1 / math.clamp(DistanceToMob, 1, 25))
                end
            else
                local DistanceToMob = PlayerPos:sub(entity:getPos()):clampLength(0, 25):length()
                DangerValue = DangerValue + math.clamp((3 - (DistanceToMob/10)), 0, 3)
            end
        end
    end

    if lib.tempBar.enabled then
        if (not lib.tempBar.customValues) and client:isModLoaded("toughasnails") then
            local targetTemp = player:getNbt()["temperatureLevel"]
            ActualTemp = math.lerp(ActualTemp, targetTemp, 0.01)
        else
            ActualTemp = lib.tempBar.value
        end
        RenderTempBar()
    else
        for _, pip in ipairs(TempPips) do
            pip:removeTask()
            pip:remove()
        end
    end

    if lib.dangerBar.enabled then
        if not lib.dangerBar.customValues then
            if TrueDangerValue > DangerValue then TrueDangerValue = TrueDangerValue * 0.995 end
            if TrueDangerValue < DangerValue then TrueDangerValue = TrueDangerValue + ((DangerValue - TrueDangerValue) * 0.05) end
            TrueDangerValue = math.clamp(TrueDangerValue, 0, 5)
        else TrueDangerValue = lib.dangerBar.value end
        DangerBarTick = DangerBarTick + 1
        if DangerBarTick >= 50 / TrueDangerValue then
            DangerBarScale = 1.25
            DangerBarTick = 1
        end
        RenderDangerBar()
        DangerBarScale = DangerBarScale - (TrueDangerValue / 100)
        DangerBarScale = math.clamp(DangerBarScale, 1, 1.25)
    else
        for _, pip in ipairs(DangerPips) do
            pip:removeTask()
        end
        DangerPips = {}
    end

    if lib.airBar.enabled then
        RenderAirBar()
    else
        for _, pip in ipairs(AirPips) do
            pip:removeTask()
        end
        AirPips = {}
    end

    if lib.karma.enabled then
        RenderKarma()
    else
        KarmaDisplay:removeTask()
    end

    if lib.rainTimer.enabled then
        RenderRain()
    else
        for _, pip in ipairs(RainPips) do
            pip:removeTask()
            pip:remove()
        end
    end

    if lib.food.customValues then ActualFoodValue = lib.food.value else ActualFoodValue = player:getFood()/2 - ExhaustionState/4 end
    Gamemode = player:getGamemode() == "SURVIVAL" or player:getGamemode() == "ADVENTURE" or lib.food.customValues
end

function lib:setFoodEnabled(bool)
    lib.food.enabled = bool
    UpdateBar()
    return self
end
function lib:setFoodRingColour(col)
    lib.food.ringColour = col
    UpdateBar()
    return self
end
function lib:setFoodPipColour(col)
    lib.food.pipColour = col
    UpdateBar()
    return self
end
function lib:setFoodSeperatorColour(col)
    lib.food.barColour = col
    UpdateBar()
    return self
end
function lib:setFoodQuarterColour(col)
    lib.food.quarterColour = col
    UpdateBar()
    return self
end
function lib:setFoodSleepReq(num)
    lib.food.sleepRequirement = math.clamp(num, 0, lib.food.maxValue)
    UpdateBar()
    return self
end
function lib:setFoodValue(num)
    lib.food.value = math.clamp(num, 0, lib.food.maxValue)
    UpdateBar()
    return self
end
function lib:setFoodMaxValue(num)
    lib.food.maxValue = math.max(1, num)
    lib:setFoodValue(math.min(lib.food.value, lib.food.maxValue)):setFoodSleepReq(math.min(lib.food.sleepRequirement, lib.food.maxValue))
    return self
end
function lib:setFoodIsCustom(bool)
    lib.food.customValues = bool
    UpdateBar()
    return self
end

function lib:setKarmaEnabled(bool)
    lib.karma.enabled = bool
    return self
end
function lib:setKarmaColour(col)
    lib.karma.colour = col
    return self
end
function lib:setKarmaValue(num)
    lib.karma.value = math.clamp(num, 0, lib.karma.maxValue)
    config:save("karmaValue", math.clamp(num, 0, lib.karma.maxValue))
    return self
end
function lib:setKarmaMaxValue(num)
    lib.karma.maxValue = math.clamp(num, 0, 9)
    lib:setKarmaValue(math.min(lib.karma.value, lib.karma.maxValue))
    return self
end
function lib:setKarmaReinforced(bool)
    lib.karma.reinforced = bool
    return self
end
function lib:setKarmaIsCustom(bool)
    lib.karma.customValues = bool
    return self
end

function lib:setRainTimerEnabled(bool)
    lib.rainTimer.enabled = bool
    return self
end
function lib:setRainTimerIsCustom(bool)
    lib.rainTimer.customValues = bool
    return self
end
function lib:setRainTimerColour(col)
    lib.rainTimer.colour = col
    return self
end
function lib:setRainTimerValue(num)
    lib.rainTimer.value = math.clamp(num, 0, lib.rainTimer.maxValue)
    return self
end
function lib:setRainTimerMaxValue(num)
    lib.rainTimer.maxValue = num
    lib:setRainTimerValue(math.min(lib.rainTimer.value, lib.rainTimer.maxValue))
    return self
end

function lib:setDangerBarEnabled(bool)
    lib.dangerBar.enabled = bool
    return self
end
function lib:setDangerBarIsCustom(bool)
    lib.dangerBar.customValues = bool
    return self
end
function lib:setDangerBarColour(col)
    lib.dangerBar.colour = col
    return self
end
function lib:setDangerBarValue(num)
    lib.dangerBar.value = math.clamp(num, 0, 5)
    return self
end

function lib:setAirBarEnabled(bool)
    lib.airBar.enabled = bool
    return self
end
function lib:setAirBarIsCustom(bool)
    lib.airBar.customValues = bool
    return self
end
function lib:setAirBarColour(col)
    lib.airBar.colour = col
    return self
end
function lib:setAirBarValue(num)
    lib.airBar.value = math.clamp(num, 0, lib.airBar.maxValue)
    return self
end
function lib:setAirBarMaxValue(num)
    lib.airBar.maxValue = num
    lib:setAirBarValue(math.min(lib.airBar.value, lib.airBar.maxValue))
    return self
end

function lib:setTemperatureEnabled(bool)
    lib.tempBar.enabled = bool
    return self
end
function lib:setTemperatureIsCustom(bool)
    lib.tempBar.customValues = bool
    return self
end
function lib:setTemperatureColour(col)
    lib.tempBar.colour = col
    return self
end
function lib:setTemperatureOverheatColour(col)
    lib.tempBar.overheatingColour = col
    return self
end
function lib:setTemperatureValue(num)
    lib.tempBar.value = math.clamp(num, 0, 4)
    return self
end

function lib:saveConfig()
    config:save("AllConfig", lib)
    return self
end
function lib:loadConfig()
    lib = config:load("AllConfig")
    return self
end

return lib