MineClone2/mods/PLAYER/mcl_hunger/init.lua
the-real-herowl fce73ab2bf Added some missing effects and improved API
* added a way to have a damage modifier relying on type instead of flag
* added Slow Falling
* added Levitation
* added Health Boost
* added Absorption
2024-05-22 21:02:24 +02:00

406 lines
15 KiB
Lua

local modname = minetest.get_current_modname()
local modpath = minetest.get_modpath(modname)
local S = minetest.get_translator(modname)
mcl_hunger = {}
--[[ This variable tells you if the hunger gameplay mechanic is active.
The state of the hunger mechanic will be determined at game start.
Hunger is enabled when damage is enabled.
If the damage setting is changed within the game, this does NOT
update the hunger mechanic, so the game must be restarted for this
to take effect. ]]
mcl_hunger.active = false
if minetest.settings:get_bool("enable_damage") == true and minetest.settings:get_bool("mcl_enable_hunger") ~= false then
mcl_hunger.active = true
end
mcl_hunger.HUD_TICK = 0.1
-- Exhaustion increase
mcl_hunger.EXHAUST_DIG = 5 -- after digging node
mcl_hunger.EXHAUST_JUMP = 50 -- jump
mcl_hunger.EXHAUST_SPRINT_JUMP = 200 -- jump while sprinting
mcl_hunger.EXHAUST_ATTACK = 100 -- hit an enemy
mcl_hunger.EXHAUST_SWIM = 10 -- player movement in water
mcl_hunger.EXHAUST_SPRINT = 100 -- sprint (per node)
mcl_hunger.EXHAUST_DAMAGE = 100 -- taking damage (protected by armor)
mcl_hunger.EXHAUST_REGEN = 6000 -- Regenerate 1 HP
mcl_hunger.EXHAUST_HUNGER = 5 -- Hunger status effect at base level.
mcl_hunger.EXHAUST_LVL = 4000 -- at what exhaustion player saturation gets lowered
mcl_hunger.EATING_DELAY = tonumber(minetest.settings:get("mcl_eating_delay")) or 1.61
mcl_hunger.EATING_WALK_SPEED = tonumber(minetest.settings:get("movement_speed_crouch")) / tonumber(minetest.settings:get("movement_speed_walk"))
mcl_hunger.EATING_TOUCHSCREEN_DELAY_PADDING = 0.75
mcl_hunger.SATURATION_INIT = 5 -- Initial saturation for new/respawning players
-- Debug Mode. If enabled, saturation and exhaustion are shown as well.
-- NOTE: Only updated when settings are loaded.
mcl_hunger.debug = false
-- Cooldown timers for each player, to force a short delay between consuming 2 food items
mcl_hunger.last_eat = {}
-- Is player eating API
function mcl_hunger.is_eating(name)
local result
if name then
if type(name) ~= "string" then
name = name:get_player_name()
end
result = mcl_hunger.eat_internal[name].is_eating_no_padding
end
return result
end
-- Variables for each player, to handle delayed eating
mcl_hunger.eat_internal = {}
mcl_hunger.eat_anim_hud = {}
-- Set per player internal variables for delayed eating
minetest.register_on_joinplayer(function(player)
local name = player:get_player_name()
mcl_hunger.eat_internal[name] = {
is_eating = false,
is_eating_no_padding = false,
itemname = nil,
item_definition = nil,
hp_change = nil,
replace_with_item = nil,
itemstack = nil,
user = nil,
pointed_thing = nil,
pitch = nil,
do_item_eat = false,
_custom_itemstack = nil, -- Used as comparison to make sure _custom_wrapper only executes when the same item is eaten
_custom_var = {}, -- Variables that can be used by _custom_var and _custom_wrapper
_custom_func = nil, -- Can be executed by _custom_wrapper
_custom_wrapper = nil, -- Will execute alongside minetest.do_item_eat if not empty and _custom_itemstack is equal to current player itemstack
_custom_do_delayed = false, -- If true, then will execute only _custom_wrapper after holding RMB or LMB within a delay specified by mcl_hunger.EATING_DELAY (Use to bypass minetest.do_item_eat entirely)
}
playerphysics.remove_physics_factor(player, "speed", "mcl_hunger:eating_speed")
player:hud_set_flags({wielditem = true})
end)
-- Clear when player leaves
minetest.register_on_leaveplayer(function(player)
local name = player:get_player_name()
mcl_hunger.eat_internal[name] = nil
mcl_hunger.eat_anim_hud[name] = nil
end)
dofile(modpath.."/api.lua")
dofile(modpath.."/hunger.lua")
dofile(modpath.."/register_foods.lua")
--[[ IF HUNGER IS ENABLED ]]
if mcl_hunger.active == true then
-- Read debug mode setting
-- The setting should only be read at the beginning, this mod is not
-- prepared to change this setting later.
mcl_hunger.debug = minetest.settings:get_bool("mcl_hunger_debug")
if mcl_hunger.debug == nil then
mcl_hunger.debug = false
end
--[[ Data value format notes:
Hunger values is identical to Minecraft's and ranges from 0 to 20.
Exhaustion and saturation values are stored as integers, unlike in Minecraft.
Exhaustion is Minecraft exhaustion times 1000 and ranges from 0 to 4000.
Saturation is Minecraft saturation and ranges from 0 to 20.
Food saturation is stored in the custom item definition field _mcl_saturation.
This field uses the original Minecraft value.
]]
-- Count number of poisonings a player has at once
mcl_hunger.poison_hunger = {} -- food poisoning, increasing hunger
-- HUD
local function init_hud(player)
local name = player:get_player_name()
hb.init_hudbar(player, "hunger", mcl_hunger.get_hunger(player))
if mcl_hunger.debug then
hb.init_hudbar(player, "saturation", mcl_hunger.get_saturation(player), mcl_hunger.get_hunger(player))
hb.init_hudbar(player, "exhaustion", mcl_hunger.get_exhaustion(player))
end
mcl_hunger.eat_anim_hud[name] = player:hud_add({
hud_elem_type = "image",
text = "blank.png",
position = {x = 0.5, y = 1},
scale = {x = -25, y = -45},
alignment = {x = 0, y = -1},
offset = {x = 0, y = -30},
z_index = -200,
})
end
-- HUD updating functions for Debug Mode. No-op if not in Debug Mode
function mcl_hunger.update_saturation_hud(player, saturation, hunger)
if mcl_hunger.debug then
hb.change_hudbar(player, "saturation", saturation, hunger)
end
end
function mcl_hunger.update_exhaustion_hud(player, exhaustion)
if mcl_hunger.debug then
if not exhaustion then
exhaustion = mcl_hunger.get_exhaustion(player)
end
hb.change_hudbar(player, "exhaustion", exhaustion)
end
end
-- register saturation hudbar
hb.register_hudbar("hunger", 0xFFFFFF, S("Food"), { icon = "hbhunger_icon.png", bgicon = "hbhunger_bgicon.png", bar = "hbhunger_bar.png" }, 1, 20, 20, false)
if mcl_hunger.debug then
hb.register_hudbar("saturation", 0xFFFFFF, S("Saturation"), { icon = "mcl_hunger_icon_saturation.png", bgicon = "mcl_hunger_bgicon_saturation.png", bar = "mcl_hunger_bar_saturation.png" }, 1, mcl_hunger.SATURATION_INIT, 200, false)
hb.register_hudbar("exhaustion", 0xFFFFFF, S("Exhaust."), { icon = "mcl_hunger_icon_exhaustion.png", bgicon = "mcl_hunger_bgicon_exhaustion.png", bar = "mcl_hunger_bar_exhaustion.png" }, 1, 0, mcl_hunger.EXHAUST_LVL, false)
end
minetest.register_on_joinplayer(function(player)
local name = player:get_player_name()
mcl_hunger.init_player(player)
init_hud(player)
mcl_hunger.poison_hunger[name] = 0
mcl_hunger.last_eat[name] = -1
end)
minetest.register_on_respawnplayer(function(player)
-- reset hunger, related values and poison
local name = player:get_player_name()
mcl_hunger.stop_poison(player)
mcl_hunger.last_eat[name] = -1
local h, s, e = 20, mcl_hunger.SATURATION_INIT, 0
mcl_hunger.set_hunger(player, h, false)
mcl_hunger.set_saturation(player, s, false)
mcl_hunger.set_exhaustion(player, e, false)
hb.change_hudbar(player, "hunger", h)
mcl_hunger.update_saturation_hud(player, s, h)
mcl_hunger.update_exhaustion_hud(player, e)
end)
-- PvP combat exhaustion
minetest.register_on_punchplayer(function(victim, puncher, time_from_last_punch, tool_capabilities, dir, damage)
if puncher:is_player() then
mcl_hunger.exhaust(puncher:get_player_name(), mcl_hunger.EXHAUST_ATTACK)
end
end)
-- Exhaust on taking damage
minetest.register_on_player_hpchange(function(player, hp_change)
if hp_change < 0 then
local name = player:get_player_name()
mcl_hunger.exhaust(name, mcl_hunger.EXHAUST_DAMAGE)
end
end)
local food_tick_timers = {} -- one food_tick_timer per player, keys are the player-objects
local eat_start_timers = {}
local eat_tick_timers = {}
local eat_effects_cooldown = {}
local function clear_eat_internal_and_timers(player, player_name)
playerphysics.remove_physics_factor(player, "speed", "mcl_hunger:eating_speed")
player:hud_set_flags({wielditem = true})
player:hud_change(mcl_hunger.eat_anim_hud[player_name], "text", "blank.png")
mcl_hunger.eat_internal[player_name] = {
is_eating = false,
is_eating_no_padding = false,
itemname = nil,
item_definition = nil,
hp_change = nil,
replace_with_item = nil,
itemstack = nil,
user = nil,
pointed_thing = nil,
pitch = nil,
do_item_eat = false,
_custom_itemstack = nil,
_custom_var = {},
_custom_func = nil,
_custom_wrapper = nil,
_custom_do_delayed = false,
}
eat_start_timers[player] = 0
eat_tick_timers[player] = 0
eat_effects_cooldown[player] = 0
end
minetest.register_globalstep(function(dtime)
for _,player in pairs(minetest.get_connected_players()) do
local food_tick_timer = food_tick_timers[player] and food_tick_timers[player] + dtime or 0
local player_name = player:get_player_name()
local food_level = mcl_hunger.get_hunger(player)
local food_saturation_level = mcl_hunger.get_saturation(player)
local player_health = player:get_hp()
local max_tick_timer = tonumber(minetest.settings:get("mcl_health_regen_delay")) or 0.5
if food_tick_timer > 4 then
food_tick_timer = 0
-- let hunger work always
if player_health > 0 then
--mcl_hunger.exhaust(player_name, mcl_hunger.EXHAUST_HUNGER) -- later for hunger status effect
mcl_hunger.update_exhaustion_hud(player)
end
if food_level >= 18 then -- slow regeneration
if player_health > 0 and player_health < player:get_properties().hp_max then
player:set_hp(player_health+1)
mcl_hunger.exhaust(player_name, mcl_hunger.EXHAUST_REGEN)
mcl_hunger.update_exhaustion_hud(player)
end
elseif food_level == 0 then -- starvation
-- the amount of health at which a player will stop to get
-- harmed by starvation (10 for Easy, 1 for Normal, 0 for Hard)
local maximum_starvation = 1
-- TODO: implement Minecraft-like difficulty modes and the update maximumStarvation here
if player_health > maximum_starvation then
mcl_util.deal_damage(player, 1, {type = "starve"})
end
end
elseif food_tick_timer > max_tick_timer and food_level == 20 and food_saturation_level > 0 then -- fast regeneration
if player_health > 0 and player_health < player:get_properties().hp_max then
food_tick_timer = 0
player:set_hp(player_health+1)
mcl_hunger.exhaust(player_name, mcl_hunger.EXHAUST_REGEN)
mcl_hunger.update_exhaustion_hud(player)
end
end
food_tick_timers[player] = food_tick_timer -- update food_tick_timer table
-- Eating delay code
if mcl_hunger.eat_internal[player_name] and mcl_hunger.eat_internal[player_name].is_eating or mcl_hunger.eat_internal[player_name]._custom_do_delayed then
mcl_hunger.eat_internal[player_name].is_eating = true
mcl_hunger.eat_internal[player_name].is_eating_no_padding = true
local control = player:get_player_control()
local inv = player:get_inventory()
local current_itemstack = player:get_wielded_item()
if not eat_start_timers[player] then
eat_start_timers[player] = 0
end
eat_start_timers[player] = eat_start_timers[player] + dtime
if not eat_tick_timers[player] then
eat_tick_timers[player] = 0
end
if not eat_effects_cooldown[player] then
eat_effects_cooldown[player] = 0
end
if not mcl_hunger.eat_internal[player_name].pitch then
mcl_hunger.eat_internal[player_name].pitch = 1 + math.random(-10, 10)*0.005
end
-- check if holding RMB (or LMB as workaround for touchscreen)
if (current_itemstack == mcl_hunger.eat_internal[player_name].itemstack or current_itemstack == mcl_hunger.eat_internal[player_name]._custom_itemstack) and (control.RMB or control.LMB) then
eat_tick_timers[player] = eat_tick_timers[player] + dtime
eat_effects_cooldown[player] = eat_effects_cooldown[player] + dtime
playerphysics.add_physics_factor(player, "speed", "mcl_hunger:eating_speed", mcl_hunger.EATING_WALK_SPEED)
player:hud_set_flags({wielditem = false})
local itemstackdef = current_itemstack:get_definition()
local wield_image = itemstackdef.wield_image
if not wield_image or wield_image == "" then wield_image = itemstackdef.inventory_image end
player:hud_change(mcl_hunger.eat_anim_hud[player_name], "text", wield_image)
player:hud_change(mcl_hunger.eat_anim_hud[player_name], "offset", {x = 0, y = 50*math.sin(10*eat_tick_timers[player]+math.random())-50})
if eat_effects_cooldown[player] > 0.2 then
eat_effects_cooldown[player] = 0
if not mcl_hunger.eat_internal[player_name].user then
mcl_hunger.eat_internal[player_name].user = player
end
if not mcl_hunger.eat_internal[player_name].itemname then
mcl_hunger.eat_internal[player_name].itemname = current_itemstack:get_name()
end
if not mcl_hunger.eat_internal[player_name].hp_change then
mcl_hunger.eat_internal[player_name].hp_change = 0
end
local pos = player:get_pos()
local itemname = mcl_hunger.eat_internal[player_name].itemname
local def = minetest.registered_items[itemname]
mcl_hunger.eat_effects(
mcl_hunger.eat_internal[player_name].user,
mcl_hunger.eat_internal[player_name].itemname,
pos,
mcl_hunger.eat_internal[player_name].hp_change,
def,
mcl_hunger.eat_internal[player_name].pitch
)
end
-- check if eating delay is over
if eat_tick_timers[player] >= mcl_hunger.EATING_DELAY then
if not mcl_hunger.eat_internal[player_name]._custom_do_delayed then
mcl_hunger.eat_internal[player_name].do_item_eat = true
minetest.do_item_eat(
mcl_hunger.eat_internal[player_name].hp_change,
mcl_hunger.eat_internal[player_name].replace_with_item,
mcl_hunger.eat_internal[player_name].itemstack,
mcl_hunger.eat_internal[player_name].user,
mcl_hunger.eat_internal[player_name].pointed_thing
)
-- bypass minetest.do_item_eat and only execute _custom_wrapper
elseif mcl_hunger.eat_internal[player_name]._custom_itemstack and
mcl_hunger.eat_internal[player_name]._custom_wrapper and
mcl_hunger.eat_internal[player_name]._custom_itemstack == current_itemstack then
mcl_hunger.eat_internal[player_name]._custom_wrapper(player_name)
player:get_inventory():set_stack("main", player:get_wield_index(), itemstack)
end
clear_eat_internal_and_timers(player, player_name)
end
elseif eat_start_timers[player] and eat_start_timers[player] > 0.2 then
playerphysics.remove_physics_factor(player, "speed", "mcl_hunger:eating_speed")
player:hud_set_flags({wielditem = true})
player:hud_change(mcl_hunger.eat_anim_hud[player_name], "text", "blank.png")
mcl_hunger.eat_internal[player_name].is_eating_no_padding = false
elseif eat_start_timers[player] and eat_start_timers[player] > mcl_hunger.EATING_TOUCHSCREEN_DELAY_PADDING then
clear_eat_internal_and_timers(player, player_name)
end
end
if eat_start_timers[player] and eat_start_timers[player] > mcl_hunger.EATING_DELAY + mcl_hunger.EATING_TOUCHSCREEN_DELAY_PADDING then
clear_eat_internal_and_timers(player, player_name)
end
end
end)
--[[ IF HUNGER IS NOT ENABLED ]]
else
minetest.register_on_joinplayer(function(player)
mcl_hunger.init_player(player)
mcl_hunger.last_eat[player:get_player_name()] = -1
end)
end