-- 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