function spears_throw (itemstack, player, pointed_thing)
	local spear = itemstack:get_name() .. '_entity'
	local player_pos = player:get_pos()
	local head_pos = vector.new(player_pos.x, player_pos.y + player:get_properties().eye_height, player_pos.z)
	local direction = player:get_look_dir()
	local throw_pos = vector.add(head_pos, vector.multiply(direction,0.5))
	local pitch = player:get_look_vertical()
	local yaw = player:get_look_horizontal()
	local rotation = vector.new(0, yaw + math.pi/2, pitch + math.pi/6)
	-- Plant into node
	if pointed_thing.type == "node" then
		local node = minetest.get_node(pointed_thing.under)
		if minetest.registered_nodes[node.name].walkable and vector.distance(pointed_thing.above, throw_pos) < 1 then
			local spear_object = minetest.add_entity(vector.divide(vector.add(vector.multiply(pointed_thing.above, 2), pointed_thing.under), 3), spear)
			spear_object:set_rotation(rotation)
			spear_object:get_luaentity()._wear = itemstack:get_wear()
			spear_object:get_luaentity()._stickpos = pointed_thing.under
			return
		end
	end
	-- Avoid hitting yourself and throw
	local throw_speed = 12
	while vector.distance(player_pos, throw_pos) < 1.2 do
		throw_pos = vector.add(throw_pos, vector.multiply(direction, 0.1))
	end
	local player_vel
	if player.is_fake_player then
		player_vel = {x=0,y=0,z=0}
	else
		player_vel = player:get_velocity()
	end
	local spear_object = minetest.add_entity(throw_pos, spear)
	spear_object:set_velocity(vector.add(player_vel, vector.multiply(direction, throw_speed)))
	spear_object:set_rotation(rotation)
	minetest.sound_play("spears_throw", {pos = player_pos}, true)
	spear_object:get_luaentity()._wear = itemstack:get_wear()
	spear_object:get_luaentity().lastpos = throw_pos
	spear_object:get_luaentity()._stickpos = nil
	return true
end

function spears_set_entity(spear_type, base_damage, toughness)
	local SPEAR_ENTITY={
		initial_properties = {
			physical = false,
			visual = "item",
			visual_size = {x = 0.3, y = 0.3, z = 0.3},
			wield_item = "spears:spear_" .. spear_type,
			collisionbox = {-0.3, -0.3, -0.3, 0.3, 0.3, 0.3},
			lastpos={},
		},

		on_activate = function (self, staticdata, dtime_s)
			self.object:set_armor_groups({immortal = 1})
		end,
		
		on_punch = function (self, puncher)
			if puncher:is_player() then -- Grab the spear
				local stack = {name='spears:spear_' .. spear_type, wear = self._wear}
				local inv = puncher:get_inventory()
				if inv:room_for_item("main", stack) then
					inv:add_item("main", stack)
					self.object:remove()
				end
			end
		end,

		on_step = function(self, dtime)
			if not self._wear then
				self.object:remove()
				return
			end
			local velocity = self.object:get_velocity()
			local speed = vector.length(velocity)
			-- Spear is stuck ?
			if self._stickpos then
				local node = minetest.get_node(self._stickpos)
				local node_cracky = minetest.registered_nodes[node.name].groups.cracky
				local pos = self.object:get_pos()
				if node_cracky and node_cracky < 3 then
					minetest.sound_play("default_metal_footstep", {pos = pos}, true)
					self.object:remove()
					minetest.add_item(pos, {name='spears:spear_' .. spear_type, wear = self._wear})
				elseif not self._node_walkable then
					minetest.sound_play("default_place_node", {pos = self._stickpos}, true)
				end
				self._node_walkable = minetest.registered_nodes[node.name].walkable			
				if not node or not self._node_walkable then -- Fall when node is removed
					self.object:remove()
					minetest.add_item(pos, {name='spears:spear_' .. spear_type, wear = self._wear})
					return
				end
			else -- Spear is flying
				local newpos = self.object:get_pos()
				for _, pos in pairs(spears_get_trajectoire(self, newpos)) do
					local direction = vector.normalize(velocity)
					local yaw = minetest.dir_to_yaw(direction)
					local pitch = math.acos(velocity.y/speed) - math.pi/3
					local spearhead_pos = vector.add(pos, vector.multiply(direction, 0.5))
					local node = minetest.get_node(spearhead_pos)
					self.object:set_rotation({x = 0, y = yaw + math.pi/2, z = pitch})
					-- Hit someone?
					local objects_in_radius = minetest.get_objects_inside_radius(spearhead_pos, 2.5)
					for _,object in ipairs(objects_in_radius) do
						if object:get_luaentity() ~= self and object:get_armor_groups().fleshy then
							local objpos = object:get_pos()
							local collisionbox = object:get_properties().collisionbox or {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5}
							if spears_touch(spearhead_pos, objpos, collisionbox) then
								local damage = (speed + base_damage)^1.15 - 20
								object:punch(self.object, 1.0, {full_punch_interval = 1.0, damage_groups = {fleshy=damage},}, direction)
								self.object:remove()
								minetest.sound_play("spears_hit", {pos = pos}, true)
								minetest.add_item(pos, {name='spears:spear_' .. spear_type, wear = self._wear + 65535/toughness})
								return
							end
						end
					end
					-- Hit a node?	
					if node and minetest.registered_nodes[node.name].walkable
					and not minetest.registered_nodes[node.name].buildable_to
					and not (minetest.registered_nodes[node.name].groups.slab and spearhead_pos.y % 1 < 0.5)
					then -- Stick
						self.object:set_acceleration({x = 0, y = 0, z = 0})
						self.object:set_velocity({x = 0, y = 0, z = 0})
						self._wear = self._wear + 65535/toughness
						if self._wear >= 65535 then
							minetest.sound_play("default_tool_breaks", {pos = pos}, true)
							self.object:remove()
							return
						end
						self._stickpos = spearhead_pos
						self.lastpos = pos
						return
					else  -- Get drag
						local drag = math.max(minetest.registered_nodes[node.name].liquid_viscosity, 0.1)
						local acceleration = vector.multiply(velocity, -drag)
						acceleration.y = acceleration.y - 10 * ((7 - drag) / 7)
						self.object:set_acceleration(acceleration)
					end
				end
				self.lastpos = newpos
			end
		end,
	}
	return SPEAR_ENTITY
end


function spears_get_trajectoire(self, newpos)
	if self.lastpos.x == nil then
		return {newpos}
	end
	local coord = {}
	local dx = vector.distance({x=newpos["x"], y=0, z=0}, {x=self.lastpos["x"], y=0, z=0} )/2
	local dy = vector.distance({x=0, y=newpos["y"], z=0}, {x=0, y=self.lastpos["y"], z=0} )/2
	local dz = vector.distance({x=0, y=0, z=newpos["z"]}, {x=0, y=0, z=self.lastpos["z"]} )/2

	if newpos["x"] < self.lastpos["x"] then
		dx = -dx
	end
	if newpos["y"] < self.lastpos["y"] then
		dy = -dy
	end
	if newpos["z"] < self.lastpos["z"] then
		dz = -dz
	end
	table.insert(coord, {x=self.lastpos["x"]+dx, y=self.lastpos["y"]+dy ,z=self.lastpos["z"]+dz })
	table.insert(coord, newpos)
	return coord
end


function spears_touch(pos, objpos, cbox)
	--colbox format {x1, y1, z1, x2, y2, z2}
	if (pos.x < objpos.x + math.max(cbox[1], cbox[4]) and pos.x > objpos.x + math.min(cbox[1], cbox[4])) 
		and (pos.y < objpos.y + math.max(cbox[2], cbox[5]) and pos.y > objpos.y + math.min(cbox[2], cbox[5])) 
		and (pos.z < objpos.z + math.max(cbox[3], cbox[6]) and pos.z > objpos.z + math.min(cbox[3], cbox[6])) then
		return true
	end
	return false
end