457 lines
12 KiB
Lua
457 lines
12 KiB
Lua
loud_walking = {}
|
|
loud_walking.version = "1.0"
|
|
loud_walking.time_factor = 10 -- affects growth abms
|
|
loud_walking.light_max = 8 -- light intensity for mushroom growth
|
|
loud_walking.path = minetest.get_modpath(minetest.get_current_modname())
|
|
loud_walking.world = minetest.get_worldpath()
|
|
|
|
loud_walking.pod_size_x = minetest.setting_get('loud_walking_pod_size_x')
|
|
if loud_walking.pod_size_x == nil then
|
|
loud_walking.pod_size_x = 100
|
|
end
|
|
|
|
loud_walking.pod_size_y = minetest.setting_get('loud_walking_pod_size_y')
|
|
if loud_walking.pod_size_y == nil then
|
|
loud_walking.pod_size_y = 100
|
|
end
|
|
|
|
loud_walking.pod_size_z = minetest.setting_get('loud_walking_pod_size_z')
|
|
if loud_walking.pod_size_z == nil then
|
|
loud_walking.pod_size_z = 100
|
|
end
|
|
|
|
loud_walking.bridge_size = minetest.setting_get('loud_walking_bridge_size')
|
|
if loud_walking.bridge_size == nil then
|
|
loud_walking.bridge_size = 50
|
|
end
|
|
|
|
loud_walking.vertical_sep = minetest.setting_get('loud_walking_vertical_sep')
|
|
if loud_walking.vertical_sep == nil then
|
|
loud_walking.vertical_sep = 300
|
|
end
|
|
|
|
loud_walking.breakable_wood = minetest.setting_getbool('loud_walking_breakable_wood')
|
|
if loud_walking.breakable_wood == nil then
|
|
loud_walking.breakable_wood = false
|
|
end
|
|
|
|
local armor_mod = minetest.get_modpath("3d_armor") and armor and armor.set_player_armor
|
|
|
|
loud_walking.elixir_armor = minetest.setting_getbool('loud_walking_use_armor_elixirs')
|
|
if loud_walking.elixir_armor == nil then
|
|
loud_walking.elixir_armor = true
|
|
end
|
|
|
|
loud_walking.expire_elixir_on_death = minetest.setting_getbool('loud_walking_expire_elixir_on_death')
|
|
if loud_walking.expire_elixir_on_death == nil then
|
|
loud_walking.expire_elixir_on_death = true
|
|
end
|
|
|
|
loud_walking.breakable_wood = minetest.setting_getbool('loud_walking_breakable_wood')
|
|
if loud_walking.breakable_wood == nil then
|
|
loud_walking.breakable_wood = false
|
|
end
|
|
|
|
loud_walking.starting_equipment = minetest.setting_getbool('loud_walking_starting_equipment')
|
|
if loud_walking.starting_equipment == nil then
|
|
loud_walking.starting_equipment = false
|
|
end
|
|
|
|
loud_walking.quick_leaf_decay = minetest.setting_getbool('loud_walking_quick_leaf_decay')
|
|
if loud_walking.quick_leaf_decay == nil then
|
|
loud_walking.quick_leaf_decay = false
|
|
end
|
|
|
|
loud_walking.goblin_rarity = minetest.setting_get('loud_walking_goblin_rarity')
|
|
if loud_walking.goblin_rarity == nil then
|
|
loud_walking.goblin_rarity = 9
|
|
end
|
|
loud_walking.goblin_rarity = 11 - loud_walking.goblin_rarity
|
|
print(loud_walking.goblin_rarity)
|
|
|
|
loud_walking.DEBUG = false -- for maintenance only
|
|
|
|
|
|
local inp = io.open(loud_walking.world..'/loud_walking_data.txt','r')
|
|
if inp then
|
|
local d = inp:read('*a')
|
|
loud_walking.db = minetest.deserialize(d)
|
|
inp:close()
|
|
end
|
|
if not loud_walking.db then
|
|
loud_walking.db = {}
|
|
end
|
|
for _, i in pairs({'teleport_data', 'hunger', 'status', 'translocators'}) do
|
|
if not loud_walking.db[i] then
|
|
loud_walking.db[i] = {}
|
|
end
|
|
end
|
|
|
|
|
|
if not minetest.set_mapgen_setting then
|
|
return
|
|
end
|
|
|
|
minetest.register_on_mapgen_init(function(mgparams)
|
|
minetest.set_mapgen_params({mgname="singlenode", water_level=-31000, flags="nolight"})
|
|
end)
|
|
|
|
|
|
-- Modify a node to add a group
|
|
function minetest.add_group(node, groups)
|
|
local def = minetest.registered_items[node]
|
|
if not (node and def and groups and type(groups) == 'table') then
|
|
return false
|
|
end
|
|
local def_groups = def.groups or {}
|
|
for group, value in pairs(groups) do
|
|
if value ~= 0 then
|
|
def_groups[group] = value
|
|
else
|
|
def_groups[group] = nil
|
|
end
|
|
end
|
|
minetest.override_item(node, {groups = def_groups})
|
|
return true
|
|
end
|
|
|
|
function loud_walking.clone_node(name)
|
|
if not (name and type(name) == 'string') then
|
|
return
|
|
end
|
|
|
|
local node = minetest.registered_nodes[name]
|
|
local node2 = table.copy(node)
|
|
return node2
|
|
end
|
|
|
|
|
|
loud_walking.registered_status = {}
|
|
function loud_walking.register_status(def)
|
|
if not (def and loud_walking.registered_status and type(def) == 'table') then
|
|
return
|
|
end
|
|
|
|
loud_walking.registered_status[def.name] = {
|
|
remove = def.remove,
|
|
start = def.start,
|
|
during = def.during,
|
|
terminate = def.terminate,
|
|
}
|
|
end
|
|
|
|
function loud_walking.set_status(player_name, status, time, param)
|
|
if not (player_name and type(player_name) == 'string' and status and type(status) == 'string') and loud_walking.db and loud_walking.db.status and loud_walking.db.status[player_name] then
|
|
return
|
|
end
|
|
|
|
local player = minetest.get_player_by_name(player_name)
|
|
local def = loud_walking.registered_status[status]
|
|
if not (def and player) then
|
|
return
|
|
end
|
|
|
|
if not param then
|
|
param = {}
|
|
end
|
|
|
|
if time then
|
|
param.remove = (minetest.get_gametime() or 0) + time
|
|
end
|
|
|
|
loud_walking.db.status[player_name][status] = param
|
|
if def.start then
|
|
def.start(player)
|
|
end
|
|
end
|
|
|
|
function loud_walking.remove_status(player_name, status)
|
|
if not (player_name and type(player_name) == 'string' and status and type(status) == 'string') and loud_walking.db and loud_walking.db.status and loud_walking.db.status[player_name] then
|
|
return
|
|
end
|
|
|
|
local player = minetest.get_player_by_name(player_name)
|
|
local def = loud_walking.registered_status[status]
|
|
if player and def then
|
|
if def.terminate then
|
|
loud_walking.db.status[player_name][status] = def.terminate(player)
|
|
else
|
|
loud_walking.db.status[player_name][status] = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
--dofile(loud_walking.path .. "/recipe_list.lua")
|
|
|
|
dofile(loud_walking.path .. "/chat.lua")
|
|
dofile(loud_walking.path .. "/nodes.lua")
|
|
dofile(loud_walking.path .. "/deco.lua")
|
|
dofile(loud_walking.path .. "/deco_caves.lua")
|
|
--dofile(loud_walking.path .. "/schematics.lua")
|
|
--dofile(loud_walking.path .. "/wallhammer.lua")
|
|
dofile(loud_walking.path .. "/mapgen.lua")
|
|
dofile(loud_walking.path .. "/wooden_buckets.lua")
|
|
--dofile(loud_walking.path .. "/tools.lua")
|
|
--dofile(loud_walking.path .. "/molotov.lua")
|
|
--dofile(loud_walking.path .. "/elixir.lua")
|
|
--dofile(loud_walking.path .. "/chat.lua")
|
|
|
|
if minetest.get_modpath("mobs") and mobs and mobs.mod == "redo" then
|
|
dofile(loud_walking.path .. "/mobs.lua")
|
|
end
|
|
|
|
dofile(loud_walking.path .. "/abms.lua")
|
|
|
|
--loud_walking.print_recipes()
|
|
|
|
|
|
-- Attempt to save data at shutdown (as well as periodically).
|
|
minetest.register_on_shutdown(function()
|
|
local out = io.open(loud_walking.world..'/loud_walking_data.txt','w')
|
|
if out then
|
|
print('Squaresville: Saving database at shutdown')
|
|
out:write(minetest.serialize(loud_walking.db))
|
|
out:close()
|
|
end
|
|
end)
|
|
|
|
|
|
local hunger_mod = minetest.get_modpath("hunger")
|
|
loud_walking.hunger_id = {}
|
|
|
|
function loud_walking.hunger_change(player, change)
|
|
if not (player and change and type(change) == 'number') then
|
|
return
|
|
end
|
|
|
|
local player_name = player:get_player_name()
|
|
if hunger_mod then
|
|
if change < 0 and hunger and hunger.update_hunger and hunger.players then
|
|
hunger.update_hunger(player, hunger.players[player_name].lvl + change * 4)
|
|
end
|
|
return
|
|
end
|
|
|
|
if not (loud_walking.db.hunger and loud_walking.hunger_id) then
|
|
return
|
|
end
|
|
|
|
local hp = player:get_hp()
|
|
if not (hp and type(hp) == 'number') then
|
|
return
|
|
end
|
|
|
|
if change < 0 or hp >= 16 then
|
|
loud_walking.db.hunger[player_name] = math.min(20, math.max(0, loud_walking.db.hunger[player_name] + change))
|
|
player:hud_change(loud_walking.hunger_id[player_name], 'number', loud_walking.db.hunger[player_name])
|
|
if loud_walking.db.hunger[player_name] == 0 then
|
|
player:set_hp(hp - 1)
|
|
end
|
|
end
|
|
end
|
|
|
|
local hunger_hud
|
|
if not hunger_mod then
|
|
hunger_hud = function(player)
|
|
if not (player and loud_walking.db.hunger and loud_walking.hunger_id) then
|
|
return
|
|
end
|
|
|
|
local player_name = player:get_player_name()
|
|
|
|
if not loud_walking.db.hunger[player_name] then
|
|
loud_walking.db.hunger[player_name] = 20
|
|
end
|
|
|
|
local hunger_bar = {
|
|
hud_elem_type = 'statbar',
|
|
position = {x=0.52, y=1},
|
|
offset = {x = 0, y = -90},
|
|
name = "hunger",
|
|
text = "farming_bread.png",
|
|
number = loud_walking.db.hunger[player_name],
|
|
direction = 0,
|
|
size = { x=24, y=24 },
|
|
}
|
|
|
|
loud_walking.hunger_id[player_name] = player:hud_add(hunger_bar)
|
|
end
|
|
|
|
minetest.register_on_item_eat(function(hp_change, replace_with_item, itemstack, user, pointed_thing)
|
|
if not (hp_change and type(hp_change) == 'number') then
|
|
return
|
|
end
|
|
|
|
if hp_change > 0 then
|
|
loud_walking.hunger_change(user, hp_change)
|
|
end
|
|
end)
|
|
end
|
|
|
|
minetest.register_on_dieplayer(function(player)
|
|
if loud_walking.db.status and not player then
|
|
return
|
|
end
|
|
|
|
local player_name = player:get_player_name()
|
|
if not (player_name and type(player_name) == 'string' and player_name ~= '') then
|
|
return
|
|
end
|
|
|
|
if loud_walking.db.status[player_name] then
|
|
for status in pairs(loud_walking.db.status[player_name]) do
|
|
local def = loud_walking.registered_status[status]
|
|
if not def.remain_after_death then
|
|
loud_walking.remove_status(player_name, status)
|
|
end
|
|
end
|
|
end
|
|
|
|
if loud_walking.db.hunger and loud_walking.hunger_id and not hunger_mod then
|
|
loud_walking.db.hunger[player_name] = 20
|
|
player:hud_change(loud_walking.hunger_id[player_name], 'number', 20)
|
|
end
|
|
end)
|
|
|
|
loud_walking.armor_id = {}
|
|
local armor_hud
|
|
if not armor_mod then
|
|
armor_hud = function(player)
|
|
if not (player and loud_walking.armor_id) then
|
|
return
|
|
end
|
|
|
|
local player_name = player:get_player_name()
|
|
if not player_name then
|
|
return
|
|
end
|
|
|
|
local armor_icon = {
|
|
hud_elem_type = 'image',
|
|
name = "armor_icon",
|
|
text = 'loud_walking_shield.png',
|
|
scale = {x=1,y=1},
|
|
position = {x=0.8, y=1},
|
|
offset = {x = -30, y = -80},
|
|
}
|
|
|
|
local armor_text = {
|
|
hud_elem_type = 'text',
|
|
name = "armor_text",
|
|
text = '0%',
|
|
number = 0xFFFFFF,
|
|
position = {x=0.8, y=1},
|
|
offset = {x = 0, y = -80},
|
|
}
|
|
|
|
loud_walking.armor_id[player_name] = {}
|
|
loud_walking.armor_id[player_name].icon = player:hud_add(armor_icon)
|
|
loud_walking.armor_id[player_name].text = player:hud_add(armor_text)
|
|
end
|
|
|
|
loud_walking.display_armor = function(player)
|
|
if not (player and loud_walking.armor_id) then
|
|
return
|
|
end
|
|
|
|
local player_name = player:get_player_name()
|
|
local armor = player:get_armor_groups()
|
|
if not (player_name and armor and armor.fleshy) then
|
|
return
|
|
end
|
|
|
|
player:hud_change(loud_walking.armor_id[player_name].text, 'text', (100 - armor.fleshy)..'%')
|
|
end
|
|
end
|
|
|
|
|
|
if loud_walking.starting_equipment then
|
|
minetest.register_on_newplayer(function(player)
|
|
local inv = player:get_inventory()
|
|
inv:add_item("main", 'default:sword_wood')
|
|
inv:add_item("main", 'default:axe_wood')
|
|
inv:add_item("main", 'default:pick_wood')
|
|
inv:add_item("main", 'default:apple 10')
|
|
inv:add_item("main", 'default:torch 10')
|
|
if minetest.registered_items['unified_inventory:bag_small'] then
|
|
inv:add_item("main", 'unified_inventory:bag_small')
|
|
end
|
|
end)
|
|
end
|
|
|
|
|
|
minetest.register_on_joinplayer(function(player)
|
|
if not (player and loud_walking.db.status) then
|
|
return
|
|
end
|
|
|
|
local player_name = player:get_player_name()
|
|
|
|
if not (player_name and type(player_name) == 'string' and player_name ~= '') then
|
|
return
|
|
end
|
|
|
|
if not loud_walking.db.status[player_name] then
|
|
loud_walking.db.status[player_name] = {}
|
|
end
|
|
|
|
if armor_hud then
|
|
armor_hud(player)
|
|
end
|
|
|
|
if hunger_hud then
|
|
hunger_hud(player)
|
|
end
|
|
|
|
-- If there's an armor mod, we wait for it to load armor.
|
|
if loud_walking.load_armor_elixir and not armor_mod then
|
|
loud_walking.load_armor_elixir(player)
|
|
end
|
|
end)
|
|
|
|
-- support for 3d_armor
|
|
-- This may or may not work with all versions.
|
|
if armor_mod then
|
|
local old_set_player_armor = armor.set_player_armor
|
|
|
|
armor.set_player_armor = function(self, player)
|
|
old_set_player_armor(self, player)
|
|
if loud_walking.load_armor_elixir then
|
|
loud_walking.load_armor_elixir(player)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
----------------------------------------------------------------------
|
|
|
|
|
|
if loud_walking.quick_leaf_decay then
|
|
for name, node in pairs(minetest.registered_nodes) do
|
|
if node.groups.leafdecay then
|
|
node.groups.leafdecay = 0
|
|
node.groups.qfc_leafdecay = 0
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
local breakable = {}
|
|
breakable['loud_walking:wood_rotten'] = true
|
|
breakable['loud_walking:glowing_fungal_wood'] = true
|
|
if not loud_walking.breakable_wood then
|
|
print('* Loud Walking: Wood is NOT breakable by hand.')
|
|
for _, item in pairs(minetest.registered_items) do
|
|
if (item.groups.tree or item.groups.wood) and not breakable[item.name] then
|
|
local groups = table.copy(item.groups)
|
|
groups.oddly_breakable_by_hand = nil
|
|
minetest.override_item(item.name, {groups=groups})
|
|
end
|
|
end
|
|
end
|
|
|
|
minetest.register_on_joinplayer(function(player)
|
|
player:set_sky("#4070FF", "plain", {})
|
|
end)
|