diff --git a/README.txt b/README.txt index 777870f..099da1c 100644 --- a/README.txt +++ b/README.txt @@ -1,36 +1,35 @@ -Minetest Game mod: fire (redo with changes by TenPlus1) -======================================================= +Minetest Game mod: fire +======================= +See license.txt for license information. -License of source code: ------------------------ -Copyright (C) 2012 Perttu Ahola (celeron55) +Authors of source code +---------------------- +Originally by Perttu Ahola (celeron55) (LGPL 2.1) +Various Minetest developers and contributors (LGPL 2.1) -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU Lesser General Public License as published by -the Free Software Foundation; either version 2.1 of the License, or -(at your option) any later version. - -http://www.gnu.org/licenses/lgpl-2.1.html - -License of media (textures and sounds) +Authors of media (textures and sounds) -------------------------------------- -Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0) -http://creativecommons.org/licenses/by-sa/3.0/ - -Authors of media files ------------------------ Everything not listed in here: -Copyright (C) 2012 Perttu Ahola (celeron55) +Copyright (C) 2012 Perttu Ahola (celeron55) (CC BY-SA 3.0) -fire_small.ogg sampled from: - http://www.freesound.org/people/dobroide/sounds/4211/ +Muadtralk (CC BY-SA 3.0) + fire_basic_flame_animated.png -fire_large.ogg sampled from: - http://www.freesound.org/people/Dynamicell/sounds/17548/ +Gambit (CC BY-SA 3.0) + fire_flint_steel.png -fire_basic_flame_animated.png: - Muadtralk +dobroide (CC BY 3.0) +http://www.freesound.org/people/dobroide/sounds/4211/ + fire_small.ogg -fire_flint_steel.png - Gambit (WTFPL) +Dynamicell (CC BY 3.0) +http://www.freesound.org/people/Dynamicell/sounds/17548/ + fire_large.ogg + fire_fire.*.ogg +fire_small.ogg and fire_large.ogg are unused but kept temporarily to not break +other mods that may use them. + +Benboncan (CC BY 3.0) +https://www.freesound.org/people/Benboncan/sounds/66457/ + fire_flint_and_steel.ogg diff --git a/init.lua b/init.lua index c715e51..6a3477f 100644 --- a/init.lua +++ b/init.lua @@ -1,15 +1,17 @@ --- minetest/fire/init.lua - -- Global namespace for functions fire = {} fire.mod = "redo" --- Register flame nodes +-- +-- Items +-- + +-- Flame nodes minetest.register_node("fire:basic_flame", { - drawtype = "plantlike", -- changed from 'firelike' for drawing speed + drawtype = "firelike", tiles = { { name = "fire_basic_flame_animated.png", @@ -32,23 +34,17 @@ minetest.register_node("fire:basic_flame", { on_timer = function(pos) local f = minetest.find_node_near(pos, 1, {"group:flammable"}) if not f then --- minetest.remove_node(pos) - minetest.swap_node(pos, {name = "air"}) + minetest.remove_node(pos) return end - -- restart timer + -- Restart timer return true end, drop = "", on_construct = function(pos) minetest.get_node_timer(pos):start(math.random(30, 60)) --- minetest.after(0, fire.update_sounds_around, pos) end, - --- on_destruct = function(pos) --- minetest.after(0, fire.update_sounds_around, pos) --- end, }) minetest.register_node("fire:permanent_flame", { @@ -82,9 +78,12 @@ minetest.register_node("fire:permanent_flame", { minetest.register_tool("fire:flint_and_steel", { description = "Flint and Steel", inventory_image = "fire_flint_steel.png", + sound = {breaks = "default_tool_breaks"}, + on_use = function(itemstack, user, pointed_thing) - itemstack:add_wear(1000) local pt = pointed_thing + minetest.sound_play("fire_flint_and_steel", + {pos = pt.above or user:getpos(), gain = 0.5, max_hear_distance = 8}) if pt.type == "node" then local node_under = minetest.get_node(pt.under).name local nodedef = minetest.registered_nodes[node_under] @@ -104,6 +103,13 @@ minetest.register_tool("fire:flint_and_steel", { end end if not minetest.setting_getbool("creative_mode") then + -- Wear tool + local wdef = itemstack:get_definition() + itemstack:add_wear(1000) + -- Tool break sound + if itemstack:get_count() == 0 and wdef.sound and wdef.sound.breaks then + minetest.sound_play(wdef.sound.breaks, {pos = pt.above, gain = 0.5}) + end return itemstack end end @@ -124,8 +130,7 @@ minetest.override_item("default:coalblock", { after_destruct = function(pos, oldnode) pos.y = pos.y + 1 if minetest.get_node(pos).name == "fire:permanent_flame" then --- minetest.remove_node(pos) - minetest.swap_node(pos, {name = "air"}) + minetest.remove_node(pos) end end, on_ignite = function(pos, igniter) @@ -136,201 +141,6 @@ minetest.override_item("default:coalblock", { end, }) - --- Get sound area of position - -fire.D = 6 -- size of sound areas - -function fire.get_area_p0p1(pos) - local p0 = { - x = math.floor(pos.x / fire.D) * fire.D, - y = math.floor(pos.y / fire.D) * fire.D, - z = math.floor(pos.z / fire.D) * fire.D, - } - local p1 = { - x = p0.x + fire.D - 1, - y = p0.y + fire.D - 1, - z = p0.z + fire.D - 1 - } - return p0, p1 -end - - --- Fire sounds table --- key: position hash of low corner of area --- value: {handle=sound handle, name=sound name} -fire.sounds = {} - - --- Update fire sounds in sound area of position - -function fire.update_sounds_around(pos) - local p0, p1 = fire.get_area_p0p1(pos) - local cp = {x = (p0.x + p1.x) / 2, y = (p0.y + p1.y) / 2, z = (p0.z + p1.z) / 2} - local flames_p = minetest.find_nodes_in_area(p0, p1, {"fire:basic_flame"}) - --print("number of flames at "..minetest.pos_to_string(p0).."/" - -- ..minetest.pos_to_string(p1)..": "..#flames_p) - local should_have_sound = (#flames_p > 0) - local wanted_sound = nil - if #flames_p >= 9 then - wanted_sound = {name = "fire_large", gain = 0.7} - elseif #flames_p > 0 then - wanted_sound = {name = "fire_small", gain = 0.9} - end - local p0_hash = minetest.hash_node_position(p0) - local sound = fire.sounds[p0_hash] - if not sound then - if should_have_sound then - fire.sounds[p0_hash] = { - handle = minetest.sound_play(wanted_sound, - {pos = cp, max_hear_distance = 16, loop = true}), - name = wanted_sound.name, - } - end - else - if not wanted_sound then - minetest.sound_stop(sound.handle) - fire.sounds[p0_hash] = nil - elseif sound.name ~= wanted_sound.name then - minetest.sound_stop(sound.handle) - fire.sounds[p0_hash] = { - handle = minetest.sound_play(wanted_sound, - {pos = cp, max_hear_distance = 16, loop = true}), - name = wanted_sound.name, - } - end - end -end - - --- Extinguish all flames quickly with water, snow, ice - -minetest.register_abm({ - label = "Extinguish flame", - nodenames = {"fire:basic_flame", "fire:permanent_flame"}, - neighbors = {"group:puts_out_fire"}, - interval = 3, - chance = 1, - catch_up = false, - action = function(pos, node, active_object_count, active_object_count_wider) --- minetest.remove_node(pos) - minetest.swap_node(pos, {name = "air"}) - minetest.sound_play("fire_extinguish_flame", - {pos = pos, max_hear_distance = 16, gain = 0.25}) - end, -}) - - --- Enable the following ABMs according to 'enable fire' setting - -local fire_enabled = minetest.setting_getbool("enable_fire") -if fire_enabled == nil then - -- New setting not specified, check for old setting. - -- If old setting is also not specified, 'not nil' is true. - fire_enabled = not minetest.setting_getbool("disable_fire") -end - -if not fire_enabled then - - -- Remove basic flames only - - minetest.register_abm({ - label = "Remove disabled fire", - nodenames = {"fire:basic_flame"}, - interval = 7, - chance = 1, - catch_up = false, - action = function(pos, node, active_object_count, active_object_count_wider) --- minetest.remove_node(pos) - minetest.swap_node(pos, {name = "air"}) - end, - }) - -else -- Fire enabled - - -- Ignite neighboring nodes, add basic flames - - minetest.register_abm({ - label = "Ignite flame", - nodenames = {"group:flammable"}, - neighbors = {"group:igniter"}, - interval = 7, - chance = 12, - catch_up = false, - action = function(pos, node, active_object_count, active_object_count_wider) - -- If there is water or stuff like that around node, don't ignite - if minetest.find_node_near(pos, 1, {"group:puts_out_fire"}) then - return - end - local p = minetest.find_node_near(pos, 1, {"air"}) - if p then - minetest.swap_node(p, {name = "fire:basic_flame"}) --- minetest.set_node(p, {name = "fire:basic_flame"}) - end - end, - }) - - -- Remove flammable nodes - - minetest.register_abm({ - label = "Remove flammable nodes", - nodenames = {"fire:basic_flame"}, - neighbors = "group:flammable", - interval = 5, - chance = 18, - catch_up = false, - action = function(pos, node, active_object_count, active_object_count_wider) - local p = minetest.find_node_near(pos, 1, {"group:flammable"}) - if p then - -- remove flammable nodes around flame - local flammable_node = minetest.get_node(p) - local def = minetest.registered_nodes[flammable_node.name] - if def.on_burn then - def.on_burn(p) - else --- minetest.remove_node(p) - minetest.swap_node(p, {name = "air"}) - minetest.check_for_falling(p) - end - end - end, - }) - -end - - --- Rarely ignite things from far - ---[[ Currently disabled to reduce the chance of uncontrollable spreading - fires that disrupt servers. Also for less lua processing load. - -minetest.register_abm({ - nodenames = {"group:igniter"}, - neighbors = {"air"}, - interval = 5, - chance = 10, - action = function(pos, node, active_object_count, active_object_count_wider) - local reg = minetest.registered_nodes[node.name] - if not reg or not reg.groups.igniter or reg.groups.igniter < 2 then - return - end - local d = reg.groups.igniter - local p = minetest.find_node_near(pos, d, {"group:flammable"}) - if p then - -- If there is water or stuff like that around flame, don't ignite - if fire.flame_should_extinguish(p) then - return - end - local p2 = fire.find_pos_for_flame_around(p) - if p2 then - minetest.set_node(p2, {name = "fire:basic_flame"}) - end - end - end, -}) ---]] - - -- used to drop items inside a chest or container function fire.drop_items(pos, invstring) @@ -371,3 +181,214 @@ minetest.override_item("default:chest", { end, }) + +-- +-- Sound +-- + +local flame_sound = false -- minetest.setting_getbool("flame_sound") ~= false + +if flame_sound then + + local handles = {} + local timer = 0 + + -- Parameters + + local radius = 8 -- Flame node search radius around player + local cycle = 3 -- Cycle time for sound updates + + -- Update sound for player + + function fire.update_player_sound(player) + local player_name = player:get_player_name() + -- Search for flame nodes in radius around player + local ppos = player:getpos() + local areamin = vector.subtract(ppos, radius) + local areamax = vector.add(ppos, radius) + local fpos, num = minetest.find_nodes_in_area( + areamin, + areamax, + {"fire:basic_flame", "fire:permanent_flame"} + ) + -- Total number of flames in radius + local flames = (num["fire:basic_flame"] or 0) + + (num["fire:permanent_flame"] or 0) + -- Stop previous sound + if handles[player_name] then + minetest.sound_stop(handles[player_name]) + handles[player_name] = nil + end + -- If flames + if flames > 0 then + -- Find centre of flame positions + local fposmid = fpos[1] + -- If more than 1 flame + if #fpos > 1 then + local fposmin = areamax + local fposmax = areamin + for i = 1, #fpos do + local fposi = fpos[i] + if fposi.x > fposmax.x then + fposmax.x = fposi.x + end + if fposi.y > fposmax.y then + fposmax.y = fposi.y + end + if fposi.z > fposmax.z then + fposmax.z = fposi.z + end + if fposi.x < fposmin.x then + fposmin.x = fposi.x + end + if fposi.y < fposmin.y then + fposmin.y = fposi.y + end + if fposi.z < fposmin.z then + fposmin.z = fposi.z + end + end + fposmid = vector.divide(vector.add(fposmin, fposmax), 2) + end + -- Play sound + local handle = minetest.sound_play( + "fire_fire", + { + pos = fposmid, + to_player = player_name, + gain = math.min(0.06 * (1 + flames * 0.125), 0.18), + max_hear_distance = 32, + loop = true, -- In case of lag + } + ) + -- Store sound handle for this player + if handle then + handles[player_name] = handle + end + end + end + + -- Cycle for updating players sounds + + minetest.register_globalstep(function(dtime) + timer = timer + dtime + if timer < cycle then + return + end + + timer = 0 + local players = minetest.get_connected_players() + for n = 1, #players do + fire.update_player_sound(players[n]) + end + end) + + -- Stop sound and clear handle on player leave + + minetest.register_on_leaveplayer(function(player) + local player_name = player:get_player_name() + if handles[player_name] then + minetest.sound_stop(handles[player_name]) + handles[player_name] = nil + end + end) +end + + +-- Deprecated function kept temporarily to avoid crashes if mod fire nodes call it + +function fire.update_sounds_around(pos) +end + + +-- +-- ABMs +-- + +-- Extinguish all flames quickly with water, snow, ice + +minetest.register_abm({ + label = "Extinguish flame", + nodenames = {"fire:basic_flame", "fire:permanent_flame"}, + neighbors = {"group:puts_out_fire"}, + interval = 3, + chance = 1, + catch_up = false, + action = function(pos, node, active_object_count, active_object_count_wider) + minetest.remove_node(pos) + minetest.sound_play("fire_extinguish_flame", + {pos = pos, max_hear_distance = 16, gain = 0.15}) + end, +}) + + +-- Enable the following ABMs according to 'enable fire' setting + +local fire_enabled = minetest.setting_getbool("enable_fire") +if fire_enabled == nil then + -- New setting not specified, check for old setting. + -- If old setting is also not specified, 'not nil' is true. + fire_enabled = not minetest.setting_getbool("disable_fire") +end + +if not fire_enabled then + + -- Remove basic flames only if fire disabled + + minetest.register_abm({ + label = "Remove disabled fire", + nodenames = {"fire:basic_flame"}, + interval = 7, + chance = 1, + catch_up = false, + action = minetest.remove_node, + }) + +else -- Fire enabled + + -- Ignite neighboring nodes, add basic flames + + minetest.register_abm({ + label = "Ignite flame", + nodenames = {"group:flammable"}, + neighbors = {"group:igniter"}, + interval = 7, + chance = 12, + catch_up = false, + action = function(pos, node, active_object_count, active_object_count_wider) + -- If there is water or stuff like that around node, don't ignite + if minetest.find_node_near(pos, 1, {"group:puts_out_fire"}) then + return + end + local p = minetest.find_node_near(pos, 1, {"air"}) + if p then + minetest.set_node(p, {name = "fire:basic_flame"}) + end + end, + }) + + -- Remove flammable nodes around basic flame + + minetest.register_abm({ + label = "Remove flammable nodes", + nodenames = {"fire:basic_flame"}, + neighbors = "group:flammable", + interval = 5, + chance = 18, + catch_up = false, + action = function(pos, node, active_object_count, active_object_count_wider) + local p = minetest.find_node_near(pos, 1, {"group:flammable"}) + if p then + local flammable_node = minetest.get_node(p) + local def = minetest.registered_nodes[flammable_node.name] + if def.on_burn then + def.on_burn(p) + else + minetest.remove_node(p) + minetest.check_for_falling(p) + end + end + end, + }) + +end diff --git a/init.lua_ok b/init.lua_ok new file mode 100644 index 0000000..c715e51 --- /dev/null +++ b/init.lua_ok @@ -0,0 +1,373 @@ +-- minetest/fire/init.lua + +-- Global namespace for functions + +fire = {} +fire.mod = "redo" + + +-- Register flame nodes + +minetest.register_node("fire:basic_flame", { + drawtype = "plantlike", -- changed from 'firelike' for drawing speed + tiles = { + { + name = "fire_basic_flame_animated.png", + animation = { + type = "vertical_frames", + aspect_w = 16, + aspect_h = 16, + length = 1 + }, + }, + }, + inventory_image = "fire_basic_flame.png", + paramtype = "light", + light_source = 13, + walkable = false, + buildable_to = true, + sunlight_propagates = true, + damage_per_second = 4, + groups = {igniter = 2, dig_immediate = 3, not_in_creative_inventory = 1}, + on_timer = function(pos) + local f = minetest.find_node_near(pos, 1, {"group:flammable"}) + if not f then +-- minetest.remove_node(pos) + minetest.swap_node(pos, {name = "air"}) + return + end + -- restart timer + return true + end, + drop = "", + + on_construct = function(pos) + minetest.get_node_timer(pos):start(math.random(30, 60)) +-- minetest.after(0, fire.update_sounds_around, pos) + end, + +-- on_destruct = function(pos) +-- minetest.after(0, fire.update_sounds_around, pos) +-- end, +}) + +minetest.register_node("fire:permanent_flame", { + description = "Permanent Flame", + drawtype = "firelike", + tiles = { + { + name = "fire_basic_flame_animated.png", + animation = { + type = "vertical_frames", + aspect_w = 16, + aspect_h = 16, + length = 1 + }, + }, + }, + inventory_image = "fire_basic_flame.png", + paramtype = "light", + light_source = 13, + walkable = false, + buildable_to = true, + sunlight_propagates = true, + damage_per_second = 4, + groups = {igniter = 2, dig_immediate = 3}, + drop = "", +}) + + +-- Flint and steel + +minetest.register_tool("fire:flint_and_steel", { + description = "Flint and Steel", + inventory_image = "fire_flint_steel.png", + on_use = function(itemstack, user, pointed_thing) + itemstack:add_wear(1000) + local pt = pointed_thing + if pt.type == "node" then + local node_under = minetest.get_node(pt.under).name + local nodedef = minetest.registered_nodes[node_under] + if not nodedef then + return + end + local player_name = user:get_player_name() + if minetest.is_protected(pt.under, player_name) then + minetest.chat_send_player(player_name, "This area is protected") + return + end + if nodedef.on_ignite then + nodedef.on_ignite(pt.under, user) + elseif minetest.get_item_group(node_under, "flammable") >= 1 + and minetest.get_node(pt.above).name == "air" then + minetest.set_node(pt.above, {name = "fire:basic_flame"}) + end + end + if not minetest.setting_getbool("creative_mode") then + return itemstack + end + end +}) + +minetest.register_craft({ + output = "fire:flint_and_steel", + recipe = { + {"default:flint", "default:steel_ingot"} + } +}) + + +-- Override coalblock to enable permanent flame above +-- Coalblock is non-flammable to avoid unwanted basic_flame nodes + +minetest.override_item("default:coalblock", { + after_destruct = function(pos, oldnode) + pos.y = pos.y + 1 + if minetest.get_node(pos).name == "fire:permanent_flame" then +-- minetest.remove_node(pos) + minetest.swap_node(pos, {name = "air"}) + end + end, + on_ignite = function(pos, igniter) + local flame_pos = {x = pos.x, y = pos.y + 1, z = pos.z} + if minetest.get_node(flame_pos).name == "air" then + minetest.set_node(flame_pos, {name = "fire:permanent_flame"}) + end + end, +}) + + +-- Get sound area of position + +fire.D = 6 -- size of sound areas + +function fire.get_area_p0p1(pos) + local p0 = { + x = math.floor(pos.x / fire.D) * fire.D, + y = math.floor(pos.y / fire.D) * fire.D, + z = math.floor(pos.z / fire.D) * fire.D, + } + local p1 = { + x = p0.x + fire.D - 1, + y = p0.y + fire.D - 1, + z = p0.z + fire.D - 1 + } + return p0, p1 +end + + +-- Fire sounds table +-- key: position hash of low corner of area +-- value: {handle=sound handle, name=sound name} +fire.sounds = {} + + +-- Update fire sounds in sound area of position + +function fire.update_sounds_around(pos) + local p0, p1 = fire.get_area_p0p1(pos) + local cp = {x = (p0.x + p1.x) / 2, y = (p0.y + p1.y) / 2, z = (p0.z + p1.z) / 2} + local flames_p = minetest.find_nodes_in_area(p0, p1, {"fire:basic_flame"}) + --print("number of flames at "..minetest.pos_to_string(p0).."/" + -- ..minetest.pos_to_string(p1)..": "..#flames_p) + local should_have_sound = (#flames_p > 0) + local wanted_sound = nil + if #flames_p >= 9 then + wanted_sound = {name = "fire_large", gain = 0.7} + elseif #flames_p > 0 then + wanted_sound = {name = "fire_small", gain = 0.9} + end + local p0_hash = minetest.hash_node_position(p0) + local sound = fire.sounds[p0_hash] + if not sound then + if should_have_sound then + fire.sounds[p0_hash] = { + handle = minetest.sound_play(wanted_sound, + {pos = cp, max_hear_distance = 16, loop = true}), + name = wanted_sound.name, + } + end + else + if not wanted_sound then + minetest.sound_stop(sound.handle) + fire.sounds[p0_hash] = nil + elseif sound.name ~= wanted_sound.name then + minetest.sound_stop(sound.handle) + fire.sounds[p0_hash] = { + handle = minetest.sound_play(wanted_sound, + {pos = cp, max_hear_distance = 16, loop = true}), + name = wanted_sound.name, + } + end + end +end + + +-- Extinguish all flames quickly with water, snow, ice + +minetest.register_abm({ + label = "Extinguish flame", + nodenames = {"fire:basic_flame", "fire:permanent_flame"}, + neighbors = {"group:puts_out_fire"}, + interval = 3, + chance = 1, + catch_up = false, + action = function(pos, node, active_object_count, active_object_count_wider) +-- minetest.remove_node(pos) + minetest.swap_node(pos, {name = "air"}) + minetest.sound_play("fire_extinguish_flame", + {pos = pos, max_hear_distance = 16, gain = 0.25}) + end, +}) + + +-- Enable the following ABMs according to 'enable fire' setting + +local fire_enabled = minetest.setting_getbool("enable_fire") +if fire_enabled == nil then + -- New setting not specified, check for old setting. + -- If old setting is also not specified, 'not nil' is true. + fire_enabled = not minetest.setting_getbool("disable_fire") +end + +if not fire_enabled then + + -- Remove basic flames only + + minetest.register_abm({ + label = "Remove disabled fire", + nodenames = {"fire:basic_flame"}, + interval = 7, + chance = 1, + catch_up = false, + action = function(pos, node, active_object_count, active_object_count_wider) +-- minetest.remove_node(pos) + minetest.swap_node(pos, {name = "air"}) + end, + }) + +else -- Fire enabled + + -- Ignite neighboring nodes, add basic flames + + minetest.register_abm({ + label = "Ignite flame", + nodenames = {"group:flammable"}, + neighbors = {"group:igniter"}, + interval = 7, + chance = 12, + catch_up = false, + action = function(pos, node, active_object_count, active_object_count_wider) + -- If there is water or stuff like that around node, don't ignite + if minetest.find_node_near(pos, 1, {"group:puts_out_fire"}) then + return + end + local p = minetest.find_node_near(pos, 1, {"air"}) + if p then + minetest.swap_node(p, {name = "fire:basic_flame"}) +-- minetest.set_node(p, {name = "fire:basic_flame"}) + end + end, + }) + + -- Remove flammable nodes + + minetest.register_abm({ + label = "Remove flammable nodes", + nodenames = {"fire:basic_flame"}, + neighbors = "group:flammable", + interval = 5, + chance = 18, + catch_up = false, + action = function(pos, node, active_object_count, active_object_count_wider) + local p = minetest.find_node_near(pos, 1, {"group:flammable"}) + if p then + -- remove flammable nodes around flame + local flammable_node = minetest.get_node(p) + local def = minetest.registered_nodes[flammable_node.name] + if def.on_burn then + def.on_burn(p) + else +-- minetest.remove_node(p) + minetest.swap_node(p, {name = "air"}) + minetest.check_for_falling(p) + end + end + end, + }) + +end + + +-- Rarely ignite things from far + +--[[ Currently disabled to reduce the chance of uncontrollable spreading + fires that disrupt servers. Also for less lua processing load. + +minetest.register_abm({ + nodenames = {"group:igniter"}, + neighbors = {"air"}, + interval = 5, + chance = 10, + action = function(pos, node, active_object_count, active_object_count_wider) + local reg = minetest.registered_nodes[node.name] + if not reg or not reg.groups.igniter or reg.groups.igniter < 2 then + return + end + local d = reg.groups.igniter + local p = minetest.find_node_near(pos, d, {"group:flammable"}) + if p then + -- If there is water or stuff like that around flame, don't ignite + if fire.flame_should_extinguish(p) then + return + end + local p2 = fire.find_pos_for_flame_around(p) + if p2 then + minetest.set_node(p2, {name = "fire:basic_flame"}) + end + end + end, +}) +--]] + + +-- used to drop items inside a chest or container +function fire.drop_items(pos, invstring) + + local meta = minetest.get_meta(pos) + local inv = meta:get_inventory() + + for i = 1, inv:get_size(invstring) do + + local m_stack = inv:get_stack(invstring, i) + local obj = minetest.add_item(pos, m_stack) + + if obj then + obj:setvelocity({ + x = math.random(-10, 10) / 9, + y = 1, + z = math.random(-10, 10) / 9 + }) + end + end + +end + +local groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 3} + +if minetest.get_modpath("pipeworks") then + groups.tubedevice = 1 + groups.tubedevice_receiver = 1 +end + +-- override chest node so that it's flammable +minetest.override_item("default:chest", { + + groups = groups, + + on_burn = function(p) + fire.drop_items(p, "main") + minetest.remove_node(p) + end, + +}) diff --git a/license.txt b/license.txt new file mode 100644 index 0000000..43f9cd7 --- /dev/null +++ b/license.txt @@ -0,0 +1,84 @@ +License of source code +---------------------- + +GNU Lesser General Public License, version 2.1 +Copyright (C) 2012-2016 celeron55, Perttu Ahola +Copyright (C) 2012-2016 Various Minetest developers and contributors + +This program is free software; you can redistribute it and/or modify it under the terms +of the GNU Lesser General Public License as published by the Free Software Foundation; +either version 2.1 of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +See the GNU Lesser General Public License for more details: +https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html + + +Licenses of media (textures and sounds) +--------------------------------------- + +Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0) +Copyright (C) 2012-2016 Perttu Ahola (celeron55) +Copyright (C) 2012-2016 Muadtralk +Copyright (C) 2013-2016 Gambit + +You are free to: +Share — copy and redistribute the material in any medium or format. +Adapt — remix, transform, and build upon the material for any purpose, even commercially. +The licensor cannot revoke these freedoms as long as you follow the license terms. + +Under the following terms: + +Attribution — You must give appropriate credit, provide a link to the license, and +indicate if changes were made. You may do so in any reasonable manner, but not in any way +that suggests the licensor endorses you or your use. + +ShareAlike — If you remix, transform, or build upon the material, you must distribute +your contributions under the same license as the original. + +No additional restrictions — You may not apply legal terms or technological measures that +legally restrict others from doing anything the license permits. + +Notices: + +You do not have to comply with the license for elements of the material in the public +domain or where your use is permitted by an applicable exception or limitation. +No warranties are given. The license may not give you all of the permissions necessary +for your intended use. For example, other rights such as publicity, privacy, or moral +rights may limit how you use the material. + +For more details: +http://creativecommons.org/licenses/by-sa/3.0/ + +----------------------- + +Attribution 3.0 Unported (CC BY 3.0) +Copyright (C) 2005 dobroide +Copyright (C) 2006 Dynamicell +Copyright (C) 2009 Benboncan + +You are free to: +Share — copy and redistribute the material in any medium or format. +Adapt — remix, transform, and build upon the material for any purpose, even commercially. +The licensor cannot revoke these freedoms as long as you follow the license terms. + +Under the following terms: + +Attribution — You must give appropriate credit, provide a link to the license, and +indicate if changes were made. You may do so in any reasonable manner, but not in any way +that suggests the licensor endorses you or your use. + +No additional restrictions — You may not apply legal terms or technological measures that +legally restrict others from doing anything the license permits. + +Notices: + +You do not have to comply with the license for elements of the material in the public +domain or where your use is permitted by an applicable exception or limitation. +No warranties are given. The license may not give you all of the permissions necessary +for your intended use. For example, other rights such as publicity, privacy, or moral +rights may limit how you use the material. + +For more details: +http://creativecommons.org/licenses/by/3.0/ diff --git a/sounds/fire_flint_and_steel.ogg b/sounds/fire_flint_and_steel.ogg new file mode 100644 index 0000000..6996e16 Binary files /dev/null and b/sounds/fire_flint_and_steel.ogg differ