VoxeLibre/mods/ENTITIES/mobs_mc/rover.lua

711 lines
20 KiB
Lua
Raw Normal View History

2017-07-05 03:15:46 +02:00
--MCmobs v0.4
--maikerumine
--made for MC like Survival game
--License for code WTFPL and otherwise stated in readmes
-- ENDERMAN BEHAVIOUR (OLD):
-- In this game, endermen attack the player on sight, like other monsters do.
-- However, they have a reduced viewing range to make them less dangerous.
-- This differs from MC, in which endermen only become hostile when provoked,
-- and they are provoked by looking directly at them.
-- Rootyjr
-----------------------------
-- implemented ability to detect when seen / break eye contact and aggressive response
-- implemented teleport to avoid arrows.
-- implemented teleport to avoid rain.
-- implemented teleport to chase.
-- added enderman particles.
-- drew mcl_portal_particle1.png
-- drew mcl_portal_particle2.png
-- drew mcl_portal_particle3.png
-- drew mcl_portal_particle4.png
-- drew mcl_portal_particle5.png
-- added rain damage.
-- fixed the grass_with_dirt issue.
-- How freqeuntly to take and place blocks, in seconds
local take_frequency_min = 235
local take_frequency_max = 245
local place_frequency_min = 235
local place_frequency_max = 245
2022-10-05 20:14:01 +02:00
minetest.register_entity("mobs_mc:ender_eyes", {
2022-10-06 17:54:38 +02:00
on_step = function(self)
self.object:remove()
2022-10-05 20:14:01 +02:00
end,
})
local S = minetest.get_translator("mobs_mc")
local enable_damage = minetest.settings:get_bool("enable_damage")
2017-07-05 03:15:46 +02:00
local telesound = function(pos, is_source)
2020-12-10 16:35:48 +01:00
local snd
if is_source then
snd = "mobs_mc_enderman_teleport_src"
else
snd = "mobs_mc_enderman_teleport_dst"
end
minetest.sound_play(snd, {pos=pos, max_hear_distance=16}, true)
end
2017-07-05 03:15:46 +02:00
--###################
--################### ENDERMAN
--###################
local pr = PseudoRandom(os.time()*(-334))
2017-09-13 23:13:47 +02:00
2017-08-23 03:50:22 +02:00
-- Select a new animation definition.
local select_rover_animation = function(animation_type)
2017-08-23 03:50:22 +02:00
-- Enderman holds a block
if animation_type == "block" then
return {
walk_speed = 25,
run_speed = 50,
stand_speed = 25,
stand_start = 200,
stand_end = 200,
walk_start = 161,
walk_end = 200,
run_start = 161,
run_end = 200,
punch_start = 121,
punch_end = 160,
}
-- Enderman doesn't hold a block
elseif animation_type == "normal" or animation_type == nil then
return {
walk_speed = 25,
run_speed = 50,
stand_speed = 25,
stand_start = 40,
stand_end = 80,
walk_start = 0,
walk_end = 40,
run_start = 0,
run_end = 40,
punch_start = 81,
punch_end = 120,
}
end
end
local mobs_griefing = minetest.settings:get_bool("mobs_griefing") ~= false
local psdefs = {{
amount = 5,
minpos = vector.new(-0.6,0,-0.6),
maxpos = vector.new(0.6,3,0.6),
minvel = vector.new(-0.25,-0.25,-0.25),
maxvel = vector.new(0.25,0.25,0.25),
minacc = vector.new(-0.5,-0.5,-0.5),
maxacc = vector.new(0.5,0.5,0.5),
minexptime = 0.2,
maxexptime = 3,
minsize = 0.2,
maxsize = 1.2,
collisiondetection = true,
vertical = false,
time = 0,
texture = "mcl_portals_particle"..math.random(1, 5)..".png",
}}
2018-03-25 22:27:06 +02:00
mcl_mobs.register_mob("mobs_mc:rover", {
2024-05-05 21:12:37 +02:00
description = S("Rover"),
type = "monster",
2020-04-11 02:46:03 +02:00
spawn_class = "passive",
can_despawn = true,
passive = true,
pathfinding = 1,
2017-07-05 03:15:46 +02:00
hp_min = 40,
hp_max = 40,
2020-12-06 15:46:42 +01:00
xp_min = 5,
xp_max = 5,
2017-07-05 03:15:46 +02:00
collisionbox = {-0.3, -0.01, -0.3, 0.3, 2.89, 0.3},
visual = "mesh",
mesh = "vl_rover.b3d",
textures = { "vl_mobs_rover.png^vl_mobs_rover_face.png" },
glow = 100,
visual_size = {x=10, y=10},
2017-07-05 03:15:46 +02:00
makes_footstep_sound = true,
sounds = {
2020-12-10 17:52:14 +01:00
-- TODO: Custom war cry sound
2017-07-05 03:15:46 +02:00
war_cry = "mobs_sandmonster",
2020-12-10 17:52:14 +01:00
death = {name="mobs_mc_enderman_death", gain=0.7},
damage = {name="mobs_mc_enderman_hurt", gain=0.5},
random = {name="mobs_mc_enderman_random", gain=0.5},
2017-07-05 03:15:46 +02:00
distance = 16,
},
walk_velocity = 2,
run_velocity = 4,
2017-07-05 03:15:46 +02:00
damage = 7,
2017-07-26 00:26:18 +02:00
reach = 2,
particlespawners = psdefs,
2017-07-05 03:15:46 +02:00
drops = {
2022-05-25 23:25:15 +02:00
{name = "mcl_throwing:ender_pearl",
2017-07-05 03:15:46 +02:00
chance = 1,
min = 0,
2020-12-23 17:41:42 +01:00
max = 1,
looting = "common"},
2017-07-05 03:15:46 +02:00
},
animation = select_rover_animation("normal"),
2017-07-05 03:15:46 +02:00
_taken_node = "",
2022-07-21 03:07:03 +02:00
can_spawn = function(pos)
return #minetest.find_nodes_in_area(vector.offset(pos,0,1,0),vector.offset(pos,0,3,0),{"air"}) > 2
end,
2017-07-05 03:15:46 +02:00
do_custom = function(self, dtime)
-- RAIN DAMAGE / EVASIVE WARP BEHAVIOUR HERE.
2022-10-14 00:24:44 +02:00
local enderpos = self.object:get_pos()
local dim = mcl_worlds.pos_to_dimension(enderpos)
2023-03-03 14:03:26 +01:00
if dim == "overworld" then
if mcl_weather.state == "rain" or mcl_weather.state == "lightning" then
local damage = true
local enderpos = self.object:get_pos()
enderpos.y = enderpos.y+2.89
local height = {x=enderpos.x, y=enderpos.y+512,z=enderpos.z}
local ray = minetest.raycast(enderpos, height, true)
-- Check for blocks above enderman.
for pointed_thing in ray do
if pointed_thing.type == "node" then
local nn = minetest.get_node(minetest.get_pointed_thing_position(pointed_thing)).name
local def = minetest.registered_nodes[nn]
if (not def) or def.walkable then
-- There's a node in the way. Delete arrow without damage
damage = false
break
end
end
end
if damage == true then
self.state = ""
--rain hurts enderman
self.object:punch(self.object, 1.0, {
full_punch_interval=1.0,
damage_groups={fleshy=self._damage},
}, nil)
--randomly teleport hopefully under something.
self:teleport(nil)
end
end
2023-03-03 14:03:26 +01:00
end
2023-03-04 01:55:56 +01:00
-- AGRESSIVELY WARP/CHASE PLAYER BEHAVIOUR HERE.
if self.state == "attack" then
self.object:set_properties({textures={"vl_mobs_rover.png^vl_mobs_rover_face_angry.png"}})
if self.attack then
local target = self.attack
local pos = target:get_pos()
if pos ~= nil then
if vector.distance(self.object:get_pos(), target:get_pos()) > 10 then
self:teleport(target)
end
end
end
else --if not attacking try to tp to the dark
self.object:set_properties({textures={"vl_mobs_rover.png^vl_mobs_rover_face.png"}})
2023-03-04 01:55:56 +01:00
if dim == 'overworld' then
local light = minetest.get_node_light(enderpos)
if light and light > minetest.LIGHT_MAX then
self:teleport(nil)
end
end
end
-- ARROW / DAYTIME PEOPLE AVOIDANCE BEHAVIOUR HERE.
-- Check for arrows and people nearby.
enderpos = self.object:get_pos()
enderpos.y = enderpos.y + 1.5
local objs = minetest.get_objects_inside_radius(enderpos, 2)
for n = 1, #objs do
2020-07-11 11:53:58 +02:00
local obj = objs[n]
if obj then
if minetest.is_player(obj) then
-- Warp from players during day.
2021-01-05 20:12:50 +01:00
--if (minetest.get_timeofday() * 24000) > 5001 and (minetest.get_timeofday() * 24000) < 19000 then
-- self:teleport(nil)
--end
else
2020-07-11 11:53:58 +02:00
local lua = obj:get_luaentity()
if lua then
if lua.name == "mcl_bows:arrow_entity" or lua.name == "mcl_throwing:snowball_entity" then
self:teleport(nil)
end
end
end
end
end
-- PROVOKED BEHAVIOUR HERE.
local enderpos = self.object:get_pos()
if self.provoked == "broke_contact" then
self.provoked = "false"
2021-01-05 20:12:50 +01:00
--if (minetest.get_timeofday() * 24000) > 5001 and (minetest.get_timeofday() * 24000) < 19000 then
-- self:teleport(nil)
-- self.state = ""
--else
if self.attack ~= nil and enable_damage then
self.state = 'attack'
end
2021-01-05 20:12:50 +01:00
--end
end
-- Check to see if people are near by enough to look at us.
for _,obj in pairs(minetest.get_connected_players()) do
2021-04-25 17:30:15 +02:00
--check if they are within radius
local player_pos = obj:get_pos()
if player_pos then -- prevent crashing in 1 in a million scenario
local ender_distance = vector.distance(enderpos, player_pos)
if ender_distance <= 64 then
-- Check if they are looking at us.
local look_dir_not_normalized = obj:get_look_dir()
local look_dir = vector.normalize(look_dir_not_normalized)
local player_eye_height = obj:get_properties().eye_height
--skip player if they have no data - log it
if not player_eye_height then
minetest.log("error", "Enderman at location: ".. dump(enderpos).." has indexed a null player!")
else
--calculate very quickly the exact location the player is looking
--within the distance between the two "heads" (player and enderman)
local look_pos = vector.new(player_pos.x, player_pos.y + player_eye_height, player_pos.z)
local look_pos_base = look_pos
local ender_eye_pos = vector.new(enderpos.x, enderpos.y + 2.75, enderpos.z)
local eye_distance_from_player = vector.distance(ender_eye_pos, look_pos)
look_pos = vector.add(look_pos, vector.multiply(look_dir, eye_distance_from_player))
2021-04-25 17:30:15 +02:00
--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.attack = minetest.get_player_by_name(obj:get_player_name())
break
else -- I'm not sure what this part does, but I don't want to break anything - jordan4ibanez
if self.provoked == "staring" then
self.provoked = "broke_contact"
2021-04-25 17:30:15 +02:00
end
end
end
end
end
end
-- ATTACK ENDERMITE
local enderpos = self.object:get_pos()
2023-03-02 13:57:33 +01:00
if math.random(1,140) == 1 then
2023-03-02 13:20:00 +01:00
local mobsnear = minetest.get_objects_inside_radius(enderpos, 64)
for n=1, #mobsnear do
local mob = mobsnear[n]
if mob then
local entity = mob:get_luaentity()
if entity and entity.name == "mobs_mc:endermite" then
self.attack = mob
2023-03-04 01:55:56 +01:00
self.state = 'attack'
2023-03-02 13:20:00 +01:00
end
end
end
end
-- TAKE AND PLACE STUFF BEHAVIOUR BELOW.
2018-03-25 22:27:06 +02:00
if not mobs_griefing then
return
end
2017-07-05 03:15:46 +02:00
-- Take and put nodes
2017-09-13 23:13:47 +02:00
if not self._take_place_timer or not self._next_take_place_time then
2017-07-05 03:15:46 +02:00
self._take_place_timer = 0
2017-09-13 23:13:47 +02:00
self._next_take_place_time = math.random(take_frequency_min, take_frequency_max)
2017-07-05 03:15:46 +02:00
return
end
self._take_place_timer = self._take_place_timer + dtime
2017-09-13 23:13:47 +02:00
if (self._taken_node == nil or self._taken_node == "") and self._take_place_timer >= self._next_take_place_time then
2017-07-05 03:15:46 +02:00
-- Take random node
self._take_place_timer = 0
2017-09-13 23:13:47 +02:00
self._next_take_place_time = math.random(place_frequency_min, place_frequency_max)
2019-02-01 06:33:07 +01:00
local pos = self.object:get_pos()
2022-05-25 14:57:59 +02:00
local takable_nodes = minetest.find_nodes_in_area_under_air({x=pos.x-2, y=pos.y-1, z=pos.z-2}, {x=pos.x+2, y=pos.y+1, z=pos.z+2}, "group:enderman_takable")
2017-07-05 03:15:46 +02:00
if #takable_nodes >= 1 then
local r = pr:next(1, #takable_nodes)
local take_pos = takable_nodes[r]
local node = minetest.get_node(take_pos)
-- Don't destroy protected stuff.
if not minetest.is_protected(take_pos, "") then
minetest.remove_node(take_pos)
local dug = minetest.get_node_or_nil(take_pos)
if dug and dug.name == "air" then
local node_obj = vl_held_item.create_item_entity(take_pos, node.name)
if node_obj then
node_obj:set_attach(self.object, "held_node")
self._node_obj = node_obj
self._taken_node = node.name
node_obj:set_properties({visual_size={x=0.02, y=0.02}})
end
local def = minetest.registered_nodes[self._taken_node]
self.animation = select_rover_animation("block")
2022-11-09 06:06:59 +01:00
self:set_animation(self.animation.current)
if def and def.sounds and def.sounds.dug then
minetest.sound_play(def.sounds.dug, {pos = take_pos, max_hear_distance = 16}, true)
end
2017-07-05 03:15:46 +02:00
end
end
end
elseif self._taken_node ~= nil and self._taken_node ~= "" and self._take_place_timer >= self._next_take_place_time then
2017-07-05 03:15:46 +02:00
-- Place taken node
self._take_place_timer = 0
2017-09-13 23:13:47 +02:00
self._next_take_place_time = math.random(take_frequency_min, take_frequency_max)
2019-02-01 06:33:07 +01:00
local pos = self.object:get_pos()
2017-07-05 03:15:46 +02:00
local yaw = self.object:get_yaw()
-- Place node at looking direction
local place_pos = vector.subtract(pos, minetest.facedir_to_dir(minetest.dir_to_facedir(minetest.yaw_to_dir(yaw))))
-- Also check to see if protected.
if minetest.get_node(place_pos).name == "air" and not minetest.is_protected(place_pos, "") then
2017-07-05 03:15:46 +02:00
-- ... but only if there's a free space
local success = minetest.place_node(place_pos, {name = self._taken_node})
if success then
local def = minetest.registered_nodes[self._taken_node]
-- Update animation accordingly (removes visible block)
self.persistent = false
self.animation = select_rover_animation("normal")
2022-11-09 06:06:59 +01:00
self:set_animation(self.animation.current)
if def and def.sounds and def.sounds.place then
2020-04-07 00:55:45 +02:00
minetest.sound_play(def.sounds.place, {pos = place_pos, max_hear_distance = 16}, true)
end
self._node_obj:remove()
self._node_obj = nil
self._taken_node = nil
2017-07-05 03:15:46 +02:00
end
end
end
end,
do_teleport = function(self, target)
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 ~= nil then
2020-06-17 06:59:16 +02:00
if #nodes > 0 then
-- Up to 64 attempts to teleport
for n=1, math.min(64, #nodes) do
local r = pr:next(1, #nodes)
local nodepos = nodes[r]
local node_ok = true
-- Selected node needs to have 3 nodes of free space above
for u=1, 3 do
local node = minetest.get_node({x=nodepos.x, y=nodepos.y+u, z=nodepos.z})
local ndef = minetest.registered_nodes[node.name]
if ndef and ndef.walkable then
2020-06-17 06:59:16 +02:00
node_ok = false
break
end
end
if node_ok then
telepos = {x=nodepos.x, y=nodepos.y+1, z=nodepos.z}
end
end
2020-06-17 06:59:16 +02:00
if telepos then
2020-12-10 16:35:48 +01:00
telesound(self.object:get_pos(), false)
2020-06-17 06:59:16 +02:00
self.object:set_pos(telepos)
2020-12-10 16:35:48 +01:00
telesound(telepos, true)
2017-07-05 03:15:46 +02:00
end
end
end
else
-- Attempt to randomly teleport enderman
local pos = self.object:get_pos()
-- Up to 8 top-level attempts to teleport
for n=1, 8 do
local node_ok = false
-- 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 ~= 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
local r = pr:next(1, #nodes)
local nodepos = nodes[r]
node_ok = true
for u=1, 3 do
local node = minetest.get_node({x=nodepos.x, y=nodepos.y+u, z=nodepos.z})
local ndef = minetest.registered_nodes[node.name]
if ndef and ndef.walkable then
node_ok = false
break
end
end
if node_ok then
2020-12-10 16:35:48 +01:00
telesound(self.object:get_pos(), false)
local telepos = {x=nodepos.x, y=nodepos.y+1, z=nodepos.z}
self.object:set_pos(telepos)
telesound(telepos, true)
2020-06-17 06:59:16 +02:00
break
end
end
end
end
if node_ok then
break
end
2017-07-05 03:15:46 +02:00
end
end
end,
on_die = function(self, pos)
-- Drop carried node on death
if self._taken_node ~= nil and self._taken_node ~= "" then
2017-07-05 03:15:46 +02:00
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 ~= nil then
2021-01-05 20:12:50 +01:00
--if (minetest.get_timeofday() * 24000) > 5001 and (minetest.get_timeofday() * 24000) < 19000 then
-- self:teleport(nil)
--else
if pr:next(1, 8) == 8 then --FIXME: real mc rate
self:teleport(hitter)
end
self.attack=hitter
self.state="attack"
2021-01-05 20:12:50 +01:00
--end
end
end,
after_activate = function(self, staticdata, def, dtime)
if not self._taken_node or self._taken_node == "" then
self.animation = select_rover_animation("normal")
self:set_animation(self.animation.current)
return
end
self.animation = select_rover_animation("block")
self:set_animation(self.animation.current)
local node_obj = vl_held_item.create_item_entity(self.object:get_pos(), self._taken_node)
if node_obj then
node_obj:set_attach(self.object, "held_node")
self._node_obj = node_obj
node_obj:set_properties({visual_size={x=0.02, y=0.02}})
end
end,
2020-08-05 18:33:53 +02:00
armor = { fleshy = 100, water_vulnerable = 100 },
2017-07-05 03:15:46 +02:00
water_damage = 8,
view_range = 64,
2017-07-05 03:15:46 +02:00
fear_height = 4,
attack_type = "dogfight",
_on_after_convert = function(obj)
2024-05-12 06:28:24 +02:00
obj:set_properties({
mesh = "vl_rover.b3d",
textures = { "vl_mobs_rover.png^vl_mobs_rover_face.png" },
visual_size = {x=10, y=10},
})
end
}) -- END mcl_mobs.register_mob("mobs_mc:rover", {
-- compat
mcl_mobs.register_conversion("mobs_mc:enderman", "mobs_mc:rover")
2024-05-05 22:55:25 +02:00
-- End spawn
2022-05-25 14:44:49 +02:00
mcl_mobs:spawn_specific(
"mobs_mc:rover",
2021-04-25 17:30:15 +02:00
"end",
2021-04-08 13:39:18 +02:00
"ground",
{
2022-09-11 19:55:13 +02:00
"End",
"EndIsland",
"EndMidlands",
"EndBarrens",
"EndBorder",
"EndSmallIslands"
2021-04-08 13:39:18 +02:00
},
2021-04-25 17:30:15 +02:00
0,
minetest.LIGHT_MAX+1,
30,
100,
2021-04-25 17:30:15 +02:00
12,
2022-05-25 23:25:15 +02:00
mcl_vars.mg_end_min,
mcl_vars.mg_end_max)
-- Overworld spawn
2022-05-25 14:44:49 +02:00
mcl_mobs:spawn_specific(
"mobs_mc:rover",
2021-04-25 17:30:15 +02:00
"overworld",
2021-04-08 13:39:18 +02:00
"ground",
{
"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",
"FlowerForest_beach",
"Forest_beach",
"StoneBeach",
"ColdTaiga_beach_water",
"Taiga_beach",
"Savanna_beach",
"Plains_beach",
"ExtremeHills_beach",
"ColdTaiga_beach",
"Swampland_shore",
"JungleM_shore",
"Jungle_shore",
"MesaPlateauFM_sandlevel",
"MesaPlateauF_sandlevel",
"MesaBryce_sandlevel",
"Mesa_sandlevel",
"RoofedForest_ocean",
"JungleEdgeM_ocean",
"BirchForestM_ocean",
"BirchForest_ocean",
"IcePlains_deep_ocean",
"Jungle_deep_ocean",
"Savanna_ocean",
"MesaPlateauF_ocean",
"ExtremeHillsM_deep_ocean",
"Savanna_deep_ocean",
"SunflowerPlains_ocean",
"Swampland_deep_ocean",
"Swampland_ocean",
"MegaSpruceTaiga_deep_ocean",
"ExtremeHillsM_ocean",
"JungleEdgeM_deep_ocean",
"SunflowerPlains_deep_ocean",
"BirchForest_deep_ocean",
"IcePlainsSpikes_ocean",
"Mesa_ocean",
"StoneBeach_ocean",
"Plains_deep_ocean",
"JungleEdge_deep_ocean",
"SavannaM_deep_ocean",
"Desert_deep_ocean",
"Mesa_deep_ocean",
"ColdTaiga_deep_ocean",
"Plains_ocean",
"MesaPlateauFM_ocean",
"Forest_deep_ocean",
"JungleM_deep_ocean",
"FlowerForest_deep_ocean",
"MegaTaiga_ocean",
"StoneBeach_deep_ocean",
"IcePlainsSpikes_deep_ocean",
"ColdTaiga_ocean",
"SavannaM_ocean",
"MesaPlateauF_deep_ocean",
"MesaBryce_deep_ocean",
"ExtremeHills+_deep_ocean",
"ExtremeHills_ocean",
"Forest_ocean",
"MegaTaiga_deep_ocean",
"JungleEdge_ocean",
"MesaBryce_ocean",
"MegaSpruceTaiga_ocean",
"ExtremeHills+_ocean",
"Jungle_ocean",
"RoofedForest_deep_ocean",
"IcePlains_ocean",
"FlowerForest_ocean",
"ExtremeHills_deep_ocean",
"MesaPlateauFM_deep_ocean",
"Desert_ocean",
"Taiga_ocean",
"BirchForestM_deep_ocean",
"Taiga_deep_ocean",
"JungleM_ocean",
"FlowerForest_underground",
"JungleEdge_underground",
"StoneBeach_underground",
"MesaBryce_underground",
"Mesa_underground",
"RoofedForest_underground",
"Jungle_underground",
"Swampland_underground",
"BirchForest_underground",
"Plains_underground",
"MesaPlateauF_underground",
"ExtremeHills_underground",
"MegaSpruceTaiga_underground",
"BirchForestM_underground",
"SavannaM_underground",
"MesaPlateauFM_underground",
"Desert_underground",
"Savanna_underground",
"Forest_underground",
"SunflowerPlains_underground",
"ColdTaiga_underground",
"IcePlains_underground",
"IcePlainsSpikes_underground",
"MegaTaiga_underground",
"Taiga_underground",
"ExtremeHills+_underground",
"JungleM_underground",
"ExtremeHillsM_underground",
"JungleEdgeM_underground",
},
2021-04-25 17:30:15 +02:00
0,
7,
30,
100,
2021-04-25 17:30:15 +02:00
2,
2022-05-25 23:25:15 +02:00
mcl_vars.mg_overworld_min,
mcl_vars.mg_overworld_max)
2021-04-08 13:39:18 +02:00
-- Nether spawn (rare)
2022-05-25 14:44:49 +02:00
mcl_mobs:spawn_specific(
"mobs_mc:rover",
2021-04-25 17:30:15 +02:00
"nether",
2021-04-08 13:39:18 +02:00
"ground",
{
"Nether",
2022-09-11 19:55:13 +02:00
"SoulsandValley",
2021-04-08 13:39:18 +02:00
},
2021-04-25 17:30:15 +02:00
0,
11,
2021-04-25 17:30:15 +02:00
30,
100,
2021-04-25 17:30:15 +02:00
4,
2022-05-25 23:25:15 +02:00
mcl_vars.mg_nether_min,
mcl_vars.mg_nether_max)
2017-07-05 03:15:46 +02:00
-- Warped Forest spawn (common)
mcl_mobs:spawn_specific(
"mobs_mc:rover",
"nether",
"ground",
{
"WarpedForest"
},
0,
11,
30,
100,
4,
mcl_vars.mg_nether_min,
mcl_vars.mg_nether_max)
2017-07-05 03:15:46 +02:00
-- spawn eggs
mcl_mobs.register_egg("mobs_mc:rover", S("Rover"), "#252525", "#151515", 0)
2024-05-05 22:55:25 +02:00
minetest.register_alias("mobs_mc:enderman", "mobs_mc:rover")