316 lines
10 KiB
Lua
316 lines
10 KiB
Lua
-- Import ------------------------------------------------------------------------------------------
|
|
|
|
local jvmi = _G.jvmi
|
|
local math = _G.math
|
|
local VoxelArea = _G.VoxelArea
|
|
|
|
local check = jvmi.check
|
|
|
|
|
|
-- Private -----------------------------------------------------------------------------------------
|
|
|
|
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",
|
|
}
|
|
}
|
|
|
|
--[[
|
|
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 = {
|
|
fill_min = nil,
|
|
fill_max = nil,
|
|
_emerged_area = nil,
|
|
_emerged_data = {},
|
|
_meta = {},
|
|
_voxels = nil,
|
|
}
|
|
setmetatable(result, { __index = 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)
|
|
check.is_type("x", x, "number")
|
|
check.is_type("y", y, "number")
|
|
check.is_type("z", z, "number")
|
|
|
|
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)
|
|
check.is_type("x", x, "number")
|
|
check.is_type("y", y, "number")
|
|
check.is_type("z", z, "number")
|
|
check.is_type("content_id", content_id, "number")
|
|
|
|
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 `do_operation` function which should have
|
|
the following signature:
|
|
|
|
function do_operation(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
|
|
do_operation: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, do_operation)
|
|
check.is_type("x_min", x_min, "number")
|
|
check.is_type("x_max", x_max, "number")
|
|
check.is_type("y_min", y_min, "number")
|
|
check.is_type("y_max", y_max, "number")
|
|
check.is_type("z_min", z_min, "number")
|
|
check.is_type("z_max", z_max, "number")
|
|
check.is_type("do_operation", do_operation, "function")
|
|
|
|
x_min = math.floor(math.max(x_min, self.fill_min.x))
|
|
x_max = math.floor(math.min(x_max, self.fill_max.x))
|
|
y_min = math.floor(math.max(y_min, self.fill_min.y))
|
|
y_max = math.floor(math.min(y_max, self.fill_max.y))
|
|
z_min = math.floor(math.max(z_min, self.fill_min.z))
|
|
z_max = math.floor(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
|
|
do_operation(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
|
|
do_operation:function(x:int,y:int,z:int) - the callback to be invoked for each voxel
|
|
]]--
|
|
function Region:iterate_below(y_max, do_operation)
|
|
check.is_type("y_max", y_max, "number")
|
|
check.is_type("do_operation", do_operation, "function")
|
|
|
|
self:iterate(
|
|
self.fill_min.x, self.fill_max.x,
|
|
self.fill_min.y, y_max,
|
|
self.fill_min.z, self.fill_max.z,
|
|
do_operation
|
|
)
|
|
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:
|
|
do_operation:function(x:int,z:int) - the callback to be invoked for each voxel
|
|
]]--
|
|
function Region:iterate_columns(do_operation)
|
|
check.is_type("do_operation", do_operation, "function")
|
|
|
|
self:iterate(
|
|
self.fill_min.x, self.fill_max.x,
|
|
self.fill_min.y, self.fill_min.y, -- we only want columns, so use a single y value
|
|
self.fill_min.z, self.fill_max.z,
|
|
function(x, y, z) do_operation(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:
|
|
do_operation:function(nt,int,int) - the callback to be invoked for each voxel
|
|
]]--
|
|
function Region:iterate_fill(do_operation)
|
|
check.is_type("do_operation", do_operation, "function")
|
|
|
|
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,
|
|
do_operation
|
|
)
|
|
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
|
|
do_operation:function(int,int,int) - the callback to be invoked for each voxel
|
|
]]--
|
|
function Region:iterate_plane(y, do_operation)
|
|
check.is_type("y", y, "number")
|
|
check.is_type("do_operation", do_operation, "function")
|
|
|
|
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,
|
|
do_operation
|
|
)
|
|
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)
|
|
check.is_type("name", name, "string")
|
|
check.is_type("x", x, "number")
|
|
check.is_type("z", z, "number")
|
|
|
|
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)
|
|
check.is_type("name", name, "string")
|
|
check.is_type("x", x, "number")
|
|
check.is_type("z", z, "number")
|
|
|
|
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)
|
|
check.is_type("voxels", voxels, "userdata")
|
|
check.is_type("fill_min", fill_min, "table")
|
|
check.is_type("fill_max", fill_max, "table")
|
|
|
|
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.fill_max = nil
|
|
self.fill_min = nil
|
|
self._emerged_area = nil
|
|
self._voxels = nil
|
|
end
|
|
|
|
|
|
-- Public ------------------------------------------------------------------------------------------
|
|
|
|
jvmi.Region = Region
|