This commit is contained in:
Andrew Miner
2026-10-25 09:33:48 -07:00
parent 6d40813523
commit bfd7f78a69
42 changed files with 855 additions and 228 deletions
+14
View File
@@ -0,0 +1,14 @@
-- Imports -----------------------------------------------------------------------------------------
local api = _G["jvmi_biomes"]
-- Functions ---------------------------------------------------------------------------------------
--[[
Apply biomes to the base terrain provided.
Args:
region:jvmi_mapgen:Region - the region currently being generated
]]--
function api.apply_biomes(region) end
+82
View File
@@ -0,0 +1,82 @@
-- Imports -----------------------------------------------------------------------------------------
-- Since we're in the mapgen environment, we can't count on the mod loading process. Instead, we
-- have to load everything we need from other mods manually.
local core = _G["core"]
local api = _G["jvmi_biomes"]
local path = core.get_modpath("jvmi_constants")
dofile(path.."/constants.lua")
local C = _G["jvmi_constants"]
path = core.get_modpath("jvmi_mapgen")
dofile(path.."/init.lua")
local mapgen = _G["jvmi_mapgen"]
local Region = mapgen.Region
-- Private -----------------------------------------------------------------------------------------
local private = {}
--[[
Assigns a specific biome to each position in the region.
Args:
region:Region - the region currently being generated
]]--
function private.assign_biomes(region)
region.iterate_columns(function(x, z)
local terrain_type = region:get_meta(Region.META.TERRAIN_TYPE, x, z)
local terrain = C.TERRAIN_TYPES[terrain_type]
region:set_meta(Region.META.BIOME, x, z, core.get_biome_id(terrain.name))
end)
end
--[[
Replace the upper layers of stone with biome-specific top and filler nodes.
Args:
region:Region - the region currently being generated
]]--
function private.fill_surface(region)
region.iterate_columns(function(x, z)
local biome_id = region:get_meta(Region.META.BIOME, x, z)
local biome_name = core.get_biome_name(biome_id)
local biome = core.registered_biomes[biome_name]
local y = region:get_meta(Region.META.ALTITUDE)
local top_count = biome.depth_top or 0
local filler_count = biome.depth_filler or 0
while y >= region.fill_min.y do
if top_count > 0 then
local content_id = core.get_content_id(biome.node_top)
if content_id then
region:set_content_id(x, y, z, content_id)
end
top_count = top_count - 1
elseif filler_count > 0 then
local content_id = core.get_content_id(biome.node_filler)
if content_id then
region:set_content_id(x, y, z, content_id)
end
filler_count = filler_count - 1
else
break
end
y = y - 1
end
end)
end
-- API Implementations -----------------------------------------------------------------------------
function api.apply_biomes(region)
private.assign_biomes(region)
private.fill_surface(region)
end
+52
View File
@@ -0,0 +1,52 @@
-- Imports -----------------------------------------------------------------------------------------
local core = _G["core"]
-- Registrations -----------------------------------------------------------------------------------
core.register_biome({
name = "ocean_floor",
node_top = "jvmi_nodes:clay", depth_top = 4,
})
core.register_biome({
name = "ocean_abyss",
node_top = "jvmi_nodes:clay", depth_top = 2,
node_filler = "jvmi_nodes:gravel", depth_filler = 2,
})
core.register_biome({
name = "ocean_shelf",
node_top = "jvmi_nodes:sand", depth_top = 2,
node_filler = "jvmi_nodes:gravel", depth_filler = 2,
})
core.register_biome({
name = "ocean_surface",
node_top = "jvmi_nodes:sand", depth_top = 2,
node_filler = "jvmi_nodes:gravel", depth_filler = 2,
})
core.register_biome({
name = "land_plains",
node_top = "jvmi_nodes:turf", depth_top = 1,
node_filler = "jvmi_nodes:dirt", depth_filler = 3,
})
core.register_biome({
name = "land_hills",
node_top = "jvmi_nodes:turf", depth_top = 1,
node_filler = "jvmi_nodes:dirt", depth_filler = 2,
})
core.register_biome({
name = "land_moors",
node_top = "jvmi_nodes:turf", depth_top = 1,
node_filler = "jvmi_nodes:dirt", depth_filler = 1,
})
core.register_biome({
name = "land_mountains",
node_top = "jvmi_nodes:gravel", depth_top = 1,
})
+23
View File
@@ -0,0 +1,23 @@
-- Imports -----------------------------------------------------------------------------------------
local core = _G["core"]
-- Public ------------------------------------------------------------------------------------------
jvmi_biomes = {} -- luacheck: globals jvmi_biomes
local path = core.get_modpath("jvmi_biomes")
dofile(path.."/api.lua")
dofile(path.."/apply.lua")
-- Registrations -----------------------------------------------------------------------------------
core.clear_registered_biomes()
dofile(path.."/definitions.lua")
-- Script ------------------------------------------------------------------------------------------
core.log("info", "jvmi_biomes loaded")
+4
View File
@@ -0,0 +1,4 @@
name = jvmi_biomes
title = Jules Verne's Mysterious Island / Biomes
description = define biomes and decoration/generation functions for them
author = tungstonminer
+112
View File
@@ -0,0 +1,112 @@
-- Import ------------------------------------------------------------------------------------------
local C = _G["jvmi_constants"]
local core = _G["core"]
-- Node Definition Constants -----------------------------------------------------------------------
C.ANIMATION_TYPE = {
VERTICAL_FRAMES = "vertical_frames",
SHEET_2D = "sheet_2d",
}
C.DRAW_TYPE = {
ALL_FACES_OPTIONAL = "allfaces_optional",
FLOWING_LIQUID = "flowingliquid",
LIQUID = "liquid",
MESH = "mesh",
NODE_BOX = "nodebox",
NORMAL = "normal",
PLANT_LIKE = "plantlike",
}
C.LIQUID_TYPE = {
NONE = "none",
SOURCE = "source",
FLOWING = "flowing",
}
C.TEXTURE_ALPHA = {
OPAQUE = "opaque",
CLIP = "clip",
BLEND = "blend",
}
C.VISCOSITY = {
XXX_FAST = 0,
XX_FAST = 1,
X_FAST = 2,
FAST = 3,
SLOW = 4,
X_SLOW = 5,
XX_SLOW = 6,
XXX_SLOW = 7,
}
C.WAVING = {
NO = 0,
PLANT_LIKE = 1,
LEAF_LIKE = 2,
LIQUID_LIKE = 3,
}
-- Mapgen Constants --------------------------------------------------------------------------------
--[[ Key altitudes which define the vertical regions of the generated map. ]]--
C.ALTITUDE = {
SKY = 256,
MOUNTAIN = 128,
MOOR = 64,
HILL = 32,
PLAIN = 16,
SURFACE = 0,
SHALLOW = -16,
DEEP = -32,
ABYSS = -64,
BEDROCK = -128,
}
local A = C.ALTITUDE
--[[ The amount of overlap (as a perentage of total weight) between adjacent terrain types. ]]--
C.TERRAIN_BLEND = 0.15
--[[ The distance from the center of the map at which only the lowest terrain types are used. ]]--
C.TERRAIN_RADIUS = 3096
--[[ The noise generator that decides which terrain type is active at a given x,z location. ]]--
C.TERRAIN_TYPE_NOISE = core.get_value_noise({
flags = "eased",
lacunarity = 2,
octaves = 1,
offset = 0,
persistence = 0.5,
scale = 1.0,
seed = 8381909047,
spread = { x = 512, y = 512, z = 0 },
})
--[[
A table defining the terrain types used in generating the base terrain.
These must be listed in average altitude order from lowest to highest. The weights are merely
relative values, and can be whatever you like. I find it easiest to think of them as
percentages and choose value which tally to 100.
Bear in mind that noise values are adjusted downward are you approach `TERRAIN_RADIUS` meters
from the center of the map, so these weights are only going to be fully reflected in the terrain
generated at the center of the map, and will progressively favor lower altitudes as you move
toward the edges.
]]--
C.TERRAIN_TYPES = {
{ name = "ocean_floor", lowest = A.BEDROCK + 10, highest = A.BEDROCK + 26, weight = 5 },
{ name = "ocean_abyss", lowest = A.ABYSS, highest = A.DEEP, weight = 15 },
{ name = "ocean_shelf", lowest = A.DEEP, highest = A.SHALLOW, weight = 10 },
{ name = "ocean_surface", lowest = A.SURFACE - 4, highest = A.SURFACE, weight = 5 },
{ name = "land_plains", lowest = A.PLAIN - 8, highest = A.PLAIN, weight = 20 },
{ name = "land_hills", lowest = A.HILL - 32, highest = A.HILL, weight = 25 },
{ name = "land_moors", lowest = A.MOOR - 16, highest = A.MOOR, weight = 15 },
{ name = "land_mountains", lowest = A.MOUNTAIN - 80, highest = A.MOUNTAIN, weight = 5 },
}
-55
View File
@@ -1,55 +0,0 @@
-- Constants ---------------------------------------------------------------------------------------
jvmi_constants = { -- luacheck: globals jvmi_constants
ALTITUDE = {
SKY = 256,
MOUNTAIN = 128,
MOOR = 64,
HILL = 32,
PLAIN = 16,
SURFACE = 0,
SHALLOW = -16,
DEEP = -32,
ABYSS = -64,
BEDROCK = -128,
},
ANIMATION_TYPE = {
VERTICAL_FRAMES = "vertical_frames",
SHEET_2D = "sheet_2d",
},
DRAW_TYPE = {
ALL_FACES_OPTIONAL = "allfaces_optional",
FLOWING_LIQUID = "flowingliquid",
LIQUID = "liquid",
MESH = "mesh",
NODE_BOX = "nodebox",
NORMAL = "normal",
PLANT_LIKE = "plantlike",
},
LIQUID_TYPE = {
NONE = "none",
SOURCE = "source",
FLOWING = "flowing",
},
TEXTURE_ALPHA = {
OPAQUE = "opaque",
CLIP = "clip",
BLEND = "blend",
},
VISCOSITY = {
XXX_FAST = 0,
XX_FAST = 1,
X_FAST = 2,
FAST = 3,
SLOW = 4,
X_SLOW = 5,
XX_SLOW = 6,
XXX_SLOW = 7,
},
WAVING = {
NO = 0,
PLANT_LIKE = 1,
LEAF_LIKE = 2,
LIQUID_LIKE = 3,
},
}
+4 -3
View File
@@ -2,10 +2,11 @@
local core = _G["core"] local core = _G["core"]
local path = core.get_modpath("jvmi_constants")
dofile(path.."/constants.lua")
-- Script ------------------------------------------------------------------------------------------ -- Script ------------------------------------------------------------------------------------------
jvmi_constants = {} -- luacheck: globals jvmi_constants
local path = core.get_modpath("jvmi_constants")
dofile(path.."/api.lua")
core.log("info", "jvmi_constants loaded") core.log("info", "jvmi_constants loaded")
-13
View File
@@ -3,19 +3,6 @@
local core = _G["core"] local core = _G["core"]
-- Private Functions -------------------------------------------------------------------------------
local private = {}
function private.register_mapgen_aliases()
core.register_alias("mapgen_stone", "jvmi_nodes:stone")
core.register_alias("mapgen_water_source", "jvmi_nodes:water_source")
core.register_alias("mapgen_river_water_source", "jvmi_nodes:water_source")
end
-- Script ------------------------------------------------------------------------------------------ -- Script ------------------------------------------------------------------------------------------
private.register_mapgen_aliases()
core.log("info", "jvmi_first loaded") core.log("info", "jvmi_first loaded")
+1 -2
View File
@@ -2,11 +2,10 @@
local core = _G["core"] local core = _G["core"]
local path = core.get_modpath("jvmi_mapgen")
-- Registrations ----------------------------------------------------------------------------------- -- Registrations -----------------------------------------------------------------------------------
local path = core.get_modpath("jvmi_mapgen")
core.register_mapgen_script(path.."/mapenv.lua") core.register_mapgen_script(path.."/mapenv.lua")
+132 -152
View File
@@ -1,193 +1,169 @@
-- Imports & Exports ------------------------------------------------------------------------------- -- Imports & Exports -------------------------------------------------------------------------------
local biomes = _G["jvmi_biomes"]
local core = _G["core"] local core = _G["core"]
local math = _G["math"] local math = _G["math"]
local VoxelArea = _G["VoxelArea"] local mapgen = _G["mapgen"]
local table = _G["jvmi_table"]
local vector = _G["vector"]
-- Since this script runs inside the mapgen environment, the constants won't be in the global table, -- Since this script runs inside the mapgen environment, we can't count on the jvmi_constants mod
-- yet, so we need to run the file manually. -- to have been loaded. Instead, we just need to load the constants manually.
local jvmi_constants_path = core.get_modpath("jvmi_constants") local jvmi_constants_path = core.get_modpath("jvmi_constants")
dofile(jvmi_constants_path.."/constants.lua") dofile(jvmi_constants_path.."/constants.lua")
local C = _G["jvmi_constants"] local C = _G["jvmi_constants"]
local A = C.ALTITUDE local A = C.ALTITUDE
local Region = mapgen.Region
-- Constants --------------------------------------------------------------------------------------- -- Constants ---------------------------------------------------------------------------------------
--[[ The amount of overlap (as a perentage of total weight) between adjacent terrain types. ]]-- local AIR_ID = core.CONTENT_AIR
local TERRAIN_BLEND = 0.15 local BEDROCK_ID = core.get_content_id("jvmi_nodes:bedrock")
local STONE_ID = core.get_content_id("jvmi_nodes:stone")
local WATER_ID = core.get_content_id("jvmi_nodes:water_source")
--[[ The distance from the center of the map at which only the lowest terrain types are used. ]]-- --[[ Create a deep clone of the shared terrain types as we need to augment the entries. ]]--
local TERRAIN_RADIUS = 3096 local TERRAIN_TYPES = nil
--[[ The noise generator that decides which terrain type is active at a given x,z location. ]]--
local TERRAIN_TYPE_NOISE = core.get_value_noise({
flags = "eased",
lacunarity = 2,
octaves = 1,
offset = 0,
persistence = 0.5,
scale = 1.0,
seed = 8381909047,
spread = { x = 512, y = 512, z = 0 },
})
--[[
A table defining the terrain types used in generating the base terrain.
These must be listed in average altitude order from lowest to highest. The weights are merely
relative values, and can be whatever you like. I find it easiest to think of them as
percentages and choose value which tally to 100.
Bear in mind that noise values are adjusted downward are you approach `TERRAIN_RADIUS` meters
from the center of the map, so these weights are only going to be fully reflected in the terrain
generated at the center of the map, and will progressively favor lower altitudes as you move
toward the edges.
]]--
local TERRAIN_TYPES = {
{ name = "ocean_floor", lowest = A.BEDROCK + 10, highest = A.BEDROCK + 26, weight = 5 },
{ name = "ocean_abyss", lowest = A.ABYSS, highest = A.DEEP, weight = 15 },
{ name = "ocean_shelf", lowest = A.DEEP, highest = A.SHALLOW, weight = 10 },
{ name = "ocean_surface", lowest = A.SURFACE - 4, highest = A.SURFACE, weight = 5 },
{ name = "land_plains", lowest = A.PLAIN - 8, highest = A.PLAIN, weight = 20 },
{ name = "land_hills", lowest = A.HILL - 32, highest = A.HILL, weight = 25 },
{ name = "land_moors", lowest = A.MOOR - 16, highest = A.MOOR, weight = 15 },
{ name = "land_mountains", lowest = A.MOUNTAIN - 80, highest = A.MOUNTAIN, weight = 5 },
}
-- Private ----------------------------------------------------------------------------------------- -- Private -----------------------------------------------------------------------------------------
local private = { local private = {
--[[ A share object which assists in generating regions of the map. ]]--
--[[ A shared buffer used to hold raw voxel data during terrain generation. ]]-- region = Region:new()
data = {}
} }
--[[ --[[
Compute the altitude of a certain world location from underlying noise generators. Fill the `Region.META.ALTITUDE` meta data for the given region.
This function uses a set of individual terrain types defined by `TERRAIN_TYPES`. An overall
terrain noise generator (see: `TERRAIN_TYPE_NOISE`) is used to determine which terrain type
should appear at a given location. Each terrain type has its own noise generator, which is
then used to determine the altitude at the given location.
To avoid abrupt lines where we shift from one terrain type to another, the `TERRAIN_BLEND`
factor indicates the percentage overlap between adjacent zones where values from both noise
generators are smoothly blended into a single value.
Finally, we want the map to make up an island with a smooth transition from higher-altitude
terrain in the center to deep ocean terrain at the edges. So, we modify the values from
`TERRAIN_TYPE_NOISE` to force them lower and lower as you move toward `TERRAIN_RADIUS`. By the
time you reach that distance from the center of the islands, the terrain selection will be
pinned to the lowest possible terrain type.
Args: Args:
- pos:vector - the position whose altitude is wanted region:Region - a region of the world being generated. The results of the caluations are
written back to the same map.
Returns:
- an int indicating the highest ground-level block in the x,z coordinate given
]]-- ]]--
function private.compute_altitude_at(pos) function private.assign_altitudes(region)
local radius = TERRAIN_RADIUS local pos = vector:new()
local radius_factor = ((pos.x * pos.x) + (pos.y * pos.y)) / (radius * radius)
radius_factor = math.max(0, math.min(1, 1.0 - radius_factor))
local raw_index = (TERRAIN_TYPE_NOISE:get_2d(pos) + 2) / 2 region.iterate_columns(function(x, z)
raw_index = math.max(0, math.min(1, raw_index)) local altitude = 0
raw_index = raw_index * radius_factor pos.x, pos.y = x, z
local band_start = raw_index - TERRAIN_BLEND / 2 for _, blend in ipairs(region:get_meta(Region.META.TERRAIN_BLEND)) do
local band_end = raw_index + TERRAIN_BLEND / 2 local terrain = TERRAIN_TYPES[blend.terrain_type]
local contribution = blend.weight * terrain.noise:get_2d(pos)
local result = 0 altitude = altitude + contribution
for _, terrain in ipairs(TERRAIN_TYPES) do
local overlap_start = math.max(band_start, terrain.range_start)
local overlap_end = math.min(band_end, terrain.range_end)
local overlap = overlap_end - overlap_start
if overlap > 0 then
local factor = overlap / TERRAIN_BLEND
result = result + factor * terrain.noise:get_2d(pos)
end end
end end)
end
return math.floor(result) --[[
]]--
function private.assign_biomes(region)
end
--[[
Compute the combination of terrain types which contribute to each map location.
This function uses a set of individual terrain types defined by `C.TERRAIN_TYPES`. An overall
terrain noise generator, `C.TERRAIN_TYPE_NOISE`, is used to determine which terrain type should
appear at a given location.
To avoid abrupt lines where we shift from one terrain type to another, the `C.TERRAIN_BLEND`
factor indicates the percentage overlap between adjacent zones where both types are smoothly
blended together.
Finally, we want the map to make up an island with a smooth transition from higher-altitude
terrain in the center to deep ocean terrain at the edges. So, we modify the values from
`C.TERRAIN_TYPE_NOISE` to force them lower and lower as you move toward `C.TERRAIN_RADIUS`. By
the time you reach that distance from the center of the islands, the terrain selection will be
pinned to the lowest possible terrain type.
The results of these calculations are stored in the `TERRAIN_BLEND` and `TERRAIN_TYPE` meta
data for the given region.
Args:
region:Region - the region of the world being generated. The results of the caluations are
written back to the same object.
]]--
function private.assign_terrain_meta(region)
local radius_squared = C.TERRAIN_RADIUS * C.TERRAIN_RADIUS
local pos = { x = 0, y = 0, z = 0 }
region.iterate_columns(function(x, z)
local radius_weight = ((x * x) + (z * z)) / radius_squared
radius_weight = math.max(0, math.min(1, 1.0 - radius_weight))
pos.x, pos.y = x, z
local raw_index = (C.TERRAIN_TYPE_NOISE:get_2d(pos) + 2) / 2
raw_index = math.max(0, math.min(1, raw_index))
raw_index = raw_index * radius_weight
local band_start = raw_index - C.TERRAIN_BLEND / 2
local band_end = raw_index + C.TERRAIN_BLEND / 2
local max_weight = 0
for terrain_type, terrain in ipairs(TERRAIN_TYPES) do
local overlap_start = math.max(band_start, terrain.range_start)
local overlap_end = math.min(band_end, terrain.range_end)
local overlap = overlap_end - overlap_start
local blend = {}
if overlap > 0 then
local weight = overlap / C.TERRAIN_BLEND
table.append(blend, { weight = weight, terrain_type = terrain_type })
if weight >= max_weight then
max_weight = weight
region:set_meta(Region.META.TERRAIN_TYPE, x, z, terrain_type)
end
end
region:set_meta(Region.META_TERRAIN_BLEND, x, z, blend)
end
end)
end end
--[[ --[[
Fill the lowest layer of the world with bedrock covered by stone. Fill the lowest layer of the world with bedrock covered by stone.
Args: Args:
- area:VoxelArea - an area calibrated to the area to fill region:Region - the portion of the world currently being generated
- fill_min:vector - the minimal corner of the area to fill
- fill_max:vector - the maximal corner of the area to fill
]]-- ]]--
function private.fill_bedrock(area, fill_min, fill_max) function private.fill_bedrock(region)
if fill_min.y > A.BEDROCK then return end region.iterate_plane(A.BEDROCK, function(x, y, z)
region:set_content_id(x, y, z, BEDROCK_ID)
local bedrock_id = core.get_content_id("jvmi_nodes:bedrock") region:set_content_id(x, y + 1, z, STONE_ID)
local stone_id = core.get_content_id("mapgen_stone") end)
for x = fill_min.x, fill_max.x do
for z = fill_min.z, fill_max.z do
private.data[area:index(x, A.BEDROCK, z)] = bedrock_id
private.data[area:index(x, A.BEDROCK + 1, z)] = stone_id
end
end
end end
--[[ --[[
Fill in the oceans by replacing air blocks below sea level with water. Fill in the oceans by replacing air blocks below sea level with water.
Args: Args:
- area:VoxelArea - an area calibrated to the area to fill region:Region - the portion of the world currently being generated
- fill_min:vector - the minimal corner of the area to fill
- fill_max:vector - the maximal corner of the area to fill
]]-- ]]--
function private.fill_ocean(area, fill_min, fill_max) function private.fill_ocean(region)
if fill_min.y > A.SURFACE then return end region.iterate_below(A.SURFACE, function(x, y, z)
if region:get_content_id(x, y, z) == AIR_ID then
local water_id = core.get_content_id("mapgen_water_source") region:set_content_id(x, y, z, WATER_ID)
local y_max = math.min(fill_max.y, A.SURFACE)
local y_min = math.max(fill_min.y, A.BEDROCK)
for x = fill_min.x, fill_max.x do
for y = y_min, y_max do
for z = fill_min.z, fill_max.z do
local index = area:index(x, y, z)
if private.data[index] == core.CONTENT_AIR then
private.data[index] = water_id
end
end
end end
end end)
end end
--[[ --[[
Fill in base stone terrain using altitude noise. Fill in base stone terrain using the pre-computed altitudes.
Args: Args:
- area:VoxelArea - an area calibrated to the area to fill region:Region - the portion of the world currently being generated
- fill_min:vector - the minimal corner of the area to fill
- fill_max:vector - the maximal corner of the area to fill
]]-- ]]--
function private.fill_terrain(area, fill_min, fill_max) function private.fill_terrain(region)
local pos = { x = 0, y = 0, z = 0 } region:iterate_fill(function(x, y, z)
local stone_id = core.get_content_id("mapgen_stone") local altitude = region:get_meta(Region.META.ALTITUDE)
local y_max = math.min(fill_max.y, A.SKY) if y > altitude then return end
local y_min = math.max(fill_min.y, A.BEDROCK) region:set_content_id(x, y, z, STONE_ID)
end)
for x = fill_min.x, fill_max.x do
for z = fill_min.z, fill_max.z do
pos.x, pos.y = x, z
local y_terrain = private.compute_altitude_at(pos)
for y = y_min, math.min(y_max, y_terrain) do
private.data[area:index(x, y, z)] = stone_id
end
end
end
end end
--[[ --[[
@@ -214,7 +190,7 @@ function private.make_noise_in_range(lowest, highest)
end end
--[[ --[[
Add computed values to the `TERRAIN_TYPES` table. Clone the `C.TERRAIN_TYPES` table and add pre-computed values to it.
The table is declared with the fewest values which uniquely define a terrain type, however the The table is declared with the fewest values which uniquely define a terrain type, however the
terrain calculation requires a few extra fields to aid in its work. This function adds the terrain calculation requires a few extra fields to aid in its work. This function adds the
@@ -223,6 +199,8 @@ end
This function *must* be called prior to the start of map generation. This function *must* be called prior to the start of map generation.
]]-- ]]--
function private.prepare_terrain_table() function private.prepare_terrain_table()
TERRAIN_TYPES = table.clone(C.TERRAIN_TYPES)
local total_weight = 0 local total_weight = 0
for _, terrain in ipairs(TERRAIN_TYPES) do for _, terrain in ipairs(TERRAIN_TYPES) do
total_weight = total_weight + terrain.weight total_weight = total_weight + terrain.weight
@@ -235,10 +213,10 @@ function private.prepare_terrain_table()
terrain.range_end = start + (terrain.weight / total_weight) terrain.range_end = start + (terrain.weight / total_weight)
if index == 1 then if index == 1 then
terrain.range_start = -1 * TERRAIN_BLEND / 2 terrain.range_start = -1 * C.TERRAIN_BLEND / 2
end end
if index == #TERRAIN_TYPES then if index == #TERRAIN_TYPES then
terrain.range_end = terrain.range_end + TERRAIN_BLEND / 2 terrain.range_end = terrain.range_end + C.TERRAIN_BLEND / 2
end end
start = terrain.range_end start = terrain.range_end
end end
@@ -248,17 +226,19 @@ end
-- Registrations ----------------------------------------------------------------------------------- -- Registrations -----------------------------------------------------------------------------------
core.register_on_generated(function(voxels, fill_min, fill_max) core.register_on_generated(function(voxels, fill_min, fill_max)
local emerged_min, emerged_max = voxels:get_emerged_area() local region = private.region
local area = VoxelArea(emerged_min, emerged_max) region:read(voxels, fill_min, fill_max)
voxels:get_data(private.data) private.assign_terrain_meta(region)
private.fill_terrain(area, fill_min, fill_max) private.assign_altitudes(region)
private.fill_bedrock(area, fill_min, fill_max)
private.fill_ocean(area, fill_min, fill_max)
voxels:set_data(private.data)
voxels:calc_lighting() private.fill_terrain(region)
voxels:update_liquids() private.fill_bedrock(region)
private.fill_ocean(region)
biomes.apply_biomes(region)
region:save()
end) end)
+272
View File
@@ -0,0 +1,272 @@
-- Import ------------------------------------------------------------------------------------------
local jvmi_mapgen = _G["jvmi_mapgen"]
local math = _G["math"]
local VoxelArea = _G["VoxelArea"]
-- Region Class ------------------------------------------------------------------------------------
local Region = {
--[[ Defines the names of the known metadata tables. ]]--
META = {
--[[ The highest solid block in a certain x,z location. ]]--
ALTITUDE = "altitude",
--[[ The id of the biome at each x,z location. ]]--
BIOME = "biome",
--[[ A list of {weight:int, terrain_type:int} tuples for each x,z location. ]]--
TERRAIN_BLEND = "terrain_blend",
--[[ The heaviest weighted terrain type from the `TERRAIN_BLEND` list. ]]--
TERRAIN_TYPE = "terrain_type",
}
}
jvmi_mapgen.Region = Region
--[[
Create a new Region object to manage the generation of a part of the map.
Returns:
an empty Region ready to be filled
]]--
function Region:new()
local result = {
_emerged_area = nil,
_emerged_data = {},
_fill_min = nil,
_fill_max = nil,
_meta = {},
_voxels = nil,
}
setmetatable(result, Region)
return result
end
--[[
Return the content_id of the node at the indicated coordinate.
Args:
x:int - the x-axis position
y:int - the y-axis position
z:int - the z-axis position
Returns:
an int giving the content_id of the node at that location
]]--
function Region:get_content_id(x, y, z)
return self._emerged_data[self._emerged_area:index(x, y, z)]
end
--[[
Alter the content_id of the node at the indicated coordinate.
Args:
x:int - the x-axis position
y:int - the y-axis position
z:int - the z-axis position
content_id:int - the new content_id for the given location
]]--
function Region:set_content_id(x, y, z, content_id)
self._emerged_data[self._emerged_area:index(x, y, z)] = content_id
end
--[[
Iterate over every voxel within a specified area.
For each voxel, inside the described cuboid, call the `doOperation` function which should have
the following signature:
function doOperation(x:int, y:int, z:int) -> None
The called function can then inspect and manipulate the content ids and meta data in the region
using the various methods on this class.
Args:
x_min:int - the lowest x coordinate in the desired cuboid
x_max:int - the highest x coordinate in the desired cuboid
y_min:int - the lowest y coordinate in the desired cuboid
y_max:int - the highest y coordinate in the desired cuboid
z_min:int - the lowest z coordinate in the desired cuboid
z_max:int - the highest z coordinate in the desired cuboid
doOperation:function(x:int,y:int,z:int) - the callback to be invoked for each voxel
]]--
function Region:iterate(x_min, x_max, y_min, y_max, z_min, z_max, doOperation)
x_min = math.max(x_min, self._fill_min.x)
x_max = math.min(x_max, self._fill_max.x)
y_min = math.max(y_min, self._fill_min.y)
y_max = math.min(y_max, self._fill_max.y)
z_min = math.max(z_min, self._fill_min.z)
z_max = math.min(z_max, self._fill_max.z)
for z = z_min, z_max do
for y = y_min, y_max do
for x = x_min, x_max do
doOperation(self, x, y, z)
end
end
end
end
--[[
Iterates over all voxels at or below a certain altitude.
Works identically to the `Region:iterate` function, except that the x & z ranges are the full
area being filled by this region, and the y range is capped at the given altitude.
Args:
y_max:int - the maximum y value to include
doOperation:function(x:int,y:int,z:int) - the callback to be invoked for each voxel
]]--
function Region:iterate_below(y_max, doOperation)
self:iterate(
self._fill_min.x, self._fill_max.x,
self._fill_min.y, y_max,
self._fill_min.z, self._fill_max.z,
doOperation
)
end
--[[
Iterates over all the x,z columns in the fill region.
Works identically to the `Region:iterate` function, except that the x & z ranges are the full
area being filled by this region, and the y-axis coordinate is omitted.
Args:
doOperation:function(x:int,z:int) - the callback to be invoked for each voxel
]]--
function Region:iterate_columns(doOperation)
self:iterate(
self._fill_min.x, self._fill_max.x,
0, 0,
self._fill_min.z, self._fill_max.z,
function(x, y, z) doOperation(x, z) end
)
end
--[[
Iterates over all voxels being filled in this region.
Works identically to the `Region:iterate` function, except that the x, y, and z ranges are the
full area being filled by this region.
Args:
doOperation:function(nt,int,int) - the callback to be invoked for each voxel
]]--
function Region:iterate_fill(doOperation)
self:iterate(
self._fill_min.x, self._fill_max.x,
self._fill_min.y, self._fill_max.y,
self._fill_min.z, self._fill_max.z,
doOperation
)
end
--[[
Iterates over all voxels at a specific altitude.
Works identically to the `Region:iterate` function, except that the x & z ranges are the full
area being filled by this region, and y is limited to exactly the given altitude.
Args:
y:int - the y value to use
doOperation:function(int,int,int) - the callback to be invoked for each voxel
]]--
function Region:iterate_plane(y, doOperation)
if y < self._fill_min.y then return end
if y > self._fill_max.y then return end
self:iterate(
self._fill_min.x, self._fill_max.x,
y, y,
self._fill_min.z, self._fill_max.z,
doOperation
)
end
--[[
Get the named metadata at the indicated coordinate.
The canonical use for this method is to find the previously-calculated altitude of the base
terrain at a certain location (e.g., `get_meta(Region.META.ALTITUDE, 292, 998)`). However, any
meta name can be used, and any data stored. This data is let until overwritten, so each mapgen
cycle should be careful to recompute any metadata it requires before running algorithms which
depend upon it.
Args:
name:string - the name of the metadata table to access
x:int - the x coordinate of the desired data
z:int - the z coordinate of the desired data
Returns:
the value previously stored for that location or `nil` if there isn't any
]]--
function Region:get_meta(name, x, z)
local meta_data = self._meta[name]
if not meta_data then return nil end
return meta_data[self._emerged_area:index(x, 0, z)]
end
--[[
Change the metadata at the indicated coordinate.
This will automatically fill in any necessary pieces to ensure that the operation succeeds
(e.g., creating a missing metadata table), so it is highly advised to use the provided
`Region.META` constants to avoid accidentally creating new tables through misspellings.
Args:
name:string - the name of the metadata table to access
x:int - the x coordinate of the desired data
z:int - the z coordinate of the desired data
value:any - the value to be stored
]]--
function Region:set_meta(name, x, z, value)
local meta_data = self._meta[name]
if not meta_data then
meta_data = {}
self._meta[name] = meta_data
end
meta_data[self._emerged_area:index(x, 0, z)] = value
end
--[[
Reads raw voxel data from a voxel manipulator.
Args:
voxels:VoxelManip - the voxel manipulator containing the data
fill_min:vector - the smaller corner of the cuboid to be filled
fill_max:vector - the larger corner of the cuboid to be filled
]]--
function Region:read_voxels(voxels, fill_min, fill_max)
self:save_voxels()
self._voxels = voxels
self._fill_min = fill_min
self._fill_max = fill_max
local min_emerged, max_emerged = voxels:get_emerged_area()
self._emerged_area = VoxelArea(min_emerged, max_emerged)
self._voxels:get_data(self._emerged_data)
end
--[[
Writes raw voxel data back into the source voxel manipulator.
If no voxel data has been read (or none has been read since the last save), then this function
returns immediately.
]]--
function Region:save_voxels()
if not self._voxels then return end
self._voxels:set_data(self._emerged_data)
self._voxels:calc_lighting()
self._voxels:update_liquids()
self._emerged_area = nil
self._fill_max = nil
self._fill_min = nil
self._voxels = nil
end
+43
View File
@@ -0,0 +1,43 @@
-- Imports & Exports -------------------------------------------------------------------------------
local core = _G["core"]
-- Constants ---------------------------------------------------------------------------------------
local S = core.get_translator("jvmi_nodes")
-- Registrations -----------------------------------------------------------------------------------
core.register_node("jvmi_nodes:clay", {
description = S("Clay"),
drop = "jvmi_nodes:clay",
is_ground_content = true,
sounds = { footstep = "jvmi_nodes_clay_footstep" },
tiles = {"jvmi_nodes_clay.png"},
})
core.register_node("jvmi_nodes:dirt", {
description = S("Dirt"),
drop = "jvmi_nodes:dirt",
is_ground_content = true,
sounds = { footstep = "jvmi_nodes_dirt_footstep" },
tiles = {"jvmi_nodes_dirt.png"},
})
core.register_node("jvmi_nodes:sand", {
description = S("Sand"),
drop = "jvmi_nodes:sand",
is_ground_content = true,
sounds = { footstep = "jvmi_nodes_sand_footstep" },
tiles = {"jvmi_nodes_sand.png"},
})
core.register_node("jvmi_nodes:turf", {
description = S("Turf"),
drop = "jvmi_nodes:turf",
is_ground_content = true,
sounds = { footstep = "jvmi_nodes_turf_footstep" },
tiles = {"jvmi_nodes_turf.png"},
})
+4 -3
View File
@@ -2,11 +2,12 @@
local core = _G["core"] local core = _G["core"]
local path = core.get_modpath("jvmi_nodes")
-- Script ------------------------------------------------------------------------------------------ -- Script ------------------------------------------------------------------------------------------
dofile(path.."/earthlike.lua") local path = core.get_modpath("jvmi_nodes")
dofile(path.."/earthy.lua")
dofile(path.."/liquid.lua") dofile(path.."/liquid.lua")
dofile(path.."/stony.lua")
core.log("info", "jvmi_nodes loaded") core.log("info", "jvmi_nodes loaded")
+1
View File
@@ -76,3 +76,4 @@ core.register_node("jvmi_nodes:water_source", {
post_effect_color = "#033C5CCC", post_effect_color = "#033C5CCC",
groups = { }, groups = { },
}) })
core.register_alias("mapgen_water_source", "jvmi_nodes:water_source")
@@ -17,6 +17,7 @@ core.register_node("jvmi_nodes:bedrock", {
sounds = { footstep = "jvmi_nodes_stone_footstep" }, sounds = { footstep = "jvmi_nodes_stone_footstep" },
tiles = {"jvmi_nodes_bedrock.png"}, tiles = {"jvmi_nodes_bedrock.png"},
}) })
core.register_alias("mapgen_bedrock", "jvmi_nodes:stone")
core.register_node("jvmi_nodes:stone", { core.register_node("jvmi_nodes:stone", {
description = S("Stone"), description = S("Stone"),
@@ -24,3 +25,4 @@ core.register_node("jvmi_nodes:stone", {
sounds = { footstep = "jvmi_nodes_stone_footstep" }, sounds = { footstep = "jvmi_nodes_stone_footstep" },
tiles = {"jvmi_nodes_stone.png"}, tiles = {"jvmi_nodes_stone.png"},
}) })
core.register_alias("mapgen_stone", "jvmi_nodes:stone")
Binary file not shown.

After

Width:  |  Height:  |  Size: 189 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 172 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 227 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 181 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 435 B

Before

Width:  |  Height:  |  Size: 647 B

After

Width:  |  Height:  |  Size: 647 B

Before

Width:  |  Height:  |  Size: 438 B

After

Width:  |  Height:  |  Size: 438 B

+90
View File
@@ -0,0 +1,90 @@
-- Imports -----------------------------------------------------------------------------------------
local api = _G["jvmi_table"]
local table = _G["table"]
-- API Functions -----------------------------------------------------------------------------------
--[[
Performs a deep clone of a given table.
This function only clones regular keys, and makes no effort to preserve the metatables of the
resulting tables. It also does not attempt to handle cycles among the given tables.
Args:
source:table - the table to be cloned
Returns:
a new table which the same keys and deeply copied values
]]--
function api.clone(source)
if type(source) ~= "table" then return source end
local target = {}
for key, value in pairs(source) do
target[key] = api.clone(value)
end
return target
end
--[[
Performs a shallow clone of a given table.
This is similar to `clone`, but it does not attempt to deeply copy the values of the given
table, instead creating a new table with the same keys and values as the original.
Args:
source:table - the table to be copied
Returns:
a new table with the same keys and values as the original
]]--
function api.copy(source)
return api.merge({}, source)
end
--[[
Add a value to the end of an array-like table.
Args:
target:array - a table which is being used like an array (i.e., contiguous integer keys)
value:any - the value to be appeneded to the array
Returns:
the target table
]]--
function api.append(target, value)
target[#target] = value
return target
end
--[[
Overwrite the contents of a target table with the values in one or more source tables.
Only those keys defined by one of the source tables will be overridden in the target table.
Each successive source table in the given sequence may override values in the earlier source
tables. This function only performs a shallow copy, so any objects in the source tables are only copied
by reference. To create a brand new table with the merged contents of the following tables,
provide nil as the first argument.
Args:
target:table - a table whose values are to be overridden
...:table - a sequence of one or more source tables whose keys are to be copied
Returns:
the target table
]]--
function api.merge(target, ...)
target = target or nil
for _, source in ipairs(arg) do
for key, value in pairs(source) do
target[key] = value
end
end
return target
end
+15
View File
@@ -0,0 +1,15 @@
-- Imports -----------------------------------------------------------------------------------------
local core = _G["core"]
-- Public ------------------------------------------------------------------------------------------
jvmi_table = {} -- luacheck: globals jvmi_table
local path = core.get_modpath("jvmi_table")
dofile(path.."/api.lua")
-- Script ------------------------------------------------------------------------------------------
core.log("info", "jvmi_tables ready")
+4
View File
@@ -0,0 +1,4 @@
name = jvmi_table
title = Jules Verne's Mysterious Island / Table
description = helpers for table manipulation
author = tungstonminer