milan
/
minetest-mm
1
0
Fork 0
Code Issues 3 Pull Requests Releases Wiki Activity
minetest-mm/mods/trees_lib/init.lua

657 lines
23 KiB
Lua
Raw Permalink Blame History

trees_lib = {}
-- place this node if a sapling does not like the environment and refuses
-- to grow into a tree there
trees_lib.place_when_tree_cant_grow = {name="default:dry_shrub"};
-----------------------------------------------------------------------------
-- compatibility functions so that trees_lib can work without default mod
-----------------------------------------------------------------------------
trees_lib.sound_leaves = function()
if( default and default.node_sound_leaves_defaults) then
return default.node_sound_leaves_defaults(table)
else
return nil
end
end
trees_lib.sound_wood = function()
if( default and default.node_sound_wood_defaults) then
return default.node_sound_wood_defaults(table)
else
return nil
end
end
-- copy of default.after_place_leaves
trees_lib.after_place_leaves = function(pos, placer, itemstack, pointed_thing)
local node = minetest.get_node(pos)
node.param2 = 1
minetest.set_node(pos, node)
end
-- generalized function called after placing fruits
trees_lib.after_place_fruit = function(pos, placer, itemstack, pointed_thing)
if placer:is_player() then
-- find out the node name (this function is for all fruits that do not override it)
local node = minetest.get_node( pos );
if( node and node.name) then
minetest.set_node(pos, {name = node.name, param2 = 1})
end
end
end
-----------------------------------------------------------------------------
-- the various node definitions that are common to all nodes of that type
-- (unless overriden)
-----------------------------------------------------------------------------
trees_lib.node_def_tree = {
--description = "TREENAME Tree",
--tiles = nodes.tree.tiles,
paramtype2 = "facedir",
is_ground_content = false,
-- moretrees uses snappy=1 here as well
groups = {tree = 1, choppy = 2, oddly_breakable_by_hand = 1, flammable = 2},
sounds = trees_lib.sound_wood,
on_place = minetest.rotate_node
}
trees_lib.node_def_wood = {
--description = "TREENAME Wood Planks",
--tiles = nodes.wood.tiles,
is_ground_content = false,
-- moretrees uses snappy=1 here
groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 3, wood = 1},
sounds = trees_lib.sound_wood,
}
trees_lib.node_def_leaves = {
--description = "TREENAME Leaves",
--tiles = nodes[k].tiles,
--special_tiles = nodes[k].special_tiles,
-- moretrees has some options for this
drawtype = "allfaces_optional",
waving = 1,
visual_scale = 1.3,
paramtype = "light",
is_ground_content = false,
-- moretrees sets moretrees_leaves=1, leafdecay = decay
groups = {snappy = 3, leafdecay = 3, flammable = 2, leaves = 1},
sounds = trees_lib.sound_leaves,
after_place_node = trees_lib.after_place_leaves,
-- the drop part of the node definition needs to be constructed
-- for each leaf individually
}
trees_lib.node_def_fruit = {
--description = "TREENAME Fruit",
drawtype = "plantlike",
visual_scale = 1.0,
--tiles = nodes.fruit.tiles,
--inventory_image = nodes.fruit.tiles[1],
paramtype = "light",
sunlight_propagates = true,
walkable = false,
is_ground_content = false,
selection_box = {
type = "fixed",
fixed = {-0.2, -0.5, -0.2, 0.2, 0, 0.2}
},
groups = {fleshy = 3, dig_immediate = 3, flammable = 2,
leafdecay = 3, leafdecay_drop = 1},
sounds = trees_lib.sound_leaves,
-- store that this fruit has been placed manually
after_place_node = trees_lib.after_place_fruit,
-- a fruit that wants to be eatable ought to supply the following line in
-- its fruit definition:
--on_use = minetest.item_eat(food_points),
}
trees_lib.node_def_sapling = {
--description = "TREENAME sapling",
drawtype = "plantlike",
visual_scale = 1.0,
--tiles = nodes.sapling.tiles,
--inventory_image = nodes.sapling.tiles[1],
--wield_image = nodes.sapling.tiles[1],
paramtype = "light",
sunlight_propagates = true,
walkable = false,
selection_box = {
type = "fixed",
fixed = {-0.3, -0.5, -0.3, 0.3, 0.35, 0.3}
},
groups = {snappy = 2, dig_immediate = 3, flammable = 2,
attached_node = 1, sapling = 1},
sounds = trees_lib.sound_leaves,
}
-----------------------------------------------------------------------------
-- internal functions for handling identification of nodes (i.e. what is a
-- trunk, what is a leaf, which nodes can be replaced by new trees)
-----------------------------------------------------------------------------
-- those are helpful for fast lookup (either by name or content id)
trees_lib.is_tree = {}
trees_lib.is_wood = {}
trees_lib.is_leaf = {}
trees_lib.is_sapling = {}
trees_lib.is_fruit = {}
trees_lib.ignore = {}
-- trees are allowed to replace these nodes when growing
-- (in addition to leaves, saplings and fruits from other trees)
trees_lib.ignore_list = {
"air","ignore",
"default:water_source","default:water_flowing",
"default:snow","default:ice"}
trees_lib.build_lookup_table = function( node_name, node_type, value, allow_removal_by_other_saplings )
if( not( node_name )
or node_name == ""
or not( minetest.registered_nodes[ node_name ])
or not( trees_lib[ node_type ])) then
return;
end
local id = minetest.get_content_id( node_name );
-- we store by id and nodename both for faster lookup
trees_lib[ node_type ][ id ] = value;
trees_lib[ node_type ][ node_name ] = value;
-- if this is set, then other saplings can overwrite these nodes during
-- their growth (i.e. replacing leaves with tree trunks)
if( allow_removal_by_other_saplings ) then
trees_lib.ignore[ id ] = value;
trees_lib.ignore[ node_name ] = value;
end
end
-- actually store the information from the ignore list
for _,v in ipairs( trees_lib.ignore_list ) do
trees_lib.build_lookup_table( v,"ignore", v, 1 );
end
-----------------------------------------------------------------------------
-- allow to call a function whenever a new tree has been registered
-----------------------------------------------------------------------------
-- contains a list of all functions that need to be called whenever a new tree
-- type is registered using trees_lib.register_tree(..)
trees_lib.register_on_new_tree_type_function_list = {}
-- the function new_tree_type_function will be called once for each tree type;
-- use this for adding the 1 tree -> 4 wood craft receipe
trees_lib.register_on_new_tree_type = function( new_tree_type_function )
-- call the function for all tree types that have been registered up
-- until now
for k,v in pairs( trees_lib.is_sapling) do
new_tree_type_function( v.tree_name, v.mod_prefix, v.nodes );
end
-- store the function so that it will get called at all subsequent
-- registrations of new trees
table.insert( trees_lib.register_on_new_tree_type_function_list,
new_tree_type_function );
end
-----------------------------------------------------------------------------
-- mix basic node definition (see below), default constructed values (which
-- are derived from modname and treename) as fallback and user (=user of the
-- trees_lib) specified node defintion up into one node definition and
-- register the node (provided it does not exist yet)
-----------------------------------------------------------------------------
trees_lib.register_one_node = function( def_common, def_default, def_user, node_type, sapling_node_name, cid )
if( not( def_user)) then
def_user = {};
end
-- find out which node we are supposed to register
local node_name = def_user.node_name;
if( not( node_name )) then
node_name = def_default.node_name;
end
-- if the node is alrady registered, then abort
if( minetest.registered_nodes[ node_name ]) then
-- store the content id of this node for this type
cid[ node_type ] = minetest.get_content_id( node_name );
def_user.node_name = node_name;
return def_user;
end
-- create the new node definition
local node_def = {};
-- first, add all entries from def_common
for k,v in pairs( def_common ) do
node_def[ k ] = v;
end
-- then try the default values
for k,v in pairs( def_default) do
node_def[ k ] = v;
end
-- last, apply all user supplied node definitions and thus overwrite
-- common and default definitions
for k,v in pairs( def_user ) do
node_def[ k ] = v;
end
-- set inventory_image and wield_image for plantlike nodes
if( node_def.drawtype
and node_def.drawtype=="plantlike"
and not( node_def.inventory_image )) then
node_def.inventory_image = node_def.tiles[1];
node_def.wield_image = node_def.tiles[1];
end
-- the node name does not belong into the node definition
node_def.node_name = nil;
-- actually register the new node
minetest.register_node( node_name, node_def );
-- make sure the node name gets saved
def_user.node_name = node_name;
-- can this node (in theory) be overwritten by other trees?
local allow_overwrite = nil;
if( node_type=="leaf" or node_type=="fruit" or node_type=="sapling") then
allow_overwrite = 1;
end
-- enter all these node names into a table for fast lookup
-- (without having to resort to checking the group)
-- the trees_lib.is_sapling field will later on contain more helpful information;
-- the sapling needs to be the first node registered for this to work reliably
trees_lib.build_lookup_table( node_name, "is_"..node_type, sapling_node_name, allow_overwrite );
-- store the content id of the newly registered node
cid[ node_type ] = minetest.get_content_id( node_name );
return def_user;
end
-----------------------------------------------------------------------------
-- nodes for the trees: trunk, planks, leaves, sapling and fruit
-----------------------------------------------------------------------------
-- (internal function)
-- * there can be up to 5 diffrent leaves types
-- * Note: craft receipes for fuel (tree, wood, leaves) do not need to be
-- added because default already contains general craft receipes
-- based on the respective groups.
-- * Note: The craft receipe for 1 tree -> 4 wood can be done via
-- trees_lib.register_on_new_tree_type
trees_lib.register_tree_nodes = function( tree_name, mod_prefix, nodes )
-- gather all the relevant content ids
local cid = {};
local tree_name_upcase = tree_name:gsub("^%l", string.upper);
local texture_prefix = mod_prefix.."_"..tree_name;
if( not( nodes )) then
nodes = {};
end
-- the sapling node name will act as a reference in the lookup table later on;
-- therefore, we need to determine how the node will be called early enough
local sapling_node_name = mod_prefix..':'..tree_name..'_sapling';
if( nodes.sapling and nodes.sapling.node_name ) then
sapling_node_name = nodes.sapling.node_name;
end
-- register the sapling
nodes.sapling = trees_lib.register_one_node( trees_lib.node_def_sapling,
{
node_name = sapling_node_name,
description = tree_name_upcase.." Sapling",
tiles = { texture_prefix.."_sapling.png",
},
}, nodes.sapling, "sapling", sapling_node_name, cid );
-- register the tree trunk
nodes.tree = trees_lib.register_one_node( trees_lib.node_def_tree,
{
node_name = mod_prefix..':'..tree_name..'_tree',
description = tree_name_upcase.." Tree",
tiles = { texture_prefix.."_tree_top.png",
texture_prefix.."_tree_top.png",
texture_prefix.."_tree.png",
},
}, nodes.tree, "tree", sapling_node_name, cid );
-- register the wood that belongs to the tree
nodes.wood = trees_lib.register_one_node( trees_lib.node_def_wood,
{
node_name = mod_prefix..':'..tree_name..'_wood',
description = tree_name_upcase.." Planks",
tiles = { texture_prefix.."_wood.png",
},
}, nodes.wood, "wood", sapling_node_name, cid );
-- default drop rate for the sapling (1/20)
local sapling_rarity = 20;
if( nodes.sapling and nodes.sapling.rarity ) then
sapling_rarity = nodes.sapling.rarity;
end
-- register the leaves; some trees may have more than one type of leaves (i.e. moretrees jungletrees)
local leaves_id = {'leaves','leaves2','leaves3','leaves4','leaves5'};
for _,k in ipairs( leaves_id ) do
-- not all leaf types need to exist; we just expect at least one type of leaves to be there
if( nodes[ k ] or k=='leaves') then
-- we need to determine the node name now as leaves tend to drop themshelves sometimes
local leaves_node_name = mod_prefix..':'..tree_name..'_'..k;
if( nodes[ k ] and nodes[ k ].node_name ) then
leaves_node_name = nodes[ k ].node_name;
end
nodes[ k ] = trees_lib.register_one_node( trees_lib.node_def_leaves,
{
node_name = leaves_node_name,
description = tree_name_upcase.." Leaves",
tiles = { texture_prefix.."_"..k..".png",
},
-- special_tiles = { texture_prefix.."_"..k.."_simple.png", },
drop = {
max_items = 1,
items = {
{
-- player will get sapling with 1/20 chance
items = { sapling_node_name},
rarity = sapling_rarity,
},
{
-- player will get leaves only if he get no saplings,
-- this is because max_items is 1
items = { leaves_node_name},
}
}
},
}, nodes[ k ], "leaf", sapling_node_name, cid);
-- also store the content ids of all leaf types
cid[ k ] = cid[ "leaf" ];
end
end
-- register the fruit
nodes.fruit = trees_lib.register_one_node( trees_lib.node_def_fruit,
{
node_name = mod_prefix..':'..tree_name..'_fruit',
description = tree_name_upcase.." Fruit",
tiles = { texture_prefix.."_fruit.png",
},
}, nodes.fruit, "fruit", sapling_node_name, cid );
-- return the ids we've gathered
return cid;
end
-----------------------------------------------------------------------------
-- growing of the trees from saplings
-----------------------------------------------------------------------------
-- turn saplings that failed to grow (because they don't like the ground or
-- environment) into dry shrub, thus allowing dry shrub farming;
-- override this function if you don't like this feature
trees_lib.failed_to_grow = function( pos, node )
minetest.set_node( pos, trees_lib.place_when_tree_cant_grow);
end
-- this function is called just before a tree actually grows;
-- the function ought to return how_to_grow for normal tree growth;
-- returning another way of growing is also possible (i.e. diffrent
-- model when growing in flower pots/on stone)
trees_lib.change_tree_growth = function( pos, node, how_to_grow )
return how_to_grow;
end
-- this function is called whenever a sapling of type node has grown
-- into a tree using how_to_grow at position pos
trees_lib.a_tree_has_grown = function( pos, node, how_to_grow )
return;
end
-- called by the abm running on the saplings;
-- if force is set, the tree will grow even if it usually wouldn't in that
-- environment
trees_lib.tree_abm_called = function( pos, node, active_object_count, active_object_count_wider, force_grow)
-- if we don't have further information about that sapling, then abort
if( not( node )
or not( node.name )
or not( trees_lib.is_sapling[ node.name ])) then
-- turn into dry shrub (because we don't know what to do with
-- this sapling)
trees_lib.failed_to_grow( pos, node );
return;
end
-- get information about what we're supposed to do with that sapling
local sapling_data = trees_lib.is_sapling[ node.name ];
-- the type of ground might be of intrest for further functions (i.e. can_grow, select_how_to_grow)
local ground_found = nil;
-- a quick check of the ground; sapling_data.grows_on has to be a list of all
-- ground types acceptable for the tree
if( not(force_grow) and sapling_data.grows_on and type( sapling_data.grows_on )=="table") then
local node_under = minetest.get_node_or_nil({x = pos.x, y = pos.y - 1, z = pos.z});
-- abort if this check cannot be done
if( not(node_under) or node_under.name=="ignore") then
return;
end
-- search all acceptable ground names
for _,g in ipairs( sapling_data.grows_on ) do
if( g==node_under.name ) then
ground_found = g;
elseif( not( ground_found)
and string.sub(g,1,6)=="group:"
and minetest.get_item_group( node_under.name, string.sub(g,7))~=0 ) then
ground_found = g;
end
end
-- abort if the tree does not like this type of ground
if( not( ground_found )) then
-- trun into dry shrub
trees_lib.failed_to_grow( pos, node );
return;
end
end
-- the tree may come with a more complex function that checks if it can grow there
if( not(force_grow) and sapling_data.can_grow and type( sapling_data.can_grow)=="function" ) then
-- the parameter ground_found is nil if the tree did not specify any demands for a particular ground
local ret = sapling_data.can_grow( pos, node, ground_found );
if( ret < 1 ) then
-- trun into dry shrub if growing failed finally (and was not just delayed)
if( ret==0 ) then
trees_lib.failed_to_grow( pos, node, ground_found );
end
return;
end
end
-- each tree can have several ways of growing
local how_to_grow = nil;
-- the sapling may - depending on the circumstances - choose a specific growth function
-- instead of a random one
if( sapling_data.select_how_to_grow and type( sapling_data.select_how_to_grow)=="function") then
-- ground_found is nil if the tree did not specify any demands for a particular ground
how_to_grow = sapling_data.select_how_to_grow( pos, node, sapling_data.how_to_grow, ground_found );
-- the select_how_to_grow function may either return a table or a number indicating which
-- growth method to select
if( how_to_grow and type(how_to_grow)=="number" and sapling_data.how_to_grow[ how_to_grow ]) then
how_to_grow = sapling_data.how_to_grow[ how_to_grow ];
end
else -- else select a random one
how_to_grow = sapling_data.how_to_grow[ math.random( 1, #sapling_data.how_to_grow )];
end
-- this function may change the way the tree grows (i.e. select a special method for trees growing in flower pots or on stone ground)
how_to_grow = trees_lib.change_tree_growth( pos, node, how_to_grow );
-- actually grow the tree in a seperate function
trees_lib.tree_abm_grow_tree( pos, node, sapling_data, how_to_grow, force_grow );
end
-- actually grow the tree from a sapling
trees_lib.tree_abm_grow_tree = function( pos, node, sapling_data, how_to_grow, force_grow )
-- abort if no way was found to grow the tree
if( not( how_to_grow ) or type(how_to_grow)~="table") then
trees_lib.failed_to_grow( pos, node );
return;
-- grow the tree using a function (like the old apple trees did)
elseif( how_to_grow.use_function and type(how_to_grow.use_function)=="function") then
-- get the voxelmanip data
local vm = minetest.get_voxel_manip()
local minp, maxp = vm:read_from_map(
{x = pos.x - how_to_grow.xoff, y = pos.y - how_to_grow.yoff, z = pos.z - how_to_grow.zoff},
{x = pos.x + how_to_grow.xoff, y = pos.y + how_to_grow.height, z = pos.z + how_to_grow.zoff}
)
local a = VoxelArea:new({MinEdge = minp, MaxEdge = maxp})
local data = vm:get_data()
how_to_grow.use_function( data, a, pos, sapling_data, how_to_grow.extra_params );
-- write the data back
vm:set_data(data)
vm:write_to_map()
vm:update_map()
-- grow the tree using a schematic
elseif( how_to_grow.use_schematic
and (type(how_to_grow.use_schematic)=="string"
or type(how_to_grow.use_schematic)=="table")) then
-- TODO: use voxelmanip
-- remove the sapling
minetest.set_node( pos, {name="air"});
-- TODO: determine xoff, yoff and zoff when registering the tree
-- (if yoff is not given, then use 0)
minetest.place_schematic(
{x = pos.x - how_to_grow.xoff,
y = pos.y - how_to_grow.yoff,
z = pos.z - how_to_grow.zoff},
how_to_grow.use_schematic, -- full path to the .mts file
"random", -- rotation
how_to_grow.use_replacements, -- use the same schematic for diffrent trees
false -- no overwriting of existing nodes
);
-- grow the tree using L-system
elseif( how_to_grow.use_lsystem and type(how_to_grow.use_lsystem)=="table") then
-- remove the sapling
minetest.set_node( pos, {name="air"});
-- spawn the l-system tree
minetest.spawn_tree(pos, how_to_grow.use_lsystem );
-- else prevent call of success function below
else
return;
end
trees_lib.a_tree_has_grown( pos, node, how_to_grow );
end
-----------------------------------------------------------------------------
-- register a new tree
-----------------------------------------------------------------------------
trees_lib.register_tree = function( tree_name, nodes, growing_methods, grows_on_node_type_list, can_grow_function, select_how_to_grow_function, interval, chance )
-- the tree name is the minimum needed in order to register a new tree
if( not( tree_name )) then
return;
end
-- we may have to register nodes - and those have to be registered under the name of whichever mod called this function and is the "current" mod
local mod_prefix = "";
-- set it to the current mod - this cannot be done in the line above as that would set mod_prefix to trees_lib and not to the calling mod
mod_prefix = minetest.get_current_modname();
-- register tree trunk, wood, leaves and fruit (provided they are not defined yet)
local cid_list = trees_lib.register_tree_nodes( tree_name, mod_prefix, nodes );
-- a sapling will be needed for growing the tree
if( not( nodes.sapling )
or not( nodes.sapling.node_name )
or not( growing_methods )) then
return;
end
-- store information about the new tree type in the sapling table
trees_lib.is_sapling[ nodes.sapling.node_name ] = {
-- minetest.get_content_id for tree, wood, leaves1..n, sapling, fruit
cid = cid_list,
-- node name of the sapling
sapling = nodes.sapling.node_name,
-- values passed on to all functions registered via
-- trees_lib.register_on_new_tree_type = function( new_tree_type_function )
tree_name = tree_name,
mod_prefix = mod_prefix,
nodes = nodes,
-- list of node names (can contain groups, i.e. "group:soil")
-- on which the sapling will grow;
-- note: the parameter ground_found to the functions below can only be
-- passed on if grows_on has been specified (else the sapling does
-- not do any ground checks on its own)
grows_on = grows_on_node_type_list,
-- are all the requirements met for growing at pos?
-- sapling will only grow if
-- growing.can_grow( pos, node, ground_found )
-- returns a value >0; if 0 is returned, the sapling will fail to grow
-- and be turned into dry shrub; if a value <0 is returned, nothing will
-- happen (the sapling can try again later on)
-- (usful for i.e. requiring water nearby, or other
-- more complex requirements)
can_grow = can_grow_function,
-- has to be either nil (for selecting a random way)
-- or return a specific growth function like the ones in
-- the list how_to_grow (see below) when called with
-- growing.select_how_to_grow( pos, node, growing.how_to_grow, ground_found )
select_how_to_grow = select_how_to_grow_function,
-- list of all methods that can turn the sapling into a
-- tree; can be a function, a file name containing a schematic
-- or a table for L-system trees;
-- this table/list is REQUIRED
how_to_grow = growing_methods,
};
-- a new tree was registered - call all functions that want to be told about new trees
for i,new_tree_type_function in ipairs( trees_lib.register_on_new_tree_type_function_list ) do
new_tree_type_function( tree_name, mod_prefix, nodes );
end
-- set default values for the tree-growing abm if none are set
if( not( interval)) then
interval = 10;
end
if( not( chance )) then
chance = 50;
end
-- now add the abm that lets the tree grow
minetest.register_abm({
nodenames = { nodes.sapling.node_name },
interval = interval,
chance = chance,
action = trees_lib.tree_abm_called,
});
end
Reference in New Issue View Git Blame Copy Permalink