696 lines
24 KiB
Lua
696 lines
24 KiB
Lua
cozylights = {
|
|
-- constant size values and tables
|
|
version = "0.2.8",
|
|
default_size = tonumber(minetest.settings:get("mapfix_default_size")) or 40,
|
|
brightness_factor = tonumber(minetest.settings:get("cozylights_brightness_factor")) or 8,
|
|
reach_factor = tonumber(minetest.settings:get("cozylights_reach_factor")) or 2,
|
|
dim_factor = tonumber(minetest.settings:get("cozylights_dim_factor")) or 9.5,
|
|
wield_step = tonumber(minetest.settings:get("cozylights_wield_step")) or 0.01,
|
|
brush_hold_step = tonumber(minetest.settings:get("cozylights_brush_hold_step")) or 0.07,
|
|
on_gen_step = tonumber(minetest.settings:get("cozylights_on_gen_step")) or 0.7,
|
|
max_wield_light_radius = tonumber(minetest.settings:get("cozylights_wielded_light_radius")) or 17,
|
|
override_engine_lights = minetest.settings:get_bool("cozylights_override_engine_lights", false),
|
|
always_fix_edges = minetest.settings:get_bool("cozylights_always_fix_edges", false),
|
|
uncozy_mode = tonumber(minetest.settings:get("cozylights_uncozy_mode")) or 0,
|
|
crispy_potato = minetest.settings:get_bool("cozylights_crispy_potato", true),
|
|
-- this is a table of modifiers for global light source settings.
|
|
-- lowkeylike and dimlike usually assigned to decorations in hopes to make all ambient naturally occuring light sources weaker
|
|
-- this is for two reasons:
|
|
-- 1. performance: never know how many various nice looking blocks which emit light will be there, or for example computing lights for
|
|
-- every node of a lava lake would be extremely expensive if those would reach far/would be very bright
|
|
-- 2. looks: they were made with default engine lighting in mind, so usually are very frequent, with such frequency default cozylights
|
|
-- settings will make the environment look blunt
|
|
coziest_table = {
|
|
--"dimlike"
|
|
[1] = {
|
|
brightness_factor = 0,
|
|
reach_factor = 0,
|
|
dim_factor = 0
|
|
},
|
|
--"lowkeylike" almost the same as dimlike, but reaches much farther with its barely visible light
|
|
[2] = {
|
|
brightness_factor = 0,
|
|
reach_factor = 2,
|
|
dim_factor = -3
|
|
},
|
|
-- "candlelike" something-something
|
|
[3] = {
|
|
brightness_factor = 0,
|
|
reach_factor = 2,
|
|
dim_factor = -3
|
|
},
|
|
-- "torchlike" torches, fires, flames. made much dimmer than what default engine lights makes them
|
|
[4] = {
|
|
brightness_factor = -2,
|
|
reach_factor = 0,
|
|
dim_factor = 0
|
|
},
|
|
-- "lamplike" a bright source, think mese lamp(actually turned out its like a projector, and below is even bigger projector)
|
|
[5] = {
|
|
brightness_factor = 0,
|
|
reach_factor = 3,
|
|
dim_factor = 4
|
|
},
|
|
-- "projectorlike" a bright source with massive reach
|
|
[6] = {
|
|
brightness_factor = 1,
|
|
reach_factor = 3,
|
|
dim_factor = 4
|
|
},
|
|
},
|
|
-- appears nodes and items might not necessarily be the same array
|
|
source_nodes = nil,
|
|
cozy_items = nil,
|
|
-- dynamic size tables, okay now what about functions
|
|
cozycids_sunlight_propagates = {},
|
|
cozycids_light_sources = {},
|
|
cozyplayers = {},
|
|
area_queue = {},
|
|
single_light_queue = {},
|
|
modpath = minetest.get_modpath(minetest.get_current_modname())
|
|
}
|
|
|
|
local modpath = minetest.get_modpath(minetest.get_current_modname())
|
|
dofile(modpath.."/helpers.lua")
|
|
|
|
-- backrooms test attempts to resolve mt engine lights problem with invisible lights, default settings will result
|
|
-- in many places being very well lit
|
|
-- me thinks ideal scenery with cozy lights in particular can be achieved with removal of all invisible lights
|
|
-- it also looks interesting after maybe a two thirds of light sources are broken
|
|
-- however the backrooms idea is not about broken windows theory at all, more about supernatural absence of any life
|
|
-- in a seemingly perfectly functioning infinite manmade mess, or idk i am not mentally masturbating any further,
|
|
-- some of the internets do that way too often, way too much
|
|
if cozylights:mod_loaded("br_core") then
|
|
cozylights.brightness_factor = cozylights.brightness_factor - 6
|
|
end
|
|
|
|
--if cozylights:mod_loaded("default") then
|
|
-- default.can_grow = function(pos)
|
|
-- local node_under = minetest.get_node_or_nil({x = pos.x, y = pos.y - 1, z = pos.z})
|
|
-- if not node_under then
|
|
-- return false
|
|
-- end
|
|
-- if minetest.get_item_group(node_under.name, "soil") == 0 then
|
|
-- return false
|
|
-- end
|
|
-- local light_level = minetest.get_node_light(pos)
|
|
-- if not light_level or light_level < 13 then
|
|
-- return false
|
|
-- end
|
|
-- return true
|
|
-- end
|
|
--end
|
|
|
|
|
|
dofile(modpath.."/nodes.lua")
|
|
dofile(modpath.."/shared.lua")
|
|
dofile(modpath.."/chat_commands.lua")
|
|
--ffi = require("ffi")
|
|
dofile(modpath.."/wield_light.lua")
|
|
dofile(modpath.."/node_light.lua")
|
|
dofile(modpath.."/light_brush.lua")
|
|
|
|
local c_air = minetest.get_content_id("air")
|
|
local c_light1 = minetest.get_content_id("cozylights:light1")
|
|
|
|
local c_lights = { c_light1, c_light1 + 1, c_light1 + 2, c_light1 + 3, c_light1 + 4, c_light1 + 5, c_light1 + 6,
|
|
c_light1 + 7, c_light1 + 8, c_light1 + 9, c_light1 + 10, c_light1 + 11, c_light1 + 12, c_light1 + 13 }
|
|
|
|
local mf = math.floor
|
|
|
|
------------------------------------------
|
|
|
|
minetest.register_on_mods_loaded(function()
|
|
local source_nodes = {}
|
|
local cozy_items = {}
|
|
local cozycids_sunlight_propagates = {}
|
|
local cozycids_light_sources = {}
|
|
local override = cozylights.override_engine_lights
|
|
for _,def in pairs(minetest.registered_items) do
|
|
if def.light_source and def.light_source > 1
|
|
and def.drawtype ~= "airlike" and def.drawtype ~= "liquid"
|
|
and string.find(def.name, "lava_flowing") == nil
|
|
and string.find(def.name, "lava_source") == nil
|
|
--and def.liquid_renewable == nil and def.drowning == nil
|
|
then
|
|
-- here we are going to define more specific skips and options for sus light sources
|
|
local skip = false
|
|
if string.find(def.name, "everness:") ~= nil and def.groups.vine ~= nil then
|
|
skip = true -- like goto continue
|
|
end
|
|
if skip == false then
|
|
local mods = nil
|
|
--if def.drawtype == "plantlike" then
|
|
-- mods = 1
|
|
--end
|
|
--if string.find(def.name,"torch") then
|
|
-- mods = 3
|
|
--end
|
|
cozy_items[def.name] = {light_source= def.light_source or 0,floodable=def.floodable or false,modifiers=mods}
|
|
if not string.find(def.name, "cozylights:light") then
|
|
source_nodes[#source_nodes+1] = def.name
|
|
end
|
|
end
|
|
end
|
|
end
|
|
for node,def in pairs(minetest.registered_nodes) do
|
|
if def.sunlight_propagates == true then
|
|
local cid = minetest.get_content_id(def.name)
|
|
cozycids_sunlight_propagates[cid] = true
|
|
end
|
|
if def.light_source and def.light_source > 1
|
|
and def.drawtype ~= "airlike" and def.drawtype ~= "liquid"
|
|
and not string.find(def.name, "lava_flowing")
|
|
and not string.find(def.name, "lava_source")
|
|
--and def.liquid_viscosity == nil and def.liquid_renewable == nil and def.drowning == nil
|
|
then
|
|
local cid = minetest.get_content_id(def.name)
|
|
if cid < c_lights[1] or cid > c_lights[14]+14 then
|
|
local skip = false
|
|
if string.find(def.name, "everness:") ~= nil and def.groups.vine ~= nil then
|
|
skip = true -- like goto :continue:
|
|
end
|
|
if skip == false then
|
|
cozycids_light_sources[cid] = true
|
|
if def.on_destruct then
|
|
local base_on_destruct = def.on_destruct
|
|
minetest.override_item(node,{
|
|
on_destruct = function(pos)
|
|
base_on_destruct(pos)
|
|
print(cozylights:dump(pos))
|
|
print(def.name.." is destroyed")
|
|
cozylights:destroy_light(pos, cozy_items[def.name])
|
|
end,
|
|
})
|
|
else
|
|
minetest.override_item(node,{
|
|
on_destruct = function(pos)
|
|
print(cozylights:dump(pos))
|
|
print(def.name.." is destroyed1")
|
|
cozylights:destroy_light(pos, cozy_items[def.name])
|
|
end,
|
|
})
|
|
end
|
|
if def.on_construct ~= nil then
|
|
local base_on_construct = def.on_construct
|
|
local light = override == true and 1 or def.light_source
|
|
if def.name == "br_core:ceiling_light_1" then
|
|
light = def.light_source - 7
|
|
end
|
|
minetest.override_item(node,{
|
|
light_source = light,
|
|
use_texture_alpha= def.use_texture_alpha or "clip",
|
|
on_construct = function(pos)
|
|
base_on_construct(pos)
|
|
cozylights:draw_node_light(pos, cozy_items[def.name])
|
|
end,
|
|
})
|
|
else
|
|
local light = override == true and 1 or def.light_source
|
|
if def.name == "br_core:ceiling_light_1" then
|
|
light = def.light_source - 7
|
|
end
|
|
minetest.override_item(node,{
|
|
light_source = light,
|
|
use_texture_alpha= def.use_texture_alpha or "clip",
|
|
on_construct = function(pos)
|
|
cozylights:draw_node_light(pos, cozy_items[def.name])
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
cozylights.source_nodes = source_nodes
|
|
cozylights.cozy_items = cozy_items
|
|
cozylights.cozycids_sunlight_propagates = cozycids_sunlight_propagates
|
|
cozylights.cozycids_light_sources = cozycids_light_sources
|
|
end)
|
|
|
|
--clean up possible stale wielded light on join, since on server shutdown we cant execute on_leave
|
|
--todo: make it more normal and less of a hack
|
|
function cozylights:on_join_cleanup(pos, radius)
|
|
local vm = minetest.get_voxel_manip()
|
|
local emin, emax = vm:read_from_map(vector.subtract(pos, radius+1), vector.add(pos, radius+1))
|
|
local data = vm:get_data()
|
|
local a = VoxelArea:new{
|
|
MinEdge = emin,
|
|
MaxEdge = emax
|
|
}
|
|
local param2data = vm:get_param2_data()
|
|
local max_radius = radius * (radius + 1)
|
|
for z = -radius, radius do
|
|
for y = -radius, radius do
|
|
for x = -radius, radius do
|
|
--local p = vector.add(pos,{x=x,y=y,z=z})
|
|
local p = {x=x+pos.x,y=y+pos.y,z=z+pos.z}
|
|
local idx = a:indexp(p)
|
|
local squared = x * x + y * y + z * z
|
|
if data[idx] >= c_lights[1] and data[idx] <= c_lights[14] and param2data[idx] == 0 and squared <= max_radius then
|
|
data[idx] = c_air
|
|
end
|
|
end
|
|
end
|
|
end
|
|
vm:set_data(data)
|
|
vm:update_liquids()
|
|
vm:write_to_map()
|
|
end
|
|
|
|
minetest.register_on_joinplayer(function(player)
|
|
if not player then return end
|
|
local pos = vector.round(player:getpos())
|
|
pos.y = pos.y + 1
|
|
cozylights:on_join_cleanup(pos, 30)
|
|
cozylights.cozyplayers[player:get_player_name()] = {
|
|
name=player:get_player_name(),
|
|
pos_hash=pos.x + (pos.y)*100 + pos.z*10000,
|
|
wielded_item=0,
|
|
last_pos=pos,
|
|
last_wield="",
|
|
prev_wielded_lights={},
|
|
lbrush={
|
|
brightness=6,
|
|
radius=0,
|
|
strength=0.5,
|
|
mode=1,
|
|
cover_only_surfaces=0,
|
|
pos_hash=0,
|
|
}
|
|
}
|
|
end)
|
|
|
|
minetest.register_on_leaveplayer(function(player)
|
|
if not player then return end
|
|
local name = player:get_player_name()
|
|
for i=1,#cozylights.cozyplayers do
|
|
if cozylights.cozyplayers[i].name == name then
|
|
cozylights:wielded_light_cleanup(player,cozylights.cozyplayers[i],30)
|
|
table.remove(cozylights.cozyplayers,i)
|
|
end
|
|
end
|
|
end)
|
|
|
|
minetest.register_on_shutdown(function()
|
|
for i=1,#cozylights.cozyplayers do
|
|
local player = minetest.get_player_by_name(cozylights.cozyplayers[i].name)
|
|
if player ~= nil then
|
|
cozylights:wielded_light_cleanup(player,cozylights.cozyplayers[i],30)
|
|
end
|
|
end
|
|
end)
|
|
|
|
local agent_total = 0
|
|
local agent_count = 0
|
|
local recently_updated = {}
|
|
local function build_lights_after_generated(minp,maxp,sources)
|
|
local t = os.clock()
|
|
local vm = minetest.get_voxel_manip()
|
|
local emin, emax = vm:read_from_map(vector.subtract(minp, 1), vector.add(maxp, 1))
|
|
local data = vm:get_data()
|
|
local param2data = vm:get_param2_data()
|
|
local a = VoxelArea:new{
|
|
MinEdge = emin,
|
|
MaxEdge = emax
|
|
}
|
|
if sources then
|
|
for i=1, #sources do
|
|
local s = sources[i]
|
|
--local hash = minetest.hash_node_position(s.pos)
|
|
local hash = s.pos.x + (s.pos.y)*100 + s.pos.z*10000
|
|
if recently_updated[hash] == nil then
|
|
recently_updated[hash] = true
|
|
cozylights:draw_node_light(s.pos, s.cozy_item, vm, a, data, param2data)
|
|
end
|
|
end
|
|
else
|
|
local cozycids_light_sources = cozylights.cozycids_light_sources
|
|
for i in a:iterp(minp,maxp) do
|
|
local cid = data[i]
|
|
if cozycids_light_sources[cid] then
|
|
local cozy_item = cozylights.cozy_items[minetest.get_name_from_content_id(cid)]
|
|
-- check if radius is not too big
|
|
local radius, _ = cozylights:calc_dims(cozy_item)
|
|
local p = a:position(i)
|
|
if a:containsp(vector.subtract(p,radius)) and a:containsp(vector.add(p,radius))
|
|
then
|
|
cozylights:draw_node_light(p,cozy_item,vm,a,data,param2data)
|
|
else
|
|
table.insert(cozylights.single_light_queue, { pos=p, cozy_item=cozy_item })
|
|
end
|
|
end
|
|
end
|
|
end
|
|
cozylights:setVoxelManipData(vm,data,param2data,true)
|
|
agent_total = agent_total + mf((os.clock() - t) * 1000)
|
|
agent_count = agent_count + 1
|
|
--print("Av build after generated time: "..
|
|
-- mf(agent_total/agent_count).." ms. Sample of: "..agent_count..". Areas left: "..#cozylights.area_queue
|
|
--)
|
|
end
|
|
|
|
--idk, size should be smarter than a constant
|
|
local size = 85
|
|
local function place_schem_but_real(pos, schematic, rotation, replacements, force_placement, flags)
|
|
if tonumber(schematic) ~= nil or type(schematic) == "string" then -- schematic.data
|
|
cozylights.area_queue[#cozylights.area_queue+1]={
|
|
minp=vector.subtract(pos, size),
|
|
maxp=vector.add(pos, size),
|
|
sources=nil
|
|
}
|
|
return
|
|
end
|
|
local sd = schematic.data
|
|
local update_needed = false
|
|
for i, node in pairs(sd) do
|
|
-- todo: account for replacements
|
|
if cozylights.cozy_items[node.name] then
|
|
-- rotation can be random so we cant know the position
|
|
-- todo: account for faster cases when its not random
|
|
update_needed = true
|
|
break
|
|
end
|
|
end
|
|
if update_needed == true then
|
|
local cozycids_light_sources = cozylights.cozycids_light_sources
|
|
print("UPDATE NEEDED")
|
|
local minp,maxp,vm,data,param2data,a = cozylights:getVoxelManipData(pos, size)
|
|
for i in a:iterp(minp, maxp) do
|
|
local cid = data[i]
|
|
if cozycids_light_sources[cid] then
|
|
local cozy_item = cozylights.cozy_items[minetest.get_name_from_content_id(cid)]
|
|
-- check if radius is not too big
|
|
local radius, _ = cozylights:calc_dims(cozy_item)
|
|
local p = a:position(i)
|
|
if a:containsp(vector.subtract(p,radius)) and a:containsp(vector.add(p,radius))
|
|
then
|
|
cozylights:draw_node_light(p,cozy_item,vm,a,data,param2data)
|
|
else
|
|
table.insert(cozylights.single_light_queue, { pos=p, cozy_item=cozy_item })
|
|
end
|
|
end
|
|
end
|
|
cozylights:setVoxelManipData(vm,data,param2data,true)
|
|
end
|
|
end
|
|
|
|
--a feeble attempt to cover schematics placements
|
|
local placeschemthatisnotreal = minetest.place_schematic
|
|
--todo: if its a village(several schematics) dont rebuild same lights
|
|
--todo: schematic exception table, if we have discovered for a fact somehow that a particular schematic
|
|
--cant possibly have any kind of lights then we ignore
|
|
--if not in runtime, then a constant table,
|
|
--might require additional tools to load all schematics on contentdb to figure this out
|
|
local schem_queue = {}
|
|
minetest.place_schematic = function(pos, schematic, rotation, replacements, force_placement, flags)
|
|
if not placeschemthatisnotreal(pos, schematic, rotation, replacements, force_placement, flags) then return end
|
|
-- now totally real stuff starts to happen
|
|
schem_queue[#schem_queue+1] = {
|
|
pos = pos,
|
|
schematic = schematic,
|
|
rotation = rotation,
|
|
replacements = replacements,
|
|
force_placement = force_placement,
|
|
flags = flags
|
|
}
|
|
end
|
|
|
|
local place_schematic_on_vmanip_nicely = minetest.place_schematic_on_vmanip
|
|
minetest.place_schematic_on_vmanip = function(vmanip, minp, filename, rotation, replacements, force_placement,flags)
|
|
if not place_schematic_on_vmanip_nicely(vmanip, minp, filename, rotation, replacements, force_placement,flags) then return end
|
|
schem_queue[#schem_queue+1] = {
|
|
pos = minp,
|
|
schematic = filename,
|
|
rotation = rotation,
|
|
replacements = replacements,
|
|
force_placement = force_placement,
|
|
flags = flags
|
|
}
|
|
end
|
|
|
|
local createschemthatisveryreadable = minetest.create_schematic
|
|
minetest.create_schematic = function(p1, p2, probability_list, filename, slice_prob_list)
|
|
if not createschemthatisveryreadable(p1, p2, probability_list, filename, slice_prob_list) then return end
|
|
-- unreadable stuff happens here
|
|
cozylights.area_queue[#cozylights.area_queue+1] = {
|
|
minp = p1,
|
|
maxp = p2,
|
|
sources = nil
|
|
}
|
|
end
|
|
|
|
local wield_light_enabled = cozylights.max_wield_light_radius > -1 and true or false
|
|
local wield_step = cozylights.wield_step
|
|
local brush_hold_step = cozylights.brush_hold_step
|
|
local on_gen_step = cozylights.on_gen_step
|
|
|
|
function cozylights:switch_wielded_light(enabled)
|
|
wield_light_enabled = enabled
|
|
end
|
|
|
|
function cozylights:set_wield_step(_time)
|
|
wield_step = _time
|
|
minetest.settings:set("cozylights_wield_step",_time)
|
|
cozylights.wield_step = _time
|
|
end
|
|
|
|
function cozylights:set_brush_hold_step(_time)
|
|
brush_hold_step = _time
|
|
minetest.settings:set("cozylights_brush_hold_step",_time)
|
|
cozylights.brush_hold_step = _time
|
|
end
|
|
|
|
function cozylights:set_on_gen_step(_time)
|
|
on_gen_step = _time
|
|
minetest.settings:set("cozylights_on_gen_step",_time)
|
|
cozylights.on_gen_step = _time
|
|
end
|
|
|
|
local brush_hold_dtime = 0
|
|
local wield_dtime = 0
|
|
local on_gen_dtime = 0
|
|
|
|
local total_brush_hold_time = 0
|
|
local total_brush_hold_step_count = 0
|
|
local total_wield_time = 0
|
|
local total_wield_step_count = 0
|
|
local uncozy_queue = {}
|
|
|
|
local function on_brush_hold(player,cozyplayer,pos,t)
|
|
local control_bits = player:get_player_control_bits()
|
|
if control_bits < 128 or control_bits >= 256 then return end
|
|
local lb = cozyplayer.lbrush
|
|
if lb.radius > 10 then return end
|
|
local look_dir = player:get_look_dir()
|
|
local endpos = vector.add(pos, vector.multiply(look_dir, 100))
|
|
local hit = minetest.raycast(pos, endpos, false, false):next()
|
|
if not hit then return end
|
|
local nodenameunder = minetest.get_node(hit.under).name
|
|
local nodedefunder = minetest.registered_nodes[nodenameunder]
|
|
local above = hit.above
|
|
if nodedefunder.buildable_to == true then
|
|
above.y = above.y - 1
|
|
end
|
|
local above_hash = above.x + (above.y)*100 + above.z*10000
|
|
if above_hash ~= lb.pos_hash or lb.mode == 2 or lb.mode == 4 or lb.mode == 5 then
|
|
lb.pos_hash = above_hash
|
|
cozylights:draw_brush_light(above, lb)
|
|
local exe_time = os.clock() - t
|
|
total_brush_hold_time = total_brush_hold_time + mf(exe_time * 1000)
|
|
total_brush_hold_step_count = total_brush_hold_step_count + 1
|
|
print("Av cozy lights brush step time " .. mf(total_brush_hold_time/total_brush_hold_step_count) .. " ms. Sample of: "..total_brush_hold_step_count)
|
|
--if exe_time > brush_hold_step then
|
|
-- minetest.chat_send_all("brush hold step was adjusted to "..(exe_time*2).." secs to help crispy potato.")
|
|
-- brush_hold_step = exe_time*2
|
|
--end
|
|
end
|
|
end
|
|
|
|
minetest.register_globalstep(function(dtime)
|
|
if wield_light_enabled then
|
|
wield_dtime = wield_dtime + dtime
|
|
if wield_dtime > wield_step then
|
|
wield_dtime = 0
|
|
for _,cozyplayer in pairs(cozylights.cozyplayers) do
|
|
local t = os.clock()
|
|
local player = minetest.get_player_by_name(cozyplayer.name)
|
|
if player == nil then
|
|
goto next_player
|
|
end
|
|
local pos = vector.round(player:getpos())
|
|
pos.y = pos.y + 1
|
|
local wield_name = player:get_wielded_item():get_name()
|
|
-- simple hash, collision will result in a rare minor barely noticeable glitch if a user teleports:
|
|
-- if in collision case right after teleport the player does not move, wielded light wont work until the player starts moving
|
|
local pos_hash = pos.x + (pos.y)*100 + pos.z*10000
|
|
if pos_hash == cozyplayer.pos_hash and cozyplayer.last_wield == wield_name then
|
|
goto next_player
|
|
end
|
|
if cozylights.cozy_items[wield_name] ~= nil then
|
|
local vel = vector.round(vector.multiply(player:get_velocity(),wield_step))
|
|
cozylights:draw_wielded_light(
|
|
pos,
|
|
cozyplayer.last_pos,
|
|
cozylights.cozy_items[wield_name],
|
|
vel,
|
|
cozyplayer
|
|
)
|
|
else
|
|
cozylights:wielded_light_cleanup(player,cozyplayer,cozyplayer.last_wield_radius or 0)
|
|
end
|
|
cozyplayer.pos_hash = pos_hash
|
|
cozyplayer.last_pos = pos
|
|
cozyplayer.last_wield = wield_name
|
|
local exe_time = (os.clock() - t)
|
|
total_wield_time = total_wield_time + mf(exe_time * 1000)
|
|
total_wield_step_count = total_wield_step_count + 1
|
|
--print("Av wielded cozy light step time " .. mf(total_wield_time/total_wield_step_count) .. " ms. Sample of: "..total_wield_step_count)
|
|
if cozylights.crispy_potato and exe_time > wield_step then
|
|
cozylights:set_wielded_light_radius(cozylights.max_wield_light_radius - 1)
|
|
minetest.chat_send_all("wield light step was adjusted to "..(exe_time*2).." secs to help crispy potato.")
|
|
wield_step = exe_time*2
|
|
end
|
|
::next_player::
|
|
end
|
|
end
|
|
end
|
|
|
|
brush_hold_dtime = brush_hold_dtime + dtime
|
|
if brush_hold_dtime > brush_hold_step then
|
|
brush_hold_dtime = 0
|
|
for _,cozyplayer in pairs(cozylights.cozyplayers) do
|
|
local t = os.clock()
|
|
local player = minetest.get_player_by_name(cozyplayer.name)
|
|
if not player == nil then
|
|
local pos = vector.round(player:getpos())
|
|
pos.y = pos.y + 1
|
|
local wield_name = player:get_wielded_item():get_name()
|
|
--todo: checking against a string is expensive, what do
|
|
if wield_name == "cozylights:light_brush" then
|
|
on_brush_hold(player,cozyplayer,pos,t)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
on_gen_dtime = on_gen_dtime + dtime
|
|
if on_gen_dtime > on_gen_step then
|
|
on_gen_dtime = 0
|
|
if cozylights.uncozy_mode == 0 then
|
|
if #schem_queue > 0 then
|
|
local s = schem_queue[1]
|
|
place_schem_but_real(s.pos, s.schematic, s.rotation, s.replacements, s.force_placement, s.flags)
|
|
table.remove(schem_queue, 1)
|
|
end
|
|
if #cozylights.area_queue ~= 0 then
|
|
local ar = cozylights.area_queue[1]
|
|
table.remove(cozylights.area_queue, 1)
|
|
print("build_lights_after_generated: "..cozylights:dump(ar.minp))
|
|
build_lights_after_generated(ar.minp,ar.maxp,ar.sources)
|
|
else
|
|
cozylights:rebuild_light()
|
|
if #recently_updated > 0 then
|
|
recently_updated = {}
|
|
end
|
|
end
|
|
else
|
|
for _,cozyplayer in pairs(cozylights.cozyplayers) do
|
|
local player = minetest.get_player_by_name(cozyplayer.name)
|
|
if player == nil then
|
|
goto next_player
|
|
end
|
|
local pos = vector.round(player:getpos())
|
|
pos.y = pos.y + 1
|
|
-- simple hash, collision will result in a rare minor barely noticeable glitch if a user teleports:
|
|
-- if in collision case right after teleport the player does not move, wielded light wont work until the player starts moving
|
|
local pos_hash = pos.x + (pos.y)*100 + pos.z*10000
|
|
if pos_hash == cozyplayer.pos_hash then
|
|
goto next_player
|
|
end
|
|
cozyplayer.pos_hash = pos_hash
|
|
cozyplayer.last_pos = pos
|
|
uncozy_queue[#uncozy_queue+1] = pos
|
|
::next_player::
|
|
end
|
|
if #uncozy_queue > 0 then
|
|
local exe_time = cozylights:clear(uncozy_queue[1], cozylights.uncozy_mode)
|
|
table.remove(uncozy_queue, 1)
|
|
if cozylights.crispy_potato and exe_time > on_gen_step then
|
|
minetest.chat_send_all("on_generated step was adjusted to "..(exe_time*2).." secs to help crispy potato.")
|
|
on_gen_step = exe_time*2
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
local gent_total = 0
|
|
local gent_count = 0
|
|
minetest.register_on_generated(function(minp, maxp)
|
|
local pos = vector.add(minp, vector.floor(vector.divide(vector.subtract(maxp,minp), 2)))
|
|
local light_sources = minetest.find_nodes_in_area(minp,maxp,cozylights.source_nodes)
|
|
if #light_sources == 0 then return end
|
|
if #light_sources > 1000 then
|
|
--print("Error: too many light sources around "..cozylights:dump(pos).." Report this to Cozy Lights dev")
|
|
return
|
|
end
|
|
--local minp_exp,maxp_exp,_,data,_,a = cozylights:getVoxelManipData(pos, size)
|
|
--local t = os.clock()
|
|
local sources = {}
|
|
local a = VoxelArea:new{
|
|
MinEdge = minp,
|
|
MaxEdge = maxp
|
|
}
|
|
local minp_exp, maxp_exp = minp, maxp
|
|
for _, p in pairs(light_sources) do
|
|
local name = minetest.get_node(p).name--get_name_from_content_id(cid)
|
|
local cozy_item = cozylights.cozy_items[name]
|
|
local radius, _ = cozylights:calc_dims(cozy_item)
|
|
local min_rad = vector.subtract(p,radius)
|
|
local max_rad = vector.add(p,radius)
|
|
if a:containsp(min_rad) and a:containsp(max_rad) then
|
|
sources[#sources+1] = {
|
|
pos=p,
|
|
cozy_item=cozy_item
|
|
}
|
|
else
|
|
minp_exp = {
|
|
x = minp_exp.x > min_rad.x and min_rad.x or minp_exp.x,
|
|
y = minp_exp.y > min_rad.y and min_rad.y or minp_exp.y,
|
|
z = minp_exp.z > min_rad.z and min_rad.z or minp_exp.z,
|
|
}
|
|
maxp_exp = {
|
|
x = maxp_exp.x < max_rad.x and max_rad.x or maxp_exp.x,
|
|
y = maxp_exp.y < max_rad.y and max_rad.y or maxp_exp.y,
|
|
z = maxp_exp.z < max_rad.z and max_rad.z or maxp_exp.z,
|
|
}
|
|
|
|
a = VoxelArea:new{
|
|
MinEdge = minp_exp,
|
|
MaxEdge = maxp_exp
|
|
}
|
|
sources[#sources+1] = {
|
|
pos=p,
|
|
cozy_item=cozy_item
|
|
}
|
|
--print("adding "..name.." to single_light_queue")
|
|
--table.insert(cozylights.single_light_queue, {
|
|
-- pos=p,
|
|
-- cozy_item=cozy_item
|
|
--})
|
|
end
|
|
end
|
|
--gent_total = gent_total + mf((os.clock() - t) * 1000)
|
|
--gent_count = gent_count + 1
|
|
--print("Av mapchunk generation time " .. mf(gent_total/gent_count) .. " ms. Sample of: "..gent_count)
|
|
if #sources > 0 then
|
|
print("on_generated adding area:"..cozylights:dump({minp=minp_exp,maxp=maxp_exp, volume=a:getVolume()}))
|
|
cozylights.area_queue[#cozylights.area_queue+1]={
|
|
minp=minp_exp,
|
|
maxp=maxp_exp,
|
|
sources=sources
|
|
}
|
|
end
|
|
end)
|
|
|