2,875
edits
m (Replace Shared module with Number module) |
(Apply sandbox changes) |
||
Line 3: | Line 3: | ||
local p = {} | local p = {} | ||
-- | local ItemEconomy = { | ||
-- | -- Amount of items required per action. | ||
-- | inputsPerAction, | ||
-- | -- Amount of items created per action. (ie. 3 bolts per action). | ||
-- | outputsPerAction, | ||
-- | -- The chance from 0 to 80 to preserve resources. | ||
preservationChance, | |||
-- | -- The chance from 0 to 100 to duplicate the crafting output. | ||
duplicationChance, | |||
-- The chance from 0 to 100 to get extra output items (not doubled). | |||
extraItemChance, | |||
-- The amount of extra items received, when the extraItemChance is rolled. | |||
extraItemAmount, | |||
-- The amount of extra items always received per action (not doubled). | |||
flatExtraItems, | |||
-- The chance to get extra base items (can be doubled). | |||
extraBaseItemChance, | |||
-- The amount of extra base items received. | |||
extraBaseItems | |||
} | |||
--- Constructor function for creating new ItemEconomy instances. | |||
-- @return ItemEconomy An instance of the ItemEconomy class. | |||
function ItemEconomy:new() | |||
local | local newObj = {} | ||
local | self.__index = self | ||
return setmetatable(newObj, self) | |||
end | |||
--- Verifies and updates the economy values of the ItemEconomy instance. | |||
-- If any economy value is nil, it sets a default value. | |||
-- If any economy value is out of range, clamp it to the nearest valid range. | |||
-- @return ItemEconomy Returns a verified copy of the ItemEconomy object. | |||
function ItemEconomy:getVerifiedEconomy() | |||
local cpy = {} | |||
-- Set default values if some are nil | |||
cpy.inputsPerAction = self.inputsPerAction or 1 | |||
cpy.outputsPerAction = self.outputsPerAction or 1 | |||
cpy.preservationChance = self.preservationChance or 0 | |||
cpy.duplicationChance = self.duplicationChance or 0 | |||
cpy.extraItemChance = self.extraItemChance or 0 | |||
cpy.extraItemAmount = self.extraItemAmount or 0 | |||
cpy.flatExtraItems = self.flatExtraItems or 0 | |||
cpy.extraBaseItemChance = self.extraBaseItemChance or 0 | |||
cpy.extraBaseItems = self.extraBaseItems or 0 | |||
local totalActions = | -- Clamp economy values (clamp the verified copy values) | ||
cpy.preservationChanceP = number.clamp(cpy.preservationChance, 0, 80) / 100 | |||
cpy.duplicationChanceP = number.clamp(cpy.duplicationChance, 0, 100) / 100 | |||
cpy.extraItemChanceP = number.clamp(cpy.extraItemChance, 0, 100) / 100 | |||
cpy.extraBaseItemChanceP = number.clamp(cpy.extraBaseItemChance, 0, 100) / 100 | |||
return setmetatable(cpy, getmetatable(self)) | |||
end | |||
--- Calculates a ratio between input to output. | |||
-- @param itemEconomy (table) The ItemEconomy object containing ItemEconomy values. | |||
-- @return (number) The output ratio of the crafting process. | |||
function p.estimatedOutputMultiplier(itemEconomy) | |||
local minOutput = p.estimatedOutput(nil, itemEconomy) | |||
return minOutput / itemEconomy.inputsPerAction | |||
end | |||
--- Estimates the output of a crafting process based on input and ItemEconomy values. | |||
-- @param inputAmount (number) The total amount of input items available for crafting. | |||
-- @param itemEconomy (table) The ItemEconomy object containing ItemEconomy values. | |||
-- @return (number) The estimated output of the crafting process. | |||
function p.estimatedOutput(inputAmount, itemEconomy) | |||
local eco = itemEconomy:getVerifiedEconomy() | |||
-- Equal inputAmount to inputsPerAction to get 1 baseAction | |||
inputAmount = inputAmount or eco.inputsPerAction | |||
local baseActions = inputAmount / eco.inputsPerAction | |||
-- Can't craft with what you don't have... | |||
if inputAmount < eco.inputsPerAction then | |||
return 0 | |||
end | |||
-- Calculate the effective actions taken. | |||
local totalActions = baseActions / (1 - eco.preservationChanceP) | |||
-- Calculates extra items that can't be doubled. | |||
local extraItems = (totalActions * eco.extraItemChanceP * eco.extraItemAmount) + (totalActions * eco.flatExtraItems) | |||
-- Calculates extra items that CAN be doubled. | |||
local baseItems = (eco.outputsPerAction + eco.extraBaseItemChanceP * eco.extraBaseItems) | |||
-- Total output | |||
return (totalActions * baseItems * (1 + eco.duplicationChanceP)) + extraItems | |||
end | |||
--- Calculates a ratio between output to input. | |||
-- @param itemEconomy (table) The ItemEconomy object containing ItemEconomy values. | |||
-- @return (number) The input ratio of the crafting process. | |||
function p.estimatedInputMultiplier(itemEconomy) | |||
-- I'm fairly certain that the following holds true in any case. | |||
return 1 / p.estimatedOutputMultiplier(itemEconomy) | |||
end | end | ||
- | --- Estimates the input required for a given output amount in a crafting process based on ItemEconomy values. | ||
-- | -- This function provides a detailed breakdown of the calculation process. | ||
-- | -- @param outputAmount The total amount of output items desired. | ||
-- | -- @param itemEconomy The ItemEconomy object containing ItemEconomy values. | ||
-- | -- @return The estimated input required for the given output amount. | ||
-- | function p.estimatedInput(outputAmount, itemEconomy) | ||
function p.estimatedInput(outputAmount, | -- Again, fairly certain Input is just 1 / Output. | ||
-- | -- Replace with p.estimatedInputVerbose is this ever isn't the case. | ||
local inputMultiplier = 1 / p.estimatedOutputMultiplier(itemEconomy) | |||
return math.max(outputAmount * inputMultiplier, itemEconomy.inputsPerAction) | |||
end | |||
function p.estimatedInputVerbose(outputAmount, itemEconomy) | |||
local eco = itemEconomy:getVerifiedEconomy() | |||
outputAmount = outputAmount or eco.outputsPerAction | |||
local preserveAmount = outputAmount * eco.inputsPerAction * (1 - eco.preservationChanceP) | |||
local duplicateAmount = eco.outputsPerAction + eco.outputsPerAction * eco.duplicationChanceP | |||
local extraBaseItems = eco.extraBaseItemChanceP * eco.extraBaseItems + eco.extraBaseItemChanceP * eco.extraBaseItems * eco.duplicationChanceP | |||
local extraItems = eco.extraItemChanceP * eco.extraItemAmount | |||
-- Total input required for given output. | |||
local actualInput = preserveAmount / (duplicateAmount + extraBaseItems + extraItems + eco.flatExtraItems) | |||
return math.max(actualInput, eco.inputsPerAction) | |||
end | end | ||
- | --- Calculates if equipping the Ring Of Wealth will result in more items for the player. | ||
-- Calculates if equipping the Ring Of Wealth will result in more items for the player. | -- @param itemEconomy The ItemEconomy object containing ItemEconomy values. | ||
-- | -- @return TRUE if the Ring of Wealth is more beneficial than harmful. | ||
function p.ringOfWealthHasEffect(itemEconomy) | |||
local rowEco = itemEconomy:getVerifiedEconomy() | |||
-- | |||
function p.ringOfWealthHasEffect( | -- Apply Ring of Wealth buffs. | ||
-- | rowEco.preservationChance = rowEco.preservationChance - 3 | ||
rowEco.duplicationChance = rowEco.duplicationChance + 7 | |||
local | local rowMultiplier = p.estimatedOutputMultiplier(rowEco) | ||
local playerMultiplier = p.estimatedOutputMultiplier(itemEconomy) | |||
local | |||
return | return rowMultiplier > playerMultiplier | ||
end | end | ||
p.ItemEconomy = ItemEconomy | |||
return p | return p |
edits