realtest_mt5/mods/prestibags/init.lua

426 lines
13 KiB
Lua

--- prestibags Minetest mod
--
-- @author prestidigitator
-- @copyright 2013, licensed under WTFPL
---- Configuration
--- Width and height of bag inventory (>0)
local BAG_WIDTH = 2
local BAG_HEIGHT = 1
--- Sound played when placing/dropping a bag on the ground
local DROP_BAG_SOUND = "prestibags_drop_bag"
local DROP_BAG_SOUND_GAIN = 1.0
local DROP_BAG_SOUND_DIST = 5.0
--- Sound played when opening a bag's inventory
local OPEN_BAG_SOUND = "prestibags_rustle_bag"
local OPEN_BAG_SOUND_GAIN = 1.0
local OPEN_BAG_SOUND_DIST = 5.0
--- HP of undamaged bag (integer >0).
local BAG_MAX_HP = 4
--- How often the inventories of destroyed bags are checked and cleaned up
-- (>0.0).
local CLEANUP_PERIOD__S = 10.0
--- How often environmental effects like burning are checked (>0.0).
local ENV_CHECK_PERIOD__S = 0.5
--- Max distance an igniter node can be and still ignite/burn the bag (>=1).
local MAX_IGNITE_DIST = 4.0
--- Probability (0.0 <= p <= 1.0) bag will be damaged for each igniter touching
-- it (increases if igniter's max range is greater than current distance).
-- Always damaged if in lava.
local BURN_DAMAGE_PROB = 0.25
--- Probability (0.0 <= p <= 1.0) bag will ignite and spawn some flames on or
-- touching it for each igniter within igniter range (increases if
-- igniter's max range is greater than current distance). Alawys ignites
-- if in lava. Ignition is ignored if "fire:basic_flame" is not available.
local IGNITE_PROB = 0.25
--- Amount of damage bag takes each time it is burned. Note that a bag can be
-- burned at most once each update cycle, so this is the MAXIMUM damage
-- taken by burning each ENV_CHECK_PERIOD__S period.
local BURN_DAMAGE__HP = 1
---- end of configuration
local EPSILON = 0.001 -- "close enough"
local function serializeContents(contents)
if not contents then return "" end
local tabs = {}
for i, stack in ipairs(contents) do
tabs[i] = stack and stack:to_table() or ""
end
return minetest.serialize(tabs)
end
local function deserializeContents(data)
if not data or data == "" then return nil end
local tabs = minetest.deserialize(data)
if not tabs or type(tabs) ~= "table" then return nil end
local contents = {}
for i, tab in ipairs(tabs) do
contents[i] = ItemStack(tab)
end
return contents
end
-- weak references to keep track of what detached inventory lists to remove
local idSet = {}
local idToWeakEntityMap = {}
setmetatable(idToWeakEntityMap, { __mode = "v" })
local entityInv
local function cleanInventory()
for id, dummy in pairs(idSet) do
if not idToWeakEntityMap[id] then
entityInv:set_size(id, 0)
idSet[id] = nil
end
end
minetest.after(CLEANUP_PERIOD__S, cleanInventory)
end
minetest.after(CLEANUP_PERIOD__S, cleanInventory)
entityInv = minetest.create_detached_inventory(
"prestibags:bags",
{
allow_move = function(inv,
fromList, fromIndex,
toList, toIndex,
count,
player)
return idToWeakEntityMap[fromList] and idToWeakEntityMap[toList]
and count
or 0
end,
allow_put = function(inv, toList, toIndex, stack, player)
return idToWeakEntityMap[toList] and stack:get_count() or 0
end,
allow_take = function(inv, fromList, fromIndex, stack, player)
return idToWeakEntityMap[fromList] and stack:get_count() or 0
end,
on_move = function(inv,
fromList, fromIndex,
toList, toIndex,
count,
player)
local fromEntity = idToWeakEntityMap[fromList]
local toEntity = idToWeakEntityMap[toList]
local fromStack = fromEntity.contents[fromIndex]
local toStack = toEntity.contents[toIndex]
local moved = fromStack:take_item(count)
toStack:add_item(moved)
end,
on_put = function(inv, toList, toIndex, stack, player)
local toEntity = idToWeakEntityMap[toList]
local toStack = toEntity.contents[toIndex]
toStack:add_item(stack)
end,
on_take = function(inv, fromList, fromIndex, stack, player)
local fromEntity = idToWeakEntityMap[fromList]
local fromStack = fromEntity.contents[fromIndex]
fromStack:take_item(stack:get_count())
end
})
local function bag_envUpdate(self, dt)
end
minetest.register_entity(
"prestibags:bag_entity",
{
initial_properties =
{
hp_max = BAG_MAX_HP,
physical = false,
collisionbox = { -0.44, -0.5, -0.425, 0.44, 0.35, 0.425 },
visual = "mesh",
visual_size = { x = 1, y = 1 },
mesh = "prestibags_bag.obj",
textures = { "prestibags_bag.png" }
},
on_activate = function(self, staticData, dt)
local id
repeat
id = "bag"..(math.random(0, 2^15-1)*2^15 + math.random(0, 2^15-1))
until not idSet[id]
idSet[id] = id
idToWeakEntityMap[id] = self
self.id = id
self.object:set_armor_groups({ punch_operable = 1, flammable = 1 })
local contents = deserializeContents(staticData)
if not contents then
contents = {}
for i = 1, BAG_WIDTH*BAG_HEIGHT do
contents[#contents+1] = ItemStack(nil)
end
end
self.contents = contents
self.timer = ENV_CHECK_PERIOD__S
end,
get_staticdata = function(self)
return serializeContents(self.contents)
end,
on_punch = function(self, hitterObj, timeSinceLastPunch, toolCaps, dir)
local playerName = hitterObj:get_player_name()
local playerInv = hitterObj:get_inventory()
if not playerName or not playerInv then return end
local contentData = serializeContents(self.contents)
local hp = self.object:get_hp()
local newItem =
ItemStack({ name = "prestibags:bag",
metadata = contentData,
wear = (2^16) * (BAG_MAX_HP - hp) / BAG_MAX_HP })
if not playerInv:room_for_item("main", newItem) then return end
self:remove()
playerInv:add_item("main", newItem)
end,
on_rightclick = function(self, player)
local invLoc = "detached:"..self.id
local w = math.max(8, 2 + BAG_WIDTH)
local h = math.max(5 + BAG_HEIGHT)
local yImg = math.floor(BAG_HEIGHT/2)
local yPlay = BAG_HEIGHT + 1
if not self.contents or #self.contents <= 0 then return end
entityInv:set_size(self.id, #self.contents)
for i, stack in ipairs(self.contents) do
entityInv:set_stack(self.id, i, stack)
end
local formspec =
"size["..w..","..h.."]"..
"image[2,"..yImg..";1,1;prestibags_bag_inv.png]"..
"list[detached:prestibags:bags;"..self.id..";3,0;"..
BAG_WIDTH..","..BAG_HEIGHT..";]"..
"list[current_player;main;0,"..yPlay..";8,4;]"
minetest.show_formspec(
player:get_player_name(), "prestibags:bag", formspec)
minetest.sound_play(
OPEN_BAG_SOUND,
{
object = self.object,
gain = OPEN_BAG_SOUND_GAIN,
max_hear_distance = OPEN_BAG_SOUND_DIST,
loop = false
})
end,
on_step = function(self, dt)
self.timer = self.timer - dt
if self.timer > 0.0 then return end
self.timer = ENV_CHECK_PERIOD__S
local haveFlame = minetest.registered_nodes["fire:basic_flame"]
local pos = self.object:get_pos()
local node = minetest.get_node(pos)
local nodeType = node and minetest.registered_nodes[node.name]
if nodeType and nodeType.walkable and not nodeType.buildable_to then
return self:remove()
end
if minetest.get_item_group(node.name, "lava") > 0 then
if haveFlame then
local flamePos = minetest.find_node_near(pos, 1.0, "air")
if flamePos then
minetest.add_node(flamePos,
{ name = "fire:basic_flame" })
end
end
return self:burn()
end
if minetest.find_node_near(pos, 1.0, "group:puts_out_fire") then
return
end
local minPos = { x = pos.x - MAX_IGNITE_DIST,
y = pos.y - MAX_IGNITE_DIST,
z = pos.z - MAX_IGNITE_DIST }
local maxPos = { x = pos.x + MAX_IGNITE_DIST,
y = pos.y + MAX_IGNITE_DIST,
z = pos.z + MAX_IGNITE_DIST }
local wasIgnited = false
local burnLevels = 0.0
local igniterPosList =
minetest.find_nodes_in_area(minPos, maxPos, "group:igniter")
for i, igniterPos in ipairs(igniterPosList) do
local distSq = (igniterPos.x - pos.x)^2 +
(igniterPos.y - pos.y)^2 +
(igniterPos.z - pos.z)^2
if distSq <= MAX_IGNITE_DIST^2 + EPSILON then
local igniterNode = minetest.get_node(igniterPos)
local igniterLevel =
minetest.get_item_group(igniterNode.name, "igniter")
- math.max(1.0, math.sqrt(distSq) - EPSILON)
if igniterLevel >= 0.0 then
if distSq <= 1.0 then
wasIgnited = true
end
burnLevels = burnLevels + 1.0 + igniterLevel
end
end
end
if burnLevels >= 1.0 then
if haveFlame and (not wasIgnited) and
math.random() >= (1.0 - IGNITE_PROB)^burnLevels
then
local flamePos =
(node.name == "air")
and pos
or minetest.find_node_near(pos, 1.0, "air")
if flamePos then
minetest.add_node(flamePos,
{ name = "fire:basic_flame" })
end
end
if math.random() >= (1.0 - BURN_DAMAGE_PROB)^burnLevels then
self:burn()
end
end
end,
remove = function(self)
entityInv:set_size(self.id, 0)
idSet[self.id] = nil
self.object:remove()
end,
burn = function(self)
local hp = self.object:get_hp() - BURN_DAMAGE__HP
self.object:set_hp(hp)
minetest.log("verbose", "bag HP = "..hp)
if hp <= 0 then
return self:remove()
end
end
})
local function rezEntity(stack, pos, player)
local x = pos.x
local y = math.floor(pos.y)
local z = pos.z
while true do
local node = minetest.get_node({ x = x, y = y-1, z = z})
local nodeType = node and minetest.registered_nodes[node.name]
if not nodeType or nodeType.walkable then
break
end
y = y - 1
end
local obj = minetest.add_entity(pos, "prestibags:bag_entity")
if not obj then return stack end
local contentData = stack:get_metadata()
local contents = deserializeContents(contentData)
if contents then
obj:get_luaentity().contents = contents
end
obj:set_hp(BAG_MAX_HP - BAG_MAX_HP * stack:get_wear() / 2^16)
minetest.sound_play(
DROP_BAG_SOUND,
{
object = obj,
gain = DROP_BAG_SOUND_GAIN,
max_hear_distance = DROP_BAG_SOUND_DIST,
loop = false
})
return ItemStack(nil)
end
-- DEBUG minetest.register_craftitem(
minetest.register_tool(
"prestibags:bag",
{
description = "Bag of Stuff",
groups = { bag = BAG_WIDTH*BAG_HEIGHT, flammable = 1 },
inventory_image = "prestibags_bag_inv.png",
wield_image = "prestibags_bag_wield.png",
stack_max = 1,
on_place = function(stack, player, pointedThing)
local pos = pointedThing and pointedThing.under
local node = pos and minetest.get_node(pos)
local nodeType = node and minetest.registered_nodes[node.name]
if not nodeType or not nodeType.buildable_to then
pos = pointedThing and pointedThing.above
node = pos and minetest.get_node(pos)
nodeType = node and minetest.registered_nodes[node.name]
end
if not pos then pos = player:get_pos() end
return rezEntity(stack, pos, player)
end,
on_drop = function(stack, player, pos)
return rezEntity(stack, pos, player)
end
-- Eventually add on_use(stack, player, pointedThing) which actually
-- opens the bag from player inventory; trick is, has to track whether
-- bag is still in inventory OR replace "player inventory" with a
-- detached proxy that doesn't allow the bag's stack to be changed
-- while open!
})
minetest.register_craft(
{
output = "prestibags:bag",
recipe =
{
{ "", "farming:string", "" },
{ "farming:string", "", "farming:string" },
{ "farming:string", "farming:string", "farming:string" },
}
})