Add files via upload

README.md

@@ -1,4 +1,4 @@
-# Wild Update
+# The Wild Update
 this mod is the wild update for mineclone 2 and 5, features all the new thing which minecraft 1.19 has in it.
 
 this will have -
@@ -12,7 +12,7 @@ this will have -
 - Deep Dark
 - All sculk Blocks
 - Warden
-- Ancient cities (not implemented yet)
+- Ancient cities (not implemented yet)
 
 https://www.planetminecraft.com/mod/the-wild-mod-fabric-5373520/
 

blocks.lua

@@ -0,0 +1,268 @@
+--wild_update_blocks--
+
+local S = minetest.get_translator("mcl_core")
+
+local register_tree_trunk = function(subname, description_trunk, description_bark, longdesc, tile_inner, tile_bark)
+minetest.register_node("wild_update:"..subname, {
+		description = description_trunk,
+		_doc_items_longdesc = longdesc,
+		_doc_items_hidden = false,
+		tiles = {tile_inner, tile_inner, tile_bark},
+		paramtype2 = "facedir",
+		on_place = mcl_util.rotate_axis,
+		stack_max = 64,
+		groups = {handy=1,axey=1, tree=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5},
+		sounds = mcl_sounds.node_sound_wood_defaults(),
+		on_rotate = on_rotate,
+		_mcl_blast_resistance = 2,
+		_mcl_hardness = 2,
+	})
+
+	minetest.register_craft({
+		output = "wild_update:"..subname.."_bark 3",
+		recipe = {
+			{ "wild_update:"..subname, "wild_update:"..subname },
+			{ "wild_update:"..subname, "wild_update:"..subname },
+		}
+	})
+end
+
+local register_wooden_planks = function(subname, description, tiles)
+minetest.register_node("wild_update:"..subname, {
+		description = description,
+		_doc_items_longdesc = doc.sub.items.temp.build,
+		_doc_items_hidden = false,
+		tiles = tiles,
+		stack_max = 64,
+		is_ground_content = false,
+		groups = {handy=1,axey=1, flammable=3,wood=1,building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=20},
+		sounds = mcl_sounds.node_sound_wood_defaults(),
+		_mcl_blast_resistance = 3,
+		_mcl_hardness = 2,
+	})
+end
+
+local register_leaves = function(subname, description, longdesc, tiles, sapling, drop_apples, sapling_chances, leafdecay_distance)
+	local drop
+	if leafdecay_distance == nil then
+		leafdecay_distance = 4
+	end
+	local apple_chances = {200, 180, 160, 120, 40}
+	local stick_chances = {50, 45, 30, 35, 10}
+	
+	local function get_drops(fortune_level)
+		local drop = {
+			max_items = 1,
+			items = {
+				{
+					items = {sapling},
+					rarity = sapling_chances[fortune_level + 1] or sapling_chances[fortune_level]
+				},
+				{
+					items = {"mcl_core:stick 1"},
+					rarity = stick_chances[fortune_level + 1]
+				},
+				{
+					items = {"mcl_core:stick 2"},
+					rarity = stick_chances[fortune_level + 1]
+				},
+			}
+		}
+		if drop_apples then
+			table.insert(drop.items, {
+				items = {"mcl_core:apple"},
+				rarity = apple_chances[fortune_level + 1]
+			})
+		end
+		return drop
+	end
+minetest.register_node("wild_update:"..subname, {
+		description = description,
+		_doc_items_longdesc = longdesc,
+		_doc_items_hidden = false,
+		drawtype = "allfaces_optional",
+		waving = 2,
+		place_param2 = 1, -- Prevent leafdecay for placed nodes
+		tiles = tiles,
+		paramtype = "light",
+		stack_max = 64,
+		groups = {handy=1,shearsy=1,swordy=1, leafdecay=leafdecay_distance, flammable=2, leaves=1, deco_block=1, dig_by_piston=1, fire_encouragement=30, fire_flammability=60},
+		_mcl_shears_drop = true,
+		sounds = mcl_sounds.node_sound_leaves_defaults(),
+		_mcl_blast_resistance = 0.2,
+		_mcl_hardness = 0.2,
+		_mcl_silk_touch_drop = true,
+		_mcl_fortune_drop = { get_drops(1), get_drops(2), get_drops(3), get_drops(4) },
+	})
+end
+
+local register_sapling = function(subname, description, longdesc, tt_help, texture, selbox)
+	minetest.register_node("wild_update:"..subname, {
+		description = description,
+		_tt_help = tt_help,
+		_doc_items_longdesc = longdesc,
+		_doc_items_hidden = false,
+		drawtype = "plantlike",
+		waving = 1,
+		visual_scale = 1.0,
+		tiles = {texture},
+		inventory_image = texture,
+		wield_image = texture,
+		paramtype = "light",
+		sunlight_propagates = true,
+		walkable = false,
+		selection_box = {
+			type = "fixed",
+			fixed = selbox
+		},
+		stack_max = 64,
+		groups = {dig_immediate=3, plant=1,sapling=1,non_mycelium_plant=1,attached_node=1,dig_by_water=1,dig_by_piston=1,destroy_by_lava_flow=1,deco_block=1},
+		sounds = mcl_sounds.node_sound_leaves_defaults(),
+		on_construct = function(pos)
+			local meta = minetest.get_meta(pos)
+			meta:set_int("stage", 0)
+		end,
+		on_place = mcl_util.generate_on_place_plant_function(function(pos, node)
+			local node_below = minetest.get_node_or_nil({x=pos.x,y=pos.y-1,z=pos.z})
+			if not node_below then return false end
+			local nn = node_below.name
+			return ((minetest.get_item_group(nn, "grass_block") == 1) or
+					nn=="mcl_core:podzol" or nn=="mcl_core:podzol_snow" or
+					nn=="mcl_core:dirt")
+		end),
+		node_placement_prediction = "",
+		_mcl_blast_resistance = 0,
+		_mcl_hardness = 0,
+	})
+end
+---plank,tree,leaves and sampling--
+
+register_tree_trunk("mangrove_tree", S("Mangrove Wood"), S("Mangrove Bark"), S("The trunk of an Mangrove tree."), "mcl_mangrove_log_top.png", "mcl_mangrove_log.png")
+register_wooden_planks("mangrove_wood", S("Mangrove Wood Planks"), {"mcl_mangrove_planks.png"})
+register_sapling("propagule", S("mangrove_propagule"),
+	S("When placed on soil (such as dirt) and exposed to light, an propagule will grow into an mangrove after some time."),
+	S("Needs soil and light to grow"),
+	"mcl_mangrove_propagule.png", {-5/16, -0.5, -5/16, 5/16, 0.5, 5/16})
+register_leaves("mangroveleaves", S("Mangrove Leaves"), S("mangrove leaves are grown from mangrove trees."), {"mcl_mangrove_leaves.png"}, "mcl_core:propagule", true, {20, 16, 12, 10})
+
+--doors and trapdoors--
+
+mcl_doors:register_door("wild_update:mangrove_door", {
+	description = ("mangrove door"),
+	_doc_items_longdesc = wood_longdesc,
+	_doc_items_usagehelp = wood_usagehelp,
+	inventory_image = "mcl_mangrove_doors.png",
+	groups = {handy=1,axey=1, material_wood=1, flammable=-1},
+	_mcl_hardness = 3,
+	_mcl_blast_resistance = 3,
+	tiles_bottom = {"mcl_mangrove_door_bottom.png", "mcl_mangrove_planks.png"},
+	tiles_top = {"mcl_mangrove_door_top.png", "mcl_mangrove_planks.png"},
+	sounds = mcl_sounds.node_sound_wood_defaults(),
+})
+
+minetest.register_craft({
+	output = "mcl_doors:mangrove_door 3",
+	recipe = {
+		{"wild_update:mangrove_wood", "wild_update:mangrove_wood"}, 
+		{"wild_update:mangrove_wood", "wild_update:mangrove_wood"}, 
+		{"wild_update:mangrove_wood", "wild_update:mangrove_wood"}, 
+	}
+})
+
+local woods = {
+	-- id, desc, texture, craftitem
+	{ "trapdoor", S("Mangrove Trapdoor"), "mcl_mangrove_trapdoor.png", "mcl_mangrove_planks.png", "wild_update:mangrove_wood" },}
+
+for w=1, #woods do
+	mcl_doors:register_trapdoor("wild_update:"..woods[w][1], {
+		description = woods[w][2],
+		_doc_items_longdesc = S("Wooden trapdoors are horizontal barriers which can be opened and closed by hand or a redstone signal. They occupy the upper or lower part of a block, depending on how they have been placed. When open, they can be climbed like a ladder."),
+		_doc_items_usagehelp = S("To open or close the trapdoor, rightclick it or send a redstone signal to it."),
+		tile_front = woods[w][3],
+		tile_side = woods[w][4],
+		wield_image = woods[w][3],
+		groups = {handy=1,axey=1, mesecon_effector_on=1, material_wood=1, flammable=-1},
+		_mcl_hardness = 3,
+		_mcl_blast_resistance = 3,
+		sounds = mcl_sounds.node_sound_wood_defaults(),
+	})
+
+minetest.register_craft({
+		output = "mcl_doors:"..woods[w][1].." 2",
+		recipe = {
+			{woods[w][5], woods[w][5], woods[w][5]},
+			{woods[w][5], woods[w][5], woods[w][5]},
+		}
+	})
+
+	minetest.register_craft({
+		type = "fuel",
+		recipe = "mcl_doors:"..woods[w][1],
+		burntime = 15,
+	})
+end
+
+--fence and fence gates--
+
+mcl_fences.register_fence_and_fence_gate(
+	"mangrove_wood_fence",
+	S("Mangrove Wood Fence"), S("Mangrove Wood Plank Fence"),
+	"mcl_mangrove_fence.png",
+	{handy=1,axey=1, flammable=2,fence_wood=1, fire_encouragement=5, fire_flammability=20},
+	minetest.registered_nodes["mcl_core:wood"]._mcl_hardness,
+	minetest.registered_nodes["mcl_core:wood"]._mcl_blast_resistance,
+	{"group:fence_wood"},
+	mcl_sounds.node_sound_wood_defaults(), "wild_update_mangrove_wood_fence_gate_open", "wild_update_mangrove_wood_fence_gate_close", 1, 1,
+	"mcl_mangrove_fence_gate.png")
+
+minetest.register_craft({
+		output = "wild_update:mangrove_wood_fence_gate",
+		recipe = {
+			{"mcl_core:stick", "wild_update:mangrove_wood", "mcl_core:stick"},
+			{"mcl_core:stick", "wild_update:mangrove_wood", "mcl_core:stick"},
+		}
+	})
+
+minetest.register_craft({
+		output = "wild_update:mangrove_wood_fence 3",
+		recipe = {
+			{"wild_update:mangrove_wood", "mcl_core:stick", "wild_update:mangrove_wood"},
+			{"wild_update:mangrove_wood", "mcl_core:stick", "wild_update:mangrove_wood"},
+		}
+	})
+
+minetest.register_craft({
+		output = "wild_update:wood 4",
+		recipe = {
+			{"wild_update:mangrove_tree"},
+		}
+	})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "group:fence_wood",
+	burntime = 15,
+})
+
+---stairs and slabs---
+
+local woods = {
+	{ "mangrove_wood", "mcl_mangrove_planks.png", S("Mangrove Wood Stairs"), S("Mangrove Wood Slab"), S("Double Mangrove Wood Slab") },}
+
+for w=1, #woods do
+	local wood = woods[w]
+	mcl_stairs.register_stair(wood[1], "mcl_core:"..wood[1],
+			{handy=1,axey=1, flammable=3,wood_stairs=1, material_wood=1, fire_encouragement=5, fire_flammability=20},
+			{wood[2]},
+			wood[3],
+			mcl_sounds.node_sound_wood_defaults(), 3, 2,
+			"woodlike")
+	mcl_stairs.register_slab(wood[1], "mcl_core:"..wood[1],
+			{handy=1,axey=1, flammable=3,wood_slab=1, material_wood=1, fire_encouragement=5, fire_flammability=20},
+			{wood[2]},
+			wood[4],
+			mcl_sounds.node_sound_wood_defaults(), 3, 2,
+			wood[5])
+end
+
+

entity.lua

@@ -0,0 +1,480 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
+local boat_visual_size = {x = 1, y = 1, z = 1}
+local paddling_speed = 22
+local boat_y_offset = 0.35
+local boat_y_offset_ground = boat_y_offset + 0.6
+local boat_side_offset = 1.001
+local boat_max_hp = 4
+
+local function is_group(pos, group)
+	local nn = minetest.get_node(pos).name
+	return minetest.get_item_group(nn, group) ~= 0
+end
+
+local is_water = flowlib.is_water
+
+local function is_ice(pos)
+	return is_group(pos, "ice")
+end
+
+local function get_sign(i)
+	if i == 0 then
+		return 0
+	else
+		return i / math.abs(i)
+	end
+end
+
+local function get_velocity(v, yaw, y)
+	local x = -math.sin(yaw) * v
+	local z =  math.cos(yaw) * v
+	return {x = x, y = y, z = z}
+end
+
+local function get_v(v)
+	return math.sqrt(v.x ^ 2 + v.z ^ 2)
+end
+
+local function check_object(obj)
+	return obj and (obj:is_player() or obj:get_luaentity()) and obj
+end
+
+local function get_visual_size(obj)
+	return obj:is_player() and {x = 1, y = 1, z = 1} or obj:get_luaentity()._old_visual_size or obj:get_properties().visual_size
+end
+
+local function set_attach(boat)
+	boat._driver:set_attach(boat.object, "",
+		{x = 0, y = 0.42, z = -1}, {x = 0, y = 0, z = 0})
+end
+
+local function set_double_attach(boat)
+	boat._driver:set_attach(boat.object, "",
+		{x = 0, y = 0.42, z = 0.8}, {x = 0, y = 0, z = 0})
+	boat._passenger:set_attach(boat.object, "",
+		{x = 0, y = 0.42, z = -2.2}, {x = 0, y = 0, z = 0})
+end
+
+local function attach_object(self, obj)
+	if self._driver then
+		if self._driver:is_player() then
+			self._passenger = obj
+		else
+			self._passenger = self._driver
+			self._driver = obj
+		end
+		set_double_attach(self)
+	else
+		self._driver = obj
+		set_attach(self)
+	end
+
+	local visual_size = get_visual_size(obj)
+	local yaw = self.object:get_yaw()
+	obj:set_properties({visual_size = vector.divide(visual_size, boat_visual_size)})
+
+	if obj:is_player() then
+		local name = obj:get_player_name()
+		mcl_player.player_attached[name] = true
+		minetest.after(0.2, function(name)
+			local player = minetest.get_player_by_name(name)
+			if player then
+				mcl_player.player_set_animation(player, "sit" , 30)
+			end
+		end, name)
+		obj:set_look_horizontal(yaw)
+		mcl_title.set(obj, "actionbar", {text=S("Sneak to dismount"), color="white", stay=60})
+	else
+		obj:get_luaentity()._old_visual_size = visual_size
+	end
+end
+
+local function detach_object(obj, change_pos)
+	obj:set_detach()
+	obj:set_properties({visual_size = get_visual_size(obj)})
+	if obj:is_player() then
+		mcl_player.player_attached[obj:get_player_name()] = false
+		mcl_player.player_set_animation(obj, "stand" , 30)
+	else
+		obj:get_luaentity()._old_visual_size = nil
+	end
+	if change_pos then
+		 obj:set_pos(vector.add(obj:get_pos(), vector.new(0, 0.2, 0)))
+	end
+end
+
+--
+-- Boat entity
+--
+
+local boat = {
+	physical = true,
+	-- Warning: Do not change the position of the collisionbox top surface,
+	-- lowering it causes the boat to fall through the world if underwater
+	collisionbox = {-0.5, -0.35, -0.5, 0.5, 0.3, 0.5},
+	visual = "mesh",
+	mesh = "mcl_boats_boat.b3d",
+	textures = {"mcl_boats_texture_oak_boat.png", "mcl_boats_texture_oak_boat.png", "mcl_boats_texture_oak_boat.png", "mcl_boats_texture_oak_boat.png", "mcl_boats_texture_oak_boat.png"},
+	visual_size = boat_visual_size,
+	hp_max = boat_max_hp,
+	damage_texture_modifier = "^[colorize:white:0",
+
+	_driver = nil, -- Attached driver (player) or nil if none
+	_passenger = nil,
+	_v = 0, -- Speed
+	_last_v = 0, -- Temporary speed variable
+	_removed = false, -- If true, boat entity is considered removed (e.g. after punch) and should be ignored
+	_itemstring = "mcl_boats:boat", -- Itemstring of the boat item (implies boat type)
+	_animation = 0, -- 0: not animated; 1: paddling forwards; -1: paddling forwards
+	_regen_timer = 0,
+	_damage_anim = 0,
+}
+
+minetest.register_on_respawnplayer(detach_object)
+
+function boat.on_rightclick(self, clicker)
+	if self._passenger or not clicker or clicker:get_attach() then
+		return
+	end
+	attach_object(self, clicker)
+end
+
+
+function boat.on_activate(self, staticdata, dtime_s)
+	self.object:set_armor_groups({fleshy = 100})
+	local data = minetest.deserialize(staticdata)
+	if type(data) == "table" then
+		self._v = data.v
+		self._last_v = self._v
+		self._itemstring = data.itemstring
+
+		while #data.textures < 5 do
+			table.insert(data.textures, data.textures[1])
+		end
+
+		self.object:set_properties({textures = data.textures})
+	end
+end
+
+function boat.get_staticdata(self)
+	return minetest.serialize({
+		v = self._v,
+		itemstring = self._itemstring,
+		textures = self.object:get_properties().textures
+	})
+end
+
+function boat.on_death(self, killer)
+	mcl_burning.extinguish(self.object)
+
+	if killer and killer:is_player() and minetest.is_creative_enabled(killer:get_player_name()) then
+		local inv = killer:get_inventory()
+		if not inv:contains_item("main", self._itemstring) then
+			inv:add_item("main", self._itemstring)
+		end
+	else
+		minetest.add_item(self.object:get_pos(), self._itemstring)
+	end
+	if self._driver then
+		detach_object(self._driver)
+	end
+	if self._passenger then
+		detach_object(self._passenger)
+	end
+	self._driver = nil
+	self._passenger = nil
+end
+
+function boat.on_punch(self, puncher, time_from_last_punch, tool_capabilities, dir, damage)
+	if damage > 0 then
+		self._regen_timer = 0
+	end
+end
+
+function boat.on_step(self, dtime, moveresult)
+	mcl_burning.tick(self.object, dtime, self)
+
+	self._v = get_v(self.object:get_velocity()) * get_sign(self._v)
+	local v_factor = 1
+	local v_slowdown = 0.02
+	local p = self.object:get_pos()
+	local on_water = true
+	local on_ice = false
+	local in_water = is_water({x=p.x, y=p.y-boat_y_offset+1, z=p.z})
+	local waterp = {x=p.x, y=p.y-boat_y_offset - 0.1, z=p.z}
+	if not is_water(waterp) then
+		on_water = false
+		if not in_water and is_ice(waterp) then
+			on_ice = true
+		else
+			v_slowdown = 0.04
+			v_factor = 0.5
+		end
+	elseif in_water then
+		on_water = false
+		in_water = true
+		v_factor = 0.75
+		v_slowdown = 0.05
+	end
+
+	local hp = self.object:get_hp()
+	local regen_timer = self._regen_timer + dtime
+	if hp >= boat_max_hp then
+		regen_timer = 0
+	elseif regen_timer >= 0.5 then
+		hp = hp + 1
+		self.object:set_hp(hp)
+		regen_timer = 0
+	end
+	self._regen_timer = regen_timer
+
+	if moveresult and moveresult.collides then
+		for _, collision in pairs(moveresult.collisions) do
+			local pos = collision.node_pos
+			if collision.type == "node" and minetest.get_item_group(minetest.get_node(pos).name, "dig_by_boat") > 0 then
+				minetest.dig_node(pos)
+			end
+		end
+	end
+
+	local had_passenger = self._passenger
+
+	self._driver = check_object(self._driver)
+	self._passenger = check_object(self._passenger)
+
+	if self._passenger then
+		if not self._driver then
+			self._driver = self._passenger
+			self._passenger = nil
+		else
+			local ctrl = self._passenger:get_player_control()
+			if ctrl and ctrl.sneak then
+				detach_object(self._passenger, true)
+				self._passenger = nil
+			end
+		end
+	end
+
+	if self._driver then
+		if had_passenger and not self._passenger then
+			set_attach(self)
+		end
+		local ctrl = self._driver:get_player_control()
+		if ctrl and ctrl.sneak then
+			detach_object(self._driver, true)
+			self._driver = nil
+			return
+		end
+		local yaw = self.object:get_yaw()
+		if ctrl and ctrl.up then
+			-- Forwards
+			self._v = self._v + 0.1 * v_factor
+
+			-- Paddling animation
+			if self._animation ~= 1 then
+				self.object:set_animation({x=0, y=40}, paddling_speed, 0, true)
+				self._animation = 1
+			end
+		elseif ctrl and ctrl.down then
+			-- Backwards
+			self._v = self._v - 0.1 * v_factor
+
+			-- Paddling animation, reversed
+			if self._animation ~= -1 then
+				self.object:set_animation({x=0, y=40}, -paddling_speed, 0, true)
+				self._animation = -1
+			end
+		else
+			-- Stop paddling animation if no control pressed
+			if self._animation ~= 0 then
+				self.object:set_animation({x=0, y=40}, 0, 0, true)
+				self._animation = 0
+			end
+		end
+		if ctrl and ctrl.left then
+			if self._v < 0 then
+				self.object:set_yaw(yaw - (1 + dtime) * 0.03 * v_factor)
+			else
+				self.object:set_yaw(yaw + (1 + dtime) * 0.03 * v_factor)
+			end
+		elseif ctrl and ctrl.right then
+			if self._v < 0 then
+				self.object:set_yaw(yaw + (1 + dtime) * 0.03 * v_factor)
+			else
+				self.object:set_yaw(yaw - (1 + dtime) * 0.03 * v_factor)
+			end
+		end
+	else
+		-- Stop paddling without driver
+		if self._animation ~= 0 then
+			self.object:set_animation({x=0, y=40}, 0, 0, true)
+			self._animation = 0
+		end
+
+		for _, obj in pairs(minetest.get_objects_inside_radius(self.object:get_pos(), 1.3)) do
+			local entity = obj:get_luaentity()
+			if entity and entity._cmi_is_mob then
+				attach_object(self, obj)
+				break
+			end
+		end
+	end
+	local s = get_sign(self._v)
+	if not on_ice and not on_water and not in_water and math.abs(self._v) > 2.0 then
+		v_slowdown = math.min(math.abs(self._v) - 2.0, v_slowdown * 5)
+	elseif not on_ice and in_water and math.abs(self._v) > 1.5 then
+		v_slowdown = math.min(math.abs(self._v) - 1.5, v_slowdown * 5)
+	end
+	self._v = self._v - v_slowdown * s
+	if s ~= get_sign(self._v) then
+		self._v = 0
+	end
+
+	p.y = p.y - boat_y_offset
+	local new_velo
+	local new_acce
+	if not is_water(p) and not on_ice then
+		-- Not on water or inside water: Free fall
+		--local nodedef = minetest.registered_nodes[minetest.get_node(p).name]
+		new_acce = {x = 0, y = -9.8, z = 0}
+		new_velo = get_velocity(self._v, self.object:get_yaw(),
+			self.object:get_velocity().y)
+	else
+		p.y = p.y + 1
+		local is_obsidian_boat = self.object:get_luaentity()._itemstring == "mcl_boats:boat_obsidian"
+		if is_water(p) or is_obsidian_boat then
+			-- Inside water: Slowly sink
+			local y = self.object:get_velocity().y
+			y = y - 0.01
+			if y < -0.2 then
+				y = -0.2
+			end
+			new_acce = {x = 0, y = 0, z = 0}
+			new_velo = get_velocity(self._v, self.object:get_yaw(), y)
+		else
+			-- On top of water
+			new_acce = {x = 0, y = 0, z = 0}
+			if math.abs(self.object:get_velocity().y) < 0 then
+				new_velo = get_velocity(self._v, self.object:get_yaw(), 0)
+			else
+				new_velo = get_velocity(self._v, self.object:get_yaw(),
+					self.object:get_velocity().y)
+			end
+		end
+	end
+
+	-- Terminal velocity: 8 m/s per axis of travel
+	local terminal_velocity = on_ice and 57.1 or 8.0
+	for _,axis in pairs({"z","y","x"}) do
+		if math.abs(new_velo[axis]) > terminal_velocity then
+			new_velo[axis] = terminal_velocity * get_sign(new_velo[axis])
+		end
+	end
+
+	local yaw = self.object:get_yaw()
+	local anim = (boat_max_hp - hp - regen_timer * 2) / boat_max_hp * math.pi / 4
+
+	self.object:set_rotation(vector.new(anim, yaw, anim))
+	self.object:set_velocity(new_velo)
+	self.object:set_acceleration(new_acce)
+end
+
+-----------
+minetest.register_entity("wild_update:boat", boat)
+
+local boat_ids = { "boat", "boat_mangrove" }
+local names = { S("Mangrove Boat") }
+local craftstuffs = {"wild_update:mangrove_wood"}
+
+
+for b=1, #boat_ids do
+	local itemstring = "wild_update:"..boat_ids[b]
+
+	local longdesc, usagehelp, tt_help, help, helpname
+	help = false
+	-- Only create one help entry for all boats
+	if b == 1 then
+		help = true
+		longdesc = S("Boats are used to travel on the surface of water.")
+		usagehelp = S("Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Use [Sneak] to leave the boat, punch the boat to make it drop as an item.")
+		helpname = S("Boat")
+	end
+	tt_help = S("Water vehicle")
+
+	minetest.register_craftitem(itemstring, {
+		description = names[b],
+		_tt_help = tt_help,
+		_doc_items_create_entry = help,
+		_doc_items_entry_name = helpname,
+		_doc_items_longdesc = longdesc,
+		_doc_items_usagehelp = usagehelp,
+		inventory_image = "mcl_boats_mangrove_boat.png",
+		liquids_pointable = true,
+		groups = { boat = 1, transport = 1},
+		stack_max = 1,
+		on_place = function(itemstack, placer, pointed_thing)
+			if pointed_thing.type ~= "node" then
+				return itemstack
+			end
+
+			-- Call on_rightclick if the pointed node defines it
+			local node = minetest.get_node(pointed_thing.under)
+			if placer and not placer:get_player_control().sneak then
+				if minetest.registered_nodes[node.name] and minetest.registered_nodes[node.name].on_rightclick then
+					return minetest.registered_nodes[node.name].on_rightclick(pointed_thing.under, node, placer, itemstack) or itemstack
+				end
+			end
+
+			local pos = table.copy(pointed_thing.under)
+			local dir = vector.subtract(pointed_thing.above, pointed_thing.under)
+
+			if math.abs(dir.x) > 0.9 or math.abs(dir.z) > 0.9 then
+				pos = vector.add(pos, vector.multiply(dir, boat_side_offset))
+			elseif is_water(pos) then
+				pos = vector.add(pos, vector.multiply(dir, boat_y_offset))
+			else
+				pos = vector.add(pos, vector.multiply(dir, boat_y_offset_ground))
+			end
+			local boat = minetest.add_entity(pos, "wild_update:boat")
+			local texture = "mcl_boats_texture_mangrove_boat.png"
+			boat:get_luaentity()._itemstring = itemstring
+			boat:set_properties({textures = { texture, texture, texture, texture, texture }})
+			boat:set_yaw(placer:get_look_horizontal())
+			if not minetest.is_creative_enabled(placer:get_player_name()) then
+				itemstack:take_item()
+			end
+			return itemstack
+		end,
+		_on_dispense = function(stack, pos, droppos, dropnode, dropdir)
+			local below = {x=droppos.x, y=droppos.y-1, z=droppos.z}
+			local belownode = minetest.get_node(below)
+			-- Place boat as entity on or in water
+			if minetest.get_item_group(dropnode.name, "water") ~= 0 or (dropnode.name == "air" and minetest.get_item_group(belownode.name, "water") ~= 0) then
+				minetest.add_entity(droppos, "wild_update:boat")
+			else
+				minetest.add_item(droppos, stack)
+			end
+		end,
+	})
+
+end
+
+	local c = craftstuffs[b]
+	minetest.register_craft({
+		output = "wild_update:boat",
+		recipe = {
+			{"wild_update:mangrove_wood", "", "wild_update:mangrove_wood"},
+			{"wild_update:mangrove_wood", "wild_update:mangrove_wood", "wild_update:mangrove_wood"},
+		},
+	})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "group:boat",
+	burntime = 20,
+})
+
+if minetest.get_modpath("doc_identifier") then
+	doc.sub.identifier.register_object("wild_update:boat", "craftitems", "wild_update:boat")
+end

init.lua

@@ -0,0 +1,7 @@
+local modpath = minetest.get_modpath("wild_update")
+
+-- Load files
+
+dofile(modpath .. "/blocks.lua")
+dofile(modpath .. "/entity.lua")
+--dofile(modpath .. "/item.lua")--