100 Commits

Author SHA1 Message Date
ceb35639b8 MapGen: minor refactoring 2026-03-21 21:26:27 +03:00
79df8f2f52 MapGen: a little bit more optimizations 2026-03-21 20:53:02 +03:00
e986a4c538 MapGen: There is now only one triangulation map instead of three. 2026-03-16 20:59:39 +03:00
93bda75727 Profiler: some changes 2026-03-16 20:57:37 +03:00
1531abc3e2 MapGen: Attempt to speed up generation. Some MapGen.Peak fields can now be accessed directly. Layers are now defined for the entire chunk, rather than per node. 2026-03-15 22:08:13 +03:00
a34822ed54 MapGen: find optimization. #37 2026-03-13 21:57:05 +03:00
145f65d4af Player: create PlayerInventoryUI class & change item count in hotbar (8->9). #34 2026-03-12 21:44:03 +03:00
e359c4be09 Profiler: create class and base functional. Close #36 2026-03-12 20:10:55 +03:00
c009493484 MapGen: remove space 2026-03-12 19:44:27 +03:00
fab86c0486 License fix 2 2026-03-12 19:29:24 +03:00
cb15f25d60 License fix 2026-03-12 19:11:41 +03:00
867238e11b MapGen: add large map, disable log profiler 2026-03-12 15:05:53 +03:00
df247108ef MapGen: fastgen? 2026-03-11 23:34:09 +03:00
e34fd29a4b MapGen: removing unnecessary code. Completion of work on a new triangulation method. Close #25 2026-03-10 21:14:31 +03:00
41cf4710da MapGen: small map test 2026-03-09 21:51:49 +03:00
c6573ae308 MapGen: fix patch 2026-03-09 21:16:53 +03:00
4ef2476771 MapGen: Moving triangulation outside of Lua scripts, using pre-triangulated JSON files 2026-03-09 20:07:00 +03:00
2c13e1697f Wood: some Russian localization has been added 2026-03-08 22:44:42 +03:00
7b4839e63b Item: minor item description changes 2026-03-08 22:44:06 +03:00
2813d9d5fe Add missing locale admin command. Remove auto-check missing locale` 2026-03-08 20:56:48 +03:00
652200f28c Update ide-helper 2026-03-08 20:55:06 +03:00
eeffae6852 Item: add missing localization check 2026-03-06 20:10:04 +03:00
fe3298d112 Change regular & mono fonts on Philosopher 2026-03-06 19:03:45 +03:00
7d49bbf535 MapGen: add post-processing generation in biomes. Close #30 2026-03-05 21:46:28 +03:00
efcbc909e0 CraftSystem: save counter in ModStorage. Close #32 2026-03-05 20:11:32 +03:00
17413df9c4 storages: create storages mod, move case wood -> storages, create draft chest 2026-03-05 19:47:27 +03:00
2eede05436 HelperLib: add regular & mono fonts - Stengazeta 2026-03-05 19:46:33 +03:00
b863c88838 wood: fix textures & add new wood - gi 2026-03-02 22:28:29 +03:00
692105abfa BaseUI: Clearing the context is now an optional parameter & edit /list command. close #33 2026-03-02 19:57:54 +03:00
1a6086190e wood: improved textures, adding stripped wood 2026-03-01 22:20:14 +03:00
e20c3b4ef4 rocks: add sylite pillars 2026-03-01 22:19:00 +03:00
8b55ccff72 adminCommands: update /list command 2026-02-27 21:55:34 +03:00
c7cfe26335 Tool: create tool class 2026-02-27 20:57:54 +03:00
51e6763457 HelperLib: add require methods 2026-02-27 20:34:37 +03:00
c47ab6ac3c soils: update textures 2026-02-27 20:23:35 +03:00
6fd8295500 Item: minor fixes & set default stack is 128 2026-02-27 20:23:15 +03:00
b12f890740 adminCommands: minor fixes & test shaders 2026-02-27 20:22:19 +03:00
4c90041c68 Add essences (rofl) 2026-02-27 20:21:26 +03:00
b50d642bcf Trees update 2026-02-24 21:48:42 +03:00
e0b9024458 Add leafs & fix list command 2026-02-22 22:01:22 +03:00
745eaa8569 CraftSystem: TappingStage can now require a tool with a specific group for crafting 2026-02-20 22:18:25 +03:00
b6051e5724 WorkStation add TODO 2026-02-20 22:01:53 +03:00
5c936025f1 Add craft abort support & fixes visual tappingCraftNode 2026-02-20 21:46:45 +03:00
Van
5be847bf58 Merge pull request 'CraftSystem: first working version' (#31) from craft-system into main 2026-02-18 22:30:38 +03:00
0198771c51 WorkStation: tidying up the code, adding comments 2026-02-18 22:20:27 +03:00
5272294aeb CraftSystem: end of work? 2026-02-18 22:19:42 +03:00
2eb7d04039 WorkStationUI: update 2026-02-18 22:18:30 +03:00
c70bf96734 BaseUI: add showForm & closeForm methods 2026-02-18 22:18:10 +03:00
b64c8e9350 WorkStation: update 2026-02-17 21:44:53 +03:00
319f155849 CraftSystem: ImmersiveCraftStage`: minor changes 2026-02-17 21:43:48 +03:00
ed4094d964 CraftSystem: add ImmersiveCraftCounter` 2026-02-17 21:43:00 +03:00
6b074c7a8c CraftSystem: PrimitiveCraft`: minor changes 2026-02-17 21:42:21 +03:00
00633226cf CraftSystem: TappingNode: add get_staticdata method, enable static_save` 2026-02-17 21:40:42 +03:00
6156a4bb6f rocks`: add some locale 2026-02-17 21:38:02 +03:00
b6f354f6fe Submodules: update ide-helper 2026-02-17 21:37:00 +03:00
cfc4502cb0 Item: minor chandes 2026-02-17 21:36:32 +03:00
bafe26983c BaseUI: add recive fields methods 2026-02-17 21:35:40 +03:00
7b43def5fb HelperLib: add receive fields methods 2026-02-17 21:34:56 +03:00
f4896b89ef HelperLib: minor changes immersive craft data 2026-02-17 21:34:25 +03:00
c58467f22b Submodules: update ide-helper 2026-02-14 19:27:17 +03:00
1d5f93c35a CraftSystem: minor annotation fix 2026-02-13 21:38:04 +03:00
46427f565f Submodules: update ide-helper 2026-02-13 21:35:47 +03:00
8fb4e4db00 Submodules: update ide-helper and fix mapgen annotations 2026-02-13 21:22:48 +03:00
9c56db6ac4 CtaftSystem: Bringing the system into order, adding annotations and comments, eliminating major bugs 2026-02-13 21:09:55 +03:00
15bb906df7 HelperLib: add getObjectByGUID & immersive craft data methods 2026-02-13 21:03:01 +03:00
e9818fba24 Events & Control: remove Events.registerCallback function 2026-02-13 21:01:44 +03:00
a6fa46bb96 Creature: minor annotation fixes 2026-02-13 20:58:44 +03:00
44adcf9535 Creature: create Creature.LuaEntity class 2026-02-12 21:12:27 +03:00
97292d6205 Creature: callback fixes 2026-02-12 21:11:52 +03:00
f2af5e725a Item & Node: corrections in the order of merging tables of parameters and default parameters 2026-02-12 21:10:18 +03:00
25f38d1acd BaseUI: create base UI class 2026-02-12 21:08:43 +03:00
1d43ae1255 CraftSystem: create ImmersiveCraftNode & add first immersive craft type Tapping 2026-02-09 22:35:05 +03:00
9426ac01dd Creature: minor fixes 2026-02-09 22:19:20 +03:00
21232bd1f7 Table: fix annotation table.merge 2026-02-09 22:13:41 +03:00
0c02c0045d Rename class: Entity -> Creature 2026-02-09 19:33:23 +03:00
205cbc10c2 Node: added missing empty lines at the end of files 2026-02-09 18:17:27 +03:00
660c96ab5c Entity: add getExtended method 2026-02-09 18:16:14 +03:00
ec8499ff76 Item & Node: add merge defaults defs to getExtended and getFactory 2026-02-09 18:15:22 +03:00
430ac78ea1 Submodules: update ide-helper 2026-02-08 20:38:59 +03:00
f7140fb3cc Entity: reating a wrapper class for an entity. Close #26 2026-02-08 20:26:17 +03:00
6153b053f6 Item: minor changes 2026-02-08 20:24:53 +03:00
bc03aa4ba6 Rename custom field use snake_case and _ 2026-02-08 18:42:07 +03:00
04f90a7b2d Submodules: update ide-helper 2026-02-08 16:46:44 +03:00
66380fb873 WorkStation: create WorkStation class, register test node & crafts, add work station UI 2026-02-07 22:14:07 +03:00
169dd64bce CraftSystem: minor fixes 2026-02-07 22:13:16 +03:00
613b7ead83 Submodules: update ide-helper 2026-02-07 20:35:59 +03:00
94dc3fa819 CraftSystem: rewrite system, completion of work on immersive craft 2026-02-06 18:19:38 +03:00
6c77b5a38c Class: minor fixes 2026-02-06 17:14:02 +03:00
c41ee05b55 CraftSystem: add lastline space 2026-02-06 16:53:32 +03:00
87c6e5f3f3 CraftSystem: Immersive craft part 2 2026-02-05 22:30:25 +03:00
e435b21b43 Item: Corrections to the design, added the last empty lines 2026-02-02 14:25:20 +03:00
0baa7af759 Entity: create dummy-class 2026-02-02 14:19:14 +03:00
83304bbfc1 CraftSystem: add dummy-class ImmersiveCraftStage 2026-02-02 13:59:12 +03:00
7dbd2f3be8 CraftSystem: add immersive craft handler (no realisation) 2026-02-02 13:46:06 +03:00
b41448da7b CraftSystem: add primitive craft handler 2026-02-02 13:33:12 +03:00
865f46b734 Add Item.Rarity 2026-02-01 20:51:23 +03:00
3dd28858f5 Add some rocks 2026-02-01 19:44:59 +03:00
Van
9119582ddd Обновить .gitea/pull_request_template.yml 2026-01-29 16:04:00 +03:00
Van
a12091fc93 Обновить .gitea/pull_request_template.yml 2026-01-29 16:03:28 +03:00
Van
cfadf47951 Обновить .gitea/pull_request_template.yml 2026-01-29 16:02:47 +03:00
119 changed files with 14354 additions and 1670 deletions

View File

@@ -32,7 +32,8 @@
"vector", "vector",
"Ensure", "Ensure",
"string", "string",
"string_utf8" "string_utf8",
"Profiler"
], ],
"globalsRegex": [] "globalsRegex": []
}, },

View File

@@ -1,5 +1,5 @@
name: Сообщение об ошибке name: PR-template
about: Сообщить о недоработке игры, которую необходимо исправить. about: PR-template
labels: labels:
- pr/wait review - pr/wait review
- review/need a maintainer - review/need a maintainer
@@ -23,12 +23,12 @@ body:
attributes: attributes:
label: Требования label: Требования
options: options:
- label: Я запускал игру и убедился в том, что она работает.
required: true
- label: Я ознакомлен с соглашением по разработке и мои изменения следуют принятым стандартам. - label: Я ознакомлен с соглашением по разработке и мои изменения следуют принятым стандартам.
required: true required: true
- label: Я запускал игру и убедился в том, что она работает.
required: false
- label: Я указал в описании запроса метки (label) с префиксом `Edit:` в соответствии с теми изменениями, которые сделал. - label: Я указал в описании запроса метки (label) с префиксом `Edit:` в соответствии с теми изменениями, которые сделал.
required: true required: false
- type: markdown - type: markdown
attributes: attributes:
value: | value: |

View File

@@ -1,7 +1,8 @@
Source code licensing: # Source code licensing
The MIT License (MIT) **The MIT License (MIT)**
Copyright (c) 2025 Apancore.Studio, Doloment
Copyright (c) 2025 Apancore.Studio, Van (varttist), Doloment
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
@@ -11,9 +12,13 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
------------------------ ------------------------
Sprites licensing: # Sprites licensing
CC BY 4.0 **CC BY 4.0**
Copyright (c) 2025 Apancore.Studio, Doloment and others (see list below)
Copyright (c) 2025 Apancore.Studio, Van (varttist) and others (see list below)
All textures except those listed here are copyrighted by Van (varttist) and are distributed under the CC BY 4.0.
List of all textures and authors: List of all textures and authors:
- ...

View File

@@ -0,0 +1,4 @@
local modInfo = Mod.getInfo('smc__core__base_ui')
local require = modInfo.require
return require('BaseUI')

View File

@@ -0,0 +1,2 @@
name = smc__core__base_ui
depends = smc__system__system_loader

View File

@@ -0,0 +1,130 @@
local getInstance = Class.getInstance
---@class BaseUI
---Context for transferring data between displaying
---the form spec to the player and handling callbacks.
---@field name string
---@field getFormSpecString fun(self:BaseUI,playerName:string,...):string
---@field contex table<string, table>
local BaseUI = {
contex = {}
}
---@param name string The name of the formspec that will be shown to the player. It is recommended that the name be unique.
---@param getFormSpecString fun(self:BaseUI,playerName:string,...):string
---@param clearContex boolean? Whether to clear the context stored for a player when that player closes the form. Default `true`.
function BaseUI:new(name, getFormSpecString, clearContex)
if clearContex == nil then
clearContex = true
end
---@type BaseUI
local instance = getInstance(self, {})
instance.name = name
instance.getFormSpecString = getFormSpecString
if clearContex then
core.log(name)
-- Ensure that when the form is closed, the context is cleared.
instance:registerOnFormQuit(function(player)
instance:clearContex(player)
end)
end
return instance
end
---Set a value for a specific key.
---Recommended for use where `core.show_formspec` is used.
---
---In the future, the key value can be obtained in the formspec callback.
---@param player string|Player Player as an object (entity) or his name
---@param key string
---@param value any
function BaseUI:setContex(player, key, value)
if type(player) ~= 'string' then
player = player:get_player_name()
end
local contex = self.contex[player]
if contex == nil then
self.contex[player] = {[key]=value}
else
contex[key] = value
end
end
---Get the value of a specific key.
---Recommended for use in a formspec callback.
---@param player string|Player Player as an object (entity) or his name
---@param key string
---@return any?
function BaseUI:getContex(player, key)
if type(player) ~= 'string' then
player = player:get_player_name()
end
local contex = self.contex[player] or {}
return contex[key]
end
---Clear saved context data for a player.
---Recommended for use when closing formspec.
---@param player string|Player Player as an object (entity) or his name
function BaseUI:clearContex(player)
if type(player) ~= 'string' then
player = player:get_player_name()
end
self.contex[player] = {}
end
---Register a callback for a specific player action in FormSpec.
---
---The callback is guaranteed to be called only for the specified field.
---@param fieldName string the name of the field for which the callback will be called.
---@param callback fun(player:Player, fieldName:string, fieldValue:any) Callback to handle the action. Parameters:
--- * `player` - the player who performed the action.
--- * `fieldName` - the name of the field on which the callback is called.
--- * `fieldValue` - the field value that is passed in the `fields` table.
function BaseUI:registerOnFormFieldAction(fieldName, callback)
Smc.registerOnFormFieldAction(self.name, fieldName, callback)
end
---Register a callback function to close the FormSpec.
---
---The callback is guaranteed to be called only for the specified form.
---@param callback fun(player:Player) Callback to handle the close. Parameters:
--- * `player` - the player who closed the form.
function BaseUI:registerOnFormQuit(callback)
Smc.registerOnFormQuit(self.name, callback)
end
---Register a callback for a specific player action in FormSpec.
---
---The callback function is guaranteed to be called only for the specified form and
---for the field whose name matches the pattern.
---@param fieldNamePattern string the name pattern of the field for which the callback will be called.
---@param callback fun(player:Player, fieldName:string, fieldValue:any) Callback to handle the action. Parameters:
--- * `player` - the player who performed the action.
--- * `fieldName` - the name of the field on which the callback is called (will match the pattern).
--- * `fieldValue` - the field value that is passed in the `fields` table.
function BaseUI:registerOnFormFieldActionMatch( fieldNamePattern, callback)
Smc.registerOnFormFieldActionMatch(self.name, fieldNamePattern, callback)
end
---Shows the player the FormSpec registered by the instance of this UI.
---@param playerName string
function BaseUI:showForm(playerName, ...)
core.show_formspec(playerName, self.name, self:getFormSpecString(playerName, ...))
end
---Close the player the FormSpec registered by the instance of this UI.
---@param playerName string
function BaseUI:closeForm(playerName)
core.close_formspec(playerName, self.name)
end
return BaseUI

View File

@@ -2,7 +2,6 @@
local Control = {} local Control = {}
-- control.on_press -- control.on_press
Events.registerEvent('control.on_press')
---@param callbackFunc fun(player:Player, controlName:string) ---@param callbackFunc fun(player:Player, controlName:string)
function Control.subcribeOnPress(callbackFunc) function Control.subcribeOnPress(callbackFunc)
@@ -11,7 +10,6 @@ end
-- control.on_release -- control.on_release
Events.registerEvent('control.on_release')
---@param callbackFunc fun(player:Player, controlName:string, holdTime:number) ---@param callbackFunc fun(player:Player, controlName:string, holdTime:number)
function Control.subcribeOnRelease(callbackFunc) function Control.subcribeOnRelease(callbackFunc)
@@ -20,7 +18,6 @@ end
-- control.on_hold -- control.on_hold
Events.registerEvent('control.on_hold')
---@param callbackFunc fun(player:Player, controlName:string, holdTime:number, dtime:number) ---@param callbackFunc fun(player:Player, controlName:string, holdTime:number, dtime:number)
function Control.subcribeOnHold(callbackFunc) function Control.subcribeOnHold(callbackFunc)
@@ -29,7 +26,6 @@ end
-- control.on_wield_change -- control.on_wield_change
Events.registerEvent('control.on_wield_change')
---@param callbackFunc fun(player:Player, player_wield_index:number, player_last_wield_index:number) ---@param callbackFunc fun(player:Player, player_wield_index:number, player_last_wield_index:number)
function Control.subcribeOnWieldChange(callbackFunc) function Control.subcribeOnWieldChange(callbackFunc)

View File

@@ -1,2 +1,2 @@
name = smc__core__craft_system name = smc__core__craft_system
depends = smc__system__system_loader depends = smc__system__system_loader, smc__core__creature

View File

@@ -1,117 +1,28 @@
local HASH_SPLITTER = '&'
local modInfo = Mod.getInfo('smc__core__craft_system') local modInfo = Mod.getInfo('smc__core__craft_system')
local require = modInfo.require local require = modInfo.require
---@alias CraftSystem.shapelessCraftsList table<CraftSystem.Craft.Group, table<string, CraftSystem.ShapelessCraft[]>> ---@type CraftSystem.PrimitiveCraftHandler
---@alias CraftSystem.processualCraftsList table<CraftSystem.Craft.Group, table<string, CraftSystem.ProcessualCraft[]>> local PrimitiveCraftHandler = require('CraftSystem.PrimitiveCraftHandler')
---@type CraftSystem.ImmersiveCraftHandler
local ImmersiveCraftHandler= require('CraftSystem.ImmersiveCraftHandler')
---@alias CraftSystem.CraftGroup string
---@alias CraftSystem.CraftRecipe string[]
---@alias CraftSystem.CraftType 'primitive'|'immersive'
---@class CraftSystem ---@class CraftSystem
---@field shapelessCraftsList CraftSystem.shapelessCraftsList local CraftSystem = {}
---@field processualCraftsList CraftSystem.processualCraftsList
local CraftSystem = {
shapelessCraftsList = {},
processualCraftsList = {},
}
---@alias CraftSystem.Craft.Type ---@param craftName string
---|'shapeless' ---@param def CraftSystem.PrimitiveCraftDef
---|'processual' function CraftSystem.registerPrimitiveCraft(craftName, def)
---@alias CraftSystem.Craft.Group string PrimitiveCraftHandler:registerCraft(craftName, def)
---@alias CraftSystem.Craft.Recipe string[]
---@alias shapelessCraftFunc fun(self:CraftSystem.ShapelessCraft, input:ItemStack[], workbenchMeta:NodeMetaRef?):boolean
---@alias processualCraftFunc fun(self:CraftSystem.ProcessualCraft, input:ItemStack[], workbenchMeta:NodeMetaRef?, processTime:number):boolean
---@class CraftSystem.BaseCraft
---@field type CraftSystem.Craft.Type
---@field group CraftSystem.Craft.Group
---@field output string
---@field recipe CraftSystem.Craft.Recipe
---@field return table? TODO: доделать тут тип
---@field craftFunc (fun(self, ...):boolean)?
---@class CraftSystem.ShapelessCraft : CraftSystem.BaseCraft
---@field craftFunc shapelessCraftFunc?
---@class CraftSystem.ProcessualCraft : CraftSystem.BaseCraft
---@field processTime number
---@field craftFunc processualCraftFunc?
---@param type CraftSystem.Craft.Type
---@return CraftSystem.shapelessCraftsList|CraftSystem.processualCraftsList
local function getCraftList(type)
local craftList
if type == 'shapeless' then
craftList = CraftSystem.shapelessCraftsList
elseif type == 'processual' then
craftList = CraftSystem.processualCraftsList
else
error(string.format('Craft type `%s` does not exist.', type))
end
return craftList
end end
---@param type CraftSystem.Craft.Type ---@param craftName string
---@param group CraftSystem.Craft.Group ---@param def CraftSystem.ImmersiveCraftDef
---@return table<string, table> function CraftSystem.registerImmersiveCraft(craftName, def)
local function getCraftGroup(type, group) ImmersiveCraftHandler:registerCraft(craftName, def)
local craftList = getCraftList(type)
---@type table<string, table>?
local craftGroup = craftList[group]
assert(craftGroup ~= nil, string.format('Craft group `%s` does not exist.', type))
return craftGroup
end
---@param type CraftSystem.Craft.Type
---@param group CraftSystem.Craft.Group
function CraftSystem.registerCraftGroup(type, group)
local craftList = getCraftList(type)
assert(craftList[group] == nil, string.format('Craft group `%s` is already registered.', type))
craftList[group] = {}
end
---@param recipe CraftSystem.Craft.Recipe
---@return string
function CraftSystem.getCraftHash(recipe)
table.sort(recipe)
local hash = ''
for i = 0, #recipe-1 do
hash = hash..recipe[i]..HASH_SPLITTER
end
return hash..recipe[#recipe]
end
---@param craftDef CraftSystem.ShapelessCraft|CraftSystem.ProcessualCraft
function CraftSystem.registerCraft(craftDef)
local craftGroup = getCraftGroup(craftDef.type, craftDef.group)
local hash = CraftSystem.getCraftHash(craftDef.recipe)
table.insert(craftGroup[hash], craftDef)
end
---@param type CraftSystem.Craft.Type
---@param group CraftSystem.Craft.Group
---@return CraftSystem.ShapelessCraft[] |
--- CraftSystem.processualCraftsList[] |
--- nil
function CraftSystem.getCraftResults(type, group, recipe)
local craftGroup = getCraftGroup(type, group)
local hash = CraftSystem.getCraftHash(recipe)
return craftGroup[hash]
end end
return CraftSystem return CraftSystem

View File

@@ -0,0 +1,13 @@
---Abstract class for craft.
---@class CraftSystem.BaseCraft
---@field name string
---@field group CraftSystem.CraftGroup
local BaseCraft = {}
---Definition table for the `CraftSystem.BaseCraft`.
---
---**Only for EmmyLua.**
---@class CraftSystem.BaseCraftDef
---@field group CraftSystem.CraftGroup
return BaseCraft

View File

@@ -0,0 +1,47 @@
---Abstract class for handling crafting.
---@class CraftSystem.BaseCraftHandler
---@field craftsByName table<string, CraftSystem.BaseCraft>
---@field craftsByGroup table<CraftSystem.CraftGroup, CraftSystem.BaseCraft[]>
---@field craftsList CraftSystem.BaseCraft[]
---@field learnedCrafts table<string, table<string, CraftSystem.BaseCraft>>
local BaseCraftHandler = {
craftsByName = {},
craftsByGroup = {},
craftsList = {},
learnedCrafts = {},
}
---@param craftName string
---@return CraftSystem.BaseCraft
function BaseCraftHandler:getCraftByName(craftName)
local craft = self.craftsByName[craftName]
assert(craft ~= nil, ('There is no primitive craft named `%s`.'):format(
craftName))
return craft
end
---@param craftGroup CraftSystem.CraftGroup
---@return CraftSystem.BaseCraft[]
function BaseCraftHandler:getCraftsByGroup(craftGroup)
local crafts = self.craftsByGroup[craftGroup]
assert(crafts ~= nil, ('There are no primitive crafts with `%s` group'):format(
craftGroup))
return crafts
end
---@param playerName string
---@return table<string, CraftSystem.BaseCraft>
function BaseCraftHandler:getLearnedCrafts(playerName)
local crafts = self.learnedCrafts[playerName]
assert(crafts ~= nil, ('There is no primitive crafting data for a player named `%s`.'):format(
playerName))
return crafts
end
return BaseCraftHandler

View File

@@ -0,0 +1,237 @@
local getInstance, extend = Class.getInstance, Class.extend
local modInfo = Mod.getInfo('smc__core__craft_system')
local require = modInfo.require
---@type CraftSystem.BaseCraft
local BaseCraft = require('CraftSystem.BaseCraft')
---@type CraftSystem.ImmersiveCraftCounter
local ImmersiveCraftCounter = require('CraftSystem.ImmersiveCraftCounter')
---Types of immersive stages.
---@class CraftSystem.StagesTypes : table<CraftSystem.ImmersiveCraftStage.Type, CraftSystem.ImmersiveCraftStage>
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 ItemStackString
---@field stagesByName table<string, CraftSystem.ImmersiveCraftStage>
local ImmersiveCraft = extend(BaseCraft, {})
---Definition table for the `CraftSystem.ImmersiveCraft`.
---
---**Only for EmmyLua.**
---@class CraftSystem.ImmersiveCraftDef : CraftSystem.BaseCraftDef
---@field startStageName string
---@field triggerItem string
---@field output string
---@field stages CraftSystem.ImmersiveCraftStageDef[]
---@param name string
---@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<string, CraftSystem.ImmersiveCraftStage>
local stagesByName = {}
for _, stageDef in ipairs(def.stages) do
-- 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
---@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.
---
---Returns `true` if the crafting process was running.
---@param pos MapPosition
---@param player Player
---@param amount integer
---@return boolean
function ImmersiveCraft:startCraft(pos, player, amount)
-- Adding craft to the counter.
-- If crafting has not been added...
if not ImmersiveCraftCounter:addCraft(pos, player:get_player_name()) then
-- ...then we don't let the player start a new craft.
core.chat_send_player(player:get_player_name(),
'The limit of simultaneously active crafts has been reached: '..
'complete or cancel active crafts to start a new one')
return false
end
-- We get the material as an ItemStack.
---@type ItemStack
local stack = ItemStack(self.triggerItem)
-- We edit the amount of materials in accordance with the number of crafts being performed.
stack:set_count(stack:get_count() * amount)
-- We get the player's inventory, from where we must take the materials for crafting.
local playerInventory = player:get_inventory()
-- If the player does not have the necessary materials for crafting...
if not playerInventory:contains_item('main', stack) then
-- ...we inform him about this.
core.chat_send_player(player:get_player_name(),
'Not enough materials for crafting')
return false
end
-- If we have the materials, we take them and start initializing the craft.
playerInventory:remove_item('main', stack)
-- We get the first stage of crafting.
local stage = self.stagesByName[self.startStageName]
-- Create a temporary data table for crafting.
---@type ImmersiveCraftData
local craftData = {
playerName = player:get_player_name(), -- The name of the player who started the craft.
craftName = self.name,
stageName = stage.name,
amount = amount,
}
-- We save it to the workstation metadata.
Smc.setCraftDataByPos(pos, craftData)
-- We are starting the first stage of crafting.
stage:startHandler(pos, player)
return true
end
---Complete the immersive crafting process.
---@param pos MapPosition
---@param player Player
function ImmersiveCraft:endCraft(pos, player)
-- We get current data on crafting.
---@type ImmersiveCraftData?
local craftData = Smc.getCraftDataByPos(pos)
assert(craftData ~= nil, 'Immersive crafting data is empty.')
-- We drop the result of crafting.
local dropPos = vector.new(pos) + vector.new(0, 0.9,0)
for i=1, craftData.amount do
core.item_drop(ItemStack(self.output), nil, dropPos)
end
-- Remove craft from the counter.
ImmersiveCraftCounter:removeCraft(pos, craftData.playerName)
-- Clearing the temporary data table for crafting, freeing up the work station for new crafts.
Smc.setCraftDataByPos(pos)
end
---Stop the crafting process and free up the workbench.
---@param pos MapPosition
function ImmersiveCraft:abortCraft(pos)
-- We get current data on crafting.
---@type ImmersiveCraftData?
local craftData = Smc.getCraftDataByPos(pos)
assert(craftData ~= nil, 'Immersive crafting data is empty.')
-- We get the current stage and start the abort process.
local stage = self.stagesByName[craftData.stageName]
stage:abortHandler(pos)
-- Clearing the temporary data table for crafting, freeing up the work station for new crafts.
Smc.setCraftDataByPos(pos)
-- Remove craft from the counter.
ImmersiveCraftCounter:removeCraft(pos, craftData.playerName)
end
---Returns a human-readable description of the crafting process.
---@return string
function ImmersiveCraft:toString()
-- We get the material as an ItemStack.
---@type ItemStack
local stack = ItemStack(self.triggerItem)
-- We obtain a table of item parameters.
---@type ItemDefinition
local itemDef = stack:get_definition()
-- Let's start writing a description of the craft.
local craftDesc = ('Material: %s x%s\n\n'):format(itemDef._title, stack:get_count())..
'Crafting process:\n'
-- Let's start with the first crafting stage.
---@type string?
local stageName = self.startStageName
local stages = self.stagesByName
-- While we have a stage name...
local count = 1
while stageName ~= nil do
-- We get a crafting stage...
local stage = stages[stageName]
-- ...and we add its description to the list of actions for crafting.
craftDesc = craftDesc..tostring(count)..'. '..stage:toString()..'\n'
-- We also get the name of the next stage.
stageName = stage.nextStage
end
-- If the cycle is interrupted, it means we have processed all the stages.
-- Return the craft description.
return craftDesc
end
return ImmersiveCraft

View File

@@ -0,0 +1,78 @@
local posToString, getSize = core.pos_to_string, table.get_size
local CRAFT_LIMIT_PER_PLAYER = 2
local CRAFT_LIMIT_PER_SERVER = 10
local modStorage = core.get_mod_storage()
---@param key string
---@return table
local function getStorageTable(key)
return core.deserialize(modStorage:get_string(key)) or {}
end
---@param key string
---@param t table
local function setStorageTable(key, t)
modStorage:set_string(key, core.serialize(t))
end
---Designed to keep track of active immersive
---crafts so as not to overload the server.
---
---The counter is individual for each player,
---but the total number of active crafts is also tracked.
---@class CraftSystem.ImmersiveCraftCounter
---@field craftsCountForPlayers table<string, table<string, boolean>>
---@field craftsCountForServer table<string, boolean>
local ImmersiveCraftCounter = {
craftsCountForPlayers = getStorageTable('crafts_count_for_players'),
craftsCountForServer = getStorageTable('crafts_count_for_serves')
}
---Add craft to the counter.
---
---Returns `false` if the counter is already full.
---@param pos MapPosition
---@param playerName string
---@return boolean
function ImmersiveCraftCounter:addCraft(pos, playerName)
if self.craftsCountForPlayers[playerName] == nil then
self.craftsCountForPlayers[playerName] = {}
end
if getSize(self.craftsCountForPlayers[playerName]) >= CRAFT_LIMIT_PER_PLAYER then
return false
end
if getSize(self.craftsCountForServer) >= CRAFT_LIMIT_PER_SERVER then
return false
end
local posString = posToString(pos)
self.craftsCountForPlayers[playerName][posString] = true
self.craftsCountForServer[posString] = true
return true
end
---Remove craft from the counter.
---@param pos MapPosition
---@param playerName string
function ImmersiveCraftCounter:removeCraft(pos, playerName)
local playerCrafts = self.craftsCountForPlayers[playerName]
if playerCrafts == nil then
return
end
local posString = posToString(pos)
playerCrafts[posString] = nil
self.craftsCountForServer[posString] = nil
end
core.register_on_shutdown(function()
setStorageTable('crafts_count_for_players', ImmersiveCraftCounter.craftsCountForPlayers)
setStorageTable('crafts_count_for_server', ImmersiveCraftCounter.craftsCountForServer)
end)
return ImmersiveCraftCounter

View File

@@ -0,0 +1,71 @@
local extend = Class.extend
local tableInsert = table.insert
local modInfo = Mod.getInfo('smc__core__craft_system')
local require = modInfo.require
---@type CraftSystem.BaseCraftHandler
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<string, CraftSystem.ImmersiveCraft[]>
---@field getCraftByName fun(self, craftName:string):CraftSystem.ImmersiveCraft
---@field getCraftsByGroup fun(self, craftGroup):CraftSystem.ImmersiveCraft[]
---@field getLearnedCrafts fun(self, playerName):table<string, CraftSystem.ImmersiveCraft>
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: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)
local crafts = self.craftsByTriggerItem[triggerItem]
return crafts
end
return ImmersiveCraftHandler

View File

@@ -0,0 +1,14 @@
---@type 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 = {},
}
})
return ImmersiveCraftNode

View File

@@ -0,0 +1,95 @@
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,
---@type ObjectProperties
initial_properties = {
visual = 'wielditem',
visual_size = {x=0.5, y=0.5, z=0.5},
collisionbox = {
-0.375, -0.375, -0.375,
0.375, 0.375, 0.375
},
},
_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, luaEntity)
return false
end,
---@param luaEntity CraftSystem.ImmersiveCraftNode.LuaTappingNode
get_staticdata = function(luaEntity)
---@type CraftSystem.ImmersiveCraftStage.TappingNode.InitParams?
local params = {
targetItem = luaEntity._item_name,
craftName = luaEntity._craft_name,
stageName = luaEntity._stage_name,
WorkStationPos = luaEntity._work_station_pos
}
return core.serialize(params)
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

View File

@@ -0,0 +1,43 @@
local getInstance = Class.getInstance
---@alias CraftSystem.ImmersiveCraftStage.Type 'tapping'
---One of the stages of immersive crafting.
---@class CraftSystem.ImmersiveCraftStage
---@field name string
---@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 abortHandler fun(self, pos:Position)
---@field toString fun(self):string
---@field nextStage string?
---@field returnItems ItemStackString[]?
local ImmersiveCraftStage = {}
---Definition table for the `CraftSystem.ImmersiveCraft`.
---
---**Only for EmmyLua.**
---@class CraftSystem.ImmersiveCraftStageDef
---@field name string
---@field type CraftSystem.ImmersiveCraftStage.Type
---@field craftName string?
---@field nextStage string?
---@field returnItems ItemStackString[]?
---@param def CraftSystem.ImmersiveCraftStageDef
---@return CraftSystem.ImmersiveCraftStage
function ImmersiveCraftStage:new(def)
---@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
return ImmersiveCraftStage

View File

@@ -0,0 +1,202 @@
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 toolGroup 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)
---@field toString fun(self:CraftSystem.ImmersiveCraftStage.TappingStage):string
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
---@field toolGroup 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
instance.toolGroup = def.toolGroup
-- 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.875,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)
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)
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()
-- We trigger an event that the crafting stage has been completed.
Events.call('craft_system:next_immersive_stage:'..tappingStage.craftName, tappingStage, pos, player)
end
-- Registering the aborting the crafting process handler.
---@param tappingStage CraftSystem.ImmersiveCraftStage.TappingStage
instance.abortHandler = function(tappingStage, pos)
-- We receive current data on crafting.
---@type ImmersiveCraftData?
local craftData = Smc.getCraftDataByPos(pos)
assert(craftData ~= nil, 'Immersive crafting data is empty.')
-- Obtaining stage time data from work station metadata.
---@type ImmersiveStageData.TappingStageData?
local stageData = craftData.stageData
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()
-- We drop the item as it was before processing.
local dropPos = vector.new(pos)+vector.new(0, 0.9,0)
for i=1, craftData.amount do
core.item_drop(ItemStack(tappingStage.targetItem), nil, dropPos)
end
end
-- Returns a human-readable description of the crafting stage.
instance.toString = function(tappingStage)
local stageDesc
if tappingStage.toolGroup ~= nil then
stageDesc = ('Tapping x%s tool with a group "%s"'):format(tappingStage.clicksNeed, tappingStage.toolGroup)
else
stageDesc = ('Tapping x%s'):format(tappingStage.clicksNeed)
end
return stageDesc
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),
---@param craftNode LuaEntity
---@param player Player
function(eventName, pos, player, craftNode)
-- We get the item that the player clicked on the crafting node.
local toolDef = player:get_wielded_item():get_definition()
-- If a crafting stage requires a specific tool group and he doesn't have it...
if instance.toolGroup and (not toolDef.groups or not toolDef.groups[instance.toolGroup]) then
-- ...then we don't do anything.
return
end
-- DRAFT START:
-- Creating particles
for i=0, 10 do
core.add_particle({
pos = vector.new(pos)+vector.new(0,0.5,0),
velocity = {x=math.random(-1,1), y=4, z=math.random(-1,1)},
acceleration = {x=0, y=-9.8, z=0},
expirationtime = 2,
collision_removal = true,
node = {name=instance.targetItem}
})
end
-- Making the entity shake (silly method :P).
craftNode.object:set_rotation(vector.new(0.01,0.1,0.01))
core.after(0.1, function() craftNode.object:set_rotation(vector.new(-0.01,-0.1,-0.01))end)
core.after(0.2, function() craftNode.object:set_rotation(vector.new(0,0,0))end)
-- DRAFT END
-- Calling the crafting stage process handler.
instance:processHandler(pos, player)
end)
return instance
end
-- Registering an entity for immersive tapping crafting.
require('CraftSystem.ImmersiveCraftNode.tappingNode')
return TappingStage

View File

@@ -0,0 +1,39 @@
local getInstance, extend = Class.getInstance, Class.extend
local modInfo = Mod.getInfo('smc__core__craft_system')
local require = modInfo.require
---@type CraftSystem.BaseCraft
local BaseCraft = require('CraftSystem.BaseCraft')
---@class CraftSystem.PrimitiveCraft : CraftSystem.BaseCraft
---@field output string
---@field recipe CraftSystem.CraftRecipe
---@field returnItems ItemStackString[]
local PrimitiveCraft = extend(BaseCraft, {})
---Definition table for the `CraftSystem.PrimitiveCraft`.
---
---**Only for EmmyLua.**
---@class CraftSystem.PrimitiveCraftDef : CraftSystem.BaseCraftDef
---@field output string
---@field recipe CraftSystem.CraftRecipe
---@field returnItems ItemStackString[]
---@param name string
---@param def CraftSystem.PrimitiveCraftDef
---@return CraftSystem.PrimitiveCraft
function PrimitiveCraft:new(name, def)
---@type CraftSystem.PrimitiveCraft
local instance = getInstance(self, {
name = name,
group = def.group,
output = def.output,
recipe = def.recipe,
returnItems = def.returnItems or {}
})
return instance
end
return PrimitiveCraft

View File

@@ -0,0 +1,42 @@
local extend = Class.extend
local tableInsert = table.insert
local modInfo = Mod.getInfo('smc__core__craft_system')
local require = modInfo.require
---@type CraftSystem.BaseCraftHandler
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<string, CraftSystem.PrimitiveCraft>
local PrimitiveCraftHandler = extend(BaseCraftHandler, {})
---Register a primitive craft that does not require special interaction.
---@param craftName string
---@param def CraftSystem.PrimitiveCraftDef
function PrimitiveCraftHandler:registerCraft(craftName, def)
assert(self.craftsByName[craftName] == nil, ('A craft named `%s` already exists.'):format(
craftName))
local craft = PrimitiveCraft:new(craftName, def)
local group = def.group
if self.craftsByGroup[group] == nil then
self.craftsByGroup[group] = {}
end
self.craftsByName[craftName] = craft
tableInsert(self.craftsByGroup[group], craft)
tableInsert(self.craftsList, craft)
end
return PrimitiveCraftHandler

View File

@@ -0,0 +1,4 @@
local modInfo = Mod.getInfo('smc__core__creature')
local require = modInfo.require
return require('Creature')

View File

@@ -0,0 +1 @@
name = smc__core__creature

View File

@@ -0,0 +1,109 @@
local getInstance, extend = Class.getInstance, Class.extend
local tableCopy, tableMerge = table.copy, table.merge
---@class Creature
---@field entityDef Creature.CreatureDefinition
---@field luantiDef EntityDefinition
---@field defaultDef Creature.CreatureDefinition
local Creature = {
defaultDef = {
settings = {
_name = '',
_add_mod_name = true,
initial_properties = {},
},
callbacks = {}
}
}
---@param entityDef Creature.CreatureDefinition
---@return EntityDefinition
local function entityDefToLuantiDef(entityDef)
entityDef = tableCopy(entityDef)
local s = entityDef.settings
local c = entityDef.callbacks or {}
---@type EntityDefinition
local luantiDef = tableMerge(s, c)
return luantiDef
end
---@param entityDef Creature.CreatureDefinition
---@return Creature
function Creature:new(entityDef)
-- Adding default parameters.
---@type Creature.CreatureDefinition
entityDef = tableMerge(entityDef, self.defaultDef, true)
-- The callback table may not be specified.
if entityDef.callbacks == nil then
---@type Creature.Callbacks
entityDef.callbacks = {}
end
local s = entityDef.settings
local c = entityDef.callbacks
-- Add the short mod name prefix to the entity name.
if s._add_mod_name then
s._name = Mod.getInfo().shortName .. ':' .. s._name
end
local onActivate = c.on_activate or function() end
-- We rewrite the entity initialization function so that custom fields
-- can be passed to it directly via `core.add_entity(pos, name, [staticdata])`.
c.on_activate = function(luaEntity, staticdata, dtime)
local initCustomFields = {}
if staticdata and staticdata ~= '' then
initCustomFields = core.deserialize(staticdata) or {}
end
-- We reset the fields that should not be overwritten.
initCustomFields.name = nil
initCustomFields.object = nil
---@type LuaEntity
self = tableMerge(self, initCustomFields)
-- If an initialization callback was specified for the entity, then we call it.
if c.on_activate ~= nil then
onActivate(luaEntity, staticdata, dtime)
end
end
---@type Creature
local instance = getInstance(self, {})
local luantiDef = entityDefToLuantiDef(entityDef)
instance.entityDef = entityDef
instance.luantiDef = luantiDef
core.register_entity(':'..s._name, luantiDef)
return instance
end
---Allows you to create a child class of an entity by specifying
---default parameters that will be added to the entity's parameters
---when an instance is received.
---@param defaultDef Creature.CreatureDefinition
---@return Creature
function Creature:getExtended(defaultDef)
-- Adding default parameters.
---@type Creature.CreatureDefinition
defaultDef = tableMerge(self.defaultDef, defaultDef)
---@type Creature
local ChildClass = extend(self, {
defaultDef = defaultDef,
})
return ChildClass
end
return Creature

View File

@@ -0,0 +1,72 @@
---@class Creature.Callbacks
local Callbacks = {}
---Called when the object is instantiated.
--- * `dtime_s` is the time passed since the object was unloaded,
---which can be used for updating the entity state.
---@type fun(self:LuaEntity, staticdata:string, dtime_s:number)?
Callbacks.on_activate = nil
---Called when the object is about to get removed or unloaded.
--- * `removal`: boolean indicating whether the object is about to get removed.
--- Calling `object:remove()` on an active object will call this with `removal=true`.
--- The mapblock the entity resides in being unloaded will call this with `removal=false`.
---
---Note that this won't be called if the object hasn't been activated in the first place.
---In particular, `core.clear_objects({mode = "full"})` won't call this,
---whereas `core.clear_objects({mode = "quick"})` might call this.
---@type fun(self:LuaEntity, removal:boolean)?
Callbacks.on_deactivate = nil
---Called on every server tick, after movement and collision processing.
--- * `dtime`: elapsed time since last call
--- * `s`: table with collision info (only available if `physical=true`)
---@type fun(self:LuaEntity, dtime:number, moveresult:table)? -- TODO: дописать более точный тип moveresult
Callbacks.on_step = nil
---Called when somebody punches the object.
---Note that you probably want to handle most punches using the automatic armor group system.
--- * `puncher`: an `ObjectRef `(can be `nil`)
--- * `time_from_last_punch`: Meant for disallowing spamming of clicks (can be `nil`).
--- * `tool_capabilities`: capability table of used item
--- * `dir`: unit vector of direction of punch. Always defined. Points from the puncher to the punched.
--- * `damage``: damage that will be done to entity.
---
---Can return `true` to prevent the default damage mechanism.
---@type (fun(self:LuaEntity, puncher:ObjectRef|Player|nil, time_from_last_punch:number|nil, tool_capabilities:table|nil, dir:vector, damage:number):boolean)? -- TODO: дописать более точный тип для tool_capabilities
Callbacks.on_punch = nil
---Called when the object dies.
--- * `killer`: an `ObjectRef` (can be `nil`)
---@type fun(self:LuaEntity, killer:ObjectRef|Player|nil)?
Callbacks.on_death = nil
---Called when `clicker` pressed the 'place/use' key while
---pointing to the object (not necessarily an actual rightclick)
--- * `clicker`: an `ObjectRef` (may or may not be a player)
---@type fun(self:LuaEntity, clicker:ObjectRef|Player)?
Callbacks.on_rightclick = nil
---Called after another object is attached to this object.
--- * `child`: an `ObjectRef` of the child
---@type fun(self:LuaEntity, child:ObjectRef)?
Callbacks.on_attach_child = nil
---Called after another object has detached from this object.
--- * `child`: an `ObjectRef` of the child
---@type fun(self:LuaEntity, child:ObjectRef)?
Callbacks.on_detach_child = nil
---Called after detaching from another object.
--- * `parent`: an ObjectRef from where it got detached
---
---**Note**: this is also called before removal from the world.
---@type fun(self:LuaEntity, parent)?
Callbacks.on_detach = nil
---Should return a string that will be passed to `on_activate` when the object
---is instantiated the next time.
---@type (fun(self:LuaEntity):string)?
Callbacks.get_staticdata = nil
return Callbacks

View File

@@ -0,0 +1,6 @@
---@class Creature.CreatureDefinition
---@field settings Creature.Settings
---@field callbacks Creature.Callbacks?
local CreatureDefinition = {}
return CreatureDefinition

View File

@@ -0,0 +1,9 @@
---A class that extends `LuaEntity` to annotate custom fields.
---
---**Only for EmmyLua.**
---@class Creature.LuaEntity : LuaEntity
---@field _name string
---@field _add_mod_name boolean
local LuaEntity = {}
return LuaEntity

View File

@@ -0,0 +1,14 @@
---@class Creature.Settings
local Settings = {}
---Registration name for the entity. Must be unique.
---@type string
Settings._name = nil
---Whether to add the mod name to the settings._name. Default: `true`
Settings._add_mod_name = nil
---@type ObjectProperties
Settings.initial_properties = nil
return Settings

View File

@@ -1 +0,0 @@
name = smc__core__entity

View File

@@ -0,0 +1,9 @@
# textdomain: item
Rarity=Редкость
common=простой
uncommon=необычный
distinguished=выдающийся
eminent=исключительный
prime=Превосходный
unique=Уникальный

View File

@@ -1,33 +1,82 @@
local getInstance = Class.getInstance local getInstance, extend = Class.getInstance, Class.extend
local modInfo = Mod.getInfo('smc__core__item') local tableCopy, tableMerge, colorize = table.copy, table.merge, core.colorize
local require = modInfo.require
local ItemFactory = Mod.getInfo('smc__core__item_factory').require('ItemFactory') local ItemFactory = Smc.requireItemFactory()
---Determines whether common rarity will be shown in item descriptions or not.
local SHOW_COMMON_RARITY = true
---Colors corresponding to the rarity color in the item description.
---@type table<Item.Rarity, ColorString>
local RARITY_COLORS = {
['common'] = '#C0C0C0',
['uncommon'] = '#7cd2e2',
['distinguished'] = '#7ce2da',
['eminent'] = '#44d1a9',
['prime'] = '#9CF0B1',
['unique'] = '#f4c95a'
}
---Whether to show the numeric index in the rarity description.
local SHOW_RARITY_INDEX = true
---@type table<Item.Rarity, integer>
local RARITY_INDEX = {
['common'] = 1,
['uncommon'] = 2,
['distinguished'] = 3,
['eminent'] = 4,
['prime'] = 5,
['unique'] = 0
}
---@class Item ---@class Item
---@field itemDef Item.ItemDefinition ---@field itemDef Item.ItemDefinition
---@field luantiDef table ---@field luantiDef ItemDefinition
---@field getVisual fun(): string ---@field getType fun():string
---@field defaultDef Item.ItemDefinition ---@field defaultDef Item.ItemDefinition
local Item = { local Item = {
defaultDef = { defaultDef = {
settings = { settings = {
name = '', name = '',
title = '', _title = '',
description = '', _description = '',
titleColor = '#FFFFFF', _title_color = '#FFFFFF',
descriptionColor = '#C0C0C0', _description_color = '#838383',
addModName = true, _rarity = 'common',
_add_mod_name = true,
stack_max = 128,
}, },
callbacks = {} callbacks = {}
} }
} }
---Adds an item's rarity tag to the description.
---@param rarity Item.Rarity
---@param desc string
---@return string
local function addRarityToDesc(rarity, desc)
if not SHOW_COMMON_RARITY and rarity == 'common' then
return desc
end
local S = core.get_translator('item')
local color = RARITY_COLORS[rarity]
local rarityString = S('Rarity')..': '..S(rarity)
if SHOW_RARITY_INDEX then
rarityString = rarityString..' ['..RARITY_INDEX[rarity]..']'
end
return desc..'\n'..colorize(color, rarityString)
end
---The alias `table.merge` for EmmyLua ---The alias `table.merge` for EmmyLua
---@type fun(...):(NodeDefinition|ItemDefinition) ---@type fun(...):(NodeDefinition|ItemDefinition)
local defMerge = function(...) local defMerge = function(...)
return table.merge(...) return tableMerge(...)
end end
---@param itemDef Item.ItemDefinition ---@param itemDef Item.ItemDefinition
@@ -36,16 +85,10 @@ local function itemDefToLuantiDef(itemDef)
local modName = Mod.getInfo().shortName local modName = Mod.getInfo().shortName
local S = core.get_translator(modName) local S = core.get_translator(modName)
itemDef = table.copy(itemDef)
local s = itemDef.settings local s = itemDef.settings
local c = itemDef.callbacks local c = itemDef.callbacks
if s.addModName then local title, description = s._title, s._description
s.name = modName .. ':' .. s.name
end
local title = s.title
local description = s.description
if title == nil or title == '' then if title == nil or title == '' then
title = string.match(s.name, '%S:(%S+)')..'-title' title = string.match(s.name, '%S:(%S+)')..'-title'
@@ -55,74 +98,106 @@ local function itemDefToLuantiDef(itemDef)
description = string.match(s.name, '%S:(%S+)')..'-desc' description = string.match(s.name, '%S:(%S+)')..'-desc'
end end
if s.titleColor ~= nil and s.descriptionColor ~= nil then if s._title_color ~= nil and s._description_color ~= nil then
description = core.colorize(s.titleColor ,S(title))..'\n'.. title = colorize(s._title_color , S(title))
core.colorize(s.descriptionColor, S(description)) description = colorize(s._description_color, S(description))
else else
error('Item description color parameters cannot be empty.') error('Item description color parameters cannot be empty.')
end end
s.title, s.description = nil, description assert(s._rarity ~= nil, 'The rarity of an item cannot be empty.')
local luantiDescription = addRarityToDesc(s._rarity, title..'\n '..description)
s._title = title
s._description = description
s.description = luantiDescription..core.get_background_escape_sequence('#110F13')
local luantiDef = defMerge(s, c) local luantiDef = defMerge(s, c)
return luantiDef return luantiDef
end end
---@param luantiDef NodeDefinition|ItemDefinition ---@param luantiDef NodeDefinition
local function register3dItem(luantiDef) local function registerNode(luantiDef)
local ld = luantiDef local name = luantiDef.name
local name = ld.name luantiDef.name = nil
ld.name = nil
core.register_node(':'..name, luantiDef) core.register_node(':'..name, luantiDef)
end end
---@param luantiDef ItemDefinition ---@param luantiDef ItemDefinition
local function registerFlatItem(luantiDef) local function registerCraftitem(luantiDef)
local ld = luantiDef local name = luantiDef.name
local name = ld.name luantiDef.name = nil
ld.name = nil
core.register_craftitem(':'..name, luantiDef) core.register_craftitem(':'..name, luantiDef)
end end
---@param luantiDef ItemDefinition
local function registerTool(luantiDef)
local name = luantiDef.name
luantiDef.name = nil
core.register_tool(':'..name, luantiDef)
end
---The alias `table.merge` for EmmyLua ---The alias `table.merge` for EmmyLua
---@type fun(...):(Item.ItemDefinition) ---@type fun(...):(Item.ItemDefinition)
local defMerge = function(...) local defMerge = function(...)
return table.merge(...) return tableMerge(...)
end end
---@param itemDef Item.ItemDefinition|Node.NodeDefinition ---@param itemDef Item.ItemDefinition|Node.NodeDefinition
---@return Item ---@return Item
function Item:new(itemDef) function Item:new(itemDef)
---Adding default parameters assert(itemDef.settings.description == nil,
'The item description was specified using `description`, not `_description`. '..
'Please note that the `description` field should not be used when registering an item. '..
'Use `_title` and `_description` instead.')
itemDef = tableCopy(itemDef)
-- Adding default parameters
itemDef = defMerge(itemDef, self.defaultDef, true) itemDef = defMerge(itemDef, self.defaultDef, true)
local s = itemDef.settings
local shortModName = Mod.getInfo().shortName
if s._add_mod_name then
s.name = shortModName .. ':' .. s.name
end
---@type Item ---@type Item
local instance = getInstance(self, {}) local instance = getInstance(self, {})
local luantiDef = itemDefToLuantiDef(itemDef) local luantiDef = itemDefToLuantiDef(itemDef)
local visual = itemDef.settings.visual local type = itemDef.settings._type
if visual == nil then if type == nil then
visual = 'item_2d' type = 'craftitem'
end end
itemDef.settings.visual = nil itemDef.settings._type = nil
if visual == 'item_3d' then if type == 'node' then
register3dItem(luantiDef) registerNode(luantiDef)
elseif type == 'craftitem' then
registerCraftitem(luantiDef)
elseif type == 'tool' then
registerTool(luantiDef)
else else
visual = 'item_2d' error(('Unknown item type: `%s`.'):format(type))
registerFlatItem(luantiDef)
end end
function instance:getVisual() function instance:getType()
return visual return type
end end
instance.itemDef = itemDef instance.itemDef = itemDef
instance.luantiDef = luantiDef instance.luantiDef = luantiDef
Smc.addRegisteredItem(shortModName, instance)
return instance return instance
end end
@@ -132,8 +207,10 @@ end
---@param defaultDef Item.ItemDefinition ---@param defaultDef Item.ItemDefinition
---@return Item ---@return Item
function Item:getExtended(defaultDef) function Item:getExtended(defaultDef)
defaultDef = defMerge(defaultDef, self.defaultDef, true)
---@type Item ---@type Item
local ChildClass = Class.extend(self, { local ChildClass = extend(self, {
defaultDef = defaultDef, defaultDef = defaultDef,
}) })
@@ -146,6 +223,8 @@ end
function Item:getFactory(defaultDef) function Item:getFactory(defaultDef)
if defaultDef == nil then if defaultDef == nil then
defaultDef = self.defaultDef defaultDef = self.defaultDef
else
defaultDef = defMerge(self.defaultDef, defaultDef, true)
end end
---@type ItemFactory ---@type ItemFactory

View File

@@ -0,0 +1,8 @@
---Rarity of items:
--- * `common`
--- * `uncommon`
--- * `distinguished`
--- * `eminent`
--- * `prime`
--- * `unique`
---@alias Item.Rarity 'common'|'uncommon'|'distinguished'|'eminent'|'prime'|'unique'

View File

@@ -5,38 +5,40 @@ local Settings = {}
---@type string ---@type string
Settings.name = '' Settings.name = ''
---@type string?
Settings.description = nil
---Whether to add the mod name to the settings.name. Default: `true` ---Whether to add the mod name to the settings.name. Default: `true`
---@type boolean? ---@type boolean?
Settings.addModName = nil Settings._add_mod_name = nil
---Item description. 1st line of item description. ---Item description. 1st line of item description.
---@type string? ---@type string?
Settings.title = nil Settings._title = nil
---Item description. The rest of item description. ---Item description. The rest of item description.
---@type string? ---@type string?
Settings.description = nil Settings._description = nil
---Item title color in description. ---Item title color in description.
--- ---
---Default: `#FFFFFF` ---Default: `#FFFFFF`
---@type ColorString? ---@type ColorString?
Settings.titleColor = nil Settings._title_color = nil
---Item description color in description. ---Item description color in description.
--- ---
---Default: `#C0C0C0` ---Default: `#C0C0C0`
---@type ColorString? ---@type ColorString?
Settings.descriptionColor = nil Settings._description_color = nil
---@alias Item.Visual
---'item_2d'|
---'item_3d'
---Visual node type. ---Visual node type.
---@type Item.Visual? ---@type Item.Type?
Settings.visual = nil Settings._type = nil
---Formal (lore) rarity of an item. Default `common`.
---@type Item.Rarity?
Settings._rarity = nil
---Table of groups-characteristics of Item. ---Table of groups-characteristics of Item.

View File

@@ -0,0 +1 @@
---@alias Item.Type 'craftitem'|'node'|'tool'

File diff suppressed because it is too large Load Diff

View File

@@ -18,9 +18,10 @@ local getInstance = Class.getInstance
---@field generateTurf generateFunc ---@field generateTurf generateFunc
---@field generateSoil generateFunc ---@field generateSoil generateFunc
---@field generateBottom generateFunc ---@field generateBottom generateFunc
---@field postProcessing fun(self, mapGenerator:MapGen, factors:MapGen.factors, data:number[], index:number, x:number, y:number, z:number, nodeType:MapGen.nodeType, area:VoxelArea)?
local Biome = {} local Biome = {}
---@alias generateFunc fun(self, mapGenerator:MapGen, data:number[], index:number, x:number, y:number, z:number) ---@alias generateFunc fun(self, mapGenerator:MapGen, factors:MapGen.factors, data:number[], index:number, x:number, y:number, z:number)
---Definition table for the `MapGen.Biome`. ---Definition table for the `MapGen.Biome`.
--- ---
@@ -39,84 +40,91 @@ local Biome = {}
---@field generateTurf generateFunc? ---@field generateTurf generateFunc?
---@field generateSoil generateFunc? ---@field generateSoil generateFunc?
---@field generateBottom generateFunc? ---@field generateBottom generateFunc?
---@field postProcessing fun(self, mapGenerator:MapGen, factors:MapGen.factors, data:number[], index:number, x:number, y:number, z:number, nodeType:MapGen.nodeType, area:VoxelArea)?
-- Default generate functions -- Default generate functions
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateAir = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateAir = function(self, mapGenerator, factors, data, index, x, y, z)
data[index] = mapGenerator.nodeIDs.air data[index] = mapGenerator.nodeIDs.air
end end
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateCavernAir = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateCavernAir = function(self, mapGenerator, factors, data, index, x, y, z)
self:generateAir(mapGenerator, data, index, x, y, z) self:generateAir(mapGenerator, factors, data, index, x, y, z)
end end
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateWater = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateWater = function(self, mapGenerator, factors, data, index, x, y, z)
data[index] = mapGenerator.nodeIDs.water data[index] = mapGenerator.nodeIDs.water
end end
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateRock = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateRock = function(self, mapGenerator, factors, data, index, x, y, z)
data[index] = self.groundNodesIDs.rock data[index] = self.groundNodesIDs.rock
end end
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateTurf = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateTurf = function(self, mapGenerator, factors, data, index, x, y, z)
data[index] = self.groundNodesIDs.turf data[index] = self.groundNodesIDs.turf
end end
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateSoil = function(self, mapGenerator,data, index, x, y, z) local defaultGenerateSoil = function(self, mapGenerator, factors, data, index, x, y, z)
data[index] = self.groundNodesIDs.soil data[index] = self.groundNodesIDs.soil
end end
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateBottom = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateBottom = function(self, mapGenerator, factors, data, index, x, y, z)
data[index] = self.groundNodesIDs.bottom data[index] = self.groundNodesIDs.bottom
end end
@@ -167,23 +175,23 @@ function Biome:new(name, def)
end end
---@type MapGen.Biome ---@type MapGen.Biome
local instance = getInstance(self, { local instance = getInstance(self, {})
name = name, instance.name = name
tempPoint = def.tempPoint, instance.tempPoint = def.tempPoint
humidityPoint = def.humidityPoint, instance.humidityPoint = def.humidityPoint
minY = def.minY, instance.minY = def.minY
maxY = def.maxY, instance.maxY = def.maxY
groundNodes = def.groundNodes, instance.groundNodes = def.groundNodes
groundNodesIDs = groundNodesIDs, instance.groundNodesIDs = groundNodesIDs
soilHeight = def.soilHeight, instance.soilHeight = def.soilHeight
generateAir = def.generateAir, instance.generateAir = def.generateAir
generateCavernAir = def.generateCavernAir, instance.generateCavernAir = def.generateCavernAir
generateWater = def.generateWater, instance.generateWater = def.generateWater
generateRock = def.generateRock, instance.generateRock = def.generateRock
generateSoil = def.generateSoil, instance.generateSoil = def.generateSoil
generateTurf = def.generateTurf, instance.generateTurf = def.generateTurf
generateBottom = def.generateBottom, instance.generateBottom = def.generateBottom
}) instance.postProcessing = def.postProcessing
return instance return instance
end end

View File

@@ -1,18 +1,20 @@
local getInstance = Class.getInstance local getInstance = Class.getInstance
---@class MapGen.Triangulation.Edge ---@class MapGen.Edge
---@field p1 MapGen.Peak ---@field p1 MapGen.Peak
---@field p2 MapGen.Peak ---@field p2 MapGen.Peak
---@field vec vector
local Edge = {} local Edge = {}
---@param p1 MapGen.Peak ---@param p1 MapGen.Peak
---@param p2 MapGen.Peak ---@param p2 MapGen.Peak
---@return MapGen.Triangulation.Edge ---@return MapGen.Edge
function Edge:new( p1, p2 ) function Edge:new( p1, p2 )
---@type MapGen.Triangulation.Edge ---@type MapGen.Edge
local instance = getInstance(self, { local instance = getInstance(self, {
p1 = p1, p1 = p1,
p2 = p2 p2 = p2,
vec = p2.pos - p1.pos
}, },
{ {
__tostring = self.toString, __tostring = self.toString,
@@ -29,14 +31,14 @@ function Edge:toString()
end end
---Returns true if the edges are equivalent. ---Returns true if the edges are equivalent.
---@param other MapGen.Triangulation.Edge ---@param other MapGen.Edge
---@return boolean ---@return boolean
function Edge:eq(other) function Edge:eq(other)
return self.p1 == other.p1 and self.p2 == other.p2 return self.p1 == other.p1 and self.p2 == other.p2
end end
---Returns true if the edges are similar. ---Returns true if the edges are similar.
---@param other MapGen.Triangulation.Edge ---@param other MapGen.Edge
---@return boolean ---@return boolean
function Edge:same(other) function Edge:same(other)
return (self.p1 == other.p1 and self.p2 == other.p2) return (self.p1 == other.p1 and self.p2 == other.p2)
@@ -46,14 +48,14 @@ end
---Returns the length of an edge. ---Returns the length of an edge.
---@return number ---@return number
function Edge:length() function Edge:length()
return (self.p1.getPeakPos() - self.p2.getPeakPos()):length() return (self.p1.pos - self.p2.pos):length()
end end
---Returns the vector of the point located in the middle of the edge. ---Returns the vector of the point located in the middle of the edge.
---@return vector ---@return vector
function Edge:getMidPoint() function Edge:getMidPoint()
local pos1 = self.p1:getPeakPos() local pos1 = self.p1.pos
local pos2 = self.p2:getPeakPos() local pos2 = self.p2.pos
return (pos1 + pos2 )/2 return (pos1 + pos2 )/2
end end

View File

@@ -7,14 +7,14 @@ local Peak = require('MapGen.Peak')
---Allows you to create a `MapGen.Peak` without specifying a noise parameter. ---Allows you to create a `MapGen.Peak` without specifying a noise parameter.
--- ---
---**WARNING: MUST NOT BE PARTICIPATED IN GENERATION** ---**WARNING: MUST NOT BE PARTICIPATED IN GENERATION**
---@class MapGen.Triangulation.FakePeak : MapGen.Peak ---@class MapGen.FakePeak : MapGen.Peak
---@field id number ---@field id number
---@field getPeakPos fun():vector ---@field getPeakPos fun():vector
local FakePeak = Class.extend(Peak, {}) local FakePeak = Class.extend(Peak, {})
---Returns a fake `MapGen.Peak` that has no noise parameters. ---Returns a fake `MapGen.Peak` that has no noise parameters.
---Note that the initialized peak should not be used in generation. ---Note that the initialized peak should not be used in generation.
---@param peakPos vector ---@param peakPos MapPosition|vector
---@return MapGen.Peak ---@return MapGen.Peak
function FakePeak:new(peakPos) function FakePeak:new(peakPos)
local instance = Peak:new({pos = peakPos, color = '#000000'}) local instance = Peak:new({pos = peakPos, color = '#000000'})

View File

@@ -1,5 +1,13 @@
local getInstance = Class.getInstance local getInstance = Class.getInstance
local modInfo = Mod.getInfo('smc__core__map_gen')
local require = modInfo.require
---@type MapGen.Peak
local Peak = require('MapGen.Peak')
---@type MapGen.Triangle
local Triangle = require('MapGen.Triangle')
---@class MapGen.Layer ---@class MapGen.Layer
---@field name string ---@field name string
---@field minY integer ---@field minY integer
@@ -11,9 +19,10 @@ local getInstance = Class.getInstance
---@field waterLevel integer ---@field waterLevel integer
---@field calcTemp fun(self:MapGen.Layer, value:number, height:number):number ---@field calcTemp fun(self:MapGen.Layer, value:number, height:number):number
---@field calcHumidity fun(self:MapGen.Layer, value:number, height:number):number ---@field calcHumidity fun(self:MapGen.Layer, value:number, height:number):number
---@field peaksList {['landscape']:MapGen.Peak[],['temp']:MapGen.Peak[],['humidity']:MapGen.Peak[]} ---@field peaksList MapGen.Peak[]
---@field noisesByColor {['landscape']:table<ColorString, ValueNoise>,['temp']:table<ColorString, ValueNoise>,['humidity']:table<ColorString, ValueNoise>} ---@field peaksByPos table<string, MapGen.Peak>
---@field noisesParamsByColor {['landscape']:table<ColorString, NoiseParams>,['temp']:table<ColorString, NoiseParams>,['humidity']:table<ColorString, NoiseParams>} ---@field noisesByColor table<MapGen.Layer.Category, table<ColorString, ValueNoise>>
---@field noisesParamsByColor table<MapGen.Layer.Category, table<ColorString, NoiseParams>>
---@field biomesByName table<string, MapGen.Biome> ---@field biomesByName table<string, MapGen.Biome>
---@field biomesList MapGen.Biome[] ---@field biomesList MapGen.Biome[]
---@field biomesDiagram table ---@field biomesDiagram table
@@ -22,14 +31,10 @@ local getInstance = Class.getInstance
---@field cavernsByName table<string, MapGen.Cavern> ---@field cavernsByName table<string, MapGen.Cavern>
---@field cavernsList MapGen.Cavern[] ---@field cavernsList MapGen.Cavern[]
---@field regionsByName table<string, MapGen.Region> ---@field regionsByName table<string, MapGen.Region>
---@field trianglesList {['landscape']:MapGen.Triangle[],['temp']:MapGen.Triangle[],['humidity']:MapGen.Triangle[]} ---@field trianglesList MapGen.Triangle[]
---@field tetrahedronsList MapGen.Tetrahedron[] **Not supported**
local Layer = { local Layer = {
peaksList = { peaksList = {},
landscape = {}, peaksByPos = {},
temp = {},
humidity = {},
},
noisesByColor = { noisesByColor = {
landscape = {}, landscape = {},
temp = {}, temp = {},
@@ -46,11 +51,7 @@ local Layer = {
cavernsByName = {}, cavernsByName = {},
cavernsList = {}, cavernsList = {},
regionsByName = {}, regionsByName = {},
trianglesList = { trianglesList = {},
landscape = {},
temp = {},
humidity = {},
},
tetrahedronsList = {}, tetrahedronsList = {},
} }
@@ -58,17 +59,23 @@ local Layer = {
--- ---
---**Only for EmmyLua.** ---**Only for EmmyLua.**
---@class MapGen.LayerDef ---@class MapGen.LayerDef
---@field minY number ---@field minY integer
---@field maxY number ---@field maxY integer
---@field minTemp number ---@field minTemp integer
---@field maxTemp number ---@field maxTemp integer
---@field minHumidity number ---@field minHumidity integer
---@field maxHumidity number ---@field maxHumidity integer
---@field waterLevel? number ---@field waterLevel? integer
---@field calcTemp (fun(self:MapGen.Layer, value:number, height:number):number)? ---@field calcTemp (fun(self:MapGen.Layer, value:number, height:number):number)?
---@field calcHumidity (fun(self:MapGen.Layer, value:number, height:number):number)? ---@field calcHumidity (fun(self:MapGen.Layer, value:number, height:number):number)?
---@field biomesGorizontalScattering number? ---@field biomesGorizontalScattering integer?
---@field biomesVerticalScattering number? ---@field biomesVerticalScattering integer?
---@field triangulationLandscapeFile string
---@field triangulationTempFile string
---@field triangulationHumidityFile string
---@field landscapeMapScale number
---@field tempMapScale number
---@field humidityMapScale number
---@param self MapGen.Layer ---@param self MapGen.Layer
---@param value number ---@param value number
@@ -78,6 +85,73 @@ local function defaultCalcFunc(self, value, height)
return value return value
end end
---Checks `def` for compliance with `MapGen.PeakDef` and creates a new peak
---if a peak with such coordinates has not yet been registered or returns an existing one.
---
---**Note:** If the colors of the new peak and the existing one at the same coordinates
---are different, an error will be called.
---@param def MapGen.PeakDef
---@param scale number
---@return MapGen.Peak
function Layer:registerPeak(def, scale)
assert(def.pos ~= nil)
assert(def.pos.x ~= nil)
assert(def.pos.z ~= nil)
assert(def.color ~= nil)
assert(type(def.color) == 'string')
def.pos.x = def.pos.x * scale
def.pos.z = def.pos.z * scale
def.pos.y = 0
local positionStr = core.pos_to_string(def.pos)
local peak = self.peaksByPos[positionStr]
if peak == nil then
peak = Peak:new(def)
self.peaksByPos[positionStr] = peak
elseif peak.color ~= def.color then
error('There cannot be two peaks with the same coordinates but different colors.')
end
return peak
end
function Layer:initTrianglesNeighbours()
local triangles = self.trianglesList
for _, triangle in pairs(triangles) do
for _, id in ipairs(triangle.neighboursIDs) do
table.insert(triangle.neighbours, triangles[id])
end
end
end
---@param fileName string
---@param category MapGen.Layer.Category
---@param scale number
function Layer:getTriaglesFromFile(fileName, category, scale)
local file = io.open(core.get_modpath(core.get_current_modname())..'/maps/'..fileName, 'r')
assert(file ~= nil)
local json = core.parse_json(file:read('*a')) or {}
file:close()
local triangles = json.triangles
assert(triangles ~= nil)
for _, tr in ipairs(triangles) do
local p1 = self:registerPeak( tr.vertices[1], scale)
local p2 = self:registerPeak( tr.vertices[2], scale)
local p3 = self:registerPeak( tr.vertices[3], scale)
local triangle = Triangle:new(tr.id,p1, p2, p3, tr.adjacent_triangle_ids)
self:addTriangle(category, triangle)
end
end
---@param name string ---@param name string
---@param def MapGen.LayerDef ---@param def MapGen.LayerDef
---@return MapGen.Layer ---@return MapGen.Layer
@@ -93,20 +167,34 @@ function Layer:new(name, def)
end end
---@type MapGen.Layer ---@type MapGen.Layer
local instance = getInstance(self, { local instance = getInstance(self, {})
name = name, instance.name = name
minY = def.minY, instance.minY = def.minY
maxY = def.maxY, instance.maxY = def.maxY
minTemp = def.minTemp, instance.minTemp = def.minTemp
maxTemp = def.maxTemp, instance.maxTemp = def.maxTemp
minHumidity = def.minHumidity, instance.minHumidity = def.minHumidity
maxHumidity = def.maxHumidity, instance.maxHumidity = def.maxHumidity
waterLevel = def.waterLevel or 0, instance.waterLevel = def.waterLevel or 0
calcTemp = def.calcTemp, instance.calcTemp = def.calcTemp
calcHumidity = def.calcHumidity, instance.calcHumidity = def.calcHumidity
biomesGorizontalScattering = def.biomesGorizontalScattering or 0, instance.biomesGorizontalScattering = def.biomesGorizontalScattering or 0
biomesVerticalScattering = def.biomesVerticalScattering or 0, instance.biomesVerticalScattering = def.biomesVerticalScattering or 0
})
instance:getTriaglesFromFile(
def.triangulationLandscapeFile,
'landscape',
def.landscapeMapScale)
instance:getTriaglesFromFile(
def.triangulationTempFile,
'temp',
def.tempMapScale)
instance:getTriaglesFromFile(
def.triangulationHumidityFile,
'humidity',
def.humidityMapScale)
instance:initTrianglesNeighbours()
return instance return instance
end end
@@ -114,34 +202,34 @@ end
---A category of noise that affects specific map generation objects. ---A category of noise that affects specific map generation objects.
---@alias MapGen.Layer.Category 'landscape'|'temp'|'humidity' ---@alias MapGen.Layer.Category 'landscape'|'temp'|'humidity'
---Adds a peak to the `Layer.peaksList` ---Adds a triangle to the `Layer.trianglesList`
---@param category MapGen.Layer.Category ---@param category MapGen.Layer.Category
---@param peak MapGen.Peak ---@param triangle MapGen.Triangle
function Layer:addPeak(category, peak) function Layer:addTriangle(category, triangle)
if category == 'landscape' then local triangles = self.trianglesList
table.insert(self.peaksList.landscape, peak) if triangles ~= nil then
elseif category == 'temp' then triangles[triangle.id] = triangle
table.insert(self.peaksList.temp, peak)
elseif category == 'humidity' then
table.insert(self.peaksList.humidity, peak)
else else
error(('There is no peak category named %s.'):format(category)) error(('There is no peak category named %s.'):format(category))
end end
end end
---Adds a peak to the `Layer.peaksList`
---@param category MapGen.Layer.Category
---@param peak MapGen.Peak
function Layer:addPeak(category, peak)
table.insert(self.peaksList, peak)
end
---Returns the `MapGen.Peak` at the coordinates. If there is no peak at these coordinates, it returns `nil`. ---Returns the `MapGen.Peak` at the coordinates. If there is no peak at these coordinates, it returns `nil`.
---@param category MapGen.Layer.Category The category in which the peak is located.
---@param pos Position Coordinate of the desired peak. ---@param pos Position Coordinate of the desired peak.
---@return MapGen.Peak? ---@return MapGen.Peak?
function Layer:getPeakByPos(category, pos) function Layer:getPeakByPos(pos)
pos = vector.new(pos) local positionStr = core.pos_to_string(pos)
local peak = self.peaksByPos[positionStr]
---@param peak MapGen.Peak
for _, peak in ipairs(self.peaksList[category]) do
if peak:getPeakPos() == pos then
return peak return peak
end
end
end end
---Adds a NoiseParams color to the `Layer.noisesParamsByColor` ---Adds a NoiseParams color to the `Layer.noisesParamsByColor`

View File

@@ -2,8 +2,8 @@ local getInstance = Class.getInstance
---@class MapGen.Peak ---@class MapGen.Peak
---@field id number ---@field id number
---@field getPeakPos fun(self):vector ---@field pos vector
---@field getColor fun(self):ColorString ---@field color ColorString
---@field getGroups fun(self):table<string, number> ---@field getGroups fun(self):table<string, number>
---@field addGroups fun(self, groups:table<string, number>) ---@field addGroups fun(self, groups:table<string, number>)
local Peak = { local Peak = {
@@ -16,14 +16,13 @@ local Peak = {
--- ---
---**Only for EmmyLua.** ---**Only for EmmyLua.**
---@class MapGen.PeakDef ---@class MapGen.PeakDef
---@field pos vector ---@field pos MapPosition|vector
---@field color ColorString ---@field color ColorString
---@field groups? table<string, number> ---@field groups? table<string, number>
---@param def MapGen.PeakDef ---@param def MapGen.PeakDef
---@return MapGen.Peak ---@return MapGen.Peak
function Peak:new(def) function Peak:new(def)
local _pos = def.pos
local _color = def.color local _color = def.color
local _groups local _groups
@@ -39,14 +38,8 @@ function Peak:new(def)
__tostring = self.toString, __tostring = self.toString,
__eq = self.eq __eq = self.eq
}) })
instance.pos = vector.new(def.pos)
function instance:getPeakPos() instance.color = def.color
return _pos:copy()
end
function instance:getColor()
return _color
end
function instance:getGroups() function instance:getGroups()
return table.copy_with_metatables(_groups) return table.copy_with_metatables(_groups)
@@ -66,7 +59,7 @@ end
---Returns a string describing the object in a readable form. ---Returns a string describing the object in a readable form.
---@return string ---@return string
function Peak:toString() function Peak:toString()
local pos = self:getPeakPos() local pos = self.pos
return ('Peak (%s) x: %.2f y: %.2f z: %.2f'):format( self.id, pos.x, pos.y, pos.z) return ('Peak (%s) x: %.2f y: %.2f z: %.2f'):format( self.id, pos.x, pos.y, pos.z)
end end
@@ -74,8 +67,8 @@ end
---@param other MapGen.Peak ---@param other MapGen.Peak
---@return boolean ---@return boolean
function Peak:eq(other) function Peak:eq(other)
local pos1 = self:getPeakPos() local pos1 = self.pos
local pos2 = other:getPeakPos() local pos2 = other.pos
return pos1.x == pos2.x and pos1.z == pos2.z return pos1.x == pos2.x and pos1.z == pos2.z
end end

View File

@@ -4,11 +4,11 @@ local getInstance = Class.getInstance
---@class MapGen.Region ---@class MapGen.Region
---@field name string ---@field name string
---@field vertices Position[] ---@field vertices MapPosition[]
local Region = {} local Region = {}
---@class MapGen.RegionDef ---@class MapGen.RegionDef
---@field vertices Position[] ---@field vertices MapPosition[]
---@param def MapGen.RegionDef ---@param def MapGen.RegionDef
---@return MapGen.Region ---@return MapGen.Region
@@ -50,7 +50,7 @@ local function calcDistanceSq(px, pz, x1, z1, x2, z2)
end end
---Checks if a point is inside a `MapGen.Region` (2D check using x and z coordinates). ---Checks if a point is inside a `MapGen.Region` (2D check using x and z coordinates).
---@param point Position ---@param point MapPosition
---@return boolean, number? ---@return boolean, number?
function Region:pointInRegion(point) function Region:pointInRegion(point)
local vertices = self.vertices local vertices = self.vertices

View File

@@ -8,7 +8,7 @@ local getInstance = Class.getInstance
---@field maxY number ---@field maxY number
---@field staticNode string ---@field staticNode string
---@field staticNodeID number ---@field staticNodeID number
---@field generateStaticNode generateFunc ---@field generateStaticNode fun(self, mapGenerator:MapGen, data:number[], index:number, x:number, y:number, z:number)
local StaticLayer = {} local StaticLayer = {}
---Definition table for the `MapGen.StaticLayer`. ---Definition table for the `MapGen.StaticLayer`.
@@ -18,7 +18,7 @@ local StaticLayer = {}
---@field minY number ---@field minY number
---@field maxY number ---@field maxY number
---@field staticNode string ---@field staticNode string
---@field generateStaticNode generateFunc ---@field generateStaticNode fun(self, mapGenerator:MapGen, data:number[], index:number, x:number, y:number, z:number)
---@param self MapGen.StaticLayer ---@param self MapGen.StaticLayer
---@param mapGenerator MapGen ---@param mapGenerator MapGen

View File

@@ -1,154 +0,0 @@
local mathAbs = math.abs
local getInstance = Class.getInstance
local modInfo = Mod.getInfo('smc__core__map_gen')
local require = modInfo.require
---@type MapGen.Triangle
local Triangle = require('MapGen.Triangle')
---@type MapGen.Triangulation.Edge
local Edge = require('MapGen.Triangulation.Edge')
---@type MapGen.Triangulation.FakePeak
local FakePeak = require('MapGen.Triangulation.FakePeak')
---@class MapGen.Tetrahedron
---@field p1 MapGen.Peak
---@field p2 MapGen.Peak
---@field p3 MapGen.Peak
---@field p4 MapGen.Peak
---@field h1 MapGen.Triangulation.Edge
---@field h2 MapGen.Triangulation.Edge
---@field h3 MapGen.Triangulation.Edge
---@field h4 MapGen.Triangulation.Edge
---@field f1 MapGen.Triangle
---@field f2 MapGen.Triangle
---@field f3 MapGen.Triangle
---@field f4 MapGen.Triangle
local Tetrahedron = {}
---@param p1 MapGen.Peak
---@param p2 MapGen.Peak
---@param p3 MapGen.Peak
---@param p4 MapGen.Peak
---@return MapGen.Tetrahedron
function Tetrahedron:new(p1, p2, p3, p4)
local instance = getInstance(self, {
p1 = p1,
p2 = p2,
p3 = p3,
p4 = p4,
h1 = self:getHeight(p1, p2, p3, p4),
h2 = self:getHeight(p2, p3, p4, p1),
h3 = self:getHeight(p3, p4, p1, p2),
h4 = self:getHeight(p4, p1, p2, p3),
f1 = Triangle:new(p1, p2, p3),
f2 = Triangle:new(p1, p2, p4),
f3 = Triangle:new(p1, p3, p4),
f4 = Triangle:new(p2, p3, p4),
},
{
__tostring = self.toString
})
return instance
end
---Returns a string describing the object in a readable form.
---@return string
function Tetrahedron:toString()
return ('Tetrahedron: \n %s\n %s\n %s\n %s'):format(
tostring(self.p1.getPeakPos()),
tostring(self.p2.getPeakPos()),
tostring(self.p3.getPeakPos()),
tostring(self.p4.getPeakPos())
)
end
---@param p1 MapGen.Peak
---@param p2 MapGen.Peak
---@param p3 MapGen.Peak
---@param p4 MapGen.Peak
function Tetrahedron:getHeight(p1, p2, p3, p4)
local pos1 = p1:getPeakPos()
local pos2 = p2:getPeakPos()
local pos3 = p3:getPeakPos()
local pos4 = p4:getPeakPos()
-- Векторы, лежащие в плоскости
local AB = pos3 - pos2
local AC = pos4 - pos2
-- Нормаль к плоскости
local normal = AB:cross(AC)
local normal_length = normal:length()
-- Если плоскость вырождена (точки на одной прямой)
if normal_length < 1e-10 then
return nil -- или другая обработка ошибки
end
-- Вектор от точки на плоскости к нашей точке
local AP = pos1 - pos2
-- Расстояние от точки до плоскости
local distance = AP:dot(normal) / normal_length
-- Проекция точки на плоскость (вектор!)
local projection = pos1 - (normal * (distance / normal_length))
return Edge:new(p1, FakePeak:new(projection))
end
---Returns the center of the circumscribed sphere.
---@return vector
function Tetrahedron:getCircumSphereCenter()
local pos1 = self.p1.getPeakPos()
local pos2 = self.p2.getPeakPos()
local pos3 = self.p3.getPeakPos()
local pos4 = self.p4.getPeakPos()
local a = pos2 - pos1
local b = pos3 - pos1
local c = pos4 - pos1
local a2 = a:dot(a)
local b2 = b:dot(b)
local c2 = c:dot(c)
local cross_bc = b:cross(c)
local cross_ca = c:cross(a)
local cross_ab = a:cross(b)
local det = a:dot(b:cross(c)) * 2
if mathAbs(det) < 0 then
return (pos1 + pos2 + pos3 + pos4) / 4
end
local center = pos1 + (cross_bc * a2 + cross_ca * b2 + cross_ab * c2) / det
return center
end
---Returns the radius of the circumscribed sphere.
---@return number
function Tetrahedron:getCircumSphereRadius()
local center = self:getCircumSphereCenter()
local pos1 = self.p1.getPeakPos()
return (pos1 - center):length()
end
---Checks whether a given point lies within the circumscribed sphere of a tetrahedron.
---@param p MapGen.Peak
function Tetrahedron:inCircumSphere(p)
local pos = p.getPeakPos()
local c = self:getCircumSphereCenter()
local r = self:getCircumSphereRadius()
local distance = (pos - c):length()
return distance <= r
end
return Tetrahedron

View File

@@ -6,10 +6,10 @@ local getInstance = Class.getInstance
local modInfo = Mod.getInfo('smc__core__map_gen') local modInfo = Mod.getInfo('smc__core__map_gen')
local require = modInfo.require local require = modInfo.require
---@type MapGen.Triangulation.Edge ---@type MapGen.Edge
local Edge = require('MapGen.Triangulation.Edge') local Edge = require('MapGen.Edge')
---@type MapGen.Triangulation.FakePeak ---@type MapGen.FakePeak
local FakePeak = require('MapGen.Triangulation.FakePeak') local FakePeak = require('MapGen.FakePeak')
-- --- Helpers functions --- -- --- Helpers functions ---
@@ -29,9 +29,9 @@ end
---@param p3 MapGen.Peak ---@param p3 MapGen.Peak
---@return boolean ---@return boolean
local function isFlatAngle(p1, p2, p3) local function isFlatAngle(p1, p2, p3)
local pos1 = p1:getPeakPos() local pos1 = p1.pos
local pos2 = p2:getPeakPos() local pos2 = p2.pos
local pos3 = p3:getPeakPos() local pos3 = p3.pos
local vec1 = pos1 - pos2 -- Vector from p2 to p1 local vec1 = pos1 - pos2 -- Vector from p2 to p1
local vec2 = pos3 - pos2 -- Vector from p2 to p3 local vec2 = pos3 - pos2 -- Vector from p2 to p3
@@ -63,16 +63,18 @@ end
---@alias MapGen.Triangle.Neighbours {t1:MapGen.Triangle?,t2:MapGen.Triangle?,t3:MapGen.Triangle?} ---@alias MapGen.Triangle.Neighbours {t1:MapGen.Triangle?,t2:MapGen.Triangle?,t3:MapGen.Triangle?}
---@class MapGen.Triangle ---@class MapGen.Triangle
---@field id integer
---@field p1 MapGen.Peak ---@field p1 MapGen.Peak
---@field p2 MapGen.Peak ---@field p2 MapGen.Peak
---@field p3 MapGen.Peak ---@field p3 MapGen.Peak
---@field e1 MapGen.Triangulation.Edge ---@field e1 MapGen.Edge
---@field e2 MapGen.Triangulation.Edge ---@field e2 MapGen.Edge
---@field e3 MapGen.Triangulation.Edge ---@field e3 MapGen.Edge
---@field h1 MapGen.Triangulation.Edge ---@field h1 MapGen.Edge
---@field h2 MapGen.Triangulation.Edge ---@field h2 MapGen.Edge
---@field h3 MapGen.Triangulation.Edge ---@field h3 MapGen.Edge
---@field neighbours MapGen.Triangle.Neighbours ---@field neighboursIDs integer[]
---@field neighbours MapGen.Triangle[]
---@field color ColorString? ---@field color ColorString?
local Triangle = { local Triangle = {
neighbours = {} neighbours = {}
@@ -82,20 +84,21 @@ local Triangle = {
---@param p2 MapGen.Peak ---@param p2 MapGen.Peak
---@param p3 MapGen.Peak ---@param p3 MapGen.Peak
---@return MapGen.Triangle ---@return MapGen.Triangle
function Triangle:new(p1, p2, p3) function Triangle:new(id, p1, p2, p3, neighboursIDs)
assert(not isFlatAngle(p1, p2, p3), ("angle (p1, p2, p3) is flat:\n %s\n %s\n %s") assert(not isFlatAngle(p1, p2, p3), ("angle (p1, p2, p3) is flat:\n %s\n %s\n %s")
:format(tostring(p1), tostring(p2), tostring(p3))) :format(tostring(p1), tostring(p2), tostring(p3)))
---@type ColorString? ---@type ColorString?
local color = nil local color = nil
local c1, c2, c3 = p1.getColor(), p2.getColor(), p3.getColor() local c1, c2, c3 = p1.color, p2.color, p3.color
if c1 == c2 and c2 == c3 and c3 == c1 then if c1 == c2 and c2 == c3 and c3 == c1 then
color = c1 color = c1
end end
local instance = getInstance(self, { local instance = getInstance(self, {
id = id,
p1 = p1, p1 = p1,
p2 = p2, p2 = p2,
p3 = p3, p3 = p3,
@@ -105,7 +108,8 @@ function Triangle:new(p1, p2, p3)
e1 = Edge:new(p1, p2), e1 = Edge:new(p1, p2),
e2 = Edge:new(p2, p3), e2 = Edge:new(p2, p3),
e3 = Edge:new(p3, p1), e3 = Edge:new(p3, p1),
color = color neighboursIDs = neighboursIDs,
color = color,
}, },
{ {
__tostring = self.toString, __tostring = self.toString,
@@ -119,9 +123,9 @@ end
---@return string ---@return string
function Triangle:toString() function Triangle:toString()
return ('Triangle: \n %s\n %s\n %s'):format( return ('Triangle: \n %s\n %s\n %s'):format(
tostring(self.p1.getPeakPos()), tostring(self.p1.pos),
tostring(self.p2.getPeakPos()), tostring(self.p2.pos),
tostring(self.p3.getPeakPos()) tostring(self.p3.pos)
) )
end end
@@ -144,9 +148,9 @@ end
---Returns the coordinates of the triangle's center. ---Returns the coordinates of the triangle's center.
---@return vector ---@return vector
function Triangle:getCenter() function Triangle:getCenter()
local pos1 = self.p1:getPeakPos() local pos1 = self.p1.pos
local pos2 = self.p2:getPeakPos() local pos2 = self.p2.pos
local pos3 = self.p3:getPeakPos() local pos3 = self.p3.pos
return (pos1 + pos2 + pos3) / 3 return (pos1 + pos2 + pos3) / 3
end end
@@ -163,11 +167,11 @@ end
---@param p1 MapGen.Peak ---@param p1 MapGen.Peak
---@param p2 MapGen.Peak ---@param p2 MapGen.Peak
---@param p3 MapGen.Peak ---@param p3 MapGen.Peak
---@return MapGen.Triangulation.Edge ---@return MapGen.Edge
function Triangle:getHeight(p1, p2, p3) function Triangle:getHeight(p1, p2, p3)
local pos1 = p1:getPeakPos() local pos1 = p1.pos
local pos2 = p2:getPeakPos() local pos2 = p2.pos
local pos3 = p3:getPeakPos() local pos3 = p3.pos
local v = pos3 - pos2 local v = pos3 - pos2
---@type vector ---@type vector
@@ -189,11 +193,11 @@ end
---@param p1 MapGen.Peak ---@param p1 MapGen.Peak
---@param p2 MapGen.Peak ---@param p2 MapGen.Peak
---@param p3 MapGen.Peak ---@param p3 MapGen.Peak
---@return MapGen.Triangulation.Edge ---@return MapGen.Edge
function Triangle:getHeight2D(p1, p2, p3) function Triangle:getHeight2D(p1, p2, p3)
local pos1 = p1:getPeakPos() local pos1 = p1.pos
local pos2 = p2:getPeakPos() local pos2 = p2.pos
local pos3 = p3:getPeakPos() local pos3 = p3.pos
pos1.y = 0 pos1.y = 0
pos2.y = 0 pos2.y = 0
@@ -224,9 +228,9 @@ end
---that is, the calculation is performed on the projection of the triangle XZ. ---that is, the calculation is performed on the projection of the triangle XZ.
---@return number, number, number ---@return number, number, number
function Triangle:getSidesLength2D() function Triangle:getSidesLength2D()
local pos1 = self.p1:getPeakPos() local pos1 = self.p1.pos
local pos2 = self.p2:getPeakPos() local pos2 = self.p2.pos
local pos3 = self.p3:getPeakPos() local pos3 = self.p3.pos
pos1.y = 0 pos1.y = 0
pos2.y = 0 pos2.y = 0
@@ -241,9 +245,9 @@ end
---that is, the calculation is performed on the projection of the triangle XZ. ---that is, the calculation is performed on the projection of the triangle XZ.
---@return vector ---@return vector
function Triangle:getCircumCenter2D() function Triangle:getCircumCenter2D()
local pos1 = self.p1:getPeakPos() local pos1 = self.p1.pos
local pos2 = self.p2:getPeakPos() local pos2 = self.p2.pos
local pos3 = self.p3:getPeakPos() local pos3 = self.p3.pos
local D = ( pos1.x * (pos2.z - pos3.z) + local D = ( pos1.x * (pos2.z - pos3.z) +
pos2.x * (pos3.z - pos1.z) + pos2.x * (pos3.z - pos1.z) +
@@ -290,7 +294,7 @@ end
---@param p MapGen.Peak ---@param p MapGen.Peak
---@return boolean ---@return boolean
function Triangle:inCircumCircle2D(p) function Triangle:inCircumCircle2D(p)
local pos = p:getPeakPos() local pos = p.pos
local c, r = self:getCircumCircle2D() local c, r = self:getCircumCircle2D()

View File

@@ -1,326 +0,0 @@
-- Tringulation lib
-- Original code: https://github.com/iskolbin/Triangulation/blob/master/Triangulation.lua
-- Date of copying: 07.11.2025
-- Commit: e8d26241767cd6af377b5eda0c1e27122b6afe8a
-- Main changes:
-- * refactoring code to our standard;
-- * splitting code into different files (classes);
-- * Adapting the code to the mapgen concept;
-- * Adding tetrahedralization;
-- * Fixed non-determinism by sorting vertices before processing;
local assert, mathMax, tableRemove, tableSort
= assert, math.max, table.remove, table.sort
local modInfo = Mod.getInfo('smc__core__map_gen')
local require = modInfo.require
---@type MapGen.Triangle
local Triangle = require('MapGen.Triangle')
---@type MapGen.Tetrahedron
local Tetrahedron = require('MapGen.Tetrahedron')
---@type MapGen.Triangulation.FakePeak
local FakePeak = require('MapGen.Triangulation.FakePeak')
---@class MapGen.Triangulation
---@field convexMultiplier number
local Triangulation = {
convexMultiplier = 1e3,
}
---Finds and writes adjacent triangles into triangles.
---@param triangles MapGen.Triangle[]
local function findTrianglesNeighbours(triangles)
for _, triangle in ipairs(triangles) do
for _, t in ipairs(triangles) do
if triangle.e1 == t.e1 and triangle.p3 ~= t.p3 then
triangle.neighbours.t1 = t
elseif triangle.e2 == t.e2 and triangle.p3 ~= t.p1 then
triangle.neighbours.t2 = t
elseif triangle.e3 == t.e3 and triangle.p3 ~= t.p2 then
triangle.neighbours.t3 = t
end
end
end
end
---Filter vertices by group and return a new table
---@param vertices table<integer, MapGen.Peak>
---@param groupKey string
---@return table<integer, MapGen.Peak>
local function filterVerticesByGroup(vertices, groupKey)
local result = {}
for i = 1, #vertices do
local vertex = vertices[i]
if vertex:getGroups()[groupKey] ~= nil then
result[#result + 1] = vertex
end
end
return result
end
---Sort vertices deterministically by position to ensure consistent triangulation
---@param vertices table<integer, MapGen.Peak>
local function sortVerticesDeterministically(vertices)
tableSort(vertices, function(a, b)
local posA = a:getPeakPos()
local posB = b:getPeakPos()
-- Sort by X first
if posA.x ~= posB.x then
return posA.x < posB.x
end
-- Then by Z
if posA.z ~= posB.z then
return posA.z < posB.z
end
-- Then by Y
if posA.y ~= posB.y then
return posA.y < posB.y
end
-- Fallback to unique identifier if positions are identical
-- This handles potential duplicate positions
local nameA = a.getName and a:getName() or ""
local nameB = b.getName and b:getName() or ""
return nameA < nameB
end)
end
---The Delaunay method divides a plane into triangles based on a list of their vertices.
---
---Doesn't take into account the Y coordinate of the vertices.
---That is, all triangles that don't lie in the XZ plane will be projected onto it.
---
---Vertices that do not have a `is2d` group will not participate in the triangulation.
---@param vertices table<integer, MapGen.Peak>
function Triangulation.triangulate(vertices)
-- Filter vertices with is2d group (creates a new table)
vertices = filterVerticesByGroup(vertices, "is2d")
-- Sort deterministically to ensure consistent results across sessions
sortVerticesDeterministically(vertices)
local nvertices = #vertices
assert(nvertices > 2, "Cannot triangulate, needs more than 3 vertices")
if nvertices == 3 then
return {Triangle:new(vertices[1], vertices[2], vertices[3])}
end
local minPos = vertices[1]:getPeakPos()
local minX, minY = minPos.x, minPos.z
local maxX, maxY = minX, minY
for i = 1, nvertices do
local vertex = vertices[i]
local vertexPos = vertex:getPeakPos()
vertex.id = i
if vertexPos.x < minX then
minX = vertexPos.x
end
if vertexPos.z < minY then
minY = vertexPos.z
end
if vertexPos.x > maxX then
maxX = vertexPos.x
end
if vertexPos.z > maxY then
maxY = vertexPos.z
end
end
-- Finding the vertices of a supertriangle
local convex_mult = Triangulation.convexMultiplier
local dx, dy = (maxX - minX) * convex_mult, (maxY - minY) * convex_mult
local deltaMax = mathMax(dx, dy)
local midx, midy = (minX + maxX) * 0.5, (minY + maxY) * 0.5
local p1 = FakePeak:new(vector.new(midx - 2 * deltaMax, 0, midy - deltaMax))
local p2 = FakePeak:new(vector.new(midx, 0, midy + 2 * deltaMax))
local p3 = FakePeak:new(vector.new(midx + 2 * deltaMax, 0, midy - deltaMax))
p1.id, p2.id, p3.id = nvertices + 1, nvertices + 2, nvertices + 3
vertices[p1.id], vertices[p2.id], vertices[p3.id] = p1, p2, p3
---@type MapGen.Triangle[]
local triangles = {Triangle:new(vertices[nvertices + 1], vertices[nvertices + 2], vertices[nvertices + 3])}
for i = 1, nvertices do
---@type MapGen.Triangulation.Edge[]
local edges = {}
-- Finding bad triangles.
for j = #triangles, 1, -1 do
local curTriangle = triangles[j]
if curTriangle:inCircumCircle2D(vertices[i]) then
edges[#edges + 1] = curTriangle.e1
edges[#edges + 1] = curTriangle.e2
edges[#edges + 1] = curTriangle.e3
tableRemove(triangles, j)
end
end
-- Removing duplicate edges.
for j = #edges - 1, 1, -1 do
for k = #edges, j + 1, -1 do
if edges[j] and edges[k] and edges[j]:same(edges[k]) then
tableRemove(edges, j)
tableRemove(edges, k - 1)
end
end
end
-- Create new triangles.
for j = 1, #edges do
triangles[#triangles + 1] = Triangle:new(edges[j].p1, edges[j].p2, vertices[i])
end
end
-- Remove triangles associated with the vertices of a supertriangle.
for i = #triangles, 1, -1 do
local triangle = triangles[i]
if triangle.p1.id > nvertices or triangle.p2.id > nvertices or triangle.p3.id > nvertices then
tableRemove(triangles, i)
end
end
-- Removing the vertices of a supertriangle.
for _ = 1, 3 do
tableRemove(vertices)
end
findTrianglesNeighbours(triangles)
return triangles
end
---The Delaunay method divides space into tetrahedra based on a list of their vertices.
---
---Vertices that do not have a `is3d` group will not participate in the triangulation.
---@param vertices table<integer, MapGen.Peak>
function Triangulation.tetrahedralize(vertices)
-- Filter vertices with is3d group (creates a new table)
vertices = filterVerticesByGroup(vertices, "is3d")
-- Sort deterministically to ensure consistent results across sessions
sortVerticesDeterministically(vertices)
local nvertices = #vertices
assert(nvertices > 3, "Cannot tetrahedralize, needs more than 4 vertices")
if nvertices == 4 then
return {Tetrahedron:new(vertices[1], vertices[2], vertices[3], vertices[4])}
end
local minPos = vertices[1]:getPeakPos()
local minX, minY, minZ = minPos.x, minPos.y, minPos.z
local maxX, maxY, maxZ = minX, minY, minZ
for i = 1, nvertices do
local vertex = vertices[i]
local vertexPos = vertex:getPeakPos()
vertex.id = i
if vertexPos.x < minX then
minX = vertexPos.x
end
if vertexPos.y < minY then
minY = vertexPos.y
end
if vertexPos.z < minZ then
minZ = vertexPos.z
end
if vertexPos.x > maxX then
maxX = vertexPos.x
end
if vertexPos.y > maxY then
maxY = vertexPos.y
end
if vertexPos.z > maxZ then
maxZ = vertexPos.z
end
end
-- Finding the vertices of a supertetrahedron
local convex_mult = Triangulation.convexMultiplier
local dx, dy, dz = (maxX - minX) * convex_mult, (maxY - minY) * convex_mult, (maxZ - minZ) * convex_mult
local deltaMax = mathMax(dx, dy, dz)
local midx, midy, midz = (minX + maxX) * 0.5, (minY + maxY) * 0.5, (minZ + maxZ) * 0.5
local p1 = FakePeak:new(vector.new(midx - 2 * deltaMax, midy - deltaMax, midz - deltaMax))
local p2 = FakePeak:new(vector.new(midx + 2 * deltaMax, midy - deltaMax, midz - deltaMax))
local p3 = FakePeak:new(vector.new(midx, midy + 2 * deltaMax, midz - deltaMax))
local p4 = FakePeak:new(vector.new(midx, midy, midz + 2 * deltaMax))
p1.id, p2.id, p3.id, p4.id = nvertices + 1, nvertices + 2, nvertices + 3, nvertices + 4
vertices[p1.id], vertices[p2.id], vertices[p3.id], vertices[p4.id] = p1, p2, p3, p4
---@type MapGen.Tetrahedron[]
local tetrahedrons = {Tetrahedron:new(p1, p2, p3, p4)}
for i = 1, nvertices do
---@type MapGen.Triangle[]
local faces = {}
-- Finding bad tetrahedrons.
for j = #tetrahedrons, 1, -1 do
local curTetrahedron = tetrahedrons[j]
if curTetrahedron:inCircumSphere(vertices[i]) then
faces[#faces + 1] = curTetrahedron.f1
faces[#faces + 1] = curTetrahedron.f2
faces[#faces + 1] = curTetrahedron.f3
faces[#faces + 1] = curTetrahedron.f4
tableRemove(tetrahedrons, j)
end
end
-- Removing duplicate faces.
for j = #faces - 1, 1, -1 do
for k = #faces, j + 1, -1 do
if faces[j] and faces[k] and faces[j]:same(faces[k]) then
tableRemove(faces, j)
tableRemove(faces, k - 1)
end
end
end
-- Create new tetrahedrons.
for j = 1, #faces do
tetrahedrons[#tetrahedrons + 1] = Tetrahedron:new(faces[j].p1, faces[j].p2, faces[j].p3, vertices[i])
end
end
-- Remove tetrahedra associated with the vertices of a supertetrahedron.
for i = #tetrahedrons, 1, -1 do
local tetrahedron = tetrahedrons[i]
if tetrahedron.p1.id > nvertices or tetrahedron.p2.id > nvertices or tetrahedron.p3.id > nvertices or tetrahedron.p4.id > nvertices then
tableRemove(tetrahedrons, i)
end
end
-- Removing the vertices of a supertetrahedron.
for _ = 1, 4 do
tableRemove(vertices)
end
return tetrahedrons
end
return Triangulation

View File

@@ -1,10 +1,4 @@
local itemRequire = Mod.getInfo('smc__core__item').require local Item, ItemFactory = Smc.requireItem(), Smc.requireItemFactory()
---@type Item
local Item = itemRequire('Item')
---@type ItemFactory
local ItemFactory = Mod.getInfo('smc__core__item_factory').require('ItemFactory')
---@class Node : Item ---@class Node : Item
---@field defaultDef Node.NodeDefinition ---@field defaultDef Node.NodeDefinition
@@ -22,7 +16,7 @@ function Node:new(nodeDef)
---Adding default parameters ---Adding default parameters
nodeDef = defMerge(nodeDef, self.defaultDef, true) nodeDef = defMerge(nodeDef, self.defaultDef, true)
nodeDef.settings.visual = 'item_3d' nodeDef.settings._type = 'node'
---@type Node ---@type Node
local instance = Item:new(nodeDef) local instance = Item:new(nodeDef)
@@ -35,6 +29,8 @@ end
---@param defaultDef Node.NodeDefinition ---@param defaultDef Node.NodeDefinition
---@return Node ---@return Node
function Node:getExtended(defaultDef) function Node:getExtended(defaultDef)
defaultDef = defMerge(defaultDef, self.defaultDef)
---@type Node ---@type Node
local ChildClass = Class.extend(self, { local ChildClass = Class.extend(self, {
defaultDef = defaultDef, defaultDef = defaultDef,
@@ -49,6 +45,8 @@ end
function Node:getFactory(defaultDef) function Node:getFactory(defaultDef)
if defaultDef == nil then if defaultDef == nil then
defaultDef = self.defaultDef defaultDef = self.defaultDef
else
defaultDef = defMerge(self.defaultDef, defaultDef)
end end
---@type ItemFactory ---@type ItemFactory

View File

@@ -1,10 +1,4 @@
local nodeRequire = Mod.getInfo('smc__core__node').require local Node = Smc.requireNode()
---@type Node
local Node = nodeRequire('Node')
-- -@type ItemFactory
---local ItemFactory = Mod.getInfo('smc__core__item_factory').require('ItemFactory')
---@class Plant : Node ---@class Plant : Node
local Plant = Node:getExtended({ local Plant = Node:getExtended({

View File

@@ -1,4 +1,23 @@
---@class Player ---@class Player
local Player = {} local Player = {}
---@type PlayerInventoryUI
local PlayerInventoryUI = Mod.getInfo('smc__ui__player_inventory').require('PlayerInventoryUI')
core.register_on_joinplayer(function(player)
player:set_inventory_formspec(PlayerInventoryUI:getFormSpecString(player:get_player_name()))
player:hud_set_hotbar_itemcount(9)
local inv = player:get_inventory()
inv:set_size('main', 18)
end)
core.register_chatcommand('show_inv',
{
func = function(name, param)
PlayerInventoryUI:showForm(name)
return true
end
}
)
return Player return Player

4
mods/CORE/Tool/init.lua Normal file
View File

@@ -0,0 +1,4 @@
local modInfo = Mod.getInfo('smc__core__tool')
local require = modInfo.require
return require('Tool')

2
mods/CORE/Tool/mod.conf Normal file
View File

@@ -0,0 +1,2 @@
name = smc__core__tool
depends = smc__core__item

View File

@@ -0,0 +1,70 @@
local Item, ItemFactory = Smc.requireItem(), Smc.requireItemFactory()
---@class Tool : Item
---@field defaultDef Item.ItemDefinition
local Tool = Class.extend(Item, {})
---The alias `table.merge` for EmmyLua
---@type fun(...):(Item.ItemDefinition)
local defMerge = function(...)
return table.merge(...)
end
---@param ToolDef Item.ItemDefinition
---@return Tool
function Tool:new(ToolDef)
---Adding default parameters
ToolDef = defMerge(ToolDef, self.defaultDef, true)
ToolDef.settings._type = 'tool'
---@type Tool
local instance = Item:new(ToolDef)
return instance
end
---Allows you to create a child class of an tool by specifying
---default parameters that will be added to the tool's parameters
---when an instance is received.
---@param defaultDef Item.ItemDefinition
---@return Tool
function Tool:getExtended(defaultDef)
defaultDef = defMerge(defaultDef, self.defaultDef)
---@type Tool
local ChildClass = Class.extend(self, {
defaultDef = defaultDef,
})
return ChildClass
end
---Returns an instance of the `ItemFactory` class that can be used to mass-register identical items.
---@param defaultDef? Item.ItemDefinition
---@return ItemFactory
function Tool:getFactory(defaultDef)
if defaultDef == nil then
defaultDef = self.defaultDef
else
defaultDef = defMerge(self.defaultDef, defaultDef)
end
---@type ItemFactory
local instance = ItemFactory:new(self, defaultDef)
return instance
end
--[[
Tool:new({
settings = {
name = 'tool',
inventory_image = 'anoba.png',
tool_capabilities = {
groupcaps={
crumbly={maxlevel=2, uses=20, times={[1]=1.60, [2]=1.20, [3]=0.80}}
},
}
}
})--]]
return Tool

View File

@@ -0,0 +1,4 @@
local modInfo = Mod.getInfo('smc__core__work_station')
local require = modInfo.require
return require('WorkStation')

View File

@@ -0,0 +1,2 @@
name = smc__core__work_station
depends = smc__core__craft_system, smc__core__node, smc__ui__work_station

View File

@@ -0,0 +1,258 @@
local getInstance = Class.getInstance
---@type CraftSystem.ImmersiveCraftHandler
local ImmersiveCraftHandler = Mod.getInfo('smc__core__craft_system').require('CraftSystem.ImmersiveCraftHandler')
---@type WorkStationUI
local WorkStationUI = Mod.getInfo('smc__ui__work_station').require('WorkStationUI')
local Node = Smc.requireNode()
-- Default settings that a work station node should have.
local WorkStationNode = Node:getExtended({
settings = {
name = 'work_station',
drawtype = 'normal',
paramtype = 'light',
groups = {work_station = 1, dig_immediate = 2,}
}
})
---A work station (node) that enables player interaction
---with the immersive crafting mechanics.
---@class WorkStation
---@field name string
---@field group CraftSystem.CraftGroup
---@field nodeDef Node.NodeDefinition
local WorkStation = {}
---Definition table for the `CraftSystem.WorkStation`.
---
---**Only for EmmyLua.**
---@class WorkStationDef
---@field group CraftSystem.CraftGroup
---@field nodeDef Node.NodeDefinition
---@param name string
---@param def WorkStationDef
function WorkStation:new(name, def)
local nodeDef = def.nodeDef
if nodeDef.callbacks == nil then
---@type Node.Callbacks
nodeDef.callbacks = {}
end
local settings = nodeDef.settings
local callbacks = nodeDef.callbacks
-- Callback when the work station block is installed in the world
-- Ensures initialization of necessary parameters
callbacks.on_construct = function(pos)
-- Getting node metadata
local meta = core.get_meta(pos)
-- Initializing the table of temporary parameters for crafting.
Smc.setCraftDataByMeta(meta)
end
-- Callback for interaction with a work station (start of crafting)
callbacks.on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
-- If the workstation is occupied by another craft...
if not Smc.workStationIsFree(pos) then
-- ...we inform the player about this...
core.chat_send_player(clicker:get_player_name(), 'The workbench is occupied by another craft.')
-- ...and do nothing.
return
end
-- We get a list of crafts that can be produced using the item that the player was holding in his hand.
local crafts = ImmersiveCraftHandler:getCraftsByTriggerItem(itemstack:get_name())
-- If the list is empty...
if crafts == nil then
-- ..this means there are no crafts for this item,
-- so we don't do anything.
return
else
-- ...else we show the player the formspec for choosing a craft.
self:showSelectionCraftForm(clicker, crafts, pos)
end
end
callbacks.on_punch = function(pos, node, puncher, pointed_thing)
if Smc.workStationIsFree(pos) then
return
end
local craftData = Smc.getCraftDataByPos(pos)
assert(craftData ~= nil, 'Immersive crafting data is empty.')
local craft = ImmersiveCraftHandler:getCraftByName(craftData.craftName)
craft:abortCraft(pos)
end
callbacks.on_dig = function(pos, node, digger)
if Smc.workStationIsFree(pos) then
return core.node_dig(pos, node, digger)
else
return false
end
end
---@type WorkStation
local instance = getInstance(self, {})
instance.name = name
instance.group = def.group
instance.nodeDef = nodeDef
-- Registering a node for Luanti.
WorkStationNode:new(nodeDef)
return instance
end
---Show the player the initial workstation interface for choosing a craft.
---@param player Player
---@param crafts CraftSystem.ImmersiveCraft[]
---@param pos Position
function WorkStation:showSelectionCraftForm(player, crafts, pos)
-- Create a table in the format craft result - craft name.
local outputs = {}
for _, craft in ipairs(crafts) do
-- TODO: добавить проверку только на известные игроку рецепты
outputs[craft.output] = craft.name
end
-- We get the name of the player who wants to start crafting.
local playerName = player:get_player_name()
-- We set the context for transferring data about the workstation coordinates and the list of crafts.
WorkStationUI:setContex(playerName, 'pos', pos)
WorkStationUI:setContex(playerName, 'outputs', outputs)
-- Showing the desktop interface to the player.
WorkStationUI:showForm(playerName,false)
end
-- Registering a callback for player choice of craft (this does not start crafting).
WorkStationUI:registerOnFormFieldActionMatch('%S+::item_button',function(player, fieldName, fieldValue)
-- We get the name of the craft from the name of the button the player pressed.
local craftName = string.match(fieldName, '(%S+)::item_button')
assert(craftName ~= nil, 'Craft name cannot be empty')
-- We get a craft object.
local craft = ImmersiveCraftHandler:getCraftByName(craftName)
-- We get the name of the player who wants to start crafting.
local playerName = player:get_player_name()
-- We enter into the context the craft that the player has chosen.
WorkStationUI:setContex(playerName, 'craft', craft)
-- We show the player a new interface with a crafting description tab.
WorkStationUI:showForm(playerName, true)
end)
-- We register a callback when the player starts crafting.
WorkStationUI:registerOnFormFieldAction('work_station:start_craft', function(player, fieldName, fieldValue)
-- We get the name of the player who wants to start crafting.
local playerName = player:get_player_name()
-- We get the workstation position and craft from the context.
local pos = WorkStationUI:getContex(playerName, 'pos')
---@type CraftSystem.ImmersiveCraft
local craft = WorkStationUI:getContex(playerName, 'craft')
-- We process the amount of crafting.
local isCraftStart = false
if fieldValue == 'x1' then
-- Single craft
isCraftStart = craft:startCraft(pos, player, 1)
elseif fieldValue == 'x10' then
-- Ten crafts at a time.
isCraftStart = craft:startCraft(pos, player, 10)
end
-- If the craft was started...
if isCraftStart then
-- ...we are closing the formspec.
WorkStationUI:closeForm(playerName)
end
end)
-- --- DEBUG ---
WorkStation:new('test_station', {
group = 'test',
nodeDef = {
settings = {
name = 'test_station',
tiles = {'test_station.png'}
}
}
})
ImmersiveCraftHandler:registerCraft('bricks', {
triggerItem = 'rocks:sylite',
output = 'rocks:sylite_bricks',
startStageName = 'tapping',
group = 'test',
stages = {
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping',
targetItem = 'rocks:sylite',
type = 'tapping',
clicksNeed = 3,
nextStage = 'tapping_2',
},
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping_2',
toolGroup = 'crushing',
targetItem = 'rocks:sylite_block',
type = 'tapping',
clicksNeed = 5,
nextStage = 'tapping_3',
},
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping_3',
targetItem = 'rocks:sylite_bricks',
type = 'tapping',
clicksNeed = 1,
}
},
})
ImmersiveCraftHandler:registerCraft('block', {
triggerItem = 'rocks:sylite',
output = 'rocks:sylite_block',
startStageName = 'tapping',
group = 'test',
stages = {
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping',
targetItem = 'rocks:sylite',
type = 'tapping',
clicksNeed = 5,
}
},
})
ImmersiveCraftHandler:registerCraft('marentine_planks', {
triggerItem = 'wood:marentine_log',
output = 'wood:marentine_planks',
startStageName = 'tapping',
group = 'test',
stages = {
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping',
targetItem = 'wood:marentine_log',
type = 'tapping',
clicksNeed = 5,
}
},
})
return WorkStation

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.2 KiB

View File

@@ -1,73 +0,0 @@
local modInfo = Mod.getInfo('smc__core__formspec')
local require = modInfo.require
---@type Formspec
local Formspec = require('Formspec')
local listForm = Formspec:new({
size = {x=21, y=12},
})
listForm:list('current_player', 'main', 10.5, 6.5, 8, 4)
local listFormItems = Formspec:new()
local items = table.get_keys(core.registered_nodes)
table.sort(items)
local w, h = 0, 0
---@param name string
for _, name in ipairs(items) do
listFormItems:itemImageButton(w, h, 1, 1, name, name..'::item_button')
w = w + 1
if w > 9 then
w = 0
h = h + 1
end
end
--listFormItems:list('current_player', 'main', 0, 0, 1, 32)
listForm:
scrollContainer(listFormItems, 0.5, 0.5, 9, 11, 'admin_commands:list_items', 'vertical'):
scrollbar(10, 0.5, 0.25, 10, 'vertical', 'admin_commands:list_items')
core.register_chatcommand('list', {
privs = {server = true},
func = function(name, param)
local player = core.get_player_by_name(name)
core.show_formspec(name, 'admin_commands:list_form', listForm:toString())
return true, ''
end
})
core.register_on_player_receive_fields(function(player, formname, fields)
if formname ~= 'admin_commands:list_form' then
return
end
for key, value in pairs(fields) do
if string.ends_with(key, '::item_button') then
---@type ItemStackString?
local stack = string.match(key, '(%S+)::item_button')
if stack == nil then
return
end
core.log(tostring(stack))
---@type InvRef
local inv = player:get_inventory()
if inv:room_for_item("main", stack) then
inv:add_item("main", stack)
end
end
end
end)

View File

@@ -1,2 +0,0 @@
name = smc__core__admin_commands
depends = smc__system__system_loader, smc__core__formspec, smc__core__item

View File

@@ -1,6 +1,8 @@
-- World generation occurs in a separate thread (MapGen Environment). -- World generation occurs in a separate thread (MapGen Environment).
-- But for the main thread, the mapgenerator object is also initialized. -- But for the main thread, the mapgenerator object is also initialized.
--core.set_mapgen_setting('chunksize', '{x=2,y=10,z=2}', true)
local mapGeneneratorRequire = Mod.getInfo('smc__core__map_generator').require local mapGeneneratorRequire = Mod.getInfo('smc__core__map_generator').require
-- Main env init -- Main env init

File diff suppressed because it is too large Load Diff

View File

@@ -17,6 +17,9 @@ dofile(core.get_modpath('smc__system__logger')..'/init.lua')
-- Math -- Math
dofile(core.get_modpath('smc__system__math')..'/init.lua') dofile(core.get_modpath('smc__system__math')..'/init.lua')
-- Profile
dofile(core.get_modpath('smc__system__profiler')..'/init.lua')
-- Require -- Require
dofile(core.get_modpath('smc__system__require')..'/init.lua') dofile(core.get_modpath('smc__system__require')..'/init.lua')

View File

@@ -49,9 +49,396 @@ mapGenerator:registerLayer('midgard', {
calcTemp = calcTemp, calcTemp = calcTemp,
calcHumidity = calcHumidity, calcHumidity = calcHumidity,
biomesVerticalScattering = 5, biomesVerticalScattering = 5,
biomesGorizontalScattering = 5 biomesGorizontalScattering = 5,
triangulationLandscapeFile = 'tarion.json',
triangulationTempFile = 'tarion.json',
triangulationHumidityFile = 'tarion.json',
landscapeMapScale = 100,
tempMapScale = 100,
humidityMapScale = 100,
}) })
-- TODO: Config should be imported from .json file in the world's folder
local ocean = {
['landscape'] = {
offset = -10,
scale = 3,
spread = {x = 10, y = 10, z = 10},
seed = 420,
octaves = 2,
persistence = 0.4,
lacunarity = 2,
},
['temp'] = {
offset = -10,
scale = 5,
spread = {x = 10, y = 10, z = 10},
seed = 47,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
['humidity'] = {
offset = -10,
scale = 5,
spread = {x = 10, y = 10, z = 10},
seed = 47,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
}
local common_lands = {
['landscape'] = {
offset = 0,
scale = 5,
spread = {x = 10, y = 10, z = 10},
seed = 88005553535,
octaves = 2,
persistence = 0.4,
lacunarity = 2,
},
['temp'] = {
offset = -10,
scale = 5,
spread = {x = 10, y = 10, z = 10},
seed = 47,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
['humidity'] = {
offset = -10,
scale = 5,
spread = {x = 10, y = 10, z = 10},
seed = 47,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
}
local foresty_lands = {
['landscape'] = {
offset = 5,
scale = 8,
spread = {x = 15, y = 15, z = 15},
seed = 12345,
octaves = 3,
persistence = 0.5,
lacunarity = 2,
},
['temp'] = {
offset = 20,
scale = 10,
spread = {x = 20, y = 20, z = 20},
seed = 48,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
['humidity'] = {
offset = 60,
scale = 15,
spread = {x = 15, y = 15, z = 15},
seed = 49,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
}
local hilly_lands = {
['landscape'] = {
offset = 15,
scale = 12,
spread = {x = 20, y = 20, z = 20},
seed = 54321,
octaves = 3,
persistence = 0.5,
lacunarity = 2,
},
['temp'] = {
offset = 15,
scale = 10,
spread = {x = 25, y = 25, z = 25},
seed = 50,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
['humidity'] = {
offset = 40,
scale = 15,
spread = {x = 20, y = 20, z = 20},
seed = 51,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
}
local low_mountains = {
['landscape'] = {
offset = 30,
scale = 20,
spread = {x = 25, y = 25, z = 25},
seed = 11111,
octaves = 4,
persistence = 0.5,
lacunarity = 2,
},
['temp'] = {
offset = 5,
scale = 15,
spread = {x = 30, y = 30, z = 30},
seed = 52,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
['humidity'] = {
offset = 30,
scale = 15,
spread = {x = 25, y = 25, z = 25},
seed = 53,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
}
local high_mountains = {
['landscape'] = {
offset = 60,
scale = 35,
spread = {x = 30, y = 30, z = 30},
seed = 22222,
octaves = 4,
persistence = 0.55,
lacunarity = 2,
},
['temp'] = {
offset = -10,
scale = 15,
spread = {x = 35, y = 35, z = 35},
seed = 54,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
['humidity'] = {
offset = 20,
scale = 10,
spread = {x = 30, y = 30, z = 30},
seed = 55,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
}
local highest_peaks = {
['landscape'] = {
offset = 100,
scale = 50,
spread = {x = 40, y = 40, z = 40},
seed = 33333,
octaves = 5,
persistence = 0.6,
lacunarity = 2,
},
['temp'] = {
offset = -30,
scale = 10,
spread = {x = 50, y = 50, z = 50},
seed = 56,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
['humidity'] = {
offset = 10,
scale = 10,
spread = {x = 40, y = 40, z = 40},
seed = 57,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
}
local rivers = {
['landscape'] = {
offset = -5,
scale = 2,
spread = {x = 5, y = 5, z = 100},
seed = 44444,
octaves = 2,
persistence = 0.3,
lacunarity = 2,
},
['temp'] = {
offset = 10,
scale = 5,
spread = {x = 50, y = 50, z = 50},
seed = 58,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
['humidity'] = {
offset = 80,
scale = 10,
spread = {x = 20, y = 20, z = 20},
seed = 59,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
}
local lakes = {
['landscape'] = {
offset = -8,
scale = 2,
spread = {x = 15, y = 15, z = 15},
seed = 55555,
octaves = 2,
persistence = 0.3,
lacunarity = 2,
},
['temp'] = {
offset = 10,
scale = 5,
spread = {x = 30, y = 30, z = 30},
seed = 60,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
['humidity'] = {
offset = 90,
scale = 5,
spread = {x = 20, y = 20, z = 20},
seed = 61,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
}
local rocky_shores = {
['landscape'] = {
offset = 2,
scale = 4,
spread = {x = 8, y = 8, z = 8},
seed = 66666,
octaves = 3,
persistence = 0.5,
lacunarity = 2,
},
['temp'] = {
offset = 15,
scale = 8,
spread = {x = 15, y = 15, z = 15},
seed = 62,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
['humidity'] = {
offset = 70,
scale = 10,
spread = {x = 15, y = 15, z = 15},
seed = 63,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
}
local rocky_islands = {
['landscape'] = {
offset = 8,
scale = 10,
spread = {x = 12, y = 12, z = 12},
seed = 77777,
octaves = 3,
persistence = 0.5,
lacunarity = 2,
},
['temp'] = {
offset = 20,
scale = 8,
spread = {x = 20, y = 20, z = 20},
seed = 64,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
['humidity'] = {
offset = 60,
scale = 15,
spread = {x = 20, y = 20, z = 20},
seed = 65,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
}
local swamp_land = {
['landscape'] = {
offset = 1,
scale = 2,
spread = {x = 12, y = 12, z = 12},
seed = 88888,
octaves = 2,
persistence = 0.4,
lacunarity = 2,
},
['temp'] = {
offset = 25,
scale = 5,
spread = {x = 15, y = 15, z = 15},
seed = 66,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
['humidity'] = {
offset = 85,
scale = 10,
spread = {x = 15, y = 15, z = 15},
seed = 67,
octaves = 3,
persistence = 0.4,
lacunarity = 2,
},
}
local v = vector.new
for _, c in ipairs({'landscape', 'temp', 'humidity'}) do
mapGenerator:registerLayerNoiseColor('midgard', c, '#4978c6', ocean[c])
mapGenerator:registerLayerNoiseColor('midgard', c, '#81c948', common_lands[c])
mapGenerator:registerLayerNoiseColor('midgard', c, '#187726', foresty_lands[c])
mapGenerator:registerLayerNoiseColor('midgard', c, '#357a60', hilly_lands[c])
mapGenerator:registerLayerNoiseColor('midgard', c, '#5a7269', low_mountains[c])
mapGenerator:registerLayerNoiseColor('midgard', c, '#773b18', high_mountains[c])
mapGenerator:registerLayerNoiseColor('midgard', c, '#a3a3a3', highest_peaks[c])
mapGenerator:registerLayerNoiseColor('midgard', c, '#182077', rivers[c])
mapGenerator:registerLayerNoiseColor('midgard', c, '#06f5ff', lakes[c])
mapGenerator:registerLayerNoiseColor('midgard', c, '#677a48', rocky_shores[c])
mapGenerator:registerLayerNoiseColor('midgard', c, '#e4dc36', rocky_islands[c])
mapGenerator:registerLayerNoiseColor('midgard', c, '#3b7718', swamp_land[c])
end
--[[
local land1 = { local land1 = {
offset = -10, offset = -10,
scale = 5, scale = 5,
@@ -145,7 +532,7 @@ mapGenerator:register2DPeaks('midgard',
v(200, 0, 100), v(200, 0, 100),
v(-300, 0, -200), v(-300, 0, -200),
})--]] })--]]
--[[
for _, c in ipairs({'landscape', 'temp', 'humidity'}) do for _, c in ipairs({'landscape', 'temp', 'humidity'}) do
mapGenerator:registerLayerNoiseColor('midgard', c, '#4978c6', land1) mapGenerator:registerLayerNoiseColor('midgard', c, '#4978c6', land1)
mapGenerator:registerLayerNoiseColor('midgard', c, '#77ea72', land2) mapGenerator:registerLayerNoiseColor('midgard', c, '#77ea72', land2)
@@ -168,13 +555,9 @@ for _, c in ipairs({'landscape', 'temp', 'humidity'}) do
color = '#4978c6', color = '#4978c6',
pos = vector.new(-512, 0, 512) pos = vector.new(-512, 0, 512)
}, },
})--]] })
end end
--]]
mapGenerator:register2DPeaksFromFile('midgard', 'map.ff', 100,{x=0, y=0}, 'landscape')
mapGenerator:register2DPeaksFromFile('midgard', 'map.ff', 150,{x=0, y=0}, 'temp')
mapGenerator:register2DPeaksFromFile('midgard', 'map.ff', 200,{x=0, y=0}, 'humidity')
-- [[ -- [[
mapGenerator:registerCavern('midgard', 'cavern1', { mapGenerator:registerCavern('midgard', 'cavern1', {
minY = -48, minY = -48,
@@ -214,7 +597,7 @@ local rocksNoiseParams ={
lacunarity = 4, lacunarity = 4,
} }
local function generateRock(biome, mapGenerator, data, index, x, y, z) local function generateRock(biome, mapGenerator, factors, data, index, x, y, z)
local ids = mapGenerator.nodeIDs local ids = mapGenerator.nodeIDs
if rocksNoise == nil then if rocksNoise == nil then
@@ -249,7 +632,7 @@ local function generateRock(biome, mapGenerator, data, index, x, y, z)
end end
---@param biome MapGen.Biome ---@param biome MapGen.Biome
local function generateSoil(biome, mapGenerator, data, index, x, y, z) local function generateSoil(biome, mapGenerator, factors, data, index, x, y, z)
local ids = mapGenerator.nodeIDs local ids = mapGenerator.nodeIDs
if rocksNoise == nil then if rocksNoise == nil then
rocksNoise = core.get_value_noise(rocksNoiseParams) rocksNoise = core.get_value_noise(rocksNoiseParams)
@@ -269,7 +652,7 @@ local function generateSoil(biome, mapGenerator, data, index, x, y, z)
end end
---@param biome MapGen.Biome ---@param biome MapGen.Biome
local function generateTurf(biome, mapGenerator, data, index, x, y, z) local function generateTurf(biome, mapGenerator, factors, data, index, x, y, z)
local ids = mapGenerator.nodeIDs local ids = mapGenerator.nodeIDs
if rocksNoise == nil then if rocksNoise == nil then
rocksNoise = core.get_value_noise(rocksNoiseParams) rocksNoise = core.get_value_noise(rocksNoiseParams)
@@ -288,6 +671,22 @@ local function generateTurf(biome, mapGenerator, data, index, x, y, z)
end end
end end
---@param area VoxelArea
local function postProcessing(biome, mapGenerator, factors, data, index, x, y, z, nodeType, area)
local trufID = biome.groundNodesIDs.turf
local waterID = mapGenerator.nodeIDs.water
if data[index] ~= trufID then
return
end
if (data[area:index(x+1, y, z)] == trufID or data[area:index(x+1, y, z)] == waterID) and
(data[area:index(x-1, y, z)] == trufID or data[area:index(x-1, y, z)] == waterID) and
(data[area:index(x, y, z+1)] == trufID or data[area:index(x, y, z+1)] == waterID) and
(data[area:index(x, y, z-1)] == trufID or data[area:index(x, y, z-1)] == waterID) then
data[index] = mapGenerator.nodeIDs.water
end
end
mapGenerator:registerBiome('midgard', 'swamp', { mapGenerator:registerBiome('midgard', 'swamp', {
tempPoint = 0, tempPoint = 0,
humidityPoint = 80, humidityPoint = 80,
@@ -303,6 +702,7 @@ mapGenerator:registerBiome('midgard', 'swamp', {
generateRock = generateRock, generateRock = generateRock,
generateTurf = generateTurf, generateTurf = generateTurf,
generateSoil = generateSoil, generateSoil = generateSoil,
postProcessing = postProcessing
}) })
return mapGenerator return mapGenerator

Binary file not shown.

After

Width:  |  Height:  |  Size: 2.2 KiB

View File

@@ -1,3 +1,3 @@
name = smc__game__items__items_loader name = smc__game__items__items_loader
description = Include this mod in your `depends` to ensure all items are registered description = Include this mod in your `depends` to ensure all items are registered
depends = smc__game__items__rocks, smc__game__items__wood, smc__game__items__soils, smc__game__items__liquids depends = smc__game__items__rocks, smc__game__items__wood, smc__game__items__soils, smc__game__items__liquids, smc__game__items__plants

View File

@@ -0,0 +1,35 @@
local Item, TileSheet = Smc.requireItem(), Smc.requireTileSheet()
---@type Item.ItemDefinition
local defaultEssenceDef = {
settings = {
name = '',
_rarity = 'uncommon',
stack_max = 32,
}
}
local defaultEssence = Item:getExtended(defaultEssenceDef)
local ts = TileSheet:new('essences_sheet.png', 16, 16)
defaultEssence:new({
settings = {
name = 'essence_experience',
inventory_image = ts:t(0, 0)
}
})
defaultEssence:new({
settings = {
name = 'essence_spell',
inventory_image = ts:t(1, 0)
}
})
defaultEssence:new({
settings = {
name = 'essence_life',
inventory_image = ts:t(2, 0)
}
})

View File

@@ -0,0 +1,10 @@
# textdomain: essences
essence_experience-title=Эссенция опыта
essence_experience-desc=Сгусток желеобразной материи,@nзаключающий в себе ремесленный опыт.
essence_spell-title=Эссенция заклятия
essence_spell-desc=Сгусток желеобразной материи,@nзаключающий в себе мистическую силу.
essence_life-title=Эссенция жизни
essence_life-desc=Сгусток желеобразной материи,@nзаключающий в себе жизненную энергию.

View File

@@ -0,0 +1,2 @@
name = smc__game__items__essences
depends = smc__core__item

Binary file not shown.

After

Width:  |  Height:  |  Size: 3.2 KiB

View File

@@ -1,11 +1,10 @@
---@type Node local Node = Smc.requireNode()
local Node = Mod.getInfo('smc__core__node').require('Node')
---@type Node.NodeDefinition ---@type Node.NodeDefinition
local defaultLiquidDef = { local defaultLiquidDef = {
settings = { settings = {
name = '', name = '',
addModName = false, _add_mod_name = false,
tiles = {}, tiles = {},
waving = 3, waving = 3,
use_texture_alpha = "blend", use_texture_alpha = "blend",

View File

@@ -1,10 +1,4 @@
local modInfo = Mod.getInfo('smc__core__plant') local Plant, TileSheet = Smc.requirePlant(), Smc.requireTileSheet()
---@type TileSheet
local TileSheet = Mod.getInfo('smc__core__tilesheet').require('TileSheet')
---@type Plant
local Plant = modInfo.require('Plant')
Plant:new({ Plant:new({
settings = { settings = {
@@ -21,7 +15,7 @@ for i=0, 3 do
Plant:new({ Plant:new({
settings = { settings = {
name = 'plant'..tostring(i), name = 'plant'..tostring(i),
title = 'Plant', _title = 'Plant',
tiles = { ts:t(i,0) }, tiles = { ts:t(i,0) },
place_param2 = 3, place_param2 = 3,
}, },

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.2 KiB

After

Width:  |  Height:  |  Size: 1.2 KiB

View File

@@ -1,14 +1,9 @@
---@type TileSheet local Node, TileSheet = Smc.requireNode(), Smc.requireTileSheet()
local TileSheet = Mod.getInfo('smc__core__tilesheet').require('TileSheet')
---@type Node
local Node = Mod.getInfo('smc__core__node').require('Node')
---@type Node.NodeDefinition ---@type Node.NodeDefinition
local defaultRockDef = { local defaultRockDef = {
settings = { settings = {
name = "", name = '',
description = "A rocks",
tiles = {}, tiles = {},
groups = { groups = {
dig_immediate = 2, dig_immediate = 2,
@@ -45,84 +40,27 @@ local function registerRocksTypes(postfix, x)
}) })
end end
local function registerPilarStaff(rock, y)
local columnTop = ts:t(9, y)
rockFactory:registerNodesByShortDef({
{rock..'_fluted_column', {columnTop, columnTop, ts:t(6, y)}},
{rock..'_ionic_chapiter', {
ts:t(3, y),
columnTop,
ts:t(7, y),
ts:t(7, y),
ts:t(8, y),
ts:t(8, y)}},
})
end
registerPilarStaff('sylite', 0)
registerPilarStaff('sylite_gray', 1)
registerPilarStaff('sylite_black', 2)
registerRocksTypes('', 0) registerRocksTypes('', 0)
registerRocksTypes('_block', 2) registerRocksTypes('_chipped', 1)
registerRocksTypes('_bricks', 5) registerRocksTypes('_block', 3)
registerRocksTypes('_bricks', 4)
--[[ registerRocksTypes('_bricks_2', 5)
rockFactory:registerItems({
---@type Node.NodeDefinition
{
settings = {
name = "sylite",
title = "Sylite",
--description = "",
tiles = {"rocks_sheet.png^[sheet:7x15:0,0"},
},
},
---@type Node.NodeDefinition
{
settings = {
name = "tauitite",
title = "Tauitite",
--description = "",
tiles = {"rocks_sheet.png^[sheet:7x15:0,2"},
},
},
---@type Node.NodeDefinition
{
settings = {
name = "iyellite",
title = "Iyellite",
--description = "",
tiles = {"rocks_sheet.png^[sheet:7x15:0,4"},
},
},
---@type Node.NodeDefinition
{
settings = {
name = "falmyte",
title = "Falmyte",
--description = "",
tiles = {"rocks_sheet.png^[sheet:7x15:0,6"},
},
},
---@type Node.NodeDefinition
{
settings = {
name = "hapcoryte",
title = "Hapcoryte",
--description = "",
tiles = {"rocks_sheet.png^[sheet:7x15:0,8"},
},
},
---@type Node.NodeDefinition
{
settings = {
name = "burcite",
title = "Burcite",
--description = "",
tiles = {"rocks_sheet.png^[sheet:7x15:0,10"},
},
},
---@type Node.NodeDefinition
{
settings = {
name = "felhor",
title = "Felhor",
--description = "",
tiles = {"rocks_sheet.png^[sheet:7x15:0,12"},
},
},
---@type Node.NodeDefinition
{
settings = {
name = "malachite",
title = "Malachite",
--description = "",
tiles = {"rocks_sheet.png^[sheet:7x15:0,14"},
},
},
})
--]]

View File

@@ -0,0 +1,6 @@
# textdomain: rocks
sylite_block-title=Силитовый блок
sylite_block-desc=Массивный блок из цельного куска силита.
sylite_bricks-title=Силитовые кирпичи
sylite_bricks-desc=Кладка из силитовых кирпичей.

Binary file not shown.

Before

Width:  |  Height:  |  Size: 106 KiB

After

Width:  |  Height:  |  Size: 151 KiB

View File

@@ -1,17 +1,14 @@
---@type TileSheet local Node, TileSheet = Smc.requireNode(), Smc.requireTileSheet()
local TileSheet = Mod.getInfo('smc__core__tilesheet').require('TileSheet')
---@type Node
local Node = Mod.getInfo('smc__core__node').require('Node')
---@type Node.NodeDefinition ---@type Node.NodeDefinition
local defaultSoilDef = { local defaultSoilDef = {
settings = { settings = {
name = "", name = "",
description = "A soil", _description = "A soil",
tiles = {}, tiles = {},
groups = { groups = {
dig_immediate = 2, dig_immediate = 2,
soil = 1,
soil_fertiliry = 100, -- Soil fertility for agriculture soil_fertiliry = 100, -- Soil fertility for agriculture
} }
}, },
@@ -47,7 +44,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "clay_soil_baren", name = "clay_soil_baren",
title = "Barren Clay Soil", _title = "Barren Clay Soil",
--description = "", --description = "",
tiles = clayTiles, tiles = clayTiles,
}, },
@@ -56,7 +53,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "clay_soil_poor", name = "clay_soil_poor",
title = "Poor Clay Soil", _title = "Poor Clay Soil",
--description = "", --description = "",
tiles = clayTiles, tiles = clayTiles,
}, },
@@ -65,7 +62,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "clay_soil_moderate", name = "clay_soil_moderate",
title = "Moderate Clay Soil", _title = "Moderate Clay Soil",
--description = "", --description = "",
tiles = clayTiles, tiles = clayTiles,
}, },
@@ -74,7 +71,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "clay_soil_fertile", name = "clay_soil_fertile",
title = "Fertile Clay Soil", _title = "Fertile Clay Soil",
--description = "", --description = "",
tiles = clayTiles, tiles = clayTiles,
}, },
@@ -83,7 +80,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "clay_soil_rich", name = "clay_soil_rich",
title = "Rich Clay Soil", _title = "Rich Clay Soil",
--description = "", --description = "",
tiles = clayTiles, tiles = clayTiles,
}, },
@@ -96,7 +93,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "sandy_soil_baren", name = "sandy_soil_baren",
title = "Barren Sandy Soil", _title = "Barren Sandy Soil",
--description = "", --description = "",
tiles = sandyTiles, tiles = sandyTiles,
}, },
@@ -105,7 +102,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "sandy_soil_poor", name = "sandy_soil_poor",
title = "Poor Sandy Soil", _title = "Poor Sandy Soil",
--description = "", --description = "",
tiles = sandyTiles, tiles = sandyTiles,
}, },
@@ -114,7 +111,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "sandy_soil_moderate", name = "sandy_soil_moderate",
title = "Moderate Sandy Soil", _title = "Moderate Sandy Soil",
--description = "", --description = "",
tiles = sandyTiles, tiles = sandyTiles,
}, },
@@ -123,7 +120,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "sandy_soil_fertile", name = "sandy_soil_fertile",
title = "Fertile Sandy Soil", _title = "Fertile Sandy Soil",
--description = "", --description = "",
tiles = sandyTiles, tiles = sandyTiles,
}, },
@@ -132,7 +129,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "sandy_soil_rich", name = "sandy_soil_rich",
title = "Rich Sandy Soil", _title = "Rich Sandy Soil",
--description = "", --description = "",
tiles = sandyTiles, tiles = sandyTiles,
}, },
@@ -145,7 +142,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "mixed_soil_baren", name = "mixed_soil_baren",
title = "Barren Mixed Soil", _title = "Barren Mixed Soil",
--description = "", --description = "",
tiles = mixedTiles, tiles = mixedTiles,
}, },
@@ -154,7 +151,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "mixed_soil_poor", name = "mixed_soil_poor",
title = "Poor Mixed Soil", _title = "Poor Mixed Soil",
--description = "", --description = "",
tiles = mixedTiles, tiles = mixedTiles,
}, },
@@ -163,7 +160,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "mixed_soil_moderate", name = "mixed_soil_moderate",
title = "Moderate Mixed Soil", _title = "Moderate Mixed Soil",
--description = "", --description = "",
tiles = mixedTiles, tiles = mixedTiles,
}, },
@@ -172,7 +169,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "mixed_soil_fertile", name = "mixed_soil_fertile",
title = "Fertile Mixed Soil", _title = "Fertile Mixed Soil",
--description = "", --description = "",
tiles = mixedTiles, tiles = mixedTiles,
}, },
@@ -181,7 +178,7 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "mixed_soil_rich", name = "mixed_soil_rich",
title = "Rich Mixed Soil", _title = "Rich Mixed Soil",
--description = "", --description = "",
tiles = mixedTiles, tiles = mixedTiles,
}, },
@@ -194,43 +191,47 @@ soilFactory:registerItems({
{ {
settings = { settings = {
name = "rocky_soil_baren", name = "rocky_soil_baren",
title = "Barren Rocky Soil", _title = "Barren Rocky Soil",
--description = "", --description = "",
tiles = rockyTiles, tiles = rockyTiles,
rarity = 'uncommon'
}, },
}, },
---@type Node.NodeDefinition ---@type Node.NodeDefinition
{ {
settings = { settings = {
name = "rocky_soil_poor", name = "rocky_soil_poor",
title = "Poor Rocky Soil", _title = "Poor Rocky Soil",
--description = "", --description = "",
tiles = rockyTiles, tiles = rockyTiles,
rarity = 'distinguished'
}, },
}, },
---@type Node.NodeDefinition ---@type Node.NodeDefinition
{ {
settings = { settings = {
name = "rocky_soil_moderate", name = "rocky_soil_moderate",
title = "Moderate Rocky Soil", _title = "Moderate Rocky Soil",
--description = "", --description = "",
tiles = rockyTiles, tiles = rockyTiles,
rarity = 'eminent'
}, },
}, },
---@type Node.NodeDefinition ---@type Node.NodeDefinition
{ {
settings = { settings = {
name = "rocky_soil_fertile", name = "rocky_soil_fertile",
title = "Fertile Rocky Soil", _title = "Fertile Rocky Soil",
--description = "", --description = "",
tiles = rockyTiles, tiles = rockyTiles,
rarity = 'prime'
}, },
}, },
---@type Node.NodeDefinition ---@type Node.NodeDefinition
{ {
settings = { settings = {
name = "rocky_soil_rich", name = "rocky_soil_rich",
title = "Rich Rocky Soil", _title = "Rich Rocky Soil",
--description = "", --description = "",
tiles = rockyTiles, tiles = rockyTiles,
}, },
@@ -241,13 +242,10 @@ soilFactory:registerItems({
---@type TileSheet ---@type TileSheet
local tsT = TileSheet:new("soils_turfs_sheet.png", 16, 16) local tsT = TileSheet:new("soils_turfs_sheet.png", 16, 16)
Node:new({ defaultSoil:new({
settings = { settings = {
name = 'turf_swamp', name = 'turf_swamp',
tiles = {tsT:t(0,0), ts:t(6, 0), ts:t(6,0)..'^'..tsT:t(0,1)}, tiles = {tsT:t(0,0), ts:t(6, 0), ts:t(6,0)..'^'..tsT:t(0,1)},
groups = { _rarity = 'unique'
dig_immediate = 2,
soil_fertiliry = 100, -- Soil fertility for agriculture
}
} }
}) })

Binary file not shown.

Before

Width:  |  Height:  |  Size: 22 KiB

After

Width:  |  Height:  |  Size: 22 KiB

View File

@@ -0,0 +1,99 @@
local Node, TileSheet = Smc.requireNode(), Smc.requireTileSheet()
local defaultStorage = Node:getExtended({
settings = {
name = '',
groups = {
dig_immediate = 2,
storage = 1
},
paramtype = 'light',
paramtype2 = 'facedir',
}
})
local storageFactory = defaultStorage:getFactory()
---@type TileSheet
local caseTileSheet = TileSheet:new('cases_sheet.png', 16, 16)
local function getCaseTiles(x, y)
return {
caseTileSheet:t(x, y),
caseTileSheet:t(x, y),
caseTileSheet:t(x, y+1),
}
end
local t = getCaseTiles
storageFactory:registerItems({
---@type Node.NodeDefinition
{
settings = {
name = 'case_closed',
_title = 'Case',
--description = '',
tiles = t(0,0)
},
},
---@type Node.NodeDefinition
{
settings = {
name = 'case_open',
_title = 'Case',
--description = '',
tiles = t(1,0);
drawtype = 'nodebox';
node_box = {
type = 'fixed',
fixed = {
{-0.5, -0.5, -0.5, 0.5, 0.5 - 1/16*2, 0.5},
}
}
},
},
---@type Node.NodeDefinition
{
settings = {
drawtype = 'mesh',
name = 'chest_close',
tiles = {'storage_chest.png'},
mesh = 'storage_chest_close.obj',
node_box = {
type = 'fixed',
fixed = {
{-7/16, -0.5, -7/16, 23/16, 6/16, 7/16},
}
},
selection_box = {
type = 'fixed',
fixed = {
{-7/16, -0.5, -7/16, 23/16, 6/16, 7/16},
}
}
},
},
---@type Node.NodeDefinition
{
settings = {
drawtype = 'mesh',
name = 'chest_open',
tiles = {'storage_chest.png'},
mesh = 'storage_chest_open.obj',
node_box = {
type = 'fixed',
fixed = {
{-7/16, -0.5, -7/16, 23/16, 6/16, 7/16},
}
},
selection_box = {
type = 'fixed',
fixed = {
{-7/16, -0.5, -7/16, 23/16, 6/16, 7/16},
}
}
},
},
})

View File

@@ -0,0 +1,2 @@
name = smc__game__items__storages
depends = smc__core__node, smc__core__tilesheet

View File

@@ -0,0 +1,49 @@
# Made in Blockbench 4.12.5
mtllib storage_chest_close.mtl
o chest_close
v 0.4375 0.375 0.4375
v 0.4375 0.375 -0.4375
v 0.4375 -0.5 0.4375
v 0.4375 -0.5 -0.4375
v -1.4375 0.375 -0.4375
v -1.4375 0.375 0.4375
v -1.4375 -0.5 -0.4375
v -1.4375 -0.5 0.4375
vt 0.109375 0.890625
vt 0.34375 0.890625
vt 0.34375 0.78125
vt 0.109375 0.78125
vt 0 0.890625
vt 0.109375 0.890625
vt 0.109375 0.78125
vt 0 0.78125
vt 0.453125 0.890625
vt 0.6875 0.890625
vt 0.6875 0.78125
vt 0.453125 0.78125
vt 0.34375 0.890625
vt 0.453125 0.890625
vt 0.453125 0.78125
vt 0.34375 0.78125
vt 0.34375 0.890625
vt 0.109375 0.890625
vt 0.109375 1
vt 0.34375 1
vt 0.578125 1
vt 0.34375 1
vt 0.34375 0.890625
vt 0.578125 0.890625
vn 0 0 -1
vn 1 0 0
vn 0 0 1
vn -1 0 0
vn 0 1 0
vn 0 -1 0
usemtl m_79b8a0d4-4f5c-1950-bda6-ec259f602f6d
f 4/4/1 7/3/1 5/2/1 2/1/1
f 3/8/2 4/7/2 2/6/2 1/5/2
f 8/12/3 3/11/3 1/10/3 6/9/3
f 7/16/4 8/15/4 6/14/4 5/13/4
f 6/20/5 1/19/5 2/18/5 5/17/5
f 7/24/6 4/23/6 3/22/6 8/21/6

View File

@@ -0,0 +1,95 @@
# Made in Blockbench 4.12.5
mtllib storage_chest_open.mtl
o сундук
v 0.4375 0.25 0.4375
v 0.4375 0.25 -0.4375
v 0.4375 -0.5 0.4375
v 0.4375 -0.5 -0.4375
v -1.4375 0.25 -0.4375
v -1.4375 0.25 0.4375
v -1.4375 -0.5 -0.4375
v -1.4375 -0.5 0.4375
vt 0.109375 0.875
vt 0.34375 0.875
vt 0.34375 0.78125
vt 0.109375 0.78125
vt 0 0.875
vt 0.109375 0.875
vt 0.109375 0.78125
vt 0 0.78125
vt 0.453125 0.875
vt 0.6875 0.875
vt 0.6875 0.78125
vt 0.453125 0.78125
vt 0.34375 0.875
vt 0.453125 0.875
vt 0.453125 0.78125
vt 0.34375 0.78125
vt 0.8125 0.890625
vt 0.578125 0.890625
vt 0.578125 1
vt 0.8125 1
vt 0.578125 1
vt 0.34375 1
vt 0.34375 0.890625
vt 0.578125 0.890625
vn 0 0 -1
vn 1 0 0
vn 0 0 1
vn -1 0 0
vn 0 1 0
vn 0 -1 0
usemtl m_79b8a0d4-4f5c-1950-bda6-ec259f602f6d
f 4/4/1 7/3/1 5/2/1 2/1/1
f 3/8/2 4/7/2 2/6/2 1/5/2
f 8/12/3 3/11/3 1/10/3 6/9/3
f 7/16/4 8/15/4 6/14/4 5/13/4
f 6/20/5 1/19/5 2/18/5 5/17/5
f 7/24/6 4/23/6 3/22/6 8/21/6
o крышка
v 0.4375 0.33838834764831843 0.46338834764831843
v 0.4375 0.9571067811865475 -0.15533008588991049
v 0.4375 0.25 0.375
v 0.4375 0.8687184335382291 -0.24371843353822897
v -1.4375 0.9571067811865475 -0.15533008588991049
v -1.4375 0.33838834764831843 0.46338834764831843
v -1.4375 0.8687184335382291 -0.24371843353822897
v -1.4375 0.25 0.375
vt 0.109375 0.890625
vt 0.34375 0.890625
vt 0.34375 0.875
vt 0.109375 0.875
vt 0 0.890625
vt 0.109375 0.890625
vt 0.109375 0.875
vt 0 0.875
vt 0.453125 0.890625
vt 0.6875 0.890625
vt 0.6875 0.875
vt 0.453125 0.875
vt 0.34375 0.890625
vt 0.453125 0.890625
vt 0.453125 0.875
vt 0.34375 0.875
vt 0.34375 0.890625
vt 0.109375 0.890625
vt 0.109375 1
vt 0.34375 1
vt 0.578125 1
vt 0.34375 1
vt 0.34375 0.890625
vt 0.578125 0.890625
vn 0 0.7071067811865476 -0.7071067811865475
vn 1 0 0
vn 0 -0.7071067811865476 0.7071067811865475
vn -1 0 0
vn 0 0.7071067811865475 0.7071067811865476
vn 0 -0.7071067811865475 -0.7071067811865476
usemtl m_79b8a0d4-4f5c-1950-bda6-ec259f602f6d
f 12/28/7 15/27/7 13/26/7 10/25/7
f 11/32/8 12/31/8 10/30/8 9/29/8
f 16/36/9 11/35/9 9/34/9 14/33/9
f 15/40/10 16/39/10 14/38/10 13/37/10
f 14/44/11 9/43/11 10/42/11 13/41/11
f 15/48/12 12/47/12 11/46/12 16/45/12

View File

Before

Width:  |  Height:  |  Size: 4.2 KiB

After

Width:  |  Height:  |  Size: 4.2 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 64 KiB

View File

@@ -1,43 +1,54 @@
---@type Node local Node, TileSheet = Smc.requireNode(), Smc.requireTileSheet()
local Node = Mod.getInfo('smc__core__node').require('Node')
---@type TileSheet
local TileSheet = Mod.getInfo('smc__core__tilesheet').require('TileSheet')
---@type Node.NodeDefinition ---@type Node.NodeDefinition
local defaultRockDef = { local defaultLogDef = {
settings = { settings = {
name = "", name = '',
description = "A log",
tiles = {}, tiles = {},
groups = { groups = {
dig_immediate = 2, dig_immediate = 2,
wood = 1
}, },
paramtype2 = "facedir", }
},
} }
---@type Node.NodeDefinition ---@type Node.NodeDefinition
local defaultPlanksDef = { local defaultPlanksDef = {
settings = { settings = {
name = "", name = '',
description = "A planks",
tiles = {}, tiles = {},
groups = { groups = {
dig_immediate = 2, dig_immediate = 2,
}, },
paramtype2 = "facedir", paramtype2 = 'facedir',
}, },
} }
local defaultLog = Node:getExtended(defaultRockDef) ---@type Node.NodeDefinition
local defaultLeafsDef = {
settings = {
drawtype = 'allfaces_optional',
name = '',
tiles = {},
groups = {
dig_immediate = 2,
},
--paramtype = 'light',
paramtype2 = 'facedir',
use_texture_alpha = 'clip',
sunlight_propagates = true,
},
}
local defaultLog = Node:getExtended(defaultLogDef)
local defaultPlanks = Node:getExtended(defaultPlanksDef) local defaultPlanks = Node:getExtended(defaultPlanksDef)
local defaultLeafs = Node:getExtended(defaultLeafsDef)
local logFactory = defaultLog:getFactory() local logFactory = defaultLog:getFactory()
local planksFactory = defaultPlanks:getFactory() local planksFactory = defaultPlanks:getFactory()
---@type TileSheet ---@type TileSheet
local logTileSheet = TileSheet:new("wood_sheet.png", 16, 16) local logTileSheet = TileSheet:new('wood_sheet.png', 16, 16)
local function getLogTiles(x, y) local function getLogTiles(x, y)
return { return {
@@ -47,161 +58,149 @@ local function getLogTiles(x, y)
} }
end end
local t = getLogTiles local t = logTileSheet
logFactory:registerItems({
---@type Node.NodeDefinition
{
settings = {
name = "marentine_log",
title = "Marentine Log",
--description = "",
tiles = t(0, 1),
},
},
---@type Node.NodeDefinition
{
settings = {
name = "allwhere_log",
title = "Allwhere Log",
--description = "",
tiles = t(2, 1),
},
},
---@type Node.NodeDefinition
{
settings = {
name = "fis_log",
title = "Fis Log",
--description = "",
tiles = t(4, 1),
},
},
---@type Node.NodeDefinition
{
settings = {
name = "tammoy_log",
title = "Tammoy Log",
--description = "",
tiles = t(6, 1),
},
},
---@type Node.NodeDefinition
{
settings = {
name = "dallalia_log",
title = "Dallalia Log",
--description = "",
tiles = t(8, 1),
},
},
---@type Node.NodeDefinition
{
settings = {
name = "zuph_log",
title = "Zuph Log",
--description = "",
tiles = t(10, 1),
},
},
})
planksFactory:registerItems({ ---@class WoodDef
---@type Node.NodeDefinition ---@field rarity Item.Rarity?
{
settings = {
name = "marentine_planks",
title = "Marentine Planks",
--description = "",
tiles = { logTileSheet:t(0, 4) },
},
},
---@type Node.NodeDefinition
{
settings = {
name = "allwhere_planks",
title = "Allwhere Planks",
--description = "",
tiles = { logTileSheet:t(2, 4) },
},
},
---@type Node.NodeDefinition
{
settings = {
name = "fis_planks",
title = "Fis Planks",
--description = "",
tiles = { logTileSheet:t(4, 4) },
},
},
---@type Node.NodeDefinition
{
settings = {
name = "tammoy_planks",
title = "Tammoy Planks",
--description = "",
tiles = { logTileSheet:t(6, 4) },
},
},
---@type Node.NodeDefinition
{
settings = {
name = "dallalia_planks",
title = "Dallalia Planks",
--description = "",
tiles = { logTileSheet:t(8, 4) },
},
},
---@type Node.NodeDefinition
{
settings = {
name = "zuph_planks",
title = "Zuph Planks",
--description = "",
tiles = { logTileSheet:t(10, 4) },
},
},
})
-- сундучки ---@param name string
---@param x number
---@param def WoodDef?
local function registerWood(name, x, def)
if def == nil then
def = {}
end
---@type TileSheet defaultLog:new({
local caseTileSheet = TileSheet:new("cases_sheet.png", 16, 16) settings = {
name = name..'_log',
local function getCaseTiles(x, y) tiles = getLogTiles(x, 2),
return { paramtype2 = 'facedir',
caseTileSheet:t(x, y), _rarity = def.rarity,
caseTileSheet:t(x, y), },
caseTileSheet:t(x, y+1), callbacks = {
on_place = core.rotate_node
} }
})
defaultLog:new({
settings = {
name = name..'_log_stripped',
tiles = getLogTiles(x, 4),
paramtype2 = 'facedir',
_rarity = def.rarity
},
callbacks = {
on_place = core.rotate_node
}
})
defaultLog:new({
settings = {
name = name..'_timber',
tiles = {logTileSheet:t(x, 8), logTileSheet:t(x, 8),
logTileSheet:t(x, 7), logTileSheet:t(x, 7),
logTileSheet:t(x, 8), logTileSheet:t(x, 8),},
paramtype2 = 'facedir',
_rarity = def.rarity,
},
callbacks = {
on_place = core.rotate_node
}
})
defaultLog:new({
settings = {
name = name..'_trunk',
tiles = {logTileSheet:t(x, 3)},
inventory_overlay = 'wood_trunk_overlay.png',
drop = 'wood:'..name..'_log',
paramtype2 = 'facedir',
_rarity = def.rarity,
},
callbacks = {
on_place = core.rotate_node
}
})
defaultLog:new({
settings = {
name = name..'_trunk_vertical',
tiles = getLogTiles(x, 2),
inventory_overlay = 'wood_trunk_overlay.png',
drop = 'wood:'..name..'_log',
paramtype2 = 'facedir',
_rarity = def.rarity,
},
callbacks = {
on_place = core.rotate_node
}
})
defaultLog:new({
settings = {
drawtype = 'nodebox',
name = name..'_trunk_branch',
tiles = {logTileSheet:t(x, 3)},
inventory_overlay = 'wood_trunk_overlay.png',
drop = 'wood:'..name..'_log',
paramtype = 'light',
node_box = {
type = 'connected',
fixed = {-.25,-.25,-.25, .25,.25,.25},
connect_top = {-.25,-.25,-.25, .25,.5,.25},
connect_bottom = {-.25,-.5,-.25, .25,.25,.25},
connect_front = {-.25,-.25,-.5, .25,.25,.25},
connect_left = {-.5,-.25,-.25, .25,.25,.25},
connect_back = {-.25,-.25,-.25, .25,.25,.5},
connect_right = {-.25,-.25,-.25, .5,.25,.25},
},
connects_to = {'group:wood', 'group:soil'},
_rarity = def.rarity,
},
})
defaultLog:new({
settings = {
drawtype = 'nodebox',
name = name..'_trunk_branch_vertical',
tiles = getLogTiles(x, 2),
inventory_overlay = 'wood_trunk_overlay.png',
drop = 'wood:'..name..'_log',
paramtype = 'light',
node_box = {
type = 'connected',
fixed = {-.25,-.25,-.25, .25,.25,.25},
connect_top = {-.25,-.25,-.25, .25,.5,.25},
connect_bottom = {-.25,-.5,-.25, .25,.25,.25},
},
connects_to = {'group:wood', 'group:soil'},
_rarity = def.rarity,
},
})
defaultPlanks:new({
settings = {
name = name..'_planks',
tiles = { logTileSheet:t(x, 6) },
_rarity = def.rarity,
},
})
defaultLeafs:new({
settings = {
name = name..'_leafs',
tiles = { logTileSheet:t(x, 1) },
_rarity = def.rarity,
},
})
end end
local t = getCaseTiles registerWood('marentine', 0)
registerWood('allwhere', 1)
planksFactory:registerItems({ registerWood('fis', 2)
---@type Node.NodeDefinition registerWood('tammoy', 3)
{ registerWood('gi', 4, {rarity = 'uncommon'})
settings = { registerWood('dallalia', 5)
name = "case_closed", registerWood('zuph', 6, {rarity = 'uncommon'})
title = "Case",
--description = "",
tiles = t(0,0)
},
},
---@type Node.NodeDefinition
{
settings = {
name = "case_open",
title = "Case",
--description = "",
tiles = t(1,0);
drawtype = 'nodebox';
node_box = {
type = "fixed",
fixed = {
{-0.5, -0.5, -0.5, 0.5, 0.5 - 1/16*2, 0.5},
}
}
},
},
})

View File

@@ -0,0 +1,133 @@
# textdomain: wood
marentine_log-title=Бревно марентина
marentine_log-desc=Темная древесина, отдающая синевой.@n Часто встречается вблизи крупных водоёмов.
marentine_log_stripped-title=Обтёсанное бревно марентина
marentine_log_stripped-desc=Освобождённое от тёмно-синей коры@n более светлая древесная сердцевина.
marentine_timber-title=
marentine_timber-desc=
marentine_trunk-title=
marentine_trunk-desc=
marentine_trunk_vertical-title=
marentine_trunk_vertical-desc=
marentine_trunk_branch-title=
marentine_trunk_branch-desc=
marentine_trunk_branch_vertical-title=
marentine_trunk_branch_vertical-desc=
marentine_planks-title=Марентиновые доски
marentine_planks-desc=Темные плотно скрепленные между собой@n доски из марентиновой древесины.
marentine_leafs-title=
marentine_leafs-desc=
allwhere_log-title=Бревно всемира
allwhere_log-desc=Распростроенный древесный материал,@n встречающийся почти во всех местах Тариона.@n Эта древесина не обладает особыми свойствами,@n но за счёт своей распространённости широко@n применяется во многих базовых изделиях.
allwhere_log_stripped-title=Обтёсанное бревно всемира.
allwhere_log_stripped-desc=Светлая мягкая сердцевина,@n лишённая своей коры.
allwhere_timber-title=
allwhere_timber-desc=
allwhere_trunk-title=
allwhere_trunk-desc=
allwhere_trunk_vertical-title=
allwhere_trunk_vertical-desc=
allwhere_trunk_branch-title=
allwhere_trunk_branch-desc=
allwhere_trunk_branch_vertical-title=
allwhere_trunk_branch_vertical-desc=
allwhere_planks-title=Всемировые доски
allwhere_planks-desc=Светлые доски, плотно@n состыкованные между собой.
allwhere_leafs-title=
allwhere_leafs-desc=
fis_log-title=Бревно фиса
fis_log-desc=Необычное бревно с кроваво-красной@n сердцевиной и коры цвета белой кости.
fis_log_stripped-title=Обтёсанное бревно фиса
fis_log_stripped-desc=Кроваво-красная сердцевина,@n лишенная оболочки из светлой коры.
fis_timber-title=
fis_timber-desc=
fis_trunk-title=
fis_trunk-desc=
fis_trunk_vertical-title=
fis_trunk_vertical-desc=
fis_trunk_branch-title=
fis_trunk_branch-desc=
fis_trunk_branch_vertical-title=
fis_trunk_branch_vertical-desc=
fis_planks-title=Фисовые доски
fis_planks-desc=Красные подогнанные друг к другу и@n доски из фисовой древесины.
fis_leafs-title=
fis_leafs-desc=
tammoy_log-title=Бревно таммоя
tammoy_log-desc=Светлая хвойная древесина, покрытая@n легкоотдираемой чешуйчатой корой.
tammoy_log_stripped-title=Обтёсанное бревно таммоя
tammoy_log_stripped-desc=Светлая хвойная древесина,@n сочащаяся смолой взамен удалённой коры.
tammoy_timber-title=
tammoy_timber-desc=
tammoy_trunk-title=
tammoy_trunk-desc=
tammoy_trunk_vertical-title=
tammoy_trunk_vertical-desc=
tammoy_trunk_branch-title=
tammoy_trunk_branch-desc=
tammoy_trunk_branch_vertical-title=
tammoy_trunk_branch_vertical-desc=
tammoy_planks-title=Таммоевые доски
tammoy_planks-desc=Смолянистые плотно прилегающие друг к другу светлые доски.
tammoy_leafs-title=
tammoy_leafs-desc=
gi_log-title=Бревно ги
gi_log-desc=Благодорно-тёмная хвойная древесина,@n относящаяся к высококачественным древесным породам.@n Эта древесина особенно славится своими прочностными@n свойствами и фактурой волокон.
gi_log_stripped-title=Обтёсанное бревно ги
gi_log_stripped-desc=Плотная хвойная сердцевина, являющаяся идеальным@n материалом для изготовления различных предметов.@n В руках умелого мастера фактура этого дерева@n приобретает особенно красивый узор.
gi_timber-title=
gi_timber-desc=
gi_trunk-title=
gi_trunk-desc=
gi_trunk_vertical-title=
gi_trunk_vertical-desc=
gi_trunk_branch-title=
gi_trunk_branch-desc=
gi_trunk_branch_vertical-title=
gi_trunk_branch_vertical-desc=
gi_planks-title=Гиевые доски
gi_planks-desc=Прочные хорошо сложенные@n доски из благодорного дерева ги.
gi_leafs-title=
gi_leafs-desc=
dallalia_log-title=Бревно даллалии
dallalia_log-desc=Сладко-жёлтоватая древесина, покрытая пепельно-серой корой.@n Плотность и прочность этого вида дерева@n позволяет дереву устремляться в небо на несколько десятков метров.
dallalia_log_stripped-title=Обтёсанное бревно даллалии
dallalia_log_stripped-desc=Освобожденная от своей бледной коры жёлтовая древесина,@n сочащаяся сладким соком.
dallalia_timber-title=
dallalia_timber-desc=
dallalia_trunk-title=
dallalia_trunk-desc=
dallalia_trunk_vertical-title=
dallalia_trunk_vertical-desc=
dallalia_trunk_branch-title=
dallalia_trunk_branch-desc=
dallalia_trunk_branch_vertical-title=
dallalia_trunk_branch_vertical-desc=
dallalia_planks-title=Даллалиевые доски
dallalia_planks-desc=Жёлтые плотно сложенные доски,@n покрытие застывшим соком дерева.
dallalia_leafs-title=
dallalia_leafs-desc=
zuph_log-title=Бревно зуфа
zuph_log-desc=Светлая древесина с корой из мелких волокон.@n Из-за толстой плотной оболочки плохо поддается рубке.
zuph_log_stripped-title=Обтёсанное бревно зуфа
zuph_log_stripped-desc=Жёлтая древесина,@n лишённая трудноразрубаемой коры.
zuph_timber-title=
zuph_timber-desc=
zuph_trunk-title=
zuph_trunk-desc=
zuph_trunk_vertical-title=
zuph_trunk_vertical-desc=
zuph_trunk_branch-title=
zuph_trunk_branch-desc=
zuph_trunk_branch_vertical-title=
zuph_trunk_branch_vertical-desc=
zuph_planks-title=Зуфовые доски
zuph_planks-desc=Хорошо скрепленные между собой жёлтые древестные изделия.
zuph_leafs-title=
zuph_leafs-desc=

Binary file not shown.

Before

Width:  |  Height:  |  Size: 122 KiB

After

Width:  |  Height:  |  Size: 16 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.2 KiB

View File

@@ -0,0 +1,132 @@
local modInfo = Mod.getInfo('smc__core__formspec')
local require = modInfo.require
---@type AdminListUI
local AdminListUI = Mod.getInfo('smc__ui__admin_list').require('AdminListUI')
core.register_chatcommand('list', {
privs = {server = true},
func = function(name, param)
local player = core.get_player_by_name(name)
AdminListUI:showForm(name)
return true, ''
end
})
AdminListUI:registerOnFormFieldActionMatch('%S+::item_button',function(player, fieldName, fieldValue)
---@type ItemStackString?
local stack = string.match(fieldName, '(%S+)::item_button')
if stack == nil then
return
end
local playerName = player:get_player_name()
AdminListUI:setContex(playerName, 'select_item', stack)
AdminListUI:showForm(playerName)
end)
AdminListUI:registerOnFormFieldAction('admin_commands:list_add_item', function(player, fieldName, fieldValue)
---@type InvRef
local inv = player:get_inventory()
local playerName = player:get_player_name()
local stack = AdminListUI:getContex(playerName, 'select_item')
stack = ItemStack(stack)
stack:set_count(fieldValue)
if inv:room_for_item('main', stack) then
inv:add_item('main', stack)
end
end)
core.register_on_joinplayer(function(player, last_login)
player:set_sky({
sky_color = {
day_sky = '#FCF0ED',
day_horizon = '#F1D4C3',
},
type = 'regular',
})
player:set_lighting({
shadows = { intensity = 0.33 },
volumetric_light = { strength = 0.45 },
exposure = {
luminance_min = -3.5,
luminance_max = -2.5,
exposure_correction = 0.35,
speed_dark_bright = 1500,
speed_bright_dark = 700,
},
saturation = 1.0,
})
end)
-- Keys indicating the languages ​​for which localization presence is checked.
local LANG_CODES = {'en', 'ru'}
-- Number of missed localizations.
local missedLocaleCount = 0
local function checkLocale(strTranslate, langCodes)
local str = core.strip_escapes(strTranslate)
for _, langCode in ipairs(langCodes or LANG_CODES) do
if core.strip_escapes(core.get_translated_string(langCode, strTranslate)) == str then
missedLocaleCount = missedLocaleCount + 1
Logger.warningLog('Localization missing[%s][%s]. String: `%s`.', missedLocaleCount, langCode, str)
end
end
end
core.register_chatcommand('get_missing_locale', {
privs = {server = true},
description = '{short_mod_name:string?, lang_codes:string[]?}',
func = function(name, paramsStr)
local params = core.deserialize('return '..paramsStr or '{}')
if params == nil then
return false
end
local shortModName = params.short_mod_name
local langCodes = params.lang_codes
if shortModName ~= nil and type(shortModName) ~= 'string' then
return false
end
if langCodes ~= nil and type(langCodes) ~= 'table' then
return false
end
local items
if shortModName == '' or shortModName == nil then
items = Smc.getRegisteredItems()
else
items = Smc.getRegisteredItemsByMod(shortModName)
end
if items == nil then
return false, 'There are no items registered for this mod (or the entire game)'
end
---@param name string
---@param item Item
for name, item in pairs(items) do
local itemSettings = item.itemDef.settings
local title, desc = itemSettings._title, itemSettings._description
checkLocale(title, langCodes)
checkLocale(desc, langCodes)
end
return true, ''
end
})

View File

@@ -0,0 +1,2 @@
name = smc__game__admin_commands
depends = smc__system__system_loader, smc__ui__admin_list

View File

@@ -1,13 +1,13 @@
local setMetaTable, TableCopy = setmetatable, table.copy_with_metatables local setMetaTable, tableCopy = setmetatable, table.copy_with_metatables
---@class Class ---@class Class
Class = {} Class = {}
---Returns a child class with inherited parameters from the parent class. ---Returns a child class with inherited parameters from the parent class.
---@param parent table ---@param parent table
---@param child table ---@param child table?
function Class.extend(parent ,child) function Class.extend(parent, child)
return setmetatable(child or {}, { __index = TableCopy(parent) }) return setMetaTable(child or {}, { __index = tableCopy(parent) })
end end
---Intended for class constructors. ---Intended for class constructors.
@@ -23,7 +23,7 @@ function Class.getInstance(self, params, metatable)
metatable = {} metatable = {}
end end
metatable.__index = TableCopy(self) metatable.__index = tableCopy(self)
local instance = setMetaTable(params, metatable) local instance = setMetaTable(params, metatable)

View File

@@ -5,20 +5,16 @@ Events = {}
---@type table<string, Events.callback[]> ---@type table<string, Events.callback[]>
local registeredEvents = {} local registeredEvents = {}
---@param eventName string
function Events.registerEvent(eventName)
assert(registeredEvents[eventName] == nil, ('Event %s is already registered.'):format(eventName))
registeredEvents[eventName] = {}
end
---@param eventName string ---@param eventName string
---@param callback Events.callback ---@param callback Events.callback
function Events.subscribe(eventName, callback) function Events.subscribe(eventName, callback)
local callbacks = registeredEvents[eventName] local callbacks = registeredEvents[eventName]
assert(callbacks ~= nil, ('Event %s does not exist'):format(eventName))
if callbacks == nil then
registeredEvents[eventName] = {callback}
else
table.insert(callbacks, callback) table.insert(callbacks, callback)
end
end end
---@param eventName string ---@param eventName string

Binary file not shown.

View File

@@ -0,0 +1,56 @@
# Game fonts
Description of the fonts that are pre-installed for the project and passed on to all clients for displaying text.
## Philosopher
Download site: https://fonts-online.ru/fonts/doloto.
Used in:
- `regular.ttf`
- `mono.ttf`
### Info
Designed by **Jovanny Lemonad**.
### Licence
Copyright 2011 The Philosopher Project Authors (https://github.com/alexeiva/philosopher)
This Font Software is licensed under the SIL Open Font License, Version 1.1 . This license is copied below, and is also available with a FAQ at: https://openfontlicense.org
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
#### PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others.
The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives.
#### DEFINITIONS
"Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation.
"Reserved Font Name" refers to any names specified as such after the copyright statement(s).
"Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s).
"Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment.
"Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software.
#### PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions:
- Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself.
- Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user.
- No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users.
- The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission.
- The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software.
#### TERMINATION
This license becomes null and void if any of the above conditions are not met.
#### DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.
---

Binary file not shown.

Binary file not shown.

View File

@@ -5,3 +5,8 @@ local require = modInfo.require
require('Lib.globalStep') require('Lib.globalStep')
require('Lib.color') require('Lib.color')
require('Lib.immersiveCraftData')
require('Lib.getObjectByGUID')
require('Lib.receiveFields')
require('Lib.registeredItems')
require('Lib.requires')

View File

@@ -0,0 +1,16 @@
---Returns an active object by unique identifier (GUID).
---* For players, this is a player name.
---* For Lua entities, this is a uniquely generated string, guaranteed not to collide with player names.
---
---**Note**: If an object with such an identifier does not exist or is inactive, the value `nil` will be returned.
---@param guid string only use printable ASCII characters. Example: `@bGh3p2AbRE29Mb4biqX6OA`.
---@return ObjectRef|Player|Entity|nil
function Smc.getObjectByGUID(guid)
local obj = core.objects_by_guid[guid]
if obj == nil then
return
else
return obj
end
end

View File

@@ -0,0 +1,94 @@
local EMPTY_FLAG = 'EMPTY_FLAG'
---@class ImmersiveStageData
---@class ImmersiveCraftData
---@field playerName string The name of the player who started the craft.
---@field craftName string
---@field stageName string
---@field amount integer
---@field stageData ImmersiveStageData?
---Returns craft data for immersive crafting, which is stored in the desktop metadata.
---@param meta NodeMetaRef
---@return ImmersiveCraftData?
function Smc.getCraftDataByMeta(meta)
local dataString = meta:get_string('craft_data')
if dataString == EMPTY_FLAG then
return
end
return core.deserialize(dataString)
end
---Sets craft data for immersive crafting that is stored in the work station metadata.
---
---If `data` is `nil`, the data is cleared.
---@param meta NodeMetaRef
---@param craftData ImmersiveCraftData?
function Smc.setCraftDataByMeta(meta, craftData)
if craftData == nil then
meta:set_string('craft_data', EMPTY_FLAG)
end
meta:set_string('craft_data', core.serialize(craftData))
end
---Returns craft data for immersive crafting, which is stored in the work station metadata.
---@param pos MapPosition
---@return ImmersiveCraftData?
function Smc.getCraftDataByPos(pos)
local meta = core.get_meta(pos)
return Smc.getCraftDataByMeta(meta)
end
---Sets craft data for immersive crafting that is stored in the work station metadata.
---
---If `data` is `nil`, the data is cleared.
---@param pos MapPosition
---@param craftData ImmersiveCraftData?
function Smc.setCraftDataByPos(pos, craftData)
local meta = core.get_meta(pos)
Smc.setCraftDataByMeta(meta, craftData)
end
---Returns stage data for immersive crafting, which is stored in the work station metadata.
---
---**Note**: If the workbench does not have crafting data, an error will be thrown.
---@param pos MapPosition
---@return ImmersiveStageData?
function Smc.getStageDataByPos(pos)
local craftData = Smc.getCraftDataByPos(pos)
assert(craftData ~= nil, 'Immersive crafting data is empty.')
return craftData.stageData
end
---Sets stage data for immersive crafting that is stored in the work station metadata.
---@param pos MapPosition
---@param stageData ImmersiveStageData
function Smc.setStageDataByPos(pos, stageData)
local craftData = Smc.getCraftDataByPos(pos)
assert(craftData ~= nil, 'Immersive crafting data is empty.')
craftData.stageData = stageData
Smc.setCraftDataByPos(pos, craftData)
end
---Checks if the workstation is busy or free for new crafting.
---
---The verification is based on `ImmersiveCraftData`.
---@param pos MapPosition
---@return boolean
function Smc.workStationIsFree(pos)
local data = Smc.getCraftDataByPos(pos)
if data == nil then
return true
else
return false
end
end

View File

@@ -0,0 +1,67 @@
---Register a callback for a specific player action in FormSpec.
---
---The callback is guaranteed to be called only for the specified form and the specified field.
---@param formName string the name of the formspec for which the callback will be called.
---@param fieldName string the name of the field for which the callback will be called.
---@param callback fun(player:Player, fieldName:string, fieldValue:any) Callback to handle the action. Parameters:
--- * `player` - the player who performed the action.
--- * `fieldName` - the name of the field on which the callback is called.
--- * `fieldValue` - the field value that is passed in the `fields` table.
function Smc.registerOnFormFieldAction(formName, fieldName, callback)
core.register_on_player_receive_fields(function(player, formname, fields)
-- If the form name does not match the given...
if formName ~= formname then
-- ...we do nothing.
return
end
local fieldValue = fields[fieldName]
-- If the field value is not nil (the player called this field)...
if fieldValue ~= nil then
-- ...calling a callback.
callback(player, fieldName, fieldValue)
end
end)
end
---Register a callback function to close the FormSpec.
---
---The callback is guaranteed to be called only for the specified form.
---@param formName string the name of the form that is being closed.
---@param callback fun(player:Player) Callback to handle the close. Parameters:
--- * `player` - the player who closed the form.
function Smc.registerOnFormQuit(formName, callback)
Smc.registerOnFormFieldAction(formName, 'quit', callback)
end
---Register a callback for a specific player action in FormSpec.
---
---The callback function is guaranteed to be called only for the specified form and
---for the field whose name matches the pattern.
---@param formName string the name of the formspec for which the callback will be called.
---@param fieldNamePattern string the name pattern of the field for which the callback will be called.
---@param callback fun(player:Player, fieldName:string, fieldValue:any) Callback to handle the action. Parameters:
--- * `player` - the player who performed the action.
--- * `fieldName` - the name of the field on which the callback is called (will match the pattern).
--- * `fieldValue` - the field value that is passed in the `fields` table.
function Smc.registerOnFormFieldActionMatch(formName, fieldNamePattern, callback)
core.register_on_player_receive_fields(function(player, formname, fields)
-- If the form name does not match the given...
if formName ~= formname then
-- ...we do nothing.
return
end
-- We go through each field in the list of fields.
for fieldName, fieldValue in pairs(fields) do
-- We check the field name pattern compliance.
local capturedName = string.match(fieldName, fieldNamePattern)
-- If the captured name is not nil...
if capturedName ~= nil then
-- ...calling a callback.
callback(player, fieldName, fieldValue)
end
end
end)
end

View File

@@ -0,0 +1,33 @@
---@type table<string, Item>
local registeredItems = {}
---@type table<string, table<string, Item>>
local registeredItemsByMod = {}
---@param shortModName string
---@param item Item
function Smc.addRegisteredItem(shortModName, item)
local itemName = item.itemDef.settings.name
local modItems = registeredItemsByMod[shortModName]
if modItems == nil then
registeredItemsByMod[shortModName] = {[itemName]=item}
return
end
assert(modItems[itemName] == nil)
registeredItems[itemName] = item
modItems[itemName] = item
end
---@param shortModName string
---@return table<string, Item>?
function Smc.getRegisteredItemsByMod(shortModName)
return table.copy_with_metatables(registeredItemsByMod[shortModName])
end
---@return table<string, Item>?
function Smc.getRegisteredItems()
return table.copy_with_metatables(registeredItems)
end

View File

@@ -0,0 +1,66 @@
-- Global methods for require classes.
---@return Item
function Smc.requireItem()
---@type Item
local class = Mod.getInfo('smc__core__item').require('Item')
return class
end
---@return Node
function Smc.requireNode()
---@type Node
local class = Mod.getInfo('smc__core__node').require('Node')
return class
end
---@return Tool
function Smc.requireTool()
---@type Tool
local class = Mod.getInfo('smc__core__tool').require('Tool')
return class
end
---@return Plant
function Smc.requirePlant()
---@type Plant
local class = Mod.getInfo('smc__core__plant').require('Plant')
return class
end
---@return ItemFactory
function Smc.requireItemFactory()
---@type ItemFactory
local class = Mod.getInfo('smc__core__item_factory').require('ItemFactory')
return class
end
---@return TileSheet
function Smc.requireTileSheet()
---@type TileSheet
local class = Mod.getInfo('smc__core__tilesheet').require('TileSheet')
return class
end
---@return BaseUI
function Smc.requireBaseUI()
---@type BaseUI
local class = Mod.getInfo('smc__core__base_ui').require('BaseUI')
return class
end
---@return Formspec
function Smc.requireFormspec()
---@type Formspec
local class = Mod.getInfo('smc__core__formspec').require('Formspec')
return class
end

View File

@@ -0,0 +1,60 @@
local getInstance = Class.getInstance
local getUsTime = core.get_us_time
---@alias Profiler.TimeUnits 'sec'|'us'
---@class Profiler
---@field name string
---@field startTime number
---@field endTime number
---@field deltaTime number
Profiler = {
timers = {}
}
---@param name string?
---@return Profiler
function Profiler:new(name)
local instance = getInstance(self, {})
instance.name = name or 'NoName'
return instance
end
---Marks the time when the timer starts.
function Profiler:startTimer()
self.startTime = getUsTime()
self.deltaTime = nil
self.endTime = nil
end
---Marks the end time of the timer.
function Profiler:stopTimer()
self.endTime = getUsTime()
self.deltaTime = self.endTime - self.startTime
end
---Returns the time difference between the start and stop of the timer in seconds (`sec`) or microseconds (`us`).
---@param units Profiler.TimeUnits? Units of time measurement. Default 'us'.
function Profiler:getDeltaTime(units)
if units == nil then
units = 'us'
end
if units == 'us' then
return self.deltaTime
elseif units == 'sec' then
return self.deltaTime/1000000
end
end
---Displays the time difference in the chat using `core.log`.
---@param min number?
function Profiler:logDeltaTime(min)
local delta = self:getDeltaTime()
if delta >= (min or 0) then
core.log(('DeltaTime[%s]: %.3f'):format(self.name, delta))
end
end

Some files were not shown because too many files have changed in this diff Show More