1102 lines
36 KiB
Lua
1102 lines
36 KiB
Lua
local mathAbs, mathRound, mathMin, mathMax, id
|
|
= math.abs, math.round, math.min, math.max, core.get_content_id
|
|
|
|
local getInstance = Class.getInstance
|
|
|
|
local modInfo = Mod.getInfo('smc__core__map_gen')
|
|
local require = modInfo.require
|
|
|
|
---@alias MapGen.PastCalcNoiseValue {triangle:MapGen.Triangle?, x:integer?, z:integer?, noiseValue:number?}
|
|
|
|
---@type table<MapGen.Layer.Category, MapGen.PastCalcNoiseValue>
|
|
local pastNoise2DCalc = {
|
|
landscape = {},
|
|
temp = {},
|
|
humidity = {}
|
|
}
|
|
|
|
---@type MapGen.Layer
|
|
local Layer = require('MapGen.Layer')
|
|
|
|
---@type MapGen.StaticLayer
|
|
local StaticLayer = require('MapGen.StaticLayer')
|
|
|
|
---@type MapGen.Peak
|
|
local Peak = require('MapGen.Peak')
|
|
|
|
---@type MapGen.Biome
|
|
local Biome = require('MapGen.Biome')
|
|
|
|
---@type MapGen.Triangulation
|
|
local Triangulation = require('MapGen.Triangulation')
|
|
|
|
---@type MapGen.Cavern
|
|
local Cavern = require('MapGen.Cavern')
|
|
|
|
---@type MapGen.Region
|
|
local Region = require('MapGen.Region')
|
|
|
|
local ff2luat = require('MapGen.ff2luat')
|
|
|
|
---@class MapGen
|
|
---@field layersByName table<string, MapGen.Layer>
|
|
---@field layersList MapGen.Layer[]
|
|
---@field staticsByName table<string, MapGen.StaticLayer>
|
|
---@field staticsList MapGen.StaticLayer[]
|
|
---@field isLayersNoisesInitialized boolean Is the fractal noise of the layer initialized? This is necessary for a one-time noise initialization.
|
|
---@field isCavernsNoiseInitialized boolean Is the fractal noise of the caverns initialized? This is necessary for a one-time noise initialization.
|
|
---@field isRunning boolean A static field that guarantees that only one instance of the `MapGen` class will work.
|
|
---@field nodeIDs table<string, number>
|
|
local MapGen = {
|
|
layersByName = {},
|
|
layersList = {},
|
|
staticsByName = {},
|
|
staticsList = {},
|
|
isLayersNoisesInitialized = false,
|
|
isCavernsNoiseInitialized = false,
|
|
isRunning = false,
|
|
}
|
|
|
|
---Definition table for the `MapGen`.
|
|
---
|
|
---**Only for EmmyLua.**
|
|
---@class MapGenDef
|
|
---@field nodes table<string, string>
|
|
|
|
---@param def MapGenDef
|
|
---@return MapGen
|
|
function MapGen:new(def)
|
|
local nodesIDs = {}
|
|
-- Converting node names to IDs
|
|
for k, v in pairs(def.nodes) do
|
|
nodesIDs[k] = id(v)
|
|
end
|
|
|
|
---@type MapGen
|
|
local instance = getInstance(self, {
|
|
nodes = def.nodes,
|
|
nodeIDs = nodesIDs,
|
|
})
|
|
|
|
return instance
|
|
end
|
|
|
|
---Returns a layer by name. If such a layer does not exist, an error will be raised.
|
|
---@param layerName string The name of the layer to be retrieved.
|
|
---@return MapGen.Layer
|
|
function MapGen:getLayerByName(layerName)
|
|
local layer = self.layersByName[layerName]
|
|
|
|
assert(layer ~= nil, ('There is no layer named `%s` registered.'):format(layerName))
|
|
|
|
return layer
|
|
end
|
|
|
|
---Determines which layer a node belongs to based on its height coordinate.
|
|
---@param yPos number
|
|
---@return MapGen.Layer?
|
|
function MapGen:getLayerByHeight(yPos)
|
|
--- TODO: возможно здесь получится сделать более оптимизированный алгоритм
|
|
--- учитывая тот факт, что эта функция вызывается для каждой ноды в on_generated
|
|
--- и может быть даже не один раз
|
|
--- Можно подумать над тем, чтобы использовать сортированный список
|
|
|
|
---@param layer MapGen.Layer
|
|
for _, layer in ipairs(self.layersList) do
|
|
|
|
if yPos >= layer.minY and yPos <= layer.maxY then
|
|
return layer
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
---Determines which statics layer a node belongs to based on its height coordinate.
|
|
---@param yPos number
|
|
---@return MapGen.StaticLayer?
|
|
function MapGen:getStaticByHeight(yPos)
|
|
--- TODO: возможно здесь получится сделать более оптимизированный алгоритм
|
|
--- учитывая тот факт, что эта функция вызывается для каждой ноды в on_generated
|
|
--- и может быть даже не один раз
|
|
--- Можно подумать над тем, чтобы использовать сортированный список
|
|
|
|
---@param static MapGen.StaticLayer
|
|
for _, static in ipairs(self.staticsList) do
|
|
|
|
if yPos >= static.minY and yPos <= static.maxY then
|
|
return static
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
---Returns the `MapGen.Peak` at the coordinates. If there is no peak at these coordinates, it returns `nil`.
|
|
---@param layer string|MapGen.Layer The layer or name of the layer in which the peak is located.
|
|
---@param category MapGen.Layer.Category The category in which the peak is located.
|
|
---@param pos MapPosition Coordinate of the desired peak.
|
|
---@return MapGen.Peak?
|
|
function MapGen:getPeakByPos(layer, category, pos)
|
|
if type(layer) == 'string' then
|
|
local layerName = layer
|
|
layer = self:getLayerByName(layerName)
|
|
end
|
|
|
|
return layer:getPeakByPos(category, pos)
|
|
end
|
|
|
|
---Returns `true` if the point is within the triangle's region.
|
|
---The barycentric coordinate method is used.
|
|
---@param px integer
|
|
---@param pz integer
|
|
---@param triangle MapGen.Triangle
|
|
local function pointInTriangle2D(px, pz, triangle)
|
|
local posP = vector.new(px, 0, pz)
|
|
local pos1 = triangle.p1.getPeakPos()
|
|
local pos2 = triangle.p2.getPeakPos()
|
|
local pos3 = triangle.p3.getPeakPos()
|
|
|
|
local v0 = pos3 - pos1
|
|
local v1 = pos2 - pos1
|
|
local v2 = posP - pos1
|
|
|
|
local dot00 = vector.dot(v0, v0)
|
|
local dot01 = vector.dot(v0, v1)
|
|
local dot02 = vector.dot(v0, v2)
|
|
local dot11 = vector.dot(v1, v1)
|
|
local dot12 = vector.dot(v1, v2)
|
|
|
|
local invDenom = 1 / (dot00 * dot11 - dot01 * dot01)
|
|
local u = (dot11 * dot02 - dot01 * dot12) * invDenom
|
|
local v = (dot00 * dot12 - dot01 * dot02) * invDenom
|
|
|
|
return (u >= 0) and (v >= 0) and (u + v <= 1)
|
|
end
|
|
|
|
---Returns the `MapGen.Triangle` at the coordinates. If there is no triangle at these coordinates, it returns `nil`.
|
|
---
|
|
---**Important:** works only in the XZ plane.
|
|
---@param layer string|MapGen.Layer The layer or name of the layer the triangle is in.
|
|
---@param category MapGen.Layer.Category The category in which the triangle is in.
|
|
---@param pos MapPosition Coordinate of the desired peak.
|
|
---@return MapGen.Triangle?
|
|
function MapGen:getTriangleByPos2D(layer, category, pos)
|
|
if type(layer) == 'string' then
|
|
local layerName = layer
|
|
layer = self:getLayerByName(layerName)
|
|
end
|
|
|
|
for _, triangle in ipairs(layer.trianglesList[category]) do
|
|
if pointInTriangle2D(pos.x, pos.z, triangle) then
|
|
return triangle
|
|
end
|
|
end
|
|
end
|
|
|
|
---Checks if a point is inside a region.
|
|
---If the point is inside the region, it will also return the distance to the nearest border.
|
|
---@param layer MapGen.Layer The name of the layer in which the region is located.
|
|
---@param regionName string The name of the region in which the location of the point is checked.
|
|
---@param point MapPosition Point position.
|
|
---@return boolean, number?
|
|
function MapGen:pointInRegion2D(layer, regionName, point)
|
|
local region = layer.regionsByName[regionName]
|
|
|
|
assert(layer ~= nil, ('There is no region named `%s` registered.'):format(regionName))
|
|
|
|
return region:pointInRegion(point)
|
|
end
|
|
|
|
---Returns `true` if there is a cavern at the specified coordinates.
|
|
---@param layer MapGen.Layer
|
|
---@param x integer
|
|
---@param y integer
|
|
---@param z integer
|
|
---@return boolean
|
|
function MapGen:isCavern(layer, x, y, z)
|
|
for _, cavern in ipairs(layer.cavernsList) do
|
|
if cavern.isRegional then
|
|
local inRegion, distance = self:pointInRegion2D(layer, cavern.name, {x=x,y=y,z=z})
|
|
|
|
if inRegion and distance ~= nil then
|
|
if cavern:isCavern(x, y, z, distance) then
|
|
return true
|
|
end
|
|
end
|
|
else
|
|
if cavern:isLayeredCavern(x, y, z) then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
---Creates a unique key for a vertex (using X and Z coordinates).
|
|
---@param peak MapGen.Peak
|
|
---@return string
|
|
local function vertexKey(peak)
|
|
local pos = peak:getPeakPos()
|
|
|
|
return string.format("%.6f,%.6f", pos.x, pos.z)
|
|
end
|
|
|
|
---Creates a canonical (sorted) key for an edge.
|
|
---@param edge MapGen.Triangulation.Edge
|
|
---@return string
|
|
local function edgeKey(edge)
|
|
local k1 = vertexKey(edge.p1)
|
|
local k2 = vertexKey(edge.p2)
|
|
|
|
if k1 < k2 then
|
|
return k1 .. "|" .. k2
|
|
else
|
|
return k2 .. "|" .. k1
|
|
end
|
|
end
|
|
|
|
---Calculates the outer boundary of a triangulated region.
|
|
---Works on the XZ horizontal plane.
|
|
---@param triangles MapGen.Triangle[]
|
|
---@return table
|
|
function MapGen:getTriangulateBoundaryVertices(triangles)
|
|
-- Count how many triangles share each edge
|
|
local edgeCount = {}
|
|
---@type table<string, MapGen.Triangulation.Edge>
|
|
local edgeData = {}
|
|
|
|
for _, triangle in ipairs(triangles) do
|
|
local edges = {
|
|
triangle.e1,
|
|
triangle.e2,
|
|
triangle.e3
|
|
}
|
|
|
|
for _, edge in ipairs(edges) do
|
|
local key = edgeKey(edge)
|
|
|
|
edgeCount[key] = (edgeCount[key] or 0) + 1
|
|
edgeData[key] = edge
|
|
end
|
|
end
|
|
|
|
-- Boundary edges belong to exactly ONE triangle
|
|
---@type MapGen.Triangulation.Edge[]
|
|
local boundaryEdges = {}
|
|
|
|
for key, count in pairs(edgeCount) do
|
|
if count == 1 then
|
|
table.insert(boundaryEdges, edgeData[key])
|
|
end
|
|
end
|
|
|
|
if #boundaryEdges == 0 then
|
|
return {}
|
|
end
|
|
|
|
-- Build adjacency list for boundary vertices
|
|
---@type table<string, MapGen.Peak>
|
|
local adjacency = {}
|
|
---@type table<string, MapGen.Peak>
|
|
local vertexData = {}
|
|
|
|
for _, edge in ipairs(boundaryEdges) do
|
|
local k1 = vertexKey(edge.p1)
|
|
local k2 = vertexKey(edge.p2)
|
|
|
|
vertexData[k1] = edge.p1
|
|
vertexData[k2] = edge.p2
|
|
|
|
adjacency[k1] = adjacency[k1] or {}
|
|
adjacency[k2] = adjacency[k2] or {}
|
|
|
|
table.insert(adjacency[k1], k2)
|
|
table.insert(adjacency[k2], k1)
|
|
end
|
|
|
|
-- Walk along boundary edges to create ordered vertex list
|
|
---@type MapPosition[]
|
|
local boundary = {}
|
|
---@type table<string, boolean>
|
|
local visited = {}
|
|
|
|
if boundaryEdges[1] == nil then
|
|
error()
|
|
end
|
|
|
|
---@type string?
|
|
local currentKey = vertexKey(boundaryEdges[1].p1)
|
|
|
|
while currentKey and not visited[currentKey] do
|
|
visited[currentKey] = true
|
|
local pos = vertexData[currentKey]:getPeakPos()
|
|
|
|
table.insert(boundary, {
|
|
x = pos.x,
|
|
y = 0,
|
|
z = pos.z
|
|
})
|
|
|
|
-- Move to next unvisited neighbor
|
|
local nextKey = nil
|
|
|
|
for _, neighborKey in ipairs(adjacency[currentKey] or {}) do
|
|
if not visited[neighborKey] then
|
|
nextKey = neighborKey
|
|
break
|
|
end
|
|
end
|
|
|
|
currentKey = nextKey
|
|
end
|
|
|
|
return boundary
|
|
end
|
|
|
|
|
|
|
|
-- --- REGISTRATION METHODS ---
|
|
|
|
---Mark the world area between two heights as a `MapGen.Layer`.
|
|
---
|
|
---Note: layers must not overlap.
|
|
---@param name string The name that will be assigned to the layer. The name must be unique for each layer.
|
|
---@param def MapGen.LayerDef Layer description table, see details `MapGen.LayerDef`.
|
|
function MapGen:registerLayer(name, def)
|
|
-- Layers with the same name cannot exist.
|
|
assert(self.layersByName[name] == nil, ('A layer named `%s` is already registered.'):format(name))
|
|
|
|
-- Layers cannot overlap.
|
|
assert(self:getLayerByHeight(def.minY) == nil and self:getLayerByHeight(def.maxY) == nil, 'Registered layers must not overlap!')
|
|
|
|
---@type MapGen.Layer
|
|
local layer = Layer:new(name, def)
|
|
|
|
self.layersByName[name] = layer
|
|
table.insert(self.layersList, layer)
|
|
|
|
-- Sort layers by maxY descending for processing priority.
|
|
table.sort(self.layersList, function(a, b)
|
|
return a.maxY > b.maxY
|
|
end)
|
|
end
|
|
|
|
---Register the color and the noise parameters that correspond to it.
|
|
---@param layerName string The name of the layer for which the color will be registered.
|
|
---@param category MapGen.Layer.Category Category indicating what will be generated by noise.
|
|
---@param color ColorString Noise color. Must be unique.
|
|
---@param noiseParams NoiseParams Fractal noise parameters.
|
|
function MapGen:registerLayerNoiseColor(layerName, category, color, noiseParams)
|
|
local layer = self:getLayerByName(layerName)
|
|
|
|
layer:addNoiseParamsColor(category, color, noiseParams)
|
|
end
|
|
|
|
---Mark the world area between two heights as a `MapGen.StaticLayer`.
|
|
---
|
|
---Note: layers must not overlap.
|
|
---@param name string The name that will be assigned to the static layer. The name must be unique for each layer.
|
|
---@param def MapGen.StaticLayerDef Static layer description table, see details `MapGen.StaticLayerDef`.
|
|
function MapGen:registerStaticLayer(name, def)
|
|
-- Static layer with the same name cannot exist.
|
|
assert(self.staticsByName[name] == nil, ('A static layer named `%s` is already registered.'):format(name))
|
|
|
|
-- Static layers cannot overlap.
|
|
assert(self:getStaticByHeight(def.minY) == nil and self:getLayerByHeight(def.maxY) == nil, 'Registered static layers must not overlap!')
|
|
|
|
---@type MapGen.StaticLayer
|
|
local static = StaticLayer:new(name, def)
|
|
|
|
self.staticsByName[name] = static
|
|
table.insert(self.staticsList, static)
|
|
|
|
-- Sort srtatics by maxY descending for processing priority.
|
|
table.sort(self.staticsList, function(a, b)
|
|
return a.maxY > b.maxY
|
|
end)
|
|
end
|
|
|
|
---Mark a world point as `MapGen.Peak` and assign it a specific color that will affect the generation.
|
|
---
|
|
---Note: The peaks shouldn't overlap.
|
|
---@param layerName string The name of the layer in which the new peak will be included.
|
|
---@param category MapGen.Layer.Category Category indicating what will be generated by peak.
|
|
---@param def MapGen.PeakDef Peak description table, see details `MapGen.PeakDef`.
|
|
function MapGen:registerPeak(layerName, category, def)
|
|
local layer = self:getLayerByName(layerName)
|
|
|
|
--assert(self:getPeakByPos(layer, category, def.pos) == nil,
|
|
--('In the `%s` layer in the `%s` category there is already a peak with coordinates: %s, %s, %s.'):format(
|
|
-- layerName, category, def.pos.x, def.pos.y, def.pos.z))
|
|
|
|
---@type MapGen.Peak
|
|
local peak = Peak:new(def)
|
|
|
|
layer:addPeak(category, peak)
|
|
end
|
|
|
|
---Mark a world point as `MapGen.Peak` and assign it a specific color that will affect the generation.
|
|
---The Y coordinate will be forced to zero, and the `is2d` group will be added to the groups field.
|
|
---
|
|
---Note: The peaks shouldn't overlap.
|
|
---@param layerName string The name of the layer in which the new peak will be included.
|
|
---@param category MapGen.Layer.Category Category indicating what will be generated by peak.
|
|
---@param def MapGen.PeakDef Peak description table, see details `MapGen.PeakDef`.
|
|
function MapGen:register2DPeak(layerName, category, def)
|
|
def = table.copy_with_metatables(def)
|
|
|
|
def.pos.y = 0
|
|
|
|
if def.groups == nil then
|
|
def.groups = {is2d = 1}
|
|
else
|
|
def.groups.is2d = 1
|
|
end
|
|
|
|
self:registerPeak(layerName, category, def)
|
|
end
|
|
|
|
---Mark the world points as `MapGen.Peak` and assign them all a specific noise that will affect generation.
|
|
---The Y coordinate will be forced to zero, and the `is2d` group will be added to the groups field.
|
|
---
|
|
---Note: The peaks shouldn't overlap.
|
|
---@param layerName string The name of the layer in which the new peaks will be included.
|
|
---@param category MapGen.Layer.Category Category indicating what will be generated by peaks.
|
|
---@param defs MapGen.PeakDef[] Peaks description table, see details `MapGen.PeakDef`.
|
|
function MapGen:register2DPeaks(layerName,category, defs)
|
|
for _, def in ipairs(defs) do
|
|
self:register2DPeak(layerName, category, def)
|
|
end
|
|
end
|
|
|
|
---Extract the `MapGen.Peak` from the image and assign them all a specific color that will affect the generation.
|
|
---@param layerName string The name of the layer in which the new peaks will be included.
|
|
---@param map string The name of the image from which the peaks will be extracted. It should be located in the `<mod_name>/textures/maps` folder and have the following format `<image_name>.ff`
|
|
---@param scale number Multiplier of how many blocks (nodes) will be between image pixels. It is not recommended to set the value below 50 for performance reasons.
|
|
---@param zeroPos IntegerPosition2d The position in pixels where the zero world coordinate will be in the image.
|
|
---@param category MapGen.Layer.Category Category indicating what will be generated by peaks.
|
|
---@param groups? table<string, number> Groups that will be added to all peaks.
|
|
function MapGen:register2DPeaksFromFile(layerName, map, scale,zeroPos, category, groups)
|
|
if scale < 2 then
|
|
error('The map scale should not be less than 2.')
|
|
end
|
|
|
|
local modPath = core.get_modpath(core.get_current_modname())
|
|
local peaks = ff2luat(modPath .. '/textures/maps/' .. map)
|
|
|
|
---@type {h:integer, w:integer}
|
|
local mapSize = peaks.size
|
|
peaks.size = nil
|
|
|
|
zeroPos.x = zeroPos.x + mathRound(mapSize.w/2)
|
|
zeroPos.y = zeroPos.y + mathRound(mapSize.h/2)
|
|
|
|
local x, z
|
|
|
|
for color, peaksPos in pairs(peaks) do
|
|
for _, peakPos in ipairs(peaksPos) do
|
|
---@type integer, integer
|
|
x, z = (peakPos.x - zeroPos.x - 1) * scale, (peakPos.y - zeroPos.y - 1) * -scale
|
|
|
|
-- Converting a rectangular grid into an isometric-like one.
|
|
if peakPos.y % 2 == 1 then
|
|
x = mathRound(x + (scale/2))
|
|
end
|
|
|
|
---@type MapGen.PeakDef
|
|
local def = {
|
|
pos = {x=x, y=0, z=z},
|
|
color = color,
|
|
groups = groups,
|
|
}
|
|
|
|
self:register2DPeak(layerName, category, def)
|
|
end
|
|
end
|
|
end
|
|
|
|
---Adds groups to the already registered groups in the peak by coordinate.
|
|
---If the peak does not exist, an error will be raised.
|
|
---@param layerName string The name of the layer in which the new peak will be included.
|
|
---@param category MapGen.Layer.Category Category indicating what will be generated by peak.
|
|
---@param pos MapPosition The position of the peak to which the group should be added.
|
|
---@param groups table<string, number> Groups to be added.
|
|
function MapGen:addGroupsToPeakByPos(layerName, category, pos, groups)
|
|
local layer = self:getLayerByName(layerName)
|
|
|
|
local peak = self:getPeakByPos(layer, category, pos)
|
|
assert( peak ~= nil, ('In the `%s` layer in the `%s` category there is no peak with coordinates: %s, %s, %s.'):format(
|
|
layerName, category, pos.x, pos.y, pos.z))
|
|
|
|
peak:addGroups(groups)
|
|
end
|
|
|
|
---Mark a point on the biomes diagram and constrain the world area by height to mark it as `MapGen.Biome`.
|
|
---@param layerName string The name of the layer in which the new biome will be included.
|
|
---@param biomeName string The name to be assigned to the biome. The name must be unique for each biome.
|
|
---@param def MapGen.BiomeDef Biome description table, see details `MapGen.BiomeDef`
|
|
function MapGen:registerBiome(layerName, biomeName, def)
|
|
local layer = self:getLayerByName(layerName)
|
|
|
|
local biome = Biome:new(biomeName, def)
|
|
|
|
layer:addBiome(biomeName, biome)
|
|
end
|
|
|
|
---Mark the world area between two heights as a `MapGen.Cavern` and assign the noise that the cave will be generated from.
|
|
---@param layerName string The name of the layer in which the new cavern will be included.
|
|
---@param cavernName string The name to be assigned to the cavern. The name must be unique for each cavern.
|
|
---@param def MapGen.CavernDef Cavern description table, see details `MapGen.CavernDef`
|
|
---@param regionVertices MapPosition[]? The region to which the cave generation will be limited.
|
|
function MapGen:registerCavern(layerName, cavernName, def, regionVertices)
|
|
local layer = self:getLayerByName(layerName)
|
|
|
|
if regionVertices ~= nil then
|
|
self:registerRegion(layerName, cavernName, {
|
|
vertices = regionVertices
|
|
})
|
|
|
|
def.isRegional = true
|
|
end
|
|
|
|
local cavern = Cavern:new(cavernName, def)
|
|
|
|
layer:addCavern(cavernName, cavern)
|
|
end
|
|
|
|
---Mark the world region between the vertices as `MapGen.Region` and give it a name.
|
|
---@param layerName string The name of the layer in which the new region will be included.
|
|
---@param regionName string The name to be assigned to the region. The name must be unique for each region.
|
|
---@param def MapGen.RegionDef Region description table, see details `MapGen.RegionDef`
|
|
function MapGen:registerRegion(layerName, regionName, def)
|
|
if regionName == 'landscape_boundary' or
|
|
regionName == 'temp_boundary' or
|
|
regionName == 'humidity_boundary' then
|
|
error(('The name `%s` is reserved for special regions and cannot be used.'):format(regionName))
|
|
end
|
|
|
|
local layer = self:getLayerByName(layerName)
|
|
|
|
local region = Region:new(regionName, def)
|
|
|
|
layer:addRegion(regionName, region)
|
|
end
|
|
|
|
|
|
|
|
-- --- INITIALIZATION METHODS ---
|
|
|
|
---Initialize the boundary region for a triangulated area.
|
|
---@param layer MapGen.Layer
|
|
---@param category MapGen.Layer.Category
|
|
---@param triangles MapGen.Triangle[]
|
|
function MapGen:initTriangultaionBoundaryRegion(layer, category, triangles)
|
|
local regionVertices = self:getTriangulateBoundaryVertices(triangles)
|
|
|
|
local regionName = category..'_boundary'
|
|
|
|
local region = Region:new(regionName, {vertices = regionVertices})
|
|
|
|
layer:addRegion(regionName, region)
|
|
end
|
|
|
|
---Divide all layers into triangles whose vertices are the `Mapgen.Peak` belonging to these layers.
|
|
function MapGen:initLayersTriangultaion()
|
|
---@param layer MapGen.Layer
|
|
for _, layer in ipairs(self.layersList) do
|
|
for category, peaks in pairs(layer.peaksList) do
|
|
local triangles = Triangulation.triangulate(peaks)
|
|
|
|
layer.trianglesList[category] = triangles
|
|
self:initTriangultaionBoundaryRegion(layer, category, triangles)
|
|
-- layer.tetrahedronsList = Triangulation.tetrahedralize(layer.peaksList) -- 3D not supported
|
|
end
|
|
end
|
|
end
|
|
|
|
---Initialize all layer noises. This should be called after the map object is loaded.
|
|
function MapGen:initLayersNoises()
|
|
---@param layer MapGen.Layer
|
|
for _, layer in ipairs(self.layersList) do
|
|
layer:initNoises()
|
|
end
|
|
end
|
|
|
|
---Initialization of the biome diagram using the Voronoi method.
|
|
function MapGen:initBiomesDiagram()
|
|
---@param layer MapGen.Layer
|
|
for _, layer in ipairs(self.layersList) do
|
|
layer:initBiomesDiagram()
|
|
end
|
|
end
|
|
|
|
---Initialize caverns's noises. This should be called after the map object is loaded.
|
|
function MapGen:initCavernsNoise()
|
|
---@param layer MapGen.Layer
|
|
for _, layer in ipairs(self.layersList) do
|
|
|
|
---@param peak MapGen.Peak
|
|
for _, cavern in ipairs(layer.cavernsList) do
|
|
cavern:initNoise()
|
|
end
|
|
|
|
end
|
|
|
|
self.isCavernsNoiseInitialized = true
|
|
end
|
|
|
|
|
|
|
|
-- --- GENERATION METHODS ---
|
|
|
|
---The core logic of world generation. Determines which node type (water, rock, soil, air)
|
|
---and which biome will be generated at the specified coordinates.
|
|
---@param mapGenerator MapGen
|
|
---@param layer MapGen.Layer
|
|
---@param height number
|
|
---@param temp number
|
|
---@param humidity number
|
|
---@param data number[]
|
|
---@param index number
|
|
---@param x integer
|
|
---@param y integer
|
|
---@param z integer
|
|
local function generateNode(mapGenerator, layer, height, temp, humidity, data, index, x, y, z)
|
|
local ids = mapGenerator.nodeIDs
|
|
local waterLevel = layer.waterLevel
|
|
|
|
-- Creating a rougher biome boundary.
|
|
local scatteringGorizontal = layer.biomesGorizontalScattering or 0
|
|
local scatteringVertical = layer.biomesVerticalScattering or 0
|
|
local scattTemp = temp
|
|
local scattHumidity = humidity
|
|
---@type number
|
|
local scattHeight = y
|
|
|
|
if scatteringGorizontal ~= 0 then
|
|
scattTemp = scattTemp + math.random(scatteringGorizontal * -1, scatteringGorizontal)
|
|
scattHumidity = scattHumidity + math.random(scatteringGorizontal * -1, scatteringGorizontal)
|
|
end
|
|
|
|
if scatteringVertical ~= 0 then
|
|
scattHeight = scattHeight + math.random(scatteringVertical * -1, scatteringVertical)
|
|
end
|
|
|
|
scattTemp = math.clamp(scattTemp, layer.minTemp, layer.maxTemp)
|
|
scattHumidity = math.clamp(scattHumidity, layer.minHumidity, layer.maxHumidity)
|
|
scattHeight = math.clamp(scattHeight, layer.minY, layer.maxY)
|
|
|
|
scattHeight, scattTemp, scattHumidity = mathRound(scattHeight), mathRound(scattTemp), mathRound(scattHumidity)
|
|
height, temp, humidity = mathRound(height), mathRound(scattTemp), mathRound(scattHumidity)
|
|
|
|
---@type MapGen.Biome
|
|
local biome = layer.biomesDiagram[scattHeight][scattTemp][scattHumidity]
|
|
|
|
-- If the block is above surface height and above water level...
|
|
if y > height and y > waterLevel then
|
|
-- ... then airspace is generated.
|
|
biome:generateAir(mapGenerator, data, index, x, y, z)
|
|
|
|
-- If the block is above the surface height BUT below the water level...
|
|
elseif y > height and y <= waterLevel then
|
|
-- ... then underwater space is generated.
|
|
biome:generateWater(mapGenerator, data, index, x, y, z)
|
|
|
|
-- If the block is below the surface height...
|
|
elseif y <= height then
|
|
-- ... and a cavern is generated in the block...
|
|
if mapGenerator:isCavern(layer, x, y, z) then
|
|
-- ... then airspace is generated.
|
|
biome:generateCavernAir(mapGenerator, data, index, x, y, z)
|
|
|
|
-- ... or if the surface height is above the water level...
|
|
elseif height > waterLevel then
|
|
--- ... and the height of the block is equal to the height of the surface...
|
|
if y == height then
|
|
-- ... then turf is generated.
|
|
biome:generateTurf(mapGenerator, data, index, x, y, z)
|
|
-- ... or if the height of the block falls within the thickness of the soil layer...
|
|
elseif y > height - biome.soilHeight then
|
|
-- ... then soil is generated.
|
|
biome:generateSoil(mapGenerator, data, index, x, y, z)
|
|
else
|
|
-- ... else e a stone is generated.
|
|
biome:generateRock(mapGenerator, data, index, x, y, z)
|
|
end
|
|
|
|
-- ... or if the surface height is below the water level...
|
|
elseif height <= waterLevel then
|
|
-- ... and if the height of the block falls within the thickness of the soil layer...
|
|
if y > height - biome.soilHeight then
|
|
-- ... then the river/ocean bottom is generated.
|
|
biome:generateBottom(mapGenerator, data, index, x, y, z)
|
|
else
|
|
-- ... else a stone is generated.
|
|
biome:generateRock(mapGenerator, data, index, x, y, z)
|
|
end
|
|
end
|
|
else
|
|
data[index] = ids.air
|
|
|
|
Logger.warningLog('If you see this error, it means that the map generator does'..
|
|
'not handle all cases of generation on coordinates: %s, %s, %s.', x, y, z)
|
|
end
|
|
end
|
|
|
|
---Calculates a weight for a coordinate using the projection onto
|
|
---the triangle's height and specifying the distance to the peak
|
|
---for which the weight is calculated.
|
|
---@param height MapGen.Triangulation.Edge
|
|
---@param x integer
|
|
---@param y integer
|
|
---@param z integer
|
|
---@return number
|
|
local function calcWeight(height, x, y, z)
|
|
local pos1 = vector.new(x, y, z)
|
|
local pos2 = height.p1:getPeakPos()
|
|
local pos3 = height.p2:getPeakPos()
|
|
|
|
local v = pos3 - pos2
|
|
---@type vector
|
|
local w = pos1 - pos2
|
|
|
|
-- Formula: (w * v) / (v * v)
|
|
-- When * the dot product.
|
|
local t = w:dot(v) / v:dot(v)
|
|
|
|
local posP = pos2 + v * t
|
|
|
|
return 1 - vector.distance(pos2, posP) / height:length()
|
|
end
|
|
|
|
---Returns the weighted values of 2d noise.
|
|
---@param category MapGen.Layer.Category
|
|
---@param layer MapGen.Layer
|
|
---@param triangle MapGen.Triangle
|
|
---@param x integer
|
|
---@param y integer
|
|
---@param z integer
|
|
---@return number
|
|
local function calcNoise2dValue(category, layer, triangle, x, y, z)
|
|
local triangleColor = triangle.color
|
|
|
|
-- If the triangle is monochromatic (all peaks have the same color and,
|
|
-- accordingly, the same noise), then there is no point in smoothing out the noise.
|
|
if triangleColor ~= nil then
|
|
return layer:getNoiseByColor(category, triangleColor):get_2d({x = x, y = z})
|
|
end
|
|
|
|
local peak1 = triangle.p1
|
|
local peak2 = triangle.p2
|
|
local peak3 = triangle.p3
|
|
|
|
local noise1 = layer:getNoiseByColor(category, peak1:getColor())
|
|
local noise2 = layer:getNoiseByColor(category, peak2:getColor())
|
|
local noise3 = layer:getNoiseByColor(category, peak3:getColor())
|
|
|
|
local noiseValue = 0.0
|
|
|
|
local totalWeight = 0.0
|
|
|
|
-- We calculate the noise value using the smoothing formula:
|
|
-- ( peak1 * weight1 + peak2 * weight2 + peak3 * weight3) / totalWeight, when
|
|
-- totalWeight = weight1 + weight2 + weight3
|
|
local weight = calcWeight(triangle.h1, x, y, z)
|
|
noiseValue = noiseValue + noise1:get_2d({x = x, y = z}) * weight
|
|
totalWeight = totalWeight + weight
|
|
|
|
weight = calcWeight(triangle.h2, x, y, z)
|
|
noiseValue = noiseValue + noise2:get_2d({x = x, y = z}) * weight
|
|
totalWeight = totalWeight + weight
|
|
|
|
weight = calcWeight(triangle.h3, x, y, z)
|
|
noiseValue = noiseValue + noise3:get_2d({x = x, y = z}) * weight
|
|
totalWeight = totalWeight + weight
|
|
|
|
return (noiseValue / totalWeight)
|
|
end
|
|
|
|
---Calculates a smoothed 2D noise value based on a preliminary space partitioning.
|
|
---
|
|
---Returns `nil` if the point is not included in any triangle.
|
|
---@param category MapGen.Layer.Category
|
|
---@param layer MapGen.Layer
|
|
---@param x integer
|
|
---@param y integer
|
|
---@param z integer
|
|
---@return number?
|
|
function MapGen:getNoises2dValue(category, layer, x, y, z)
|
|
---@type MapGen.PastCalcNoiseValue
|
|
local pastCalc = pastNoise2DCalc[category]
|
|
|
|
if (pastCalc.x ~= nil and pastCalc.z ~= nil) and (x == pastCalc.x and z == pastCalc.z) then
|
|
return pastCalc.noiseValue
|
|
end
|
|
|
|
if pastCalc.triangle ~= nil then
|
|
---@type number?
|
|
local noiseValue
|
|
|
|
local triangles = {
|
|
pastCalc.triangle,
|
|
pastCalc.triangle.neighbours.t1,
|
|
pastCalc.triangle.neighbours.t2,
|
|
pastCalc.triangle.neighbours.t3,
|
|
}
|
|
|
|
---@param t MapGen.Triangle
|
|
for _, t in ipairs(triangles) do
|
|
if pointInTriangle2D(x, z, t) then
|
|
noiseValue = calcNoise2dValue(category, layer, t, x, y, z)
|
|
|
|
pastCalc.x = x
|
|
pastCalc.z = z
|
|
pastCalc.noiseValue = noiseValue
|
|
|
|
return noiseValue
|
|
end
|
|
end
|
|
end
|
|
|
|
if not self:pointInRegion2D(layer, category..'_boundary', {x=x, y=y, z=z}) then
|
|
return nil
|
|
end
|
|
|
|
---@param triangle MapGen.Triangle
|
|
for _, triangle in ipairs(layer.trianglesList[category]) do
|
|
if pointInTriangle2D(x, z, triangle) then
|
|
local noiseValue = calcNoise2dValue(category, layer, triangle, x, y, z)
|
|
|
|
pastCalc.triangle = triangle
|
|
pastCalc.x = x
|
|
pastCalc.z = z
|
|
pastCalc.noiseValue = noiseValue
|
|
|
|
return noiseValue
|
|
end
|
|
end
|
|
|
|
-- If the point does not fall within the triangle, it is impossible to calculate the height.
|
|
-- For debugging purposes only, may slow down generation:
|
|
--core.log('warning', string.format('The point %s %s %s does not fall within any triangle, calculating the noise value is impossible.', tostring(x), tostring(y), tostring(z)))
|
|
end
|
|
|
|
--[[
|
|
3D noise smoothing is too slow, so it was decided to stop using it.
|
|
|
|
---@param P vector
|
|
---@param A vector
|
|
---@param B vector
|
|
---@param C vector
|
|
local function pointInTetrahedron(P, A, B, C, D)
|
|
local function det3(a, b, c)
|
|
return a.x * (b.y * c.z - b.z * c.y)
|
|
- a.y * (b.x * c.z - b.z * c.x)
|
|
+ a.z * (b.x * c.y - b.y * c.x)
|
|
end
|
|
|
|
local v0 = B - A
|
|
local v1 = C - A
|
|
local v2 = D - A
|
|
local v3 = P - A
|
|
|
|
local d = det3(v0, v1, v2)
|
|
|
|
local u = det3(v3, v1, v2) / d
|
|
local v = det3(v0, v3, v2) / d
|
|
local w = det3(v0, v1, v3) / d
|
|
|
|
return (u >= 0 and v >= 0 and w >= 0 and (u + v + w) <= 1)
|
|
end
|
|
|
|
---Calculates a smoothed 3D noise value based on a preliminary space partitioning.
|
|
---
|
|
---Returns `nil` if the point is not included in any tetrahedron.
|
|
---
|
|
---@param layer MapGen.Layer
|
|
---@param x number
|
|
---@param y number
|
|
---@param z number
|
|
---@return number?
|
|
function MapGen:getNoises3dValues(layer, x, y, z)
|
|
---@param triangle MapGen.Tetrahedron
|
|
for _, tetrahedron in ipairs(layer.tetrahedronsList) do
|
|
local peak1 = tetrahedron.p1
|
|
local peak2 = tetrahedron.p2
|
|
local peak3 = tetrahedron.p3
|
|
local peak4 = tetrahedron.p4
|
|
|
|
local pos1 = peak1:getPeakPos()
|
|
local pos2 = peak2:getPeakPos()
|
|
local pos3 = peak3:getPeakPos()
|
|
local pos4 = peak4:getPeakPos()
|
|
|
|
-- If the point is in the tetrahedron defined by the `MapGen.Peak`...
|
|
if pointInTetrahedron(
|
|
vector.new(x, y, z),
|
|
pos1,
|
|
pos2,
|
|
pos3,
|
|
pos4
|
|
)
|
|
then
|
|
local noiseValue = 0.0
|
|
|
|
local totalWeight = 0.0
|
|
|
|
-- ... we calculate the height for this point using smoothing.
|
|
local weight = calcWeight(tetrahedron.h1, x, y, z)
|
|
noiseValue = noiseValue + peak1:getMultinoise().someNoise:get_3d({x = x, y = y, z = z}) * weight
|
|
totalWeight = totalWeight + weight
|
|
|
|
weight = calcWeight(tetrahedron.h2, x, y, z)
|
|
noiseValue = noiseValue + peak1:getMultinoise().someNoise:get_3d({x = x, y = y, z = z}) * weight
|
|
totalWeight = totalWeight + weight
|
|
|
|
weight = calcWeight(tetrahedron.h3, x, y, z)
|
|
noiseValue = noiseValue + peak2:getMultinoise().someNoise:get_3d({x = x, y = y, z = z}) * weight
|
|
totalWeight = totalWeight + weight
|
|
|
|
weight = calcWeight(tetrahedron.h4, x, y, z)
|
|
noiseValue = noiseValue + peak3:getMultinoise().someNoise:get_2d({x = x, y = y, z = z}) * weight
|
|
totalWeight = totalWeight + weight
|
|
|
|
return mathRound(noiseValue / totalWeight)
|
|
end
|
|
end
|
|
|
|
-- If the point does not fall within the tetrahedron, it is impossible to calculate the height.
|
|
-- For debugging purposes only, may slow down generation:
|
|
-- core.log('warning', string.format('The point %s %s %s does not fall within any tetrahedron, calculating the noise value is impossible.', tostring(x), tostring(y), tostring(z)))
|
|
end
|
|
--]]
|
|
|
|
---Generator handler for specific coordinates.
|
|
---@param mapGenerator MapGen
|
|
---@param data number[]
|
|
---@param index number
|
|
---@param x integer
|
|
---@param y integer
|
|
---@param z integer
|
|
local function generatorHandler(mapGenerator, data, index, x, y, z)
|
|
-- If the node belongs to a static layer, then a static node is generated.
|
|
local static = mapGenerator:getStaticByHeight(y)
|
|
if static ~= nil then
|
|
static:generateStaticNode(mapGenerator, data, index, x, y, z)
|
|
|
|
return
|
|
end
|
|
|
|
-- If generation occurs outside the layers, then a void is generated.
|
|
local layer = mapGenerator:getLayerByHeight(y)
|
|
if layer == nil then
|
|
data[index] = mapGenerator.nodeIDs.air
|
|
|
|
return
|
|
end
|
|
|
|
-- If the value of the noise is `nil`,
|
|
-- then the point does not fall within any of the triangles.
|
|
local noiseHeightValue = mapGenerator:getNoises2dValue('landscape', layer, x, y, z)
|
|
if noiseHeightValue == nil then
|
|
data[index] = core.CONTENT_IGNORE
|
|
return
|
|
end
|
|
|
|
local noiseTempValue = mapGenerator:getNoises2dValue('temp', layer, x, y, z)
|
|
if noiseTempValue == nil then
|
|
data[index] = core.CONTENT_IGNORE
|
|
return
|
|
end
|
|
|
|
local noiseHumidityValue = mapGenerator:getNoises2dValue('humidity', layer, x, y, z)
|
|
if noiseHumidityValue == nil then
|
|
data[index] = core.CONTENT_IGNORE
|
|
return
|
|
end
|
|
|
|
-- We recalculate the climate based on altitude.
|
|
noiseTempValue = layer:calcTemp(noiseTempValue, y)
|
|
noiseHumidityValue = layer:calcHumidity(noiseHumidityValue, y)
|
|
|
|
generateNode(mapGenerator, layer, noiseHeightValue, noiseTempValue, noiseHumidityValue, data, index, x, y, z)
|
|
end
|
|
|
|
---Chunk generation handler.
|
|
---@param voxelManip VoxelManip
|
|
---@param minPos MapPosition
|
|
---@param maxPos MapPosition
|
|
---@param blockseed number
|
|
function MapGen:onMapGenerated(voxelManip, minPos, maxPos, blockseed)
|
|
-- We obtain a generation area for further manipulations
|
|
--local voxelManip, eMin, eMax = core.get_mapgen_object('voxelmanip')
|
|
|
|
local eMin, eMax = voxelManip:get_emerged_area()
|
|
|
|
if not self.isLayersNoisesInitialized then
|
|
self:initLayersNoises()
|
|
end
|
|
|
|
if not self.isCavernsNoiseInitialized then
|
|
self:initCavernsNoise()
|
|
end
|
|
|
|
local data = voxelManip:get_data()
|
|
-- local param2_data = voxelManip:get_param2_data()
|
|
local area = VoxelArea:new({MinEdge = eMin, MaxEdge = eMax})
|
|
|
|
local index
|
|
-- Initial generation: landscape
|
|
for z = minPos.z, maxPos.z do
|
|
for x = minPos.x, maxPos.x do
|
|
for y = minPos.y, maxPos.y do
|
|
index = area:index(x, y, z)
|
|
|
|
if data[index] == core.CONTENT_AIR then
|
|
generatorHandler(self, data, index, x, y, z)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- We make changes back to LVM and recalculate light & liquids
|
|
voxelManip:set_data(data)
|
|
|
|
core.generate_ores(voxelManip, minPos, maxPos)
|
|
core.generate_decorations(voxelManip, minPos, maxPos)
|
|
|
|
--voxelManip:set_param2_data()
|
|
voxelManip:set_lighting({ day = 14, night = 0})
|
|
voxelManip:calc_lighting()
|
|
voxelManip:update_liquids()
|
|
|
|
--voxelManip:write_to_map() -- Async edit
|
|
end
|
|
|
|
|
|
|
|
-- --- OTHER ---
|
|
|
|
---Run world generation through this mapgen object
|
|
---
|
|
---Note: only one instance of a `MapGen` class can be running.
|
|
---
|
|
---**FOR MAPGEN ENVIRONMENT ONLY**
|
|
function MapGen:run()
|
|
if MapGen.isRunning then
|
|
error('Only one instance of a `MapGen` class can be running.')
|
|
end
|
|
|
|
---@param ... VoxelManip
|
|
core.register_on_generated(function(...)
|
|
self:onMapGenerated(...)
|
|
end)
|
|
|
|
self:initBiomesDiagram()
|
|
self:initLayersTriangultaion()
|
|
|
|
MapGen.isRunning = true
|
|
end
|
|
|
|
return MapGen
|