From 9c56db6ac44e0fbccf53b7b103dd8492fdb093d2 Mon Sep 17 00:00:00 2001 From: Vanic Date: Fri, 13 Feb 2026 21:09:55 +0300 Subject: [PATCH] `CtaftSystem`: Bringing the system into order, adding annotations and comments, eliminating major bugs --- mods/CORE/CraftSystem/src/CraftSystem.lua | 6 +- .../src/CraftSystem/BaseCraftHandler.lua | 2 + .../src/CraftSystem/ImmersiveCraft.lua | 104 ++++++++++++-- .../src/CraftSystem/ImmersiveCraftHandler.lua | 17 ++- ...veCraftNode.lua => ImmersiveCraftNode.lua} | 7 +- .../ImmersiveCraftNode/TapperNode.lua | 12 -- .../ImmersiveCraftNode/tappingNode.lua | 78 ++++++++++ .../src/CraftSystem/ImmersiveCraftStage.lua | 43 +++--- .../ImmersiveCraftStage/Tapping.lua | 38 ----- .../ImmersiveCraftStage/TappingStage.lua | 133 ++++++++++++++++++ .../src/CraftSystem/PrimitiveCraft.lua | 1 + .../src/CraftSystem/PrimitiveCraftHandler.lua | 5 +- 12 files changed, 354 insertions(+), 92 deletions(-) rename mods/CORE/CraftSystem/src/CraftSystem/{immersiveCraftNode.lua => ImmersiveCraftNode.lua} (59%) delete mode 100644 mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftNode/TapperNode.lua create mode 100644 mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftNode/tappingNode.lua delete mode 100644 mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftStage/Tapping.lua create mode 100644 mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftStage/TappingStage.lua diff --git a/mods/CORE/CraftSystem/src/CraftSystem.lua b/mods/CORE/CraftSystem/src/CraftSystem.lua index a8691ea..01ae6f9 100644 --- a/mods/CORE/CraftSystem/src/CraftSystem.lua +++ b/mods/CORE/CraftSystem/src/CraftSystem.lua @@ -5,8 +5,6 @@ local require = modInfo.require local PrimitiveCraftHandler = require('CraftSystem.PrimitiveCraftHandler') ---@type CraftSystem.ImmersiveCraftHandler local ImmersiveCraftHandler= require('CraftSystem.ImmersiveCraftHandler') ----@type CraftSystem.ImmersiveCraftNode -local ImmersiveCraftNode= require('CraftSystem.ImmersiveCraftNode') ---@alias CraftSystem.CraftGroup string ---@alias CraftSystem.CraftRecipe string[] @@ -18,13 +16,13 @@ local CraftSystem = {} ---@param craftName string ---@param def CraftSystem.PrimitiveCraftDef function CraftSystem.registerPrimitiveCraft(craftName, def) - PrimitiveCraftHandler:addCraft(craftName, def) + PrimitiveCraftHandler:registerCraft(craftName, def) end ---@param craftName string ---@param def CraftSystem.ImmersiveCraftDef function CraftSystem.registerImmersiveCraft(craftName, def) - ImmersiveCraftHandler:addCraft(craftName, def) + ImmersiveCraftHandler:registerCraft(craftName, def) end return CraftSystem diff --git a/mods/CORE/CraftSystem/src/CraftSystem/BaseCraftHandler.lua b/mods/CORE/CraftSystem/src/CraftSystem/BaseCraftHandler.lua index 4b27431..1e7f76d 100644 --- a/mods/CORE/CraftSystem/src/CraftSystem/BaseCraftHandler.lua +++ b/mods/CORE/CraftSystem/src/CraftSystem/BaseCraftHandler.lua @@ -1,4 +1,6 @@ ---Abstract class for handling crafting. +--- +---**Only for EmmyLua.** ---@class CraftSystem.BaseCraftHandler ---@field craftsByName table ---@field craftsByGroup table diff --git a/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraft.lua b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraft.lua index 0d4952c..fa8a944 100644 --- a/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraft.lua +++ b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraft.lua @@ -5,13 +5,19 @@ local require = modInfo.require ---@type CraftSystem.BaseCraft local BaseCraft = require('CraftSystem.BaseCraft') ----@type CraftSystem.ImmersiveCraftStage -local ImmersiveCraftStage = require('CraftSystem.ImmersiveCraftStage') +---Types of immersive stages. +---@class CraftSystem.StagesTypes : table +local stageTypes = { + ---@type CraftSystem.ImmersiveCraftStage.TappingStage + tapping = require('CraftSystem.ImmersiveCraftStage.TappingStage'), +} + +---Immersive crafting aimed at a more logical process of crafting items. ---@class CraftSystem.ImmersiveCraft : CraftSystem.BaseCraft ---@field startStageName string ---@field triggerItem string ----@field output string +---@field output ItemStackString ---@field stagesByName table local ImmersiveCraft = extend(BaseCraft, {}) @@ -28,24 +34,98 @@ local ImmersiveCraft = extend(BaseCraft, {}) ---@param def CraftSystem.ImmersiveCraftDef ---@return CraftSystem.ImmersiveCraft function ImmersiveCraft:new(name, def) + -- We create a table of crafting stages that the player needs to complete. + ---@type table local stagesByName = {} for _, stageDef in ipairs(def.stages) do - local stage = ImmersiveCraftStage:new(stageDef) + -- We get the stage class based on its type. + local StageClass = stageTypes[stageDef.type] + -- Create a stage and add the craft name to the instance. + stageDef.craftName = name + local stage = StageClass:new(stageDef) + + -- We add an instance of the stage to the table by name. stagesByName[stageDef.name] = stage end - local instance = getInstance(self, { - name = name, - group = def.group, - startStageName = def.startStageName, - triggerItem = def.triggerItem, - output = def.output, - stagesByName = stagesByName, - }) + ---@type CraftSystem.ImmersiveCraft + local instance = getInstance(self, {}) + instance.name = name + instance.group = def.group + instance.startStageName = def.startStageName + instance.triggerItem = def.triggerItem + instance.output = def.output + instance.stagesByName = stagesByName + + -- Subscribe to an event that will determine that the player has completed the crafting stage. + Events.subscribe('craft_system:next_immersive_stage:'..name, + ---@param eventName string + ---@param stage CraftSystem.ImmersiveCraftStage + ---@param pos MapPosition + ---@param Player Player + function(eventName, stage, pos, Player) + -- From the current stage (which has been completed) we get the name of the next one. + local nextStageName = stage.nextStage + + -- If there is no next stage... + if nextStageName == nil then + -- ...we are finishing the craft. + instance:endCraft(pos, Player) + else + -- ...else we start the next stage. + local nextStage = instance.stagesByName[nextStageName] + + -- We get a table of temporary data. + local craftData = Smc.getCraftDataByPos(pos) + assert(craftData ~= nil, 'Immersive crafting data is empty.') + + -- We are updating the crafting stage in it. + craftData.stageName = nextStageName + -- We save it to the workstation metadata. + Smc.setCraftDataByPos(pos, craftData) + + -- We are starting the next stage of crafting. + nextStage:startHandler(pos, Player) + end + end) return instance end +---Initialize the start of the immersive crafting process. +---@param pos MapPosition +---@param Player Player +function ImmersiveCraft:startCraft(pos, Player) + -- TODO: забирать из инвентаря игрока материалы для крафта + + -- We get the first stage of crafting. + local stage = self.stagesByName[self.startStageName] + + -- Create a temporary data table for crafting. + ---@type ImmersiveCraftData + local craftData = { + craftName = self.name, + stageName = stage.name, + } + -- We save it to the workstation metadata. + Smc.setCraftDataByPos(pos, craftData) + + -- We are starting the first stage of crafting. + stage:startHandler(pos, Player) +end + +---Complete the immersive crafting process. +---@param pos MapPosition +---@param Player Player +function ImmersiveCraft:endCraft(pos, Player) + -- Clearing the temporary data table for crafting, freeing up the work station for new crafts. + Smc.setCraftDataByPos(pos) + + -- We drop away the result of crafting. + -- TODO: переписать определение этого метода в хелпере: itemstack не может быть строкой, а dropper опционален + core.item_drop(ItemStack(self.output), nil, vector.new(pos)+vector.new(0, 0.9,0)) +end + return ImmersiveCraft diff --git a/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftHandler.lua b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftHandler.lua index 4a3e916..dafa271 100644 --- a/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftHandler.lua +++ b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftHandler.lua @@ -10,6 +10,8 @@ local BaseCraftHandler = require('CraftSystem.BaseCraftHandler') ---@type CraftSystem.ImmersiveCraft local ImmersiveCraft = require('CraftSystem.ImmersiveCraft') +---A handler for immersive crafting that requires the player to complete +---crafting stages and interact with entities (crafting nodes) ---@class CraftSystem.ImmersiveCraftHandler : CraftSystem.BaseCraftHandler ---@field craftsByTriggerItem table ---@field getCraftByName fun(self, craftName:string):CraftSystem.ImmersiveCraft @@ -19,32 +21,45 @@ local ImmersiveCraftHandler = extend(BaseCraftHandler, { craftsByTriggerItem = {}, }) +---Register an immersive crafting experience that requires the player to complete +---one or more crafting stages that involve interaction with entities (crafting nodes) ---@param craftName string ---@param def CraftSystem.ImmersiveCraftDef -function ImmersiveCraftHandler:addCraft(craftName, def) +function ImmersiveCraftHandler:registerCraft(craftName, def) assert(self.craftsByName[craftName] == nil, ('A craft named `%s` already exists.'):format( craftName)) + -- We obtain a crafting instance according to the given parameters. local craft = ImmersiveCraft:new(craftName, def) + -- The craft group to which the craft belongs. local group = def.group + -- If no craft with this group has been registered before... if self.craftsByGroup[group] == nil then + -- ...then we create a list for this group. self.craftsByGroup[group] = {} end + -- The material from which crafting begins (also known as the starting item). local triggerItem = def.triggerItem + -- If no crafting for such a starting item has been registered before... if self.craftsByTriggerItem[triggerItem] == nil then + -- ...then we create a list for this item. self.craftsByTriggerItem[triggerItem] = {} end + -- Adding craft to the lists: self.craftsByName[craftName] = craft tableInsert(self.craftsByGroup[group], craft) tableInsert(self.craftsByTriggerItem[triggerItem], craft) tableInsert(self.craftsList, craft) end +---Returns a list of crafts that use the given item as a starting material. +--- +---Will return `nil` if the item is not used in any craft as a starting item. ---@param triggerItem string ---@return CraftSystem.ImmersiveCraft[]? function ImmersiveCraftHandler:getCraftsByTriggerItem(triggerItem) diff --git a/mods/CORE/CraftSystem/src/CraftSystem/immersiveCraftNode.lua b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftNode.lua similarity index 59% rename from mods/CORE/CraftSystem/src/CraftSystem/immersiveCraftNode.lua rename to mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftNode.lua index c84b95a..3b556df 100644 --- a/mods/CORE/CraftSystem/src/CraftSystem/immersiveCraftNode.lua +++ b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftNode.lua @@ -1,14 +1,13 @@ ---@type Creature -local Creature = Mod.getInfo('smc__core__entity').require('Creature') +local Creature = Mod.getInfo('smc__core__creature').require('Creature') +---The entity the player interacts with during immersive crafting. ---@class CraftSystem.ImmersiveCraftNode : Creature local ImmersiveCraftNode = Creature:getExtended({ settings = { _name = 'craft_system:immersive_craft_node', _add_mod_name = false, - initial_properties = { - - } + initial_properties = {}, } }) diff --git a/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftNode/TapperNode.lua b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftNode/TapperNode.lua deleted file mode 100644 index 2cbc9f3..0000000 --- a/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftNode/TapperNode.lua +++ /dev/null @@ -1,12 +0,0 @@ -local extend = Class.extend - -local modInfo = Mod.getInfo('smc__core__craft_system') -local require = modInfo.require - ----@type CraftSystem.ImmersiveCraftNode -local ImmersiveCraftNode = require('CraftSystem.ImmersiveCraftNode') - ----@class CraftSystem.ImmersiveCraftNode.TapperNode : CraftSystem.ImmersiveCraftNode -local TapperNode = extend(ImmersiveCraftNode, {}) - -return TapperNode diff --git a/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftNode/tappingNode.lua b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftNode/tappingNode.lua new file mode 100644 index 0000000..d8ce28d --- /dev/null +++ b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftNode/tappingNode.lua @@ -0,0 +1,78 @@ +local modInfo = Mod.getInfo('smc__core__craft_system') +local require = modInfo.require + +---@type CraftSystem.ImmersiveCraftNode +local ImmersiveCraftNode = require('CraftSystem.ImmersiveCraftNode') + +---A class that extends `Creature.LuaEntity` to annotate custom fields needed for immersive crafting. +--- +---**Only for EmmyLua.** +---@class CraftSystem.ImmersiveCraftNode.LuaTappingNode : Creature.LuaEntity +---The name of the item that the crafting node display. +---@field _item_name ItemStackString +---Sets the entity display of the item. If the item stack was not transferred, `self._item_name` is used. +---@field _set_item fun(self:CraftSystem.ImmersiveCraftNode.LuaTappingNode, itemName:ItemStackString?) +---@field _craft_name string +---@field _stage_name string +---@field _work_station_pos MapPosition + +-- A crafting node (entity) that is used in the tapping crafting stage. +local tappingNode = ImmersiveCraftNode:new({ + settings = { + _name = 'craft_system:tapping_node', + _add_mod_name = false, + + initial_properties = { + visual = 'wielditem', + visual_size = {x=0.4, y=0.4, z=0.4}, + static_save = false, + }, + + _item_name = '', + _craft_name = '', + _stage_name = '', + _work_station_pos = {}, + }, + callbacks = { + ---@param luaEntity CraftSystem.ImmersiveCraftNode.LuaTappingNode + on_activate = function(luaEntity, staticdata, dtime) + -- We obtain a table of initial parameters for the craft node entity. + ---@type CraftSystem.ImmersiveCraftStage.TappingNode.InitParams? + local params = core.deserialize(staticdata) + + -- We enter parameters into the entity's custom fields. + if params ~= nil then + luaEntity._item_name = params.targetItem + luaEntity._craft_name = params.craftName + luaEntity._stage_name = params.stageName + luaEntity._work_station_pos = params.WorkStationPos + end + + -- we set the appearance of the item to be processed on the crafting node. + luaEntity:_set_item(luaEntity._item_name) + -- We add an immortal group to the entity so that it cannot be killed. + luaEntity.object:set_armor_groups({immortal = 1}) + end, + + ---@param luaEntity CraftSystem.ImmersiveCraftNode.LuaTappingNode + on_punch = function(luaEntity, puncher, time_from_last_punch, tool_capabilities, dir, damage) + -- We simply trigger the event that the player hits the crafting node, bound to the work station with coordinates. + Events.call(('craft_system:punch_tapping_node:%s:%s'):format( + luaEntity._craft_name, luaEntity._stage_name), luaEntity._work_station_pos, puncher) + + return false + end, + + ---Sets the entity display of the item. If the item stack was not transferred, `self._item_name` is used. + ---@param luaEntity CraftSystem.ImmersiveCraftNode.LuaTappingNode + ---@param itemName ItemStackString? + _set_item = function(luaEntity, itemName) + -- We change the entity field so that the engine itself displays it as a given item. + luaEntity.object:set_properties({ + wield_item = itemName or luaEntity._item_name, + }) + end, + } +}) + +return tappingNode diff --git a/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftStage.lua b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftStage.lua index fd5bcc7..acb6f2e 100644 --- a/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftStage.lua +++ b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftStage.lua @@ -1,36 +1,39 @@ local getInstance = Class.getInstance ----@alias CraftSystem.ImmersiveCraftStage.HandlerFunc fun(self, Player) +---@alias CraftSystem.ImmersiveCraftStage.Type 'tapping' +---One of the stages of immersive crafting. ---@class CraftSystem.ImmersiveCraftStage ---@field name string ----@field startHandler CraftSystem.ImmersiveCraftStage.HandlerFunc ----@field processHandler CraftSystem.ImmersiveCraftStage.HandlerFunc ----@field endHandler CraftSystem.ImmersiveCraftStage.HandlerFunc +---@field type CraftSystem.ImmersiveCraftStage.Type +---@field craftName string +---@field startHandler fun(self, pos:Position, Player:Player) +---@field processHandler fun(self, pos:Position, Player:Player) +---@field endHandler fun(self, pos:Position, Player:Player) +---@field nextStage string? ---@field returnItems table? TODO: доделать тут тип -local ImmersiveCraftStage = { - data = {} -} +local ImmersiveCraftStage = {} ---Definition table for the `CraftSystem.ImmersiveCraft`. --- ---**Only for EmmyLua.** ---@class CraftSystem.ImmersiveCraftStageDef ----@field name string ----@field startHandler CraftSystem.ImmersiveCraftStage.HandlerFunc ----@field processHandler CraftSystem.ImmersiveCraftStage.HandlerFunc ----@field endHandler CraftSystem.ImmersiveCraftStage.HandlerFunc ----@field returnItems table? TODO: доделать тут тип +---@field name string +---@field type CraftSystem.ImmersiveCraftStage.Type +---@field craftName string? +---@field nextStage string? +---@field returnItems table? TODO: доделать тут тип ----@param def CraftSystem.ImmersiveCraftStageDef ----@return CraftSystem.ImmersiveCraftStage +---@param def CraftSystem.ImmersiveCraftStageDef +---@return CraftSystem.ImmersiveCraftStage function ImmersiveCraftStage:new(def) - local instance = getInstance(self, { - name = def.name, - startHandler = def.startHandler, - processHandler = def.processHandler, - endHandler = def.endHandler - }) + ---@type CraftSystem.ImmersiveCraftStage + local instance = getInstance(self, {}) + instance.name = def.name + instance.type = def.type + instance.craftName = def.craftName + instance.nextStage = def.nextStage + instance.returnItems = def.returnItems return instance end diff --git a/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftStage/Tapping.lua b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftStage/Tapping.lua deleted file mode 100644 index b47a93b..0000000 --- a/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftStage/Tapping.lua +++ /dev/null @@ -1,38 +0,0 @@ -local getInstance, extend = Class.getInstance, Class.extend - ----@type CraftSystem.ImmersiveCraftStage -local ImmersiveCraftStage = Mod.getInfo('smc__core__craft_system').require('ImmersiveCraftStage') - ----@class CraftSystem.ImmersiveCraftStage.Tapping : CraftSystem.ImmersiveCraftStage ----@field targetItem string ----@field startHandler fun(self:CraftSystem.ImmersiveCraftStage.Tapping, pos:Position, Player:Player) ----@field processHandler fun(self:CraftSystem.ImmersiveCraftStage.Tapping, pos:Position, Player:Player) ----@field endHabdler fun(self:CraftSystem.ImmersiveCraftStage.Tapping, pos:Position, Player:Player) ----@field entity Entity -local Tapping = extend(ImmersiveCraftStage, {}) - ----@class CraftSystem.ImmersiveCraftStage.TappingDef ----@field targetItem string - ----@param def CraftSystem.ImmersiveCraftStage.TappingDef -function Tapping:new(def) - local instance = getInstance(self, {}) - - instance.targetItem = def.targetItem - - instance.startHandler = function(self, pos, Player) - - end - - instance.processHandler = function(self, pos, Player) - - end - - instance.endHabdler = function(self, pos, Player) - - end - - return instance -end - -return Tapping diff --git a/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftStage/TappingStage.lua b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftStage/TappingStage.lua new file mode 100644 index 0000000..bbd000c --- /dev/null +++ b/mods/CORE/CraftSystem/src/CraftSystem/ImmersiveCraftStage/TappingStage.lua @@ -0,0 +1,133 @@ +local extend = Class.extend + +local getStageDataByPos, setStageDataByPos = Smc.getStageDataByPos, Smc.setStageDataByPos + +local require = Mod.getInfo('smc__core__craft_system').require + +---@type CraftSystem.ImmersiveCraftStage +local ImmersiveCraftStage = require('CraftSystem.ImmersiveCraftStage') + +---A crafting step that requires the player to hit a crafting node (entity) a certain number of times. +---@class CraftSystem.ImmersiveCraftStage.TappingStage : CraftSystem.ImmersiveCraftStage +---@field targetItem string +---@field clicksNeed string +---@field startHandler fun(self:CraftSystem.ImmersiveCraftStage.TappingStage, pos:MapPosition, Player:Player) +---@field processHandler fun(self:CraftSystem.ImmersiveCraftStage.TappingStage, pos:MapPosition, Player:Player) +---@field endHandler fun(self:CraftSystem.ImmersiveCraftStage.TappingStage, pos:MapPosition, Player:Player) +local TappingStage = extend(ImmersiveCraftStage, {}) + +---Definition table for the `CraftSystem.ImmersiveCraftStage.TappingStage`. +--- +---**Only for EmmyLua.** +---@class CraftSystem.ImmersiveCraftStage.TappingStageDef : CraftSystem.ImmersiveCraftStageDef +---@field targetItem string +---@field clicksNeed string + +---Data table for transferring various time parameters between calls. +--- +---**Only for EmmyLua.** +---@class ImmersiveStageData.TappingStageData : ImmersiveStageData +---How many clicks were made by the player on the entity. +---@field clickCount integer +---Unique identifier of the entity (craft node). +---@field entityGUID string + +---@param def CraftSystem.ImmersiveCraftStage.TappingStageDef +function TappingStage:new(def) + ---@type CraftSystem.ImmersiveCraftStage.TappingStage + local instance = ImmersiveCraftStage:new(def) + instance.targetItem = def.targetItem + instance.clicksNeed = def.clicksNeed + + -- Registering the crafting stage start handler. + instance.startHandler = function(tappingStage , pos, Player) + -- We determine the coordinate where we will create the crafting node (entity). + local entityPos = vector.new(pos) + vector.new(0,0.9,0) + + -- We create a table of initial parameters that we will pass to the entity. + ---@class CraftSystem.ImmersiveCraftStage.TappingNode.InitParams + local params = { + targetItem = tappingStage.targetItem, + craftName = tappingStage.craftName, + stageName = tappingStage.name, + WorkStationPos = pos, + } + + -- Adding an entity to the world. + local obj = core.add_entity(entityPos, 'craft_system:tapping_node', core.serialize(params)) + + -- If the entity was not returned, something went wrong. + if obj == nil then + return + end + + -- Create a temporary table of crafting stage data. + ---@type ImmersiveStageData.TappingStageData + local stageData = { + clickCount = 0, + entityGUID = obj:get_guid() + } + + -- Saving temporary data in work station metadata. + setStageDataByPos(pos, stageData) + print(pos, dump(Smc.getCraftDataByPos(pos)), 'ONE') + end + + -- Registering the crafting stage process handler. + -- Called when a player clicks on a crafting node (entity). + instance.processHandler = function(tappingStage, pos, Player) + -- Obtaining stage time data from work station metadata. + ---@type ImmersiveStageData.TappingStageData? + local stageData = getStageDataByPos(pos) + print(dump(pos), dump(Smc.getCraftDataByPos(pos)), 'TWO') + assert(stageData ~= nil, 'Immersive stage data is empty.') + + -- Increasing the click counter + local clickCount = stageData.clickCount + clickCount = clickCount + 1 + + -- If the number of clicks is greater than required to complete the step... + if clickCount >= tappingStage.clicksNeed then + -- ...we are completing the stage. + tappingStage:endHandler(pos, Player) + else + -- ...else we save the number of clicks in the temporary data table. + stageData.clickCount = clickCount + Smc.setStageDataByPos(pos, stageData) + end + end + + -- Registering the crafting stage end handler. + instance.endHandler = function(tappingStage, pos, Player) + -- Obtaining stage time data from work station metadata. + ---@type ImmersiveStageData.TappingStageData? + local stageData = getStageDataByPos(pos) + assert(stageData ~= nil, 'Immersive stage data is empty.') + + -- We get the entity object. + local entity = Smc.getObjectByGUID(stageData.entityGUID) + assert(entity ~= nil, 'The entity for immersive crafting is nil.') + + -- Removing an entity from the world. + entity:remove() + + -- Clearing the crafting stage time table. + setStageDataByPos(pos) + + -- We trigger an event that the crafting stage has been completed. + Events.call('craft_system:next_immersive_stage:'..tappingStage.craftName, tappingStage, pos, Player) + end + + -- Subscribe to an event that means the player hit the entity. + Events.subscribe(('craft_system:punch_tapping_node:%s:%s'):format(instance.craftName, instance.name), + function(eventName, pos, Player) + instance:processHandler(pos, Player) + end) + + return instance +end + +-- Registering an entity for immersive tapping crafting. +require('CraftSystem.ImmersiveCraftNode.tappingNode') + +return TappingStage diff --git a/mods/CORE/CraftSystem/src/CraftSystem/PrimitiveCraft.lua b/mods/CORE/CraftSystem/src/CraftSystem/PrimitiveCraft.lua index d954c77..3d3e581 100644 --- a/mods/CORE/CraftSystem/src/CraftSystem/PrimitiveCraft.lua +++ b/mods/CORE/CraftSystem/src/CraftSystem/PrimitiveCraft.lua @@ -24,6 +24,7 @@ local PrimitiveCraft = extend(BaseCraft, {}) ---@param def CraftSystem.PrimitiveCraftDef ---@return CraftSystem.PrimitiveCraft function PrimitiveCraft:new(name, def) + ---@type CraftSystem.PrimitiveCraft local instance = getInstance(self, { name = name, group = def.group, diff --git a/mods/CORE/CraftSystem/src/CraftSystem/PrimitiveCraftHandler.lua b/mods/CORE/CraftSystem/src/CraftSystem/PrimitiveCraftHandler.lua index c898348..6694a36 100644 --- a/mods/CORE/CraftSystem/src/CraftSystem/PrimitiveCraftHandler.lua +++ b/mods/CORE/CraftSystem/src/CraftSystem/PrimitiveCraftHandler.lua @@ -11,15 +11,18 @@ local BaseCraftHandler = require('CraftSystem.BaseCraftHandler') ---@type CraftSystem.PrimitiveCraft local PrimitiveCraft = require('CraftSystem.PrimitiveCraft') +---A primitive crafting processor that doesn't require much interaction and provides +---simple crafting based on a recipe-result scheme. ---@class CraftSystem.PrimitiveCraftHandler : CraftSystem.BaseCraftHandler ---@field getCraftByName fun(self, craftName:string):CraftSystem.PrimitiveCraft ---@field getCraftsByGroup fun(self, craftGroup):CraftSystem.PrimitiveCraft[] ---@field getLearnedCrafts fun(self, playerName):table local PrimitiveCraftHandler = extend(BaseCraftHandler, {}) +---Register a primitive craft that does not require special interaction. ---@param craftName string ---@param def CraftSystem.PrimitiveCraftDef -function PrimitiveCraftHandler:addCraft(craftName, def) +function PrimitiveCraftHandler:registerCraft(craftName, def) assert(self.craftsByName[craftName] == nil, ('A craft named `%s` already exists.'):format( craftName))