378 lines
14 KiB
Lua
378 lines
14 KiB
Lua
--[[
|
|
Everness. Never ending discovery in Everness mapgen.
|
|
Copyright (C) 2025 SaKeL
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
--]]
|
|
|
|
local path = core.get_modpath('everness')
|
|
|
|
-- Shim missing main-thread engine registration/notification methods in the async mapgen environment
|
|
core.set_gen_notify = core.set_gen_notify or function() end
|
|
core.register_biome = core.register_biome or function() end
|
|
core.register_decoration = core.register_decoration or function() end
|
|
core.register_ore = core.register_ore or function() end
|
|
core.register_node = core.register_node or function() end
|
|
core.register_tool = core.register_tool or function() end
|
|
core.register_craftitem = core.register_craftitem or function() end
|
|
core.register_abm = core.register_abm or function() end
|
|
core.register_lbm = core.register_lbm or function() end
|
|
core.register_alias = core.register_alias or function() end
|
|
core.get_translator = core.get_translator or function() return function(s) return s end end
|
|
core.emerge_area = core.emerge_area or function() end
|
|
core.place_schematic = core.place_schematic or function() end
|
|
core.get_node = core.get_node or function() return { name = 'ignore' } end
|
|
core.set_node = core.set_node or function() end
|
|
core.remove_node = core.remove_node or function() end
|
|
core.get_biome_data = core.get_biome_data or function() return nil end
|
|
core.get_mapgen_setting = core.get_mapgen_setting or function() return nil end
|
|
core.dir_to_wallmounted = core.dir_to_wallmounted or function(dir)
|
|
if dir.y > 0.5 then return 1
|
|
elseif dir.y < -0.5 then return 0
|
|
elseif dir.x > 0.5 then return 5
|
|
elseif dir.x < -0.5 then return 4
|
|
elseif dir.z > 0.5 then return 3
|
|
elseif dir.z < -0.5 then return 2
|
|
end
|
|
return 0
|
|
end
|
|
|
|
core.registered_decorations = core.registered_decorations or {}
|
|
core.registered_nodes = core.registered_nodes or {}
|
|
core.registered_items = core.registered_items or {}
|
|
core.registered_biomes = core.registered_biomes or {}
|
|
core.registered_ores = core.registered_ores or {}
|
|
|
|
-- Load API definitions in the isolated mapgen Lua environment
|
|
dofile(path .. '/api.lua')
|
|
|
|
-- Load all enabled biome mapgen definitions to populate Everness.on_generated_queue
|
|
if Everness.settings.biomes.everness_bamboo_forest_under.enabled then
|
|
dofile(path .. '/mapgen_bamboo_forest_under.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_bamboo_forest.enabled then
|
|
dofile(path .. '/mapgen_bamboo_forest.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_baobab_savanna.enabled then
|
|
dofile(path .. '/mapgen_baobab_savanna.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_coral_forest_dunes.enabled then
|
|
dofile(path .. '/mapgen_coral_forest_dunes.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_coral_forest_ocean.enabled then
|
|
dofile(path .. '/mapgen_coral_forest_ocean.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_coral_forest_deep_ocean.enabled then
|
|
dofile(path .. '/mapgen_coral_forest_deep_ocean.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_coral_forest_under.enabled then
|
|
dofile(path .. '/mapgen_coral_forest_under.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_coral_forest.enabled then
|
|
dofile(path .. '/mapgen_coral_forest.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_crystal_forest_dunes.enabled then
|
|
dofile(path .. '/mapgen_crystal_forest_dunes.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_crystal_forest_ocean.enabled then
|
|
dofile(path .. '/mapgen_crystal_forest_ocean.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_crystal_forest_deep_ocean.enabled then
|
|
dofile(path .. '/mapgen_crystal_forest_deep_ocean.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_crystal_forest_shore.enabled then
|
|
dofile(path .. '/mapgen_crystal_forest_shore.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_crystal_forest_under.enabled then
|
|
dofile(path .. '/mapgen_crystal_forest_under.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_crystal_forest.enabled then
|
|
dofile(path .. '/mapgen_crystal_forest.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_cursed_lands_dunes.enabled then
|
|
dofile(path .. '/mapgen_cursed_lands_dunes.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_cursed_lands_ocean.enabled then
|
|
dofile(path .. '/mapgen_cursed_lands_ocean.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_cursed_lands_deep_ocean.enabled then
|
|
dofile(path .. '/mapgen_cursed_lands_deep_ocean.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_cursed_lands_swamp.enabled then
|
|
dofile(path .. '/mapgen_cursed_lands_swamp.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_cursed_lands_under.enabled then
|
|
dofile(path .. '/mapgen_cursed_lands_under.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_cursed_lands.enabled then
|
|
dofile(path .. '/mapgen_cursed_lands.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_forsaken_desert_ocean.enabled then
|
|
dofile(path .. '/mapgen_forsaken_desert_ocean.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_forsaken_desert_under.enabled then
|
|
dofile(path .. '/mapgen_forsaken_desert_under.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_forsaken_desert.enabled then
|
|
dofile(path .. '/mapgen_forsaken_desert.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_forsaken_tundra_beach.enabled then
|
|
dofile(path .. '/mapgen_forsaken_tundra_beach.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_forsaken_tundra_ocean.enabled then
|
|
dofile(path .. '/mapgen_forsaken_tundra_ocean.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_forsaken_tundra_under.enabled then
|
|
dofile(path .. '/mapgen_forsaken_tundra_under.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_forsaken_tundra.enabled then
|
|
dofile(path .. '/mapgen_forsaken_tundra.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_frosted_icesheet_ocean.enabled then
|
|
dofile(path .. '/mapgen_frosted_icesheet_ocean.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_frosted_icesheet_under.enabled then
|
|
dofile(path .. '/mapgen_frosted_icesheet_under.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_frosted_icesheet.enabled then
|
|
dofile(path .. '/mapgen_frosted_icesheet.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_mineral_waters.enabled then
|
|
dofile(path .. '/mapgen_mineral_waters.lua')
|
|
end
|
|
if Everness.settings.biomes.everness_mineral_waters_under.enabled then
|
|
dofile(path .. '/mapgen_mineral_waters_under.lua')
|
|
end
|
|
|
|
-- Reusable data buffers for VoxelManip in the async worker thread
|
|
local data = {}
|
|
local p2data = {}
|
|
|
|
-- Persistent content ID and group caches for async mapgen lookups
|
|
local cid_cache = {}
|
|
local group_cids_cache = {}
|
|
|
|
local function safe_get_content_id(name)
|
|
local id = cid_cache[name]
|
|
if id ~= nil then
|
|
if id then
|
|
return id
|
|
end
|
|
return nil
|
|
end
|
|
local ok, res = pcall(core.get_content_id, name)
|
|
if ok and type(res) == 'number' then
|
|
cid_cache[name] = res
|
|
return res
|
|
end
|
|
cid_cache[name] = false
|
|
return nil
|
|
end
|
|
|
|
local function get_group_cids(group_name)
|
|
local list = group_cids_cache[group_name]
|
|
if list then
|
|
return list
|
|
end
|
|
list = {}
|
|
for node_name in pairs(core.registered_nodes) do
|
|
if core.get_item_group(node_name, group_name) > 0 then
|
|
local id = safe_get_content_id(node_name)
|
|
if id and (not core.CONTENT_IGNORE or id ~= core.CONTENT_IGNORE) then
|
|
list[#list + 1] = id
|
|
end
|
|
end
|
|
end
|
|
group_cids_cache[group_name] = list
|
|
return list
|
|
end
|
|
|
|
local function build_cids_map(nodenames)
|
|
local cids_map = {}
|
|
for _, name in ipairs(nodenames) do
|
|
if name:sub(1, 6) == 'group:' then
|
|
local g = name:sub(7)
|
|
local cids = get_group_cids(g)
|
|
for i = 1, #cids do
|
|
cids_map[cids[i]] = name
|
|
end
|
|
else
|
|
local id = safe_get_content_id(name)
|
|
if id then
|
|
cids_map[id] = name
|
|
end
|
|
end
|
|
end
|
|
return cids_map
|
|
end
|
|
|
|
-- Async on_generated callback in Minetest 5.9.0+ / Luanti
|
|
-- Receives `vmanip` as the first argument; engine commits vmanip automatically on return
|
|
core.register_on_generated(function(vmanip, minp, maxp, blockseed)
|
|
local rand = PcgRandom(blockseed)
|
|
local biomemap = core.get_mapgen_object('biomemap') or {}
|
|
local gennotify = core.get_mapgen_object('gennotify') or {}
|
|
local emin, emax = vmanip:get_emerged_area()
|
|
local area = VoxelArea:new({ MinEdge = emin, MaxEdge = emax })
|
|
|
|
-- Fetch raw voxel data upfront for direct, high-performance array indexing
|
|
vmanip:get_data(data)
|
|
vmanip:get_param2_data(p2data)
|
|
|
|
local c_air = core.get_content_id('air')
|
|
local ystride = area.ystride
|
|
|
|
-- Expose VoxelManip-backed helper functions for structure / marker checks during mapgen
|
|
core.get_node = function(pos)
|
|
return vmanip:get_node_at(pos)
|
|
end
|
|
core.set_node = function(pos, node)
|
|
return vmanip:set_node_at(pos, node)
|
|
end
|
|
core.remove_node = function(pos)
|
|
return vmanip:set_node_at(pos, { name = 'air' })
|
|
end
|
|
core.swap_node = function(pos, node)
|
|
return vmanip:set_node_at(pos, node)
|
|
end
|
|
|
|
core.find_nodes_in_area = function(search_minp, search_maxp, nodenames, grouped)
|
|
if type(nodenames) == 'string' then
|
|
nodenames = { nodenames }
|
|
end
|
|
local cids_map = build_cids_map(nodenames)
|
|
|
|
if grouped then
|
|
local res = {}
|
|
local counts = {}
|
|
for _, name in ipairs(nodenames) do
|
|
res[name] = {}
|
|
counts[name] = 0
|
|
end
|
|
for z = search_minp.z, search_maxp.z do
|
|
for y = search_minp.y, search_maxp.y do
|
|
local vi = area:index(search_minp.x, y, z)
|
|
for x = search_minp.x, search_maxp.x do
|
|
local cid = data[vi]
|
|
local match_name = cids_map[cid]
|
|
if match_name then
|
|
local tbl = res[match_name]
|
|
tbl[#tbl + 1] = vector.new(x, y, z)
|
|
counts[match_name] = counts[match_name] + 1
|
|
end
|
|
vi = vi + 1
|
|
end
|
|
end
|
|
end
|
|
return res, counts
|
|
else
|
|
local res = {}
|
|
local counts = {}
|
|
for z = search_minp.z, search_maxp.z do
|
|
for y = search_minp.y, search_maxp.y do
|
|
local vi = area:index(search_minp.x, y, z)
|
|
for x = search_minp.x, search_maxp.x do
|
|
local cid = data[vi]
|
|
local match_name = cids_map[cid]
|
|
if match_name then
|
|
res[#res + 1] = vector.new(x, y, z)
|
|
counts[match_name] = (counts[match_name] or 0) + 1
|
|
end
|
|
vi = vi + 1
|
|
end
|
|
end
|
|
end
|
|
return res, counts
|
|
end
|
|
end
|
|
|
|
core.emerge_area = function(search_minp, search_maxp, callback, extra_data)
|
|
if extra_data and extra_data.callback then
|
|
extra_data.callback(extra_data.data)
|
|
elseif callback then
|
|
callback(nil, 0, 0, extra_data)
|
|
end
|
|
end
|
|
|
|
core.place_schematic = function(pos, schem, rot, repl, force, flags)
|
|
return core.place_schematic_on_vmanip(vmanip, pos, schem, rot, repl, force, flags)
|
|
end
|
|
|
|
core.find_nodes_in_area_under_air = function(search_minp, search_maxp, nodenames)
|
|
if type(nodenames) == 'string' then
|
|
nodenames = { nodenames }
|
|
end
|
|
local cids_map = build_cids_map(nodenames)
|
|
local res = {}
|
|
|
|
for z = search_minp.z, search_maxp.z do
|
|
for y = search_minp.y, search_maxp.y do
|
|
local vi = area:index(search_minp.x, y, z)
|
|
for x = search_minp.x, search_maxp.x do
|
|
local cid = data[vi]
|
|
if cids_map[cid] then
|
|
local vi_above = vi + ystride
|
|
if data[vi_above] == c_air then
|
|
res[#res + 1] = vector.new(x, y, z)
|
|
end
|
|
end
|
|
vi = vi + 1
|
|
end
|
|
end
|
|
end
|
|
return res
|
|
end
|
|
|
|
local chunk_biomes = {}
|
|
for i = 1, #biomemap do
|
|
chunk_biomes[biomemap[i]] = true
|
|
end
|
|
|
|
local active_defs = {}
|
|
for _, def in ipairs(Everness.on_generated_queue) do
|
|
if def.can_run(biomemap, chunk_biomes) then
|
|
table.insert(active_defs, def)
|
|
end
|
|
end
|
|
|
|
if #active_defs == 0 then
|
|
return
|
|
end
|
|
|
|
local shared_args = {}
|
|
|
|
-- 1. on_data: Raw VoxelManip content/param2 manipulation
|
|
for _, def in ipairs(active_defs) do
|
|
if def.on_data then
|
|
shared_args[def.name] = shared_args[def.name] or {}
|
|
def.on_data(minp, maxp, area, data, p2data, gennotify, rand, shared_args[def.name], biomemap)
|
|
end
|
|
end
|
|
|
|
vmanip:set_data(data)
|
|
vmanip:set_param2_data(p2data)
|
|
|
|
-- 2. after_set_data: Schematics placement on VoxelManip
|
|
for _, def in ipairs(active_defs) do
|
|
if def.after_set_data then
|
|
shared_args[def.name] = shared_args[def.name] or {}
|
|
def.after_set_data(minp, maxp, vmanip, area, data, p2data, gennotify, rand, shared_args[def.name])
|
|
end
|
|
end
|
|
|
|
-- 3. Lighting & Liquid calculation
|
|
vmanip:set_lighting({ day = 0, night = 0 })
|
|
vmanip:calc_lighting()
|
|
vmanip:update_liquids()
|
|
-- Note: vmanip:write_to_map() is NOT called here because the engine automatically
|
|
-- writes and commits the async vmanip upon callback completion.
|
|
end)
|