Merge remote-tracking branch 'upstream/master' into nalc-1.2-dev

Update README.md to reflect current location of repo

See merge request rautars/weather_pack!11

README.md

@@ -2,6 +2,12 @@ weather-pack
 =======================
 Weather mod for Minetest (http://minetest.net/)
 
+Feedback and Improvements
+-----------------------
+* See newest version at https://gitlab.com/zombiebot/weather_pack
+* Register bugs at https://gitlab.com/zombiebot/weather_pack/issues
+* Questions / Discussion at https://forum.minetest.net/viewtopic.php?p=215869
+
 Weathers included
 -----------------------
 * light_rain, rain, heavy_rain
@@ -15,9 +21,11 @@ requires `weather_manager` privilege.
   * `start_weather <weather_code>` 
   * `stop_weather <weather_code>` 
 
+Be aware that weather may not be visible for player until player is in right biome.
+
 Dependencies
 -----------------------
-Thunder weather requres [lightning](https://github.com/minetest-mods/lightning) mod.
+Thunder weather requires [lightning](https://github.com/minetest-mods/lightning) mod.
 
 License of source code:
 -----------------------
@@ -29,12 +37,8 @@ Authors of media files:
 xeranas:
 
   * `happy_weather_heavy_rain_drops.png` - CC-0
-  * `happy_weather_light_rain_raindrop_1.png` - CC-0
+  * `happy_weather_light_rain_raindrop_*.png` - CC-0
-  * `happy_weather_light_rain_raindrop_2.png` - CC-0
+  * `happy_weather_light_snow_snowflake_*.png` - CC-0
-  * `happy_weather_light_rain_raindrop_3.png` - CC-0
-  * `happy_weather_light_snow_snowflake_1.png` - CC-0
-  * `happy_weather_light_snow_snowflake_2.png` - CC-0
-  * `happy_weather_light_snow_snowflake_3.png` - CC-0
 
 inchadney (http://freesound.org/people/inchadney/):
 

embedded_sky_layer_api.lua

@@ -1,265 +0,0 @@
--------------------------
--- Sky Layers: API
-
--- License: MIT
--- Credits: xeranas
--------------------------
-
-skylayer = {}
-
--- flag for enable / disable skylayer temporally if needed
-skylayer.enabled = true
-
--- supported skylayer types
-skylayer.SKY_PLAIN = "plain"
-skylayer.SKY_SOLID_COLOR = "solid_color"
-skylayer.SKY_SKYBOX = "skybox"
-
--- helps track total dtime
-local timer = 0
-
-local gradient_default_min_value = 0
-local gradient_default_max_value = 1000
-
--- how often sky will be updated in seconds
-skylayer.update_interval = 4
-
--- keeps player related data such as player itself and own sky layers
-local sky_players = {}
-
--- adds player to sky layer affected players list
-local add_player = function(player)
-	local data = {}
-	data.id = player:get_player_name()
-	data.player = player
-	data.skylayers = {}
-	table.insert(sky_players, data)
-end
-
--- remove player from sky layer affected players list
-local remove_player = function(player_name)
-	if #sky_players == 0 then
-		return
-	end
-
-	for k, player_data in ipairs(sky_players) do
-		if player_data.id == player_name then
-			set_default_sky(player_data.player)
-			table.remove(sky_players, k)
-			return
-		end
-	end
-end
-
-local get_player_by_name = function(player_name)
-	if player_name == nil then
-		return nil
-	end
-
-	if #minetest.get_connected_players() == 0 then
-		return nil
-	end
-
-	for i, player in ipairs(minetest.get_connected_players()) do
-		if player:get_player_name() == player_name then
-			return player
-		end
-	end
-
-	return nil
-end
-
-local get_player_data = function(player_name)
-	if #sky_players == 0 then
-		return nil
-	end
-
-	for k, player_data in ipairs(sky_players) do
-		if player_data.id == player_name then
-			return player_data
-		end
-	end	
-end
-
-local create_new_player_data = function(player_name)
-	local player_data = get_player_data(player_name)
-	if player_data == nil then
-		local player = get_player_by_name(player_name)
-		if player == nil then
-			minetest.log("error", "Fail to resolve player '" .. player_name .. "'")
-			return
-		end
-		add_player(player)
-		return get_player_data(player_name)
-	end
-	return player_data
-end
-
--- sets default / regular sky for player
-local set_default_sky = function(player)
-	player:set_sky(nil, "regular", nil)
-end
-
--- resolves latest skylayer based on added layer time
-local get_latest_layer = function(layers)
-	if #layers == 0 then
-		return nil
-	end
-
-	local latest_layer = nil
-	for k, layer in ipairs(layers) do
-		if latest_layer == nil then
-			latest_layer = layer
-		else
-			if layer.added_time >= latest_layer.added_time then
-				latest_layer = layer
-			end
-		end
-	end
-
-	return latest_layer
-end
-
-local convert_to_rgb = function(minval, maxval, current_val, colors)
-	local max_index = #colors - 1
-	local val = (current_val-minval) / (maxval-minval) * max_index + 1.0
-	local index1 = math.floor(val)
-	local index2 = math.min(math.floor(val)+1, max_index + 1)
-	local f = val - index1
-	local c1 = colors[index1]
-	local c2 = colors[index2]
-	
-	return {
-		r=math.floor(c1.r + f*(c2.r - c1.r)), 
-		g=math.floor(c1.g + f*(c2.g-c1.g)), 
-		b=math.floor(c1.b + f*(c2.b - c1.b))
-	}
-end
-
--- Returns current layer color in {r, g, b} format
-local get_current_layer_color = function(layer_data)
-	-- min timeofday value 0; max timeofday value 1. So sky color gradient range will be between 0 and 1 * skycolor.max_value.
-	local timeofday = minetest.get_timeofday()
-	local min_val = layer_data.gradient_data.min_value
-	if min_val == nil then
-		min_val = gradient_default_min_value
-	end
-	local max_val = layer_data.gradient_data.max_value
-	if max_val == nil then
-		max_val = gradient_default_max_value
-	end
-	local rounded_time = math.floor(timeofday * max_val)
-	local gradient_colors = layer_data.gradient_data.colors
-	local color = convert_to_rgb(min_val, max_val, rounded_time, gradient_colors)
-	return color
-end
-
-local update_plain_sky = function(player, layer_data)
-	local color = get_current_layer_color(layer_data)
-	player:set_sky(color, "plain", nil)
-end
-
-local update_solid_color_sky = function(player, layer_data)
-	player:set_sky(layer_data.color, "plain", nil)
-end
-
-local update_skybox_sky = function(player, layer_data)
-	player:set_sky(layer_data.skybox[1], layer_data.skybox[2], layer_data.skybox[3])
-end
-
-local update_sky = function(player, timer)
-	local player_data = get_player_data(player:get_player_name())
-	if player_data == nil then return end
-
-	local current_layer = get_latest_layer(player_data.skylayers)
-	if current_layer == nil then
-		return
-	end
-
-	if current_layer.updated == false or timer >= skylayer.update_interval then
-		current_layer.updated = os.time()
-		
-		if current_layer.layer_type == skylayer.SKY_PLAIN then
-			update_plain_sky(player, current_layer.data)
-			return
-		end
-
-		if current_layer.layer_type == skylayer.SKY_SOLID_COLOR then
-			update_solid_color_sky(player, current_layer.data)
-			return
-		end
-
-		if current_layer.layer_type == skylayer.SKY_SKYBOX then
-			update_skybox_sky(player, current_layer.data)
-			return
-		end
-	end
-end
-
-skylayer.add_layer = function(player_name, layer)
-	if layer == nil or layer.name == nil then
-		minetest.log("error", "Incorrect skylayer definition")
-		return
-	end
-
-	local player_data = get_player_data(player_name)
-	if player_data == nil then
-		player_data = create_new_player_data(player_name)
-	end
-
-	if player_data == nil then
-		minetest.log("error", "Fail to add skylayer to player '" .. player_name .. "'")
-		return
-	end
-	layer.added_time = os.time()
-	layer.updated = false
-	table.insert(player_data.skylayers, layer)
-end
-
-skylayer.remove_layer = function(player_name, layer_name)
-	local player_data = get_player_data(player_name)
-	if player_data == nil or player_data.skylayers == nil then
-		return
-	end
-
-	if #player_data.skylayers == 0 then
-		return
-	end
-
-	for k, layer in ipairs(player_data.skylayers) do
-		if layer.name == layer_name then
-			table.remove(player_data.skylayers, k)
-			if #player_data.skylayers == 0 then
-				local player = get_player_by_name(player_name)
-				if player ~= nil then
-					set_default_sky(player)
-				end
-			end
-			return
-		end
-	end
-
-end
-
-minetest.register_globalstep(function(dtime)
-	if skylayer.enabled == false then
-		return
-	end
-
-	if #minetest.get_connected_players() == 0 then
-		return
-	end
-
-	-- timer addition calculated outside of players loop 
-	timer = timer + dtime;
-
-	for k, player in ipairs(minetest.get_connected_players()) do
-		update_sky(player, timer)
-	end
-
-	-- reset timer outside of loop to make sure that all players sky will be updated
-	if timer >= skylayer.update_interval then
-		timer = 0
-	end
-end)
-

init.lua

@@ -2,28 +2,37 @@ local modpath = minetest.get_modpath("weather_pack");
 
 -- If skylayer mod not located then embeded version will be loaded.
 if minetest.get_modpath("skylayer") == nil then
-  dofile(modpath.."/embedded_sky_layer_api.lua")
+	dofile(modpath.."/lib_sky_layer_api.lua")
 end
 
 -- If happy_weather_api mod not located then embeded version will be loaded.
 if minetest.get_modpath("happy_weather_api") == nil then
-  dofile(modpath.."/embedded_happy_weather_api.lua")
+	dofile(modpath.."/lib_happy_weather_api.lua")
-  dofile(modpath.."/commands.lua")
+	dofile(modpath.."/commands.lua")
+end
+
+legacy_MT_version = false
+if minetest.get_humidity == nil then
+	minetest.log("warning", "MOD [weather_pack]: Old Minetest version detected, some mod features will not work.")
+	legacy_MT_version = true
 end
 
 -- Happy Weather utilities
 dofile(modpath.."/utils.lua")
 
-dofile(modpath.."/light_rain.lua")
+dofile(modpath.."/weathers/light_rain.lua")
-dofile(modpath.."/rain.lua")
+dofile(modpath.."/weathers/rain.lua")
-dofile(modpath.."/heavy_rain.lua")
+dofile(modpath.."/weathers/heavy_rain.lua")
-dofile(modpath.."/snow.lua")
+dofile(modpath.."/weathers/snow.lua")
+dofile(modpath.."/weathers/snowstorm.lua")
 
 if minetest.get_modpath("lightning") ~= nil then
-  dofile(modpath.."/thunder.lua")
+	dofile(modpath.."/weathers/thunder.lua")
-  
+
-  -- Turn off lightning mod 'auto mode'
+	-- Turn off lightning mod 'auto mode'
-  lightning.auto = false
+	lightning.auto = false
 end
 
 dofile(modpath.."/abm.lua")
+
+minetest.log("action", "[weather_pack] loaded.")

lib_happy_weather_api.lua

@@ -11,6 +11,112 @@ happy_weather = {}
 -- Local variables which helps organize active and deactive weahers
 local registered_weathers = {}
 local active_weathers = {}
+local meta_plawpos = {} -- meta about Player Last Active Weaher Position
+
+------------------------------------
+-- Local helper / utility methods --
+------------------------------------
+
+-- Adds weather to active_weathers table
+local add_active_weather = function(weather_obj)
+	table.insert(active_weathers, weather_obj)
+end
+
+-- Remove weather from active_weathers table
+local remove_active_weather = function(weather_code)
+	if #active_weathers == 0 then
+		return
+	end
+
+	for k, weather_ in ipairs(active_weathers) do
+		if weather_.code == weather_code then
+			table.remove(active_weathers, k)
+			return
+		end
+	end
+end
+
+-- Returns active weather
+local get_active_weather = function(weather_code)
+	if #active_weathers == 0 then
+		return nil
+	end
+
+	for k, weather_ in ipairs(active_weathers) do
+		if weather_.code == weather_code then
+			return weather_
+		end
+	end
+end
+
+-- adds player to affected_players table
+local add_player = function(affected_players, player)
+	table.insert(affected_players, player)
+end
+
+-- remove player from affected_players table
+local remove_player = function(affected_players, player_name)
+	if #affected_players == 0 then
+		return
+	end
+
+	for k, player_ in ipairs(affected_players) do
+		if player_:get_player_name() == player_name then
+			table.remove(affected_players, k)
+			return
+		end
+	end
+end
+
+local is_player_affected = function(affected_players, player_name)
+	if #affected_players == 0 then
+		return false
+	end
+
+	for k, player_ in ipairs(affected_players) do
+		if player_:get_player_name() == player_name then
+			return true
+		end
+	end
+end
+
+
+local remove_meta_plawpos = function(weather_code, player_name)
+	if #meta_plawpos == 0 then
+		return
+	end
+
+	for k, meta_ in ipairs(meta_plawpos) do
+		if (meta_.name == player_name and meta_.code == weather_code) then
+			table.remove(meta_plawpos, k)
+		end
+	end
+end
+
+local add_meta_plawpos = function(weather_code, player)
+	local meta = {}
+	meta.code = weather_code
+	meta.pos = player:getpos()
+	meta.name = player:get_player_name()
+	
+	remove_meta_plawpos(weather_code, player:get_player_name())
+	table.insert(meta_plawpos, meta)
+end
+
+local get_meta_plawpos = function(weather_code, player_name)
+	if #meta_plawpos == 0 then
+		return nil
+	end
+
+	for k, meta_ in ipairs(meta_plawpos) do
+		if (meta_.name == player_name and meta_.code == weather_code) then
+			return meta_.pos
+		end
+	end
+
+	return nil
+end
+
 
 ---------------------------
 -- Weather API functions --
@@ -63,58 +169,17 @@ happy_weather.request_to_end = function(weather_code)
 	end
 end
 
-------------------------------------
+happy_weather.is_player_in_weather_area = function(player_name, weather_code)
--- Local helper / utility methods --
-------------------------------------
-
--- Adds weather to active_weathers table
-local add_active_weather = function(weather_obj)
-	table.insert(active_weathers, weather_obj)
-end
-
--- Remove weather from active_weathers table
-local remove_active_weather = function(weather_code)
 	if #active_weathers == 0 then
-		return
-	end
-
-	for k, weather_ in ipairs(active_weathers) do
-		if weather_.code == weather_code then
-			table.remove(active_weathers, k)
-			return
-		end
-	end
-end
-
--- adds player to affected_players table
-local add_player = function(affected_players, player)
-	table.insert(affected_players, player)
-end
-
--- remove player from affected_players table
-local remove_player = function(affected_players, player_name)
-	if #affected_players == 0 then
-		return
-	end
-
-	for k, player_ in ipairs(affected_players) do
-		if player_:get_player_name() == player_name then
-			table.remove(affected_players, k)
-			return
-		end
-	end
-end
-
-local is_player_affected = function(affected_players, player_name)
-	if #affected_players == 0 then
 		return false
 	end
 
-	for k, player_ in ipairs(affected_players) do
+	local active_weather = get_active_weather(weather_code)
-		if player_:get_player_name() == player_name then
+	if active_weather == nil then
-			return true
+		return false
-		end
 	end
+
+	return is_player_affected(active_weather.affected_players, player_name)
 end
 
 -----------------------------------------------------------------------------
@@ -153,7 +218,7 @@ local weather_remove_player = function(weather_obj, player)
 	weather_obj.remove_player(player)
 end
 
--- Weather remove_player method nil-safe wrapper
+-- Weather in_area method nil-safe wrapper
 local weather_in_area = function(weather_obj, position)
 	if weather_obj.in_area == nil then
 		return true
@@ -198,14 +263,36 @@ local prepare_starting = function(weather_obj)
 	add_active_weather(weather_obj)
 end
 
+local MAX_DISTANCE_FROM_WEATHER = 35
+
+-- This function aims to remove weather flickering effect when player walks on biome edge.
+-- To accomlish that extra distance is applied before removing player from weather affection.
+local is_outside_recent_weather = function(weather_code, player)
+	local pos = get_meta_plawpos(weather_code, player:get_player_name())
+	if pos == nil then
+		return false
+	end
+
+	local ppos = player:getpos()
+	local d = ((ppos.x - pos.x)^2 + (ppos.y - pos.y)^2 + (ppos.z - pos.z)^2)^0.5
+	return MAX_DISTANCE_FROM_WEATHER - d < 0
+end
+
+
 -- While still active weather can or can not affect players based on area they are
 local render_if_in_area = function(weather_obj, dtime, player)
 	if is_player_affected(weather_obj.affected_players, player:get_player_name()) then
 		if weather_in_area(weather_obj, player:getpos()) then
 			weather_render(weather_obj, dtime, player)
+			add_meta_plawpos(weather_obj.code, player)
 		else
-			weather_remove_player(weather_obj, player)
+			if (is_outside_recent_weather(weather_obj.code, player)) then
-			remove_player(weather_obj.affected_players, player:get_player_name())
+				weather_remove_player(weather_obj, player)
+				remove_player(weather_obj.affected_players, player:get_player_name())
+			-- render weather until player will be completely outside weather range
+			else
+				weather_render(weather_obj, dtime, player)
+			end
 		end
 	else
 		if weather_in_area(weather_obj, player:getpos()) then
@@ -239,7 +326,7 @@ minetest.register_globalstep(function(dtime)
 
 		-- Loop through connected players
 		for ii, player in ipairs(minetest.get_connected_players()) do
-			
+
 			-- Weaher is active checking if it about to end
 			if weather_.active then 
 				if weather_is_ending(weather_, dtime) or deactivate_weather then
@@ -254,7 +341,7 @@ minetest.register_globalstep(function(dtime)
 
 			-- Weaher is not active checking if it about to start
 			else
-				if weather_.is_starting(dtime, player:getpos()) then
+				if weather_is_starting(weather_, dtime, player:getpos()) then
 					activate_weather = true
 				end
 			end	

lib_sky_layer_api.lua

@@ -0,0 +1,364 @@
+
+
+-------------------------
+-- Sky Layers: Core
+
+-- License: MIT
+-- Credits: xeranas
+-- Thanks: Perkovec for colorise utils (github.com/Perkovec/colorise-lua) 
+-------------------------
+
+local colorise = {}
+
+colorise.rgb2hex = function (rgb)
+	local hexadecimal = '#'
+
+	for key = 1, #rgb do
+	    local value = rgb[key] 
+		local hex = ''
+
+		while(value > 0)do
+			local index = math.fmod(value, 16) + 1
+			value = math.floor(value / 16)
+			hex = string.sub('0123456789ABCDEF', index, index) .. hex			
+		end
+
+		if(string.len(hex) == 0)then
+			hex = '00'
+		elseif(string.len(hex) == 1)then
+			hex = '0' .. hex
+		end
+		hexadecimal = hexadecimal .. hex
+	end
+
+	return hexadecimal
+end
+
+local core = {}
+
+core.settings = {}
+
+-- flag to disable skylayer at global step
+core.settings.enabled = true
+
+-- default gradient interval values
+core.settings.gradient_default_min_value = 0
+core.settings.gradient_default_max_value = 1000
+
+-- how often sky will be updated in seconds
+core.settings.update_interval = 4
+
+-- helps track total dtime
+core.timer = 0
+
+core.default_clouds = nil
+
+-- keeps player related data such as player itself and own sky layers
+core.sky_players = {}
+
+-- adds player to sky layer affected players list
+core.add_player = function(player)
+	local data = {}
+	data.id = player:get_player_name()
+	data.player = player
+	data.skylayers = {}
+	table.insert(core.sky_players, data)
+end
+
+-- remove player from sky layer affected players list
+core.remove_player = function(player_name)
+	if #core.sky_players == 0 then
+		return
+	end
+	for k, player_data in ipairs(core.sky_players) do
+		if player_data.id == player_name then
+			reset_sky(player_data.player)
+			table.remove(core.sky_players, k)
+			return
+		end
+	end
+end
+
+core.get_player_by_name = function(player_name)
+	if player_name == nil then
+		return nil
+	end
+	if #minetest.get_connected_players() == 0 then
+		return nil
+	end
+	for i, player in ipairs(minetest.get_connected_players()) do
+		if player:get_player_name() == player_name then
+			return player
+		end
+	end
+	return nil
+end
+
+core.get_player_data = function(player_name)
+	if #core.sky_players == 0 then
+		return nil
+	end
+	for k, player_data in ipairs(core.sky_players) do
+		if player_data.id == player_name then
+			return player_data
+		end
+	end	
+end
+
+core.create_new_player_data = function(player_name)
+	local player_data = core.get_player_data(player_name)
+	if player_data == nil then
+		local player = core.get_player_by_name(player_name)
+		if player == nil then
+			minetest.log("error", "Fail to resolve player '" .. player_name .. "'")
+			return
+		end
+		core.add_player(player)
+		return core.get_player_data(player_name)
+	end
+	return player_data
+end
+
+-- sets default / regular sky for player
+core.reset_sky = function(player)
+	core.set_default_sky(player)
+	core.set_default_clouds(player)
+end
+
+core.set_default_sky = function(player)
+	player:set_sky(nil, "regular", nil)
+end
+
+core.set_default_clouds = function(player)
+	player:set_clouds(core.default_clouds)
+end
+
+-- resolves latest skylayer based on added layer time
+core.get_latest_layer = function(layers)
+	if #layers == 0 then
+		return nil
+	end
+
+	local latest_layer = nil
+	for k, layer in ipairs(layers) do
+		if latest_layer == nil then
+			latest_layer = layer
+		else
+			if layer.added_time >= latest_layer.added_time then
+				latest_layer = layer
+			end
+		end
+	end
+
+	return latest_layer
+end
+
+core.convert_to_rgb = function(minval, maxval, current_val, colors)
+	local max_index = #colors - 1
+	local val = (current_val-minval) / (maxval-minval) * max_index + 1.0
+	local index1 = math.floor(val)
+	local index2 = math.min(math.floor(val)+1, max_index + 1)
+	local f = val - index1
+	local c1 = colors[index1]
+	local c2 = colors[index2]
+	
+	return {
+		r=math.floor(c1.r + f*(c2.r - c1.r)), 
+		g=math.floor(c1.g + f*(c2.g-c1.g)), 
+		b=math.floor(c1.b + f*(c2.b - c1.b))
+	}
+end
+
+-- Returns current gradient color in {r, g, b} format
+core.calculate_current_gradient_color = function(gradient_colors, min_val, max_val)
+	if gradient_colors == nil then return nil end
+	local timeofday = minetest.get_timeofday()
+	if min_val == nil then
+		min_val = core.settings.gradient_default_min_value
+	end
+	if max_val == nil then
+		max_val = core.settings.gradient_default_max_value
+	end
+	local rounded_time = math.floor(timeofday * max_val)
+	return core.convert_to_rgb(min_val, max_val, rounded_time, gradient_colors)
+end
+
+-- Returns current sky color in {r, g, b} format
+core.get_current_layer_color = function(gradient_colors, min_val, max_val)
+	return core.calculate_current_gradient_color(gradient_colors, min_val, max_val)
+end
+
+-- Returns current cloud color in hex format
+core.get_current_cloud_color = function(gradient_colors, min_val, max_val)
+	local rgb_color = core.calculate_current_gradient_color(gradient_colors, min_val, max_val)
+	if rgb_color == nil then return nil end
+	return colorise.rgb2hex({rgb_color.r, rgb_color.g, rgb_color.b}) 
+end
+
+core.update_sky_details = function(player, sky_layer)
+	local sky_data = sky_layer.sky_data
+
+	if sky_data == nil then 
+		if sky_layer.reset_defaults == true then
+			core.set_default_sky(player)
+			sky_layer.reset_defaults = false
+		end
+		return
+	end
+
+	local sky_color = core.get_current_layer_color(
+		sky_data.gradient_colors, 
+		sky_data.gradient_min_value,
+		sky_data.gradient_max_value)
+	local bgcolor = sky_data.bgcolor
+	if sky_color ~= nil then
+		bgcolor = sky_color
+	end
+	local sky_type = "plain" -- default
+	if sky_data.type ~= nil then
+		sky_type = sky_data.type
+	end
+	local clouds = sky_layer.clouds_data ~= nil
+	if sky_data.clouds ~= nil then
+		clouds = sky_data.clouds
+	end
+	player:set_sky(bgcolor, sky_type, sky_data.textures, clouds)	
+end
+
+core.update_clouds_details = function(player, sky_layer)
+	local clouds_data = sky_layer.clouds_data
+
+	if clouds_data == nil then 
+		if sky_layer.reset_defaults == true then
+			core.set_default_clouds(player)
+			sky_layer.reset_defaults = false
+		end
+		return
+	end
+
+	local cloud_color = core.get_current_cloud_color(
+		clouds_data.gradient_colors, 
+		clouds_data.gradient_min_value,
+		clouds_data.gradient_max_value)
+	if cloud_color == nil then
+		cloud_color = clouds_data.color
+	end
+	player:set_clouds({
+		color = cloud_color,
+		density = clouds_data.density,
+		ambient = clouds_data.ambient,
+		height = clouds_data.height,
+		thickness = clouds_data.thickness,
+		speed = clouds_data.speed})
+end
+
+core.update_sky = function(player, timer)
+	local player_data = core.get_player_data(player:get_player_name())
+	if player_data == nil then return end
+
+	local current_layer = core.get_latest_layer(player_data.skylayers)
+	if current_layer == nil then
+		return
+	end
+
+	if skylayer.update_interval == nil then
+		skylayer.update_interval = core.settings.update_interval
+	end
+
+	if player_data.last_active_layer == nil or player_data.last_active_layer ~= current_layer.name then
+		current_layer.reset_defaults = true
+	end
+	player_data.last_active_layer = current_layer.name
+
+	if current_layer.updated == false or core.timer >= skylayer.update_interval then
+		current_layer.updated = os.time()
+		core.update_sky_details(player, current_layer)
+		core.update_clouds_details(player, current_layer)
+	end
+end
+
+minetest.register_on_joinplayer(function(player)
+	if core.default_clouds == nil then
+		core.default_clouds = player:get_clouds()
+	end
+end)
+
+minetest.register_globalstep(function(dtime)
+	if core.settings.enabled == false then
+		return
+	end
+
+	if #minetest.get_connected_players() == 0 then
+		return
+	end
+
+	-- timer addition calculated outside of players loop 
+	core.timer = core.timer + dtime;
+
+	for k, player in ipairs(minetest.get_connected_players()) do
+		core.update_sky(player, core.timer)
+	end
+
+	-- reset timer outside of loop to make sure that all players sky will be updated
+	if core.timer >= core.settings.update_interval then
+		core.timer = 0
+	end
+end)
+
+-------------------------
+-- Sky Layers: API
+
+-- License: MIT
+-- Credits: xeranas
+-------------------------
+
+skylayer = {}
+
+-- set flag for enable / disable skylayer
+skylayer.is_enabled = function(enabled)
+	core.settings.enabled = enabled
+end
+
+skylayer.add_layer = function(player_name, layer)
+	if layer == nil or layer.name == nil then
+		minetest.log("error", "Incorrect skylayer definition")
+		return
+	end
+
+	local player_data = core.get_player_data(player_name)
+	if player_data == nil then
+		player_data = core.create_new_player_data(player_name)
+	end
+
+	if player_data == nil then
+		minetest.log("error", "Fail to add skylayer to player '" .. player_name .. "'")
+		return
+	end
+	layer.added_time = os.time()
+	layer.updated = false
+	table.insert(player_data.skylayers, layer)
+end
+
+skylayer.remove_layer = function(player_name, layer_name)
+	local player_data = core.get_player_data(player_name)
+	if player_data == nil or player_data.skylayers == nil then
+		return
+	end
+
+	if #player_data.skylayers == 0 then
+		return
+	end
+
+	for k, layer in ipairs(player_data.skylayers) do
+		if layer.name == layer_name then
+			table.remove(player_data.skylayers, k)
+			if #player_data.skylayers == 0 then
+				local player = core.get_player_by_name(player_name)
+				if player ~= nil then
+					core.reset_sky(player)
+				end
+			end
+			return
+		end
+	end
+end

utils.lua

@@ -6,10 +6,12 @@
 -- Credits: xeranas
 ---------------------------------------
 
-if hw_utils == nil then
+if not minetest.global_exists("hw_utils") then
 	hw_utils = {}
 end
 
+local mg_name = minetest.get_mapgen_setting("mg_name")
+
 -- outdoor check based on node light level
 hw_utils.is_outdoor = function(pos, offset_y)
 	if offset_y == nil then
@@ -25,52 +27,102 @@ end
 -- checks if player is undewater. This is needed in order to
 -- turn off weather particles generation.
 hw_utils.is_underwater = function(player)
-    local ppos = player:getpos()
+	local ppos = player:getpos()
-    local offset = player:get_eye_offset()
+	local offset = player:get_eye_offset()
-    local player_eye_pos = {x = ppos.x + offset.x, 
+	local player_eye_pos = {
-                            y = ppos.y + offset.y + 1.5, 
+		x = ppos.x + offset.x, 
-                            z = ppos.z + offset.z}
+		y = ppos.y + offset.y + 1.5, 
-    local node_level = minetest.get_node_level(player_eye_pos)
+		z = ppos.z + offset.z}
-    if node_level == 8 or node_level == 7 then
+	local node_level = minetest.get_node_level(player_eye_pos)
-      return true
+	if node_level == 8 or node_level == 7 then
-    end
+		return true
-    return false
+	end
+	return false
 end
 
 -- trying to locate position for particles by player look direction for performance reason.
 -- it is costly to generate many particles around player so goal is focus mainly on front view.  
 hw_utils.get_random_pos = function(player, offset)
-  local look_dir = player:get_look_dir()
+	local look_dir = player:get_look_dir()
-  local player_pos = player:getpos()
+	local player_pos = player:getpos()
 
-  local random_pos_x = 0
+	local random_pos_x = 0
-  local random_pos_y = 0
+	local random_pos_y = 0
-  local random_pos_z = 0
+	local random_pos_z = 0
 
-  if look_dir.x > 0 then
+	if look_dir.x > 0 then
-    if look_dir.z > 0 then
+		if look_dir.z > 0 then
-      random_pos_x = math.random(player_pos.x - offset.back, player_pos.x + offset.front) + math.random()
+			random_pos_x = math.random(player_pos.x - offset.back, player_pos.x + offset.front) + math.random()
-      random_pos_z = math.random(player_pos.z - offset.back, player_pos.z + offset.front) + math.random() 
+			random_pos_z = math.random(player_pos.z - offset.back, player_pos.z + offset.front) + math.random() 
-    else
+		else
-      random_pos_x = math.random(player_pos.x - offset.back, player_pos.x + offset.front) + math.random()
+			random_pos_x = math.random(player_pos.x - offset.back, player_pos.x + offset.front) + math.random()
-      random_pos_z = math.random(player_pos.z - offset.front, player_pos.z + offset.back) + math.random()
+			random_pos_z = math.random(player_pos.z - offset.front, player_pos.z + offset.back) + math.random()
-    end
+		end
-  else
+	else
-    if look_dir.z > 0 then
+		if look_dir.z > 0 then
-      random_pos_x = math.random(player_pos.x - offset.front, player_pos.x + offset.back) + math.random()
+			random_pos_x = math.random(player_pos.x - offset.front, player_pos.x + offset.back) + math.random()
-      random_pos_z = math.random(player_pos.z - offset.back, player_pos.z + offset.front) + math.random()
+			random_pos_z = math.random(player_pos.z - offset.back, player_pos.z + offset.front) + math.random()
-    else
+		else
-      random_pos_x = math.random(player_pos.x - offset.front, player_pos.x + offset.back) + math.random()
+			random_pos_x = math.random(player_pos.x - offset.front, player_pos.x + offset.back) + math.random()
-      random_pos_z = math.random(player_pos.z - offset.front, player_pos.z + offset.back) + math.random()
+			random_pos_z = math.random(player_pos.z - offset.front, player_pos.z + offset.back) + math.random()
-    end
+		end
-  end
+	end
 
-  if offset.bottom ~= nil then
+	if offset.bottom ~= nil then
-  	random_pos_y = math.random(player_pos.y - offset.bottom, player_pos.y + offset.top)
+		random_pos_y = math.random(player_pos.y - offset.bottom, player_pos.y + offset.top)
-  else
+	else
-  	random_pos_y = player_pos.y + offset.top
+		random_pos_y = player_pos.y + offset.top
-  end
+	end
 
-  
+	return {x=random_pos_x, y=random_pos_y, z=random_pos_z}
-  return {x=random_pos_x, y=random_pos_y, z=random_pos_z}
+end
-end
+
+local is_biome_frozen = function(position)
+	if legacy_MT_version then
+		return false;
+	end
+	local heat = minetest.get_heat(position)
+	-- below 35 heat biome considered to be frozen type
+	return heat < 35
+end
+
+hw_utils.is_biome_frozen = function(position)
+	if mg_name == "v6" then
+		return false -- v6 not supported.
+	end
+	return is_biome_frozen(position)
+end
+
+local is_biome_dry = function(position)
+	if legacy_MT_version then
+		return false;
+	end
+	local humidity = minetest.get_humidity(position)
+	local heat = minetest.get_heat(position)
+	return humidity < 50 and heat > 65
+end
+
+hw_utils.is_biome_dry = function(position)
+	if mg_name == "v6" then
+		return false
+	end
+	return is_biome_dry(position)
+end
+
+local is_biome_tropic = function(position)
+	if legacy_MT_version then
+		return false;
+	end
+	local humidity = minetest.get_humidity(position)
+	local heat = minetest.get_heat(position)
+
+	-- humid and temp values are taked by testing flying around world (not sure actually)
+	return humidity > 55 and heat > 70
+end
+
+hw_utils.is_biome_tropic = function(position)
+	if mg_name == "v6" then
+		return false -- v6 not supported yet.
+	end
+	return is_biome_tropic(position)
+end

weathers/heavy_rain.lua

@@ -8,7 +8,7 @@
 
 local heavy_rain = {}
 heavy_rain.last_check = 0
-heavy_rain.check_interval = 600
+heavy_rain.check_interval = 200
 
 -- Weather identification code
 heavy_rain.code = "heavy_rain"
@@ -26,7 +26,12 @@ local SKYCOLOR_LAYER = "happy_weather_heavy_rain_sky"
 heavy_rain.is_starting = function(dtime, position)
 	if heavy_rain.last_check + heavy_rain.check_interval < os.time() then
 		heavy_rain.last_check = os.time()
-		if math.random() < 0.05 then
+		local heavy_rain_chance = 0.06
+		if hw_utils.is_biome_tropic(position) then
+			heavy_rain_chance = 0.4
+		end
+
+		if math.random() < heavy_rain_chance then
 			happy_weather.request_to_end("light_rain")
       		happy_weather.request_to_end("rain")
 			return true
@@ -45,7 +50,9 @@ heavy_rain.is_ending = function(dtime)
 	if heavy_rain.last_check + heavy_rain.check_interval < os.time() then
 		heavy_rain.last_check = os.time()
 		if math.random() < 0.7 then
-			happy_weather.request_to_start("rain")
+			if math.random() < 0.4 then
+				happy_weather.request_to_start("rain")
+			end
 			return true
 		end
 	end
@@ -60,15 +67,26 @@ end
 
 local set_sky_box = function(player_name)
 	local sl = {}
-	sl.layer_type = skylayer.SKY_PLAIN
 	sl.name = SKYCOLOR_LAYER
-	sl.data = {gradient_data={}}
+	sl.sky_data = {
-	sl.data.gradient_data.colors = {
+		gradient_colors = {
-		{r=0, g=0, b=0},
+			{r=0, g=0, b=0},
-		{r=65, g=66, b=78},
+			{r=85, g=86, b=98},
-		{r=112, g=110, b=119},
+			{r=142, g=140, b=149},
-		{r=65, g=66, b=78},
+			{r=85, g=86, b=98},
-		{r=0, g=0, b=0}
+			{r=0, g=0, b=0}
+		},
+	}
+	sl.clouds_data = {
+		gradient_colors = {
+			{r=0, g=0, b=0},
+			{r=65, g=66, b=78},
+			{r=112, g=110, b=119},
+			{r=65, g=66, b=78},
+			{r=0, g=0, b=0}
+		},
+		speed = {z = 10, y = -40},
+		density = 0.6
 	}
 	skylayer.add_layer(player_name, sl)
 end
@@ -146,6 +164,7 @@ local add_wide_range_rain_particle = function(player)
 		  collisiondetection = true,
 		  collision_removal = true,
 		  vertical = true,
+		  
 		  texture = rain_drop_texture,
 		  playername = player:get_player_name()
 		})
@@ -178,7 +197,12 @@ heavy_rain.stop = function()
 end
 
 heavy_rain.in_area = function(position)
-	if position.y > -10 then
+	if hw_utils.is_biome_frozen(position) or 
+		hw_utils.is_biome_dry(position) then
+		return false
+	end
+
+	if position.y > -10 and position.y < 120 then
 		return true
 	end
 	return false

weathers/light_rain.lua

@@ -8,7 +8,8 @@
 
 local light_rain = {}
 light_rain.last_check = 0
-light_rain.check_interval = 300
+light_rain.check_interval = 200
+light_rain.chance = 0.15
 
 -- Weather identification code
 light_rain.code = "light_rain"
@@ -26,7 +27,7 @@ local SKYCOLOR_LAYER = "happy_weather_light_rain_sky"
 light_rain.is_starting = function(dtime, position)
 	if light_rain.last_check + light_rain.check_interval < os.time() then
 		light_rain.last_check = os.time()
-		if math.random() < 0.2 then
+		if math.random() < light_rain.chance then
 			return true
 		end
 	end
@@ -42,7 +43,7 @@ end
 light_rain.is_ending = function(dtime)
 	if light_rain.last_check + light_rain.check_interval < os.time() then
 		light_rain.last_check = os.time()
-		if math.random() < 0.4 then
+		if math.random() < 0.5 then
 			return true
 		end
 	end
@@ -57,15 +58,16 @@ end
 
 local set_sky_box = function(player_name)
 	local sl = {}
-	sl.layer_type = skylayer.SKY_PLAIN
 	sl.name = SKYCOLOR_LAYER
-	sl.data = {gradient_data={}}
+	sl.clouds_data = {
-	sl.data.gradient_data.colors = {
+		gradient_colors = {
-		{r=0, g=0, b=0},
+			{r=50, g=50, b=50},
-		{r=85, g=86, b=98},
+			{r=120, g=120, b=120},
-		{r=152, g=150, b=159},
+			{r=200, g=200, b=200},
-		{r=85, g=86, b=98},
+			{r=120, g=120, b=120},
-		{r=0, g=0, b=0}
+			{r=50, g=50, b=50}
+		},
+		density = 0.6
 	}
 	skylayer.add_layer(player_name, sl)
 end
@@ -83,7 +85,7 @@ local remove_rain_sound = function(player)
 	if sound ~= nil then
 		minetest.sound_stop(sound)
 		sound_handlers[player:get_player_name()] = nil
-  	end
+	end
 end
 
 light_rain.add_player = function(player)
@@ -98,16 +100,10 @@ end
 
 -- Random texture getter
 local choice_random_rain_drop_texture = function()
-	local texture_name
+	local base_name = "happy_weather_light_rain_raindrop_"
-	local random_number = math.random()
+	local number = math.random(1, 4)
-	if random_number > 0.33 then
+	local extension = ".png"
-		texture_name = "happy_weather_light_rain_raindrop_1.png"
+	return base_name .. number .. extension
-	elseif random_number > 0.66 then
-		texture_name = "happy_weather_light_rain_raindrop_2.png"
-	else
-		texture_name = "happy_weather_light_rain_raindrop_3.png"
-	end
-	return texture_name;
 end
 
 local add_rain_particle = function(player)
@@ -121,16 +117,16 @@ local add_rain_particle = function(player)
 
 	if hw_utils.is_outdoor(random_pos) then
 		minetest.add_particle({
-		  pos = {x=random_pos.x, y=random_pos.y, z=random_pos.z},
+			pos = {x=random_pos.x, y=random_pos.y, z=random_pos.z},
-		  velocity = {x=0, y=-10, z=0},
+			velocity = {x=0, y=-10, z=0},
-		  acceleration = {x=0, y=-30, z=0},
+			acceleration = {x=0, y=-30, z=0},
-		  expirationtime = 2,
+			expirationtime = 2,
-		  size = math.random(0.5, 3),
+			size = math.random(0.5, 3),
-		  collisiondetection = true,
+			collisiondetection = true,
-		  collision_removal = true,
+			collision_removal = true,
-		  vertical = true,
+			vertical = true,
-		  texture = choice_random_rain_drop_texture(),
+			texture = choice_random_rain_drop_texture(),
-		  playername = player:get_player_name()
+			playername = player:get_player_name()
 		})
 	end
 end
@@ -144,7 +140,12 @@ local display_rain_particles = function(player)
 end
 
 light_rain.in_area = function(position)
-	if position.y > -10 then
+	if hw_utils.is_biome_frozen(position) or 
+		hw_utils.is_biome_dry(position) then
+		return false
+	end
+
+	if position.y > -10 and position.y < 120 then
 		return true
 	end
 	return false

weathers/rain.lua

@@ -8,7 +8,8 @@
 
 local rain = {}
 rain.last_check = 0
-rain.check_interval = 400
+rain.check_interval = 300
+rain.chance = 0.1
 
 -- Weather identification code
 rain.code = "rain"
@@ -24,14 +25,14 @@ local manual_trigger_end = false
 local SKYCOLOR_LAYER = "happy_weather_rain_sky"
 
 rain.is_starting = function(dtime, position)
-  if rain.last_check + rain.check_interval < os.time() then
+	if rain.last_check + rain.check_interval < os.time() then
-    rain.last_check = os.time()
+		rain.last_check = os.time()
-    if math.random() < 0.1 then
+		if math.random() < rain.chance then
-      happy_weather.request_to_end("light_rain")
+			happy_weather.request_to_end("light_rain")
-      happy_weather.request_to_end("heavy_rain")
+			happy_weather.request_to_end("heavy_rain")
-      return true
+			return true
-    end
+		end
-  end
+	end
 
 	if manual_trigger_start then
 		manual_trigger_start = false
@@ -42,13 +43,13 @@ rain.is_starting = function(dtime, position)
 end
 
 rain.is_ending = function(dtime)
-  if rain.last_check + rain.check_interval < os.time() then
+	if rain.last_check + rain.check_interval < os.time() then
-    rain.last_check = os.time()
+		rain.last_check = os.time()
-    if math.random() < 0.3 then
+		if math.random() < 0.6 then
-      happy_weather.request_to_start("light_rain")
+			happy_weather.request_to_start("light_rain")
-      return true
+			return true
-    end
+		end
-  end
+	end
 
 	if manual_trigger_end then
 		manual_trigger_end = false
@@ -62,13 +63,24 @@ local set_sky_box = function(player_name)
 	local sl = {}
 	sl.layer_type = skylayer.SKY_PLAIN
 	sl.name = SKYCOLOR_LAYER
-	sl.data = {gradient_data={}}
+	sl.sky_data = {
-	sl.data.gradient_data.colors = {
+		gradient_colors = {
-		{r=0, g=0, b=0},
+			{r=0, g=0, b=0},
-		{r=85, g=86, b=98},
+			{r=65, g=66, b=78},
-		{r=152, g=150, b=159},
+			{r=112, g=110, b=119},
-		{r=85, g=86, b=98},
+			{r=65, g=66, b=78},
-		{r=0, g=0, b=0}
+			{r=0, g=0, b=0}
+		},
+	}
+	sl.clouds_data = {
+		gradient_colors = {
+			{r=10, g=10, b=10},
+			{r=55, g=56, b=68},
+			{r=102, g=100, b=109},
+			{r=55, g=56, b=68},
+			{r=10, g=10, b=10}
+		},
+		density = 0.5
 	}
 	skylayer.add_layer(player_name, sl)
 end
@@ -86,7 +98,7 @@ local remove_rain_sound = function(player)
 	if sound ~= nil then
 		minetest.sound_stop(sound)
 		sound_handlers[player:get_player_name()] = nil
-  	end
+	end
 end
 
 rain.add_player = function(player)
@@ -101,16 +113,10 @@ end
 
 -- Random texture getter
 local choice_random_rain_drop_texture = function()
-	local texture_name
+	local base_name = "happy_weather_light_rain_raindrop_"
-	local random_number = math.random()
+	local number = math.random(1, 4)
-  if random_number > 0.33 then
+	local extension = ".png"
-    texture_name = "happy_weather_light_rain_raindrop_1.png"
+	return base_name .. number .. extension
-  elseif random_number > 0.66 then
-    texture_name = "happy_weather_light_rain_raindrop_2.png"
-  else
-    texture_name = "happy_weather_light_rain_raindrop_3.png"
-  end
-	return texture_name;
 end
 
 local add_rain_particle = function(player)
@@ -124,16 +130,16 @@ local add_rain_particle = function(player)
 
 	if hw_utils.is_outdoor(random_pos) then
 		minetest.add_particle({
-		  pos = {x=random_pos.x, y=random_pos.y, z=random_pos.z},
+			pos = {x=random_pos.x, y=random_pos.y, z=random_pos.z},
-		  velocity = {x=0, y=-15, z=0},
+			velocity = {x=0, y=-15, z=0},
-		  acceleration = {x=0, y=-35, z=0},
+			acceleration = {x=0, y=-35, z=0},
-		  expirationtime = 2,
+			expirationtime = 2,
-		  size = math.random(1, 6),
+			size = math.random(1, 4),
-		  collisiondetection = true,
+			collisiondetection = true,
-		  collision_removal = true,
+			collision_removal = true,
-		  vertical = true,
+			vertical = true,
-		  texture = choice_random_rain_drop_texture(),
+			texture = choice_random_rain_drop_texture(),
-		  playername = player:get_player_name()
+			playername = player:get_player_name()
 		})
 	end
 end
@@ -147,7 +153,12 @@ local display_rain_particles = function(player)
 end
 
 rain.in_area = function(position)
-	if position.y > -10 then
+	if hw_utils.is_biome_frozen(position) or 
+		hw_utils.is_biome_dry(position) then
+		return false
+	end
+
+	if position.y > -10 and position.y < 120 then
 		return true
 	end
 	return false

weathers/snow.lua

@@ -7,6 +7,9 @@
 ------------------------------
 
 local snow = {}
+snow.last_check = 0
+snow.check_interval = 200
+snow.chance = 0.2
 
 -- Weather identification code
 snow.code = "snow"
@@ -19,6 +22,13 @@ local manual_trigger_end = false
 local SKYCOLOR_LAYER = "happy_weather_snow_sky"
 
 snow.is_starting = function(dtime, position)
+	if snow.last_check + snow.check_interval < os.time() then
+		snow.last_check = os.time()
+		if math.random() < snow.chance then
+			return true
+		end
+	end
+
 	if manual_trigger_start then
 		manual_trigger_start = false
 		return true
@@ -28,6 +38,13 @@ snow.is_starting = function(dtime, position)
 end
 
 snow.is_ending = function(dtime)
+	if snow.last_check + snow.check_interval < os.time() then
+		snow.last_check = os.time()
+		if math.random() < 0.5 then
+			return true
+		end
+	end
+
 	if manual_trigger_end then
 		manual_trigger_end = false
 		return true
@@ -38,13 +55,13 @@ end
 
 local set_sky_box = function(player_name)
 	local sl = {}
-	sl.layer_type = skylayer.SKY_PLAIN
 	sl.name = SKYCOLOR_LAYER
-	sl.data = {gradient_data={}}
+	sl.sky_data = {
-	sl.data.gradient_data.colors = {
+		gradient_colors = {
-		{r=0, g=0, b=0},
+			{r=0, g=0, b=0},
-		{r=241, g=244, b=249},
+			{r=231, g=234, b=239},
-		{r=0, g=0, b=0}
+			{r=0, g=0, b=0}
+		}
 	}
 	skylayer.add_layer(player_name, sl)
 end
@@ -59,16 +76,10 @@ end
 
 -- Random texture getter
 local choice_random_rain_drop_texture = function()
-	local texture_name
+	local base_name = "happy_weather_light_snow_snowflake_"
-	local random_number = math.random()
+	local number = math.random(1, 3)
-	if random_number > 0.33 then
+	local extension = ".png"
-		texture_name = "happy_weather_light_snow_snowflake_1.png"
+	return base_name .. number .. extension
-	elseif random_number > 0.66 then
-		texture_name = "happy_weather_light_snow_snowflake_2.png"
-	else
-		texture_name = "happy_weather_light_snow_snowflake_3.png"
-	end
-	return texture_name;
 end
 
 local add_particle = function(player)
@@ -84,9 +95,9 @@ local add_particle = function(player)
 		minetest.add_particle({
 			pos = {x=random_pos.x, y=random_pos.y, z=random_pos.z},
 			velocity = {x = math.random(-1,-0.5), y = math.random(-2,-1), z = math.random(-1,-0.5)},
-        	acceleration = {x = math.random(-1,-0.5), y=-0.5, z = math.random(-1,-0.5)},
+			acceleration = {x = math.random(-1,-0.5), y=-0.5, z = math.random(-1,-0.5)},
-        	expirationtime = 2.0,
+			expirationtime = 2.0,
-        	size = math.random(0.5, 2),
+			size = math.random(0.5, 2),
 			collisiondetection = true,
 			collision_removal = true,
 			vertical = true,
@@ -106,9 +117,20 @@ end
 
 local particles_number_per_update = 10
 snow.render = function(dtime, player)
-  for i=particles_number_per_update, 1,-1 do
+	for i=particles_number_per_update, 1,-1 do
-    display_particles(player)
+		display_particles(player)
-  end
+	end
+end
+
+snow.in_area = function(position)
+	if hw_utils.is_biome_frozen(position) == false then
+		return false
+	end
+
+	if position.y > -10 and position.y < 120 then
+		return true
+	end
+	return false
 end
 
 snow.start = function()

weathers/snowstorm.lua

@@ -0,0 +1,203 @@
+----------------------------
+-- Happy Weather: Snowfall
+
+-- License: MIT
+
+-- Credits: xeranas
+----------------------------
+
+local snowstorm = {}
+
+-- Weather identification code
+snowstorm.code = "snowstorm"
+snowstorm.last_check = 0
+snowstorm.check_interval = 300
+snowstorm.chance = 0.05
+
+-- Keeps sound handler references
+local sound_handlers = {}
+
+-- Manual triggers flags
+local manual_trigger_start = false
+local manual_trigger_end = false
+
+-- Skycolor layer id
+local SKYCOLOR_LAYER = "happy_weather_snowstorm_sky"
+
+local set_weather_sound = function(player) 
+	return minetest.sound_play("happy_weather_snowstorm", {
+		object = player,
+		max_hear_distance = 2,
+		loop = true,
+	})
+end
+
+local remove_weather_sound = function(player)
+	local sound = sound_handlers[player:get_player_name()]
+	if sound ~= nil then
+		minetest.sound_stop(sound)
+		sound_handlers[player:get_player_name()] = nil
+	end
+end
+
+snowstorm.is_starting = function(dtime, position)
+	if snowstorm.last_check + snowstorm.check_interval < os.time() then
+		snowstorm.last_check = os.time()
+		if math.random() < snowstorm.chance then
+			return true
+		end
+	end
+
+	if manual_trigger_start then
+		manual_trigger_start = false
+		return true
+	end
+	
+	return false
+end
+
+snowstorm.is_ending = function(dtime)
+	if manual_trigger_end then
+		manual_trigger_end = false
+		return true
+	end
+
+	return false
+end
+
+local set_sky_box = function(player_name)
+	local sl = {}
+	sl.layer_type = skylayer.SKY_PLAIN
+	sl.name = SKYCOLOR_LAYER
+	sl.sky_data = {
+		gradient_colors = {
+			{r=0, g=0, b=0},
+			{r=231, g=234, b=239},
+			{r=0, g=0, b=0}
+		}
+	}
+	skylayer.add_layer(player_name, sl)
+end
+
+snowstorm.in_area = function(position)
+	if hw_utils.is_biome_frozen(position) == false then
+		return false
+	end
+
+	if position.y > 30 and position.y < 140 then
+		return true
+	end
+	return false
+end
+
+snowstorm.add_player = function(player)
+	sound_handlers[player:get_player_name()] = set_weather_sound(player)
+	set_sky_box(player:get_player_name())
+end
+
+snowstorm.remove_player = function(player)
+	remove_weather_sound(player)
+	skylayer.remove_layer(player:get_player_name(), SKYCOLOR_LAYER)
+end
+
+local rain_drop_texture = "happy_weather_snowstorm.png"
+
+local sign = function (number)
+	if number >= 0 then
+		return 1
+	else
+		return -1
+	end
+end
+
+local add_wide_range_rain_particle = function(player)
+	local offset = {
+		front = 7,
+		back = 4,
+		top = 3,
+		bottom = 0
+	}
+
+	local random_pos = hw_utils.get_random_pos(player, offset)
+	local p_pos = player:getpos()
+
+	local look_dir = player:get_look_dir()
+
+	if hw_utils.is_outdoor(random_pos) then
+		minetest.add_particle({
+			pos = {x=random_pos.x, y=random_pos.y, z=random_pos.z},
+		  	velocity = {x = sign(look_dir.x) * -10, y = -1, z = sign(look_dir.z) * -10},
+		  	acceleration = {x = sign(look_dir.x) * -10, y = -1, z = sign(look_dir.z) * -10},
+		  	expirationtime = 0.3,
+		  	size = 30,
+		  	collisiondetection = true,
+		  	texture = "happy_weather_snowstorm.png",
+		  	playername = player:get_player_name()
+		})
+	end
+end
+
+
+-- Random texture getter
+local choice_random_rain_drop_texture = function()
+	local base_name = "happy_weather_light_snow_snowflake_"
+	local number = math.random(1, 3)
+	local extension = ".png"
+	return base_name .. number .. extension
+end
+
+local add_snow_particle = function(player)
+	local offset = {
+		front = 5,
+		back = 2,
+		top = 4
+	}
+
+	local random_pos = hw_utils.get_random_pos(player, offset)
+
+	if hw_utils.is_outdoor(random_pos) then
+		minetest.add_particle({
+			pos = {x=random_pos.x, y=random_pos.y, z=random_pos.z},
+			velocity = {x = math.random(-5,-2.5), y = math.random(-10,-5), z = math.random(-5,-2.5)},
+			acceleration = {x = math.random(-5,-2.5), y=-2.5, z = math.random(-5,-2.5)},
+			expirationtime = 2.0,
+			size = math.random(1, 3),
+			collisiondetection = true,
+			collision_removal = true,
+			vertical = true,
+			texture = choice_random_rain_drop_texture(),
+			playername = player:get_player_name()
+		})
+	end
+end
+
+local display_particles = function(player)
+	if hw_utils.is_underwater(player) then
+		return
+	end
+
+	local particles_number_per_update = 3
+	for i=particles_number_per_update, 1,-1 do
+		add_wide_range_rain_particle(player)
+	end
+
+	local snow_particles_number_per_update = 10
+	for i=snow_particles_number_per_update, 1,-1 do
+		add_snow_particle(player)
+	end
+end
+
+snowstorm.render = function(dtime, player)
+	display_particles(player)
+end
+
+snowstorm.start = function()
+	manual_trigger_start = true
+end
+
+snowstorm.stop = function()
+	manual_trigger_end = true
+end
+
+happy_weather.register_weather(snowstorm)
+

weathers/thunder.lua

@@ -11,6 +11,7 @@
 local thunder = {}
 thunder.last_check = 0
 thunder.check_interval = 100
+thunder.chance = 0.8
 
 -- Weather identification code
 thunder.code = "thunder"
@@ -27,14 +28,13 @@ local thunder_weather_next_check = 0
 local thunder_weather_check_delay = 600 -- to avoid checks continuously
 
 thunder.is_starting = function(dtime)
-	checked = false
 	thunder.next_strike = 0
 	thunder.min_delay = 5
 	thunder.max_delay = math.random(5, 45)
 
 	if thunder.last_check + thunder.check_interval < os.time() then
 		thunder.last_check = os.time()
-		if math.random() < 0.8 and happy_weather.is_weather_active("heavy_rain") then
+		if math.random() < thunder.chance and happy_weather.is_weather_active("heavy_rain") then
 			return true
 		end
 	end
@@ -69,6 +69,11 @@ local calculate_thunder_strike_delay = function()
 end
 
 thunder.render = function(dtime, player)
+	local player_name = player:get_player_name()
+	if happy_weather.is_player_in_weather_area(player_name, "heavy_rain") == false then
+		return
+	end
+
 	if thunder.next_strike <= os.time() then
 		lightning.strike()
 		calculate_thunder_strike_delay()