diff --git a/mods/CORE/ProcessingStation/src/ProcessingStation.lua b/mods/CORE/ProcessingStation/src/ProcessingStation.lua index 409d786..04c9c2c 100644 --- a/mods/CORE/ProcessingStation/src/ProcessingStation.lua +++ b/mods/CORE/ProcessingStation/src/ProcessingStation.lua @@ -1,4 +1,4 @@ -local FUEL_ENERGY_FACTOR = 10 +local FUEL_ENERGY_FACTOR = 0.1 local getInstance = Class.getInstance @@ -21,6 +21,7 @@ local ProcessingStationNode = Node:getExtended({ ---@field name string ---@field timeout number ---@field enableRegression boolean? +---@field enableIdling boolean? ---@field craftType CraftSystem.ProcessingCraftType ---@field fuelGroup string ---@field inputSlots integer @@ -38,6 +39,7 @@ local ProcessingStation = {} ---@class ProcessingStationDef ---@field timeout number? ---@field enableRegression boolean? +---@field enableIdling boolean? ---@field craftType CraftSystem.ProcessingCraftType ---@field fuelGroup string? ---@field inputSlots integer? @@ -45,11 +47,12 @@ local ProcessingStation = {} ---@field fuelSlots integer? ---@field tab PlayerInventoryUI.getTabFunc ----@param name string ----@param def ProcessingStationDef ----@param nodeDef Node.NodeDefinition ----@param activeNodeDef Node.NodeDefinition? -function ProcessingStation:new(name, def, nodeDef, activeNodeDef) +---@alias ProcessingStation.NodesDef {settings:Node.Settings, activeSettings?:Node.Settings, callbacks:Node.Callbacks?} + +---@param name string +---@param def ProcessingStationDef +---@param nodesDef ProcessingStation.NodesDef +function ProcessingStation:new(name, def, nodesDef) local handler = CraftSystem:getProcessingCraftHandler(def.craftType) ---@type ProcessingStation @@ -57,6 +60,7 @@ function ProcessingStation:new(name, def, nodeDef, activeNodeDef) instance.name = name instance.timeout = def.timeout or 1 instance.enableRegression = def.enableRegression + instance.enableIdling = def.enableIdling instance.craftType = def.craftType instance.fuelGroup = def.fuelGroup or 'fuel' instance.inputSlots = def.inputSlots or 1 @@ -65,212 +69,249 @@ function ProcessingStation:new(name, def, nodeDef, activeNodeDef) instance.handler = handler instance.tab = def.tab - if nodeDef.callbacks == nil then - ---@type Node.Callbacks - nodeDef.callbacks = {} - end - local settings = nodeDef.settings - local callbacks = nodeDef.callbacks + local settings = nodesDef.settings + local activeSettings = nodesDef.activeSettings + local callbacks = nodesDef.callbacks or {} + local oldCallback = callbacks.on_construct or function(...) end -- When we install a station in the world, -- we initialize the metadata, set the inventory size, and start the timer. callbacks.on_construct = function(pos) - local meta = core.get_meta(pos) - meta:set_float('remaining_fuel', 0.0) - meta:set_float('processing_time', 0.0) + oldCallback(pos) - local inventory = meta:get_inventory() - inventory:set_size('input', instance.inputSlots) - inventory:set_size('output', instance.outputSlots) - inventory:set_size('fuel', instance.fuelSlots) - - core.get_node_timer(pos):start(instance.timeout) + instance:init(pos) end + oldCallback = callbacks.on_rightclick or function(...) end -- Right-clicking on a station opens the player's inventory, adding context to the station tab. -- Note: we do not use formspec via node metadata. callbacks.on_rightclick = function(pos, node, clicker, itemstack, pointed_thing) - local playerName = clicker:get_player_name() - PlayerInventoryUI:setContex(playerName, 'left_tab_name', 'node_tab') - PlayerInventoryUI:setContex(playerName, 'node_tab_pos', pos) - PlayerInventoryUI:setContex(playerName, 'node_tab', instance.tab) - PlayerInventoryUI:showForm(playerName) + oldCallback(pos, node, clicker, itemstack, pointed_thing) + + instance:showForm(pos, clicker) end + oldCallback = callbacks.on_metadata_inventory_move or function(...) end -- Whenever we change items, we start the station timer, -- because it can be stopped (if the crafting or fuel runs out). callbacks.on_metadata_inventory_move = function(pos, from_list, from_index, to_list, to_index, count, player) - local timer = core.get_node_timer(pos) - if not timer:is_started() then - timer:start(instance.timeout) - end + oldCallback(pos, from_list, from_index, to_list, to_index, count, player) + + instance:startTimer(pos) end + oldCallback = callbacks.on_metadata_inventory_put or function(...) end callbacks.on_metadata_inventory_put = function(pos, listname, index, stack, player) - local timer = core.get_node_timer(pos) - if not timer:is_started() then - timer:start(instance.timeout) - end + oldCallback(pos, listname, index, stack, player) + + instance:startTimer(pos) end + oldCallback = callbacks.on_metadata_inventory_take or function(...) end callbacks.on_metadata_inventory_take = function(pos, listname, index, stack, player) - local timer = core.get_node_timer(pos) - if not timer:is_started() then - timer:start(instance.timeout) - end + oldCallback(pos, listname, index, stack, player) + + instance:startTimer(pos) end + oldCallback = callbacks.on_timer or function(...) end -- The basic logic of the station's work. callbacks.on_timer = function(pos, elapsed, node, timeout) - ---An indicator of whether the station - ---is processing resources in this iteration. - local isProcessing = true + oldCallback(pos, elapsed, node, timeout) - ---@type ProcessingStation.MetaData - local meta = core.get_meta(pos) - local inventory = meta:get_inventory() - - ---An indicator of how many units of fuel are currently remaining. - local remainingFuel = meta:get_float('remaining_fuel') - ---An indicator of how long the station has been processing the materials. - local processingTime = meta:get_float('processing_time') - - local craft = handler:getCraftByRecipe(inventory:get_list('input')) - - -- If the materials in the input slot are not a recipe for any crafting, - -- then we will not process them. - if craft == nil then - isProcessing = false - end - - -- If there is no space in the output slots for the crafting result, then we stop processing. - if isProcessing and craft ~= nil and not inventory:room_for_item('output', craft.output) then - isProcessing = false - end - - -- If we are in the process of processing and we run out of fuel, - -- but there are still items in the fuel slot... - if isProcessing and remainingFuel <= 0 and not inventory:is_empty('fuel') then - -- ... then we will convert the first itemstack into station fuel - -- if it has the required fuel group. - local fuelList = inventory:get_list('fuel') - for index, fuelStack in ipairs(fuelList) do - if not fuelStack:is_empty() then - ---Fuel units contained in the itemstack. - --- - -- Note: since item groups can only contain integers, - -- we divide the fuel units by a constant to convert seconds to smaller units. - local fuelEnergy = core.get_item_group(fuelStack:get_name(), instance.fuelGroup or 'fuel') / FUEL_ENERGY_FACTOR - if fuelEnergy > 0 then - local itemCount = fuelStack:get_count() - - -- If the energy of one item is not enough for one iteration, - -- we calculate how many items we need to take - if fuelEnergy < timeout then - itemCount = math.min(math.ceil(timeout/fuelEnergy), itemCount) - else - itemCount = 1 - end - - remainingFuel = remainingFuel + (fuelEnergy * itemCount) - - fuelStack:set_count(itemCount) - inventory:remove_item('fuel', fuelStack) - end - end - end - end - - -- If we have fuel remaining, - -- we subtract units for this iteration. - if remainingFuel >= 0 then - remainingFuel = remainingFuel - timeout - end - - -- If we don't have fuel remaining, - -- we don't process the materials. - if remainingFuel < 0 then - remainingFuel = 0 - isProcessing = false - end - - -- If we process materials... - if isProcessing == true then - -- ...then we add the processing progress for this iteration. - processingTime = processingTime + timeout - else - -- ...else we take away progress - -- (if there was progress, but the fuel ran out, - -- the crafting progress will gradually decrease). - if instance.enableRegression then - processingTime = processingTime - timeout - end - end - - -- If the station is working and the progress time is longer than required for crafting, we produce the craft - -- (we take the item stacks needed for crafting and put the result of the crafting into the output) - if isProcessing and craft ~= nil and processingTime >= craft.time then - for _, item in ipairs(craft.recipe) do - inventory:remove_item('input', item) - end - - inventory:add_item('output', craft.output) - processingTime = 0 - end - - if processingTime < 0 then - processingTime = 0 - end - - meta:set_float('processing_time', processingTime) - meta:set_float('remaining_fuel', remainingFuel) - - PlayerInventoryUI:updateNodeForm(pos) - - -- If the processing is in progress and the station has an active node type, then we use it. - if instance.activeNodeName ~= nil then - if isProcessing then - core.swap_node(pos, {name = instance.activeNodeName}) - else - core.swap_node(pos, {name = instance.nodeName}) - end - end - - -- If we not processing and processing time is zero - -- we stop the timer so as not to overload the server. - -- - -- The timer will have to start again - -- if the player interacts with any items in the station's inventory. - if not isProcessing and processingTime == 0 then - return false - else - return true - end + return instance:onTimer(pos, elapsed, node, timeout) end -- Registering a nodes for Luanti. - local node = ProcessingStationNode:new(nodeDef) + local node = ProcessingStationNode:new({ settings = settings, callbacks = callbacks }) instance.nodeName = node.itemDef.settings.name - if activeNodeDef ~= nil then - if activeNodeDef.callbacks == nil then - activeNodeDef.callbacks = {} - end - local activeNodeCallbacks = activeNodeDef.callbacks - activeNodeCallbacks.on_construct = callbacks.on_construct - activeNodeCallbacks.on_rightclick = callbacks.on_rightclick - activeNodeCallbacks.on_metadata_inventory_move = callbacks.on_metadata_inventory_move - activeNodeCallbacks.on_metadata_inventory_put = callbacks.on_metadata_inventory_put - activeNodeCallbacks.on_metadata_inventory_take = callbacks.on_metadata_inventory_take - activeNodeCallbacks.on_timer = callbacks.on_timer - - local activeNode = ProcessingStationNode:new(activeNodeDef) + if activeSettings ~= nil then + local activeNode = ProcessingStationNode:new({ settings = activeSettings, callbacks = callbacks }) instance.activeNodeName = activeNode.itemDef.settings.name end return instance end +---Opens the player's inventory, adding the tab described in `self.tab`. +---@param pos MapPosition +---@param player Player +function ProcessingStation:showForm(pos, player) + local playerName = player:get_player_name() + + PlayerInventoryUI:addActiveNodeForm(pos, playerName) + PlayerInventoryUI:setContex(playerName, 'left_tab_name', 'node_tab') + PlayerInventoryUI:setContex(playerName, 'node_tab_pos', pos) + PlayerInventoryUI:setContex(playerName, 'node_tab', self.tab) + + PlayerInventoryUI:showForm(playerName) +end + +---@param pos MapPosition +function ProcessingStation:init(pos) + local meta = core.get_meta(pos) + meta:set_float('remaining_fuel', 0.0) + meta:set_float('processing_time', 0.0) + + local inventory = meta:get_inventory() + inventory:set_size('input', self.inputSlots) + inventory:set_size('output', self.outputSlots) + inventory:set_size('fuel', self.fuelSlots) + + self:startTimer(pos) +end + +---Starts the station timer only if it is not running. +--- +---The timer timeout is set to the timeout specified `self.timeout`. +--- +---Returns `true` if the timer has been started. +---@param pos MapPosition +---@return boolean +function ProcessingStation:startTimer(pos) + local timer = core.get_node_timer(pos) + if not timer:is_started() then + timer:start(self.timeout) + return true + end + + return false +end + +---@param pos MapPosition +---@param elapsed number +---@param node NodeTable +---@param timeout number +---@return boolean +function ProcessingStation:onTimer(pos, elapsed, node, timeout) + ---An indicator of whether the station + ---is processing resources in this iteration. + local isProcessing = true + + ---@type ProcessingStation.MetaData + local meta = core.get_meta(pos) + local inventory = meta:get_inventory() + + ---An indicator of how many units of fuel are currently remaining. + local remainingFuel = meta:get_float('remaining_fuel') + ---An indicator of how long the station has been processing the materials. + local processingTime = meta:get_float('processing_time') + + local craft = self.handler:getCraftByRecipe(inventory:get_list('input')) + + -- If the materials in the input slot are not a recipe for any crafting, + -- then we will not process them. + if craft == nil then + isProcessing = false + end + + -- If there is no space in the output slots for the crafting result, then we stop processing. + if isProcessing and craft ~= nil and not inventory:room_for_item('output', craft.output) then + isProcessing = false + end + + -- If we are in the process of processing and we run out of fuel, + -- but there are still items in the fuel slot... + if isProcessing and remainingFuel <= 0 and not inventory:is_empty('fuel') then + -- ... then we will convert the first itemstack into station fuel + -- if it has the required fuel group. + local fuelList = inventory:get_list('fuel') + for index, fuelStack in ipairs(fuelList) do + if not fuelStack:is_empty() then + ---Fuel units contained in the itemstack. + --- + -- Note: since item groups can only contain integers, + -- we divide the fuel units by a constant to convert seconds to smaller units. + local fuelEnergy = core.get_item_group(fuelStack:get_name(), self.fuelGroup or 'fuel') / FUEL_ENERGY_FACTOR + if fuelEnergy > 0 then + local itemCount = fuelStack:get_count() + + -- If the energy of one item is not enough for one iteration, + -- we calculate how many items we need to take + if fuelEnergy < timeout then + itemCount = math.min(math.ceil(timeout/fuelEnergy), itemCount) + else + itemCount = 1 + end + + remainingFuel = remainingFuel + (fuelEnergy * itemCount) + + fuelStack:set_count(itemCount) + inventory:remove_item('fuel', fuelStack) + end + end + end + end + + if self.enableIdling and isProcessing then + remainingFuel = remainingFuel - timeout + else + remainingFuel = remainingFuel - timeout + end + + -- If we don't have fuel remaining, + -- we don't process the materials. + if remainingFuel < 0 then + remainingFuel = 0 + isProcessing = false + end + + -- If we process materials... + if isProcessing == true then + -- ...then we add the processing progress for this iteration. + processingTime = processingTime + timeout + else + -- ...else we take away progress + -- (if there was progress, but the fuel ran out, + -- the crafting progress will gradually decrease). + if self.enableRegression then + processingTime = processingTime - timeout + end + end + + -- If the station is working and the progress time is longer than required for crafting, we produce the craft + -- (we take the item stacks needed for crafting and put the result of the crafting into the output) + if isProcessing and craft ~= nil and processingTime >= craft.time then + for _, item in ipairs(craft.recipe) do + inventory:remove_item('input', item) + end + + inventory:add_item('output', craft.output) + processingTime = 0 + end + + if processingTime < 0 then + processingTime = 0 + end + + -- If the processing is in progress and the station has an active node type, then we use it. + if self.activeNodeName ~= nil then + if isProcessing then + core.swap_node(pos, {name = self.activeNodeName}) + else + core.swap_node(pos, {name = self.nodeName}) + end + end + + meta:set_float('processing_time', processingTime) + meta:set_float('remaining_fuel', remainingFuel) + + PlayerInventoryUI:updateNodeForm(pos) + + -- If we not processing we stop the timer so as not to overload the server. + -- + -- The timer will have to start again + -- if the player interacts with any items in the station's inventory. + if not isProcessing and (not self.enableRegression or processingTime == 0) and (not self.enableIdling or remainingFuel == 0) then + core.log('timer stop') + return false + else + core.log('timer work') + return true + end +end + --- DEBUG --- local Formspec = Smc.requireFormspec() @@ -311,7 +352,9 @@ ProcessingStation:new('test_processing_node', { craftType = 'test', tab = tab, inputSlots = 2, - fuelGroup = 'wood' + fuelGroup = 'wood', + enableIdling = true, + enableRegression = false, }, { settings = { @@ -324,10 +367,8 @@ ProcessingStation:new('test_processing_node', { tileSheet:t(0, 2), tileSheet:t(0, 2) } - } -}, -{ - settings = { + }, + activeSettings = { name = 'test_processing_node_active', tiles = { tileSheet:t(0, 0),