Bram
/
MineClone2
1
0
Fork 0
Code Pull Requests Activity

Merge master

mineclone5
kay27 2021-06-12 15:12:33 +04:00
parent 525599d340 e11dc4b58e
commit b3e3b91b7c
432 changed files with 8331 additions and 4699 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
# Text Editor TMP Files
*.swp

12
.luacheckrc
View File

@ -40,4 +40,16 @@ read_globals = {
"factorial"
}
},
------
--MODS
------
--GENERAL
"default",
--ENTITIES
"cmi",
--HUD
"sfinv", "sfinv_buttons", "unified_inventory", "cmsg", "inventory_plus",
}

24
CONTRIBUTING.md
View File

@ -1,5 +1,5 @@
# Contributing to MineClone 2
So you want to MineClone 2?
So you want to contribute to MineClone 2?
Wow, thank you! :-)
But first, some things to note:
@ -46,6 +46,28 @@ Your commit names should be relatively descriptive, e.g. when saying "Fix #issue
Contributors will be credited in `CREDITS.md`.
## Code Style
Each mod must provide `mod.conf`.
Each mod which add API functions should store functions inside a global table named like the mod.
Public functions should not use self references but rather just access the table directly.
Functions should be defined in this way:
```
function mcl_xyz.stuff(param) end
```
Insteed of this way:
```
mcl_xyz.stuff = function(param) end
```
Indentation must be unified, more likely with tabs.
Time sensitive mods should make a local copy of most used API functions to improve performances.
```
local vector = vector
local get_node = minetest.get_node
```
## Features > 1.12
If you want to make a feature that was added in a Minecraft version later than 1.12, you should fork MineClone5 (mineclone5 branch in the repository) and add your changes to this.

4
README.md
View File

@ -82,10 +82,10 @@ Please report all bugs and missing Minecraft features here:
<https://git.minetest.land/MineClone2/MineClone2/issues>
## Chating with the community
## Chatting with the community
Join our discord server at:
<https://discord.gg/84GKcxczG3>
<https://discord.gg/xE4z8EEpDC>
## Project description
The main goal of **MineClone 2** is to be a clone of Minecraft and to be released as free software.

BIN
menu/Header.blend Normal file
View File

Binary file not shown.

20
mods/CORE/_mcl_autogroup/init.lua
View File

@ -83,7 +83,7 @@ local function get_hardness_values_for_groups()
for _, ndef in pairs(minetest.registered_nodes) do
for g, _ in pairs(mcl_autogroup.registered_diggroups) do
if ndef.groups[g] ~= nil then
if ndef.groups[g] then
maps[g][ndef._mcl_hardness or 0] = true
end
end
@ -121,7 +121,7 @@ local hardness_values = get_hardness_values_for_groups()
-- hardness_value. Used for quick lookup.
local hardness_lookup = get_hardness_lookup_for_groups(hardness_values)
local function compute_creativetimes(group)
--[[local function compute_creativetimes(group)
local creativetimes = {}
for index, hardness in pairs(hardness_values[group]) do
@ -129,7 +129,7 @@ local function compute_creativetimes(group)
end
return creativetimes
end
end]]
-- Get the list of digging times for using a specific tool on a specific
-- diggroup.
@ -239,13 +239,13 @@ function mcl_autogroup.can_harvest(nodename, toolname)
end
-- Get one groupcap field for using a specific tool on a specific group.
local function get_groupcap(group, can_harvest, multiplier, efficiency, uses)
--[[local function get_groupcap(group, can_harvest, multiplier, efficiency, uses)
return {
times = get_digtimes(group, can_harvest, multiplier, efficiency),
uses = uses,
maxlevel = 0,
}
end
end]]
-- Returns the tool_capabilities from a tool definition or a default set of
-- tool_capabilities
@ -271,7 +271,7 @@ end
-- toolname - Name of the tool being enchanted (like "mcl_tools:diamond_pickaxe")
-- efficiency - The efficiency level the tool is enchanted with (default 0)
--
-- NOTE:
-- NOTE:
-- This function can only be called after mod initialization. Otherwise a mod
-- would have to add _mcl_autogroup as a dependency which would break the mod
-- loading order.
@ -288,7 +288,7 @@ end
-- toolname - Name of the tool used
-- diggroup - The name of the diggroup the tool is used on
--
-- NOTE:
-- NOTE:
-- This function can only be called after mod initialization. Otherwise a mod
-- would have to add _mcl_autogroup as a dependency which would break the mod
-- loading order.
@ -298,7 +298,7 @@ function mcl_autogroup.get_wear(toolname, diggroup)
return math.ceil(65535 / uses)
end
local overwrite = function()
local function overwrite()
for nname, ndef in pairs(minetest.registered_nodes) do
local newgroups = table.copy(ndef.groups)
if (nname ~= "ignore" and ndef.diggable) then
@ -315,12 +315,12 @@ local overwrite = function()
newgroups.opaque = 1
end
local creative_breakable = false
--local creative_breakable = false
-- Assign groups used for digging this node depending on
-- the registered digging groups
for g, gdef in pairs(mcl_autogroup.registered_diggroups) do
creative_breakable = true
--creative_breakable = true
local index = hardness_lookup[g][ndef._mcl_hardness or 0]
if ndef.groups[g] then
if gdef.levels then

10
mods/CORE/biomeinfo/init.lua
View File

@ -81,11 +81,11 @@ if v6_use_snow_biomes then
end
local v6_freq_desert = tonumber(minetest.get_mapgen_setting("mgv6_freq_desert") or 0.45)
local NOISE_MAGIC_X = 1619
local NOISE_MAGIC_Y = 31337
local NOISE_MAGIC_Z = 52591
local NOISE_MAGIC_SEED = 1013
local noise2d = function(x, y, seed)
--local NOISE_MAGIC_X = 1619
--local NOISE_MAGIC_Y = 31337
--local NOISE_MAGIC_Z = 52591
--local NOISE_MAGIC_SEED = 1013
local function noise2d(x, y, seed)
-- TODO: implement noise2d function for biome blend
return 0
--[[

58
mods/CORE/controls/init.lua
View File

@ -1,6 +1,8 @@
local get_connected_players = minetest.get_connected_players
local clock = os.clock
local pairs = pairs
controls = {}
controls.players = {}
@ -20,15 +22,15 @@ function controls.register_on_hold(func)
end
local known_controls = {
jump=true,
right=true,
left=true,
LMB=true,
RMB=true,
sneak=true,
aux1=true,
down=true,
up=true,
jump = true,
right = true,
left = true,
LMB = true,
RMB = true,
sneak = true,
aux1 = true,
down = true,
up = true,
}
minetest.register_on_joinplayer(function(player)
@ -49,27 +51,27 @@ minetest.register_globalstep(function(dtime)
local player_name = player:get_player_name()
local player_controls = player:get_player_control()
if controls.players[player_name] then
for cname, cbool in pairs(player_controls) do
if known_controls[cname] == true then
--Press a key
if cbool==true and controls.players[player_name][cname][1]==false then
for _, func in pairs(controls.registered_on_press) do
func(player, cname)
for cname, cbool in pairs(player_controls) do
if known_controls[cname] == true then
--Press a key
if cbool == true and controls.players[player_name][cname][1] == false then
for _, func in pairs(controls.registered_on_press) do
func(player, cname)
end
controls.players[player_name][cname] = {true, clock()}
elseif cbool == true and controls.players[player_name][cname][1] == true then
for _, func in pairs(controls.registered_on_hold) do
func(player, cname, clock()-controls.players[player_name][cname][2])
end
--Release a key
elseif cbool == false and controls.players[player_name][cname][1] == true then
for _, func in pairs(controls.registered_on_release) do
func(player, cname, clock()-controls.players[player_name][cname][2])
end
controls.players[player_name][cname] = {false}
end
end
controls.players[player_name][cname] = {true, clock()}
elseif cbool==true and controls.players[player_name][cname][1]==true then
for _, func in pairs(controls.registered_on_hold) do
func(player, cname, clock()-controls.players[player_name][cname][2])
end
--Release a key
elseif cbool==false and controls.players[player_name][cname][1]==true then
for _, func in pairs(controls.registered_on_release) do
func(player, cname, clock()-controls.players[player_name][cname][2])
end
controls.players[player_name][cname] = {false}
end
end
end
end
end
end)

144
mods/CORE/flowlib/init.lua
View File

@ -1,95 +1,100 @@
local math = math
local get_node = minetest.get_node
local get_item_group = minetest.get_item_group
local registered_nodes = minetest.registered_nodes
flowlib = {}
--sum of direction vectors must match an array index
--(sum,root)
--(0,1), (1,1+0=1), (2,1+1=2), (3,1+2^2=5), (4,2^2+2^2=8)
local inv_roots = {
[0] = 1,
[1] = 1,
[2] = 0.70710678118655,
[4] = 0.5,
[5] = 0.44721359549996,
[8] = 0.35355339059327,
}
local function to_unit_vector(dir_vector)
--(sum,root)
-- (0,1), (1,1+0=1), (2,1+1=2), (3,1+2^2=5), (4,2^2+2^2=8)
local inv_roots = {[0] = 1, [1] = 1, [2] = 0.70710678118655, [4] = 0.5
, [5] = 0.44721359549996, [8] = 0.35355339059327}
local sum = dir_vector.x*dir_vector.x + dir_vector.z*dir_vector.z
return {x=dir_vector.x*inv_roots[sum],y=dir_vector.y
,z=dir_vector.z*inv_roots[sum]}
local sum = dir_vector.x * dir_vector.x + dir_vector.z * dir_vector.z
return {x = dir_vector.x * inv_roots[sum], y = dir_vector.y, z = dir_vector.z * inv_roots[sum]}
end
local is_touching = function(realpos,nodepos,radius)
local function is_touching(realpos,nodepos,radius)
local boarder = 0.5 - radius
return (math.abs(realpos - nodepos) > (boarder))
return math.abs(realpos - nodepos) > (boarder)
end
flowlib.is_touching = is_touching
local is_water = function(pos)
return (minetest.get_item_group(minetest.get_node(
{x=pos.x,y=pos.y,z=pos.z}).name
, "water") ~= 0)
local function is_water(pos)
return get_item_group(get_node(pos).name, "water") ~= 0
end
flowlib.is_water = is_water
local node_is_water = function(node)
return (minetest.get_item_group(node.name, "water") ~= 0)
local function node_is_water(node)
return get_item_group(node.name, "water") ~= 0
end
flowlib.node_is_water = node_is_water
local is_lava = function(pos)
return (minetest.get_item_group(minetest.get_node(
{x=pos.x,y=pos.y,z=pos.z}).name
, "lava") ~= 0)
local function is_lava(pos)
return get_item_group(get_node(pos).name, "lava") ~= 0
end
flowlib.is_lava = is_lava
local node_is_lava = function(node)
return (minetest.get_item_group(node.name, "lava") ~= 0)
local function node_is_lava(node)
return get_item_group(node.name, "lava") ~= 0
end
flowlib.node_is_lava = node_is_lava
local is_liquid = function(pos)
return (minetest.get_item_group(minetest.get_node(
{x=pos.x,y=pos.y,z=pos.z}).name
, "liquid") ~= 0)
local function is_liquid(pos)
return get_item_group(get_node(pos).name, "liquid") ~= 0
end
flowlib.is_liquid = is_liquid
local node_is_liquid = function(node)
return (minetest.get_item_group(node.name, "liquid") ~= 0)
local function node_is_liquid(node)
return minetest.get_item_group(node.name, "liquid") ~= 0
end
flowlib.node_is_liquid = node_is_liquid
--This code is more efficient
local function quick_flow_logic(node,pos_testing,direction)
local function quick_flow_logic(node, pos_testing, direction)
local name = node.name
if not minetest.registered_nodes[name] then
if not registered_nodes[name] then
return 0
end
if minetest.registered_nodes[name].liquidtype == "source" then
local node_testing = minetest.get_node(pos_testing)
local param2_testing = node_testing.param2
if not minetest.registered_nodes[node_testing.name] then
if registered_nodes[name].liquidtype == "source" then
local node_testing = get_node(pos_testing)
if not registered_nodes[node_testing.name] then
return 0
end
if minetest.registered_nodes[node_testing.name].liquidtype
~= "flowing" then
if registered_nodes[node_testing.name].liquidtype ~= "flowing" then
return 0
else
return direction
end
elseif minetest.registered_nodes[name].liquidtype == "flowing" then
local node_testing = minetest.get_node(pos_testing)
elseif registered_nodes[name].liquidtype == "flowing" then
local node_testing = get_node(pos_testing)
local param2_testing = node_testing.param2
if not minetest.registered_nodes[node_testing.name] then
if not registered_nodes[node_testing.name] then
return 0
end
if minetest.registered_nodes[node_testing.name].liquidtype
== "source" then
if registered_nodes[node_testing.name].liquidtype == "source" then
return -direction
elseif minetest.registered_nodes[node_testing.name].liquidtype
== "flowing" then
elseif registered_nodes[node_testing.name].liquidtype == "flowing" then
if param2_testing < node.param2 then
if (node.param2 - param2_testing) > 6 then
return -direction
@ -108,48 +113,41 @@ local function quick_flow_logic(node,pos_testing,direction)
return 0
end
local quick_flow = function(pos,node)
local x = 0
local z = 0
local function quick_flow(pos, node)
if not node_is_liquid(node) then
return {x=0,y=0,z=0}
return {x = 0, y = 0, z = 0}
end
x = x + quick_flow_logic(node,{x=pos.x-1,y=pos.y,z=pos.z},-1)
x = x + quick_flow_logic(node,{x=pos.x+1,y=pos.y,z=pos.z}, 1)
z = z + quick_flow_logic(node,{x=pos.x,y=pos.y,z=pos.z-1},-1)
z = z + quick_flow_logic(node,{x=pos.x,y=pos.y,z=pos.z+1}, 1)
return to_unit_vector({x=x,y=0,z=z})
local x = quick_flow_logic(node,{x = pos.x-1, y = pos.y, z = pos.z},-1) + quick_flow_logic(node,{x = pos.x+1, y = pos.y, z = pos.z}, 1)
local z = quick_flow_logic(node,{x = pos.x, y = pos.y, z = pos.z-1},-1) + quick_flow_logic(node,{x = pos.x, y = pos.y, z = pos.z+1}, 1)
return to_unit_vector({x = x, y = 0, z = z})
end
flowlib.quick_flow = quick_flow
--if not in water but touching, move centre to touching block
--x has higher precedence than z
--if pos changes with x, it affects z
--if not in water but touching, move centre to touching block
--x has higher precedence than z
--if pos changes with x, it affects z
local move_centre = function(pos,realpos,node,radius)
if is_touching(realpos.x,pos.x,radius) then
if is_liquid({x=pos.x-1,y=pos.y,z=pos.z}) then
node = minetest.get_node({x=pos.x-1,y=pos.y,z=pos.z})
pos = {x=pos.x-1,y=pos.y,z=pos.z}
elseif is_liquid({x=pos.x+1,y=pos.y,z=pos.z}) then
node = minetest.get_node({x=pos.x+1,y=pos.y,z=pos.z})
pos = {x=pos.x+1,y=pos.y,z=pos.z}
local function move_centre(pos, realpos, node, radius)
if is_touching(realpos.x, pos.x, radius) then
if is_liquid({x = pos.x-1, y = pos.y, z = pos.z}) then
node = get_node({x=pos.x-1, y = pos.y, z = pos.z})
pos = {x = pos.x-1, y = pos.y, z = pos.z}
elseif is_liquid({x = pos.x+1, y = pos.y, z = pos.z}) then
node = get_node({x = pos.x+1, y = pos.y, z = pos.z})
pos = {x = pos.x+1, y = pos.y, z = pos.z}
end
end
if is_touching(realpos.z,pos.z,radius) then
if is_liquid({x=pos.x,y=pos.y,z=pos.z-1}) then
node = minetest.get_node({x=pos.x,y=pos.y,z=pos.z-1})
pos = {x=pos.x,y=pos.y,z=pos.z-1}
elseif is_liquid({x=pos.x,y=pos.y,z=pos.z+1}) then
node = minetest.get_node({x=pos.x,y=pos.y,z=pos.z+1})
pos = {x=pos.x,y=pos.y,z=pos.z+1}
if is_touching(realpos.z, pos.z, radius) then
if is_liquid({x = pos.x, y = pos.y, z = pos.z - 1}) then
node = get_node({x = pos.x, y = pos.y, z = pos.z - 1})
pos = {x = pos.x, y = pos.y, z = pos.z - 1}
elseif is_liquid({x = pos.x, y = pos.y, z = pos.z + 1}) then
node = get_node({x = pos.x, y = pos.y, z = pos.z + 1})
pos = {x = pos.x, y = pos.y, z = pos.z + 1}
end
end
return pos,node
return pos, node
end
flowlib.move_centre = move_centre

21
mods/CORE/mcl_attached/init.lua
View File

@ -1,17 +1,21 @@
local vector = vector
local facedir_to_dir = minetest.facedir_to_dir
local get_item_group = minetest.get_item_group
local remove_node = minetest.remove_node
local get_node = minetest.get_node
local original_function = minetest.check_single_for_falling
minetest.check_single_for_falling = function(pos)
function minetest.check_single_for_falling(pos)
local ret_o = original_function(pos)
local ret = false
local node = minetest.get_node(pos)
if minetest.get_item_group(node.name, "attached_node_facedir") ~= 0 then
local dir = minetest.facedir_to_dir(node.param2)
if get_item_group(node.name, "attached_node_facedir") ~= 0 then
local dir = facedir_to_dir(node.param2)
if dir then
local cpos = vector.add(pos, dir)
local cnode = minetest.get_node(cpos)
if minetest.get_item_group(cnode.name, "solid") == 0 then
minetest.remove_node(pos)
if get_item_group(get_node(vector.add(pos, dir)).name, "solid") == 0 then
remove_node(pos)
local drops = minetest.get_node_drops(node.name, "")
for dr=1, #drops do
minetest.add_item(pos, drops[dr])
@ -20,7 +24,6 @@ minetest.check_single_for_falling = function(pos)
end
end
end
return ret_o or ret
end

113
mods/CORE/mcl_explosions/init.lua
View File

@ -12,10 +12,12 @@ under the LGPLv2.1 license.
mcl_explosions = {}
local mod_fire = minetest.get_modpath("mcl_fire") ~= nil
local CONTENT_FIRE = minetest.get_content_id("mcl_fire:fire")
local mod_fire = minetest.get_modpath("mcl_fire")
--local CONTENT_FIRE = minetest.get_content_id("mcl_fire:fire")
local S = minetest.get_translator("mcl_explosions")
local math = math
local vector = vector
local table = table
local hash_node_position = minetest.hash_node_position
local get_objects_inside_radius = minetest.get_objects_inside_radius
@ -26,6 +28,7 @@ local get_voxel_manip = minetest.get_voxel_manip
local bulk_set_node = minetest.bulk_set_node
local check_for_falling = minetest.check_for_falling
local add_item = minetest.add_item
local pos_to_string = minetest.pos_to_string
-- Saved sphere explosion shapes for various radiuses
local sphere_shapes = {}
@ -66,46 +69,44 @@ local function compute_sphere_rays(radius)
local rays = {}
local sphere = {}
for i=1, 2 do
local function add_ray(pos)
sphere[hash_node_position(pos)] = pos
end
for y = -radius, radius do
for z = -radius, radius do
for x = -radius, 0 do
local d = x * x + y * y + z * z
if d <= radius * radius then
add_ray(vector.new(x, y, z))
add_ray(vector.new(-x, y, z))
break
end
end
end
end
for x = -radius, radius do
for z = -radius, radius do
for y = -radius, 0 do
local d = x * x + y * y + z * z
if d <= radius * radius then
add_ray(vector.new(x, y, z))
add_ray(vector.new(x, -y, z))
break
end
end
end
end
for x = -radius, radius do
for y = -radius, radius do
for z = -radius, radius do
for x = -radius, 0, 1 do
local d = x * x + y * y + z * z
if d <= radius * radius then
local pos = { x = x, y = y, z = z }
sphere[hash_node_position(pos)] = pos
break
end
end
end
end
end
for i=1,2 do
for x = -radius, radius do
for z = -radius, radius do
for y = -radius, 0, 1 do
local d = x * x + y * y + z * z
if d <= radius * radius then
local pos = { x = x, y = y, z = z }
sphere[hash_node_position(pos)] = pos
break
end
end
end
end
end
for i=1,2 do
for x = -radius, radius do
for y = -radius, radius do
for z = -radius, 0, 1 do
local d = x * x + y * y + z * z
if d <= radius * radius then
local pos = { x = x, y = y, z = z }
sphere[hash_node_position(pos)] = pos
break
end
for z = -radius, 0 do
local d = x * x + y * y + z * z
if d <= radius * radius then
add_ray(vector.new(x, y, z))
add_ray(vector.new(x, y, -z))
break
end
end
end
@ -176,14 +177,11 @@ local function trace_explode(pos, strength, raydirs, radius, info, direct, sourc
local ystride = (emax.x - emin_x + 1)
local zstride = ystride * (emax.y - emin_y + 1)
local pos_x = pos.x
local pos_y = pos.y
local pos_z = pos.z
local area = VoxelArea:new {
--[[local area = VoxelArea:new {
MinEdge = emin,
MaxEdge = emax
}
}]]
local data = vm:get_data()
local destroy = {}
@ -247,7 +245,7 @@ local function trace_explode(pos, strength, raydirs, radius, info, direct, sourc
local ent = obj:get_luaentity()
-- Ignore items to lower lag
if (obj:is_player() or (ent and ent.name ~= '__builtin.item')) and obj:get_hp() > 0 then
if (obj:is_player() or (ent and ent.name ~= "__builtin.item")) and obj:get_hp() > 0 then
local opos = obj:get_pos()
local collisionbox = nil
@ -260,12 +258,12 @@ local function trace_explode(pos, strength, raydirs, radius, info, direct, sourc
if collisionbox then
-- Create rays from random points in the collision box
local x1 = collisionbox[1] * 2
local y1 = collisionbox[2] * 2
local z1 = collisionbox[3] * 2
local x2 = collisionbox[4] * 2
local y2 = collisionbox[5] * 2
local z2 = collisionbox[6] * 2
local x1 = collisionbox[1]
local y1 = collisionbox[2]
local z1 = collisionbox[3]
local x2 = collisionbox[4]
local y2 = collisionbox[5]
local z2 = collisionbox[6]
local x_len = math.abs(x2 - x1)
local y_len = math.abs(y2 - y1)
local z_len = math.abs(z2 - z1)
@ -363,9 +361,9 @@ local function trace_explode(pos, strength, raydirs, radius, info, direct, sourc
local on_blast = node_on_blast[data[idx]]
local remove = true
if do_drop or on_blast ~= nil then
if do_drop or on_blast then
local npos = get_position_from_hash(hash)
if on_blast ~= nil then
if on_blast then
on_blast(npos, 1.0, do_drop)
remove = false
else
@ -407,8 +405,7 @@ local function trace_explode(pos, strength, raydirs, radius, info, direct, sourc
end
-- Log explosion
minetest.log('action', 'Explosion at ' .. minetest.pos_to_string(pos) ..
' with strength ' .. strength .. ' and radius ' .. radius)
minetest.log("action", "Explosion at "..pos_to_string(pos).." with strength "..strength.." and radius "..radius)
end
-- Create an explosion with strength at pos.

2
mods/CORE/mcl_explosions/locale/mcl_explosions.de.tr
View File

@ -1,2 +0,0 @@
# textdomain:mcl_explosions
@1 was caught in an explosion.=@1 wurde Opfer einer Explosion.

2
mods/CORE/mcl_explosions/locale/mcl_explosions.fr.tr
View File

@ -1,2 +0,0 @@
# textdomain:mcl_explosions
@1 was caught in an explosion.=@1 a été pris dans une explosion.

2
mods/CORE/mcl_explosions/locale/mcl_explosions.pl.tr Normal file
View File

@ -0,0 +1,2 @@
# textdomain:mcl_explosions
@1 was caught in an explosion.=@1 została wysadzona.

2
mods/CORE/mcl_explosions/locale/mcl_explosions.ru.tr
View File

@ -1,2 +0,0 @@
# textdomain:mcl_explosions
@1 was caught in an explosion.=@1 не удалось пережить взрыва.

2
mods/CORE/mcl_explosions/locale/template.txt
View File

@ -1,2 +0,0 @@
# textdomain:mcl_explosions
@1 was caught in an explosion.=

4
mods/CORE/mcl_init/init.lua
View File

@ -32,9 +32,9 @@ local singlenode = mg_name == "singlenode"
-- Calculate mapgen_edge_min/mapgen_edge_max
mcl_vars.chunksize = math.max(1, tonumber(minetest.get_mapgen_setting("chunksize")) or 5)
mcl_vars.MAP_BLOCKSIZE = math.max(1, core.MAP_BLOCKSIZE or 16)
mcl_vars.MAP_BLOCKSIZE = math.max(1, minetest.MAP_BLOCKSIZE or 16)
mcl_vars.mapgen_limit = math.max(1, tonumber(minetest.get_mapgen_setting("mapgen_limit")) or 31000)
mcl_vars.MAX_MAP_GENERATION_LIMIT = math.max(1, core.MAX_MAP_GENERATION_LIMIT or 31000)
mcl_vars.MAX_MAP_GENERATION_LIMIT = math.max(1, minetest.MAX_MAP_GENERATION_LIMIT or 31000)
local central_chunk_offset = -math.floor(mcl_vars.chunksize / 2)
mcl_vars.central_chunk_offset_in_nodes = central_chunk_offset * mcl_vars.MAP_BLOCKSIZE
mcl_vars.chunk_size_in_nodes = mcl_vars.chunksize * mcl_vars.MAP_BLOCKSIZE

7
mods/CORE/mcl_loot/init.lua
View File

@ -40,10 +40,9 @@ function mcl_loot.get_loot(loot_definitions, pr)
total_weight = total_weight + (loot_definitions.items[i].weight or 1)
end
local stacks_min = loot_definitions.stacks_min
local stacks_max = loot_definitions.stacks_max
if not stacks_min then stacks_min = 1 end
if not stacks_max then stacks_max = 1 end
--local stacks_min = loot_definitions.stacks_min or 1
--local stacks_max = loot_definitions.stacks_max or 1
local stacks = pr:next(loot_definitions.stacks_min, loot_definitions.stacks_max)
for s=1, stacks do
local r = pr:next(1, total_weight)

30
mods/CORE/mcl_particles/init.lua
View File

@ -1,3 +1,12 @@
local vector = vector
local table = table
local hash_node_position = minetest.hash_node_position
local add_particlespawner = minetest.add_particlespawner
local delete_particlespawner = minetest.delete_particlespawner
local ipairs = ipairs
mcl_particles = {}
-- Table of particlespawner IDs on a per-node hash basis
@ -32,11 +41,11 @@ function mcl_particles.add_node_particlespawner(pos, particlespawner_definition,
if allowed_level == 0 or levels[level] > allowed_level then
return
end
local poshash = minetest.hash_node_position(pos)
local poshash = hash_node_position(pos)
if not poshash then
return
end
local id = minetest.add_particlespawner(particlespawner_definition)
local id = add_particlespawner(particlespawner_definition)
if id == -1 then
return
end
@ -47,6 +56,8 @@ function mcl_particles.add_node_particlespawner(pos, particlespawner_definition,
return id
end
local add_node_particlespawner = mcl_particles.add_node_particlespawner
-- Deletes all particlespawners that are assigned to a node position.
-- If no particlespawners exist for this position, nothing happens.
-- pos: Node positon. MUST use integer values!
@ -55,11 +66,11 @@ function mcl_particles.delete_node_particlespawners(pos)
if allowed_level == 0 then
return false
end
local poshash = minetest.hash_node_position(pos)
local poshash = hash_node_position(pos)
local ids = particle_nodes[poshash]
if ids then
for i=1, #ids do
minetest.delete_particlespawner(ids[i])
delete_particlespawner(ids[i])
end
particle_nodes[poshash] = nil
return true
@ -72,7 +83,6 @@ end
local smoke_pdef_cached = {}
function mcl_particles.spawn_smoke(pos, name, smoke_pdef_base)
local min = math.min
local new_minpos = vector.add(pos, smoke_pdef_base.minrelpos)
local new_maxpos = vector.add(pos, smoke_pdef_base.maxrelpos)
@ -81,7 +91,7 @@ function mcl_particles.spawn_smoke(pos, name, smoke_pdef_base)
for i, smoke_pdef in ipairs(smoke_pdef_cached[name]) do
smoke_pdef.minpos = new_minpos
smoke_pdef.maxpos = new_maxpos
mcl_particles.add_node_particlespawner(pos, smoke_pdef, "high")
add_node_particlespawner(pos, smoke_pdef, "high")
end
-- cache already populated
else
@ -111,13 +121,11 @@ function mcl_particles.spawn_smoke(pos, name, smoke_pdef_base)
smoke_pdef.animation.length = exptime + 0.1
-- minexptime must be set such that the last frame is actully rendered,
-- even if its very short. Larger exptime -> larger range
smoke_pdef.minexptime = min(exptime, (7.0/8.0 * (exptime + 0.1) + 0.1))
smoke_pdef.minexptime = math.min(exptime, (7.0/8.0 * (exptime + 0.1) + 0.1))
smoke_pdef.texture = "mcl_particles_smoke_anim.png^[colorize:#000000:" ..colorize
mcl_particles.add_node_particlespawner(pos, smoke_pdef, "high")
add_node_particlespawner(pos, smoke_pdef, "high")
table.insert(smoke_pdef_cached[name], table.copy(smoke_pdef))
end
end
end
end
end

BIN
mods/CORE/mcl_particles/textures/mcl_particles_bonemeal.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.3 KiB

13
mods/CORE/mcl_util/init.lua
View File

@ -150,7 +150,7 @@ function mcl_util.get_eligible_transfer_item_slot(src_inventory, src_list, dst_i
end
-- Returns true if itemstack is a shulker box
local is_not_shulker_box = function(itemstack)
local function is_not_shulker_box(itemstack)
local g = minetest.get_item_group(itemstack:get_name(), "shulker_box")
return g == 0 or g == nil
end
@ -212,7 +212,7 @@ function mcl_util.move_item_container(source_pos, destination_pos, source_list,
end
-- Normalize double container by forcing to always use the left segment first
local normalize_double_container = function(pos, node, ctype)
local function normalize_double_container(pos, node, ctype)
if ctype == 6 then
pos = mcl_util.get_double_container_neighbor_pos(pos, node.param2, "right")
if not pos then
@ -456,14 +456,7 @@ function mcl_util.calculate_durability(itemstack)
end
end
end
if not uses then
local toolcaps = itemstack:get_tool_capabilities()
local groupcaps = toolcaps.groupcaps
for _, v in pairs(groupcaps) do
uses = v.uses
break
end
end
uses = uses or (next(itemstack:get_tool_capabilities().groupcaps) or {}).uses
end
return uses or 0

9
mods/CORE/mcl_worlds/API.md
View File

@ -61,20 +61,21 @@ In mc, you cant use clock in the nether and the end.
* pos: position
## mcl_worlds.register_on_dimension_change(function(player, dimension))
## mcl_worlds.register_on_dimension_change(function(player, dimension, last_dimension))
Register a callback function func(player, dimension).
It will be called whenever a player changes between dimensions.
The void counts as dimension.
* player: player, the player who changed the dimension
* dimension: position, The new dimension of the player ("overworld", "nether", "end", "void").
* player: player, the player who changed of dimension
* dimension: string, The new dimension of the player ("overworld", "nether", "end", "void").
* last_dimension: string, The dimension where the player was ("overworld", "nether", "end", "void").
## mcl_worlds.registered_on_dimension_change
Table containing all function registered with mcl_worlds.register_on_dimension_change()
## mcl_worlds.dimension_change(player, dimension)
Notify this mod of a dimmension change of <player> to <dimension>
Notify this mod of a dimension change of <player> to <dimension>
* player: player, player who changed the dimension
* dimension: string, new dimension ("overworld", "nether", "end", "void")

83
mods/CORE/mcl_worlds/init.lua
View File

@ -1,5 +1,7 @@
mcl_worlds = {}
local get_connected_players = minetest.get_connected_players
-- For a given position, returns a 2-tuple:
-- 1st return value: true if pos is in void
-- 2nd return value: true if it is in the deadly part of the void
@ -33,60 +35,64 @@ end
-- If the Y coordinate is not located in any dimension, it will return:
-- nil, "void"
function mcl_worlds.y_to_layer(y)
if y >= mcl_vars.mg_overworld_min then
return y - mcl_vars.mg_overworld_min, "overworld"
elseif y >= mcl_vars.mg_nether_min and y <= mcl_vars.mg_nether_max+128 then
return y - mcl_vars.mg_nether_min, "nether"
elseif y >= mcl_vars.mg_end_min and y <= mcl_vars.mg_end_max then
return y - mcl_vars.mg_end_min, "end"
else
return nil, "void"
end
if y >= mcl_vars.mg_overworld_min then
return y - mcl_vars.mg_overworld_min, "overworld"
elseif y >= mcl_vars.mg_nether_min and y <= mcl_vars.mg_nether_max+128 then
return y - mcl_vars.mg_nether_min, "nether"
elseif y >= mcl_vars.mg_end_min and y <= mcl_vars.mg_end_max then
return y - mcl_vars.mg_end_min, "end"
else
return nil, "void"
end
end
local y_to_layer = mcl_worlds.y_to_layer
-- Takes a pos and returns the dimension it belongs to (same as above)
function mcl_worlds.pos_to_dimension(pos)
local _, dim = mcl_worlds.y_to_layer(pos.y)
local _, dim = y_to_layer(pos.y)
return dim
end
local pos_to_dimension = mcl_worlds.pos_to_dimension
-- Takes a Minecraft layer and a “dimension” name
-- and returns the corresponding Y coordinate for
-- MineClone 2.
-- mc_dimension is one of "overworld", "nether", "end" (default: "overworld").
function mcl_worlds.layer_to_y(layer, mc_dimension)
if mc_dimension == "overworld" or mc_dimension == nil then
return layer + mcl_vars.mg_overworld_min
elseif mc_dimension == "nether" then
return layer + mcl_vars.mg_nether_min
elseif mc_dimension == "end" then
return layer + mcl_vars.mg_end_min
end
if mc_dimension == "overworld" or mc_dimension == nil then
return layer + mcl_vars.mg_overworld_min
elseif mc_dimension == "nether" then
return layer + mcl_vars.mg_nether_min
elseif mc_dimension == "end" then
return layer + mcl_vars.mg_end_min
end
end
-- Takes a position and returns true if this position can have weather
function mcl_worlds.has_weather(pos)
-- Weather in the Overworld and the high part of the void below
return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64
-- Weather in the Overworld and the high part of the void below
return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64
end
-- Takes a position and returns true if this position can have Nether dust
function mcl_worlds.has_dust(pos)
-- Weather in the Overworld and the high part of the void below
return pos.y <= mcl_vars.mg_nether_max + 138 and pos.y >= mcl_vars.mg_nether_min - 10
-- Weather in the Overworld and the high part of the void below
return pos.y <= mcl_vars.mg_nether_max + 138 and pos.y >= mcl_vars.mg_nether_min - 10
end
-- Takes a position (pos) and returns true if compasses are working here
function mcl_worlds.compass_works(pos)
-- It doesn't work in Nether and the End, but it works in the Overworld and in the high part of the void below
local _, dim = mcl_worlds.y_to_layer(pos.y)
if dim == "nether" or dim == "end" then
return false
elseif dim == "void" then
return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64
else
return true
end
-- It doesn't work in Nether and the End, but it works in the Overworld and in the high part of the void below
local _, dim = mcl_worlds.y_to_layer(pos.y)
if dim == "nether" or dim == "end" then
return false
elseif dim == "void" then
return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64
else
return true
end
end
-- Takes a position (pos) and returns true if clocks are working here
@ -112,12 +118,15 @@ local last_dimension = {}
-- * player: Player who changed the dimension
-- * dimension: New dimension ("overworld", "nether", "end", "void")
function mcl_worlds.dimension_change(player, dimension)
local playername = player:get_player_name()
for i=1, #mcl_worlds.registered_on_dimension_change do
mcl_worlds.registered_on_dimension_change[i](player, dimension)
last_dimension[player:get_player_name()] = dimension
mcl_worlds.registered_on_dimension_change[i](player, dimension, last_dimension[playername])
end
last_dimension[playername] = dimension
end
local dimension_change = mcl_worlds.dimension_change
----------------------- INTERNAL STUFF ----------------------
-- Update the dimension callbacks every DIM_UPDATE seconds
@ -125,19 +134,19 @@ local DIM_UPDATE = 1
local dimtimer = 0
minetest.register_on_joinplayer(function(player)
last_dimension[player:get_player_name()] = mcl_worlds.pos_to_dimension(player:get_pos())
last_dimension[player:get_player_name()] = pos_to_dimension(player:get_pos())
end)
minetest.register_globalstep(function(dtime)
-- regular updates based on iterval
dimtimer = dimtimer + dtime;
if dimtimer >= DIM_UPDATE then
local players = minetest.get_connected_players()
for p=1, #players do
local dim = mcl_worlds.pos_to_dimension(players[p]:get_pos())
local players = get_connected_players()
for p = 1, #players do
local dim = pos_to_dimension(players[p]:get_pos())
local name = players[p]:get_player_name()
if dim ~= last_dimension[name] then
mcl_worlds.dimension_change(players[p], dim)
dimension_change(players[p], dim)
end
end
dimtimer = 0

32
mods/CORE/walkover/init.lua
View File

@ -4,6 +4,7 @@ local get_connected_players = minetest.get_connected_players
local get_node = minetest.get_node
local vector_add = vector.add
local ceil = math.ceil
local pairs = pairs
walkover = {}
walkover.registered_globals = {}
@ -31,24 +32,21 @@ minetest.register_globalstep(function(dtime)
timer = timer + dtime;
if timer >= 0.3 then
for _,player in pairs(get_connected_players()) do
local pp = player:get_pos()
pp.y = ceil(pp.y)
local loc = vector_add(pp, {x=0,y=-1,z=0})
if loc ~= nil then
local nodeiamon = get_node(loc)
if nodeiamon ~= nil then
if on_walk[nodeiamon.name] then
on_walk[nodeiamon.name](loc, nodeiamon, player)
end
for i = 1, #registered_globals do
local pp = player:get_pos()
pp.y = ceil(pp.y)
local loc = vector_add(pp, {x=0,y=-1,z=0})
if loc then
local nodeiamon = get_node(loc)
if nodeiamon then
if on_walk[nodeiamon.name] then
on_walk[nodeiamon.name](loc, nodeiamon, player)
end
for i = 1, #registered_globals do
registered_globals[i](loc, nodeiamon, player)
end
end
end
end
end
end
end
end
timer = 0
end
end)

85
mods/ENTITIES/drippingwater/init.lua
View File

@ -1,6 +1,8 @@
--Dripping Water Mod
--by kddekadenz
local math = math
-- License of code, textures & sounds: CC0
--Drop entities
@ -20,26 +22,21 @@ minetest.register_entity("drippingwater:drop_water", {
spritediv = {x=1, y=1},
initial_sprite_basepos = {x=0, y=0},
static_save = false,
on_activate = function(self, staticdata)
self.object:set_sprite({x=0,y=0}, 1, 1, true)
end,
on_step = function(self, dtime)
local k = math.random(1,222)
local ownpos = self.object:get_pos()
if k==1 then
self.object:set_acceleration({x=0, y=-5, z=0})
end
if minetest.get_node({x=ownpos.x, y=ownpos.y +0.5, z=ownpos.z}).name == "air" then
self.object:set_acceleration({x=0, y=-5, z=0})
end
local k = math.random(1,222)
local ownpos = self.object:get_pos()
if k==1 then
self.object:set_acceleration({x=0, y=-5, z=0})
end
if minetest.get_node({x=ownpos.x, y=ownpos.y +0.5, z=ownpos.z}).name == "air" then
self.object:set_acceleration({x=0, y=-5, z=0})
end
if minetest.get_node({x=ownpos.x, y=ownpos.y -0.5, z=ownpos.z}).name ~= "air" then
self.object:remove()
minetest.sound_play({name="drippingwater_drip"}, {pos = ownpos, gain = 0.5, max_hear_distance = 8}, true)
self.object:remove()
minetest.sound_play({name="drippingwater_drip"}, {pos = ownpos, gain = 0.5, max_hear_distance = 8}, true)
end
end,
})
@ -61,27 +58,21 @@ minetest.register_entity("drippingwater:drop_lava", {
spritediv = {x=1, y=1},
initial_sprite_basepos = {x=0, y=0},
static_save = false,
on_activate = function(self, staticdata)
self.object:set_sprite({x=0,y=0}, 1, 0, true)
end,
on_step = function(self, dtime)
local k = math.random(1,222)
local ownpos = self.object:get_pos()
if k==1 then
self.object:set_acceleration({x=0, y=-5, z=0})
end
if minetest.get_node({x=ownpos.x, y=ownpos.y +0.5, z=ownpos.z}).name == "air" then
self.object:set_acceleration({x=0, y=-5, z=0})
end
local k = math.random(1,222)
local ownpos = self.object:get_pos()
if k == 1 then
self.object:set_acceleration({x=0, y=-5, z=0})
end
if minetest.get_node({x=ownpos.x, y=ownpos.y +0.5, z=ownpos.z}).name == "air" then
self.object:set_acceleration({x=0, y=-5, z=0})
end
if minetest.get_node({x=ownpos.x, y=ownpos.y -0.5, z=ownpos.z}).name ~= "air" then
self.object:remove()
minetest.sound_play({name="drippingwater_lavadrip"}, {pos = ownpos, gain = 0.5, max_hear_distance = 8}, true)
self.object:remove()
minetest.sound_play({name="drippingwater_lavadrip"}, {pos = ownpos, gain = 0.5, max_hear_distance = 8}, true)
end
end,
})
@ -90,36 +81,34 @@ minetest.register_entity("drippingwater:drop_lava", {
--Create drop
minetest.register_abm(
{
minetest.register_abm({
label = "Create water drops",
nodenames = {"group:opaque", "group:leaves"},
neighbors = {"group:water"},
interval = 2,
chance = 22,
action = function(pos)
if minetest.get_item_group(minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name, "water") ~= 0 and
minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "air" then
interval = 2,
chance = 22,
action = function(pos)
if minetest.get_item_group(minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name, "water") ~= 0
and minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "air" then
local i = math.random(-45,45) / 100
minetest.add_entity({x=pos.x + i, y=pos.y - 0.501, z=pos.z + i}, "drippingwater:drop_water")
end
end,
end,
})
--Create lava drop
minetest.register_abm(
{
minetest.register_abm({
label = "Create lava drops",
nodenames = {"group:opaque"},
neighbors = {"group:lava"},
interval = 2,
chance = 22,
action = function(pos)
if minetest.get_item_group(minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name, "lava") ~= 0 and
minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "air" then
interval = 2,
chance = 22,
action = function(pos)
if minetest.get_item_group(minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name, "lava") ~= 0
and minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "air" then
local i = math.random(-45,45) / 100
minetest.add_entity({x=pos.x + i, y=pos.y - 0.501, z=pos.z + i}, "drippingwater:drop_lava")
end
end,
})
end,
})

8
mods/ENTITIES/mcl_boats/init.lua
View File

@ -1,4 +1,4 @@
local S = minetest.get_translator("mcl_boats")
local S = minetest.get_translator(minetest.get_current_modname())
local boat_visual_size = {x = 1, y = 1, z = 1}
local paddling_speed = 22
@ -328,10 +328,10 @@ function boat.on_step(self, dtime, moveresult)
p.y = p.y - boat_y_offset
local new_velo
local new_acce = {x = 0, y = 0, z = 0}
local new_acce
if not is_water(p) and not on_ice then
-- Not on water or inside water: Free fall
local nodedef = minetest.registered_nodes[minetest.get_node(p).name]
--local nodedef = minetest.registered_nodes[minetest.get_node(p).name]
new_acce = {x = 0, y = -9.8, z = 0}
new_velo = get_velocity(self._v, self.object:get_yaw(),
self.object:get_velocity().y)
@ -470,6 +470,6 @@ minetest.register_craft({
burntime = 20,
})
if minetest.get_modpath("doc_identifier") ~= nil then
if minetest.get_modpath("doc_identifier") then
doc.sub.identifier.register_object("mcl_boats:boat", "craftitems", "mcl_boats:boat")
end

12
mods/ENTITIES/mcl_boats/locale/mcl_boats.pl.tr Normal file
View File

@ -0,0 +1,12 @@
# textdomain: mcl_boats
Acacia Boat=Akacjowa łódź
Birch Boat=Brzozowa łódź
Boat=Łódź
Boats are used to travel on the surface of water.=Łodzie są wykorzystywane do podróżowania po powierzchni wody.
Dark Oak Boat=Ciemno-dębowa łódź
Jungle Boat=Tropikalna łódź
Oak Boat=Dębowa łódź
Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Use [Sneak] to leave the boat, punch the boat to make it drop as an item.=Kliknij prawym przyciskiem myszy na źródło wody by postawić łódź. Kliknij prawym przyciskiem myszy by w nią wsiąść. Użyj przycisków [Lewy] oraz [Prawy] by sterować, [Naprzód] by przyspieszyć i [W tył] by zwolnić lub się cofać. Kliknij [Skradanie] by z niej wyjść, uderz ją by wziąć ją jako przedmiot.
Spruce Boat=Świerkowa łódź
Water vehicle=Pojazd wodny
Sneak to dismount=Skradaj się by opuścić łódź

4
mods/ENTITIES/mcl_burning/api.lua
View File

@ -1,5 +1,3 @@
local S = minetest.get_translator("mcl_burning")
function mcl_burning.get_storage(obj)
return obj:is_player() and mcl_burning.storage[obj] or obj:get_luaentity()
end
@ -145,4 +143,4 @@ function mcl_burning.tick(obj, dtime, storage)
end
end
end
end
end

18
mods/ENTITIES/mcl_burning/init.lua
View File

@ -1,5 +1,9 @@
local S = minetest.get_translator("mcl_burning")
local modpath = minetest.get_modpath("mcl_burning")
local modpath = minetest.get_modpath(minetest.get_current_modname())
local pairs = pairs
local get_connected_players = minetest.get_connected_players
local get_item_group = minetest.get_item_group
mcl_burning = {
storage = {},
@ -9,7 +13,7 @@ mcl_burning = {
dofile(modpath .. "/api.lua")
minetest.register_globalstep(function(dtime)
for _, player in pairs(minetest.get_connected_players()) do
for _, player in pairs(get_connected_players()) do
local storage = mcl_burning.storage[player]
if not mcl_burning.tick(player, dtime, storage) and not mcl_burning.is_affected_by_rain(player) then
local nodes = mcl_burning.get_touching_nodes(player, {"group:puts_out_fire", "group:set_on_fire"}, storage)
@ -17,12 +21,12 @@ minetest.register_globalstep(function(dtime)
for _, pos in pairs(nodes) do
local node = minetest.get_node(pos)
if minetest.get_item_group(node.name, "puts_out_fire") > 0 then
if get_item_group(node.name, "puts_out_fire") > 0 then
burn_time = 0
break
end
local value = minetest.get_item_group(node.name, "set_on_fire")
local value = get_item_group(node.name, "set_on_fire")
if value > burn_time then
burn_time = value
end
@ -56,7 +60,6 @@ minetest.register_on_leaveplayer(function(player)
local storage = mcl_burning.storage[player]
storage.fire_hud_id = nil
player:get_meta():set_string("mcl_burning:data", minetest.serialize(storage))
mcl_burning.storage[player] = nil
end)
@ -68,11 +71,10 @@ minetest.register_entity("mcl_burning:fire", {
visual = "cube",
pointable = false,
glow = -1,
backface_culling = false,
},
animation_frame = 0,
animation_timer = 0,
on_step = function(self, dtime)
local parent, storage = self:sanity_check()

22
mods/ENTITIES/mcl_falling_nodes/init.lua
View File

@ -1,7 +1,4 @@
local S = minetest.get_translator("mcl_falling_nodes")
local has_mcl_armor = minetest.get_modpath("mcl_armor")
local get_falling_depth = function(self)
local function get_falling_depth(self)
if not self._startpos then
-- Fallback
self._startpos = self.object:get_pos()
@ -9,7 +6,7 @@ local get_falling_depth = function(self)
return self._startpos.y - vector.round(self.object:get_pos()).y
end
local deal_falling_damage = function(self, dtime)
local function deal_falling_damage(self, dtime)
if minetest.get_item_group(self.node.name, "falling_node_damage") == 0 then
return
end
@ -38,7 +35,7 @@ local deal_falling_damage = function(self, dtime)
inv:set_stack("armor", 2, helmet)
end
end
local deathmsg, dmg_type
local dmg_type
if minetest.get_item_group(self.node.name, "anvil") ~= 0 then
dmg_type = "anvil"
else
@ -60,10 +57,8 @@ minetest.register_entity(":__builtin:falling_node", {
collide_with_objects = false,
collisionbox = {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
},
node = {},
meta = {},
set_node = function(self, node, meta)
local def = minetest.registered_nodes[node.name]
-- Change falling node if definition tells us to
@ -90,7 +85,6 @@ minetest.register_entity(":__builtin:falling_node", {
glow = glow,
})
end,
get_staticdata = function(self)
local meta = self.meta
-- Workaround: Save inventory seperately from metadata.
@ -111,7 +105,6 @@ minetest.register_entity(":__builtin:falling_node", {
}
return minetest.serialize(ds)
end,
on_activate = function(self, staticdata)
self.object:set_armor_groups({immortal = 1})
@ -134,7 +127,6 @@ minetest.register_entity(":__builtin:falling_node", {
end
self._startpos = vector.round(self._startpos)
end,
on_step = function(self, dtime)
-- Set gravity
local acceleration = self.object:get_acceleration()
@ -186,10 +178,9 @@ minetest.register_entity(":__builtin:falling_node", {
return
end
local nd = minetest.registered_nodes[n2.name]
if n2.name == "mcl_portals:portal_end" then
-- TODO: Teleport falling node.
elseif (nd and nd.buildable_to == true) or minetest.get_item_group(self.node.name, "crush_after_fall") ~= 0 then
--if n2.name == "mcl_portals:portal_end" then
-- TODO: Teleport falling node.
if (nd and nd.buildable_to == true) or minetest.get_item_group(self.node.name, "crush_after_fall") ~= 0 then
-- Replace destination node if it's buildable to
minetest.remove_node(np)
-- Run script hook
@ -256,7 +247,6 @@ minetest.register_entity(":__builtin:falling_node", {
self.object:set_pos(npos)
end
end
deal_falling_damage(self, dtime)
end
})

3
mods/ENTITIES/mcl_falling_nodes/locale/mcl_falling_nodes.de.tr
View File

@ -1,3 +0,0 @@
# textdomain: mcl_falling_nodes
@1 was smashed by a falling anvil.=@1 wurde von einem fallenden Amboss zerschmettert.
@1 was smashed by a falling block.=@1 wurde von einem fallenden Block zerschmettert.

3
mods/ENTITIES/mcl_falling_nodes/locale/mcl_falling_nodes.es.tr
View File

@ -1,3 +0,0 @@
# textdomain: mcl_falling_nodes
@1 was smashed by a falling anvil.=@1 fue aplastado por la caída de un yunque.
@1 was smashed by a falling block.=@1 fue aplastado por la caída de un bloque.

3
mods/ENTITIES/mcl_falling_nodes/locale/mcl_falling_nodes.fr.tr
View File

@ -1,3 +0,0 @@
# textdomain: mcl_falling_nodes
@1 was smashed by a falling anvil.=@1 a été écrasé par une enclume qui tombait.
@1 was smashed by a falling block.=@1 a été écrasé par un bloc qui tombait.

3
mods/ENTITIES/mcl_falling_nodes/locale/mcl_falling_nodes.pl.tr Normal file
View File

@ -0,0 +1,3 @@
# textdomain: mcl_falling_nodes
@1 was smashed by a falling anvil.=@1 została zmiażdżona przez spadające kowadło.
@1 was smashed by a falling block.=@1 została zmiażdżona przez spadający blok.

3
mods/ENTITIES/mcl_falling_nodes/locale/mcl_falling_nodes.ru.tr
View File

@ -1,3 +0,0 @@
# textdomain: mcl_falling_nodes
@1 was smashed by a falling anvil.=@1 придавило падающей наковальней.
@1 was smashed by a falling block.=@1 раздавило падающим блоком.

3
mods/ENTITIES/mcl_falling_nodes/locale/template.txt
View File

@ -1,3 +0,0 @@
# textdomain: mcl_falling_nodes
@1 was smashed by a falling anvil.=
@1 was smashed by a falling block.=

45
mods/ENTITIES/mcl_item_entity/init.lua
View File

@ -1,5 +1,5 @@
--these are lua locals, used for higher performance
local minetest,math,vector,ipairs = minetest,math,vector,ipairs
local minetest, math, vector, ipairs, pairs = minetest, math, vector, ipairs, pairs
--this is used for the player pool in the sound buffer
local pool = {}
@ -38,7 +38,7 @@ item_drop_settings.drop_single_item = false --if true, the drop control dro
item_drop_settings.magnet_time = 0.75 -- how many seconds an item follows the player before giving up
local get_gravity = function()
local function get_gravity()
return tonumber(minetest.settings:get("movement_gravity")) or 9.81
end
@ -60,7 +60,7 @@ mcl_item_entity.register_pickup_achievement("mcl_mobitems:blaze_rod", "mcl:blaze
mcl_item_entity.register_pickup_achievement("mcl_mobitems:leather", "mcl:killCow")
mcl_item_entity.register_pickup_achievement("mcl_core:diamond", "mcl:diamonds")
local check_pickup_achievements = function(object, player)
local function check_pickup_achievements(object, player)
if has_awards then
local itemname = ItemStack(object:get_luaentity().itemstring):get_name()
local playername = player:get_player_name()
@ -72,7 +72,7 @@ local check_pickup_achievements = function(object, player)
end
end
local enable_physics = function(object, luaentity, ignore_check)
local function enable_physics(object, luaentity, ignore_check)
if luaentity.physical_state == false or ignore_check == true then
luaentity.physical_state = true
object:set_properties({
@ -83,7 +83,7 @@ local enable_physics = function(object, luaentity, ignore_check)
end
end
local disable_physics = function(object, luaentity, ignore_check, reset_movement)
local function disable_physics(object, luaentity, ignore_check, reset_movement)
if luaentity.physical_state == true or ignore_check == true then
luaentity.physical_state = false
object:set_properties({
@ -98,13 +98,11 @@ end
minetest.register_globalstep(function(dtime)
tick = not tick
for _,player in pairs(minetest.get_connected_players()) do
if player:get_hp() > 0 or not minetest.settings:get_bool("enable_damage") then
local name = player:get_player_name()
local pos = player:get_pos()
@ -235,7 +233,7 @@ function minetest.handle_node_drops(pos, drops, digger)
local dug_node = minetest.get_node(pos)
local tooldef
local tool
if digger ~= nil then
if digger then
tool = digger:get_wielded_item()
tooldef = minetest.registered_tools[tool:get_name()]
@ -316,7 +314,7 @@ function minetest.handle_node_drops(pos, drops, digger)
end
-- Spawn item and apply random speed
local obj = minetest.add_item(dpos, drop_item)
if obj ~= nil then
if obj then
local x = math.random(1, 5)
if math.random(1,2) == 1 then
x = -x
@ -365,6 +363,17 @@ if not time_to_live then
time_to_live = 300
end
local function cxcz(o, cw, one, zero)
if cw < 0 then
table.insert(o, { [one]=1, y=0, [zero]=0 })
table.insert(o, { [one]=-1, y=0, [zero]=0 })
else
table.insert(o, { [one]=-1, y=0, [zero]=0 })
table.insert(o, { [one]=1, y=0, [zero]=0 })
end
return o
end
minetest.register_entity(":__builtin:item", {
initial_properties = {
hp_max = 1,
@ -385,7 +394,7 @@ minetest.register_entity(":__builtin:item", {
-- The itemstring MUST be set immediately to a non-empty string after creating the entity.
-- The hand is NOT permitted as dropped item. ;-)
-- Item entities will be deleted if they still have an empty itemstring on their first on_step tick.
itemstring = '',
itemstring = "",
-- If true, item will fall
physical_state = true,
@ -426,13 +435,9 @@ minetest.register_entity(":__builtin:item", {
if itemtable then
itemname = stack:to_table().name
end
local item_texture = nil
local item_type = ""
local glow
local def = minetest.registered_items[itemname]
if def then
item_texture = def.inventory_image
item_type = def.type
description = def.description
glow = def.light_source
end
@ -580,7 +585,7 @@ minetest.register_entity(":__builtin:item", {
return
end
self.age = self.age + dtime
if self._collector_timer ~= nil then
if self._collector_timer then
self._collector_timer = self._collector_timer + dtime
end
if time_to_live > 0 and self.age > time_to_live then
@ -648,16 +653,6 @@ minetest.register_entity(":__builtin:item", {
-- 1st: closest
-- 2nd: other direction
-- 3rd and 4th: other axis
local cxcz = function(o, cw, one, zero)
if cw < 0 then
table.insert(o, { [one]=1, y=0, [zero]=0 })
table.insert(o, { [one]=-1, y=0, [zero]=0 })
else
table.insert(o, { [one]=-1, y=0, [zero]=0 })
table.insert(o, { [one]=1, y=0, [zero]=0 })
end
return o
end
if math.abs(cx) < math.abs(cz) then
order = cxcz(order, cx, "x", "z")
order = cxcz(order, cz, "z", "x")

23
mods/ENTITIES/mcl_minecarts/functions.lua
View File

@ -1,3 +1,5 @@
local vector = vector
function mcl_minecarts:get_sign(z)
if z == 0 then
return 0
@ -38,11 +40,9 @@ end
function mcl_minecarts:check_front_up_down(pos, dir_, check_down, railtype)
local dir = vector.new(dir_)
local cur = nil
-- Front
dir.y = 0
cur = vector.add(pos, dir)
local cur = vector.add(pos, dir)
if mcl_minecarts:is_rail(cur, railtype) then
return dir
end
@ -65,9 +65,9 @@ end
function mcl_minecarts:get_rail_direction(pos_, dir, ctrl, old_switch, railtype)
local pos = vector.round(pos_)
local cur = nil
local cur
local left_check, right_check = true, true
-- Check left and right
local left = {x=0, y=0, z=0}
local right = {x=0, y=0, z=0}
@ -78,7 +78,7 @@ function mcl_minecarts:get_rail_direction(pos_, dir, ctrl, old_switch, railtype)
left.z = dir.x
right.z = -dir.x
end
if ctrl then
if old_switch == 1 then
left_check = false
@ -100,13 +100,13 @@ function mcl_minecarts:get_rail_direction(pos_, dir, ctrl, old_switch, railtype)
right_check = true
end
end
-- Normal
cur = mcl_minecarts:check_front_up_down(pos, dir, true, railtype)
if cur then
return cur
end
-- Left, if not already checked
if left_check then
cur = mcl_minecarts:check_front_up_down(pos, left, false, railtype)
@ -114,7 +114,7 @@ function mcl_minecarts:get_rail_direction(pos_, dir, ctrl, old_switch, railtype)
return cur
end
end
-- Right, if not already checked
if right_check then
cur = mcl_minecarts:check_front_up_down(pos, right, false, railtype)
@ -122,7 +122,6 @@ function mcl_minecarts:get_rail_direction(pos_, dir, ctrl, old_switch, railtype)
return cur
end
end
-- Backwards
if not old_switch then
cur = mcl_minecarts:check_front_up_down(pos, {
@ -134,7 +133,5 @@ function mcl_minecarts:get_rail_direction(pos_, dir, ctrl, old_switch, railtype)
return cur
end
end
return {x=0, y=0, z=0}
end
end

61
mods/ENTITIES/mcl_minecarts/init.lua
View File

@ -1,9 +1,10 @@
local S = minetest.get_translator("mcl_minecarts")
local modname = minetest.get_current_modname()
local S = minetest.get_translator(modname)
local has_mcl_wip = minetest.get_modpath("mcl_wip")
mcl_minecarts = {}
mcl_minecarts.modpath = minetest.get_modpath("mcl_minecarts")
mcl_minecarts.modpath = minetest.get_modpath(modname)
mcl_minecarts.speed_max = 10
mcl_minecarts.check_float_time = 15
@ -204,7 +205,7 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
rou_pos = vector.round(pos)
node = minetest.get_node(rou_pos)
local g = minetest.get_item_group(node.name, "connect_to_raillike")
if g ~= self._railtype and self._railtype ~= nil then
if g ~= self._railtype and self._railtype then
-- Detach driver
if player then
if self._old_pos then
@ -486,7 +487,6 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
if update.pos then
self.object:set_pos(pos)
end
update = nil
end
function cart:get_staticdata()
@ -497,7 +497,7 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
end
-- Place a minecart at pointed_thing
mcl_minecarts.place_minecart = function(itemstack, pointed_thing, placer)
function mcl_minecarts.place_minecart(itemstack, pointed_thing, placer)
if not pointed_thing.type == "node" then
return
end
@ -524,7 +524,7 @@ mcl_minecarts.place_minecart = function(itemstack, pointed_thing, placer)
local cart = minetest.add_entity(railpos, entity_id)
local railtype = minetest.get_item_group(node.name, "connect_to_raillike")
local le = cart:get_luaentity()
if le ~= nil then
if le then
le._railtype = railtype
end
local cart_dir = mcl_minecarts:get_rail_direction(railpos, {x=1, y=0, z=0}, nil, nil, railtype)
@ -541,7 +541,7 @@ mcl_minecarts.place_minecart = function(itemstack, pointed_thing, placer)
end
local register_craftitem = function(itemstring, entity_id, description, tt_help, longdesc, usagehelp, icon, creative)
local function register_craftitem(itemstring, entity_id, description, tt_help, longdesc, usagehelp, icon, creative)
entity_mapping[itemstring] = entity_id
local groups = { minecart = 1, transport = 1 }
@ -607,7 +607,7 @@ Register a minecart
local function register_minecart(itemstring, entity_id, description, tt_help, longdesc, usagehelp, mesh, textures, icon, drop, on_rightclick, on_activate_by_rail, creative)
register_entity(entity_id, mesh, textures, drop, on_rightclick, on_activate_by_rail)
register_craftitem(itemstring, entity_id, description, tt_help, longdesc, usagehelp, icon, creative)
if minetest.get_modpath("doc_identifier") ~= nil then
if minetest.get_modpath("doc_identifier") then
doc.sub.identifier.register_object(entity_id, "craftitems", itemstring)
end
end
@ -817,31 +817,30 @@ minetest.register_craft({
})
-- TODO: Re-enable crafting of special minecarts when they have been implemented
if false then
minetest.register_craft({
output = "mcl_minecarts:furnace_minecart",
recipe = {
{"mcl_furnaces:furnace"},
{"mcl_minecarts:minecart"},
},
})
--[[minetest.register_craft({
output = "mcl_minecarts:furnace_minecart",
recipe = {
{"mcl_furnaces:furnace"},
{"mcl_minecarts:minecart"},
},
})
minetest.register_craft({
output = "mcl_minecarts:hopper_minecart",
recipe = {
{"mcl_hoppers:hopper"},
{"mcl_minecarts:minecart"},
},
})
minetest.register_craft({
output = "mcl_minecarts:hopper_minecart",
recipe = {
{"mcl_hoppers:hopper"},
{"mcl_minecarts:minecart"},
},
})
minetest.register_craft({
output = "mcl_minecarts:chest_minecart",
recipe = {
{"mcl_chests:chest"},
{"mcl_minecarts:minecart"},
},
})]]
minetest.register_craft({
output = "mcl_minecarts:chest_minecart",
recipe = {
{"mcl_chests:chest"},
{"mcl_minecarts:minecart"},
},
})
end
if has_mcl_wip then
mcl_wip.register_wip_item("mcl_minecarts:chest_minecart")

36
mods/ENTITIES/mcl_minecarts/locale/mcl_minecarts.pl.tr Normal file
View File

@ -0,0 +1,36 @@
# textdomain: mcl_minecarts
Minecart=Wagonik
Minecarts can be used for a quick transportion on rails.=Wagoniki mogą być użyte do szybkiego transportu po torach.
Minecarts only ride on rails and always follow the tracks. At a T-junction with no straight way ahead, they turn left. The speed is affected by the rail type.=Wagoniki mogą jeździć tylko po torach i zawsze podążają za wytyczoną ścieżką. W przypadku skrzyżowań typu T, gdzie nie ma prostej ścieżki, skręcają w lew. Ich szybkość zależy od typu torów.
You can place the minecart on rails. Right-click it to enter it. Punch it to get it moving.=Możesz postawić wagonik na torach. Kliknij prawym przyciskiem myszy aby do niego wejść. Uderz go by zaczął się poruszać.
To obtain the minecart, punch it while holding down the sneak key.=Aby odzyskać wagonik uderz go podczas skradania.
A minecart with TNT is an explosive vehicle that travels on rail.=Wagonik z TNT jest wybuchowym pojazdem podróżującym po torach.
Place it on rails. Punch it to move it. The TNT is ignited with a flint and steel or when the minecart is on an powered activator rail.=Postaw go na torach. Uderz by zaczął się poruszać. TNT zapala się krzesiwem lub gdy wagonik jest na zasilonych torach aktywacyjnych.
To obtain the minecart and TNT, punch them while holding down the sneak key. You can't do this if the TNT was ignited.=Aby odzyskać wagonik z TNT uderz go podczas skradania. Nie możesz tego zrobić gdy TNT jest zapalone.
A minecart with furnace is a vehicle that travels on rails. It can propel itself with fuel.=Wagonik z piecem jest pojazdem podróżującym na torach. Napędza on samego siebie za pomocą paliwa.
Place it on rails. If you give it some coal, the furnace will start burning for a long time and the minecart will be able to move itself. Punch it to get it moving.=Postaw go na torach. Jeśli dasz mu nieco węgla piec zacznie palić przez długi czas, a wagonik będzie się sam poruszał. Uderz go by zaczął się poruszać.
To obtain the minecart and furnace, punch them while holding down the sneak key.=Aby odzyskać wagonik z piecem uderz go podczas skradania.
Minecart with Chest=Wagonik ze skrzynią
Minecart with Furnace=Wagonik z piecem
Minecart with Command Block=Wagonik z blokiem poleceń
Minecart with Hopper=Wagonik z lejem
Minecart with TNT=Wagonik z TNT
Place them on the ground to build your railway, the rails will automatically connect to each other and will turn into curves, T-junctions, crossings and slopes as needed.=Postaw je na ziemi by zbudować ścieżkę z torów. Tory automatycznie połączą się ze sobą i zamienią się w zakręty, skrzyżowania typu T, skrzyżowania i równie w zależności od potrzeb.
Rail=Tor
Rails can be used to build transport tracks for minecarts. Normal rails slightly slow down minecarts due to friction.=Tory mogą być wykorzystane do zbudowania torów dla wagoników. Zwyczajne tory nieco spowalniają wagoniki ze względu na tarcie.
Powered Rail=Zasilane tory
Rails can be used to build transport tracks for minecarts. Powered rails are able to accelerate and brake minecarts.=Tory mogą być wykorzystane do zbudowania torów dla wagoników. Zasilane tory mogą przyspieszać lub spowalniać wagoniki.
Without redstone power, the rail will brake minecarts. To make this rail accelerate minecarts, power it with redstone power.=Bez zasilania czerwienitem tory będą spowalniać wagoniki. Aby sprawić by je przyspieszały zasil je czerwienitem.
Activator Rail=Tory aktywacyjne
Rails can be used to build transport tracks for minecarts. Activator rails are used to activate special minecarts.=Tory mogą być wykorzystane do zbudowania torów dla wagoników. Tory aktywacyjne są wykorzystywane do aktywacji specjalnych wagoników.
To make this rail activate minecarts, power it with redstone power and send a minecart over this piece of rail.=Aby ten tor aktywował wagonik, zasil go czerwienitem i spraw by wagonik po nim przejechał.
Detector Rail=Tory z czujnikiem
Rails can be used to build transport tracks for minecarts. A detector rail is able to detect a minecart above it and powers redstone mechanisms.=Tory mogą być wykorzystane do zbudowania torów dla wagoników. Tory z czujnikiem są w stanie wykryć kiedy wagonik po nich przejeżdża i wysłać sygnał do czerwienitowych mechanizmów.
To detect a minecart and provide redstone power, connect it to redstone trails or redstone mechanisms and send any minecart over the rail.=Aby wykryć wagonik i dostarczyć zasilanie czerwienitem podłącz go czerwienitem to mechanizmu i spraw by wagonik po nim przejechał.
Track for minecarts=Tor dla wagoników
Speed up when powered, slow down when not powered=Przyspiesza gdy zasilane, spowalnia gdy nie
Activates minecarts when powered=Aktywuje wagoniki gdy zasilane
Emits redstone power when a minecart is detected=Emituje zasilanie czerwienitem gdy wagonik jest wykryty
Vehicle for fast travel on rails=Pojazd do szybkiej podróży na torach
Can be ignited by tools or powered activator rail=Może być zapalony przez narzędzia, lub zasilane tor aktywacyjne
Sneak to dismount=Zacznij się skradać by zejść

12
mods/ENTITIES/mcl_minecarts/rails.lua
View File

@ -1,7 +1,7 @@
local S = minetest.get_translator("mcl_minecarts")
local S = minetest.get_translator(minetest.get_current_modname())
-- Template rail function
local register_rail = function(itemstring, tiles, def_extras, creative)
local function register_rail(itemstring, tiles, def_extras, creative)
local groups = {handy=1,pickaxey=1, attached_node=1,rail=1,connect_to_raillike=minetest.raillike_group("rail"),dig_by_water=1,destroy_by_lava_flow=1, transport=1}
if creative == false then
groups.not_in_creative_inventory = 1
@ -206,11 +206,11 @@ register_rail("mcl_minecarts:detector_rail_on",
-- Crafting
minetest.register_craft({
output = 'mcl_minecarts:rail 16',
output = "mcl_minecarts:rail 16",
recipe = {
{'mcl_core:iron_ingot', '', 'mcl_core:iron_ingot'},
{'mcl_core:iron_ingot', 'mcl_core:stick', 'mcl_core:iron_ingot'},
{'mcl_core:iron_ingot', '', 'mcl_core:iron_ingot'},
{"mcl_core:iron_ingot", "", "mcl_core:iron_ingot"},
{"mcl_core:iron_ingot", "mcl_core:stick", "mcl_core:iron_ingot"},
{"mcl_core:iron_ingot", "", "mcl_core:iron_ingot"},
}
})

0
mods/ENTITIES/mcl_mobs/readme.MD → mods/ENTITIES/mcl_mobs/README.md
View File

162
mods/ENTITIES/mcl_mobs/api/api.lua
View File

@ -11,133 +11,111 @@ 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_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_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_protected = minetest.is_protected
--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_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
--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_pi = math.pi
local math_sin = math.sin
local math_cos = math.cos
local math_abs = math.abs
local math_min = math.min
local math_max = math.max
local math_atan = math.atan
local math_random = math.random
local math_floor = math.floor
local math = math
-- localize vector functions
local vector_new = vector.new
local vector_add = vector.add
local vector_length = vector.length
local vector_direction = vector.direction
local vector_normalize = vector.normalize
local vector_multiply = vector.multiply
local vector_divide = vector.divide
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 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 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 = {}
--[[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 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)
--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
--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"
--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") ~= nil
local mod_explosions = minetest_get_modpath("mcl_explosions") ~= nil
local mod_mobspawners = minetest_get_modpath("mcl_mobspawners") ~= nil
local mod_hunger = minetest_get_modpath("mcl_hunger") ~= nil
local mod_worlds = minetest_get_modpath("mcl_worlds") ~= nil
local mod_armor = minetest_get_modpath("mcl_armor") ~= nil
local mod_experience = minetest_get_modpath("mcl_experience") ~= nil
--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
--local los_switcher = false
--local height_switcher = false
-- Get translator
local S = minetest.get_translator("mcl_mobs")
local S = minetest.get_translator(minetest.get_current_modname())
-- CMI support check
local use_cmi = minetest.global_exists("cmi")
-- Invisibility mod check
mobs.invis = {}
if minetest.global_exists("invisibility") then
mobs.invis = invisibility
end
--local use_cmi = minetest.global_exists("cmi")
-- creative check
function mobs.is_creative(name)
return minetest_is_creative_enabled(name)
end
local atan = function(x)
--[[local function atan(x)
if not x or x ~= x then
return 0
else
return math_atan(x)
return math.atan(x)
end
end
end]]
-- Shows helpful debug info above each mob
local mobs_debug = minetest_settings:get_bool("mobs_debug", false)
--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
@ -191,7 +169,7 @@ function mobs:register_mob(name, def)
if (not value) or (value == default) or (value == special) then
return default
else
return math_max(min, value * difficulty)
return math.max(min, value * difficulty)
end
end
@ -366,15 +344,11 @@ function mobs:register_mob(name, def)
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
has_head = def.has_head or false,
head_bone = def.head_bone,
--you must use these to adjust the mob's head positions
--has_head is used as a logic gate (quick easy check)
@ -444,7 +418,7 @@ function mobs:register_mob(name, def)
--on_detach_child = mob_detach_child,
on_activate = function(self, staticdata, dtime)
self.object:set_acceleration(vector_new(0,-GRAVITY, 0))
self.object:set_acceleration(vector.new(0,-GRAVITY, 0))
return mobs.mob_activate(self, staticdata, def, dtime)
end,
@ -455,7 +429,7 @@ function mobs:register_mob(name, def)
--harmed_by_heal = def.harmed_by_heal,
})
if minetest_get_modpath("doc_identifier") ~= nil then
if minetest_get_modpath("doc_identifier") then
doc.sub.identifier.register_object(name, "basics", "mobs")
end
@ -556,10 +530,10 @@ function mobs:register_arrow(name, def)
and def.tail_texture then
--do this to prevent clipping through main entity sprite
local pos_adjustment = vector_multiply(vector_normalize(vel), -1)
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)
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},
@ -693,12 +667,12 @@ function mobs:register_egg(mob, desc, background, addegg, no_creative)
if pos
--and within_limits(pos, 0)
and not minetest_is_protected(pos, placer:get_player_name()) then
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
if minetest.is_protected(pointed_thing.under, name) then
minetest.record_protection_violation(pointed_thing.under, name)
return itemstack
end
@ -743,7 +717,7 @@ function mobs:register_egg(mob, desc, background, addegg, no_creative)
nametag = string.sub(nametag, 1, MAX_MOB_NAME_LENGTH)
end
ent.nametag = nametag
update_tag(ent)
--update_tag(ent)
end
-- if not in creative then take item

255
mods/ENTITIES/mcl_mobs/api/mob_functions/ai.lua
View File

@ -1,12 +1,8 @@
local math_random = math.random
local math_pi = math.pi
local math_floor = math.floor
local math_round = math.round
local math = math
local vector = vector
local string = string
local vector_multiply = vector.multiply
local vector_add = vector.add
local vector_new = vector.new
local vector_distance = vector.distance
local tonumber = tonumber
local minetest_yaw_to_dir = minetest.yaw_to_dir
local minetest_get_item_group = minetest.get_item_group
@ -17,9 +13,8 @@ local minetest_get_node_light = minetest.get_node_light
local DOUBLE_PI = math.pi * 2
local THIRTY_SECONDTH_PI = DOUBLE_PI * 0.03125
--a simple helper function which is too small to move into movement.lua
local quick_rotate = function(self,dtime)
local function quick_rotate(self,dtime)
self.yaw = self.yaw + THIRTY_SECONDTH_PI
if self.yaw > DOUBLE_PI then
self.yaw = self.yaw - DOUBLE_PI
@ -28,46 +23,45 @@ end
--a simple helper function for rounding
--http://lua-users.org/wiki/SimpleRound
function round2(num, numDecimalPlaces)
local function round2(num, numDecimalPlaces)
return tonumber(string.format("%." .. (numDecimalPlaces or 0) .. "f", num))
end
--[[
_ _
_ _
| | | |
| | __ _ _ __ __| |
| | / _` | '_ \ / _` |
| | / _` | '_ \ / _` |
| |___| (_| | | | | (_| |
\_____/\__,_|_| |_|\__,_|
]]--
--this is basically reverse jump_check
local cliff_check = function(self,dtime)
local function cliff_check(self,dtime)
--mobs will flip out if they are falling without this
if self.object:get_velocity().y ~= 0 then
return false
end
local pos = self.object:get_pos()
local dir = minetest_yaw_to_dir(self.yaw)
local dir = minetest_yaw_to_dir(self.yaw)
local collisionbox = self.object:get_properties().collisionbox
local radius = collisionbox[4] + 0.5
dir = vector_multiply(dir,radius)
dir = vector.multiply(dir,radius)
local free_fall, blocker = minetest_line_of_sight(
local free_fall = minetest_line_of_sight(
{x = pos.x + dir.x, y = pos.y, z = pos.z + dir.z},
{x = pos.x + dir.x, y = pos.y - self.fear_height, z = pos.z + dir.z})
return free_fall
end
-- state switching logic (stand, walk, run, attacks)
local land_state_list_wandering = {"stand", "walk"}
local land_state_switch = function(self, dtime)
local function land_state_switch(self, dtime)
--do math before sure not attacking, following, or running away so continue
--doing random walking for mobs if all states are not met
@ -93,8 +87,8 @@ local land_state_switch = function(self, dtime)
end
--ignore everything else if following
if mobs.check_following(self) and
(not self.breed_lookout_timer or (self.breed_lookout_timer and self.breed_lookout_timer == 0)) and
if mobs.check_following(self) and
(not self.breed_lookout_timer or (self.breed_lookout_timer and self.breed_lookout_timer == 0)) and
(not self.breed_timer or (self.breed_timer and self.breed_timer == 0)) then
self.state = "follow"
return
@ -120,7 +114,7 @@ local land_state_switch = function(self, dtime)
end
-- states are executed here
local land_state_execution = function(self,dtime)
local function land_state_execution(self, dtime)
--[[ -- this is a debug which shows the timer and makes mobs breed 100 times faster
print(self.breed_timer)
@ -136,7 +130,6 @@ local land_state_execution = function(self,dtime)
if not self.object:get_properties() then
return
end
--timer to time out looking for mate
if self.breed_lookout_timer and self.breed_lookout_timer > 0 then
@ -176,12 +169,12 @@ local land_state_execution = function(self,dtime)
if velocity.y < 0 then
--lua is acting really weird so we have to help it
if round2(self.object:get_acceleration().y, 1) == -self.gravity then
self.object:set_acceleration(vector_new(0,0,0))
self.object:set_acceleration(vector.new(0,0,0))
mobs.mob_fall_slow(self)
end
else
if round2(self.object:get_acceleration().y, 1) == 0 then
self.object:set_acceleration(vector_new(0,-self.gravity,0))
self.object:set_acceleration(vector.new(0,-self.gravity,0))
end
end
end
@ -206,15 +199,13 @@ local land_state_execution = function(self,dtime)
end
mobs.lock_yaw(self)
elseif self.state == "follow" then
elseif self.state == "follow" then
--always look at players
mobs.set_yaw_while_following(self)
--check distance
local distance_from_follow_person = vector_distance(self.object:get_pos(), self.following_person:get_pos())
local distance_from_follow_person = vector.distance(self.object:get_pos(), self.following_person:get_pos())
local distance_2d = mobs.get_2d_distance(self.object:get_pos(), self.following_person:get_pos())
--don't push the player if too close
--don't spin around randomly
if self.follow_distance < distance_from_follow_person and self.minimum_follow_distance < distance_2d then
@ -240,7 +231,7 @@ local land_state_execution = function(self,dtime)
self.walk_timer = math.random(1,6) + math.random()
--set the mob into a random direction
self.yaw = (math_random() * (math.pi * 2))
self.yaw = (math.random() * (math.pi * 2))
end
--do animation
@ -253,15 +244,13 @@ local land_state_execution = function(self,dtime)
local node_in_front_of = mobs.jump_check(self)
if node_in_front_of == 1 then
mobs.jump(self)
--turn if on the edge of cliff
--(this is written like this because unlike
--jump_check which simply tells the mob to jump
--this requires a mob to turn, removing the
--ease of a full implementation for it in a single
--function)
--turn if on the edge of cliff
--(this is written like this because unlike
--jump_check which simply tells the mob to jump
--this requires a mob to turn, removing the
--ease of a full implementation for it in a single
--function)
elseif node_in_front_of == 2 or (self.fear_height ~= 0 and cliff_check(self,dtime)) then
--turn 45 degrees if so
quick_rotate(self,dtime)
@ -292,9 +281,7 @@ local land_state_execution = function(self,dtime)
local node_in_front_of = mobs.jump_check(self)
if node_in_front_of == 1 then
mobs.jump(self)
--turn if on the edge of cliff
--(this is written like this because unlike
--jump_check which simply tells the mob to jump
@ -342,7 +329,7 @@ local land_state_execution = function(self,dtime)
mobs.set_velocity(self, self.walk_velocity)
--smoosh together basically
if vector_distance(self.object:get_pos(), mate:get_pos()) <= self.breed_distance then
if vector.distance(self.object:get_pos(), mate:get_pos()) <= self.breed_distance then
mobs.set_mob_animation(self, "stand")
if self.special_breed_timer == 0 then
self.special_breed_timer = 2 --breeding takes 2 seconds
@ -353,7 +340,7 @@ local land_state_execution = function(self,dtime)
--pop a baby out, it's a miracle!
local baby_pos = vector.divide(vector.add(self.object:get_pos(), mate:get_pos()), 2)
local baby_mob = minetest.add_entity(pos, self.name, minetest.serialize({baby = true, grow_up_timer = self.grow_up_goal, bred = true}))
minetest.add_entity(baby_pos, self.name, minetest.serialize({baby = true, grow_up_timer = self.grow_up_goal, bred = true}))
mobs.play_sound_specific(self,"item_drop_pickup")
@ -375,14 +362,13 @@ local land_state_execution = function(self,dtime)
mobs.set_velocity(self,0)
end
end
end
if float_now then
mobs.float(self)
else
local acceleration = self.object:get_acceleration()
if acceleration and acceleration.y == 0 then
self.object:set_acceleration(vector_new(0,-self.gravity,0))
self.object:set_acceleration(vector.new(0,-self.gravity,0))
end
end
end
@ -391,10 +377,10 @@ end
--[[
_____ _
/ ___| (_)
\ `--.__ ___ _ __ ___
`--. \ \ /\ / / | '_ ` _ \
_____ _
/ ___| (_)
\ `--.__ ___ _ __ ___
`--. \ \ /\ / / | '_ ` _ \
/\__/ /\ V V /| | | | | | |
\____/ \_/\_/ |_|_| |_| |_|
]]--
@ -404,7 +390,7 @@ end
-- state switching logic (stand, walk, run, attacks)
local swim_state_list_wandering = {"stand", "swim"}
local swim_state_switch = function(self, dtime)
local function swim_state_switch(self, dtime)
self.state_timer = self.state_timer - dtime
if self.state_timer <= 0 then
self.state_timer = math.random(4,10) + math.random()
@ -414,41 +400,40 @@ end
--check if a mob needs to turn while swimming
local swim_turn_check = function(self,dtime)
local function swim_turn_check(self,dtime)
local pos = self.object:get_pos()
pos.y = pos.y + 0.1
local dir = minetest_yaw_to_dir(self.yaw)
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 collisionbox = self.object:get_properties().collisionbox
local radius = collisionbox[4] + 0.5
vector_multiply(dir, radius)
vector.multiply(dir, radius)
local test_dir = vector.add(pos,dir)
local test_dir = vector.add(pos,dir)
local green_flag_1 = minetest_get_item_group(minetest_get_node(test_dir).name, "solid") ~= 0
return(green_flag_1)
return green_flag_1
end
--this is to swap the built in engine acceleration modifier
local swim_physics_swapper = function(self,inside_swim_node)
local function swim_physics_swapper(self, inside_swim_node)
--should be swimming, gravity is applied, switch to floating
if inside_swim_node and self.object:get_acceleration().y ~= 0 then
self.object:set_acceleration(vector_new(0,0,0))
self.object:set_acceleration(vector.new(0,0,0))
--not be swim, gravity isn't applied, switch to falling
elseif not inside_swim_node and self.object:get_acceleration().y == 0 then
self.pitch = 0
self.object:set_acceleration(vector_new(0,-self.gravity,0))
self.object:set_acceleration(vector.new(0,-self.gravity,0))
end
end
local random_pitch_multiplier = {-1,1}
-- states are executed here
local swim_state_execution = function(self,dtime)
local function swim_state_execution(self, dtime)
local pos = self.object:get_pos()
@ -465,7 +450,7 @@ local swim_state_execution = function(self,dtime)
end
--turn gravity on or off
swim_physics_swapper(self,inside_swim_node)
swim_physics_swapper(self, inside_swim_node)
--swim properly if inside swim node
if inside_swim_node then
@ -482,22 +467,17 @@ local swim_state_execution = function(self,dtime)
end
mobs.lock_yaw(self)
elseif self.state == "swim" then
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))
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)]
self.pitch = math.random() * math.random(1,3) * random_pitch_multiplier[math.random(1,2)]
end
--do animation
@ -535,20 +515,20 @@ end
--[[
______ _
| ___| |
| |_ | |_ _
______ _
| ___| |
| |_ | |_ _
| _| | | | | |
| | | | |_| |
\_| |_|\__, |
__/ |
|___/
__/ |
|___/
]]--
-- state switching logic (stand, walk, run, attacks)
local fly_state_list_wandering = {"stand", "fly"}
local fly_state_switch = function(self, dtime)
local function fly_state_switch(self, dtime)
if self.hostile and self.attacking then
self.state = "attack"
@ -564,41 +544,41 @@ end
--check if a mob needs to turn while flying
local fly_turn_check = function(self,dtime)
local function fly_turn_check(self, dtime)
local pos = self.object:get_pos()
pos.y = pos.y + 0.1
local dir = minetest_yaw_to_dir(self.yaw)
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 collisionbox = self.object:get_properties().collisionbox
local radius = collisionbox[4] + 0.5
vector_multiply(dir, radius)
vector.multiply(dir, radius)
local test_dir = vector.add(pos,dir)
local test_dir = vector.add(pos,dir)
local green_flag_1 = minetest_get_item_group(minetest_get_node(test_dir).name, "solid") ~= 0
return(green_flag_1)
return green_flag_1
end
--this is to swap the built in engine acceleration modifier
local fly_physics_swapper = function(self,inside_fly_node)
local function fly_physics_swapper(self, inside_fly_node)
--should be flyming, gravity is applied, switch to floating
if inside_fly_node and self.object:get_acceleration().y ~= 0 then
self.object:set_acceleration(vector_new(0,0,0))
self.object:set_acceleration(vector.new(0,0,0))
--not be fly, gravity isn't applied, switch to falling
elseif not inside_fly_node and self.object:get_acceleration().y == 0 then
self.pitch = 0
self.object:set_acceleration(vector_new(0,-self.gravity,0))
self.object:set_acceleration(vector.new(0,-self.gravity,0))
end
end
local random_pitch_multiplier = {-1,1}
-- states are executed here
local fly_state_execution = function(self,dtime)
local function fly_state_execution(self, dtime)
local pos = self.object:get_pos()
pos.y = pos.y + 0.1
local current_node = minetest_get_node(pos).name
@ -635,15 +615,13 @@ local fly_state_execution = function(self,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))
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)]
self.pitch = math.random() * math.random(1,3) * random_pitch_multiplier[math.random(1,2)]
end
--do animation
@ -663,9 +641,7 @@ local fly_state_execution = function(self,dtime)
--enable rotation locking
mobs.movement_rotation_lock(self)
elseif self.state == "attack" then
--execute mob attack type
--if self.attack_type == "explode" then
@ -697,40 +673,39 @@ end
--[[
___
|_ |
| |_ _ _ __ ___ _ __
| | | | | '_ ` _ \| '_ \
___
|_ |
| |_ _ _ __ ___ _ __
| | | | | '_ ` _ \| '_ \
/\__/ / |_| | | | | | | |_) |
\____/ \__,_|_| |_| |_| .__/
| |
|_|
\____/ \__,_|_| |_| |_| .__/
| |
|_|
]]--
--check if a mob needs to turn while jumping
local jump_turn_check = function(self,dtime)
--[[local function jump_turn_check(self, dtime)
local pos = self.object:get_pos()
pos.y = pos.y + 0.1
local dir = minetest_yaw_to_dir(self.yaw)
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 collisionbox = self.object:get_properties().collisionbox
local radius = collisionbox[4] + 0.5
vector_multiply(dir, radius)
vector.multiply(dir, radius)
local test_dir = vector.add(pos,dir)
local test_dir = vector.add(pos,dir)
local green_flag_1 = minetest_get_item_group(minetest_get_node(test_dir).name, "solid") ~= 0
return(green_flag_1)
end
return green_flag_1
end]]
-- state switching logic (stand, jump, run, attacks)
local jump_state_list_wandering = {"stand", "jump"}
local jump_state_switch = function(self, dtime)
local function jump_state_switch(self, dtime)
self.state_timer = self.state_timer - dtime
if self.state_timer <= 0 then
self.state_timer = math.random(4,10) + math.random()
@ -739,8 +714,8 @@ local jump_state_switch = function(self, dtime)
end
-- states are executed here
local jump_state_execution = function(self,dtime)
local function jump_state_execution(self, dtime)
local node_in_front_of = mobs.jump_check(self)
local pos = self.object:get_pos()
local collisionbox = self.object:get_properties().collisionbox
--get the center of the mob
@ -775,7 +750,7 @@ local jump_state_execution = function(self,dtime)
self.walk_timer = math.random(1,6) + math.random()
--set the mob into a random direction
self.yaw = (math_random() * (math.pi * 2))
self.yaw = (math.random() * (math.pi * 2))
end
--do animation
@ -793,15 +768,10 @@ local jump_state_execution = function(self,dtime)
mobs.jump_move(self,self.walk_velocity)
elseif self.state == "run" then
print("run")
elseif self.state == "attack" then
print("attack")
end
end
if float_now then
mobs.float(self)
end
@ -811,18 +781,18 @@ end
--[[
___ ___ _ _ _
| \/ | (_) | | (_)
| . . | __ _ _ _ __ | | ___ __ _ _ ___
___ ___ _ _ _
| \/ | (_) | | (_)
| . . | __ _ _ _ __ | | ___ __ _ _ ___
| |\/| |/ _` | | '_ \ | | / _ \ / _` | |/ __|
| | | | (_| | | | | | | |___| (_) | (_| | | (__
| | | | (_| | | | | | | |___| (_) | (_| | | (__
\_| |_/\__,_|_|_| |_| \_____/\___/ \__, |_|\___|
__/ |
|___/
__/ |
|___/
]]--
--the main loop
mobs.mob_step = function(self, dtime)
function mobs.mob_step(self, dtime)
--do not continue if non-existent
if not self or not self.object or not self.object:get_luaentity() then
@ -859,13 +829,13 @@ mobs.mob_step = function(self, dtime)
end
--color modifier which coincides with the pause_timer
if self.old_health and self.health < self.old_health then
if self.old_health and self.health < self.old_health then
self.object:set_texture_mod("^[colorize:red:120")
--fix double death sound
if self.health > 0 then
mobs.play_sound(self,"damage")
end
end
end
self.old_health = self.health
--do death logic (animation, poof, explosion, etc)
@ -916,7 +886,6 @@ mobs.mob_step = function(self, dtime)
elseif self.breath < self.breath_max then
self.breath = self.breath + dtime
--clean timer reset
if self.breath > self.breath_max then
self.breath = self.breath_max
@ -948,10 +917,6 @@ mobs.mob_step = function(self, dtime)
end
end
--baby grows up
if self.baby then
--print(self.grow_up_timer)
@ -968,8 +933,6 @@ mobs.mob_step = function(self, dtime)
mobs.baby_grow_up(self)
end
end
--do custom mob instructions
if self.do_custom then
@ -1015,7 +978,7 @@ mobs.mob_step = function(self, dtime)
self.memory = self.memory - dtime
--get if memory player is within viewing range
if self.attacking and self.attacking:is_player() then
local distance = vector_distance(self.object:get_pos(), self.attacking:get_pos())
local distance = vector.distance(self.object:get_pos(), self.attacking:get_pos())
if distance > self.view_range then
self.memory = 0
end
@ -1027,7 +990,7 @@ mobs.mob_step = function(self, dtime)
if self.memory <= 0 then
--reset states when coming out of hostile state
if self.attacking ~= nil then
if self.attacking then
self.state_timer = -1
end
@ -1090,7 +1053,7 @@ mobs.mob_step = function(self, dtime)
--jump only (like slimes)
if self.jump_only then
jump_state_switch(self, dtime)
jump_state_execution(self, dtime)
jump_state_execution(self, dtime)
--swimming
elseif self.swim then
swim_state_switch(self, dtime)
@ -1124,28 +1087,22 @@ mobs.mob_step = function(self, dtime)
--overrides absolutely everything
--mobs get stuck in cobwebs like players
if not self.ignores_cobwebs then
local pos = self.object:get_pos()
local node = pos and minetest_get_node(pos).name
if node == "mcl_core:cobweb" then
--fight the rest of the api
if self.object:get_acceleration().y ~= 0 then
self.object:set_acceleration(vector_new(0,0,0))
self.object:set_acceleration(vector.new(0,0,0))
end
mobs.stick_in_cobweb(self)
self.was_stuck_in_cobweb = true
else
--do not override other functions
if self.was_stuck_in_cobweb == true then
--return the mob back to normal
self.was_stuck_in_cobweb = nil
if self.object:get_acceleration().y == 0 and not self.swim and not self.fly then
self.object:set_acceleration(vector_new(0,-self.gravity,0))
self.object:set_acceleration(vector.new(0,-self.gravity,0))
end
end
end

22
mods/ENTITIES/mcl_mobs/api/mob_functions/animation.lua
View File

@ -1,7 +1,7 @@
local math_pi = math.pi
local math_floor = math.floor
local math_random = math.random
local HALF_PI = math_pi/2
local math = math
local vector = vector
local HALF_PI = math.pi/2
local vector_direction = vector.direction
@ -48,8 +48,7 @@ mobs.set_mob_animation = function(self, anim, fixed_frame)
self.animation[anim .. "_speed"] or self.animation.speed_normal or 15,
0, self.animation[anim .. "_loop"] ~= false)
self.current_animation = anim
self.current_animation = anim
end
@ -65,14 +64,14 @@ mobs.death_effect = function(pos, yaw, collisionbox, rotate)
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 = 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({
minetest.add_particlespawner({
amount = 50,
time = 0.001,
minpos = vector.add(pos, min),
@ -88,7 +87,7 @@ mobs.death_effect = function(pos, yaw, collisionbox, rotate)
texture = "mcl_particles_mob_death.png^[colorize:#000000:255",
})
minetest_sound_play("mcl_mobs_mob_poof", {
minetest.sound_play("mcl_mobs_mob_poof", {
pos = pos,
gain = 1.0,
max_hear_distance = 8,
@ -99,7 +98,6 @@ 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
@ -159,7 +157,7 @@ local calculate_pitch = function(self)
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)
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

60
mods/ENTITIES/mcl_mobs/api/mob_functions/attack_type_instructions.lua
View File

@ -1,11 +1,11 @@
local vector_direction = vector.direction
local minetest_dir_to_yaw = minetest.dir_to_yaw
--local minetest_dir_to_yaw = minetest.dir_to_yaw
local vector_distance = vector.distance
local vector_multiply = vector.multiply
local math_random = math.random
--[[
_ _ _ _
_ _ _ _
| | | | | | | |
| | | | __ _ _ __ __| | | |
| | | | / _` | '_ \ / _` | | |
@ -16,14 +16,14 @@ local math_random = math.random
--[[
_____ _ _
| ___| | | | |
| |____ ___ __ | | ___ __| | ___
_____ _ _
| ___| | | | |
| |____ ___ __ | | ___ __| | ___
| __\ \/ / '_ \| |/ _ \ / _` |/ _ \
| |___> <| |_) | | (_) | (_| | __/
\____/_/\_\ .__/|_|\___/ \__,_|\___|
| |
|_|
| |
|_|
]]--
mobs.explode_attack_walk = function(self,dtime)
@ -41,7 +41,7 @@ mobs.explode_attack_walk = function(self,dtime)
--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 ~= nil and self.explosion_animation > 0 and distance_from_attacking <= self.defuse_reach) then
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")
@ -74,7 +74,6 @@ mobs.explode_attack_walk = function(self,dtime)
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
@ -86,9 +85,8 @@ 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 ~= nil and self.explosion_animation > 0 then
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
@ -102,10 +100,10 @@ end
--[[
______ _
| ___ \ | |
| |_/ / _ _ __ ___| |__
| __/ | | | '_ \ / __| '_ \
______ _
| ___ \ | |
| |_/ / _ _ __ ___| |__
| __/ | | | '_ \ / __| '_ \
| | | |_| | | | | (__| | | |
\_| \__,_|_| |_|\___|_| |_|
]]--
@ -113,7 +111,6 @@ ______ _
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
@ -187,14 +184,14 @@ end
--[[
______ _ _ _ _
| ___ \ (_) | | (_) |
| |_/ / __ ___ _ ___ ___| |_ _| | ___
______ _ _ _ _
| ___ \ (_) | | (_) |
| |_/ / __ ___ _ ___ ___| |_ _| | ___
| __/ '__/ _ \| |/ _ \/ __| __| | |/ _ \
| | | | | (_) | | __/ (__| |_| | | __/
\_| |_| \___/| |\___|\___|\__|_|_|\___|
_/ |
|__/
_/ |
|__/
]]--
@ -255,40 +252,39 @@ 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
@ -315,7 +311,7 @@ mobs.projectile_attack_fly = function(self, dtime)
local distance_from_attacking = vector_distance(self.object:get_pos(), self.attacking:get_pos())
if distance_from_attacking >= self.reach then
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")

74
mods/ENTITIES/mcl_mobs/api/mob_functions/backup_code_api.lua → mods/ENTITIES/mcl_mobs/api/mob_functions/backup_code_api.txt
View File

@ -1,4 +1,7 @@
local disable_physics = function(object, luaentity, ignore_check, reset_movement)
local math = math
local vector = vector
local function disable_physics(object, luaentity, ignore_check, reset_movement)
if luaentity.physical_state == true or ignore_check == true then
luaentity.physical_state = false
object:set_properties({
@ -12,7 +15,7 @@ local disable_physics = function(object, luaentity, ignore_check, reset_movement
end
----For Water Flowing:
local enable_physics = function(object, luaentity, ignore_check)
local function enable_physics(object, luaentity, ignore_check)
if luaentity.physical_state == false or ignore_check == true then
luaentity.physical_state = true
object:set_properties({
@ -272,7 +275,7 @@ local falling = function(self, pos)
self.object:set_acceleration({
x = 0,
y = -self.fall_speed / (math_max(1, v.y) ^ 2),
y = -self.fall_speed / (math.max(1, v.y) ^ 2),
z = 0
})
end
@ -503,9 +506,9 @@ local follow_flop = function(self)
if sdef and sdef.walkable then
mob_sound(self, "flop")
self.object:set_velocity({
x = math_random(-FLOP_HOR_SPEED, FLOP_HOR_SPEED),
x = math.random(-FLOP_HOR_SPEED, FLOP_HOR_SPEED),
y = FLOP_HEIGHT,
z = math_random(-FLOP_HOR_SPEED, FLOP_HOR_SPEED),
z = math.random(-FLOP_HOR_SPEED, FLOP_HOR_SPEED),
})
end
@ -987,7 +990,7 @@ local check_for_death = function(self, cause, cmi_cause)
item_drop(self, cooked, looting)
if mod_experience and ((not self.child) or self.type ~= "animal") and (minetest_get_us_time() - self.xp_timestamp <= 5000000) then
mcl_experience.throw_experience(self.object:get_pos(), math_random(self.xp_min, self.xp_max))
mcl_experience.throw_experience(self.object:get_pos(), math.random(self.xp_min, self.xp_max))
end
end
end
@ -1361,7 +1364,7 @@ local do_attack = function(self, player)
self.state = "attack"
-- TODO: Implement war_cry sound without being annoying
--if math_random(0, 100) < 90 then
--if math.random(0, 100) < 90 then
--mob_sound(self, "war_cry", true)
--end
end
@ -1396,7 +1399,7 @@ local mob_sound = function(self, soundname, is_opinion, fixed_pitch)
pitch = base_pitch
end
-- randomize the pitch a bit
pitch = pitch + math_random(-10, 10) * 0.005
pitch = pitch + math.random(-10, 10) * 0.005
end
minetest_sound_play(sound, {
object = self.object,
@ -1699,7 +1702,7 @@ local do_env_damage = function(self)
end
if drowning then
self.breath = math_max(0, self.breath - 1)
self.breath = math.max(0, self.breath - 1)
effect(pos, 2, "bubble.png", nil, nil, 1, nil)
if self.breath <= 0 then
@ -2044,7 +2047,7 @@ local breed = function(self)
-- Give XP
if mod_experience then
mcl_experience.throw_experience(pos, math_random(1, 7))
mcl_experience.throw_experience(pos, math.random(1, 7))
end
-- custom breed function
@ -2061,7 +2064,7 @@ local breed = function(self)
-- Use texture of one of the parents
local p = math_random(1, 2)
local p = math.random(1, 2)
if p == 1 then
ent_c.base_texture = parent1.base_texture
else
@ -2091,7 +2094,7 @@ local replace = function(self, pos)
or not self.replace_what
or self.child == true
or self.object:get_velocity().y ~= 0
or math_random(1, self.replace_rate) > 1 then
or math.random(1, self.replace_rate) > 1 then
return
end
@ -2099,7 +2102,7 @@ local replace = function(self, pos)
if type(self.replace_what[1]) == "table" then
local num = math_random(#self.replace_what)
local num = math.random(#self.replace_what)
what = self.replace_what[num][1] or ""
with = self.replace_what[num][2] or ""
@ -2163,7 +2166,7 @@ function do_states(self)
if self.state == "stand" then
if math_random(1, 4) == 1 then
if math.random(1, 4) == 1 then
local lp = nil
local s = self.object:get_pos()
@ -2189,7 +2192,7 @@ function do_states(self)
if lp.x > s.x then yaw = yaw + math_pi end
else
yaw = yaw + math_random(-0.5, 0.5)
yaw = yaw + math.random(-0.5, 0.5)
end
yaw = set_yaw(self, yaw, 8)
@ -2204,7 +2207,7 @@ function do_states(self)
if self.walk_chance ~= 0
and self.facing_fence ~= true
and math_random(1, 100) <= self.walk_chance
and math.random(1, 100) <= self.walk_chance
and is_at_cliff_or_danger(self) == false then
set_velocity(self, self.walk_velocity)
@ -2254,7 +2257,7 @@ function do_states(self)
{x = s.x + 5, y = s.y + 1, z = s.z + 5},
{"group:solid"})
lp = #lp > 0 and lp[math_random(#lp)]
lp = #lp > 0 and lp[math.random(#lp)]
-- did we find land?
if lp then
@ -2280,8 +2283,8 @@ function do_states(self)
else
-- Randomly turn
if math_random(1, 100) <= 30 then
yaw = yaw + math_random(-0.5, 0.5)
if math.random(1, 100) <= 30 then
yaw = yaw + math.random(-0.5, 0.5)
yaw = set_yaw(self, yaw, 8)
end
end
@ -2289,9 +2292,9 @@ function do_states(self)
yaw = set_yaw(self, yaw, 8)
-- otherwise randomly turn
elseif math_random(1, 100) <= 30 then
elseif math.random(1, 100) <= 30 then
yaw = yaw + math_random(-0.5, 0.5)
yaw = yaw + math.random(-0.5, 0.5)
yaw = set_yaw(self, yaw, 8)
end
@ -2302,7 +2305,7 @@ function do_states(self)
end
if self.facing_fence == true
or cliff_or_danger
or math_random(1, 100) <= 30 then
or math.random(1, 100) <= 30 then
set_velocity(self, 0)
self.state = "stand"
@ -2602,7 +2605,7 @@ function do_states(self)
self.timer = 0
if self.double_melee_attack
and math_random(1, 2) == 1 then
and math.random(1, 2) == 1 then
set_animation(self, "punch2")
else
set_animation(self, "punch")
@ -2669,7 +2672,7 @@ function do_states(self)
if self.shoot_interval
and self.timer > self.shoot_interval
and not minetest_raycast(p, self.attack:get_pos(), false, false):next()
and math_random(1, 100) <= 60 then
and math.random(1, 100) <= 60 then
self.timer = 0
set_animation(self, "shoot")
@ -2759,7 +2762,7 @@ end
-- Code to execute before custom on_rightclick handling
local on_rightclick_prefix = function(self, clicker)
local function on_rightclick_prefix(self, clicker)
local item = clicker:get_wielded_item()
-- Name mob with nametag
@ -2785,17 +2788,17 @@ local on_rightclick_prefix = function(self, clicker)
return false
end
local create_mob_on_rightclick = function(on_rightclick)
--[[local function create_mob_on_rightclick(on_rightclick)
return function(self, clicker)
local stop = on_rightclick_prefix(self, clicker)
if (not stop) and (on_rightclick) then
on_rightclick(self, clicker)
end
end
end
end]]
-- set and return valid yaw
local set_yaw = function(self, yaw, delay, dtime)
local function set_yaw(self, yaw, delay, dtime)
if not yaw or yaw ~= yaw then
yaw = 0
@ -2805,7 +2808,7 @@ local set_yaw = function(self, yaw, delay, dtime)
if delay == 0 then
if self.shaking and dtime then
yaw = yaw + (math_random() * 2 - 1) * 5 * dtime
yaw = yaw + (math.random() * 2 - 1) * 5 * dtime
end
self.yaw(yaw)
update_roll(self)
@ -2825,8 +2828,7 @@ function mobs:yaw(self, yaw, delay, dtime)
end
mob_step = function()
--mob_step = function()
--if self.state == "die" then
-- print("need custom die stop moving thing")
-- return
@ -2901,7 +2903,7 @@ mob_step = function()
--end
-- mob plays random sound at times
--if math_random(1, 70) == 1 then
--if math.random(1, 70) == 1 then
-- mob_sound(self, "random", true)
--end
@ -2934,11 +2936,11 @@ mob_step = function()
--if is_at_water_danger(self) and self.state ~= "attack" then
-- if math_random(1, 10) <= 6 then
-- if math.random(1, 10) <= 6 then
-- set_velocity(self, 0)
-- self.state = "stand"
-- set_animation(self, "stand")
-- yaw = yaw + math_random(-0.5, 0.5)
-- yaw = yaw + math.random(-0.5, 0.5)
-- yaw = set_yaw(self, yaw, 8)
-- end
--end
@ -2982,7 +2984,7 @@ mob_step = function()
mcl_burning.extinguish(self.object)
self.object:remove()
elseif self.lifetimer <= 10 then
if math_random(10) < 4 then
if math.random(10) < 4 then
self.despawn_immediately = true
else
self.lifetimer = 20
@ -2991,4 +2993,4 @@ mob_step = function()
end
]]--
end
--end

57
mods/ENTITIES/mcl_mobs/api/mob_functions/breeding.lua
View File

@ -1,14 +1,13 @@
local minetest_get_objects_inside_radius = minetest.get_objects_inside_radius
local vector_distance = vector.distance
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)
return false
end
--hey look, this thing works for passive mobs too!
@ -20,20 +19,20 @@ mobs.check_following = function(self) -- returns true or false
--safety check
if not stack then
self.following_person = nil
return(false)
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)
return true
end
end
--everything failed
self.following_person = nil
return(false)
return false
end
--a function which attempts to make mobs enter
@ -42,30 +41,30 @@ mobs.enter_breed_state = function(self,clicker)
--do not breed if baby
if self.baby then
return(false)
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)
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)
return false
end
local stack = clicker:get_wielded_item()
--safety check
if not stack then
return(false)
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 item_name == self.follow then
if not minetest.is_creative_enabled(clicker:get_player_name()) then
stack:take_item()
clicker:set_wielded_item(stack)
@ -73,11 +72,11 @@ mobs.enter_breed_state = function(self,clicker)
self.breed_lookout_timer = self.breed_lookout_timer_goal
self.bred = true
mobs.play_sound_specific(self,"mobs_mc_animal_eat_generic")
return(true)
return true
end
--everything failed
return(false)
return false
end
@ -96,23 +95,23 @@ mobs.look_for_mate = function(self)
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
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)
local distance = vector.distance(pos1,pos2)
if distance <= radius then
if line_of_sight 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)
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
@ -141,9 +140,7 @@ mobs.look_for_mate = function(self)
winner_mate = mate
end
end
return(winner_mate)
return winner_mate
end
--make the baby grow up
@ -160,14 +157,14 @@ 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)
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
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()
@ -175,10 +172,8 @@ mobs.make_baby_grow_faster = function(self,clicker)
end
mobs.play_sound_specific(self,"mobs_mc_animal_eat_generic")
return(true)
return true
end
end
return(false)
return false
end

15
mods/ENTITIES/mcl_mobs/api/mob_functions/collision.lua
View File

@ -8,10 +8,8 @@ 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
@ -20,7 +18,7 @@ mobs.collision = function(self)
local collisionbox = self.object:get_properties().collisionbox
pos.y = pos.y + collisionbox[2]
local collision_boundary = collisionbox[4]
local radius = collision_boundary
@ -41,7 +39,7 @@ mobs.collision = function(self)
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 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
@ -52,7 +50,7 @@ mobs.collision = function(self)
end
local pos2 = object:get_pos()
local object_collisionbox = object:get_properties().collisionbox
pos2.y = pos2.y + object_collisionbox[2]
@ -74,7 +72,7 @@ mobs.collision = function(self)
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
@ -84,7 +82,7 @@ mobs.collision = function(self)
end
local velocity = dir
--0.5 is the max force multiplier
local force = 0.5 - (0.5 * distance / (collision_boundary + object_collision_boundary))
@ -104,11 +102,9 @@ mobs.collision = function(self)
end
end
end
self.object:add_velocity(vel1)
object:add_velocity(vel2)
end
end
end
end
@ -116,7 +112,6 @@ 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}

16
mods/ENTITIES/mcl_mobs/api/mob_functions/death_logic.lua
View File

@ -1,5 +1,5 @@
local minetest_add_item = minetest.add_item
local minetest_sound_play = minetest.sound_play
--local minetest_sound_play = minetest.sound_play
local math_pi = math.pi
local math_random = math.random
@ -19,7 +19,7 @@ local item_drop = function(self, cooked, looting_level)
return
end
local obj, item, num
local obj, item
local pos = self.object:get_pos()
self.drops = self.drops or {} -- nil check
@ -56,8 +56,11 @@ local item_drop = function(self, cooked, looting_level)
-- cook items when true
if cooked then
local output = minetest_get_craft_result({
method = "cooking", width = 1, items = {item}})
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()
@ -117,15 +120,10 @@ mobs.death_logic = function(self, dtime)
--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_experience(self.object:get_pos(), math_random(self.xp_min, self.xp_max))
self.object:remove()
return
end

36
mods/ENTITIES/mcl_mobs/api/mob_functions/environment.lua
View File

@ -1,5 +1,5 @@
local minetest_line_of_sight = minetest.line_of_sight
local minetest_dir_to_yaw = minetest.dir_to_yaw
--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
@ -18,19 +18,16 @@ local table_copy = table.copy
local math_abs = math.abs
-- default function when mobs are blown up with TNT
local do_tnt = function(obj, damage)
--[[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
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
@ -49,7 +46,7 @@ mobs.detect_closest_player_within_radius = function(self, line_of_sight, radius,
--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(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
@ -79,8 +76,7 @@ mobs.detect_closest_player_within_radius = function(self, line_of_sight, radius,
winner_player = player
end
end
return(winner_player)
return winner_player
end
@ -107,14 +103,13 @@ mobs.jump_check = function(self,dtime)
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
return 1
elseif green_flag_1 and not green_flag_2 then
--wall in front of mob
return(2)
return 2
end
--nothing to jump over
return(0)
return 0
end
-- a helper function to quickly turn neutral passive mobs hostile
@ -180,15 +175,10 @@ 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
within_limits = function(pos, radius)
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
end
end
return pos
@ -231,12 +221,12 @@ mobs.check_for_player_within_area = function(self, radius)
local distance = vector_distance(pos1,pos2)
if distance < radius then
--found a player
return(true)
return true
end
end
end
--did not find a player
return(false)
return false
end
@ -244,7 +234,7 @@ end
mobs.get_2d_distance = function(pos1,pos2)
pos1.y = 0
pos2.y = 0
return(vector_distance(pos1, pos2))
return vector_distance(pos1, pos2)
end
-- fall damage onto solid ground

178
mods/ENTITIES/mcl_mobs/api/mob_functions/head_logic.lua
View File

@ -1,112 +1,98 @@
local vector_new = vector.new
local math = math
local vector = vector
--converts yaw to degrees
local degrees = function(yaw)
return(yaw*180.0/math.pi)
return yaw*180.0/math.pi
end
mobs.do_head_logic = function(self,dtime)
local player = minetest.get_player_by_name("singleplayer")
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 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
local pos = self.object:get_pos()
--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
local body_yaw = self.object:get_yaw()
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
local body_dir = minetest.yaw_to_dir(body_yaw)
if self.head_pitch_modifier then
head_pitch = head_pitch + self.head_pitch_modifier
end
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
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])
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

51
mods/ENTITIES/mcl_mobs/api/mob_functions/interaction.lua
View File

@ -2,22 +2,19 @@ local minetest_after = minetest.after
local minetest_sound_play = minetest.sound_play
local minetest_dir_to_yaw = minetest.dir_to_yaw
local math_floor = math.floor
local math_min = math.min
local math_random = math.random
local vector_direction = vector.direction
local vector_multiply = vector.multiply
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 on_rightclick_prefix = function(self, clicker)
local function on_rightclick_prefix(self, clicker)
local item = clicker:get_wielded_item()
-- Name mob with nametag
@ -60,7 +57,6 @@ 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
@ -94,14 +90,13 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
pos2.y = 0
local dir = vector_direction(pos2,pos1)
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
@ -113,23 +108,20 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
--don't do damage until pause timer resets
if self.pause_timer > 0 then
return
end
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
--local punch_interval = 1.4
-- exhaust attacker
if mod_hunger and is_player then
@ -139,7 +131,6 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
-- calculate mob damage
local damage = 0
local armor = self.object:get_armor_groups() or {}
local tmp
--calculate damage groups
for group,_ in pairs( (tool_capabilities.damage_groups or {}) ) do
@ -163,13 +154,13 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
-- healing
if damage <= -1 then
self.health = self.health - math_floor(damage)
self.health = self.health - math.floor(damage)
return
end
if tool_capabilities then
punch_interval = tool_capabilities.full_punch_interval or 1.4
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)
@ -183,7 +174,7 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
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)
local wear = math.floor(65535/tool_capabilities.punch_attack_uses)
weapon:add_wear(wear)
hitter:set_wielded_item(weapon)
end
@ -224,7 +215,7 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
-- knock back effect
local velocity = self.object:get_velocity()
--2d direction
local pos1 = self.object:get_pos()
pos1.y = 0
@ -240,9 +231,8 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
up = 0
end
--0.75 for perfect distance to not be too easy, and not be too hard
local multiplier = 0.75
local multiplier = 0.75
-- check if tool already has specific knockback value
local knockback_enchant = mcl_enchanting.get_enchantment(hitter:get_wielded_item(), "knockback")
@ -254,21 +244,16 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
--it's coming for you
if self.hostile then
multiplier = multiplier + 2
end
dir = vector_multiply(dir,multiplier)
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
@ -278,7 +263,7 @@ mobs.shoot_projectile = function(self)
pos2.y = pos2.y + self.attacking:get_properties().eye_height
--get direction
local dir = vector_direction(pos1,pos2)
local dir = vector.direction(pos1,pos2)
--call internal shoot_arrow function
self.shoot_arrow(self,pos1,dir)

12
mods/ENTITIES/mcl_mobs/api/mob_functions/mob_effects.lua
View File

@ -1,9 +1,8 @@
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 yaw = self.object:get_yaw()
local collisionbox = self.object:get_properties().collisionbox
local min, max
@ -33,7 +32,7 @@ end
mobs.critical_effect = function(self)
local pos = self.object:get_pos()
local yaw = self.object:get_yaw()
--local yaw = self.object:get_yaw()
local collisionbox = self.object:get_properties().collisionbox
local min, max
@ -62,9 +61,8 @@ end
--when feeding a mob
mobs.feed_effect = function(self)
local pos = self.object:get_pos()
local yaw = self.object:get_yaw()
--local yaw = self.object:get_yaw()
local collisionbox = self.object:get_properties().collisionbox
local min, max
@ -94,7 +92,7 @@ end
--hearts when tamed
mobs.tamed_effect = function(self)
local pos = self.object:get_pos()
local yaw = self.object:get_yaw()
--local yaw = self.object:get_yaw()
local collisionbox = self.object:get_properties().collisionbox
local min, max
@ -124,7 +122,7 @@ end
--hearts when breeding
mobs.breeding_effect = function(self)
local pos = self.object:get_pos()
local yaw = self.object:get_yaw()
--local yaw = self.object:get_yaw()
local collisionbox = self.object:get_properties().collisionbox
local min, max

138
mods/ENTITIES/mcl_mobs/api/mob_functions/movement.lua
View File

@ -1,16 +1,10 @@
local math_pi = math.pi
local math_sin = math.sin
local math_cos = math.cos
local math_random = math.random
local HALF_PI = math_pi / 2
local DOUBLE_PI = math_pi * 2
-- localize math functions
local math = math
local HALF_PI = math.pi / 2
local DOUBLE_PI = math.pi * 2
-- localize vector functions
local vector_new = vector.new
local vector_length = vector.length
local vector_multiply = vector.multiply
local vector_distance = vector.distance
local vector_normalize = vector.normalize
local vector = vector
local minetest_yaw_to_dir = minetest.yaw_to_dir
local minetest_dir_to_yaw = minetest.dir_to_yaw
@ -19,18 +13,17 @@ 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)
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
if vector.length(new_velocity_addition) >= 0.0001 then
self.object:add_velocity(new_velocity_addition)
end
end
@ -38,8 +31,11 @@ end
--this is a generic float function
mobs.float = function(self)
if self.object:get_acceleration().y ~= 0 then
self.object:set_acceleration(vector_new(0,0,0))
local acceleration = self.object:get_acceleration()
if acceleration and acceleration.y ~= 0 then
self.object:set_acceleration(vector.new(0,0,0))
else
return
end
local current_velocity = self.object:get_velocity()
@ -56,7 +52,7 @@ mobs.float = function(self)
new_velocity_addition.z = 0
--smooths out mobs a bit
if vector_length(new_velocity_addition) >= 0.0001 then
if vector.length(new_velocity_addition) >= 0.0001 then
self.object:add_velocity(new_velocity_addition)
end
end
@ -78,7 +74,7 @@ mobs.climb = function(self)
new_velocity_addition.z = 0
--smooths out mobs a bit
if vector_length(new_velocity_addition) >= 0.0001 then
if vector.length(new_velocity_addition) >= 0.0001 then
self.object:add_velocity(new_velocity_addition)
end
end
@ -86,10 +82,10 @@ end
--[[
_ _
_ _
| | | |
| | __ _ _ __ __| |
| | / _` | '_ \ / _` |
| | / _` | '_ \ / _` |
| |___| (_| | | | | (_| |
\_____/\__,_|_| |_|\__,_|
]]
@ -100,28 +96,28 @@ end
--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),
x = (math.sin(yaw) * -v),
y = 0,
z = (math_cos(yaw) * v),
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)))
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
if vector.length(new_velocity_addition) >= 0.0001 then
self.object:add_velocity(new_velocity_addition)
end
end
@ -136,7 +132,7 @@ mobs.get_velocity = function(self)
v.y = 0
if v then
return vector_length(v)
return vector.length(v)
end
return 0
@ -152,7 +148,7 @@ mobs.jump = function(self, velocity)
--fallback velocity to allow modularity
velocity = velocity or DEFAULT_JUMP_HEIGHT
self.object:add_velocity(vector_new(0,velocity,0))
self.object:add_velocity(vector.new(0,velocity,0))
end
--make mobs fall slowly
@ -172,15 +168,15 @@ mobs.mob_fall_slow = function(self)
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)))
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
if vector.length(new_velocity_addition) >= 0.0001 then
self.object:add_velocity(new_velocity_addition)
end
@ -188,10 +184,10 @@ end
--[[
_____ _
/ ___| (_)
\ `--.__ ___ _ __ ___
`--. \ \ /\ / / | '_ ` _ \
_____ _
/ ___| (_)
\ `--.__ ___ _ __ ___
`--. \ \ /\ / / | '_ ` _ \
/\__/ /\ V V /| | | | | | |
\____/ \_/\_/ |_|_| |_| |_|
]]--
@ -212,16 +208,16 @@ mobs.flop = function(self, velocity)
velocity = velocity or DEFAULT_JUMP_HEIGHT
--create a random direction (2d yaw)
local dir = DOUBLE_PI * math_random()
local dir = DOUBLE_PI * math.random()
--create a random force value
local force = math_random(0,3) + math_random()
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)
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
final_additional_force.y = velocity
self.object:add_velocity(final_additional_force)
@ -235,7 +231,7 @@ end
--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)
@ -246,33 +242,33 @@ mobs.set_swim_velocity = function(self, v)
local current_velocity = self.object:get_velocity()
local goal_velocity = {
x = (math_sin(yaw) * -v),
x = (math.sin(yaw) * -v),
y = pitch,
z = (math_cos(yaw) * v),
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)))
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
if vector.length(new_velocity_addition) >= 0.0001 then
self.object:add_velocity(new_velocity_addition)
end
end
--[[
______ _
| ___| |
| |_ | |_ _
______ _
| ___| |
| |_ | |_ _
| _| | | | | |
| | | | |_| |
\_| |_|\__, |
__/ |
|___/
|___/
]]--
-- move mob in facing direction
@ -280,7 +276,7 @@ ______ _
--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)
@ -291,20 +287,20 @@ mobs.set_fly_velocity = function(self, v)
local current_velocity = self.object:get_velocity()
local goal_velocity = {
x = (math_sin(yaw) * -v),
x = (math.sin(yaw) * -v),
y = pitch,
z = (math_cos(yaw) * v),
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)))
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
if vector.length(new_velocity_addition) >= 0.0001 then
self.object:add_velocity(new_velocity_addition)
end
end
@ -316,7 +312,7 @@ mobs.calculate_pitch = function(pos1, pos2)
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)
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
@ -332,14 +328,14 @@ end
--[[
___
|_ |
| |_ _ _ __ ___ _ __
| | | | | '_ ` _ \| '_ \
___
|_ |
| |_ _ _ __ ___ _ __
| | | | | '_ ` _ \| '_ \
/\__/ / |_| | | | | | | |_) |
\____/ \__,_|_| |_| |_| .__/
| |
|_|
\____/ \__,_|_| |_| |_| .__/
| |
|_|
]]--
--special mob jump movement
@ -353,27 +349,27 @@ mobs.jump_move = function(self, velocity)
mobs.set_velocity(self,0)
--fallback velocity to allow modularity
jump_height = DEFAULT_JUMP_HEIGHT
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),
x = (math.sin(yaw) * -velocity),
y = jump_height,
z = (math_cos(yaw) * velocity),
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)))
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
if vector.length(new_velocity_addition) >= 0.0001 then
self.object:add_velocity(new_velocity_addition)
end
end
@ -388,4 +384,4 @@ mobs.swap_auto_step_height_adjust = function(self)
elseif y_vel ~= 0 and self.stepheight ~= 0 then
self.stepheight = 0
end
end
end

3
mods/ENTITIES/mcl_mobs/api/mob_functions/projectile_handling.lua
View File

@ -36,9 +36,8 @@ mobs.shoot_projectile_handling = function(arrow_item, pos, dir, yaw, shooter, po
le._collectable = collectable
--play custom shoot sound
if shooter ~= nil and shooter.shoot_sound then
if shooter and shooter.shoot_sound then
minetest.sound_play(shooter.shoot_sound, {pos=pos, max_hear_distance=16}, true)
end
return obj
end

10
mods/ENTITIES/mcl_mobs/api/mob_functions/set_up.lua
View File

@ -1,10 +1,12 @@
local math_random = math.random
local minetest_settings = minetest.settings
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
@ -142,8 +144,6 @@ mobs.mob_activate = function(self, staticdata, def, dtime)
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
@ -185,7 +185,6 @@ mobs.mob_activate = function(self, staticdata, def, dtime)
self.opinion_sound_cooloff = 0 -- used to prevent sound spam of particular sound types
self.texture_mods = {}
self.v_start = false
self.timer = 0
@ -199,7 +198,6 @@ mobs.mob_activate = function(self, staticdata, def, dtime)
else
self.object:set_texture_mod("")
end
-- set anything changed above
self.object:set_properties(self)

34
mods/ENTITIES/mcl_mobs/api/mount.lua
View File

@ -1,8 +1,11 @@
-- lib_mount by Blert2112 (edited by TenPlus1)
local enable_crash = false
local crash_threshold = 6.5 -- ignored if enable_crash=false
--local enable_crash = false
--local crash_threshold = 6.5 -- ignored if enable_crash=false
local math = math
local vector = vector
------------------------------------------------------------------------------
@ -10,7 +13,7 @@ local crash_threshold = 6.5 -- ignored if enable_crash=false
-- Helper functions
--
local node_ok = function(pos, fallback)
--[[local function node_ok(pos, fallback)
fallback = fallback or mobs.fallback_node
@ -21,10 +24,10 @@ local node_ok = function(pos, fallback)
end
return {name = fallback}
end
end]]
local function node_is(pos)
--[[local function node_is(pos)
local node = node_ok(pos)
@ -45,7 +48,7 @@ local function node_is(pos)
end
return "other"
end
end]]
local function get_sign(i)
@ -60,13 +63,11 @@ 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)
@ -172,7 +173,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)
@ -187,13 +188,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
rot_view = math.pi/2
end
--if entity.player_rotation.y == 90 then
-- rot_view = math.pi/2
--end
local acce_y = 0
--local acce_y = 0
local velo = entity.object:get_velocity()
entity.v = get_v(velo) * get_sign(entity.v)
@ -388,7 +389,6 @@ 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

34
mods/ENTITIES/mcl_mobs/api/spawning.lua
View File

@ -5,19 +5,21 @@ 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 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 max = math.max
--local max = math.max
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
@ -167,7 +169,7 @@ Overworld regular:
-- count how many mobs are in an area
local count_mobs = function(pos)
local function count_mobs(pos)
local num = 0
for _,object in pairs(get_objects_inside_radius(pos, aoc_range)) do
if object and object:get_luaentity() and object:get_luaentity()._cmi_is_mob then
@ -242,8 +244,7 @@ function mobs:spawn_specific(name, dimension, type_of_spawning, biomes, min_ligh
end
--[[
local spawn_action
spawn_action = function(pos, node, active_object_count, active_object_count_wider, name)
local function spawn_action(pos, node, active_object_count, active_object_count_wider, name)
local orig_pos = table.copy(pos)
-- is mob actually registered?
@ -280,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 ~= nil then
if day_toggle then
local tod = (minetest.get_timeofday() or 0) * 24000
@ -370,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 ~= nil and (not minetest.registered_nodes[node_ok(pos).name].walkable) then
if ent.spawn_small_alternative 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
@ -486,7 +487,8 @@ local axis
local inner = 15
local outer = 64
local int = {-1,1}
local position_calculation = function(pos)
local function position_calculation(pos)
pos = vector_floor(pos)
@ -501,7 +503,7 @@ local position_calculation = function(pos)
pos.z = pos.z + math_random(inner,outer)*int[math_random(1,2)]
pos.x = pos.x + math_random(-outer,outer)
end
return(pos)
return pos
end
--[[
@ -540,7 +542,7 @@ if mobs_spawn then
timer = timer + dtime
if timer >= 10 then
timer = 0
for _,player in pairs(minetest.get_connected_players()) do
for _,player in pairs(get_connected_players()) do
-- after this line each "break" means "continue"
local do_mob_spawning = true
repeat
@ -548,15 +550,15 @@ if mobs_spawn then
--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
break -- ignore void and unloaded area
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
for i = 1, math_random(1,4) do
-- after this line each "break" means "continue"
local do_mob_algorithm = true
repeat
@ -573,10 +575,10 @@ if mobs_spawn then
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
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
@ -606,7 +608,7 @@ if mobs_spawn then
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)

2
mods/ENTITIES/mcl_mobs/crafts.lua
View File

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

11
mods/ENTITIES/mcl_mobs/locale/mcl_mobs.pl.tr Normal file
View File

@ -0,0 +1,11 @@
# 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

2
mods/ENTITIES/mcl_mobs/mod.conf
View File

@ -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, invisibility, cmi, doc_identifier, mcl_armor, mcl_portals, mcl_experience
optional_depends = mcl_weather, mcl_explosions, mcl_hunger, mcl_worlds, cmi, doc_identifier, mcl_armor, mcl_portals, mcl_experience

25
mods/ENTITIES/mcl_paintings/init.lua
View File

@ -1,12 +1,15 @@
mcl_paintings = {}
dofile(minetest.get_modpath(minetest.get_current_modname()).."/paintings.lua")
local modname = minetest.get_current_modname()
dofile(minetest.get_modpath(modname).."/paintings.lua")
local S = minetest.get_translator("mcl_paintings")
local S = minetest.get_translator(modname)
local math = math
local wood = "[combine:16x16:-192,0=mcl_paintings_paintings.png"
local is_protected = function(pos, name)
local function is_protected(pos, name)
if minetest.is_protected(pos, name) then
minetest.record_protection_violation(pos, name)
return true
@ -17,7 +20,7 @@ end
-- Check if there's a painting for provided painting size.
-- If yes, returns the arguments.
-- If not, returns the next smaller available painting.
local shrink_painting = function(x, y)
local function shrink_painting(x, y)
if x > 4 or y > 4 then
return nil
end
@ -43,7 +46,7 @@ local shrink_painting = function(x, y)
end
end
local get_painting = function(x, y, motive)
local function get_painting(x, y, motive)
local painting = mcl_paintings.paintings[y] and mcl_paintings.paintings[y][x] and mcl_paintings.paintings[y][x][motive]
if not painting then
return nil
@ -53,7 +56,7 @@ local get_painting = function(x, y, motive)
return "[combine:"..sx.."x"..sy..":"..px..","..py.."=mcl_paintings_paintings.png"
end
local get_random_painting = function(x, y)
local function get_random_painting(x, y)
if not mcl_paintings.paintings[y] or not mcl_paintings.paintings[y][x] then
return nil
end
@ -65,7 +68,7 @@ local get_random_painting = function(x, y)
return get_painting(x, y, r), r
end
local size_to_minmax = function(size)
--[[local function size_to_minmax(size)
local min, max
if size == 2 then
min = -0.5
@ -81,13 +84,13 @@ local size_to_minmax = function(size)
max = 0.5
end
return min, max
end
end]]
local size_to_minmax_entity = function(size)
local function size_to_minmax_entity(size)
return -size/2, size/2
end
local set_entity = function(object)
local function set_entity(object)
local ent = object:get_luaentity()
local wallm = ent._facing
local xsize = ent._xsize
@ -169,7 +172,7 @@ minetest.register_entity("mcl_paintings:painting", {
on_punch = function(self, puncher, time_from_last_punch, tool_capabilities, dir, damage)
-- Drop as item on punch
if puncher and puncher:is_player() then
kname = puncher:get_player_name()
local kname = puncher:get_player_name()
local pos = self._pos
if not pos then
pos = self.object:get_pos()

2
mods/ENTITIES/mcl_paintings/locale/mcl_paintings.pl.tr Normal file
View File

@ -0,0 +1,2 @@
# textdomain:mcl_paintings
Painting=Obraz

6
mods/ENTITIES/mcl_paintings/paintings.lua
View File

@ -3,7 +3,7 @@ local TS = 16 -- texture size
mcl_paintings.paintings = {
[1] = {
[1] = {
{ cx = 0, cy = 0 },
{ cx = 0, cy = 0 },
{ cx = TS, cy = 0 },
{ cx = 2*TS, cy = 0 },
{ cx = 3*TS, cy = 0 },
@ -26,7 +26,7 @@ mcl_paintings.paintings = {
{ cx = 0, cy = 4*TS },
{ cx = TS, cy = 4*TS },
},
[2] = {
[2] = {
{ cx = 0, cy = 8*TS },
{ cx = 2*TS, cy = 8*TS },
{ cx = 4*TS, cy = 8*TS },
@ -35,7 +35,7 @@ mcl_paintings.paintings = {
{ cx = 10*TS, cy = 8*TS },
},
[3] = 2,
[4] = {
[4] = {
{ cx = 0, cy = 6*TS },
},
},

5
mods/ENTITIES/mobs_mc/0_gameconfig.lua
View File

@ -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
@ -83,7 +83,7 @@ mobs_mc.items = {
water_source = "default:water_source",
water_flowing = "default:water_flowing",
river_water_source = "default:river_water_source",
water_flowing = "default:river_water_flowing",
--water_flowing = "default:river_water_flowing",
black_dye = "dye:black",
poppy = "flowers:rose",
dandelion = "flowers:dandelion_yellow",
@ -128,7 +128,6 @@ mobs_mc.items = {
nether_portal = "nether:portal",
netherrack = "nether:rack",
nether_brick_block = "nether:brick",
-- Wool (Minecraft color scheme)
wool_white = "wool:white",

6
mods/ENTITIES/mobs_mc/1_items_default.lua
View File

@ -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("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
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',
recipe = { 'mobs_mc:blaze_powder', 'mobs_mc:blaze_rod'},
output = "mobs_mc:ender_eye",
recipe = { "mobs_mc:blaze_powder", "mobs_mc:blaze_rod"},
})
end

20
mods/ENTITIES/mobs_mc/2_throwing.lua
View File

@ -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("mobs_mc")
--local S = minetest.get_translator(minetest.get_current_modname())
--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() ~= nil then
if obj:get_luaentity() 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 mobs_shoot_egg = function (item, player, pointed_thing)
local function mobs_shoot_egg(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 mobs_shoot_snowball = function (item, player, pointed_thing)
local function mobs_shoot_snowball(item, player, pointed_thing)
local playerpos = player:get_pos()

3
mods/ENTITIES/mobs_mc/4_heads.lua
View File

@ -3,8 +3,9 @@
-- 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 = minetest.get_translator("mobs_mc")
--local S = local S = minetest.get_translator(minetest.get_current_modname())
-- Heads system

2
mods/ENTITIES/mobs_mc/agent.lua
View File

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

2
mods/ENTITIES/mobs_mc/bat.lua
View File

@ -1,6 +1,6 @@
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
mobs:register_mob("mobs_mc:bat", {
description = S("Bat"),

4
mods/ENTITIES/mobs_mc/blaze.lua
View File

@ -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("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### BLAZE
@ -20,7 +20,7 @@ mobs:register_mob("mobs_mc:blaze", {
xp_max = 10,
tilt_fly = false,
hostile = true,
rotate = 270,
--rotate = 270,
collisionbox = {-0.3, -0.01, -0.3, 0.3, 1.79, 0.3},
rotate = -180,
visual = "mesh",

2
mods/ENTITIES/mobs_mc/chicken.lua
View File

@ -1,6 +1,6 @@
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### CHICKEN

6
mods/ENTITIES/mobs_mc/cow+mooshroom.lua
View File

@ -1,6 +1,6 @@
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
local cow_def = {
description = S("Cow"),
@ -89,7 +89,7 @@ local cow_def = {
--head code
has_head = true,
head_bone = "head",
swap_y_with_x = false,
reverse_head_yaw = false,
@ -168,7 +168,7 @@ mooshroom_def.on_rightclick = function(self, clicker)
pos.y = pos.y + 0.5
minetest.add_item(pos, {name = mobs_mc.items.mushroom_stew})
end
end
end
end
mobs:register_mob("mobs_mc:mooshroom", mooshroom_def)

10
mods/ENTITIES/mobs_mc/creeper.lua
View File

@ -1,6 +1,6 @@
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### CREEPER
@ -72,7 +72,7 @@ mobs:register_mob("mobs_mc:creeper", {
-- 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 ~= nil then
if self._forced_explosion_countdown_timer then
return
end
local item = clicker:get_wielded_item()
@ -92,7 +92,7 @@ mobs:register_mob("mobs_mc:creeper", {
end
end,
do_custom = function(self, dtime)
if self._forced_explosion_countdown_timer ~= nil then
if self._forced_explosion_countdown_timer then
self._forced_explosion_countdown_timer = self._forced_explosion_countdown_timer - dtime
if self._forced_explosion_countdown_timer <= 0 then
mobs:boom(self, mcl_util.get_object_center(self.object), self.explosion_strength)
@ -196,7 +196,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 ~= nil then
if self._forced_explosion_countdown_timer then
return
end
local item = clicker:get_wielded_item()
@ -216,7 +216,7 @@ mobs:register_mob("mobs_mc:creeper_charged", {
end
end,
do_custom = function(self, dtime)
if self._forced_explosion_countdown_timer ~= nil then
if self._forced_explosion_countdown_timer then
self._forced_explosion_countdown_timer = self._forced_explosion_countdown_timer - dtime
if self._forced_explosion_countdown_timer <= 0 then
mobs:boom(self, mcl_util.get_object_center(self.object), self.explosion_strength)

15
mods/ENTITIES/mobs_mc/ender_dragon.lua
View File

@ -2,7 +2,7 @@
--################### ENDERDRAGON
--###################
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
mobs:register_mob("mobs_mc:enderdragon", {
description = S("Ender Dragon"),
@ -16,7 +16,7 @@ mobs:register_mob("mobs_mc:enderdragon", {
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)
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,
@ -24,7 +24,6 @@ mobs:register_mob("mobs_mc:enderdragon", {
xp_max = 500,
collisionbox = {-2, 0, -2, 2, 2, 2},
eye_height = 1,
physical = false,
visual = "mesh",
mesh = "mobs_mc_dragon.b3d",
textures = {
@ -60,8 +59,6 @@ mobs:register_mob("mobs_mc:enderdragon", {
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,
@ -114,8 +111,8 @@ mobs:register_mob("mobs_mc:enderdragon", {
fire_resistant = true,
})
local mobs_griefing = minetest.settings:get_bool("mobs_griefing") ~= false
--TODO: replace this setting by a proper gamerules system
local mobs_griefing = minetest.settings:get_bool("mobs_griefing", true)
-- dragon fireball (projectile)
mobs:register_arrow("mobs_mc:dragon_fireball", {
@ -143,7 +140,9 @@ mobs:register_arrow("mobs_mc:dragon_fireball", {
-- node hit, explode
hit_node = function(self, pos, node)
--mobs:boom(self, pos, 2)
mcl_explosions.explode(self.object:get_pos(), 2,{ drop_chance = 1.0 })
if mobs_griefing then
mcl_explosions.explode(self.object:get_pos(), 2, { drop_chance = 1.0 })
end
end
})

28
mods/ENTITIES/mobs_mc/enderman.lua
View File

@ -24,9 +24,11 @@
-- added rain damage.
-- fixed the grass_with_dirt issue.
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
local telesound = function(pos, is_source)
local vector = vector
local function telesound(pos, is_source)
local snd
if is_source then
snd = "mobs_mc_enderman_teleport_src"
@ -302,7 +304,7 @@ mobs:register_mob("mobs_mc:enderman", {
if self.attacking then
local target = self.attacking
local pos = target:get_pos()
if pos ~= nil then
if pos then
if vector.distance(self.object:get_pos(), target:get_pos()) > 10 then
self:teleport(target)
end
@ -318,12 +320,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
else
if not obj:is_player() then
local lua = obj:get_luaentity()
if lua then
if lua.name == "mcl_bows:arrow_entity" or lua.name == "mcl_throwing:snowball_entity" then
@ -341,8 +343,8 @@ mobs:register_mob("mobs_mc:enderman", {
-- self:teleport(nil)
-- self.state = ""
--else
if self.attack ~= nil and not minetest.settings:get_bool("creative_mode") then
self.state = 'attack'
if self.attack and not minetest.settings:get_bool("creative_mode") then
self.state = "attack"
end
--end
end
@ -459,7 +461,7 @@ mobs:register_mob("mobs_mc:enderman", {
end
end
end
elseif self._taken_node ~= nil and self._taken_node ~= "" and self._take_place_timer >= self._next_take_place_time then
elseif self._taken_node 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)
@ -485,12 +487,12 @@ mobs:register_mob("mobs_mc:enderman", {
end
end,
do_teleport = function(self, target)
if target ~= nil then
if target 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
if nodes then
if #nodes > 0 then
-- Up to 64 attempts to teleport
for n=1, math.min(64, #nodes) do
@ -525,7 +527,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 ~= nil then
if nodes 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
@ -557,13 +559,13 @@ mobs:register_mob("mobs_mc:enderman", {
end,
on_die = function(self, pos)
-- Drop carried node on death
if self._taken_node ~= nil and self._taken_node ~= "" then
if self._taken_node 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 ~= nil then
if hitter ~= self.object and hitter then
--if (minetest.get_timeofday() * 24000) > 5001 and (minetest.get_timeofday() * 24000) < 19000 then
-- self:teleport(nil)
--else

2
mods/ENTITIES/mobs_mc/endermite.lua
View File

@ -2,7 +2,7 @@
--################### ENDERMITE
--###################
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
mobs:register_mob("mobs_mc:endermite", {
description = S("Endermite"),

2
mods/ENTITIES/mobs_mc/ghast.lua
View File

@ -3,7 +3,7 @@
--made for MC like Survival game
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### GHAST

5
mods/ENTITIES/mobs_mc/guardian.lua
View File

@ -2,7 +2,7 @@
--################### GUARDIAN
--###################
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
mobs:register_mob("mobs_mc:guardian", {
description = S("Guardian"),
@ -13,7 +13,7 @@ mobs:register_mob("mobs_mc:guardian", {
xp_min = 10,
xp_max = 10,
breath_max = -1,
passive = false,
passive = false,
attack_type = "punch",
pathfinding = 1,
view_range = 16,
@ -94,7 +94,6 @@ 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

5
mods/ENTITIES/mobs_mc/guardian_elder.lua
View File

@ -4,7 +4,7 @@
--################### GUARDIAN
--###################
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
mobs:register_mob("mobs_mc:guardian_elder", {
description = S("Elder Guardian"),
@ -15,7 +15,7 @@ mobs:register_mob("mobs_mc:guardian_elder", {
xp_min = 10,
xp_max = 10,
breath_max = -1,
passive = false,
passive = false,
attack_type = "punch",
pathfinding = 1,
view_range = 16,
@ -104,7 +104,6 @@ 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

8
mods/ENTITIES/mobs_mc/horse.lua
View File

@ -3,7 +3,7 @@
--made for MC like Survival game
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### 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
@ -314,7 +314,7 @@ local horse = {
-- 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

2
mods/ENTITIES/mobs_mc/init.lua
View File

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

8
mods/ENTITIES/mobs_mc/iron_golem.lua
View File

@ -3,7 +3,7 @@
--made for MC like Survival game
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### IRON GOLEM
@ -18,7 +18,7 @@ mobs:register_mob("mobs_mc:iron_golem", {
passive = true,
rotate = 270,
hp_min = 100,
hp_max = 100,
hp_max = 100,
protect = true,
neutral = true,
breath_max = -1,
@ -158,11 +158,11 @@ mobs_mc.tools.check_iron_golem_summon = function(pos)
if ok then
-- Remove the nodes
minetest.remove_node(pos)
core.check_for_falling(pos)
minetest.check_for_falling(pos)
for i=1, 4 do
local cpos = vector.add(pos, checks[c][i])
minetest.remove_node(cpos)
core.check_for_falling(cpos)
minetest.check_for_falling(cpos)
end
-- Summon iron golem
local place

14
mods/ENTITIES/mobs_mc/llama.lua
View File

@ -1,4 +1,4 @@
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### LLAMA
@ -35,7 +35,7 @@ mobs:register_mob("mobs_mc:llama", {
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)
mobs.shoot_projectile_handling("mobs_mc:spit", pos, dir, self.object:get_yaw(), self.object, nil, dmg)
end,
hp_min = 15,
hp_max = 30,
@ -146,7 +146,7 @@ mobs:register_mob("mobs_mc:llama", {
self.tamed = true
self.owner = clicker:get_player_name()
return
end
end
--ignore other logic
--make baby grow faster
@ -307,19 +307,19 @@ mobs:register_arrow("mobs_mc:spit", {
tail_distance_divider = 4,
hit_player = function(self, player)
if rawget(_G, "armor") and armor.last_damage_types then
--[[if rawget(_G, "armor") and armor.last_damage_types then
armor.last_damage_types[player:get_player_name()] = "spit"
end
end]]
player:punch(self.object, 1.0, {
full_punch_interval = 1.0,
damage_groups = {fleshy = self._damage},
}, nil)
end,
hit_mob = function(self, mob)
hit_mob = function(self, mob)
mob:punch(self.object, 1.0, {
full_punch_interval = 1.0,
damage_groups = {fleshy = _damage},
damage_groups = {fleshy = self._damage},
}, nil)
end,

75
mods/ENTITIES/mobs_mc/locale/mobs_mc.pl.tr Normal file
View File

@ -0,0 +1,75 @@
# 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

4
mods/ENTITIES/mobs_mc/ocelot.lua
View File

@ -3,7 +3,7 @@
--made for MC like Survival game
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### OCELOT AND CAT
@ -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

4
mods/ENTITIES/mobs_mc/parrot.lua
View File

@ -3,7 +3,7 @@
--made for MC like Survival game
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### PARROT
@ -44,7 +44,7 @@ mobs:register_mob("mobs_mc:parrot", {
max = 2,
looting = "common",},
},
animation = {
animation = {
stand_speed = 50,
walk_speed = 50,
fly_speed = 50,

6
mods/ENTITIES/mobs_mc/pig.lua
View File

@ -1,6 +1,6 @@
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
mobs:register_mob("mobs_mc:pig", {
description = S("Pig"),
@ -130,7 +130,7 @@ 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 +163,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})

2
mods/ENTITIES/mobs_mc/polar_bear.lua
View File

@ -1,6 +1,6 @@
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### POLARBEAR

2
mods/ENTITIES/mobs_mc/rabbit.lua
View File

@ -1,6 +1,6 @@
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
local rabbit = {
description = S("Rabbit"),

9
mods/ENTITIES/mobs_mc/sheep.lua
View File

@ -1,6 +1,6 @@
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### SHEEP
@ -38,7 +38,7 @@ local rainbow_colors = {
"unicolor_red_violet"
}
if minetest.get_modpath("mcl_wool") ~= nil then
if minetest.get_modpath("mcl_wool") then
colors["unicolor_light_blue"] = { mobs_mc.items.wool_light_blue, "#5050FFD0" }
end
@ -79,11 +79,11 @@ mobs:register_mob("mobs_mc:sheep", {
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,
@ -150,7 +150,6 @@ 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"

2
mods/ENTITIES/mobs_mc/shulker.lua
View File

@ -3,7 +3,7 @@
--made for MC like Survival game
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### SHULKER

13
mods/ENTITIES/mobs_mc/silverfish.lua
View File

@ -2,7 +2,7 @@
--################### SILVERFISH
--###################
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
mobs:register_mob("mobs_mc:silverfish", {
description = S("Silverfish"),
@ -46,7 +46,6 @@ mobs:register_mob("mobs_mc:silverfish", {
view_range = 16,
attack_type = "punch",
damage = 1,
reach = 1,
})
mobs:register_egg("mobs_mc:silverfish", S("Silverfish"), "mobs_mc_spawn_icon_silverfish.png", 0)
@ -62,7 +61,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,
@ -73,7 +72,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,
})
@ -83,7 +82,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,
})
@ -95,7 +94,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,
})
@ -105,7 +104,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,
})

10
mods/ENTITIES/mobs_mc/skeleton+stray.lua
View File

@ -3,8 +3,8 @@
--made for MC like Survival game
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local mod_bows = minetest.get_modpath("mcl_bows") ~= nil
local S = minetest.get_translator(minetest.get_current_modname())
local mod_bows = minetest.get_modpath("mcl_bows")
--###################
--################### SKELETON
@ -31,12 +31,8 @@ local skeleton = {
group_attack = true,
visual = "mesh",
mesh = "mobs_mc_skeleton.b3d",
textures = { {
"mcl_bows_bow_0.png", -- bow
"mobs_mc_skeleton.png", -- skeleton
} },
--head code
--head code
has_head = false,
head_bone = "head",

2
mods/ENTITIES/mobs_mc/skeleton_wither.lua
View File

@ -3,7 +3,7 @@
--made for MC like Survival game
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### WITHER SKELETON

6
mods/ENTITIES/mobs_mc/slime+magma_cube.lua
View File

@ -1,6 +1,6 @@
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
-- Returns a function that spawns children in a circle around pos.
-- To be used as on_die callback.
@ -41,10 +41,10 @@ local spawn_children_on_die = function(child_mob, children_count, spawn_distance
-- 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 ~= nil then
if le then
le.state = "attack"
le.attack = enemy
end

10
mods/ENTITIES/mobs_mc/snowman.lua
View File

@ -3,12 +3,12 @@
--made for MC like Survival game
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
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") ~= nil
local mod_throwing = minetest.get_modpath("mcl_throwing")
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)
core.check_for_falling(pos)
core.check_for_falling(b1)
core.check_for_falling(b2)
minetest.check_for_falling(pos)
minetest.check_for_falling(b1)
minetest.check_for_falling(b2)
local obj = minetest.add_entity(place, "mobs_mc:snowman")
if obj then
summon_particles(obj)

2
mods/ENTITIES/mobs_mc/spider.lua
View File

@ -3,7 +3,7 @@
--made for MC like Survival game
--License for code WTFPL and otherwise stated in readmes
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
--###################
--################### SPIDER

2
mods/ENTITIES/mobs_mc/squid.lua
View File

@ -4,7 +4,7 @@
--################### SQUID
--###################
local S = minetest.get_translator("mobs_mc")
local S = minetest.get_translator(minetest.get_current_modname())
mobs:register_mob("mobs_mc:squid", {
description = S("Squid"),

Some files were not shown because too many files have changed in this diff Show More