Merge pull request 'Revert mob rewrite' (#1992) from revert-to-oldmobs into master

Reviewed-on: https://git.minetest.land/MineClone2/MineClone2/pulls/1992

mods/ENTITIES/mcl_mobs/api.txt

@@ -502,6 +502,20 @@ and damages any entity caught inside the blast radius.  Protection will limit
 node destruction but not entity damage.
 
 
+mobs:capture_mob
+----------------
+
+mobs:capture_mob(...)
+
+Does nothing and returns false.
+
+This function is provided for compability with Mobs Redo for an attempt to
+capture a mob.
+Mobs cannot be captured in MineClone 2.
+
+In Mobs Redo, this is generally called inside the on_rightclick section of the mob
+api code, it provides a chance of capturing the mob. See Mobs Redo documentation
+of parameters.
 
 Feeding and Taming/Breeding
 ---------------------------
@@ -521,6 +535,19 @@ Will return true when mob is fed with item it likes.
                 them up
 
 
+Protecting Mobs
+---------------
+
+mobs:protect(self, clicker)
+
+This function can be used to right-click any tamed mob with mobs:protector item,
+this will protect the mob from harm inside of a protected area from other
+players.  Will return true when mob right-clicked with mobs:protector item.
+
+   'self'    mob information
+   'clicker' player information
+
+
 Riding Mobs
 -----------
 
@@ -578,7 +605,7 @@ Note: animation names above are from the pre-defined animation lists inside mob
 registry without extensions.
 
 
-mobs.set_mob_animation(self, name)
+mobs:set_animation(self, name)
 
 This function sets the current animation for mob, defaulting to "stand" if not
 found.
@@ -754,5 +781,8 @@ mobs:register_mob("mob_horse:horse", {
 				inv:remove_item("main", "mobs:saddle")
 			end
 		end
+
+		-- used to capture horse with magic lasso
+		mobs:capture_mob(self, clicker, 0, 0, 80, false, nil)
 	end
 })

mods/ENTITIES/mcl_mobs/api/api.lua

@@ -1,736 +0,0 @@
--- API for Mobs Redo: MineClone 2 Delux 2.0 DRM Free Early Access Super Extreme Edition
-
--- mobs library
-mobs = {}
-
--- lua locals - can grab from this to easily plop them into the api lua files
-
---localize minetest functions
-local minetest_settings                     = minetest.settings
-local minetest_get_objects_inside_radius    = minetest.get_objects_inside_radius
-local minetest_get_modpath                  = minetest.get_modpath
-local minetest_registered_nodes             = minetest.registered_nodes
-local minetest_get_node                     = minetest.get_node
---local minetest_get_item_group               = minetest.get_item_group
-local minetest_registered_entities          = minetest.registered_entities
---local minetest_line_of_sight                = minetest.line_of_sight
---local minetest_after                        = minetest.after
---local minetest_sound_play                   = minetest.sound_play
---local minetest_add_particlespawner          = minetest.add_particlespawner
---local minetest_registered_items             = minetest.registered_items
---local minetest_set_node                     = minetest.set_node
-local minetest_add_item                     = minetest.add_item
---local minetest_get_craft_result             = minetest.get_craft_result
---local minetest_find_path                    = minetest.find_path
-local minetest_is_creative_enabled          = minetest.is_creative_enabled
---local minetest_find_node_near               = minetest.find_node_near
---local minetest_find_nodes_in_area_under_air = minetest.find_nodes_in_area_under_air
---local minetest_raycast                      = minetest.raycast
---local minetest_get_us_time                  = minetest.get_us_time
-local minetest_add_entity                   = minetest.add_entity
---local minetest_get_natural_light            = minetest.get_natural_light
---local minetest_get_node_or_nil              = minetest.get_node_or_nil
-
--- localize math functions
-local math = math
-
--- localize vector functions
-local vector = vector
-
-local string = string
-
--- mob constants
---local BREED_TIME          = 30
---local BREED_TIME_AGAIN    = 300
---local CHILD_GROW_TIME     = 60*20
---local DEATH_DELAY         = 0.5
-local DEFAULT_FALL_SPEED  = -10
---local FLOP_HEIGHT         = 5.0
---local FLOP_HOR_SPEED      = 1.5
-local GRAVITY             = minetest_settings:get("movement_gravity")-- + 9.81
-
-local MAX_MOB_NAME_LENGTH = 30
-
-
---[[local MOB_CAP   = {}
-MOB_CAP.hostile = 70
-MOB_CAP.passive = 10
-MOB_CAP.ambient = 15
-MOB_CAP.water   = 15
-]]
-
--- Load main settings
---local damage_enabled    = minetest_settings:get_bool("enable_damage")
---local disable_blood     = minetest_settings:get_bool("mobs_disable_blood")
---local mobs_drop_items   = minetest_settings:get_bool("mobs_drop_items") ~= false
---local mobs_griefing     = minetest_settings:get_bool("mobs_griefing") ~= false
---local spawn_protected   = minetest_settings:get_bool("mobs_spawn_protected") ~= false
---local remove_far        = true
-local difficulty        = tonumber(minetest_settings:get("mob_difficulty")) or 1.0
---local show_health       = false
---local max_per_block     = tonumber(minetest_settings:get("max_objects_per_block") or 64)
----local mobs_spawn_chance = tonumber(minetest_settings:get("mobs_spawn_chance") or 2.5)
-
--- pathfinding settings
---local enable_pathfinding = true
---local stuck_timeout      = 3 -- how long before mob gets stuck in place and starts searching
---local stuck_path_timeout = 10 -- how long will mob follow path before giving up
-
--- default nodes
---local node_ice       = "mcl_core:ice"
---local node_snowblock = "mcl_core:snowblock"
---local node_snow      = "mcl_core:snow"
-mobs.fallback_node   = minetest.registered_aliases["mapgen_dirt"] or "mcl_core:dirt"
-
---local mod_weather     = minetest_get_modpath("mcl_weather")
---local mod_explosions  = minetest_get_modpath("mcl_explosions")
-local mod_mobspawners = minetest_get_modpath("mcl_mobspawners")
---local mod_hunger      = minetest_get_modpath("mcl_hunger")
---local mod_worlds      = minetest_get_modpath("mcl_worlds")
---local mod_armor       = minetest_get_modpath("mcl_armor")
---local mod_experience  = minetest_get_modpath("mcl_experience")
-
-
--- random locals I found
---local los_switcher    = false
---local height_switcher = false
-
--- Get translator
-local S = minetest.get_translator(minetest.get_current_modname())
-
--- CMI support check
---local use_cmi = minetest.global_exists("cmi")
-
--- creative check
-function mobs.is_creative(name)
-	return minetest_is_creative_enabled(name)
-end
-
---[[local function atan(x)
-	if not x or x ~= x then
-		return 0
-	else
-		return math.atan(x)
-	end
-end]]
-
--- Shows helpful debug info above each mob
---local mobs_debug = minetest_settings:get_bool("mobs_debug", false)
-
--- Peaceful mode message so players will know there are no monsters
-if minetest_settings:get_bool("only_peaceful_mobs", false) then
-	minetest.register_on_joinplayer(function(player)
-		minetest.chat_send_player(player:get_player_name(),
-			S("Peaceful mode active! No monsters will spawn."))
-	end)
-end
-
-
-local api_path = minetest.get_modpath(minetest.get_current_modname()).."/api/mob_functions/"
-
---ignite all parts of the api
-dofile(api_path .. "flow_lib.lua")
-dofile(api_path .. "ai.lua")
-dofile(api_path .. "animation.lua")
-dofile(api_path .. "collision.lua")
-dofile(api_path .. "environment.lua")
-dofile(api_path .. "interaction.lua")
-dofile(api_path .. "movement.lua")
-dofile(api_path .. "set_up.lua")
-dofile(api_path .. "attack_type_instructions.lua")
-dofile(api_path .. "sound_handling.lua")
-dofile(api_path .. "death_logic.lua")
-dofile(api_path .. "mob_effects.lua")
-dofile(api_path .. "projectile_handling.lua")
-dofile(api_path .. "breeding.lua")
-dofile(api_path .. "head_logic.lua")
-
-
-mobs.spawning_mobs = {}
-
-
-
-
--- register mob entity
-function mobs:register_mob(name, def)
-
-	local collisionbox = def.collisionbox or {-0.25, -0.25, -0.25, 0.25, 0.25, 0.25}
-
-	-- Workaround for <https://github.com/minetest/minetest/issues/5966>:
-	-- Increase upper Y limit to avoid mobs glitching through solid nodes.
-	-- FIXME: Remove workaround if it's no longer needed.
-
-	if collisionbox[5] < 0.79 then
-		collisionbox[5] = 0.79
-	end
-
-	mobs.spawning_mobs[name] = true
-
-	local function scale_difficulty(value, default, min, special)
-		if (not value) or (value == default) or (value == special) then
-			return default
-		else
-			return math.max(min, value * difficulty)
-		end
-	end
-
-	minetest.register_entity(name, {
-		description = def.description,
-		use_texture_alpha = def.use_texture_alpha,
-		stepheight = def.stepheight or 0.6,
-		stepheight_backup = def.stepheight or 0.6,
-		name = name,
-		type = def.type,
-		attack_type = def.attack_type,
-		fly = def.fly,
-		fly_in = def.fly_in or {"air", "__airlike"},
-		owner = def.owner or "",
-		order = def.order or "",
-		on_die = def.on_die,
-		spawn_small_alternative = def.spawn_small_alternative,
-		do_custom = def.do_custom,
-		jump_height = def.jump_height or 4, -- was 6
-		rotate = def.rotate or 0, --  0=front, 90=side, 180=back, 270=side2
-		hp_min = scale_difficulty(def.hp_min, 5, 1),
-		hp_max = scale_difficulty(def.hp_max, 10, 1),
-		xp_min = def.xp_min or 1,
-		xp_max = def.xp_max or 5,
-		breath_max = def.breath_max or 6,
-		breathes_in_water = def.breathes_in_water or false,
-		physical = true,
-		collisionbox = collisionbox,
-		collide_with_objects = def.collide_with_objects or false,
-		selectionbox = def.selectionbox or def.collisionbox,
-		visual = def.visual,
-		visual_size = def.visual_size or {x = 1, y = 1},
-		mesh = def.mesh,
-		makes_footstep_sound = def.makes_footstep_sound or false,
-		view_range = def.view_range or 16,
-		walk_velocity = def.walk_velocity or 1,
-		run_velocity = def.run_velocity or 2,
-		damage = scale_difficulty(def.damage, 0, 0),
-		light_damage = def.light_damage or 0,
-		sunlight_damage = def.sunlight_damage or 0,
-		water_damage = def.water_damage or 0,
-		lava_damage = def.lava_damage or 8,
-		fire_damage = def.fire_damage or 1,
-		suffocation = def.suffocation or true,
-		fall_damage = def.fall_damage or 1,
-		fall_speed = def.fall_speed or DEFAULT_FALL_SPEED, -- must be lower than -2
-		drops = def.drops or {},
-		armor = def.armor or 100,
-		on_rightclick = mobs.create_mob_on_rightclick(def.on_rightclick),
-		arrow = def.arrow,
-		shoot_interval = def.shoot_interval,
-		sounds = def.sounds or {},
-		animation = def.animation,
-		jump = def.jump ~= false,
-		walk_chance = def.walk_chance or 50,
-		attacks_monsters = def.attacks_monsters or false,
-		group_attack = def.group_attack or false,
-		passive = def.passive or false,
-		knock_back = def.knock_back ~= false,
-		shoot_offset = def.shoot_offset or 0,
-		floats = def.floats or 1, -- floats in water by default
-		floats_on_lava = def.floats_on_lava or 0,
-		replace_rate = def.replace_rate,
-		replace_what = def.replace_what,
-		replace_with = def.replace_with,
-		replace_offset = def.replace_offset or 0,
-		on_replace = def.on_replace,
-		timer = 0,
-		state_timer = 0,
-		env_damage_timer = 0,
-		tamed = false,
-		pause_timer = 0,
-		gotten = false,
-		reach = def.reach or 3,
-		htimer = 0,
-		texture_list = def.textures,
-		child_texture = def.child_texture,
-		docile_by_day = def.docile_by_day or false,
-		time_of_day = 0.5,
-		fear_height = def.fear_height or 0,
-		runaway = def.runaway,
-		runaway_timer = 0,
-		pathfinding = def.pathfinding,
-		immune_to = def.immune_to or {},
-		explosion_radius = def.explosion_radius, -- LEGACY
-		explosion_damage_radius = def.explosion_damage_radius, -- LEGACY
-		explosiontimer_reset_radius = def.explosiontimer_reset_radius,
-		explosion_timer = def.explosion_timer or 3,
-		allow_fuse_reset = def.allow_fuse_reset ~= false,
-		stop_to_explode = def.stop_to_explode ~= false,
-		custom_attack = def.custom_attack,
-		double_melee_attack = def.double_melee_attack,
-		dogshoot_switch = def.dogshoot_switch,
-		dogshoot_count = 0,
-		dogshoot_count_max = def.dogshoot_count_max or 5,
-		dogshoot_count2_max = def.dogshoot_count2_max or (def.dogshoot_count_max or 5),
-		attack_animals = def.attack_animals or false,
-		specific_attack = def.specific_attack,
-		runaway_from = def.runaway_from,
-		owner_loyal = def.owner_loyal,
-		facing_fence = false,
-
-		_cmi_is_mob = true,
-
-		pushable = def.pushable or true,
-
-		--j4i stuff
-		yaw = 0,
-		automatic_face_movement_dir = def.rotate or 0,  --  0=front, 90=side, 180=back, 270=side2
-		automatic_face_movement_max_rotation_per_sec = 360, --degrees
-		backface_culling = true,
-		walk_timer = 0,
-		stand_timer = 0,
-		current_animation = "",
-		gravity = GRAVITY,
-		swim = def.swim,
-		swim_in = def.swim_in or {mobs_mc.items.water_source, "mcl_core:water_flowing", mobs_mc.items.river_water_source},
-		pitch_switch = "static",
-		jump_only = def.jump_only,
-		hostile = def.hostile,
-		neutral = def.neutral,
-		attacking = nil,
-		visual_size_origin = def.visual_size or {x = 1, y = 1, z = 1},
-		punch_timer_cooloff = def.punch_timer_cooloff or 0.5,
-		death_animation_timer = 0,
-		hostile_cooldown = def.hostile_cooldown or 15,
-		tilt_fly = def.tilt_fly,
-		tilt_swim = def.tilt_swim,
-		fall_slow = def.fall_slow,
-		projectile_cooldown_min = def.projectile_cooldown_min or 2,
-		projectile_cooldown_max = def.projectile_cooldown_max or 6,
-		skittish = def.skittish,
-
-		minimum_follow_distance = def.minimum_follow_distance or 0.5, --make mobs not freak out when underneath
-
-		memory = 0, -- memory timer if chasing/following
-		fly_random_while_attack = def.fly_random_while_attack,
-
-		--for spiders
-		always_climb = def.always_climb,
-
-		--despawn mechanic variables
-		lifetimer_reset = 30, --30 seconds
-		lifetimer = 30, --30 seconds
-
-		--breeding stuff
-		breed_timer = 0,
-		breed_lookout_timer = 0,
-		breed_distance = def.breed_distance or 1.5, --how far away mobs have to be to begin actual breeding
-		breed_lookout_timer_goal = 30, --30 seconds (this timer is for how long the mob looks for a mate)
-		breed_timer_cooloff = 5*60, -- 5 minutes (this timer is for how long the mob has to wait before being bred again)
-		bred = false,
-		follow = def.follow, --this item is also used for the breeding mechanism
-		follow_distance = def.follow_distance or 2,
-		baby_size = def.baby_size or 0.5,
-		baby = false,
-		grow_up_timer = 0,
-		grow_up_goal  = 20*60, --in 20 minutes the mob grows up
-		special_breed_timer = 0, --this is used for the AHEM AHEM part of breeding
-
-		backup_visual_size = def.visual_size,
-		backup_collisionbox = collisionbox,
-		backup_selectionbox = def.selectionbox or def.collisionbox,
-
-
-		--fire timer
-		burn_timer = 0,
-
-		ignores_cobwebs = def.ignores_cobwebs,
-		breath = def.breath_max or 6,
-
-		random_sound_timer_min = 3,
-		random_sound_timer_max = 10,
-
-		--head code variables
-		--defaults are for the cow's default
-		--because I don't know what else to set them
-		--to :P
-
-		--you must use these to adjust the mob's head positions
-
-		--has_head is used as a logic gate (quick easy check)
-		has_head = def.has_head or false,
-		--head_bone is the actual bone in the model which the head
-		--is attached to for animation
-		head_bone = def.head_bone or "head",
-
-		--this part controls the base position of the head calculations
-		--localized to the mob's visual yaw when gotten (self.object:get_yaw())
-		--you can enable the debug in /mob_functions/head_logic.lua by uncommenting the
-		--particle spawner code
-		head_height_offset =  def.head_height_offset or 1.0525,
-		head_direction_offset = def.head_direction_offset or 0.5,
-
-		--this part controls the visual of the head
-		head_bone_pos_y = def.head_bone_pos_y or 3.6,
-		head_bone_pos_z = def.head_bone_pos_z or -0.6,
-		head_pitch_modifier = def.head_pitch_modifier or 0,
-
-		--these variables are switches in case the model
-		--moves the wrong way
-		swap_y_with_x = def.swap_y_with_x or false,
-		reverse_head_yaw = def.reverse_head_yaw or false,
-
-		--END HEAD CODE VARIABLES
-
-		--end j4i stuff
-
-		-- MCL2 extensions
-		teleport = mobs.teleport,
-		do_teleport = def.do_teleport,
-		spawn_class = def.spawn_class,
-		ignores_nametag = def.ignores_nametag or false,
-		rain_damage = def.rain_damage or 0,
-		glow = def.glow,
-		--can_despawn = can_despawn,
-		child = def.child or false,
-		texture_mods = {},
-		shoot_arrow = def.shoot_arrow,
-		sounds_child = def.sounds_child,
-		explosion_strength = def.explosion_strength,
-		suffocation_timer = 0,
-		follow_velocity = def.follow_velocity or 2.4,
-		instant_death = def.instant_death or false,
-		fire_resistant = def.fire_resistant or false,
-		fire_damage_resistant = def.fire_damage_resistant or false,
-		ignited_by_sunlight = def.ignited_by_sunlight or false,
-		eye_height = def.eye_height or 1.5,
-		defuse_reach = def.defuse_reach or 4,
-		-- End of MCL2 extensions
-
-		on_spawn = def.on_spawn,
-
-		--on_blast = def.on_blast or do_tnt,
-
-		on_step  = mobs.mob_step,
-
-		--do_punch = def.do_punch,
-
-		on_punch = mobs.mob_punch,
-
-		--on_breed = def.on_breed,
-
-		--on_grown = def.on_grown,
-
-		--on_detach_child = mob_detach_child,
-
-		on_activate = function(self, staticdata, dtime)
-			self.object:set_acceleration(vector.new(0,-GRAVITY, 0))
-			return mobs.mob_activate(self, staticdata, def, dtime)
-		end,
-
-		get_staticdata = function(self)
-			return mobs.mob_staticdata(self)
-		end,
-
-		--harmed_by_heal = def.harmed_by_heal,
-	})
-
-	if minetest_get_modpath("doc_identifier") then
-		doc.sub.identifier.register_object(name, "basics", "mobs")
-	end
-
-end -- END mobs:register_mob function
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
--- register arrow for shoot attack
-function mobs:register_arrow(name, def)
-
-	-- errorcheck
-	if not name or not def then
-		print("failed to register arrow entity")
-		return
-	end
-
-	minetest.register_entity(name.."_entity", {
-
-		physical = false,
-		visual = def.visual,
-		visual_size = def.visual_size,
-		textures = def.textures,
-		velocity = def.velocity,
-		hit_player = def.hit_player,
-		hit_node = def.hit_node,
-		hit_mob = def.hit_mob,
-		hit_object = def.hit_object,
-		drop = def.drop or false, -- drops arrow as registered item when true
-		collisionbox = {0, 0, 0, 0, 0, 0}, -- remove box around arrows
-		timer = 0,
-		switch = 0,
-		owner_id = def.owner_id,
-		rotate = def.rotate,
-		speed = def.speed or nil,
-		on_step = function(self)
-
-			local vel = self.object:get_velocity()
-
-			local pos = self.object:get_pos()
-
-			if self.timer > 150
-			or not mobs.within_limits(pos, 0) then
-				mcl_burning.extinguish(self.object)
-				self.object:remove();
-				return
-			end
-
-			-- does arrow have a tail (fireball)
-			if def.tail
-			and def.tail == 1
-			and def.tail_texture then
-
-				--do this to prevent clipping through main entity sprite
-				local pos_adjustment = vector.multiply(vector.normalize(vel), -1)
-				local divider = def.tail_distance_divider or 1
-				pos_adjustment = vector.divide(pos_adjustment, divider)
-				local new_pos = vector.add(pos, pos_adjustment)
-				minetest.add_particle({
-					pos = new_pos,
-					velocity = {x = 0, y = 0, z = 0},
-					acceleration = {x = 0, y = 0, z = 0},
-					expirationtime = def.expire or 0.25,
-					collisiondetection = false,
-					texture = def.tail_texture,
-					size = def.tail_size or 5,
-					glow = def.glow or 0,
-				})
-			end
-
-			if self.hit_node then
-
-				local node = minetest_get_node(pos).name
-
-				if minetest_registered_nodes[node].walkable then
-
-					self.hit_node(self, pos, node)
-
-					if self.drop == true then
-
-						pos.y = pos.y + 1
-
-						self.lastpos = (self.lastpos or pos)
-
-						minetest_add_item(self.lastpos, self.object:get_luaentity().name)
-					end
-
-					self.object:remove();
-
-					return
-				end
-			end
-
-			if self.hit_player or self.hit_mob or self.hit_object then
-
-				for _,player in pairs(minetest_get_objects_inside_radius(pos, 1.5)) do
-
-					if self.hit_player
-					and player:is_player() then
-
-						if self.hit_player then
-							self.hit_player(self, player)
-						else
-							mobs.arrow_hit(self, player)
-						end
-
-						self.object:remove();
-						return
-					end
-
-					--[[
-					local entity = player:get_luaentity()
-
-					if entity
-					and self.hit_mob
-					and entity._cmi_is_mob == true
-					and tostring(player) ~= self.owner_id
-					and entity.name ~= self.object:get_luaentity().name
-					and (self._shooter and entity.name ~= self._shooter:get_luaentity().name) then
-
-						--self.hit_mob(self, player)
-						self.object:remove();
-						return
-					end
-					]]--
-
-					--[[
-					if entity
-					and self.hit_object
-					and (not entity._cmi_is_mob)
-					and tostring(player) ~= self.owner_id
-					and entity.name ~= self.object:get_luaentity().name
-					and (self._shooter and entity.name ~= self._shooter:get_luaentity().name) then
-
-						--self.hit_object(self, player)
-						self.object:remove();
-						return
-					end
-					]]--
-				end
-			end
-
-			self.lastpos = pos
-		end
-	})
-end
-
--- Register spawn eggs
-
--- Note: This also introduces the “spawn_egg” group:
--- * spawn_egg=1: Spawn egg (generic mob, no metadata)
--- * spawn_egg=2: Spawn egg (captured/tamed mob, metadata)
-function mobs:register_egg(mob, desc, background, addegg, no_creative)
-
-	local grp = {spawn_egg = 1}
-
-	-- do NOT add this egg to creative inventory (e.g. dungeon master)
-	if no_creative == true then
-		grp.not_in_creative_inventory = 1
-	end
-
-	local invimg = background
-
-	if addegg == 1 then
-		invimg = "mobs_chicken_egg.png^(" .. invimg ..
-			"^[mask:mobs_chicken_egg_overlay.png)"
-	end
-
-	-- register old stackable mob egg
-	minetest.register_craftitem(mob, {
-
-		description = desc,
-		inventory_image = invimg,
-		groups = grp,
-
-		_doc_items_longdesc = S("This allows you to place a single mob."),
-		_doc_items_usagehelp = S("Just place it where you want the mob to appear. Animals will spawn tamed, unless you hold down the sneak key while placing. If you place this on a mob spawner, you change the mob it spawns."),
-
-		on_place = function(itemstack, placer, pointed_thing)
-
-			local pos = pointed_thing.above
-
-			-- am I clicking on something with existing on_rightclick function?
-			local under = minetest_get_node(pointed_thing.under)
-			local def = minetest_registered_nodes[under.name]
-			if def and def.on_rightclick then
-				return def.on_rightclick(pointed_thing.under, under, placer, itemstack)
-			end
-
-			if pos
-			--and within_limits(pos, 0)
-			and not minetest.is_protected(pos, placer:get_player_name()) then
-
-				local name = placer:get_player_name()
-				local privs = minetest.get_player_privs(name)
-				if mod_mobspawners and under.name == "mcl_mobspawners:spawner" then
-					if minetest.is_protected(pointed_thing.under, name) then
-						minetest.record_protection_violation(pointed_thing.under, name)
-						return itemstack
-					end
-					if not privs.maphack then
-						minetest.chat_send_player(name, S("You need the “maphack” privilege to change the mob spawner."))
-						return itemstack
-					end
-					mcl_mobspawners.setup_spawner(pointed_thing.under, itemstack:get_name())
-					if not mobs.is_creative(name) then
-						itemstack:take_item()
-					end
-					return itemstack
-				end
-
-				if not minetest_registered_entities[mob] then
-					return itemstack
-				end
-
-				if minetest_settings:get_bool("only_peaceful_mobs", false)
-						and minetest_registered_entities[mob].type == "monster" then
-					minetest.chat_send_player(name, S("Only peaceful mobs allowed!"))
-					return itemstack
-				end
-
-				local mob = minetest_add_entity(pos, mob)
-				minetest.log("action", "Mob spawned: "..name.." at "..minetest.pos_to_string(pos))
-				local ent = mob:get_luaentity()
-
-				-- don't set owner if monster or sneak pressed
-				--[[
-				if ent.type ~= "monster"
-				and not placer:get_player_control().sneak then
-					ent.owner = placer:get_player_name()
-					ent.tamed = true
-				end
-				]]--
-
-				-- set nametag
-				local nametag = itemstack:get_meta():get_string("name")
-				if nametag ~= "" then
-					if string.len(nametag) > MAX_MOB_NAME_LENGTH then
-						nametag = string.sub(nametag, 1, MAX_MOB_NAME_LENGTH)
-					end
-					ent.nametag = nametag
-					--update_tag(ent)
-				end
-
-				-- if not in creative then take item
-				if not mobs.is_creative(placer:get_player_name()) then
-					itemstack:take_item()
-				end
-			end
-
-			return itemstack
-		end,
-	})
-
-end
-
-

mods/ENTITIES/mcl_mobs/api/mob_functions/animation.lua

@@ -1,257 +0,0 @@
-local math = math
-local vector = vector
-
-local HALF_PI     = math.pi/2
-
-
-local vector_direction = vector.direction
-local vector_distance  = vector.distance
-local vector_new       = vector.new
-
-local minetest_dir_to_yaw = minetest.dir_to_yaw
-
--- set defined animation
-mobs.set_mob_animation = function(self, anim, fixed_frame)
-
-	if not self.animation or not anim then
-		return
-	end
-
-	if self.state == "die" and anim ~= "die" and anim ~= "stand" then
-		return
-	end
-
-
-	if (not self.animation[anim .. "_start"] or not self.animation[anim .. "_end"]) then
-		return
-	end
-
-	--animations break if they are constantly set
-	--so we put this return gate to check if it is
-	--already at the animation we are trying to implement
-	if self.current_animation == anim then
-		return
-	end
-
-	local a_start = self.animation[anim .. "_start"]
-	local a_end
-
-	if fixed_frame then
-		a_end = a_start
-	else
-		a_end = self.animation[anim .. "_end"]
-	end
-
-	self.object:set_animation({
-		x = a_start,
-		y = a_end},
-		self.animation[anim .. "_speed"] or self.animation.speed_normal or 15,
-		0, self.animation[anim .. "_loop"] ~= false)
-
-	self.current_animation = anim
-end
-
-
-
-
-mobs.death_effect = function(pos, yaw, collisionbox, rotate)
-	local min, max
-	if collisionbox then
-		min = {x=collisionbox[1], y=collisionbox[2], z=collisionbox[3]}
-		max = {x=collisionbox[4], y=collisionbox[5], z=collisionbox[6]}
-	else
-		min = { x = -0.5, y = 0, z = -0.5 }
-		max = { x = 0.5, y = 0.5, z = 0.5 }
-	end
-	if rotate then
-		min = vector.rotate(min, {x=0, y=yaw, z=math.pi/2})
-		max = vector.rotate(max, {x=0, y=yaw, z=math.pi/2})
-		min, max = vector.sort(min, max)
-		min = vector.multiply(min, 0.5)
-		max = vector.multiply(max, 0.5)
-	end
-
-	minetest.add_particlespawner({
-		amount = 50,
-		time = 0.001,
-		minpos = vector.add(pos, min),
-		maxpos = vector.add(pos, max),
-		minvel = vector_new(-5,-5,-5),
-		maxvel = vector_new(5,5,5),
-		minexptime = 1.1,
-		maxexptime = 1.5,
-		minsize = 1,
-		maxsize = 2,
-		collisiondetection = false,
-		vertical = false,
-		texture = "mcl_particles_mob_death.png^[colorize:#000000:255",
-	})
-
-	minetest.sound_play("mcl_mobs_mob_poof", {
-		pos = pos,
-		gain = 1.0,
-		max_hear_distance = 8,
-	}, true)
-end
-
-
---this allows auto facedir rotation while making it so mobs
---don't look like wet noodles flopping around
-mobs.movement_rotation_lock = function(self)
-	local current_engine_yaw = self.object:get_yaw()
-	local current_lua_yaw = self.yaw
-
-	if current_engine_yaw > math.pi * 2 then
-		current_engine_yaw = current_engine_yaw - (math.pi * 2)
-	end
-
-	if math.abs(current_engine_yaw - current_lua_yaw) <= 0.05 and self.object:get_properties().automatic_face_movement_dir then
-		self.object:set_properties{automatic_face_movement_dir = false}
-	elseif math.abs(current_engine_yaw - current_lua_yaw) > 0.05 and self.object:get_properties().automatic_face_movement_dir == false then
-		self.object:set_properties{automatic_face_movement_dir = self.rotate}
-	end
-end
-
-
---this is used when a mob is chasing a player
-mobs.set_yaw_while_attacking = function(self)
-
-	if self.object:get_properties().automatic_face_movement_dir then
-		self.object:set_properties{automatic_face_movement_dir = false}
-	end
-
-	--turn positions into pseudo 2d vectors
-	local pos1 = self.object:get_pos()
-	pos1.y = 0
-
-	local pos2 = self.attacking:get_pos()
-	pos2.y = 0
-
-	local new_direction = vector_direction(pos1,pos2)
-	local new_yaw = minetest_dir_to_yaw(new_direction)
-
-	self.object:set_yaw(new_yaw)
-	self.yaw = new_yaw
-end
-
---this is used to unlock a mob's yaw after attacking
-mobs.unlock_yaw = function(self)
-	if self.object:get_properties().automatic_face_movement_dir == false then
-		self.object:set_properties{automatic_face_movement_dir = self.rotate}
-	end
-end
-
---this is used to lock a mob's yaw when they're standing
-mobs.lock_yaw = function(self)
-	if self.object:get_properties().automatic_face_movement_dir then
-		self.object:set_properties{automatic_face_movement_dir = false}
-	end
-end
-
-
-local calculate_pitch = function(self)
-	local pos  = self.object:get_pos()
-	local pos2 = self.old_pos
-
-	if pos == nil or pos2 == nil then
-		return false
-	end
-
-    return minetest_dir_to_yaw(vector_new(vector_distance(vector_new(pos.x,0,pos.z),vector_new(pos2.x,0,pos2.z)),0,pos.y - pos2.y)) + HALF_PI
-end
-
---this is a helper function used to make mobs pitch rotation dynamically flow when flying/swimming
-mobs.set_dynamic_pitch = function(self)
-	local pitch = calculate_pitch(self)
-
-	if not pitch then
-		return
-	end
-
-	local current_rotation = self.object:get_rotation()
-
-	current_rotation.x = pitch
-
-	self.object:set_rotation(current_rotation)
-
-	self.pitch_switch = "dynamic"
-end
-
---this is a helper function used to make mobs pitch rotation reset when flying/swimming
-mobs.set_static_pitch = function(self)
-
-	if self.pitch_switch == "static" then
-		return
-	end
-
-	local current_rotation = self.object:get_rotation()
-
-	current_rotation.x = 0
-
-	self.object:set_rotation(current_rotation)
-	self.pitch_switch = "static"
-end
-
---this is a helper function for mobs explosion animation
-mobs.handle_explosion_animation = function(self)
-
-	--secondary catch-all
-	if not self.explosion_animation then
-		self.explosion_animation = 0
-	end
-
-	--the timer works from 0 for sense of a 0 based counting
-	--but this just bumps it up so it's usable in here
-	local explosion_timer_adjust = self.explosion_animation + 1
-
-
-	local visual_size_modified = table.copy(self.visual_size_origin)
-
-	visual_size_modified.x = visual_size_modified.x * (explosion_timer_adjust ^ 3)
-	visual_size_modified.y = visual_size_modified.y * explosion_timer_adjust
-
-	self.object:set_properties({visual_size = visual_size_modified})
-end
-
-
---this is used when a mob is following player
-mobs.set_yaw_while_following = function(self)
-
-	if self.object:get_properties().automatic_face_movement_dir then
-		self.object:set_properties{automatic_face_movement_dir = false}
-	end
-
-	--turn positions into pseudo 2d vectors
-	local pos1 = self.object:get_pos()
-	pos1.y = 0
-
-	local pos2 = self.following_person:get_pos()
-	pos2.y = 0
-
-	local new_direction = vector_direction(pos1,pos2)
-	local new_yaw = minetest_dir_to_yaw(new_direction)
-
-	self.object:set_yaw(new_yaw)
-	self.yaw = new_yaw
-end
-
---this is used for when mobs breed
-mobs.set_yaw_while_breeding = function(self, mate)
-
-	if self.object:get_properties().automatic_face_movement_dir then
-		self.object:set_properties{automatic_face_movement_dir = false}
-	end
-
-	--turn positions into pseudo 2d vectors
-	local pos1 = self.object:get_pos()
-	pos1.y = 0
-
-	local pos2 = mate:get_pos()
-	pos2.y = 0
-
-	local new_direction = vector_direction(pos1,pos2)
-	local new_yaw = minetest_dir_to_yaw(new_direction)
-
-	self.object:set_yaw(new_yaw)
-	self.yaw = new_yaw
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/attack_type_instructions.lua

@@ -1,347 +0,0 @@
-local vector_direction = vector.direction
---local minetest_dir_to_yaw = minetest.dir_to_yaw
-local vector_distance = vector.distance
-local vector_multiply = vector.multiply
-local math_random  = math.random
-
---[[
- _   _                     _   _
-| | | |                   | | | |
-| | | |     __ _ _ __   __| | | |
-| | | |    / _` | '_ \ / _` | | |
-|_| | |___| (_| | | | | (_| | |_|
-(_) \_____/\__,_|_| |_|\__,_| (_)
-]]--
-
-
-
---[[
- _____           _           _
-|  ___|         | |         | |
-| |____  ___ __ | | ___   __| | ___
-|  __\ \/ / '_ \| |/ _ \ / _` |/ _ \
-| |___>  <| |_) | | (_) | (_| |  __/
-\____/_/\_\ .__/|_|\___/ \__,_|\___|
-          | |
-          |_|
-]]--
-
-mobs.explode_attack_walk = function(self,dtime)
-
-    --this needs an exception
-    if self.attacking == nil or not self.attacking:is_player() then
-        self.attacking = nil
-        return
-    end
-
-    mobs.set_yaw_while_attacking(self)
-
-    local distance_from_attacking = vector_distance(self.object:get_pos(), self.attacking:get_pos())
-
-    --make mob walk up to player within 2 nodes distance then start exploding
-    if distance_from_attacking >= self.reach and
-    --don't allow explosion to cancel unless out of the reach boundary
-    not (self.explosion_animation and self.explosion_animation > 0 and distance_from_attacking <= self.defuse_reach) then
-
-        mobs.set_velocity(self, self.run_velocity)
-        mobs.set_mob_animation(self,"run")
-
-        mobs.reverse_explosion_animation(self,dtime)
-    else
-        mobs.set_velocity(self,0)
-
-        --this is the only way I can reference this without dumping extra data on all mobs
-        if not self.explosion_animation then
-            self.explosion_animation = 0
-        end
-
-        --play ignite sound
-        if self.explosion_animation == 0 then
-            mobs.play_sound(self,"attack")
-        end
-
-        mobs.set_mob_animation(self,"stand")
-
-        mobs.handle_explosion_animation(self)
-
-        self.explosion_animation = self.explosion_animation + (dtime/2.5)
-    end
-
-    --make explosive mobs jump
-    --check for nodes to jump over
-    --explosive mobs will just ride against walls for now
-	local node_in_front_of = mobs.jump_check(self)
-	if node_in_front_of == 1 then
-		mobs.jump(self)
-    end
-
-    --do biggening explosion thing
-    if self.explosion_animation and self.explosion_animation > self.explosion_timer then
-        mcl_explosions.explode(self.object:get_pos(), self.explosion_strength,{ drop_chance = 1.0 })
-        self.object:remove()
-    end
-end
-
-
---this is a small helper function to make working with explosion animations easier
-mobs.reverse_explosion_animation = function(self,dtime)
-    --if explosion animation was greater than 0 then reverse it
-    if self.explosion_animation and self.explosion_animation > 0 then
-        self.explosion_animation = self.explosion_animation - dtime
-        if self.explosion_animation < 0 then
-            self.explosion_animation = 0
-        end
-    end
-
-    mobs.handle_explosion_animation(self)
-end
-
-
-
-
---[[
-______                 _
-| ___ \               | |
-| |_/ /   _ _ __   ___| |__
-|  __/ | | | '_ \ / __| '_ \
-| |  | |_| | | | | (__| | | |
-\_|   \__,_|_| |_|\___|_| |_|
-]]--
-
-
-
-mobs.punch_attack_walk = function(self,dtime)
-    --this needs an exception
-    if self.attacking == nil or not self.attacking:is_player() then
-        self.attacking = nil
-        return
-    end
-
-    local distance_from_attacking = mobs.get_2d_distance(self.object:get_pos(), self.attacking:get_pos())
-
-    if distance_from_attacking >= self.minimum_follow_distance then
-        mobs.set_velocity(self, self.run_velocity)
-        mobs.set_mob_animation(self, "run")
-    else
-        mobs.set_velocity(self, 0)
-        mobs.set_mob_animation(self, "stand")
-    end
-
-    mobs.set_yaw_while_attacking(self)
-
-    --make punchy mobs jump
-    --check for nodes to jump over
-    --explosive mobs will just ride against walls for now
-	local node_in_front_of = mobs.jump_check(self)
-
-	if node_in_front_of == 1 then
-		mobs.jump(self)
-    end
-
-    --mobs that can climb over stuff
-    if self.always_climb and node_in_front_of > 0 then
-        mobs.climb(self)
-    end
-
-
-    --auto reset punch_timer
-    if not self.punch_timer then
-        self.punch_timer = 0
-    end
-
-    if self.punch_timer > 0 then
-        self.punch_timer = self.punch_timer - dtime
-    end
-end
-
-mobs.punch_attack = function(self)
-
-    self.attacking:punch(self.object, 1.0, {
-        full_punch_interval = 1.0,
-        damage_groups = {fleshy = self.damage}
-    }, nil)
-
-    self.punch_timer = self.punch_timer_cooloff
-
-
-    --knockback
-    local pos1 = self.object:get_pos()
-    pos1.y = 0
-    local pos2 = self.attacking:get_pos()
-    pos2.y = 0
-    local dir = vector_direction(pos1,pos2)
-
-    dir = vector_multiply(dir,3)
-
-    if self.attacking:get_velocity().y <= 1 then
-        dir.y = 5
-    end
-
-    self.attacking:add_velocity(dir)
-end
-
-
-
-
---[[
-______          _           _   _ _
-| ___ \        (_)         | | (_) |
-| |_/ / __ ___  _  ___  ___| |_ _| | ___
-|  __/ '__/ _ \| |/ _ \/ __| __| | |/ _ \
-| |  | | | (_) | |  __/ (__| |_| | |  __/
-\_|  |_|  \___/| |\___|\___|\__|_|_|\___|
-              _/ |
-             |__/
-]]--
-
-
-mobs.projectile_attack_walk = function(self,dtime)
-
-    --this needs an exception
-    if self.attacking == nil or not self.attacking:is_player() then
-        self.attacking = nil
-        return
-    end
-
-    mobs.set_yaw_while_attacking(self)
-
-    local distance_from_attacking = vector_distance(self.object:get_pos(), self.attacking:get_pos())
-
-
-    if distance_from_attacking >= self.reach then
-        mobs.set_velocity(self, self.run_velocity)
-        mobs.set_mob_animation(self,"run")
-    else
-        mobs.set_velocity(self,0)
-        mobs.set_mob_animation(self,"stand")
-    end
-
-    --do this to not load data into other mobs
-    if not self.projectile_timer then
-        self.projectile_timer = math_random(self.projectile_cooldown_min, self.projectile_cooldown_max)
-    end
-
-    --run projectile timer
-    if self.projectile_timer > 0 then
-        self.projectile_timer = self.projectile_timer - dtime
-
-        --shoot
-        if self.projectile_timer <= 0 then
-            --reset timer
-            self.projectile_timer = math_random(self.projectile_cooldown_min, self.projectile_cooldown_max)
-            mobs.shoot_projectile(self)
-        end
-    end
-
-    --make shooty mobs jump
-    --check for nodes to jump over
-    --explosive mobs will just ride against walls for now
-	local node_in_front_of = mobs.jump_check(self)
-	if node_in_front_of == 1 then
-		mobs.jump(self)
-    end
-
-end
-
-
-
-
-
-
-
-
-
---[[
- _  ______ _         _
-| | |  ___| |       | |
-| | | |_  | |_   _  | |
-| | |  _| | | | | | | |
-|_| | |   | | |_| | |_|
-(_) \_|   |_|\__, | (_)
-              __/ |
-             |___/
-]]--
-
-
-
-
---[[
-______          _           _   _ _
-| ___ \        (_)         | | (_) |
-| |_/ / __ ___  _  ___  ___| |_ _| | ___
-|  __/ '__/ _ \| |/ _ \/ __| __| | |/ _ \
-| |  | | | (_) | |  __/ (__| |_| | |  __/
-\_|  |_|  \___/| |\___|\___|\__|_|_|\___|
-              _/ |
-             |__/
-]]--
-
-local random_pitch_multiplier = {-1,1}
-
-mobs.projectile_attack_fly = function(self, dtime)
-    --this needs an exception
-    if self.attacking == nil or not self.attacking:is_player() then
-        self.attacking = nil
-        return
-    end
-
-    --this is specifically for random ghast movement
-    if self.fly_random_while_attack then
-
-        --enable rotation locking
-		mobs.movement_rotation_lock(self)
-
-        self.walk_timer = self.walk_timer - dtime
-
-        --reset the walk timer
-        if self.walk_timer <= 0 then
-            --re-randomize the walk timer
-            self.walk_timer = math.random(1,6) + math.random()
-            --set the mob into a random direction
-            self.yaw = (math_random() * (math.pi * 2))
-            --create a truly random pitch, since there is no easy access to pitch math that I can find
-            self.pitch = math_random() * math.random(1,3) * random_pitch_multiplier[math_random(1,2)]
-        end
-
-        mobs.set_fly_velocity(self, self.run_velocity)
-
-    else
-
-        mobs.set_yaw_while_attacking(self)
-
-        local distance_from_attacking = vector_distance(self.object:get_pos(), self.attacking:get_pos())
-
-        if distance_from_attacking >= self.reach then
-            mobs.set_pitch_while_attacking(self)
-            mobs.set_fly_velocity(self, self.run_velocity)
-            mobs.set_mob_animation(self,"run")
-        else
-            mobs.set_pitch_while_attacking(self)
-            mobs.set_fly_velocity(self, 0)
-            mobs.set_mob_animation(self,"stand")
-        end
-    end
-
-
-    --do this to not load data into other mobs
-    if not self.projectile_timer then
-        self.projectile_timer = math_random(self.projectile_cooldown_min, self.projectile_cooldown_max)
-    end
-
-    --run projectile timer
-    if self.projectile_timer > 0 then
-        self.projectile_timer = self.projectile_timer - dtime
-
-        --shoot
-        if self.projectile_timer <= 0 then
-
-            if self.fly_random_while_attack then
-                mobs.set_yaw_while_attacking(self)
-                self.walk_timer = 0
-            end
-            --reset timer
-            self.projectile_timer = math_random(self.projectile_cooldown_min, self.projectile_cooldown_max)
-            mobs.shoot_projectile(self)
-        end
-    end
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/breeding.lua

@@ -1,179 +0,0 @@
-local minetest_get_objects_inside_radius = minetest.get_objects_inside_radius
-
-local vector = vector
-
---check to see if someone nearby has some tasty food
-mobs.check_following = function(self) -- returns true or false
-    --ignore
-    if not self.follow then
-        self.following_person = nil
-        return false
-    end
-
-    --hey look, this thing works for passive mobs too!
-    local follower = mobs.detect_closest_player_within_radius(self,true,self.view_range,self.eye_height)
-
-    --check if the follower is a player incase they log out
-    if follower and follower:is_player() then
-        local stack = follower:get_wielded_item()
-        --safety check
-        if not stack then
-            self.following_person = nil
-            return false
-        end
-
-        local item_name = stack:get_name()
-        --all checks have passed, that guy has some good looking food
-        if item_name == self.follow then
-            self.following_person = follower
-            return true
-        end
-    end
-
-    --everything failed
-    self.following_person = nil
-    return false
-end
-
---a function which attempts to make mobs enter
---the breeding state
-mobs.enter_breed_state = function(self,clicker)
-
-    --do not breed if baby
-    if self.baby then
-        return false
-    end
-
-    --do not do anything if looking for mate or
-    --if cooling off from breeding
-    if self.breed_lookout_timer > 0 or self.breed_timer > 0 then
-        return false
-    end
-
-    --if this is caught, that means something has gone
-    --seriously wrong
-    if not clicker or not clicker:is_player() then
-        return false
-    end
-
-    local stack = clicker:get_wielded_item()
-    --safety check
-    if not stack then
-        return false
-    end
-
-    local item_name = stack:get_name()
-    --all checks have passed, that guy has some good looking food
-    if item_name == self.follow then
-        if not minetest.is_creative_enabled(clicker:get_player_name()) then
-            stack:take_item()
-            clicker:set_wielded_item(stack)
-        end
-        self.breed_lookout_timer = self.breed_lookout_timer_goal
-        self.bred = true
-        mobs.play_sound_specific(self,"mobs_mc_animal_eat_generic")
-        return true
-    end
-
-    --everything failed
-    return false
-end
-
-
---find the closest mate in the area
-mobs.look_for_mate = function(self)
-
-	local pos1 = self.object:get_pos()
-    pos1.y = pos1.y + self.eye_height
-
-	local mates_in_area = {}
-	local winner_mate = nil
-	local mates_detected = 0
-    local radius = self.view_range
-
-	--get mates in radius
-	for _,mate in pairs(minetest_get_objects_inside_radius(pos1, radius)) do
-
-        --look for a breeding mate
-		if mate and mate:get_luaentity()
-        and mate:get_luaentity()._cmi_is_mob
-        and mate:get_luaentity().name == self.name
-        and mate:get_luaentity().breed_lookout_timer > 0
-        and mate:get_luaentity() ~= self then
-
-			local pos2 = mate:get_pos()
-
-			local distance = vector.distance(pos1,pos2)
-
-			if distance <= radius then
-				if minetest.line_of_sight then
-					--must add eye height or stuff breaks randomly because of
-					--seethrough nodes being a blocker (like grass)
-					if minetest.line_of_sight(
-							vector.new(pos1.x, pos1.y, pos1.z),
-							vector.new(pos2.x, pos2.y + mate:get_properties().eye_height, pos2.z)
-						) then
-						mates_detected = mates_detected + 1
-						mates_in_area[mate] = distance
-					end
-				else
-					mates_detected = mates_detected + 1
-					mates_in_area[mate] = distance
-				end
-			end
-		end
-	end
-
-
-	--return if there's no one near by
-	if mates_detected <= 0 then --handle negative numbers for some crazy error that could possibly happen
-		return nil
-	end
-
-	--do a default radius max
-	local shortest_distance = radius + 1
-
-	--sort through mates and find the closest mate
-	for mate,distance in pairs(mates_in_area) do
-		if distance < shortest_distance then
-			shortest_distance = distance
-			winner_mate = mate
-		end
-	end
-	return winner_mate
-end
-
---make the baby grow up
-mobs.baby_grow_up = function(self)
-    self.baby = nil
-    self.visual_size  = self.backup_visual_size
-    self.collisionbox = self.backup_collisionbox
-    self.selectionbox = self.backup_selectionbox
-    self.object:set_properties(self)
-end
-
---makes the baby grow up faster with diminishing returns
-mobs.make_baby_grow_faster = function(self,clicker)
-    if clicker and clicker:is_player() then
-        local stack = clicker:get_wielded_item()
-        --safety check
-        if not stack then
-            return false
-        end
-
-        local item_name = stack:get_name()
-        --all checks have passed, that guy has some good looking food
-        if item_name == self.follow then
-            self.grow_up_timer = self.grow_up_timer - (self.grow_up_timer * 0.10) --take 10 percent off - diminishing returns
-
-            if not minetest.is_creative_enabled(clicker:get_player_name()) then
-                stack:take_item()
-                clicker:set_wielded_item(stack)
-            end
-
-            mobs.play_sound_specific(self,"mobs_mc_animal_eat_generic")
-            return true
-        end
-    end
-    return false
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/collision.lua

@@ -1,135 +0,0 @@
-local minetest_get_objects_inside_radius    = minetest.get_objects_inside_radius
-
-local math_random = math.random
-local vector_multiply = vector.multiply
-
-local vector_direction = vector.direction
-
-local integer_test = {-1,1}
-
-mobs.collision = function(self)
-	local pos = self.object:get_pos()
-
-	if not self or not self.object or not self.object:get_luaentity() then
-		return
-	end
-
-	--do collision detection from the base of the mob
-	local collisionbox = self.object:get_properties().collisionbox
-
-	pos.y = pos.y + collisionbox[2]
-
-	local collision_boundary = collisionbox[4]
-
-	local radius = collision_boundary
-
-	if collisionbox[5] > collision_boundary then
-		radius = collisionbox[5]
-	end
-
-	local collision_count = 0
-
-
-	local check_for_attack = false
-
-	if self.attack_type == "punch" and self.hostile and self.attacking then
-		check_for_attack = true
-	end
-
-	for _,object in ipairs(minetest_get_objects_inside_radius(pos, radius*1.25)) do
-		if object and object ~= self.object and (object:is_player() or (object:get_luaentity() and object:get_luaentity()._cmi_is_mob == true and object:get_luaentity().health > 0)) and
-		--don't collide with rider, rider don't collide with thing
-		(not object:get_attach() or (object:get_attach() and object:get_attach() ~= self.object)) and
-		(not self.object:get_attach() or (self.object:get_attach() and self.object:get_attach() ~= object)) then
-			--stop infinite loop
-			collision_count = collision_count + 1
-			--mob cramming
-			if collision_count > 30 then
-				self.health = -20
-				break
-			end
-
-			local pos2 = object:get_pos()
-
-			local object_collisionbox = object:get_properties().collisionbox
-
-			pos2.y = pos2.y + object_collisionbox[2]
-
-			local object_collision_boundary = object_collisionbox[4]
-
-
-			--this is checking the difference of the object collided with's possision
-			--if positive top of other object is inside (y axis) of current object
-			local y_base_diff = (pos2.y + object_collisionbox[5]) - pos.y
-
-			local y_top_diff = (pos.y + collisionbox[5]) - pos2.y
-
-
-			local distance = vector.distance(vector.new(pos.x,0,pos.z),vector.new(pos2.x,0,pos2.z))
-
-			if distance <= collision_boundary + object_collision_boundary and y_base_diff >= 0 and y_top_diff >= 0 then
-
-				local dir = vector.direction(pos,pos2)
-
-				dir.y = 0
-
-				--eliminate mob being stuck in corners
-				if dir.x == 0 and dir.z == 0 then
-					--slightly adjust mob position to prevent equal length
-					--corner/wall sticking
-					dir.x = dir.x + ((math_random()/10)*integer_test[math.random(1,2)])
-					dir.z = dir.z + ((math_random()/10)*integer_test[math.random(1,2)])
-				end
-
-				local velocity = dir
-
-				--0.5 is the max force multiplier
-				local force = 0.5 - (0.5 * distance / (collision_boundary + object_collision_boundary))
-
-				local vel1 = vector.multiply(velocity, -1.5)
-				local vel2 = vector.multiply(velocity,  1.5)
-
-				vel1 = vector.multiply(vel1, force * 10)
-				vel2 = vector.multiply(vel2, force)
-
-				if object:is_player() then
-					vel2 = vector_multiply(vel2, 2.5)
-
-					--integrate mob punching into collision detection
-					if check_for_attack and self.punch_timer <= 0 then
-						if object == self.attacking then
-							mobs.punch_attack(self)
-						end
-					end
-				end
-				self.object:add_velocity(vel1)
-				object:add_velocity(vel2)
-			end
-		end
-	end
-end
-
-
---this is used for arrow collisions
-mobs.arrow_hit = function(self, player)
-    player:punch(self.object, 1.0, {
-        full_punch_interval = 1.0,
-        damage_groups = {fleshy = self._damage}
-    }, nil)
-
-
-    --knockback
-    local pos1 = self.object:get_pos()
-	pos1.y = 0
-    local pos2 = player:get_pos()
-    pos2.y = 0
-    local dir = vector_direction(pos1,pos2)
-
-    dir = vector_multiply(dir,3)
-
-    if player:get_velocity().y <= 1 then
-        dir.y = 5
-    end
-
-    player:add_velocity(dir)
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/death_logic.lua

@@ -1,161 +0,0 @@
-local minetest_add_item = minetest.add_item
---local minetest_sound_play = minetest.sound_play
-
-local math_pi     = math.pi
-local math_random = math.random
-local math_floor  = math.floor
-local HALF_PI     = math_pi / 2
-
-local vector_new = vector.new
-
-
--- drop items
-local item_drop = function(self, cooked, looting_level)
-
-	looting_level = looting_level or 0
-
-	-- no drops for child mobs (except monster)
-	if (self.child and self.type ~= "monster") then
-		return
-	end
-
-	local obj, item
-	local pos = self.object:get_pos()
-
-	self.drops = self.drops or {} -- nil check
-
-	for n = 1, #self.drops do
-		local dropdef = self.drops[n]
-		local chance = 1 / dropdef.chance
-		local looting_type = dropdef.looting
-
-		if looting_level > 0 then
-			local chance_function = dropdef.looting_chance_function
-			if chance_function then
-				chance = chance_function(looting_level)
-			elseif looting_type == "rare" then
-				chance = chance + (dropdef.looting_factor or 0.01) * looting_level
-			end
-		end
-
-		local num = 0
-		local do_common_looting = (looting_level > 0 and looting_type == "common")
-		if math_random() < chance then
-			num = math_random(dropdef.min or 1, dropdef.max or 1)
-		elseif not dropdef.looting_ignore_chance then
-			do_common_looting = false
-		end
-
-		if do_common_looting then
-			num = num + math_floor(math_random(0, looting_level) + 0.5)
-		end
-
-		if num > 0 then
-			item = dropdef.name
-
-			-- cook items when true
-			if cooked then
-
-				local output = minetest.get_craft_result({
-					method = "cooking",
-                    width = 1,
-                    items = {item},
-                })
-
-				if output and output.item and not output.item:is_empty() then
-					item = output.item:get_name()
-				end
-			end
-
-			-- add item if it exists
-			for x = 1, num do
-				obj = minetest_add_item(pos, ItemStack(item .. " " .. 1))
-			end
-
-			if obj and obj:get_luaentity() then
-
-				obj:set_velocity({
-					x = math_random(-10, 10) / 9,
-					y = 6,
-					z = math_random(-10, 10) / 9,
-				})
-			elseif obj then
-				obj:remove() -- item does not exist
-			end
-		end
-	end
-
-	self.drops = {}
-end
-
-
-mobs.death_logic = function(self, dtime)
-
-	--stop crashing game when object is nil
-	if not self or not self.object or not self.object:get_luaentity() then
-		return
-	end
-
-    self.death_animation_timer = self.death_animation_timer + dtime
-
-	--get all attached entities and sort through them
-	local attached_entities = self.object:get_children()
-	if #attached_entities > 0 then
-		for _,entity in pairs(attached_entities) do
-			--kick the player off
-			if entity:is_player() then
-				mobs.detach(entity)
-			--kick mobs off
-			--if there is scaling issues, this needs an additional check
-			else
-				entity:set_detach()
-			end
-		end
-	end
-
-	--stop mob from getting in the way of other mobs you're fighting
-	if self.object:get_properties().pointable then
-		self.object:set_properties({pointable = false})
-	end
-
-    --the final POOF of a mob despawning
-    if self.death_animation_timer >= 1.25 then
-        item_drop(self,false,1)
-        mobs.death_effect(self)
-        mcl_experience.throw_xp(self.object:get_pos(), math_random(self.xp_min, self.xp_max))
-        if self.on_die then
-          self.on_die(self, self.object:get_pos())
-        end
-        self.object:remove()
-        return
-    end
-
-    --I'm sure there's a more efficient way to do this
-    --but this is the easiest, easier to work with 1 variable synced
-    --this is also not smooth
-    local death_animation_roll = self.death_animation_timer * 2 -- * 2 to make it faster
-    if death_animation_roll > 1 then
-        death_animation_roll = 1
-    end
-
-    local rot = self.object:get_rotation() --(no pun intended)
-
-    rot.z = death_animation_roll * HALF_PI
-
-    self.object:set_rotation(rot)
-
-    mobs.set_mob_animation(self,"stand", true)
-
-
-    --flying and swimming mobs just fall down
-    if self.fly or self.swim then
-        if self.object:get_acceleration().y ~= -self.gravity then
-            self.object:set_acceleration(vector_new(0,-self.gravity,0))
-        end
-    end
-
-    --when landing allow mob to slow down and just fall if in air
-    if self.pause_timer <= 0 then
-        mobs.set_velocity(self,0)
-    end
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/environment.lua

@@ -1,250 +0,0 @@
-local minetest_line_of_sight = minetest.line_of_sight
---local minetest_dir_to_yaw    = minetest.dir_to_yaw
-local minetest_yaw_to_dir    = minetest.yaw_to_dir
-local minetest_get_node      = minetest.get_node
-local minetest_get_item_group = minetest.get_item_group
-local minetest_get_objects_inside_radius = minetest.get_objects_inside_radius
-local minetest_get_node_or_nil = minetest.get_node_or_nil
-local minetest_registered_nodes = minetest.registered_nodes
-local minetest_get_connected_players = minetest.get_connected_players
-
-local vector_new = vector.new
-local vector_add = vector.add
-local vector_multiply = vector.multiply
-local vector_distance = vector.distance
-
-local table_copy = table.copy
-
-local math_abs = math.abs
-
--- default function when mobs are blown up with TNT
---[[local function do_tnt(obj, damage)
-	obj.object:punch(obj.object, 1.0, {
-		full_punch_interval = 1.0,
-		damage_groups = {fleshy = damage},
-	}, nil)
-	return false, true, {}
-end]]
-
---a fast function to be able to detect only players without using objects_in_radius
-mobs.detect_closest_player_within_radius = function(self, line_of_sight, radius, object_height_adder)
-	local pos1 = self.object:get_pos()
-	local players_in_area = {}
-	local winner_player = nil
-	local players_detected = 0
-
-	--get players in radius
-	for _,player in pairs(minetest.get_connected_players()) do
-		if player and player:get_hp() > 0 then
-
-			local pos2 = player:get_pos()
-
-			local distance = vector_distance(pos1,pos2)
-
-			if distance <= radius then
-				if line_of_sight then
-					--must add eye height or stuff breaks randomly because of
-					--seethrough nodes being a blocker (like grass)
-					if minetest_line_of_sight(
-							vector_new(pos1.x, pos1.y + object_height_adder, pos1.z),
-							vector_new(pos2.x, pos2.y + player:get_properties().eye_height, pos2.z)
-						) then
-						players_detected = players_detected + 1
-						players_in_area[player] = distance
-					end
-				else
-					players_detected = players_detected + 1
-					players_in_area[player] = distance
-				end
-			end
-		end
-	end
-
-
-	--return if there's no one near by
-	if players_detected <= 0 then --handle negative numbers for some crazy error that could possibly happen
-		return nil
-	end
-
-	--do a default radius max
-	local shortest_distance = radius + 1
-
-	--sort through players and find the closest player
-	for player,distance in pairs(players_in_area) do
-		if distance < shortest_distance then
-			shortest_distance = distance
-			winner_player = player
-		end
-	end
-	return winner_player
-end
-
-
---check if a mob needs to jump
-mobs.jump_check = function(self,dtime)
-
-    local pos = self.object:get_pos()
-    pos.y = pos.y + 0.1
-    local dir = minetest_yaw_to_dir(self.yaw)
-
-    local collisionbox = self.object:get_properties().collisionbox
-	local radius = collisionbox[4] + 0.5
-
-    vector_multiply(dir, radius)
-
-	--only jump if there's a node and a non-solid node above it
-    local test_dir = vector_add(pos,dir)
-
-	local green_flag_1 = minetest_get_item_group(minetest_get_node(test_dir).name, "solid") ~= 0
-
-	test_dir.y = test_dir.y + 1
-
-	local green_flag_2 = minetest_get_item_group(minetest_get_node(test_dir).name, "solid") == 0
-
-    if green_flag_1 and green_flag_2 then
-		--can jump over node
-        return 1
-	elseif green_flag_1 and not green_flag_2 then
-		--wall in front of mob
-		return 2
-    end
-	--nothing to jump over
-	return 0
-end
-
--- a helper function to quickly turn neutral passive mobs hostile
-local turn_hostile = function(self,detected_mob)
-	--drop in variables for attacking (stops crash)
-	detected_mob.punch_timer = 0
-	--set to hostile
-	detected_mob.hostile = true
-	--hostile_cooldown timer is initialized here
-	detected_mob.hostile_cooldown_timer = detected_mob.hostile_cooldown
-	--set target to the same
-	detected_mob.attacking = self.attacking
-end
-
---allow hostile mobs to signal to other mobs
---to switch from neutal passive to neutral hostile
-mobs.group_attack_initialization = function(self)
-
-	--get basic data
-	local friends_list
-
-	if self.group_attack == true then
-		friends_list = {self.name}
-	else
-		friends_list = table_copy(self.group_attack)
-	end
-
-	local objects_in_area = minetest_get_objects_inside_radius(self.object:get_pos(), self.view_range)
-
-	--get the player's name
-	local name = self.attacking:get_player_name()
-
-	--re-use local variable
-	local detected_mob
-
-	--run through mobs in viewing distance
-	for _,object in pairs(objects_in_area) do
-		if object and object:get_luaentity() then
-			detected_mob = object:get_luaentity()
-			-- only alert members of same mob or friends
-			if detected_mob._cmi_is_mob and detected_mob.state ~= "attack" and detected_mob.owner ~= name then
-				if detected_mob.name == self.name then
-					turn_hostile(self,detected_mob)
-				else
-					for _,id in pairs(friends_list) do
-						if detected_mob.name == id then
-							turn_hostile(self,detected_mob)
-							break
-						end
-					end
-				end
-			end
-
-			--THIS NEEDS TO BE RE-IMPLEMENTED AS A GLOBAL HIT IN MOB_PUNCH!!
-			-- have owned mobs attack player threat
-			--if obj.owner == name and obj.owner_loyal then
-			--	do_attack(obj, self.object)
-			--end
-		end
-	end
-end
-
--- check if within physical map limits (-30911 to 30927)
--- within_limits, wmin, wmax = nil, -30913, 30928
-mobs.within_limits = function(pos, radius)
-    local wmin, wmax
-	if mcl_vars then
-		if mcl_vars.mapgen_edge_min and mcl_vars.mapgen_edge_max then
-			wmin, wmax = mcl_vars.mapgen_edge_min, mcl_vars.mapgen_edge_max
-		end
-	end
-	return pos
-		and (pos.x - radius) > wmin and (pos.x + radius) < wmax
-		and (pos.y - radius) > wmin and (pos.y + radius) < wmax
-		and (pos.z - radius) > wmin and (pos.z + radius) < wmax
-end
-
--- get node but use fallback for nil or unknown
-mobs.node_ok = function(pos, fallback)
-
-	fallback = fallback or mobs.fallback_node
-
-	local node = minetest_get_node_or_nil(pos)
-
-	if node and minetest_registered_nodes[node.name] then
-		return node
-	end
-
-	return minetest_registered_nodes[fallback]
-end
-
-
---a teleport functoin
-mobs.teleport = function(self, target)
-	if self.do_teleport then
-		if self.do_teleport(self, target) == false then
-			return
-		end
-	end
-end
-
---a function used for despawning mobs
-mobs.check_for_player_within_area = function(self, radius)
-	local pos1 = self.object:get_pos()
-	--get players in radius
-	for _,player in pairs(minetest_get_connected_players()) do
-		if player and player:get_hp() > 0 then
-			local pos2 = player:get_pos()
-			local distance = vector_distance(pos1,pos2)
-			if distance < radius then
-				--found a player
-				return true
-			end
-		end
-	end
-	--did not find a player
-	return false
-end
-
-
---a simple helper function for mobs following
-mobs.get_2d_distance = function(pos1,pos2)
-	pos1.y = 0
-	pos2.y = 0
-	return vector_distance(pos1, pos2)
-end
-
--- fall damage onto solid ground
-mobs.calculate_fall_damage = function(self)
-	if self.old_velocity and self.old_velocity.y < -7 and self.object:get_velocity().y == 0 then
-		local vel = self.object:get_velocity()
-		if vel then
-			local damage = math_abs(self.old_velocity.y + 7) * 2
-			self.pause_timer = 0.4
-			self.health = self.health - damage
-		end
-	end
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/flow_lib.lua

@@ -1,78 +0,0 @@
---this is from https://github.com/HybridDog/builtin_item/blob/e6dfd9dce86503b3cbd1474257eca5f6f6ca71c2/init.lua#L50
-local
-minetest,vector,math,pairs,minetest_get_node,vector_subtract,minetest_registered_nodes
-=
-minetest,vector,math,pairs,minetest.get_node,vector.subtract,minetest.registered_nodes
-
-local tab
-local n
-local function get_nodes(pos)
-	tab,n = {},1
-	for i = -1,1,2 do
-		for _,p in pairs({
-			{x=pos.x+i, y=pos.y, z=pos.z},
-			{x=pos.x, y=pos.y, z=pos.z+i}
-		}) do
-			tab[n] = {p, minetest_get_node(p)}
-			n = n+1
-		end
-	end
-	return tab
-end
-
-
-local data
-local param2
-local nd
-local par2
-local name
-local tmp
-local c_node
-function mobs.get_flowing_dir(pos)
-	c_node = minetest_get_node(pos).name
-	if c_node ~= "mcl_core:water_flowing" and c_node ~= "mcl_core:water" then
-		return nil
-	end
-	data = get_nodes(pos)
-	param2 = minetest_get_node(pos).param2
-	if param2 > 7 then
-		return nil
-	end
-	if c_node == "mcl_core:water" then
-		for _,i in pairs(data) do
-			nd = i[2]
-			name = nd.name
-			par2 = nd.param2
-			if name == "mcl_core:water_flowing" and par2 == 7 then
-				return(vector_subtract(i[1],pos))
-			end
-		end
-	end
-	for _,i in pairs(data) do
-		nd = i[2]
-		name = nd.name
-		par2 = nd.param2
-		if name == "mcl_core:water_flowing" and par2 < param2 then
-			return(vector_subtract(i[1],pos))
-		end
-	end
-	for _,i in pairs(data) do
-		nd = i[2]
-		name = nd.name
-		par2 = nd.param2
-		if name == "mcl_core:water_flowing" and par2 >= 11 then
-			return(vector_subtract(i[1],pos))
-		end
-	end
-	for _,i in pairs(data) do
-		nd = i[2]
-		name = nd.name
-		par2 = nd.param2
-		tmp = minetest_registered_nodes[name]
-		if tmp and not tmp.walkable and name ~= "mcl_core:water_flowing" and name ~= "mcl_core:water" then
-			return(vector_subtract(i[1],pos))
-		end
-	end
-
-	return nil
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/head_logic.lua

@@ -1,98 +0,0 @@
-local math = math
-local vector = vector
-
---converts yaw to degrees
-local degrees = function(yaw)
-	return yaw*180.0/math.pi
-end
-
-mobs.do_head_logic = function(self,dtime)
-
-	local player = minetest.get_player_by_name("singleplayer")
-
-	local look_at = player:get_pos()
-	look_at.y = look_at.y + player:get_properties().eye_height
-
-	local pos = self.object:get_pos()
-
-	local body_yaw = self.object:get_yaw()
-
-	local body_dir = minetest.yaw_to_dir(body_yaw)
-
-	pos.y = pos.y + self.head_height_offset
-
-	local head_offset = vector.multiply(body_dir, self.head_direction_offset)
-
-	pos = vector.add(pos, head_offset)
-
-	minetest.add_particle({
-		pos = pos,
-		velocity = {x=0, y=0, z=0},
-		acceleration = {x=0, y=0, z=0},
-		expirationtime = 0.2,
-		size = 1,
-		texture = "default_dirt.png",
-	})
-
-	local bone_pos = vector.new(0,0,0)
-
-	--(horizontal)
-	bone_pos.y = self.head_bone_pos_y
-
-	--(vertical)
-	bone_pos.z = self.head_bone_pos_z
-
-	--print(yaw)
-
-	--local _, bone_rot = self.object:get_bone_position("head")
-
-	--bone_rot.x = bone_rot.x + (dtime * 10)
-	--bone_rot.z = bone_rot.z + (dtime * 10)
-
-	local head_yaw = minetest.dir_to_yaw(vector.direction(pos,look_at)) - body_yaw
-
-	if self.reverse_head_yaw then
-		head_yaw = head_yaw * -1
-	end
-
-	--over rotation protection
-	--stops radians from going out of spec
-	if head_yaw > math.pi then
-		head_yaw = head_yaw - (math.pi * 2)
-	elseif head_yaw < -math.pi then
-		head_yaw = head_yaw + (math.pi * 2)
-	end
-
-
-	local check_failed = false
-	--upper check + 90 degrees or upper math.radians (3.14/2)
-	if head_yaw > math.pi - (math.pi/2) then
-		head_yaw = 0
-		check_failed = true
-	--lower check - 90 degrees or lower negative math.radians (-3.14/2)
-	elseif head_yaw < -math.pi + (math.pi/2) then
-		head_yaw = 0
-		check_failed = true
-	end
-
-	local head_pitch = 0
-
-	--DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
-	--head_yaw = 0
-	--DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
-
-	if not check_failed then
-		head_pitch = minetest.dir_to_yaw(vector.new(vector.distance(vector.new(pos.x,0,pos.z),vector.new(look_at.x,0,look_at.z)),0,pos.y-look_at.y))+(math.pi/2)
-	end
-
-	if self.head_pitch_modifier then
-		head_pitch = head_pitch + self.head_pitch_modifier
-	end
-
-	if self.swap_y_with_x then
-		self.object:set_bone_position(self.head_bone, bone_pos, vector.new(degrees(head_pitch),degrees(head_yaw),0))
-	else
-		self.object:set_bone_position(self.head_bone, bone_pos, vector.new(degrees(head_pitch),0,degrees(head_yaw)))
-	end
-	--set_bone_position([bone, position, rotation])
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/interaction.lua

@@ -1,276 +0,0 @@
-local minetest_after      = minetest.after
-local minetest_sound_play = minetest.sound_play
-local minetest_dir_to_yaw = minetest.dir_to_yaw
-
-local math = math
-local vector = vector
-
-local MAX_MOB_NAME_LENGTH = 30
-
-local mod_hunger = minetest.get_modpath("mcl_hunger")
-
-mobs.feed_tame = function(self)
-    return nil
-end
-
--- Code to execute before custom on_rightclick handling
-local function on_rightclick_prefix(self, clicker)
-	local item = clicker:get_wielded_item()
-
-	-- Name mob with nametag
-	if not self.ignores_nametag and item:get_name() == "mcl_mobs:nametag" then
-
-		local tag = item:get_meta():get_string("name")
-		if tag ~= "" then
-			if string.len(tag) > MAX_MOB_NAME_LENGTH then
-				tag = string.sub(tag, 1, MAX_MOB_NAME_LENGTH)
-			end
-			self.nametag = tag
-
-			mobs.update_tag(self)
-
-			if not mobs.is_creative(clicker:get_player_name()) then
-				item:take_item()
-				clicker:set_wielded_item(item)
-			end
-			return true
-		end
-
-	end
-	return false
-end
-
--- I have no idea what this does
-mobs.create_mob_on_rightclick = function(on_rightclick)
-	return function(self, clicker)
-		--don't allow rightclicking dead mobs
-		if self.health <= 0 then
-			return
-		end
-		local stop = on_rightclick_prefix(self, clicker)
-		if (not stop) and (on_rightclick) then
-			on_rightclick(self, clicker)
-		end
-	end
-end
-
-
--- deal damage and effects when mob punched
-mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
-	--don't do anything if the mob is already dead
-	if self.health <= 0 then
-		return
-	end
-
-	--neutral passive mobs switch to neutral hostile
-	if self.neutral then
-		--drop in variables for attacking (stops crash)
-		self.attacking   = hitter
-		self.punch_timer = 0
-		self.hostile = true
-		--hostile_cooldown timer is initialized here
-		self.hostile_cooldown_timer = self.hostile_cooldown
-
-		--initialize the group attack (check for other mobs in area, make them neutral hostile)
-		if self.group_attack then
-			mobs.group_attack_initialization(self)
-		end
-	end
-
-	--turn skittish mobs away and RUN
-	if self.skittish then
-
-		self.state = "run"
-
-		self.run_timer = 5 --arbitrary 5 seconds
-
-		local pos1 = self.object:get_pos()
-		pos1.y = 0
-		local pos2 = hitter:get_pos()
-		pos2.y = 0
-
-
-		local dir = vector.direction(pos2,pos1)
-
-		local yaw = minetest_dir_to_yaw(dir)
-
-		self.yaw = yaw
-	end
-
-	-- custom punch function
-	if self.do_punch then
-		-- when false skip going any further
-		if self.do_punch(self, hitter, tflp, tool_capabilities, dir) == false then
-			return
-		end
-	end
-
-	--don't do damage until pause timer resets
-	if self.pause_timer > 0 then
-		return
-	end
-
-	-- error checking when mod profiling is enabled
-	if not tool_capabilities then
-		minetest.log("warning", "[mobs_mc] Mod profiling enabled, damage not enabled")
-		return
-	end
-
-	local is_player = hitter:is_player()
-
-	-- punch interval
-	local weapon = hitter:get_wielded_item()
-
-	--local punch_interval = 1.4
-
-	-- exhaust attacker
-	if mod_hunger and is_player then
-		mcl_hunger.exhaust(hitter:get_player_name(), mcl_hunger.EXHAUST_ATTACK)
-	end
-
-	-- calculate mob damage
-	local damage = 0
-	local armor = self.object:get_armor_groups() or {}
-
-	--calculate damage groups
-	for group,_ in pairs( (tool_capabilities.damage_groups or {}) ) do
-		damage = damage + (tool_capabilities.damage_groups[group] or 0) * ((armor[group] or 0) / 100.0)
-	end
-
-	if weapon then
-		local fire_aspect_level = mcl_enchanting.get_enchantment(weapon, "fire_aspect")
-		if fire_aspect_level > 0 then
-			mcl_burning.set_on_fire(self.object, fire_aspect_level * 4)
-		end
-	end
-
-	-- check for tool immunity or special damage
-	for n = 1, #self.immune_to do
-		if self.immune_to[n][1] == weapon:get_name() then
-			damage = self.immune_to[n][2] or 0
-			break
-		end
-	end
-
-	-- healing
-	if damage <= -1 then
-		self.health = self.health - math.floor(damage)
-		return
-	end
-
-	--if tool_capabilities then
-	--	punch_interval = tool_capabilities.full_punch_interval or 1.4
-	--end
-
-	-- add weapon wear manually
-	-- Required because we have custom health handling ("health" property)
-	--minetest_is_creative_enabled("") ~= true --removed for now
-	if tool_capabilities then
-		if tool_capabilities.punch_attack_uses then
-			-- Without this delay, the wear does not work. Quite hacky ...
-			minetest_after(0, function(name)
-				local player = minetest.get_player_by_name(name)
-				if not player then return end
-				local weapon = hitter:get_wielded_item(player)
-				local def = weapon:get_definition()
-				if def.tool_capabilities and def.tool_capabilities.punch_attack_uses then
-					local wear = math.floor(65535/tool_capabilities.punch_attack_uses)
-					weapon:add_wear(wear)
-					hitter:set_wielded_item(weapon)
-				end
-			end, hitter:get_player_name())
-		end
-	end
-
-
-	--if player is falling multiply damage by 1.5
-	--critical hit
-	if hitter:get_velocity().y < 0 then
-		damage = damage * 1.5
-		mobs.critical_effect(self)
-	end
-
-
-	-- only play hit sound and show blood effects if damage is 1 or over; lower to 0.1 to ensure armor works appropriately.
-	if damage >= 0.1 then
-
-		minetest_sound_play("default_punch", {
-			object = self.object,
-			max_hear_distance = 16
-		}, true)
-
-		-- do damage
-		self.health = self.health - damage
-
-
-		--0.4 seconds until you can hurt the mob again
-		self.pause_timer = 0.4
-
-		--don't do knockback from a rider
-		for _,obj in pairs(self.object:get_children()) do
-			if obj == hitter then
-				return
-			end
-		end
-
-		-- knock back effect
-		local velocity = self.object:get_velocity()
-
-		--2d direction
-		local pos1 = self.object:get_pos()
-		pos1.y = 0
-		local pos2 = hitter:get_pos()
-		pos2.y = 0
-
-		local dir = vector.direction(pos2,pos1)
-
-		local up = 3
-
-		-- if already in air then dont go up anymore when hit
-		if velocity.y ~= 0 then
-			up = 0
-		end
-
-		--0.75 for perfect distance to not be too easy, and not be too hard
-		local multiplier = 0.75
-
-		-- check if tool already has specific knockback value
-		local knockback_enchant = mcl_enchanting.get_enchantment(hitter:get_wielded_item(), "knockback")
-		if knockback_enchant and knockback_enchant > 0 then
-			multiplier = knockback_enchant + 1 --(starts from 1, 1 would be no change)
-		end
-
-		--do this to sure you can punch a mob back when
-		--it's coming for you
-		if self.hostile then
-			multiplier = multiplier + 2
-		end
-		dir = vector.multiply(dir,multiplier)
-		dir.y = up
-		--add the velocity
-		self.object:add_velocity(dir)
-	end
-end
-
---do internal per mob projectile calculations
-mobs.shoot_projectile = function(self)
-	local pos1 = self.object:get_pos()
-	--add mob eye height
-	pos1.y = pos1.y + self.eye_height
-
-	local pos2 = self.attacking:get_pos()
-	--add player eye height
-	pos2.y = pos2.y + self.attacking:get_properties().eye_height
-
-	--get direction
-	local dir = vector.direction(pos1,pos2)
-
-	--call internal shoot_arrow function
-	self.shoot_arrow(self,pos1,dir)
-end
-
-mobs.update_tag = function(self)
-	self.object:set_properties({
-		nametag = self.nametag,
-	})
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/mob_effects.lua

@@ -1,150 +0,0 @@
-local minetest_add_particlespawner = minetest.add_particlespawner
-
-mobs.death_effect = function(self)
-    local pos = self.object:get_pos()
-    --local yaw = self.object:get_yaw()
-    local collisionbox = self.object:get_properties().collisionbox
-
-    local min, max
-
-    if collisionbox then
-        min = {x=collisionbox[1], y=collisionbox[2], z=collisionbox[3]}
-        max = {x=collisionbox[4], y=collisionbox[5], z=collisionbox[6]}
-    end
-
-    minetest_add_particlespawner({
-        amount = 50,
-        time = 0.0001,
-        minpos = vector.add(pos, min),
-        maxpos = vector.add(pos, max),
-        minvel = vector.new(-0.5,0.5,-0.5),
-        maxvel = vector.new(0.5,1,0.5),
-        minexptime = 1.1,
-        maxexptime = 1.5,
-        minsize = 1,
-        maxsize = 2,
-        collisiondetection = false,
-        vertical = false,
-        texture = "mcl_particles_mob_death.png", -- this particle looks strange
-    })
-end
-
-mobs.critical_effect = function(self)
-
-    local pos = self.object:get_pos()
-    --local yaw = self.object:get_yaw()
-    local collisionbox = self.object:get_properties().collisionbox
-
-    local min, max
-
-    if collisionbox then
-        min = {x=collisionbox[1], y=collisionbox[2], z=collisionbox[3]}
-        max = {x=collisionbox[4], y=collisionbox[5], z=collisionbox[6]}
-    end
-
-    minetest_add_particlespawner({
-        amount = 10,
-        time = 0.0001,
-        minpos = vector.add(pos, min),
-        maxpos = vector.add(pos, max),
-        minvel = vector.new(-1,1,-1),
-        maxvel = vector.new(1,3,1),
-        minexptime = 0.7,
-        maxexptime = 1,
-        minsize = 1,
-        maxsize = 2,
-        collisiondetection = false,
-        vertical = false,
-        texture = "heart.png^[colorize:black:255",
-    })
-end
-
---when feeding a mob
-mobs.feed_effect = function(self)
-    local pos = self.object:get_pos()
-    --local yaw = self.object:get_yaw()
-    local collisionbox = self.object:get_properties().collisionbox
-
-    local min, max
-
-    if collisionbox then
-        min = {x=collisionbox[1], y=collisionbox[2], z=collisionbox[3]}
-        max = {x=collisionbox[4], y=collisionbox[5], z=collisionbox[6]}
-    end
-
-    minetest_add_particlespawner({
-        amount = 10,
-        time = 0.0001,
-        minpos = vector.add(pos, min),
-        maxpos = vector.add(pos, max),
-        minvel = vector.new(-1,1,-1),
-        maxvel = vector.new(1,3,1),
-        minexptime = 0.7,
-        maxexptime = 1,
-        minsize = 1,
-        maxsize = 2,
-        collisiondetection = false,
-        vertical = false,
-        texture = "heart.png^[colorize:gray:255",
-    })
-end
-
---hearts when tamed
-mobs.tamed_effect = function(self)
-    local pos = self.object:get_pos()
-    --local yaw = self.object:get_yaw()
-    local collisionbox = self.object:get_properties().collisionbox
-
-    local min, max
-
-    if collisionbox then
-        min = {x=collisionbox[1], y=collisionbox[2], z=collisionbox[3]}
-        max = {x=collisionbox[4], y=collisionbox[5], z=collisionbox[6]}
-    end
-
-    minetest_add_particlespawner({
-        amount = 30,
-        time = 0.0001,
-        minpos = vector.add(pos, min),
-        maxpos = vector.add(pos, max),
-        minvel = vector.new(-1,1,-1),
-        maxvel = vector.new(1,3,1),
-        minexptime = 0.7,
-        maxexptime = 1,
-        minsize = 1,
-        maxsize = 2,
-        collisiondetection = false,
-        vertical = false,
-        texture = "heart.png",
-    })
-end
-
---hearts when breeding
-mobs.breeding_effect = function(self)
-    local pos = self.object:get_pos()
-    --local yaw = self.object:get_yaw()
-    local collisionbox = self.object:get_properties().collisionbox
-
-    local min, max
-
-    if collisionbox then
-        min = {x=collisionbox[1], y=collisionbox[2], z=collisionbox[3]}
-        max = {x=collisionbox[4], y=collisionbox[5], z=collisionbox[6]}
-    end
-
-    minetest_add_particlespawner({
-        amount = 2,
-        time = 0.0001,
-        minpos = vector.add(pos, min),
-        maxpos = vector.add(pos, max),
-        minvel = vector.new(-1,1,-1),
-        maxvel = vector.new(1,3,1),
-        minexptime = 0.7,
-        maxexptime = 1,
-        minsize = 1,
-        maxsize = 2,
-        collisiondetection = false,
-        vertical = false,
-        texture = "heart.png",
-    })
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/movement.lua

@@ -1,390 +0,0 @@
--- localize math functions
-local math = math
-local HALF_PI     = math.pi / 2
-local DOUBLE_PI   = math.pi * 2
-
--- localize vector functions
-local vector = vector
-
-local minetest_yaw_to_dir = minetest.yaw_to_dir
-local minetest_dir_to_yaw = minetest.dir_to_yaw
-
-local DEFAULT_JUMP_HEIGHT = 5
-local DEFAULT_FLOAT_SPEED = 4
-local DEFAULT_CLIMB_SPEED = 3
-
-mobs.stick_in_cobweb = function(self)
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = vector.multiply(vector.normalize(current_velocity), 0.4)
-
-	goal_velocity.y = -0.5
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
---this is a generic float function
-mobs.float = function(self)
-
-	local acceleration = self.object:get_acceleration()
-
-	if not acceleration then
-		return
-	end
-
-	if acceleration.y ~= 0 then
-		self.object:set_acceleration({x=0, y=0, z=0})
-	end
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = 0,
-		y = DEFAULT_FLOAT_SPEED,
-		z = 0,
-	}
-
-	local new_velocity_addition = vector.subtract(goal_velocity, current_velocity)
-
-	new_velocity_addition.x = 0
-	new_velocity_addition.z = 0
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
---this is a generic climb function
-mobs.climb = function(self)
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = 0,
-		y = DEFAULT_CLIMB_SPEED,
-		z = 0,
-	}
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	new_velocity_addition.x = 0
-	new_velocity_addition.z = 0
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
-
-
---[[
- _                     _
-| |                   | |
-| |     __ _ _ __   __| |
-| |    / _` | '_ \ / _` |
-| |___| (_| | | | | (_| |
-\_____/\__,_|_| |_|\__,_|
-]]
-
-
--- move mob in facing direction
---this has been modified to be internal
---internal = lua (self.yaw)
---engine = c++ (self.object:get_yaw())
-mobs.set_velocity = function(self, v)
-
-	local yaw = (self.yaw or 0)
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = (math.sin(yaw) * -v),
-		y = 0,
-		z = (math.cos(yaw) * v),
-	}
-
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
-	end
-
-	new_velocity_addition.y = 0
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
-
-
--- calculate mob velocity
-mobs.get_velocity = function(self)
-
-	local v = self.object:get_velocity()
-
-	v.y = 0
-
-	if v then
-		return vector.length(v)
-	end
-
-	return 0
-end
-
---make mobs jump
-mobs.jump = function(self, velocity)
-
-    if self.object:get_velocity().y ~= 0 or not self.old_velocity or (self.old_velocity and self.old_velocity.y > 0) then
-        return
-    end
-
-	--fallback velocity to allow modularity
-    velocity = velocity or DEFAULT_JUMP_HEIGHT
-
-    self.object:add_velocity(vector.new(0,velocity,0))
-end
-
---make mobs fall slowly
-mobs.mob_fall_slow = function(self)
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = 0,
-		y = -2,
-		z = 0,
-	}
-
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	new_velocity_addition.x = 0
-	new_velocity_addition.z = 0
-
-	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
-	end
-
-	new_velocity_addition.x = 0
-	new_velocity_addition.z = 0
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-
-end
-
-
---[[
- _____          _
-/  ___|        (_)
-\ `--.__      ___ _ __ ___
- `--. \ \ /\ / / | '_ ` _ \
-/\__/ /\ V  V /| | | | | | |
-\____/  \_/\_/ |_|_| |_| |_|
-]]--
-
-
-
-
---make mobs flop
-mobs.flop = function(self, velocity)
-
-    if self.object:get_velocity().y ~= 0 or not self.old_velocity or (self.old_velocity and self.old_velocity.y > 0) then
-        return false
-    end
-
-	mobs.set_velocity(self, 0)
-
-	--fallback velocity to allow modularity
-    velocity = velocity or DEFAULT_JUMP_HEIGHT
-
-	--create a random direction (2d yaw)
-	local dir = DOUBLE_PI * math.random()
-
-	--create a random force value
-	local force = math.random(0,3) + math.random()
-
-	--convert the yaw to a direction vector then multiply it times the force
-	local final_additional_force = vector.multiply(minetest_yaw_to_dir(dir), force)
-
-	--place in the "flop" velocity to make the mob flop
-	final_additional_force.y = velocity
-
-    self.object:add_velocity(final_additional_force)
-
-	return true
-end
-
-
-
--- move mob in facing direction
---this has been modified to be internal
---internal = lua (self.yaw)
---engine = c++ (self.object:get_yaw())
-mobs.set_swim_velocity = function(self, v)
-
-	local yaw = (self.yaw or 0)
-	local pitch = (self.pitch or 0)
-
-	if v == 0 then
-		pitch = 0
-	end
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = (math.sin(yaw) * -v),
-		y = pitch,
-		z = (math.cos(yaw) * v),
-	}
-
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
-	end
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
---[[
-______ _
-|  ___| |
-| |_  | |_   _
-|  _| | | | | |
-| |   | | |_| |
-\_|   |_|\__, |
-          __/ |
-         |___/
-]]--
-
--- move mob in facing direction
---this has been modified to be internal
---internal = lua (self.yaw)
---engine = c++ (self.object:get_yaw())
-mobs.set_fly_velocity = function(self, v)
-
-	local yaw = (self.yaw or 0)
-	local pitch = (self.pitch or 0)
-
-	if v == 0 then
-		pitch = 0
-	end
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = (math.sin(yaw) * -v),
-		y = pitch,
-		z = (math.cos(yaw) * v),
-	}
-
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
-	end
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
---a quick and simple pitch calculation between two vector positions
-mobs.calculate_pitch = function(pos1, pos2)
-
-	if pos1 == nil or pos2 == nil then
-		return false
-	end
-
-    return minetest_dir_to_yaw(vector.new(vector.distance(vector.new(pos1.x,0,pos1.z),vector.new(pos2.x,0,pos2.z)),0,pos1.y - pos2.y)) + HALF_PI
-end
-
---make mobs fly up or down based on their y difference
-mobs.set_pitch_while_attacking = function(self)
-	local pos1 = self.object:get_pos()
-	local pos2 = self.attacking:get_pos()
-
-	local pitch = mobs.calculate_pitch(pos2,pos1)
-
-	self.pitch = pitch
-end
-
-
-
---[[
-   ___
-  |_  |
-    | |_   _ _ __ ___  _ __
-    | | | | | '_ ` _ \| '_ \
-/\__/ / |_| | | | | | | |_) |
-\____/ \__,_|_| |_| |_| .__/
-                      | |
-                      |_|
-]]--
-
---special mob jump movement
-mobs.jump_move = function(self, velocity)
-
-    if self.object:get_velocity().y ~= 0 or not self.old_velocity or (self.old_velocity and self.old_velocity.y > 0) then
-        return
-    end
-
-	--make the mob stick for a split second
-	mobs.set_velocity(self,0)
-
-	--fallback velocity to allow modularity
-    local jump_height = DEFAULT_JUMP_HEIGHT
-
-	local yaw = (self.yaw or 0)
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = (math.sin(yaw) * -velocity),
-		y = jump_height,
-		z = (math.cos(yaw) * velocity),
-	}
-
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
-	end
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
---make it so mobs do not glitch out and freak out
---when moving around over nodes
-mobs.swap_auto_step_height_adjust = function(self)
-	local y_vel = self.object:get_velocity().y
-
-	if y_vel == 0 and self.stepheight ~= self.stepheight_backup then
-		self.stepheight = self.stepheight_backup
-	elseif y_vel ~= 0 and self.stepheight ~= 0 then
-		self.stepheight = 0
-	end
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/projectile_handling.lua

@@ -1,43 +0,0 @@
-local GRAVITY             = minetest.settings:get("movement_gravity")-- + 9.81
-
-mobs.shoot_projectile_handling = function(arrow_item, pos, dir, yaw, shooter, power, damage, is_critical, bow_stack, collectable, gravity)
-	local obj = minetest.add_entity({x=pos.x,y=pos.y,z=pos.z}, arrow_item.."_entity")
-	if power == nil then
-		power = 19
-	end
-	if damage == nil then
-		damage = 3
-	end
-
-    gravity = gravity or -GRAVITY
-
-	local knockback
-	if bow_stack then
-		local enchantments = mcl_enchanting.get_enchantments(bow_stack)
-		if enchantments.power then
-			damage = damage + (enchantments.power + 1) / 4
-		end
-		if enchantments.punch then
-			knockback = enchantments.punch * 3
-		end
-		if enchantments.flame then
-			mcl_burning.set_on_fire(obj, math.huge)
-		end
-	end
-	obj:set_velocity({x=dir.x*power, y=dir.y*power, z=dir.z*power})
-	obj:set_acceleration({x=0, y=gravity, z=0})
-	obj:set_yaw(yaw-math.pi/2)
-	local le = obj:get_luaentity()
-	le._shooter = shooter
-	le._damage = damage
-	le._is_critical = is_critical
-	le._startpos = pos
-	le._knockback = knockback
-	le._collectable = collectable
-
-    --play custom shoot sound
-    if shooter and shooter.shoot_sound then
-        minetest.sound_play(shooter.shoot_sound, {pos=pos, max_hear_distance=16}, true)
-    end
-	return obj
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/set_up.lua

@@ -1,224 +0,0 @@
-local math_random = math.random
-
-local minetest_settings = minetest.settings
-
--- CMI support check
-local use_cmi = minetest.global_exists("cmi")
-
--- get entity staticdata
-mobs.mob_staticdata = function(self)
-	--despawn mechanism
-	--don't despawned tamed or bred mobs
-	if not self.tamed and not self.bred then
-		if not mobs.check_for_player_within_area(self, 64) then
-			--print("removing SERIALIZED!")
-			self.object:remove()
-			return
-		end
-	end
-
-	self.remove_ok = true
-	self.attack = nil
-	self.following = nil
-
-	if use_cmi then
-		self.serialized_cmi_components = cmi.serialize_components(self._cmi_components)
-	end
-
-	local tmp = {}
-
-	for _,stat in pairs(self) do
-
-		local t = type(stat)
-
-		if  t ~= "function"
-		and t ~= "nil"
-		and t ~= "userdata"
-		and _ ~= "_cmi_components" then
-			tmp[_] = self[_]
-		end
-	end
-
-	return minetest.serialize(tmp)
-end
-
-
--- activate mob and reload settings
-mobs.mob_activate = function(self, staticdata, def, dtime)
-
-	-- remove monsters in peaceful mode
-	if self.type == "monster" and minetest_settings:get_bool("only_peaceful_mobs", false) then
-		mcl_burning.extinguish(self.object)
-		self.object:remove()
-		return
-	end
-
-	-- load entity variables
-	local tmp = minetest.deserialize(staticdata)
-
-	if tmp then
-		for _,stat in pairs(tmp) do
-			self[_] = stat
-		end
-	end
-
-	--set up wandering
-	if not self.wandering then
-		self.wandering = true
-	end
-
-	--clear animation
-	self.current_animation = nil
-
-	-- select random texture, set model and size
-	if not self.base_texture then
-
-		-- compatiblity with old simple mobs textures
-		if type(def.textures[1]) == "string" then
-			def.textures = {def.textures}
-		end
-
-		self.base_texture = def.textures[math_random(1, #def.textures)]
-		self.base_mesh = def.mesh
-		self.base_size = self.visual_size
-		self.base_colbox = self.collisionbox
-		self.base_selbox = self.selectionbox
-	end
-
-	-- for current mobs that dont have this set
-	if not self.base_selbox then
-		self.base_selbox = self.selectionbox or self.base_colbox
-	end
-
-	-- set texture, model and size
-	local textures = self.base_texture
-	local mesh = self.base_mesh
-	local vis_size = self.base_size
-	local colbox = self.base_colbox
-	local selbox = self.base_selbox
-
-	-- specific texture if gotten
-	if self.gotten == true
-	and def.gotten_texture then
-		textures = def.gotten_texture
-	end
-
-	-- specific mesh if gotten
-	if self.gotten == true
-	and def.gotten_mesh then
-		mesh = def.gotten_mesh
-	end
-
-	-- set baby mobs to half size
-	if self.baby == true then
-
-		vis_size = {
-			x = self.base_size.x * self.baby_size,
-			y = self.base_size.y * self.baby_size,
-		}
-
-		if def.child_texture then
-			textures = def.child_texture[1]
-		end
-
-		colbox = {
-			self.base_colbox[1] * self.baby_size,
-			self.base_colbox[2] * self.baby_size,
-			self.base_colbox[3] * self.baby_size,
-			self.base_colbox[4] * self.baby_size,
-			self.base_colbox[5] * self.baby_size,
-			self.base_colbox[6] * self.baby_size
-		}
-		selbox = {
-			self.base_selbox[1] * self.baby_size,
-			self.base_selbox[2] * self.baby_size,
-			self.base_selbox[3] * self.baby_size,
-			self.base_selbox[4] * self.baby_size,
-			self.base_selbox[5] * self.baby_size,
-			self.base_selbox[6] * self.baby_size
-		}
-	end
-
-	--stop mobs from reviving
-	if not self.dead and not self.health then
-		self.health = math_random (self.hp_min, self.hp_max)
-	end
-
-	if not self.random_sound_timer then
-		self.random_sound_timer = math_random(self.random_sound_timer_min,self.random_sound_timer_max)
-	end
-
-	if self.breath == nil then
-		self.breath = self.breath_max
-	end
-
-	-- pathfinding init
-	self.path = {}
-	self.path.way = {} -- path to follow, table of positions
-	self.path.lastpos = {x = 0, y = 0, z = 0}
-	self.path.stuck = false
-	self.path.following = false -- currently following path?
-	self.path.stuck_timer = 0 -- if stuck for too long search for path
-
-	-- Armor groups
-	-- immortal=1 because we use custom health
-	-- handling (using "health" property)
-	local armor
-	if type(self.armor) == "table" then
-		armor = table.copy(self.armor)
-		armor.immortal = 1
-	else
-		armor = {immortal=1, fleshy = self.armor}
-	end
-	self.object:set_armor_groups(armor)
-	self.old_y = self.object:get_pos().y
-	self.old_health = self.health
-	self.sounds.distance = self.sounds.distance or 10
-	self.textures = textures
-	self.mesh = mesh
-	self.collisionbox = colbox
-	self.selectionbox = selbox
-	self.visual_size = vis_size
-	self.standing_in = "ignore"
-	self.standing_on = "ignore"
-	self.jump_sound_cooloff = 0 -- used to prevent jump sound from being played too often in short time
-	self.opinion_sound_cooloff = 0 -- used to prevent sound spam of particular sound types
-
-	self.texture_mods = {}
-
-	self.v_start = false
-	self.timer = 0
-	self.blinktimer = 0
-	self.blinkstatus = false
-
-
-	--continue mob effect on server restart
-	if self.dead or self.health <= 0 then
-		self.object:set_texture_mod("^[colorize:red:120")
-	else
-		self.object:set_texture_mod("")
-	end
-
-	-- set anything changed above
-	self.object:set_properties(self)
-
-	--update_tag(self)
-	--mobs.set_animation(self, "stand")
-
-	-- run on_spawn function if found
-	if self.on_spawn and not self.on_spawn_run then
-		if self.on_spawn(self) then
-			self.on_spawn_run = true --  if true, set flag to run once only
-		end
-	end
-
-	-- run after_activate
-	if def.after_activate then
-		def.after_activate(self, staticdata, def, dtime)
-	end
-
-	if use_cmi then
-		self._cmi_components = cmi.activate_components(self.serialized_cmi_components)
-		cmi.notify_activate(self.object, dtime)
-	end
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/sound_handling.lua

@@ -1,59 +0,0 @@
-local math_random = math.random
-
-
---generic call for sound handler for mobs (data access)
-mobs.play_sound = function(self,sound)
-    local soundinfo = self.sounds
-
-    if not soundinfo then
-        return
-    end
-
-    local play_sound = soundinfo[sound]
-
-    if not play_sound then
-        return
-    end
-
-    mobs.play_sound_handler(self, play_sound)
-end
-
-
---generic sound handler for mobs
-mobs.play_sound_handler = function(self, sound)
-    local pitch = (100 + math_random(-15,15) + math_random()) / 100
-    local distance = self.sounds.distance or 16
-
-    minetest.sound_play(sound, {
-        object = self.object,
-        gain = 1.0,
-        max_hear_distance = distance,
-        pitch = pitch,
-    }, true)
-end
-
-
---random sound timing handler
-mobs.random_sound_handling = function(self,dtime)
-
-    self.random_sound_timer = self.random_sound_timer - dtime
-
-    --play sound and reset timer
-    if self.random_sound_timer <= 0 then
-        mobs.play_sound(self,"random")
-        self.random_sound_timer = math_random(self.random_sound_timer_min,self.random_sound_timer_max)
-    end
-end
-
---used for playing a non-mob internal sound at random pitches
-mobs.play_sound_specific = function(self,soundname)
-    local pitch = (100 + math_random(-15,15) + math_random()) / 100
-    local distance = self.sounds.distance or 16
-
-    minetest.sound_play(soundname, {
-        object = self.object,
-        gain = 1.0,
-        max_hear_distance = distance,
-        pitch = pitch,
-    }, true)
-end

mods/ENTITIES/mcl_mobs/crafts.lua

@@ -1,5 +1,5 @@
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mcl_mobs")
 
 -- name tag
 minetest.register_craftitem("mcl_mobs:nametag", {

mods/ENTITIES/mcl_mobs/init.lua

@@ -1,16 +1,14 @@
 
 local path = minetest.get_modpath(minetest.get_current_modname())
 
-local api_path = path.."/api"
-
 -- Mob API
-dofile(api_path .. "/api.lua")
+dofile(path .. "/api.lua")
 
 -- Spawning Algorithm
-dofile(api_path .. "/spawning.lua")
+dofile(path .. "/spawning.lua")
 
 -- Rideable Mobs
-dofile(api_path .. "/mount.lua")
+dofile(path .. "/mount.lua")
 
 -- Mob Items
 dofile(path .. "/crafts.lua")

mods/ENTITIES/mcl_mobs/locale/mcl_mobs.pl.tr

@@ -1,11 +0,0 @@
-# textdomain: mcl_mobs
-Peaceful mode active! No monsters will spawn.=Tryb pokojowy aktywowany! Potwory nie będą się pojawiać.
-This allows you to place a single mob.=To pozwala na przywołanie jednego moba.
-Just place it where you want the mob to appear. Animals will spawn tamed, unless you hold down the sneak key while placing. If you place this on a mob spawner, you change the mob it spawns.=Postaw to w miejscu w którym chcesz aby pojawił się mob. Zwierzęta pojawią się jako oswojone chyba, że będziesz się skradał podczas stawiania. Jeśli postawisz to na spawnerze to zmienisz którego moba przywołuje.
-You need the “maphack” privilege to change the mob spawner.=Potrzebujesz przywileju "maphack", aby zmienić spawner.
-Name Tag=Znacznik
-A name tag is an item to name a mob.=Znacznik jest przedmiotem pozwalającym nazwać moba.
-Before you use the name tag, you need to set a name at an anvil. Then you can use the name tag to name a mob. This uses up the name tag.=Zanim użyjesz znacznika musisz wybrać imię przy kowadle. Następnie możesz użyć znacznika by nazwać moba. To zużywa znacznik.
-Only peaceful mobs allowed!=Tylko pokojowe moby są dozwolone!
-Give names to mobs=Nazwij moby
-Set name at anvil=Wybierz imię przy kowadle

mods/ENTITIES/mcl_mobs/lucky_block.lua

@@ -0,0 +1,8 @@
+
+if minetest.get_modpath("lucky_block") then
+
+	lucky_block:add_blocks({
+		{"dro", {"mcl_mobs:nametag"}, 1},
+		{"lig"},
+	})
+end

mods/ENTITIES/mcl_mobs/mod.conf

@@ -2,4 +2,4 @@ name = mcl_mobs
 author = PilzAdam
 description = Adds a mob API for mods to add animals or monsters, etc.
 depends = mcl_particles
-optional_depends = mcl_weather, mcl_explosions, mcl_hunger, mcl_worlds, cmi, doc_identifier, mcl_armor, mcl_portals, mcl_experience
+optional_depends = mcl_weather, mcl_explosions, mcl_hunger, mcl_worlds, invisibility, lucky_block, cmi, doc_identifier, mcl_armor, mcl_portals, mcl_experience

mods/ENTITIES/mcl_mobs/mount.lua

@@ -1,11 +1,8 @@
 
 -- lib_mount by Blert2112 (edited by TenPlus1)
 
---local enable_crash = false
+local enable_crash = false
---local crash_threshold = 6.5 -- ignored if enable_crash=false
+local crash_threshold = 6.5 -- ignored if enable_crash=false
-
-local math = math
-local vector = vector
 
 ------------------------------------------------------------------------------
 
@@ -13,7 +10,7 @@ local vector = vector
 -- Helper functions
 --
 
---[[local function node_ok(pos, fallback)
+local node_ok = function(pos, fallback)
 
 	fallback = fallback or mobs.fallback_node
 
@@ -24,10 +21,10 @@ local vector = vector
 	end
 
 	return {name = fallback}
-end]]
+end
 
 
---[[local function node_is(pos)
+local function node_is(pos)
 
 	local node = node_ok(pos)
 
@@ -48,7 +45,7 @@ end]]
 	end
 
 	return "other"
-end]]
+end
 
 
 local function get_sign(i)
@@ -63,11 +60,13 @@ local function get_sign(i)
 end
 
 
---[[local function get_velocity(v, yaw, y)
+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]]
+end
 
 
 local function get_v(v)
@@ -173,7 +172,7 @@ function mobs.detach(player, offset)
 
 	--pos = {x = pos.x + offset.x, y = pos.y + 0.2 + offset.y, z = pos.z + offset.z}
 
-	player:add_velocity(vector.new(math.random(-6,6), math.random(5,8), math.random(-6,6))) --throw the rider off
+	player:add_velocity(vector.new(math.random(-6,6),math.random(5,8),math.random(-6,6))) --throw the rider off
 
 	--[[
 	minetest.after(0.1, function(name, pos)
@@ -188,13 +187,13 @@ end
 
 function mobs.drive(entity, moving_anim, stand_anim, can_fly, dtime)
 
-	--local rot_view = 0
+	local rot_view = 0
 
-	--if entity.player_rotation.y == 90 then
+	if entity.player_rotation.y == 90 then
-	--	rot_view = math.pi/2
+		rot_view = math.pi/2
-	--end
+	end
 
-	--local acce_y = 0
+	local acce_y = 0
 	local velo = entity.object:get_velocity()
 
 	entity.v = get_v(velo) * get_sign(entity.v)
@@ -207,30 +206,21 @@ function mobs.drive(entity, moving_anim, stand_anim, can_fly, dtime)
 		-- move forwards
 		if ctrl.up then
 
-			mobs.set_velocity(entity, entity.run_velocity)
+			entity.v = entity.v + entity.accel / 10
-
-			mobs.set_mob_animation(entity, moving_anim)
 
 		-- move backwards
 		elseif ctrl.down then
 
-			mobs.set_velocity(entity, -entity.run_velocity)
+			if entity.max_speed_reverse == 0 and entity.v == 0 then
+				return
+			end
 
-			mobs.set_mob_animation(entity, moving_anim)
+			entity.v = entity.v - entity.accel / 10
-
-		--halt
-		else
-
-			mobs.set_velocity(entity, 0)
-
-			mobs.set_mob_animation(entity, stand_anim)
 		end
 
-		-- mob rotation
+		-- fix mob rotation
 		entity.object:set_yaw(entity.driver:get_look_horizontal() - entity.rotate)
-		entity.yaw = entity.driver:get_look_horizontal() - entity.rotate
 
-		--[[
 		if can_fly then
 
 			-- fly up
@@ -254,21 +244,32 @@ function mobs.drive(entity, moving_anim, stand_anim, can_fly, dtime)
 			end
 
 		else
-			]]--
 
-		-- jump
+			-- jump
-		if ctrl.jump then
+			if ctrl.jump then
+
+				if velo.y == 0 then
+					velo.y = velo.y + entity.jump_height
+					acce_y = acce_y + (acce_y * 3) + 1
+				end
+			end
 
-			mobs.jump(entity)
 		end
-
-		--end
 	end
 
-	--[[
+	-- if not moving then set animation and return
+	if entity.v == 0 and velo.x == 0 and velo.y == 0 and velo.z == 0 then
+
+		if stand_anim then
+			mobs:set_animation(entity, stand_anim)
+		end
+
+		return
+	end
+
 	-- set moving animation
 	if moving_anim then
-		mobs:set_mob_animation(entity, moving_anim)
+		mobs:set_animation(entity, moving_anim)
 	end
 
 	-- Stop!
@@ -382,17 +383,13 @@ function mobs.drive(entity, moving_anim, stand_anim, can_fly, dtime)
 	end
 
 	entity.v2 = v
-	]]--
 end
 
 
 -- directional flying routine by D00Med (edited by TenPlus1)
 
 function mobs.fly(entity, dtime, speed, shoots, arrow, moving_anim, stand_anim)
-	if true then
+
-		print("succ")
-		return
-	end
 	local ctrl = entity.driver:get_player_control()
 	local velo = entity.object:get_velocity()
 	local dir = entity.driver:get_look_dir()
@@ -443,9 +440,9 @@ function mobs.fly(entity, dtime, speed, shoots, arrow, moving_anim, stand_anim)
 	-- change animation if stopped
 	if velo.x == 0 and velo.y == 0 and velo.z == 0 then
 
-		mobs:set_mob_animation(entity, stand_anim)
+		mobs:set_animation(entity, stand_anim)
 	else
 		-- moving animation
-		mobs:set_mob_animation(entity, moving_anim)
+		mobs:set_animation(entity, moving_anim)
 	end
 end

mods/ENTITIES/mcl_mobs/sounds/attributes.txt

@@ -1,4 +0,0 @@
- 
-default_punch.1 = https://freesound.org/people/Merrick079/sounds/566436/
-default_punch.2 = https://freesound.org/people/Merrick079/sounds/566435/
-default_punch.3 = https://freesound.org/people/Merrick079/sounds/566434/

mods/ENTITIES/mcl_mobs/spawning.lua

@@ -1,32 +1,17 @@
 --lua locals
-local get_node                     = minetest.get_node
+local get_node       = minetest.get_node
-local get_item_group               = minetest.get_item_group
+local get_item_group = minetest.get_item_group
-local get_node_light               = minetest.get_node_light
+local get_node_light = minetest.get_node_light
 local find_nodes_in_area_under_air = minetest.find_nodes_in_area_under_air
-local get_biome_name               = minetest.get_biome_name
+local new_vector     = vector.new
-local get_objects_inside_radius    = minetest.get_objects_inside_radius
-local get_connected_players        = minetest.get_connected_players
-
-
 local math_random    = math.random
-local math_floor     = math.floor
+local get_biome_name = minetest.get_biome_name
---local max            = math.max
+local max            = math.max
-
+local get_objects_inside_radius = minetest.get_objects_inside_radius
---local vector_distance = vector.distance
+local vector_distance = vector.distance
-local vector_new      = vector.new
-local vector_floor    = vector.floor
-
-local table_copy     = table.copy
-local table_remove   = table.remove
-
-local pairs = pairs
 
 -- range for mob count
-local aoc_range = 48
+local aoc_range = 32
-
---do mobs spawn?
-local mobs_spawn = minetest.settings:get_bool("mobs_spawn", true) ~= false
-
 --[[
 
 THIS IS THE BIG LIST OF ALL BIOMES - used for programming/updating mobs
@@ -168,14 +153,28 @@ Overworld regular:
 
 
 
--- count how many mobs are in an area
+
-local function count_mobs(pos)
+local mobs_spawn = minetest.settings:get_bool("mobs_spawn", true) ~= false
+-- count how many mobs of one type are inside an area
+
+local count_mobs = function(pos,mobtype)
 	local num = 0
-	for _,object in pairs(get_objects_inside_radius(pos, aoc_range)) do
+	local objs = get_objects_inside_radius(pos, aoc_range)
-		if object and object:get_luaentity() and object:get_luaentity()._cmi_is_mob then
+	for n = 1, #objs do
-			num = num + 1
+		local obj = objs[n]:get_luaentity()
+		if obj and obj.name and obj._cmi_is_mob then
+			-- count hostile mobs only
+			if mobtype == "hostile" then
+				if obj.spawn_class == "hostile" then
+					num = num + 1
+				end
+			-- count passive mobs only
+			else
+				num = num + 1
+			end
 		end
 	end
+
 	return num
 end
 
@@ -244,7 +243,8 @@ function mobs:spawn_specific(name, dimension, type_of_spawning, biomes, min_ligh
 	end
 
 	--[[
-	local function spawn_action(pos, node, active_object_count, active_object_count_wider, name)
+	local spawn_action
+	spawn_action = function(pos, node, active_object_count, active_object_count_wider, name)
 
 			local orig_pos = table.copy(pos)
 			-- is mob actually registered?
@@ -281,7 +281,7 @@ function mobs:spawn_specific(name, dimension, type_of_spawning, biomes, min_ligh
 			end
 
 			-- if toggle set to nil then ignore day/night check
-			if day_toggle then
+			if day_toggle ~= nil then
 
 				local tod = (minetest.get_timeofday() or 0) * 24000
 
@@ -371,7 +371,7 @@ function mobs:spawn_specific(name, dimension, type_of_spawning, biomes, min_ligh
 						if minetest.registered_nodes[node_ok(pos2).name].walkable == true then
 							-- inside block
 							minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, too little space!")
-							if ent.spawn_small_alternative and (not minetest.registered_nodes[node_ok(pos).name].walkable) then
+							if ent.spawn_small_alternative ~= nil and (not minetest.registered_nodes[node_ok(pos).name].walkable) then
 								minetest.log("info", "Trying to spawn smaller alternative mob: "..ent.spawn_small_alternative)
 								spawn_action(orig_pos, node, active_object_count, active_object_count_wider, ent.spawn_small_alternative)
 							end
@@ -484,26 +484,25 @@ end
 
 local axis
 --inner and outer part of square donut radius
-local inner = 15
+local inner = 1
-local outer = 64
+local outer = 65
 local int = {-1,1}
+local position_calculation = function(pos)
 
-local function position_calculation(pos)
+	pos = vector.floor(pos)
-
-	pos = vector_floor(pos)
 
 	--this is used to determine the axis buffer from the player
-	axis = math_random(0,1)
+	axis = math.random(0,1)
 
 	--cast towards the direction
 	if axis == 0 then --x
-		pos.x = pos.x + math_random(inner,outer)*int[math_random(1,2)]
+		pos.x = pos.x + math.random(inner,outer)*int[math.random(1,2)]
-		pos.z = pos.z + math_random(-outer,outer)
+		pos.z = pos.z + math.random(-outer,outer)
 	else --z
-		pos.z = pos.z + math_random(inner,outer)*int[math_random(1,2)]
+		pos.z = pos.z + math.random(inner,outer)*int[math.random(1,2)]
-		pos.x = pos.x + math_random(-outer,outer)
+		pos.x = pos.x + math.random(-outer,outer)
 	end
-	return pos
+	return(pos)
 end
 
 --[[
@@ -517,7 +516,7 @@ local decypher_limits_dictionary = {
 local function decypher_limits(posy)
 	--local min_max_table = decypher_limits_dictionary[dimension]
 	--return min_max_table[1],min_max_table[2]
-	posy = math_floor(posy)
+	posy = math.floor(posy)
 	return posy - 32, posy + 32
 end
 
@@ -540,169 +539,108 @@ if mobs_spawn then
 	local timer = 0
 	minetest.register_globalstep(function(dtime)
 		timer = timer + dtime
-		if timer >= 10 then
+		if timer >= 8 then
 			timer = 0
-			for _,player in pairs(get_connected_players()) do
+			for _,player in pairs(minetest.get_connected_players()) do
-				-- after this line each "break" means "continue"
+				for i = 1,math_random(3,8) do
-				local do_mob_spawning = true
+					repeat -- after this line each "break" means "continue"
-				repeat
+						local player_pos = player:get_pos()
-					--don't need to get these variables more than once
-					--they happen in a single server step
 
-					local player_pos = player:get_pos()
+						local _,dimension = mcl_worlds.y_to_layer(player_pos.y)
-					local dimension = mcl_worlds.pos_to_dimension(player_pos)
 
-					if dimension == "void" or dimension == "default" then
+						if dimension == "void" or dimension == "default" then
-						break -- ignore void and unloaded area
+							break -- ignore void and unloaded area
-					end
+						end
 
-					local min, max = decypher_limits(player_pos.y)
+						local min,max = decypher_limits(player_pos.y)
 
-					for i = 1, math_random(1,4) do
+						local goal_pos = position_calculation(player_pos)
-						-- after this line each "break" means "continue"
-						local do_mob_algorithm = true
-						repeat
 
-							local goal_pos = position_calculation(player_pos)
+						local spawning_position_list = find_nodes_in_area_under_air(new_vector(goal_pos.x,min,goal_pos.z), vector.new(goal_pos.x,max,goal_pos.z), {"group:solid", "group:water", "group:lava"})
-
-							local spawning_position_list = find_nodes_in_area_under_air(vector_new(goal_pos.x,min,goal_pos.z), vector_new(goal_pos.x,max,goal_pos.z), {"group:solid", "group:water", "group:lava"})
-
-							--couldn't find node
-							if #spawning_position_list <= 0 then
-								break
-							end
-
-							local spawning_position = spawning_position_list[math_random(1,#spawning_position_list)]
-
-							--Prevent strange behavior   --- this is commented out: /too close to player --fixed with inner circle
-							if not spawning_position then --  or vector_distance(player_pos, spawning_position) < 15
-								break
-							end
-
-							--hard code mob limit in area to 5 for now
-							if count_mobs(spawning_position) >= 5 then
-								break
-							end
-
-							local gotten_node = get_node(spawning_position).name
-
-							if not gotten_node or gotten_node == "air" then --skip air nodes
-								break
-							end
-
-							local gotten_biome = minetest.get_biome_data(spawning_position)
-
-							if not gotten_biome then
-								break --skip if in unloaded area
-							end
-
-							gotten_biome = get_biome_name(gotten_biome.biome) --makes it easier to work with
-
-							--add this so mobs don't spawn inside nodes
-							spawning_position.y = spawning_position.y + 1
-
-							--only need to poll for node light if everything else worked
-							local gotten_light = get_node_light(spawning_position)
-
-							local is_water = get_item_group(gotten_node, "water") ~= 0
-							local is_lava  = get_item_group(gotten_node, "lava") ~= 0
-
-							local mob_def = nil
-
-							--create a disconnected clone of the spawn dictionary
-							--prevents memory leak
-							local mob_library_worker_table = table_copy(spawn_dictionary)
-
-							--grab mob that fits into the spawning location
-							--randomly grab a mob, don't exclude any possibilities
-							local repeat_mob_search = true
-							repeat
-
-								--do not infinite loop
-								if #mob_library_worker_table <= 0 then
-									--print("breaking infinite loop")
-									break
-								end
-
-								local skip = false
-
-								--use this for removing table elements of mobs that do not match
-								local temp_index = math_random(1,#mob_library_worker_table)
-
-								local temp_def = mob_library_worker_table[temp_index]
-
-								--skip if something ridiculous happens (nil mob def)
-								--something truly horrible has happened if skip gets
-								--activated at this point
-								if not temp_def then
-									skip = true
-								end
-
-								if not skip and (spawning_position.y < temp_def.min_height or spawning_position.y > temp_def.max_height) then
-									skip = true
-								end
-
-								--skip if not correct dimension
-								if not skip and (temp_def.dimension ~= dimension) then
-									skip = true
-								end
-
-								--skip if not in correct biome
-								if not skip and (not biome_check(temp_def.biomes, gotten_biome)) then
-									skip = true
-								end
-
-								--don't spawn if not in light limits
-								if not skip and (gotten_light < temp_def.min_light or gotten_light > temp_def.max_light) then
-									skip = true
-								end
-
-								--skip if not in correct spawning type
-								if not skip and (temp_def.type_of_spawning == "ground" and is_water) then
-									skip = true
-								end
-
-								if not skip and (temp_def.type_of_spawning == "ground" and is_lava) then
-									skip = true
-								end
-
-								--found a mob, exit out of loop
-								if not skip then
-									--minetest.log("warning", "found mob:"..temp_def.name)
-									--print("found mob:"..temp_def.name)
-									mob_def = table_copy(temp_def)
-									break
-								else
-									--minetest.log("warning", "deleting temp index "..temp_index)
-									--print("deleting temp index")
-									table_remove(mob_library_worker_table, temp_index)
-								end
-
-							until repeat_mob_search == false --this is needed to sort through mobs randomly
-
-
-							--catch if went through all mobs and something went horribly wrong
-							--could not find a valid mob to spawn that fits the environment
-							if not mob_def then
-								break
-							end
-
-							--adjust the position for water and lava mobs
-							if mob_def.type_of_spawning == "water"  or mob_def.type_of_spawning == "lava" then
-								spawning_position.y = spawning_position.y - 1
-							end
-
-							--print("spawning: " .. mob_def.name)
-
-							--everything is correct, spawn mob
-							minetest.add_entity(spawning_position, mob_def.name)
 
+						--couldn't find node
+						if #spawning_position_list <= 0 then
 							break
-						until do_mob_algorithm == false --this is a safety catch
+						end
-					end
 
-					break
+						local spawning_position = spawning_position_list[math_random(1,#spawning_position_list)]
-				until do_mob_spawning == false --this is a performance catch
+
+						--Prevent strange behavior/too close to player
+						if not spawning_position or vector_distance(player_pos, spawning_position) < 15 then
+							break
+						end
+
+						local gotten_node = get_node(spawning_position).name
+
+						if not gotten_node or gotten_node == "air" then --skip air nodes
+							break
+						end
+
+						local gotten_biome = minetest.get_biome_data(spawning_position)
+
+						if not gotten_biome then
+							break --skip if in unloaded area
+						end
+
+						gotten_biome = get_biome_name(gotten_biome.biome) --makes it easier to work with
+
+						--grab random mob
+						local mob_def = spawn_dictionary[math.random(1,#spawn_dictionary)]
+
+						if not mob_def then
+							break --skip if something ridiculous happens (nil mob def)
+						end
+
+						--skip if not correct dimension
+						if mob_def.dimension ~= dimension then
+							break
+						end
+
+						--skip if not in correct biome
+						if not biome_check(mob_def.biomes, gotten_biome) then
+							break
+						end
+
+						--add this so mobs don't spawn inside nodes
+						spawning_position.y = spawning_position.y + 1
+
+						if spawning_position.y < mob_def.min_height or spawning_position.y > mob_def.max_height then
+							break
+						end
+
+						--only need to poll for node light if everything else worked
+						local gotten_light = get_node_light(spawning_position)
+
+						--don't spawn if not in light limits
+						if gotten_light < mob_def.min_light or gotten_light > mob_def.max_light then
+							break
+						end
+
+						local is_water = get_item_group(gotten_node, "water") ~= 0
+						local is_lava  = get_item_group(gotten_node, "lava") ~= 0
+
+						if mob_def.type_of_spawning == "ground" and is_water then
+							break
+						end
+
+						if mob_def.type_of_spawning == "ground" and is_lava then
+							break
+						end
+
+						--finally do the heavy check (for now) of mobs in area
+						if count_mobs(spawning_position, mob_def.spawn_class) >= mob_def.aoc then
+							break
+						end
+
+						--adjust the position for water and lava mobs
+						if mob_def.type_of_spawning == "water"  or mob_def.type_of_spawning == "lava" then
+							spawning_position.y = spawning_position.y - 1
+						end
+
+						--everything is correct, spawn mob
+						minetest.add_entity(spawning_position, mob_def.name)
+					until true --this is a safety catch
+				end
 			end
 		end
 	end)

mods/ENTITIES/mcl_mobs/todo.txt

@@ -1 +0,0 @@
---use vector.distance to count down mob despawn timer

mods/ENTITIES/mobs_mc/0_gameconfig.lua

@@ -15,7 +15,7 @@ with name "mobs_mc_gameconfig". ]]
 -- Set to false in your gameconfig mod if you create your own monster egg nodes.
 mobs_mc.create_monster_egg_nodes = true
 
---mobs_mc.items = {}
+mobs_mc.items = {}
 
 mobs_mc.items = {
 	-- Items defined in mobs_mc
@@ -81,9 +81,7 @@ mobs_mc.items = {
 	gunpowder = "tnt:gunpowder",
 	flint_and_steel = "fire:flint_and_steel",
 	water_source = "default:water_source",
-	water_flowing = "default:water_flowing",
 	river_water_source = "default:river_water_source",
-	--water_flowing = "default:river_water_flowing",
 	black_dye = "dye:black",
 	poppy = "flowers:rose",
 	dandelion = "flowers:dandelion_yellow",
@@ -128,6 +126,7 @@ mobs_mc.items = {
 
 	nether_portal = "nether:portal",
 	netherrack = "nether:rack",
+	nether_brick_block = "nether:brick",
 
 	-- Wool (Minecraft color scheme)
 	wool_white = "wool:white",

mods/ENTITIES/mobs_mc/1_items_default.lua

@@ -8,7 +8,7 @@
 -- NOTE: Most strings intentionally not marked for translation, other mods already have these items.
 -- TODO: Remove this file eventually, most items are already outsourced in other mods.
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 local c = mobs_mc.is_item_variable_overridden
 
@@ -234,8 +234,8 @@ end
 if c("ender_eye") and c("blaze_powder") and c("blaze_rod") then
 	minetest.register_craft({
 		type = "shapeless",
-		output = "mobs_mc:ender_eye",
+		output = 'mobs_mc:ender_eye',
-		recipe = { "mobs_mc:blaze_powder", "mobs_mc:blaze_rod"},
+		recipe = { 'mobs_mc:blaze_powder', 'mobs_mc:blaze_rod'},
 	})
 end
 

mods/ENTITIES/mobs_mc/2_throwing.lua

@@ -6,7 +6,7 @@
 -- NOTE: Strings intentionally not marked for translation, other mods already have these items.
 -- TODO: Remove this file eventually, all items here are already outsourced in other mods.
 
---local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --maikerumines throwing code
 --arrow (weapon)
@@ -83,7 +83,7 @@ THROWING_ARROW_ENTITY.on_step = function(self, dtime)
 	if self.timer>0.2 then
 		local objs = minetest.get_objects_inside_radius({x=pos.x,y=pos.y,z=pos.z}, 1.5)
 		for k, obj in pairs(objs) do
-			if obj:get_luaentity() then
+			if obj:get_luaentity() ~= nil then
 				if obj:get_luaentity().name ~= "mobs_mc:arrow_entity" and obj:get_luaentity().name ~= "__builtin:item" then
 					local damage = 3
 					minetest.sound_play("damage", {pos = pos}, true)
@@ -108,7 +108,7 @@ THROWING_ARROW_ENTITY.on_step = function(self, dtime)
 	if self.lastpos.x~=nil then
 		if node.name ~= "air" then
 			minetest.sound_play("bowhit1", {pos = pos}, true)
-			minetest.add_item(self.lastpos, "mobs_mc:arrow")
+			minetest.add_item(self.lastpos, 'mobs_mc:arrow')
 			self.object:remove()
 		end
 	end
@@ -155,7 +155,7 @@ end
 
 if c("arrow") and c("flint") and c("feather") and c("stick") then
 	minetest.register_craft({
-		output = "mobs_mc:arrow 4",
+		output = 'mobs_mc:arrow 4',
 		recipe = {
 			{mobs_mc.items.flint},
 			{mobs_mc.items.stick},
@@ -181,11 +181,11 @@ if c("bow") then
 	})
 
 	minetest.register_craft({
-		output = "mobs_mc:bow_wood",
+		output = 'mobs_mc:bow_wood',
 		recipe = {
-			{mobs_mc.items.string, mobs_mc.items.stick, ""},
+			{mobs_mc.items.string, mobs_mc.items.stick, ''},
-			{mobs_mc.items.string, "", mobs_mc.items.stick},
+			{mobs_mc.items.string, '', mobs_mc.items.stick},
-			{mobs_mc.items.string, mobs_mc.items.stick, ""},
+			{mobs_mc.items.string, mobs_mc.items.stick, ''},
 		}
 	})
 end
@@ -259,7 +259,7 @@ if c("egg") then
 	})
 
 	-- shoot egg
-	local function mobs_shoot_egg(item, player, pointed_thing)
+	local mobs_shoot_egg = function (item, player, pointed_thing)
 
 		local playerpos = player:get_pos()
 
@@ -349,7 +349,7 @@ mobs:register_arrow("mobs_mc:snowball_entity", {
 
 if c("snowball") then
 	-- shoot snowball
-	local function mobs_shoot_snowball(item, player, pointed_thing)
+	local mobs_shoot_snowball = function (item, player, pointed_thing)
 
 		local playerpos = player:get_pos()
 

mods/ENTITIES/mobs_mc/4_heads.lua

@@ -3,9 +3,8 @@
 
 -- NOTE: Strings intentionally not marked for translation, other mods already have these items.
 -- TODO: Remove this file eventually, all items here are already outsourced in other mods.
--- TODO: Add translation.
 
---local S = local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 -- Heads system
 

mods/ENTITIES/mobs_mc/LICENSE-media.md

@@ -190,10 +190,9 @@ Origin of those models:
 * [Spennnyyy](https://freesound.org/people/Spennnyyy/) (CC0)
     * `mcl_totems_totem.ogg`
         * Source: <https://freesound.org/people/Spennnyyy/sounds/323502/>
-* [Baŝto](https://opengameart.org/users/ba%C5%9Dto) (remixer) and [kantouth](https://freesound.org/people/kantouth/) (original author)
+* [Baŝto](https://opengameart.org/users/ba%C5%9Dto)
     * `mobs_mc_skeleton_random.*.ogg` (CC BY 3.0)
         * Source: <https://opengameart.org/content/walking-skeleton>
-            * Based on:  <https://freesound.org/people/kantouth/sounds/115113/>
 * [spookymodem](https://freesound.org/people/spookymodem/)
     * `mobs_mc_skeleton_death.ogg` (CC0)
         * <https://freesound.org/people/spookymodem/sounds/202091/>
@@ -307,4 +306,4 @@ Origin of those models:
 
 Note: Many of these sounds have been more or less modified to fit the game.
 
-Sounds not mentioned here are licensed under CC0.
+Sounds not mentioned hre are licensed under CC0.

mods/ENTITIES/mobs_mc/agent.lua

@@ -2,7 +2,7 @@
 --################### AGENT - seemingly unused
 --###################
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 mobs:register_mob("mobs_mc:agent", {
 	type = "npc",

mods/ENTITIES/mobs_mc/bat.lua

@@ -1,6 +1,6 @@
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 mobs:register_mob("mobs_mc:bat", {
 	description = S("Bat"),
@@ -8,9 +8,6 @@ mobs:register_mob("mobs_mc:bat", {
 	spawn_class = "ambient",
 	can_despawn = true,
 	passive = true,
-	rotate = 270,
-	tilt_fly = true,
-	fly = true,
 	hp_min = 6,
 	hp_max = 6,
 	collisionbox = {-0.25, -0.01, -0.25, 0.25, 0.89, 0.25},
@@ -48,7 +45,9 @@ mobs:register_mob("mobs_mc:bat", {
 	fall_damage = 0,
 	view_range = 16,
 	fear_height = 0,
+
 	jump = false,
+	fly = true,
 	makes_footstep_sound = false,
 })
 

mods/ENTITIES/mobs_mc/blaze.lua

@@ -3,7 +3,7 @@
 -- Model and mobs_blaze.png see https://github.com/22i/minecraft-voxel-blender-models -hi 22i ~jordan4ibanez
 -- blaze.lua partial copy of mobs_mc/ghast.lua
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### BLAZE
@@ -18,9 +18,6 @@ mobs:register_mob("mobs_mc:blaze", {
 	hp_max = 20,
 	xp_min = 10,
 	xp_max = 10,
-	tilt_fly = false,
-	hostile = true,
-	--rotate = 270,
 	collisionbox = {-0.3, -0.01, -0.3, 0.3, 1.79, 0.3},
 	rotate = -180,
 	visual = "mesh",
@@ -39,7 +36,7 @@ mobs:register_mob("mobs_mc:blaze", {
 	walk_velocity = .8,
 	run_velocity = 1.6,
 	damage = 6,
-	reach = 4, -- don't want blaze getting too close
+	reach = 2,
 	pathfinding = 1,
 	drops = {
 		{name = mobs_mc.items.blaze_rod,
@@ -67,7 +64,7 @@ mobs:register_mob("mobs_mc:blaze", {
 	fall_speed = -2.25,
 	light_damage = 0,
 	view_range = 16,
-	attack_type = "projectile",
+	attack_type = "dogshoot",
 	arrow = "mobs_mc:blaze_fireball",
 	shoot_interval = 3.5,
 	shoot_offset = 1.0,
@@ -79,18 +76,9 @@ mobs:register_mob("mobs_mc:blaze", {
 	fear_height = 0,
 	glow = 14,
 	fire_resistant = true,
-	eye_height = 0.75,
-	projectile_cooldown_min = 2,
-	projectile_cooldown_max = 3,
-	shoot_arrow = function(self, pos, dir)
-		-- 2-4 damage per arrow
-		local dmg = math.random(2,4)
-		mobs.shoot_projectile_handling("mobs_mc:blaze_fireball", pos, dir, self.object:get_yaw(), self.object, 7, dmg,nil,nil,nil,-0.4)
-	end,
-
 	do_custom = function(self)
-		if self.attacking and self.state == "attack" and vector.distance(self.object:get_pos(), self.attacking:get_pos()) < 1.2 then
+		if self.state == "attack" and self.attack:get_pos() and vector.distance(self.object:get_pos(), self.attack:get_pos()) < 1.2 then
-			mcl_burning.set_on_fire(self.attacking, 5)
+			mcl_burning.set_on_fire(self.attack, 5)
 		end
 		local pos = self.object:get_pos()
 		minetest.add_particle({
@@ -160,11 +148,6 @@ mobs:register_arrow("mobs_mc:blaze_fireball", {
 	visual_size = {x = 0.3, y = 0.3},
 	textures = {"mcl_fire_fire_charge.png"},
 	velocity = 15,
-	speed = 5,
-	tail = 1,
-	tail_texture = "mobs_mc_spit.png^[colorize:black:255", --repurpose spit texture
-	tail_size = 2,
-	tail_distance_divider = 3,
 	_is_fireball = true,
 
 	-- Direct hit, no fire... just plenty of pain
@@ -172,7 +155,7 @@ mobs:register_arrow("mobs_mc:blaze_fireball", {
 		mcl_burning.set_on_fire(player, 5)
 		player:punch(self.object, 1.0, {
 			full_punch_interval = 1.0,
-			damage_groups = {fleshy = self._damage},
+			damage_groups = {fleshy = 5},
 		}, nil)
 	end,
 
@@ -180,7 +163,7 @@ mobs:register_arrow("mobs_mc:blaze_fireball", {
 		mcl_burning.set_on_fire(mob, 5)
 		mob:punch(self.object, 1.0, {
 			full_punch_interval = 1.0,
-			damage_groups = {fleshy = self._damage},
+			damage_groups = {fleshy = 5},
 		}, nil)
 	end,
 
@@ -195,9 +178,7 @@ mobs:register_arrow("mobs_mc:blaze_fireball", {
 
 	-- Node hit, make fire
 	hit_node = function(self, pos, node)
-		if node.name ~= "air" then
+		if node.name == "air" then
-			local pos_above = table.copy(pos)
-			pos_above.y = pos_above.y + 1
 			minetest.set_node(pos_above, {name=mobs_mc.items.fire})
 		else
 			local v = self.object:get_velocity()

mods/ENTITIES/mobs_mc/chicken.lua

@@ -1,6 +1,6 @@
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### CHICKEN
@@ -18,8 +18,7 @@ mobs:register_mob("mobs_mc:chicken", {
 	xp_min = 1,
 	xp_max = 3,
 	collisionbox = {-0.2, -0.01, -0.2, 0.2, 0.69, 0.2},
-	skittish = true,
+	runaway = true,
-	fall_slow = true,
 	floats = 1,
 	visual = "mesh",
 	mesh = "mobs_mc_chicken.b3d",
@@ -27,10 +26,9 @@ mobs:register_mob("mobs_mc:chicken", {
 		{"mobs_mc_chicken.png"},
 	},
 	visual_size = {x=2.2, y=2.2},
-	rotate = 270,
+
 	makes_footstep_sound = true,
 	walk_velocity = 1,
-	run_velocity = 3,
 	drops = {
 		{name = mobs_mc.items.chicken_raw,
 		chance = 1,
@@ -66,25 +64,14 @@ mobs:register_mob("mobs_mc:chicken", {
 		run_start = 0,		run_end = 40,
 	},
 
-	follow = "mcl_farming:wheat_seeds",
+	follow = mobs_mc.follow.chicken,
-	breed_distance = 1.5,
-	baby_size = 0.5,
-	follow_distance = 2,
 	view_range = 16,
 	fear_height = 4,
 
-	--why do chickend breed if they lay eggs??
 	on_rightclick = function(self, clicker)
-		--attempt to enter breed state
+		if mobs:feed_tame(self, clicker, 1, true, true) then return end
-		if mobs.enter_breed_state(self,clicker) then
+		if mobs:protect(self, clicker) then return end
-			return
+		if mobs:capture_mob(self, clicker, 0, 60, 5, false, nil) then return end
-		end
-
-		--make baby grow faster
-		if self.baby then
-			mobs.make_baby_grow_faster(self,clicker)
-			return
-		end
 	end,
 
 	do_custom = function(self, dtime)
@@ -111,21 +98,6 @@ mobs:register_mob("mobs_mc:chicken", {
 		}, true)
 	end,
 
-	--head code
-	has_head = true,
-	head_bone = "head",
-
-	swap_y_with_x = false,
-	reverse_head_yaw = false,
-
-	head_bone_pos_y = 1.675,
-	head_bone_pos_z = 0,
-
-	head_height_offset = 0.55,
-	head_direction_offset = 0.0925,
-
-	head_pitch_modifier = -math.pi/2,
-	--end head code
 })
 
 --spawn
@@ -134,53 +106,22 @@ mobs:spawn_specific(
 "overworld",
 "ground",
 {
-	"FlowerForest_beach",
+"FlowerForest",
-	"Forest_beach",
+"Swampland",
-	"StoneBeach",
+"Taiga",
-	"ColdTaiga_beach_water",
+"ExtremeHills",
-	"Taiga_beach",
+"BirchForest",
-	"Savanna_beach",
+"MegaSpruceTaiga",
-	"Plains_beach",
+"MegaTaiga",
-	"ExtremeHills_beach",
+"ExtremeHills+",
-	"ColdTaiga_beach",
+"Forest",
-	"Swampland_shore",
+"Plains",
-	"JungleM_shore",
+"ColdTaiga",
-	"Jungle_shore",
+"SunflowerPlains",
-	"MesaPlateauFM_sandlevel",
+"RoofedForest",
-	"MesaPlateauF_sandlevel",
+"MesaPlateauFM_grasstop",
-	"MesaBryce_sandlevel",
+"ExtremeHillsM",
-	"Mesa_sandlevel",
+"BirchForestM",
-	"Mesa",
-	"FlowerForest",
-	"Swampland",
-	"Taiga",
-	"ExtremeHills",
-	"Jungle",
-	"Savanna",
-	"BirchForest",
-	"MegaSpruceTaiga",
-	"MegaTaiga",
-	"ExtremeHills+",
-	"Forest",
-	"Plains",
-	"Desert",
-	"ColdTaiga",
-	"IcePlainsSpikes",
-	"SunflowerPlains",
-	"IcePlains",
-	"RoofedForest",
-	"ExtremeHills+_snowtop",
-	"MesaPlateauFM_grasstop",
-	"JungleEdgeM",
-	"ExtremeHillsM",
-	"JungleM",
-	"BirchForestM",
-	"MesaPlateauF",
-	"MesaPlateauFM",
-	"MesaPlateauF_grasstop",
-	"MesaBryce",
-	"JungleEdge",
-	"SavannaM",
 },
 9,
 minetest.LIGHT_MAX+1,

mods/ENTITIES/mobs_mc/cow+mooshroom.lua

@@ -1,6 +1,6 @@
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 local cow_def = {
 	description = S("Cow"),
@@ -10,7 +10,6 @@ local cow_def = {
 	hp_max = 10,
 	xp_min = 1,
 	xp_max = 3,
-	rotate = 270,
 	collisionbox = {-0.45, -0.01, -0.45, 0.45, 1.39, 0.45},
 	visual = "mesh",
 	mesh = "mobs_mc_cow.b3d",
@@ -21,7 +20,6 @@ local cow_def = {
 	visual_size = {x=2.8, y=2.8},
 	makes_footstep_sound = true,
 	walk_velocity = 1,
-	run_velocity = 3,
 	drops = {
 		{name = mobs_mc.items.beef_raw,
 		chance = 1,
@@ -34,7 +32,7 @@ local cow_def = {
 		max = 2,
 		looting = "common",},
 	},
-	skittish = true,
+	runaway = true,
 	sounds = {
 		random = "mobs_mc_cow",
 		damage = "mobs_mc_cow_hurt",
@@ -49,17 +47,12 @@ local cow_def = {
 		walk_end = 40,      run_start = 0,
 		run_end = 40,
 	},
-	--follow = mobs_mc.follow.cow,
+	follow = mobs_mc.follow.cow,
 	on_rightclick = function(self, clicker)
+		if mobs:feed_tame(self, clicker, 1, true, true) then return end
+		if mobs:protect(self, clicker) then return end
 
-		--attempt to enter breed state
+		if self.child then
-		if mobs.enter_breed_state(self,clicker) then
-			return
-		end
-
-		--make baby grow faster
-		if self.baby then
-			mobs.make_baby_grow_faster(self,clicker)
 			return
 		end
 
@@ -78,28 +71,11 @@ local cow_def = {
 			end
 			return
 		end
+		mobs:capture_mob(self, clicker, 0, 5, 60, false, nil)
 	end,
-	breed_distance = 1.5,
-	baby_size = 0.5,
-	follow_distance = 2,
 	follow = mobs_mc.items.wheat,
 	view_range = 10,
 	fear_height = 4,
-
-	--head code
-	has_head = true,
-	head_bone = "head",
-
-	swap_y_with_x = false,
-	reverse_head_yaw = false,
-
-	head_bone_pos_y = 3.6,
-	head_bone_pos_z = -0.6,
-
-	head_height_offset = 1.0525,
-	head_direction_offset = 0.5,
-	head_pitch_modifier = 0,
-	--end head code
 }
 
 mobs:register_mob("mobs_mc:cow", cow_def)
@@ -110,17 +86,12 @@ mooshroom_def.description = S("Mooshroom")
 mooshroom_def.mesh = "mobs_mc_cow.b3d"
 mooshroom_def.textures = { {"mobs_mc_mooshroom.png", "mobs_mc_mushroom_red.png"}, {"mobs_mc_mooshroom_brown.png", "mobs_mc_mushroom_brown.png" } }
 mooshroom_def.on_rightclick = function(self, clicker)
-	--attempt to enter breed state
+	if mobs:feed_tame(self, clicker, 1, true, true) then return end
-	if mobs.enter_breed_state(self,clicker) then
+	if mobs:protect(self, clicker) then return end
+
+	if self.child then
 		return
 	end
-
-	--make baby grow faster
-	if self.baby then
-		mobs.make_baby_grow_faster(self,clicker)
-		return
-	end
-
 	local item = clicker:get_wielded_item()
 	-- Use shears to get mushrooms and turn mooshroom into cow
 	if item:get_name() == mobs_mc.items.shears then
@@ -169,6 +140,7 @@ mooshroom_def.on_rightclick = function(self, clicker)
 			minetest.add_item(pos, {name = mobs_mc.items.mushroom_stew})
 		end
 	end
+	mobs:capture_mob(self, clicker, 0, 5, 60, false, nil)
 end
 mobs:register_mob("mobs_mc:mooshroom", mooshroom_def)
 
@@ -179,53 +151,22 @@ mobs:spawn_specific(
 "overworld",
 "ground",
 {
-	"FlowerForest_beach",
+"FlowerForest",
-	"Forest_beach",
+"Swampland",
-	"StoneBeach",
+"Taiga",
-	"ColdTaiga_beach_water",
+"ExtremeHills",
-	"Taiga_beach",
+"BirchForest",
-	"Savanna_beach",
+"MegaSpruceTaiga",
-	"Plains_beach",
+"MegaTaiga",
-	"ExtremeHills_beach",
+"ExtremeHills+",
-	"ColdTaiga_beach",
+"Forest",
-	"Swampland_shore",
+"Plains",
-	"JungleM_shore",
+"ColdTaiga",
-	"Jungle_shore",
+"SunflowerPlains",
-	"MesaPlateauFM_sandlevel",
+"RoofedForest",
-	"MesaPlateauF_sandlevel",
+"MesaPlateauFM_grasstop",
-	"MesaBryce_sandlevel",
+"ExtremeHillsM",
-	"Mesa_sandlevel",
+"BirchForestM",
-	"Mesa",
-	"FlowerForest",
-	"Swampland",
-	"Taiga",
-	"ExtremeHills",
-	"Jungle",
-	"Savanna",
-	"BirchForest",
-	"MegaSpruceTaiga",
-	"MegaTaiga",
-	"ExtremeHills+",
-	"Forest",
-	"Plains",
-	"Desert",
-	"ColdTaiga",
-	"IcePlainsSpikes",
-	"SunflowerPlains",
-	"IcePlains",
-	"RoofedForest",
-	"ExtremeHills+_snowtop",
-	"MesaPlateauFM_grasstop",
-	"JungleEdgeM",
-	"ExtremeHillsM",
-	"JungleM",
-	"BirchForestM",
-	"MesaPlateauF",
-	"MesaPlateauFM",
-	"MesaPlateauF_grasstop",
-	"MesaBryce",
-	"JungleEdge",
-	"SavannaM",
 },
 9,
 minetest.LIGHT_MAX+1,

mods/ENTITIES/mobs_mc/creeper.lua

@@ -1,6 +1,6 @@
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### CREEPER
@@ -12,8 +12,6 @@ local S = minetest.get_translator(minetest.get_current_modname())
 mobs:register_mob("mobs_mc:creeper", {
 	type = "monster",
 	spawn_class = "hostile",
-	hostile = true,
-	rotate = 270,
 	hp_min = 20,
 	hp_max = 20,
 	xp_min = 5,
@@ -35,44 +33,28 @@ mobs:register_mob("mobs_mc:creeper", {
 		explode = "tnt_explode",
 		distance = 16,
 	},
-	makes_footstep_sound = false,
+	makes_footstep_sound = true,
 	walk_velocity = 1.05,
 	run_velocity = 2.1,
 	runaway_from = { "mobs_mc:ocelot", "mobs_mc:cat" },
 	attack_type = "explode",
-	eye_height = 1.25,
+
 	--hssssssssssss
 
 	explosion_strength = 3,
-	--explosion_radius = 3,
+	explosion_radius = 3.5,
-	--explosion_damage_radius = 6,
+	explosion_damage_radius = 3.5,
-	--explosiontimer_reset_radius = 6,
+	explosiontimer_reset_radius = 6,
 	reach = 3,
-	defuse_reach = 5.2,
+	explosion_timer = 1.5,
-	explosion_timer = 0.3,
 	allow_fuse_reset = true,
 	stop_to_explode = true,
 
-	--head code
-	has_head = true,
-	head_bone = "head",
-
-	swap_y_with_x = true,
-	reverse_head_yaw = true,
-
-	head_bone_pos_y = 2.4,
-	head_bone_pos_z = 0,
-
-	head_height_offset = 1.1,
-	head_direction_offset = 0,
-	head_pitch_modifier = 0,
-	--end head code
-
 	-- Force-ignite creeper with flint and steel and explode after 1.5 seconds.
 	-- TODO: Make creeper flash after doing this as well.
 	-- TODO: Test and debug this code.
 	on_rightclick = function(self, clicker)
-		if self._forced_explosion_countdown_timer then
+		if self._forced_explosion_countdown_timer ~= nil then
 			return
 		end
 		local item = clicker:get_wielded_item()
@@ -92,11 +74,10 @@ mobs:register_mob("mobs_mc:creeper", {
 		end
 	end,
 	do_custom = function(self, dtime)
-		if self._forced_explosion_countdown_timer then
+		if self._forced_explosion_countdown_timer ~= nil then
 			self._forced_explosion_countdown_timer = self._forced_explosion_countdown_timer - dtime
 			if self._forced_explosion_countdown_timer <= 0 then
-				local mobs_griefing = minetest.settings:get_bool("mobs_griefing") ~= false
+				mobs:boom(self, mcl_util.get_object_center(self.object), self.explosion_strength)
-				mcl_explosions.explode(mcl_util.get_object_center(self.object), self.explosion_strength, { griefing = mobs_griefing, drop_chance = 1.0}, self.object)
 			end
 		end
 	end,
@@ -149,10 +130,9 @@ mobs:register_mob("mobs_mc:creeper", {
 })
 
 mobs:register_mob("mobs_mc:creeper_charged", {
-	description = S("Charged Creeper"),
+	description = S("Creeper"),
 	type = "monster",
 	spawn_class = "hostile",
-	hostile = true,
 	hp_min = 20,
 	hp_max = 20,
 	xp_min = 5,
@@ -169,7 +149,6 @@ mobs:register_mob("mobs_mc:creeper_charged", {
 		"mobs_mc_creeper_charge.png"},
 	},
 	visual_size = {x=3, y=3},
-	rotate = 270,
 	sounds = {
 		attack = "tnt_ignite",
 		death = "mobs_mc_creeper_death",
@@ -178,19 +157,18 @@ mobs:register_mob("mobs_mc:creeper_charged", {
 		explode = "tnt_explode",
 		distance = 16,
 	},
-	makes_footstep_sound = false,
+	makes_footstep_sound = true,
 	walk_velocity = 1.05,
 	run_velocity = 2.1,
 	runaway_from = { "mobs_mc:ocelot", "mobs_mc:cat" },
 	attack_type = "explode",
 
 	explosion_strength = 6,
-	--explosion_radius = 3,
+	explosion_radius = 8,
-	--explosion_damage_radius = 6,
+	explosion_damage_radius = 8,
-	--explosiontimer_reset_radius = 3,
+	explosiontimer_reset_radius = 6,
 	reach = 3,
-	defuse_reach = 5.2,
+	explosion_timer = 1.5,
-	explosion_timer = 0.3,
 	allow_fuse_reset = true,
 	stop_to_explode = true,
 
@@ -198,7 +176,7 @@ mobs:register_mob("mobs_mc:creeper_charged", {
 	-- TODO: Make creeper flash after doing this as well.
 	-- TODO: Test and debug this code.
 	on_rightclick = function(self, clicker)
-		if self._forced_explosion_countdown_timer then
+		if self._forced_explosion_countdown_timer ~= nil then
 			return
 		end
 		local item = clicker:get_wielded_item()
@@ -218,11 +196,10 @@ mobs:register_mob("mobs_mc:creeper_charged", {
 		end
 	end,
 	do_custom = function(self, dtime)
-		if self._forced_explosion_countdown_timer then
+		if self._forced_explosion_countdown_timer ~= nil then
 			self._forced_explosion_countdown_timer = self._forced_explosion_countdown_timer - dtime
 			if self._forced_explosion_countdown_timer <= 0 then
-				local mobs_griefing = minetest.settings:get_bool("mobs_griefing") ~= false
+				mobs:boom(self, mcl_util.get_object_center(self.object), self.explosion_strength)
-				mcl_explosions.explode(mcl_util.get_object_center(self.object), self.explosion_strength, { griefing = mobs_griefing, drop_chance = 1.0}, self.object)
 			end
 		end
 	end,

mods/ENTITIES/mobs_mc/ender_dragon.lua

@@ -2,28 +2,21 @@
 --################### ENDERDRAGON
 --###################
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 mobs:register_mob("mobs_mc:enderdragon", {
 	description = S("Ender Dragon"),
 	type = "monster",
 	spawn_class = "hostile",
+	pathfinding = 1,
 	attacks_animals = true,
 	walk_chance = 100,
-	rotate = 270,
-	tilt_fly = true,
-	hostile = true,
-	shoot_arrow = function(self, pos, dir)
-		-- 2-4 damage per arrow
-		local dmg = math.random(2,4)
-		mobs.shoot_projectile_handling("mobs_mc:dragon_fireball", pos, dir, self.object:get_yaw(), self.object, nil, dmg)
-	end,
 	hp_max = 200,
 	hp_min = 200,
 	xp_min = 500,
 	xp_max = 500,
-	collisionbox = {-2, 0, -2, 2, 2, 2},
+	collisionbox = {-2, 3, -2, 2, 5, 2},
-	eye_height = 1,
+	physical = false,
 	visual = "mesh",
 	mesh = "mobs_mc_dragon.b3d",
 	textures = {
@@ -31,7 +24,6 @@ mobs:register_mob("mobs_mc:enderdragon", {
 	},
 	visual_size = {x=3, y=3},
 	view_range = 35,
-	reach = 20,
 	walk_velocity = 6,
 	run_velocity = 6,
 	can_despawn = false,
@@ -55,10 +47,12 @@ mobs:register_mob("mobs_mc:enderdragon", {
 	lava_damage = 0,
 	fire_damage = 0,
 	on_rightclick = nil,
-	attack_type = "projectile",
+	attack_type = "dogshoot",
 	arrow = "mobs_mc:dragon_fireball",
 	shoot_interval = 0.5,
 	shoot_offset = -1.0,
+	xp_min = 500,
+	xp_max = 500,
 	animation = {
 		fly_speed = 8, stand_speed = 8,
 		stand_start = 0,		stand_end = 20,
@@ -111,8 +105,8 @@ mobs:register_mob("mobs_mc:enderdragon", {
 	fire_resistant = true,
 })
 
---TODO: replace this setting by a proper gamerules system
+
-local mobs_griefing = minetest.settings:get_bool("mobs_griefing", true)
+local mobs_griefing = minetest.settings:get_bool("mobs_griefing") ~= false
 
 -- dragon fireball (projectile)
 mobs:register_arrow("mobs_mc:dragon_fireball", {
@@ -139,13 +133,10 @@ mobs:register_arrow("mobs_mc:dragon_fireball", {
 
 	-- node hit, explode
 	hit_node = function(self, pos, node)
-		--mobs:boom(self, pos, 2)
+		mobs:boom(self, pos, 2)
-		if mobs_griefing then
-			mcl_explosions.explode(self.object:get_pos(), 2, { drop_chance = 1.0 })
-		end
 	end
 })
 
 mobs:register_egg("mobs_mc:enderdragon", S("Ender Dragon"), "mobs_mc_spawn_icon_dragon.png", 0, true)
 
---mcl_wip.register_wip_item("mobs_mc:enderdragon")
+mcl_wip.register_wip_item("mobs_mc:enderdragon")

mods/ENTITIES/mobs_mc/enderman.lua

@@ -24,11 +24,9 @@
 -- added rain damage.
 -- fixed the grass_with_dirt issue.
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
-local vector = vector
+local telesound = function(pos, is_source)
-
-local function telesound(pos, is_source)
 	local snd
 	if is_source then
 		snd = "mobs_mc_enderman_teleport_src"
@@ -195,19 +193,18 @@ mobs:register_mob("mobs_mc:enderman", {
 	description = S("Enderman"),
 	type = "monster",
 	spawn_class = "passive",
-	neutral = true,
+	passive = true,
+	pathfinding = 1,
 	hp_min = 40,
 	hp_max = 40,
 	xp_min = 5,
 	xp_max = 5,
-	rotate = 270,
 	collisionbox = {-0.3, -0.01, -0.3, 0.3, 2.89, 0.3},
 	visual = "mesh",
 	mesh = "mobs_mc_enderman.b3d",
 	textures = create_enderman_textures(),
 	visual_size = {x=3, y=3},
 	makes_footstep_sound = true,
-	eye_height = 2.5,
 	sounds = {
 		-- TODO: Custom war cry sound
 		war_cry = "mobs_sandmonster",
@@ -216,8 +213,8 @@ mobs:register_mob("mobs_mc:enderman", {
 		random = {name="mobs_mc_enderman_random", gain=0.5},
 		distance = 16,
 	},
-	walk_velocity = 1,
+	walk_velocity = 0.2,
-	run_velocity = 4,
+	run_velocity = 3.4,
 	damage = 7,
 	reach = 2,
 	drops = {
@@ -227,22 +224,6 @@ mobs:register_mob("mobs_mc:enderman", {
 		max = 1,
 		looting = "common"},
 	},
-
-	--head code
-	has_head = false,
-	head_bone = "head.low",
-
-	swap_y_with_x = false,
-	reverse_head_yaw = false,
-
-	head_bone_pos_y = 2.4,
-	head_bone_pos_z = 0,
-
-	head_height_offset = 1.1,
-	head_direction_offset = 0,
-	head_pitch_modifier = 0,
-	--end head code
-
 	animation = select_enderman_animation("normal"),
 	_taken_node = "",
 	do_custom = function(self, dtime)
@@ -301,10 +282,10 @@ mobs:register_mob("mobs_mc:enderman", {
 				--self:teleport(nil)
 				--self.state = ""
 			--else
-				if self.attacking then
+				if self.attack then
-					local target = self.attacking
+					local target = self.attack
 					local pos = target:get_pos()
-					if pos then
+					if pos ~= nil then
 						if vector.distance(self.object:get_pos(), target:get_pos()) > 10 then
 							self:teleport(target)
 						end
@@ -320,12 +301,12 @@ mobs:register_mob("mobs_mc:enderman", {
 		for n = 1, #objs do
 			local obj = objs[n]
 			if obj then
-				--if minetest.is_player(obj) then
+				if minetest.is_player(obj) then
 					-- Warp from players during day.
 					--if (minetest.get_timeofday() * 24000) > 5001 and (minetest.get_timeofday() * 24000) < 19000 then
 					--	self:teleport(nil)
 					--end
-				if not obj:is_player() then
+				else
 					local lua = obj:get_luaentity()
 					if lua then
 						if lua.name == "mcl_bows:arrow_entity" or lua.name == "mcl_throwing:snowball_entity" then
@@ -343,8 +324,8 @@ mobs:register_mob("mobs_mc:enderman", {
 			--	self:teleport(nil)
 			--	self.state = ""
 			--else
-				if self.attack and not minetest.settings:get_bool("creative_mode") then
+				if self.attack ~= nil and not minetest.settings:get_bool("creative_mode") then
-					self.state = "attack"
+					self.state = 'attack'
 				end
 			--end
 		end
@@ -379,16 +360,11 @@ mobs:register_mob("mobs_mc:enderman", {
 						--if looking in general head position, turn hostile
 						if minetest.line_of_sight(ender_eye_pos, look_pos_base) and vector.distance(look_pos, ender_eye_pos) <= 0.4 then
 							self.provoked = "staring"
-							self.state = "stand"
+							self.attack = minetest.get_player_by_name(obj:get_player_name())
-							self.hostile = false
 							break
-						--begin attacking the player
+						else -- I'm not sure what this part does, but I don't want to break anything - jordan4ibanez
-						else
 							if self.provoked == "staring" then
 								self.provoked = "broke_contact"
-								self.hostile = true
-								self.state = "attack"
-								self.attacking = obj
 							end
 						end
 
@@ -454,14 +430,14 @@ mobs:register_mob("mobs_mc:enderman", {
 						self.base_texture = create_enderman_textures(block_type, self._taken_node)
 						self.object:set_properties({ textures = self.base_texture })
 						self.animation = select_enderman_animation("block")
-						mobs.set_mob_animation(self, self.animation.current)
+						mobs:set_animation(self, self.animation.current)
 						if def.sounds and def.sounds.dug then
 							minetest.sound_play(def.sounds.dug, {pos = take_pos, max_hear_distance = 16}, true)
 						end
 					end
 				end
 			end
-		elseif self._taken_node and self._taken_node ~= "" and self._take_place_timer >= self._next_take_place_time then
+		elseif self._taken_node ~= nil and self._taken_node ~= "" and self._take_place_timer >= self._next_take_place_time then
 			-- Place taken node
 			self._take_place_timer = 0
 			self._next_take_place_time = math.random(take_frequency_min, take_frequency_max)
@@ -477,7 +453,7 @@ mobs:register_mob("mobs_mc:enderman", {
 					local def = minetest.registered_nodes[self._taken_node]
 					-- Update animation accordingly (removes visible block)
 					self.animation = select_enderman_animation("normal")
-					mobs.set_mob_animation(self, self.animation.current)
+					mobs:set_animation(self, self.animation.current)
 					if def.sounds and def.sounds.place then
 						minetest.sound_play(def.sounds.place, {pos = place_pos, max_hear_distance = 16}, true)
 					end
@@ -487,12 +463,12 @@ mobs:register_mob("mobs_mc:enderman", {
 		end
 	end,
 	do_teleport = function(self, target)
-		if target then
+		if target ~= nil then
 			local target_pos = target:get_pos()
 			-- Find all solid nodes below air in a 10×10×10 cuboid centered on the target
 			local nodes = minetest.find_nodes_in_area_under_air(vector.subtract(target_pos, 5), vector.add(target_pos, 5), {"group:solid", "group:cracky", "group:crumbly"})
 			local telepos
-			if nodes then
+			if nodes ~= nil then
 				if #nodes > 0 then
 					-- Up to 64 attempts to teleport
 					for n=1, math.min(64, #nodes) do
@@ -527,7 +503,7 @@ mobs:register_mob("mobs_mc:enderman", {
 				-- We need to add (or subtract) different random numbers to each vector component, so it couldn't be done with a nice single vector.add() or .subtract():
 				local randomCube = vector.new( pos.x + 8*(pr:next(0,16)-8), pos.y + 8*(pr:next(0,16)-8), pos.z + 8*(pr:next(0,16)-8) )
 				local nodes = minetest.find_nodes_in_area_under_air(vector.subtract(randomCube, 4), vector.add(randomCube, 4), {"group:solid", "group:cracky", "group:crumbly"})
-				if nodes then
+				if nodes ~= nil then
 					if #nodes > 0 then
 						-- Up to 8 low-level (in total up to 8*8 = 64) attempts to teleport
 						for n=1, math.min(8, #nodes) do
@@ -559,13 +535,13 @@ mobs:register_mob("mobs_mc:enderman", {
 	end,
 	on_die = function(self, pos)
 		-- Drop carried node on death
-		if self._taken_node and self._taken_node ~= "" then
+		if self._taken_node ~= nil and self._taken_node ~= "" then
 			minetest.add_item(pos, self._taken_node)
 		end
 	end,
 	do_punch = function(self, hitter, tflp, tool_caps, dir)
 		-- damage from rain caused by itself so we don't want it to attack itself.
-		if hitter ~= self.object and hitter then
+		if hitter ~= self.object and hitter ~= nil then
 			--if (minetest.get_timeofday() * 24000) > 5001 and (minetest.get_timeofday() * 24000) < 19000 then
 			--	self:teleport(nil)
 			--else
@@ -581,7 +557,7 @@ mobs:register_mob("mobs_mc:enderman", {
 	water_damage = 8,
 	view_range = 64,
 	fear_height = 4,
-	attack_type = "punch",
+	attack_type = "dogfight",
 })
 
 

mods/ENTITIES/mobs_mc/endermite.lua

@@ -2,22 +2,19 @@
 --################### ENDERMITE
 --###################
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 mobs:register_mob("mobs_mc:endermite", {
 	description = S("Endermite"),
 	type = "monster",
 	spawn_class = "hostile",
 	passive = false,
-	rotate = 270,
-	hostile = true,
 	hp_min = 8,
 	hp_max = 8,
 	xp_min = 3,
 	xp_max = 3,
 	armor = {fleshy = 100, arthropod = 100},
 	group_attack = true,
-	attack_type = "punch",
 	collisionbox = {-0.2, -0.01, -0.2, 0.2, 0.29, 0.2},
 	visual = "mesh",
 	mesh = "mobs_mc_endermite.b3d",

mods/ENTITIES/mobs_mc/ghast.lua

@@ -3,7 +3,7 @@
 --made for MC like Survival game
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### GHAST
@@ -14,17 +14,13 @@ mobs:register_mob("mobs_mc:ghast", {
 	description = S("Ghast"),
 	type = "monster",
 	spawn_class = "hostile",
+	pathfinding = 1,
 	group_attack = true,
-	hostile = true,
-	fly_random_while_attack = true,
 	hp_min = 10,
 	hp_max = 10,
-	rotate = 270,
 	xp_min = 5,
 	xp_max = 5,
-	reach = 20,
+	collisionbox = {-2, 5, -2, 2, 9, 2},
-	eye_height = 2.5,
-	collisionbox = {-2, 0, -2, 2, 4, 2},
 	visual = "mesh",
 	mesh = "mobs_mc_ghast.b3d",
 	textures = {
@@ -40,10 +36,8 @@ mobs:register_mob("mobs_mc:ghast", {
 		-- TODO: damage
 		-- TODO: better death
 	},
-
 	walk_velocity = 1.6,
 	run_velocity = 3.2,
-
 	drops = {
 		{name = mobs_mc.items.gunpowder, chance = 1, min = 0, max = 2, looting = "common"},
 		{name = mobs_mc.items.ghast_tear, chance = 10/6, min = 0, max = 1, looting = "common", looting_ignore_chance = true},
@@ -54,23 +48,22 @@ mobs:register_mob("mobs_mc:ghast", {
 		walk_start = 0,		walk_end = 40,
 		run_start = 0,		run_end = 40,
 	},
-
 	fall_damage = 0,
-	view_range = 28,
+	view_range = 100,
-	attack_type = "projectile",
+	attack_type = "dogshoot",
-	arrow = "mobs_mc:ghast_fireball",
+	arrow = "mobs_mc:fireball",
+	shoot_interval = 3.5,
+	shoot_offset = -5,
+	dogshoot_switch = 1,
+	dogshoot_count_max =1,
+	passive = false,
+	jump = true,
+	jump_height = 4,
 	floats=1,
 	fly = true,
 	makes_footstep_sound = false,
+	instant_death = true,
 	fire_resistant = true,
-	projectile_cooldown_min = 5,
-	projectile_cooldown_max = 7,
-	shoot_arrow = function(self, pos, dir)
-		-- 2-4 damage per arrow
-		local dmg = math.random(2,4)
-		mobs.shoot_projectile_handling("mobs_mc:ghast_fireball", pos, dir, self.object:get_yaw(), self.object, 11, dmg,nil,nil,nil,-0.6)
-	end,
-	--[[
 	do_custom = function(self)
 		if self.firing == true then
 			self.base_texture = {"mobs_mc_ghast_firing.png"}
@@ -80,7 +73,6 @@ mobs:register_mob("mobs_mc:ghast", {
 			self.object:set_properties({textures=self.base_texture})
 		end
 	end,
-	]]--
 })
 
 
@@ -100,40 +92,32 @@ mobs_mc.spawn_height.nether_min,
 mobs_mc.spawn_height.nether_max)
 
 -- fireball (projectile)
-mobs:register_arrow("mobs_mc:ghast_fireball", {
+mobs:register_arrow("mobs_mc:fireball", {
 	visual = "sprite",
 	visual_size = {x = 1, y = 1},
 	textures = {"mcl_fire_fire_charge.png"},
 	velocity = 15,
 	collisionbox = {-.5, -.5, -.5, .5, .5, .5},
-	tail = 1,
-	tail_texture = "mobs_mc_spit.png^[colorize:black:255", --repurpose spit texture
-	tail_size = 5,
 	_is_fireball = true,
 
 	hit_player = function(self, player)
-		--[[
 		player:punch(self.object, 1.0, {
 			full_punch_interval = 1.0,
 			damage_groups = {fleshy = 6},
 		}, nil)
-		]]--
+		mobs:boom(self, self.object:get_pos(), 1, true)
-		--mobs:boom(self, self.object:get_pos(), 1, true)
-		mcl_explosions.explode(self.object:get_pos(), 3,{ drop_chance = 1.0 })
 	end,
 
 	hit_mob = function(self, mob)
 		mob:punch(self.object, 1.0, {
 			full_punch_interval = 1.0,
-			damage_groups = {fleshy = self._damage},
+			damage_groups = {fleshy = 6},
 		}, nil)
-		--mobs:boom(self, self.object:get_pos(), 1, true)
+		mobs:boom(self, self.object:get_pos(), 1, true)
-		mcl_explosions.explode(self.object:get_pos(), 3,{ drop_chance = 1.0 })
 	end,
 
 	hit_node = function(self, pos, node)
-		--mobs:boom(self, pos, 1, true)
+		mobs:boom(self, pos, 1, true)
-		mcl_explosions.explode(self.object:get_pos(), 3,{ drop_chance = 1.0 })
 	end
 })
 

mods/ENTITIES/mobs_mc/guardian.lua

@@ -2,7 +2,7 @@
 --################### GUARDIAN
 --###################
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 mobs:register_mob("mobs_mc:guardian", {
 	description = S("Guardian"),
@@ -13,8 +13,8 @@ mobs:register_mob("mobs_mc:guardian", {
 	xp_min = 10,
 	xp_max = 10,
 	breath_max = -1,
-    passive = false,
+    	passive = false,
-	attack_type = "punch",
+	attack_type = "dogfight",
 	pathfinding = 1,
 	view_range = 16,
 	walk_velocity = 2,
@@ -94,6 +94,7 @@ mobs:register_mob("mobs_mc:guardian", {
 	makes_footstep_sound = false,
 	fly_in = { mobs_mc.items.water_source, mobs_mc.items.river_water_source },
 	jump = false,
+	view_range = 16,
 })
 
 -- Spawning disabled due to size issues

mods/ENTITIES/mobs_mc/guardian_elder.lua

@@ -4,7 +4,7 @@
 --################### GUARDIAN
 --###################
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 mobs:register_mob("mobs_mc:guardian_elder", {
 	description = S("Elder Guardian"),
@@ -15,8 +15,8 @@ mobs:register_mob("mobs_mc:guardian_elder", {
 	xp_min = 10,
 	xp_max = 10,
 	breath_max = -1,
-    passive = false,
+    	passive = false,
-	attack_type = "punch",
+	attack_type = "dogfight",
 	pathfinding = 1,
 	view_range = 16,
 	walk_velocity = 2,
@@ -104,6 +104,7 @@ mobs:register_mob("mobs_mc:guardian_elder", {
 	makes_footstep_sound = false,
 	fly_in = { mobs_mc.items.water_source, mobs_mc.items.river_water_source },
 	jump = false,
+	view_range = 16,
 })
 
 -- Spawning disabled due to size issues <- what do you mean? -j4i

mods/ENTITIES/mobs_mc/horse.lua

@@ -3,7 +3,7 @@
 --made for MC like Survival game
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### HORSE
@@ -38,9 +38,9 @@ end
 local can_equip_horse_armor = function(entity_id)
 	return entity_id == "mobs_mc:horse" or entity_id == "mobs_mc:skeleton_horse" or entity_id == "mobs_mc:zombie_horse"
 end
---[[local can_equip_chest = function(entity_id)
+local can_equip_chest = function(entity_id)
 	return entity_id == "mobs_mc:mule" or entity_id == "mobs_mc:donkey"
-end]]
+end
 local can_breed = function(entity_id)
 	return entity_id == "mobs_mc:horse" or "mobs_mc:mule" or entity_id == "mobs_mc:donkey"
 end
@@ -88,10 +88,6 @@ local horse = {
 	spawn_class = "passive",
 	visual = "mesh",
 	mesh = "mobs_mc_horse.b3d",
-	rotate = 270,
-	walk_velocity = 1,
-	run_velocity = 8,
-	skittish = true,
 	visual_size = {x=3.0, y=3.0},
 	collisionbox = {-0.69825, -0.01, -0.69825, 0.69825, 1.59, 0.69825},
 	animation = {
@@ -101,7 +97,7 @@ local horse = {
 		walk_speed = 25,
 		walk_start = 0,
 		walk_end = 40,
-		run_speed = 120,
+		run_speed = 60,
 		run_start = 0,
 		run_end = 40,
 	},
@@ -118,8 +114,7 @@ local horse = {
 	fly = false,
 	walk_chance = 60,
 	view_range = 16,
-	follow = "mcl_farming:wheat_item",
+	follow = mobs_mc.follow.horse,
-	follow_distance = 3,
 	passive = true,
 	hp_min = 15,
 	hp_max = 30,
@@ -187,7 +182,7 @@ local horse = {
 		-- if driver present and horse has a saddle allow control of horse
 		if self.driver and self._saddle then
 
-			mobs.drive(self, "run", "stand", false, dtime)
+			mobs.drive(self, "walk", "stand", false, dtime)
 
 			return false -- skip rest of mob functions
 		end
@@ -219,21 +214,6 @@ local horse = {
 		local iname = item:get_name()
 		local heal = 0
 
-		--sneak click to breed the horse/feed it
-		if self.owner and self.owner == clicker:get_player_name() then
-			--attempt to enter breed state
-			if mobs.enter_breed_state(self,clicker) then
-				return
-			end
-		end
-
-		--don't do any other logic with the baby
-		--make baby grow faster
-		if self.baby then
-			mobs.make_baby_grow_faster(self,clicker)
-			return
-		end
-
 		-- Taming
 		self.temper = self.temper or (math.random(1,100))
 
@@ -259,7 +239,6 @@ local horse = {
 				self.buck_off_time = 40 -- TODO how long does it take in minecraft?
 				if self.temper > 100 then
 					self.tamed = true -- NOTE taming can only be finished by riding the horse
-					mobs.tamed_effect(self)
 					if not self.owner or self.owner == "" then
 						self.owner = clicker:get_player_name()
 					end
@@ -274,14 +253,6 @@ local horse = {
 			-- If nothing happened temper_increase = 0 and addition does nothing
 			self.temper = self.temper + temper_increase
 
-			--give the player some kind of idea
-			--of what's happening with the horse's temper
-			if self.temper <= 100 then
-				mobs.feed_effect(self)
-			else
-				mobs.tamed_effect(self)
-			end
-
 			return
 		end
 
@@ -311,10 +282,14 @@ local horse = {
 			return
 		end
 
+		if mobs:protect(self, clicker) then
+			return
+		end
+
 		-- Make sure tamed horse is mature and being clicked by owner only
 		if self.tamed and not self.child and self.owner == clicker:get_player_name() then
 
-			--local inv = clicker:get_inventory()
+			local inv = clicker:get_inventory()
 
 			-- detatch player already riding horse
 			if self.driver and clicker == self.driver then
@@ -382,6 +357,9 @@ local horse = {
 				self.object:set_properties({stepheight = 1.1})
 				mobs.attach(self, clicker)
 
+			-- Used to capture horse
+			elseif not self.driver and iname ~= "" then
+				mobs:capture_mob(self, clicker, 0, 5, 60, false, nil)
 			end
 		end
 	end,
@@ -542,53 +520,22 @@ mobs:spawn_specific(
 "overworld",
 "ground",
 {
-	"FlowerForest_beach",
+"FlowerForest",
-	"Forest_beach",
+"Swampland",
-	"StoneBeach",
+"Taiga",
-	"ColdTaiga_beach_water",
+"ExtremeHills",
-	"Taiga_beach",
+"BirchForest",
-	"Savanna_beach",
+"MegaSpruceTaiga",
-	"Plains_beach",
+"MegaTaiga",
-	"ExtremeHills_beach",
+"ExtremeHills+",
-	"ColdTaiga_beach",
+"Forest",
-	"Swampland_shore",
+"Plains",
-	"JungleM_shore",
+"ColdTaiga",
-	"Jungle_shore",
+"SunflowerPlains",
-	"MesaPlateauFM_sandlevel",
+"RoofedForest",
-	"MesaPlateauF_sandlevel",
+"MesaPlateauFM_grasstop",
-	"MesaBryce_sandlevel",
+"ExtremeHillsM",
-	"Mesa_sandlevel",
+"BirchForestM",
-	"Mesa",
-	"FlowerForest",
-	"Swampland",
-	"Taiga",
-	"ExtremeHills",
-	"Jungle",
-	"Savanna",
-	"BirchForest",
-	"MegaSpruceTaiga",
-	"MegaTaiga",
-	"ExtremeHills+",
-	"Forest",
-	"Plains",
-	"Desert",
-	"ColdTaiga",
-	"IcePlainsSpikes",
-	"SunflowerPlains",
-	"IcePlains",
-	"RoofedForest",
-	"ExtremeHills+_snowtop",
-	"MesaPlateauFM_grasstop",
-	"JungleEdgeM",
-	"ExtremeHillsM",
-	"JungleM",
-	"BirchForestM",
-	"MesaPlateauF",
-	"MesaPlateauFM",
-	"MesaPlateauF_grasstop",
-	"MesaBryce",
-	"JungleEdge",
-	"SavannaM",
 },
 0,
 minetest.LIGHT_MAX+1,

mods/ENTITIES/mobs_mc/init.lua

@@ -3,7 +3,7 @@
 --made for MC like Survival game
 --License for code WTFPL and otherwise stated in readmes
 
-local path = minetest.get_modpath(minetest.get_current_modname())
+local path = minetest.get_modpath("mobs_mc")
 
 if not minetest.get_modpath("mobs_mc_gameconfig") then
 	mobs_mc = {}

mods/ENTITIES/mobs_mc/iron_golem.lua

@@ -3,7 +3,7 @@
 --made for MC like Survival game
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### IRON GOLEM
@@ -16,11 +16,8 @@ mobs:register_mob("mobs_mc:iron_golem", {
 	type = "npc",
 	spawn_class = "passive",
 	passive = true,
-	rotate = 270,
 	hp_min = 100,
 	hp_max = 100,
-	protect = true,
-	neutral = true,
 	breath_max = -1,
 	collisionbox = {-0.7, -0.01, -0.7, 0.7, 2.69, 0.7},
 	visual = "mesh",
@@ -43,7 +40,7 @@ mobs:register_mob("mobs_mc:iron_golem", {
 	reach = 3,
 	group_attack = true,
 	attacks_monsters = true,
-	attack_type = "punch",
+	attack_type = "dogfight",
 	drops = {
 		{name = mobs_mc.items.iron_ingot,
 		chance = 1,
@@ -158,11 +155,11 @@ mobs_mc.tools.check_iron_golem_summon = function(pos)
 		if ok then
 			-- Remove the nodes
 			minetest.remove_node(pos)
-			minetest.check_for_falling(pos)
+			core.check_for_falling(pos)
 			for i=1, 4 do
 				local cpos = vector.add(pos, checks[c][i])
 				minetest.remove_node(cpos)
-				minetest.check_for_falling(cpos)
+				core.check_for_falling(cpos)
 			end
 			-- Summon iron golem
 			local place

mods/ENTITIES/mobs_mc/llama.lua

@@ -1,4 +1,4 @@
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### LLAMA
@@ -28,15 +28,6 @@ mobs:register_mob("mobs_mc:llama", {
 	description = S("Llama"),
 	type = "animal",
 	spawn_class = "passive",
-	rotate = 270,
-	neutral = true,
-	group_attack = true,
-	attack_type = "projectile",
-	shoot_arrow = function(self, pos, dir)
-		-- 2-4 damage per arrow
-		local dmg = 1
-		mobs.shoot_projectile_handling("mobs_mc:spit", pos, dir, self.object:get_yaw(), self.object, nil, dmg)
-	end,
 	hp_min = 15,
 	hp_max = 30,
 	xp_min = 1,
@@ -59,11 +50,7 @@ mobs:register_mob("mobs_mc:llama", {
 	walk_velocity = 1,
 	run_velocity = 4.4,
 	follow_velocity = 4.4,
-	breed_distance = 1.5,
-	baby_size = 0.5,
-	follow_distance = 2,
 	floats = 1,
-	reach = 6,
 	drops = {
 		{name = mobs_mc.items.leather,
 		chance = 1,
@@ -96,7 +83,7 @@ mobs:register_mob("mobs_mc:llama", {
 		look_start = 78,
 		look_end = 108,
 	},
-	follow = mobs_mc.items.hay_bale,
+	follow = mobs_mc.follow.llama,
 	view_range = 16,
 	do_custom = function(self, dtime)
 
@@ -139,71 +126,30 @@ mobs:register_mob("mobs_mc:llama", {
 			return
 		end
 
-		--owner is broken for this
+		local item = clicker:get_wielded_item()
-		--we'll make the owner this guy
+		if item:get_name() == mobs_mc.items.hay_bale then
-		--attempt to enter breed state
+			-- Breed with hay bale
-		if mobs.enter_breed_state(self,clicker) then
+			if mobs:feed_tame(self, clicker, 1, true, false) then return end
-			self.tamed = true
+		else
-			self.owner = clicker:get_player_name()
+			-- Feed with anything else
-			return
+			if mobs:feed_tame(self, clicker, 1, false, true) then return end
 		end
-
+		if mobs:protect(self, clicker) then return end
-		--ignore other logic
-		--make baby grow faster
-		if self.baby then
-			mobs.make_baby_grow_faster(self,clicker)
-			return
-		end
-
 
 		-- Make sure tamed llama is mature and being clicked by owner only
 		if self.tamed and not self.child and self.owner == clicker:get_player_name() then
 
-			local item = clicker:get_wielded_item()
-			--safety catch
-			if not item then
-				return
-			end
-
-
-
-			--put chest on carpeted llama
-			if self.carpet and not self.chest and item:get_name() == "mcl_chests:chest" then
-				if not minetest.is_creative_enabled(clicker:get_player_name()) then
-					item:take_item()
-					clicker:set_wielded_item(item)
-				end
-
-				self.base_texture = table.copy(self.base_texture)
-				self.base_texture[1] = "mobs_mc_llama_chest.png"
-				self.object:set_properties({
-					textures = self.base_texture,
-				})
-				self.chest = true
-
-				return --don't attempt to ride
-			end
-
-
 			-- Place carpet
-			--TODO: Re-enable this code when carpet textures arrived.
+			--[[ TODO: Re-enable this code when carpet textures arrived.
-			if minetest.get_item_group(item:get_name(), "carpet") == 1 then
+			if minetest.get_item_group(item:get_name(), "carpet") == 1 and not self.carpet then
-
 				for group, carpetdata in pairs(carpets) do
 					if minetest.get_item_group(item:get_name(), group) == 1 then
 						if not minetest.is_creative_enabled(clicker:get_player_name()) then
 							item:take_item()
 							clicker:set_wielded_item(item)
-
-							--shoot off old carpet
-							if self.carpet then
-								minetest.add_item(self.object:get_pos(), self.carpet)
-							end
 						end
-
 						local substr = carpetdata[2]
 						local tex_carpet = "mobs_mc_llama_decor_"..substr..".png"
-
 						self.base_texture = table.copy(self.base_texture)
 						self.base_texture[2] = tex_carpet
 						self.object:set_properties({
@@ -224,21 +170,23 @@ mobs:register_mob("mobs_mc:llama", {
 					end
 				end
 			end
+			]]
 
-			if self.carpet then
+			-- detatch player already riding llama
-				-- detatch player already riding llama
+			if self.driver and clicker == self.driver then
-				if self.driver and clicker == self.driver then
 
-					mobs.detach(clicker, {x = 1, y = 0, z = 1})
+				mobs.detach(clicker, {x = 1, y = 0, z = 1})
 
-				-- attach player to llama
+			-- attach player to llama
-				elseif not self.driver then
+			elseif not self.driver then
 
-					self.object:set_properties({stepheight = 1.1})
+				self.object:set_properties({stepheight = 1.1})
-					mobs.attach(self, clicker)
+				mobs.attach(self, clicker)
-				end
 			end
 
+		-- Used to capture llama
+		elseif not self.driver and clicker:get_wielded_item():get_name() ~= "" then
+			mobs:capture_mob(self, clicker, 0, 5, 60, false, nil)
 		end
 	end,
 
@@ -292,38 +240,3 @@ mobs_mc.spawn_height.overworld_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:llama", S("Llama"), "mobs_mc_spawn_icon_llama.png", 0)
-
-
--- llama spit
-mobs:register_arrow("mobs_mc:spit", {
-	visual = "sprite",
-	visual_size = {x = 0.3, y = 0.3},
-	textures = {"mobs_mc_spit.png"},
-	velocity = 1,
-	speed = 1,
-	tail = 1,
-	tail_texture = "mobs_mc_spit.png",
-	tail_size = 2,
-	tail_distance_divider = 4,
-
-	hit_player = function(self, player)
-		--[[if rawget(_G, "armor") and armor.last_damage_types then
-			armor.last_damage_types[player:get_player_name()] = "spit"
-		end]]
-		player:punch(self.object, 1.0, {
-			full_punch_interval = 1.0,
-			damage_groups = {fleshy = self._damage},
-		}, nil)
-	end,
-
-	hit_mob = function(self, mob)
-		mob:punch(self.object, 1.0, {
-			full_punch_interval = 1.0,
-			damage_groups = {fleshy = self._damage},
-		}, nil)
-	end,
-
-	hit_node = function(self, pos, node)
-		--does nothing
-	end
-})

mods/ENTITIES/mobs_mc/locale/mobs_mc.de.tr

@@ -28,7 +28,6 @@ Pig=Schwein
 Polar Bear=Eisbär
 Rabbit=Kaninchen
 Killer Bunny=Killerkaninchen
-The Killer Bunny=Das Killerkaninchen
 Sheep=Schaf
 Shulker=Shulker
 Silverfish=Silberfischchen

mods/ENTITIES/mobs_mc/locale/mobs_mc.es.tr

@@ -28,7 +28,6 @@ Pig=Cerdo
 Polar Bear=Oso polar
 Rabbit=Conejo
 Killer Bunny=Conejo asesino
-The Killer Bunny=El Conejo asesino
 Sheep=Oveja
 Shulker=Shulker
 Silverfish=Lepisma

mods/ENTITIES/mobs_mc/locale/mobs_mc.fr.tr

@@ -28,7 +28,6 @@ Pig=Cochon
 Polar Bear=Ours blanc
 Rabbit=Lapin
 Killer Bunny=Lapin tueur
-The Killer Bunny=Le Lapin tueur
 Sheep=Mouton
 Shulker=Shulker
 Silverfish=Poisson d'argent

mods/ENTITIES/mobs_mc/locale/mobs_mc.pl.tr

@@ -1,75 +0,0 @@
-# textdomain: mobs_mc
-Totem of Undying=Token nieśmiertelności
-A totem of undying is a rare artifact which may safe you from certain death.=Totem nieśmiertelności to rzadki artefakt, który może uchronić cię przed pewną śmiercią.
-The totem only works while you hold it in your hand. If you receive fatal damage, you are saved from death and you get a second chance with 1 HP. The totem is destroyed in the process, however.=Totem działa tylko kiedy trzymasz go w dłoni. Jeśli otrzymasz obrażenia od upadku zostaniesz oszczędzony i pozostanie ci 1 HP, jednak totem zostanie wtedy zniszczony.
-Agent=Agent
-Bat=Nietoperz
-Blaze=Płomyk
-Chicken=Kurczak
-Cow=Krowa
-Mooshroom=Muuuchomor
-Creeper=Creeper
-Ender Dragon=Smok kresu
-Enderman=Enderman
-Endermite=Endermit
-Ghast=Ghast
-Elder Guardian=Prastrażnik
-Guardian=Strażnik
-Horse=Koń
-Skeleton Horse=Koń szkielet
-Zombie Horse=Koń zombie
-Donkey=Osioł
-Mule=Muł
-Iron Golem=Żelazny golem
-Llama=Lama
-Ocelot=Ocelot
-Parrot=Papuga
-Pig=Świnia
-Polar Bear=Niedźwiedź polarny
-Rabbit=Królik
-Killer Bunny=Królik zabójca
-Sheep=Owca
-Shulker=Shulker
-Silverfish=Rybik cukrowy
-Skeleton=Szkielet
-Stray=Tułacz
-Wither Skeleton=Witherowy szkielet
-Magma Cube=Kostka magmy
-Slime=Szlam
-Snow Golem=Śnieżny golem
-Spider=Pająk
-Cave Spider=Pająk jaskiniowy
-Squid=Kałamarnica
-Vex=Dręczyciel
-Evoker=Przywoływacz
-Illusioner=Iluzjonista
-Villager=Osadnik
-Vindicator=Obrońca
-Zombie Villager=Osadnik zombie
-Witch=Wiedźma
-Wither=Wither
-Wolf=Wilk
-Husk=Posuch
-Zombie=Zombie
-Zombie Pigman=Świniak zombie
-Iron Horse Armor=Żelazna zbroja dla konia
-Iron horse armor can be worn by horses to increase their protection from harm a bit.=Żelazna zbroja dla konia może być noszona przez konie aby nieco zwiększyć ich odporność na obrażenia.
-Golden Horse Armor=Złota zbroja dla konia
-Golden horse armor can be worn by horses to increase their protection from harm.=Złota zbroja dla konia może być noszona przez konie aby zwiększyć ich odporność na obrażenia.
-Diamond Horse Armor=Diamentowa zbroja dla konia
-Diamond horse armor can be worn by horses to greatly increase their protection from harm.=Diamentowa zbroja dla konia może być noszona przez konie aby istotnie zwiększyć ich odporność na obrażenia.
-Place it on a horse to put on the horse armor. Donkeys and mules can't wear horse armor.=Połóż ją na koniu aby założyć zbroję dla konia. Osły i muły nie mogą nosić zbroi dla konia.
-Farmer=Rolnik
-Fisherman=Rybak
-Fletcher=Łuczarz
-Shepherd=Pasterz
-Librarian=Bibliotekarz
-Cartographer=Kartograf
-Armorer=Płatnerz
-Leatherworker=Rymarz
-Butcher=Rzeźnik
-Weapon Smith=Zbrojmistrz
-Tool Smith=Narzędziarz
-Cleric=Kapłan
-Nitwit=Głupiec
-Protects you from death while wielding it=Chroni przed śmiercią gdy go trzymasz

mods/ENTITIES/mobs_mc/locale/mobs_mc.ru.tr

@@ -28,7 +28,6 @@ Pig=Свинья
 Polar Bear=Полярный медведь
 Rabbit=Кролик
 Killer Bunny=Кролик-убийца
-The Killer Bunny=Кролик-убийца
 Sheep=Овца
 Shulker=Шалкер
 Silverfish=Чешуйница

mods/ENTITIES/mobs_mc/locale/template.txt

@@ -28,7 +28,6 @@ Pig=
 Polar Bear=
 Rabbit=
 Killer Bunny=
-The Killer Bunny=
 Sheep=
 Shulker=
 Silverfish=

mods/ENTITIES/mobs_mc/models/attributes.txt

@@ -1 +0,0 @@
-Ghast fixed by epCode - Thanks!

mods/ENTITIES/mobs_mc/ocelot.lua

@@ -3,7 +3,7 @@
 --made for MC like Survival game
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### OCELOT AND CAT
@@ -31,8 +31,6 @@ local ocelot = {
 	type = "animal",
 	spawn_class = "passive",
 	can_despawn = true,
-	rotate = 270,
-	skittish = true,
 	hp_min = 10,
 	hp_max = 10,
 	xp_min = 1,
@@ -45,7 +43,7 @@ local ocelot = {
 	makes_footstep_sound = true,
 	walk_chance = default_walk_chance,
 	walk_velocity = 1,
-	run_velocity = 10,
+	run_velocity = 3,
 	follow_velocity = 1,
 	floats = 1,
 	runaway = true,
@@ -59,7 +57,7 @@ local ocelot = {
 	},
 	animation = {
 		speed_normal = 25,
-		run_speed = 150,
+		run_speed = 50,
 		stand_start = 0,
 		stand_end = 0,
 		walk_start = 0,
@@ -125,6 +123,8 @@ cat.sounds = {
 }
 cat.on_rightclick = function(self, clicker)
 	if mobs:feed_tame(self, clicker, 1, true, false) then return end
+	if mobs:capture_mob(self, clicker, 0, 60, 5, false, nil) then return end
+	if mobs:protect(self, clicker) then return end
 
 	if self.child then return end
 
@@ -151,7 +151,7 @@ end
 
 mobs:register_mob("mobs_mc:cat", cat)
 
---local base_spawn_chance = 5000
+local base_spawn_chance = 5000
 
 -- Spawn ocelot
 --they get the same as the llama because I'm trying to rework so much of this code right now -j4i

mods/ENTITIES/mobs_mc/parrot.lua

@@ -3,7 +3,7 @@
 --made for MC like Survival game
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### PARROT
@@ -20,14 +20,11 @@ mobs:register_mob("mobs_mc:parrot", {
 	hp_max = 6,
 	xp_min = 1,
 	xp_max = 3,
-	tilt_fly = true,
+	collisionbox = {-0.25, -0.01, -0.25, 0.25, 0.89, 0.25},
-	collisionbox = {-0.25, 0, -0.25, 0.25, 0.9, 0.25},
-	eye_height = 0.45,
 	visual = "mesh",
 	mesh = "mobs_mc_parrot.b3d",
 	textures = {{"mobs_mc_parrot_blue.png"},{"mobs_mc_parrot_green.png"},{"mobs_mc_parrot_grey.png"},{"mobs_mc_parrot_red_blue.png"},{"mobs_mc_parrot_yellow_blue.png"}},
 	visual_size = {x=3, y=3},
-	rotate = 270,
 	walk_velocity = 3,
 	run_velocity = 5,
 	sounds = {
@@ -44,7 +41,7 @@ mobs:register_mob("mobs_mc:parrot", {
 		max = 2,
 		looting = "common",},
 	},
-		animation = {
+    	animation = {
 		stand_speed = 50,
 		walk_speed = 50,
 		fly_speed = 50,
@@ -88,6 +85,8 @@ mobs:register_mob("mobs_mc:parrot", {
 
 		-- Feed to tame, but not breed
 		if mobs:feed_tame(self, clicker, 1, false, true) then return end
+		if mobs:protect(self, clicker) then return end
+		if mobs:capture_mob(self, clicker, 0, 50, 80, false, nil) then return end
 	end,
 
 })

mods/ENTITIES/mobs_mc/pig.lua

@@ -1,13 +1,12 @@
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 mobs:register_mob("mobs_mc:pig", {
 	description = S("Pig"),
 	type = "animal",
 	spawn_class = "passive",
-	skittish = true,
+	runaway = true,
-	rotate = 270,
 	hp_min = 10,
 	hp_max = 10,
 	xp_min = 1,
@@ -20,30 +19,11 @@ mobs:register_mob("mobs_mc:pig", {
 		"mobs_mc_pig.png", -- base
 		"blank.png", -- saddle
 	}},
-
-	--head code
-	has_head = true,
-	head_bone = "head",
-
-	swap_y_with_x = false,
-	reverse_head_yaw = false,
-
-	head_bone_pos_y = 2.4,
-	head_bone_pos_z = 0,
-
-	head_height_offset = 1.1,
-	head_direction_offset = 0,
-	head_pitch_modifier = 0,
-	--end head code
-
 	visual_size = {x=2.5, y=2.5},
 	makes_footstep_sound = true,
 	walk_velocity = 1,
 	run_velocity = 3,
 	follow_velocity = 3.4,
-	breed_distance = 1.5,
-	baby_size = 0.5,
-	follow_distance = 2,
 	drops = {
 		{name = mobs_mc.items.porkchop_raw,
 		chance = 1,
@@ -70,7 +50,7 @@ mobs:register_mob("mobs_mc:pig", {
 		run_start = 0,
 		run_end = 40,
 	},
-	follow = "mcl_farming:carrot_item",
+	follow = mobs_mc.follow.pig,
 	view_range = 8,
 	do_custom = function(self, dtime)
 
@@ -111,17 +91,12 @@ mobs:register_mob("mobs_mc:pig", {
 			return
 		end
 
-		--attempt to enter breed state
+		local wielditem = clicker:get_wielded_item()
-		if mobs.enter_breed_state(self,clicker) then
+		-- Feed pig
-			return
+		if wielditem:get_name() ~= mobs_mc.items.carrot_on_a_stick then
-		end
+			if mobs:feed_tame(self, clicker, 1, true, true) then return end
-
-		--ignore other logic
-		--make baby grow faster
-		if self.baby then
-			mobs.make_baby_grow_faster(self,clicker)
-			return
 		end
+		if mobs:protect(self, clicker) then return end
 
 		if self.child then
 			return
@@ -129,8 +104,6 @@ mobs:register_mob("mobs_mc:pig", {
 
 		-- Put saddle on pig
 		local item = clicker:get_wielded_item()
-		local wielditem = item
-
 		if item:get_name() == mobs_mc.items.saddle and self.saddle ~= "yes" then
 			self.base_texture = {
 				"blank.png", -- baby
@@ -163,7 +136,7 @@ mobs:register_mob("mobs_mc:pig", {
 		end
 
 		-- Mount or detach player
-		--local name = clicker:get_player_name()
+		local name = clicker:get_player_name()
 		if self.driver and clicker == self.driver then
 			-- Detach if already attached
 			mobs.detach(clicker, {x=1, y=0, z=0})
@@ -191,6 +164,10 @@ mobs:register_mob("mobs_mc:pig", {
 				inv:set_stack("main",self.driver:get_wield_index(), wielditem)
 			end
 			return
+
+		-- Capture pig
+		elseif not self.driver and clicker:get_wielded_item():get_name() ~= "" then
+			mobs:capture_mob(self, clicker, 0, 5, 60, false, nil)
 		end
 	end,
 
@@ -211,53 +188,22 @@ mobs:spawn_specific(
 "overworld",
 "ground",
 {
-	"FlowerForest_beach",
+"FlowerForest",
-	"Forest_beach",
+"Swampland",
-	"StoneBeach",
+"Taiga",
-	"ColdTaiga_beach_water",
+"ExtremeHills",
-	"Taiga_beach",
+"BirchForest",
-	"Savanna_beach",
+"MegaSpruceTaiga",
-	"Plains_beach",
+"MegaTaiga",
-	"ExtremeHills_beach",
+"ExtremeHills+",
-	"ColdTaiga_beach",
+"Forest",
-	"Swampland_shore",
+"Plains",
-	"JungleM_shore",
+"ColdTaiga",
-	"Jungle_shore",
+"SunflowerPlains",
-	"MesaPlateauFM_sandlevel",
+"RoofedForest",
-	"MesaPlateauF_sandlevel",
+"MesaPlateauFM_grasstop",
-	"MesaBryce_sandlevel",
+"ExtremeHillsM",
-	"Mesa_sandlevel",
+"BirchForestM",
-	"Mesa",
-	"FlowerForest",
-	"Swampland",
-	"Taiga",
-	"ExtremeHills",
-	"Jungle",
-	"Savanna",
-	"BirchForest",
-	"MegaSpruceTaiga",
-	"MegaTaiga",
-	"ExtremeHills+",
-	"Forest",
-	"Plains",
-	"Desert",
-	"ColdTaiga",
-	"IcePlainsSpikes",
-	"SunflowerPlains",
-	"IcePlains",
-	"RoofedForest",
-	"ExtremeHills+_snowtop",
-	"MesaPlateauFM_grasstop",
-	"JungleEdgeM",
-	"ExtremeHillsM",
-	"JungleM",
-	"BirchForestM",
-	"MesaPlateauF",
-	"MesaPlateauFM",
-	"MesaPlateauF_grasstop",
-	"MesaBryce",
-	"JungleEdge",
-	"SavannaM",
 },
 9,
 minetest.LIGHT_MAX+1,

mods/ENTITIES/mobs_mc/polar_bear.lua

@@ -1,6 +1,6 @@
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### POLARBEAR
@@ -31,7 +31,7 @@ mobs:register_mob("mobs_mc:polar_bear", {
 	walk_velocity = 1.2,
 	run_velocity = 2.4,
 	group_attack = true,
-	attack_type = "punch",
+	attack_type = "dogfight",
 	drops = {
 		-- 3/4 chance to drop raw fish (poor approximation)
 		{name = mobs_mc.items.fish_raw,

mods/ENTITIES/mobs_mc/rabbit.lua

@@ -1,6 +1,6 @@
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 local rabbit = {
 	description = S("Rabbit"),
@@ -8,7 +8,7 @@ local rabbit = {
 	spawn_class = "passive",
 	passive = true,
 	reach = 1,
-	rotate = 270,
+
 	hp_min = 3,
 	hp_max = 3,
 	xp_min = 1,
@@ -62,6 +62,8 @@ local rabbit = {
 	on_rightclick = function(self, clicker)
 		-- Feed, tame protect or capture
 		if mobs:feed_tame(self, clicker, 1, true, true) then return end
+		if mobs:protect(self, clicker) then return end
+		if mobs:capture_mob(self, clicker, 0, 50, 80, false, nil) then return end
 	end,
 	do_custom = function(self)
 		-- Easter egg: Change texture if rabbit is named “Toast”
@@ -99,7 +101,7 @@ killer_bunny.on_rightclick = nil
 killer_bunny.run_velocity = 6
 killer_bunny.do_custom = function(self)
 	if not self._killer_bunny_nametag_set then
-		self.nametag = S("The Killer Bunny")
+		self.nametag = "The Killer Bunny"
 		self._killer_bunny_nametag_set = true
 	end
 end
@@ -114,53 +116,22 @@ mobs:spawn_specific(
 "overworld",
 "ground",
 {
-	"FlowerForest_beach",
+"FlowerForest",
-	"Forest_beach",
+"Swampland",
-	"StoneBeach",
+"Taiga",
-	"ColdTaiga_beach_water",
+"ExtremeHills",
-	"Taiga_beach",
+"BirchForest",
-	"Savanna_beach",
+"MegaSpruceTaiga",
-	"Plains_beach",
+"MegaTaiga",
-	"ExtremeHills_beach",
+"ExtremeHills+",
-	"ColdTaiga_beach",
+"Forest",
-	"Swampland_shore",
+"Plains",
-	"JungleM_shore",
+"ColdTaiga",
-	"Jungle_shore",
+"SunflowerPlains",
-	"MesaPlateauFM_sandlevel",
+"RoofedForest",
-	"MesaPlateauF_sandlevel",
+"MesaPlateauFM_grasstop",
-	"MesaBryce_sandlevel",
+"ExtremeHillsM",
-	"Mesa_sandlevel",
+"BirchForestM",
-	"Mesa",
-	"FlowerForest",
-	"Swampland",
-	"Taiga",
-	"ExtremeHills",
-	"Jungle",
-	"Savanna",
-	"BirchForest",
-	"MegaSpruceTaiga",
-	"MegaTaiga",
-	"ExtremeHills+",
-	"Forest",
-	"Plains",
-	"Desert",
-	"ColdTaiga",
-	"IcePlainsSpikes",
-	"SunflowerPlains",
-	"IcePlains",
-	"RoofedForest",
-	"ExtremeHills+_snowtop",
-	"MesaPlateauFM_grasstop",
-	"JungleEdgeM",
-	"ExtremeHillsM",
-	"JungleM",
-	"BirchForestM",
-	"MesaPlateauF",
-	"MesaPlateauFM",
-	"MesaPlateauF_grasstop",
-	"MesaBryce",
-	"JungleEdge",
-	"SavannaM",
 },
 9,
 minetest.LIGHT_MAX+1,
@@ -233,4 +204,4 @@ mobs:spawn(spawn_grass)
 mobs:register_egg("mobs_mc:rabbit", S("Rabbit"), "mobs_mc_spawn_icon_rabbit.png", 0)
 
 -- Note: This spawn egg does not exist in Minecraft
-mobs:register_egg("mobs_mc:killer_bunny", S("Killer Bunny"), "mobs_mc_spawn_icon_rabbit_caerbannog.png", 0) 
+mobs:register_egg("mobs_mc:killer_bunny", S("Killer Bunny"), "mobs_mc_spawn_icon_rabbit.png^[colorize:#FF0000:192", 0) -- TODO: Update inventory image

mods/ENTITIES/mobs_mc/sheep.lua

@@ -1,6 +1,6 @@
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### SHEEP
@@ -38,7 +38,7 @@ local rainbow_colors = {
 	"unicolor_red_violet"
 }
 
-if minetest.get_modpath("mcl_wool") then
+if minetest.get_modpath("mcl_wool") ~= nil then
 	colors["unicolor_light_blue"] = { mobs_mc.items.wool_light_blue, "#5050FFD0" }
 end
 
@@ -63,13 +63,8 @@ mobs:register_mob("mobs_mc:sheep", {
 	hp_max = 8,
 	xp_min = 1,
 	xp_max = 3,
-	skittish = true,
-	breed_distance = 1.5,
-	baby_size = 0.5,
-	follow_distance = 2,
-	follow = mobs_mc.items.wheat,
 	collisionbox = {-0.45, -0.01, -0.45, 0.45, 1.29, 0.45},
-	rotate = 270,
+
 	visual = "mesh",
 	visual_size = {x=3, y=3},
 	mesh = "mobs_mc_sheepfur.b3d",
@@ -78,23 +73,6 @@ mobs:register_mob("mobs_mc:sheep", {
 	color = "unicolor_white",
 	makes_footstep_sound = true,
 	walk_velocity = 1,
-	run_velocity = 3,
-
-	--head code
-	has_head = true,
-	head_bone = "head",
-
-	swap_y_with_x = false,
-	reverse_head_yaw = false,
-
-	head_bone_pos_y = 3.6,
-	head_bone_pos_z = -0.6,
-
-	head_height_offset = 1.0525,
-	head_direction_offset = 0.5,
-	head_pitch_modifier = 0,
-	--end head code
-
 	drops = {
 		{name = mobs_mc.items.mutton_raw,
 		chance = 1,
@@ -121,6 +99,7 @@ mobs:register_mob("mobs_mc:sheep", {
 		walk_start = 0,		walk_end = 40,
 		run_start = 0,		run_end = 40,
 	},
+	follow = mobs_mc.follow.sheep,
 	view_range = 12,
 
 	-- Eat grass
@@ -150,6 +129,7 @@ mobs:register_mob("mobs_mc:sheep", {
 	do_custom = function(self, dtime)
 		if not self.initial_color_set then
 			local r = math.random(0,100000)
+			local textures
 			if r <= 81836 then
 				-- 81.836%
 				self.color = "unicolor_white"
@@ -215,16 +195,8 @@ mobs:register_mob("mobs_mc:sheep", {
 	on_rightclick = function(self, clicker)
 		local item = clicker:get_wielded_item()
 
-		--attempt to enter breed state
+		if mobs:feed_tame(self, clicker, 1, true, true) then return end
-		if mobs.enter_breed_state(self,clicker) then
+		if mobs:protect(self, clicker) then return end
-			return
-		end
-
-		--make baby grow faster
-		if self.baby then
-			mobs.make_baby_grow_faster(self,clicker)
-			return
-		end
 
 		if item:get_name() == mobs_mc.items.shears and not self.gotten and not self.child then
 			self.gotten = true
@@ -280,6 +252,7 @@ mobs:register_mob("mobs_mc:sheep", {
 			end
 			return
 		end
+		if mobs:capture_mob(self, clicker, 0, 5, 70, false, nil) then return end
 	end,
 	on_breed = function(parent1, parent2)
 		-- Breed sheep and choose a fur color for the child.
@@ -336,53 +309,22 @@ mobs:spawn_specific(
 "overworld",
 "ground",
 {
-	"FlowerForest_beach",
+"FlowerForest",
-	"Forest_beach",
+"Swampland",
-	"StoneBeach",
+"Taiga",
-	"ColdTaiga_beach_water",
+"ExtremeHills",
-	"Taiga_beach",
+"BirchForest",
-	"Savanna_beach",
+"MegaSpruceTaiga",
-	"Plains_beach",
+"MegaTaiga",
-	"ExtremeHills_beach",
+"ExtremeHills+",
-	"ColdTaiga_beach",
+"Forest",
-	"Swampland_shore",
+"Plains",
-	"JungleM_shore",
+"ColdTaiga",
-	"Jungle_shore",
+"SunflowerPlains",
-	"MesaPlateauFM_sandlevel",
+"RoofedForest",
-	"MesaPlateauF_sandlevel",
+"MesaPlateauFM_grasstop",
-	"MesaBryce_sandlevel",
+"ExtremeHillsM",
-	"Mesa_sandlevel",
+"BirchForestM",
-	"Mesa",
-	"FlowerForest",
-	"Swampland",
-	"Taiga",
-	"ExtremeHills",
-	"Jungle",
-	"Savanna",
-	"BirchForest",
-	"MegaSpruceTaiga",
-	"MegaTaiga",
-	"ExtremeHills+",
-	"Forest",
-	"Plains",
-	"Desert",
-	"ColdTaiga",
-	"IcePlainsSpikes",
-	"SunflowerPlains",
-	"IcePlains",
-	"RoofedForest",
-	"ExtremeHills+_snowtop",
-	"MesaPlateauFM_grasstop",
-	"JungleEdgeM",
-	"ExtremeHillsM",
-	"JungleM",
-	"BirchForestM",
-	"MesaPlateauF",
-	"MesaPlateauFM",
-	"MesaPlateauF_grasstop",
-	"MesaBryce",
-	"JungleEdge",
-	"SavannaM",
 },
 0,
 minetest.LIGHT_MAX+1,
@@ -394,4 +336,3 @@ mobs_mc.spawn_height.overworld_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:sheep", S("Sheep"), "mobs_mc_spawn_icon_sheep.png", 0)
-

mods/ENTITIES/mobs_mc/shulker.lua

@@ -3,7 +3,7 @@
 --made for MC like Survival game
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### SHULKER
@@ -15,7 +15,7 @@ mobs:register_mob("mobs_mc:shulker", {
 	description = S("Shulker"),
 	type = "monster",
 	spawn_class = "hostile",
-	attack_type = "projectile",
+	attack_type = "shoot",
 	shoot_interval = 0.5,
 	arrow = "mobs_mc:shulkerbullet",
 	shoot_offset = 0.5,

mods/ENTITIES/mobs_mc/silverfish.lua

@@ -2,7 +2,7 @@
 --################### SILVERFISH
 --###################
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 mobs:register_mob("mobs_mc:silverfish", {
 	description = S("Silverfish"),
@@ -44,8 +44,9 @@ mobs:register_mob("mobs_mc:silverfish", {
 		run_start = 0,		run_end = 20,
 	},
 	view_range = 16,
-	attack_type = "punch",
+	attack_type = "dogfight",
 	damage = 1,
+	reach = 1,
 })
 
 mobs:register_egg("mobs_mc:silverfish", S("Silverfish"), "mobs_mc_spawn_icon_silverfish.png", 0)
@@ -61,7 +62,7 @@ if minetest.get_modpath("default") and mobs_mc.create_monster_egg_nodes then
 		description = "Stone Monster Egg",
 		tiles = {"default_stone.png"},
 		groups = {oddly_breakable_by_hand = 2, spawns_silverfish = 1},
-		drop = "",
+		drop = '',
 		is_ground_content = true,
 		sounds = default.node_sound_stone_defaults(),
 		after_dig_node = spawn_silverfish,
@@ -72,7 +73,7 @@ if minetest.get_modpath("default") and mobs_mc.create_monster_egg_nodes then
 		tiles = {"default_cobble.png"},
 		is_ground_content = false,
 		groups = {oddly_breakable_by_hand = 2, spawns_silverfish = 1},
-		drop = "",
+		drop = '',
 		sounds = default.node_sound_stone_defaults(),
 		after_dig_node = spawn_silverfish,
 	})
@@ -82,7 +83,7 @@ if minetest.get_modpath("default") and mobs_mc.create_monster_egg_nodes then
 		tiles = {"default_mossycobble.png"},
 		is_ground_content = false,
 		groups = {oddly_breakable_by_hand = 2, spawns_silverfish = 1},
-		drop = "",
+		drop = '',
 		sounds = default.node_sound_stone_defaults(),
 		after_dig_node = spawn_silverfish,
 	})
@@ -94,7 +95,7 @@ if minetest.get_modpath("default") and mobs_mc.create_monster_egg_nodes then
 		tiles = {"default_stone_brick.png"},
 		is_ground_content = false,
 		groups = {oddly_breakable_by_hand = 2, spawns_silverfish = 1},
-		drop = "",
+		drop = '',
 		sounds = default.node_sound_stone_defaults(),
 		after_dig_node = spawn_silverfish,
 	})
@@ -104,7 +105,7 @@ if minetest.get_modpath("default") and mobs_mc.create_monster_egg_nodes then
 		tiles = {"default_stone_block.png"},
 		is_ground_content = false,
 		groups = {oddly_breakable_by_hand = 2, spawns_silverfish = 1},
-		drop = "",
+		drop = '',
 		sounds = default.node_sound_stone_defaults(),
 		after_dig_node = spawn_silverfish,
 	})

mods/ENTITIES/mobs_mc/skeleton+stray.lua

@@ -3,8 +3,8 @@
 --made for MC like Survival game
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
-local mod_bows = minetest.get_modpath("mcl_bows")
+local mod_bows = minetest.get_modpath("mcl_bows") ~= nil
 
 --###################
 --################### SKELETON
@@ -16,37 +16,21 @@ local skeleton = {
 	description = S("Skeleton"),
 	type = "monster",
 	spawn_class = "hostile",
-	hostile = true,
-	rotate = 270,
 	hp_min = 20,
 	hp_max = 20,
 	xp_min = 6,
 	xp_max = 6,
 	breath_max = -1,
-	eye_height = 1.5,
-	projectile_cooldown = 1.5,
 	armor = {undead = 100, fleshy = 100},
 	collisionbox = {-0.3, -0.01, -0.3, 0.3, 1.98, 0.3},
 	pathfinding = 1,
 	group_attack = true,
 	visual = "mesh",
 	mesh = "mobs_mc_skeleton.b3d",
-
+	textures = { {
-    --head code
+		"mcl_bows_bow_0.png", -- bow
-	has_head = false,
+		"mobs_mc_skeleton.png", -- skeleton
-	head_bone = "head",
+	} },
-
-	swap_y_with_x = true,
-	reverse_head_yaw = true,
-
-	head_bone_pos_y = 2.4,
-	head_bone_pos_z = 0,
-
-	head_height_offset = 1.1,
-	head_direction_offset = 0,
-	head_pitch_modifier = 0,
-	--end head code
-
 	visual_size = {x=1, y=1},
 	makes_footstep_sound = true,
 	textures = {
@@ -59,7 +43,7 @@ local skeleton = {
 	walk_velocity = 1.2,
 	run_velocity = 2.4,
 	damage = 2,
-	reach = 3,
+	reach = 2,
 	drops = {
 		{name = mobs_mc.items.arrow,
 		chance = 1,
@@ -91,8 +75,6 @@ local skeleton = {
 		walk_speed = 15,
 		walk_start = 40,
 		walk_end = 60,
-		run_start = 40,
-		run_end = 60,
 		run_speed = 30,
 		shoot_start = 70,
 		shoot_end = 90,
@@ -104,13 +86,13 @@ local skeleton = {
 	ignited_by_sunlight = true,
 	view_range = 16,
 	fear_height = 4,
-	attack_type = "projectile",
+	attack_type = "dogshoot",
 	arrow = "mcl_bows:arrow_entity",
 	shoot_arrow = function(self, pos, dir)
 		if mod_bows then
 			-- 2-4 damage per arrow
-			local dmg = math.random(2,4)
+			local dmg = math.max(4, math.random(2, 8))
-			mobs.shoot_projectile_handling("mcl_bows:arrow", pos, dir, self.object:get_yaw(), self.object, nil, dmg)
+			mcl_bows.shoot_arrow("mcl_bows:arrow", pos, dir, self.object:get_yaw(), self.object, nil, dmg)
 		end
 	end,
 	shoot_interval = 2,

mods/ENTITIES/mobs_mc/skeleton_wither.lua

@@ -3,7 +3,7 @@
 --made for MC like Survival game
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### WITHER SKELETON
@@ -87,7 +87,7 @@ mobs:register_mob("mobs_mc:witherskeleton", {
 	fire_damage = 0,
 	light_damage = 0,
 	view_range = 16,
-	attack_type = "punch",
+	attack_type = "dogfight",
 	dogshoot_switch = 1,
 	dogshoot_count_max =0.5,
 	fear_height = 4,

mods/ENTITIES/mobs_mc/slime+magma_cube.lua

@@ -1,6 +1,6 @@
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 -- Returns a function that spawns children in a circle around pos.
 -- To be used as on_die callback.
@@ -31,22 +31,20 @@ local spawn_children_on_die = function(child_mob, children_count, spawn_distance
 				speed_penalty = 0.5
 			end
 			local mob = minetest.add_entity(newpos, child_mob)
-			if mob then
+			if (not mother_stuck) then
-				if (not mother_stuck) then
+				mob:set_velocity(vector.multiply(dir, eject_speed * speed_penalty))
-					mob:set_velocity(vector.multiply(dir, eject_speed * speed_penalty))
-				end
-				mob:set_yaw(angle - math.pi/2)
-				table.insert(children, mob)
-				angle = angle + (math.pi*2)/children_count
 			end
+			mob:set_yaw(angle - math.pi/2)
+			table.insert(children, mob)
+			angle = angle + (math.pi*2)/children_count
 		end
 		-- If mother was murdered, children attack the killer after 1 second
 		if self.state == "attack" then
 			minetest.after(1.0, function(children, enemy)
-				for c = 1, #children do
+				for c=1, #children do
 					local child = children[c]
 					local le = child:get_luaentity()
-					if le then
+					if le ~= nil then
 						le.state = "attack"
 						le.attack = enemy
 					end
@@ -66,7 +64,6 @@ local slime_big = {
 	hp_max = 16,
 	xp_min = 4,
 	xp_max = 4,
-	rotate = 270,
 	collisionbox = {-1.02, -0.01, -1.02, 1.02, 2.03, 1.02},
 	visual_size = {x=12.5, y=12.5},
 	textures = {{"mobs_mc_slime.png", "mobs_mc_slime.png"}},
@@ -98,9 +95,8 @@ local slime_big = {
 	},
 	fall_damage = 0,
 	view_range = 16,
-	attack_type = "jump_punch",
+	attack_type = "dogfight",
 	passive = false,
-	jump_only = true,
 	jump = true,
 	walk_velocity = 2.5,
 	run_velocity = 2.5,
@@ -313,7 +309,6 @@ local magma_cube_big = {
 	},
 	walk_velocity = 4,
 	run_velocity = 4,
-	rotate = 270,
 	damage = 6,
 	reach = 3,
 	armor = 53,
@@ -337,13 +332,12 @@ local magma_cube_big = {
 	},
 	water_damage = 0,
 	lava_damage = 0,
-    fire_damage = 0,
+        fire_damage = 0,
 	light_damage = 0,
 	fall_damage = 0,
 	view_range = 16,
-	attack_type = "jump_punch",
+	attack_type = "dogfight",
 	passive = false,
-	jump_only = true,
 	jump = true,
 	jump_height = 8,
 	walk_chance = 0,

mods/ENTITIES/mobs_mc/snowman.lua

@@ -3,12 +3,12 @@
 --made for MC like Survival game
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 local snow_trail_frequency = 0.5 -- Time in seconds for checking to add a new snow trail
 
 local mobs_griefing = minetest.settings:get_bool("mobs_griefing") ~= false
-local mod_throwing = minetest.get_modpath("mcl_throwing")
+local mod_throwing = minetest.get_modpath("mcl_throwing") ~= nil
 
 local gotten_texture = {
 	"mobs_mc_snowman.png",
@@ -179,9 +179,9 @@ mobs_mc.tools.check_snow_golem_summon = function(pos)
 			minetest.remove_node(pos)
 			minetest.remove_node(b1)
 			minetest.remove_node(b2)
-			minetest.check_for_falling(pos)
+			core.check_for_falling(pos)
-			minetest.check_for_falling(b1)
+			core.check_for_falling(b1)
-			minetest.check_for_falling(b2)
+			core.check_for_falling(b2)
 			local obj = minetest.add_entity(place, "mobs_mc:snowman")
 			if obj then
 				summon_particles(obj)

mods/ENTITIES/mobs_mc/spider.lua

@@ -3,7 +3,7 @@
 --made for MC like Survival game
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### SPIDER
@@ -17,22 +17,17 @@ local spider = {
 	type = "monster",
 	spawn_class = "hostile",
 	passive = false,
-	hostile = true,
-	always_climb = true,
 	docile_by_day = true,
-	attack_type = "punch",
+	attack_type = "dogfight",
-	punch_timer_cooloff = 0.5,
+	pathfinding = 1,
-	rotate = 270,
 	damage = 2,
 	reach = 2,
 	hp_min = 16,
 	hp_max = 16,
-	ignores_cobwebs = true,
 	xp_min = 5,
 	xp_max = 5,
-	eye_height = 0.475,
 	armor = {fleshy = 100, arthropod = 100},
-	collisionbox = {-0.45, 0, -0.45, 0.45, 0.9, 0.45},
+	collisionbox = {-0.7, -0.01, -0.7, 0.7, 0.89, 0.7},
 	visual = "mesh",
 	mesh = "mobs_mc_spider.b3d",
 	textures = {
@@ -49,7 +44,7 @@ local spider = {
 		distance = 16,
 	},
 	walk_velocity = 1.3,
-	run_velocity = 2.75, --spider can become extremely difficult if any higher
+	run_velocity = 2.8,
 	jump = true,
 	jump_height = 4,
 	view_range = 16,

mods/ENTITIES/mobs_mc/squid.lua

@@ -4,7 +4,7 @@
 --################### SQUID
 --###################
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 mobs:register_mob("mobs_mc:squid", {
 	description = S("Squid"),
@@ -17,8 +17,6 @@ mobs:register_mob("mobs_mc:squid", {
     xp_min = 1,
     xp_max = 3,
     armor = 100,
-    rotate = 270,
-    tilt_swim = true,
     -- FIXME: If the squid is near the floor, it turns black
     collisionbox = {-0.4, 0.0, -0.4, 0.4, 0.9, 0.4},
     visual = "mesh",
@@ -50,7 +48,8 @@ mobs:register_mob("mobs_mc:squid", {
 	},
     visual_size = {x=3, y=3},
     makes_footstep_sound = false,
-    swim = true,
+    fly = true,
+    fly_in = { mobs_mc.items.water_source, mobs_mc.items.river_water_source },
     breathes_in_water = true,
     jump = false,
     view_range = 16,

mods/ENTITIES/mobs_mc/vex.lua

@@ -3,7 +3,7 @@
 --made for MC like Survival game
 --License for code WTFPL and otherwise stated in readmes
 
-local S = minetest.get_translator(minetest.get_current_modname())
+local S = minetest.get_translator("mobs_mc")
 
 --###################
 --################### VEX
@@ -36,6 +36,7 @@ mobs:register_mob("mobs_mc:vex", {
 	view_range = 16,
 	walk_velocity = 3.2,
 	run_velocity = 5.9,
+	attack_type = "dogfight",
 	sounds = {
 		-- TODO: random
 		death = "mobs_mc_vex_death",