Merge branch 'master' into hgcleanup
This commit is contained in:
Wuzzy
commit
073fc61acb
@ -1 +1,2 @@
|
||||
default
|
||||
playermodel
|
||||
|
||||
4
mods/builtin_item/.gitignore
vendored
Normal file
4
mods/builtin_item/.gitignore
vendored
Normal file
@ -0,0 +1,4 @@
|
||||
## Generic ignorable patterns and files
|
||||
*~
|
||||
.*.swp
|
||||
debug.txt
|
||||
@ -1,181 +1,168 @@
|
||||
minetest.register_entity(":__builtin:item", {
|
||||
initial_properties = {
|
||||
hp_max = 1,
|
||||
physical = true,
|
||||
collisionbox = {-0.17,-0.17,-0.17, 0.17,0.17,0.17},
|
||||
visual = "sprite",
|
||||
visual_size = {x=0.5, y=0.5},
|
||||
textures = {""},
|
||||
spritediv = {x=1, y=1},
|
||||
initial_sprite_basepos = {x=0, y=0},
|
||||
is_visible = false,
|
||||
timer = 0,
|
||||
},
|
||||
|
||||
itemstring = '',
|
||||
physical_state = true,
|
||||
local time = tonumber(os.clock())+10
|
||||
local lastpos = vector.zero or {x=0, y=0, z=0}
|
||||
local last_tab, always_test
|
||||
|
||||
set_item = function(self, itemstring)
|
||||
self.itemstring = itemstring
|
||||
local stack = ItemStack(itemstring)
|
||||
local itemtable = stack:to_table()
|
||||
local itemname = nil
|
||||
if itemtable then
|
||||
itemname = stack:to_table().name
|
||||
if not core.get_gravity then
|
||||
local gravity,grav_updating = 10
|
||||
function core.get_gravity()
|
||||
if not grav_updating then
|
||||
gravity = tonumber(core.setting_get("movement_gravity")) or gravity
|
||||
grav_updating = true
|
||||
core.after(50, function()
|
||||
grav_updating = false
|
||||
end)
|
||||
end
|
||||
local item_texture = nil
|
||||
local item_type = ""
|
||||
if minetest.registered_items[itemname] then
|
||||
item_texture = minetest.registered_items[itemname].inventory_image
|
||||
item_type = minetest.registered_items[itemname].type
|
||||
return gravity
|
||||
end
|
||||
local set_setting = core.setting_set
|
||||
function core.setting_set(name, v, ...)
|
||||
if name == "gravity" then
|
||||
name = "movement_gravity"
|
||||
gravity = tonumber(v) or gravity
|
||||
end
|
||||
prop = {
|
||||
is_visible = true,
|
||||
visual = "sprite",
|
||||
textures = {"unknown_item.png"}
|
||||
}
|
||||
if item_texture and item_texture ~= "" then
|
||||
prop.visual = "sprite"
|
||||
prop.textures = {item_texture}
|
||||
prop.visual_size = {x=0.50, y=0.50}
|
||||
else
|
||||
prop.visual = "wielditem"
|
||||
prop.textures = {itemname}
|
||||
prop.visual_size = {x=0.20, y=0.20}
|
||||
prop.automatic_rotate = math.pi * 0.25
|
||||
return set_setting(name, v, ...)
|
||||
end
|
||||
local get_setting = core.setting_get
|
||||
function core.setting_get(name, ...)
|
||||
if name == "gravity" then
|
||||
name = "movement_gravity"
|
||||
end
|
||||
self.object:set_properties(prop)
|
||||
end,
|
||||
return get_setting(name, ...)
|
||||
end
|
||||
end
|
||||
|
||||
get_staticdata = function(self)
|
||||
--return self.itemstring
|
||||
return minetest.serialize({
|
||||
itemstring = self.itemstring,
|
||||
always_collect = self.always_collect,
|
||||
timer = self.timer,
|
||||
local function get_nodes(pos)
|
||||
if not always_test then
|
||||
local rnd_pos = vector.round(pos)
|
||||
local t = tonumber(os.clock())
|
||||
if vector.equals(rnd_pos, lastpos)
|
||||
and t-time < 10 then
|
||||
return last_tab
|
||||
end
|
||||
time = t
|
||||
lastpos = rnd_pos
|
||||
local near_objects = minetest.get_objects_inside_radius(pos, 1)
|
||||
if #near_objects >= 2 then
|
||||
always_test = true
|
||||
minetest.after(10, function() always_test = false end)
|
||||
end
|
||||
end
|
||||
local tab,n = {},1
|
||||
for i = -1,1,2 do
|
||||
for _,p in pairs({
|
||||
{x=pos.x+i, y=pos.y, z=pos.z},
|
||||
{x=pos.x, y=pos.y, z=pos.z+i}
|
||||
}) do
|
||||
tab[n] = {p, minetest.get_node(p)}
|
||||
n = n+1
|
||||
end
|
||||
end
|
||||
if not always_test then
|
||||
last_tab = tab
|
||||
end
|
||||
return tab
|
||||
end
|
||||
|
||||
local function get_flowing_dir(pos)
|
||||
local data = get_nodes(pos)
|
||||
local param2 = minetest.get_node(pos).param2
|
||||
if param2 > 7 then
|
||||
return
|
||||
end
|
||||
for _,i in pairs(data) do
|
||||
local nd = i[2]
|
||||
local name = nd.name
|
||||
local par2 = nd.param2
|
||||
if name == "default:water_flowing"
|
||||
and par2 < param2 then
|
||||
return i[1]
|
||||
end
|
||||
end
|
||||
for _,i in pairs(data) do
|
||||
local nd = i[2]
|
||||
local name = nd.name
|
||||
local par2 = nd.param2
|
||||
if name == "default:water_flowing"
|
||||
and par2 >= 11 then
|
||||
return i[1]
|
||||
end
|
||||
end
|
||||
for _,i in pairs(data) do
|
||||
local nd = i[2]
|
||||
local name = nd.name
|
||||
local par2 = nd.param2
|
||||
local tmp = minetest.registered_nodes[name]
|
||||
if tmp
|
||||
and not tmp.walkable
|
||||
and name ~= "default:water_flowing" then
|
||||
return i[1]
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local item_entity = minetest.registered_entities["__builtin:item"]
|
||||
local old_on_step = item_entity.on_step or function()end
|
||||
|
||||
item_entity.on_step = function(self, dtime)
|
||||
old_on_step(self, dtime)
|
||||
|
||||
local p = self.object:getpos()
|
||||
|
||||
local name = minetest.get_node(p).name
|
||||
if name == "default:lava_flowing"
|
||||
or name == "default:lava_source" then
|
||||
minetest.sound_play("builtin_item_lava", {pos=p})
|
||||
minetest.add_particlespawner({
|
||||
amount = 3,
|
||||
time = 0.1,
|
||||
minpos = {x=p.x, y=p.y, z=p.z},
|
||||
maxpos = {x=p.x, y=p.y+0.2, z=p.z},
|
||||
minacc = {x=-0.5,y=5,z=-0.5},
|
||||
maxacc = {x=0.5,y=5,z=0.5},
|
||||
minexptime = 0.1,
|
||||
minsize = 2,
|
||||
maxsize = 4,
|
||||
texture = "smoke_puff.png"
|
||||
})
|
||||
minetest.add_particlespawner ({
|
||||
amount = 1, time = 0.4,
|
||||
minpos = {x = p.x, y= p.y + 0.25, z= p.z},
|
||||
maxpos = {x = p.x, y= p.y + 0.5, z= p.z},
|
||||
minexptime = 0.2, maxexptime = 0.4,
|
||||
minsize = 4, maxsize = 6,
|
||||
collisiondetection = false,
|
||||
vertical = false,
|
||||
texture = "fire_basic_flame.png",
|
||||
})
|
||||
end,
|
||||
|
||||
on_activate = function(self, staticdata, dtime_s)
|
||||
if string.sub(staticdata, 1, string.len("return")) == "return" then
|
||||
local data = minetest.deserialize(staticdata)
|
||||
if data and type(data) == "table" then
|
||||
self.itemstring = data.itemstring
|
||||
self.always_collect = data.always_collect
|
||||
self.timer = data.timer
|
||||
if not self.timer then
|
||||
self.timer = 0
|
||||
end
|
||||
self.timer = self.timer+dtime_s
|
||||
end
|
||||
else
|
||||
self.itemstring = staticdata
|
||||
end
|
||||
self.object:set_armor_groups({immortal=1})
|
||||
self.object:setvelocity({x=0, y=2, z=0})
|
||||
self.object:setacceleration({x=0, y=-10, z=0})
|
||||
self:set_item(self.itemstring)
|
||||
end,
|
||||
|
||||
on_step = function(self, dtime)
|
||||
local time = minetest.setting_get("remove_items")
|
||||
if not time then
|
||||
time = 300
|
||||
end
|
||||
if not self.timer then
|
||||
self.timer = 0
|
||||
end
|
||||
self.timer = self.timer + dtime
|
||||
if time ~= 0 and (self.timer > time) then
|
||||
self.object:remove()
|
||||
end
|
||||
|
||||
local p = self.object:getpos()
|
||||
|
||||
local name = minetest.env:get_node(p).name
|
||||
if name == "default:lava_flowing" or name == "default:lava_source" then
|
||||
minetest.sound_play("builtin_item_lava", {pos=self.object:getpos()})
|
||||
self.object:remove()
|
||||
return
|
||||
end
|
||||
|
||||
if minetest.registered_nodes[name].liquidtype == "flowing" then
|
||||
get_flowing_dir = function(self)
|
||||
local pos = self.object:getpos()
|
||||
local param2 = minetest.env:get_node(pos).param2
|
||||
for i,d in ipairs({-1, 1, -1, 1}) do
|
||||
if i<3 then
|
||||
pos.x = pos.x+d
|
||||
else
|
||||
pos.z = pos.z+d
|
||||
end
|
||||
|
||||
local name = minetest.env:get_node(pos).name
|
||||
local par2 = minetest.env:get_node(pos).param2
|
||||
if name == "default:water_flowing" and par2 < param2 then
|
||||
return pos
|
||||
end
|
||||
|
||||
if i<3 then
|
||||
pos.x = pos.x-d
|
||||
else
|
||||
pos.z = pos.z-d
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local vec = get_flowing_dir(self)
|
||||
if vec then
|
||||
local v = self.object:getvelocity()
|
||||
if vec and vec.x-p.x > 0 then
|
||||
self.object:setvelocity({x=0.5,y=v.y,z=0})
|
||||
elseif vec and vec.x-p.x < 0 then
|
||||
self.object:setvelocity({x=-0.5,y=v.y,z=0})
|
||||
elseif vec and vec.z-p.z > 0 then
|
||||
self.object:setvelocity({x=0,y=v.y,z=0.5})
|
||||
elseif vec and vec.z-p.z < 0 then
|
||||
self.object:setvelocity({x=0,y=v.y,z=-0.5})
|
||||
end
|
||||
self.object:setacceleration({x=0, y=-10, z=0})
|
||||
self.physical_state = true
|
||||
self.object:set_properties({
|
||||
physical = true
|
||||
})
|
||||
return
|
||||
end
|
||||
end
|
||||
|
||||
p.y = p.y - 0.3
|
||||
local nn = minetest.env:get_node(p).name
|
||||
-- If node is not registered or node is walkably solid
|
||||
if not minetest.registered_nodes[nn] or minetest.registered_nodes[nn].walkable then
|
||||
if self.physical_state then
|
||||
self.object:setvelocity({x=0,y=0,z=0})
|
||||
self.object:setacceleration({x=0, y=0, z=0})
|
||||
self.physical_state = false
|
||||
self.object:set_properties({
|
||||
physical = false
|
||||
})
|
||||
end
|
||||
else
|
||||
if not self.physical_state then
|
||||
self.object:setvelocity({x=0,y=0,z=0})
|
||||
self.object:setacceleration({x=0, y=-10, z=0})
|
||||
self.physical_state = true
|
||||
self.object:set_properties({
|
||||
physical = true
|
||||
})
|
||||
end
|
||||
end
|
||||
end,
|
||||
|
||||
on_punch = function(self, hitter)
|
||||
if self.itemstring ~= '' then
|
||||
hitter:get_inventory():add_item("main", self.itemstring)
|
||||
end
|
||||
self.object:remove()
|
||||
end,
|
||||
})
|
||||
return
|
||||
end
|
||||
|
||||
local tmp = minetest.registered_nodes[name]
|
||||
if tmp
|
||||
and tmp.liquidtype == "flowing" then
|
||||
local vec = get_flowing_dir(self.object:getpos())
|
||||
if vec then
|
||||
local v = self.object:getvelocity()
|
||||
if vec.x-p.x > 0 then
|
||||
self.object:setvelocity({x=0.5,y=v.y,z=0})
|
||||
elseif vec.x-p.x < 0 then
|
||||
self.object:setvelocity({x=-0.5,y=v.y,z=0})
|
||||
elseif vec.z-p.z > 0 then
|
||||
self.object:setvelocity({x=0,y=v.y,z=0.5})
|
||||
elseif vec.z-p.z < 0 then
|
||||
self.object:setvelocity({x=0,y=v.y,z=-0.5})
|
||||
end
|
||||
self.object:setacceleration({x=0, y=-core.get_gravity(), z=0})
|
||||
self.physical_state = true
|
||||
self.object:set_properties({
|
||||
physical = true
|
||||
})
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
minetest.register_entity(":__builtin:item", item_entity)
|
||||
|
||||
if minetest.setting_get("log_mods") then
|
||||
minetest.log("action", "builtin_item loaded")
|
||||
|
||||
@ -88,12 +88,6 @@ Calinou (CC BY-SA):
|
||||
default_copper_lump.png
|
||||
default_mineral_copper.png
|
||||
|
||||
MirceaKitsune (WTFPL):
|
||||
character.x
|
||||
|
||||
Jordach (CC BY-SA 3.0):
|
||||
character.png
|
||||
|
||||
PilzAdam (WTFPL):
|
||||
default_jungleleaves.png
|
||||
default_junglesapling.png
|
||||
|
||||
@ -9,11 +9,19 @@ LAVA_VISC = 7
|
||||
LIGHT_MAX = 14
|
||||
|
||||
-- Definitions made by this mod that other mods can use too
|
||||
default = {}
|
||||
if default == nil then
|
||||
default = {}
|
||||
end
|
||||
|
||||
default.inventory_background = "background[0,0;9,8;default_inventory_background.png;true]"
|
||||
default.inventory_listcolors = "listcolors[#8E6C3C;#EEAF6B;#683E12;#CA7700;#FFFFFF]"
|
||||
|
||||
-- Update appearance when the player joins
|
||||
minetest.register_on_joinplayer(function(player)
|
||||
player:hud_set_hotbar_image("gui_hotbar.png")
|
||||
player:hud_set_hotbar_selected_image("gui_hotbar_selected.png")
|
||||
end)
|
||||
|
||||
-- Load files
|
||||
dofile(minetest.get_modpath("default").."/functions.lua")
|
||||
dofile(minetest.get_modpath("default").."/nodes.lua")
|
||||
@ -21,5 +29,4 @@ dofile(minetest.get_modpath("default").."/tools.lua")
|
||||
dofile(minetest.get_modpath("default").."/craftitems.lua")
|
||||
dofile(minetest.get_modpath("default").."/crafting.lua")
|
||||
dofile(minetest.get_modpath("default").."/mapgen.lua")
|
||||
dofile(minetest.get_modpath("default").."/player.lua")
|
||||
dofile(minetest.get_modpath("default").."/trees.lua")
|
||||
|
||||
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 3.1 KiB |
File diff suppressed because it is too large
Load Diff
14
mods/hungry_games/README.txt
Normal file
14
mods/hungry_games/README.txt
Normal file
@ -0,0 +1,14 @@
|
||||
License of code: GPL version 2 or later
|
||||
|
||||
License of media files:
|
||||
|
||||
Michel Baradari (CC-BY 3.0):
|
||||
- hungry_games_death.1.ogg
|
||||
- hungry_games_death.1.ogg
|
||||
|
||||
Unknown author (WTFPL):
|
||||
- hungry_games_starting_drum.ogg
|
||||
- hungry_games_prestart.ogg
|
||||
- hungry_games_start.ogg
|
||||
- hungry_games_grace_over.ogg
|
||||
- hungry_games_victory.ogg
|
||||
@ -6,10 +6,13 @@ local grace = false
|
||||
local countdown = false
|
||||
|
||||
local registrants = {}
|
||||
local voters = {}
|
||||
local currGame = {}
|
||||
local gameSequenceNumber = 0 --[[ Sequence number of current round, will be incremented each round.
|
||||
Used to determine whether minetest.after calls are still valid or should be discarded. ]]
|
||||
|
||||
local spots_shuffled = {}
|
||||
|
||||
local timer_hudids = {}
|
||||
|
||||
local timer = nil
|
||||
@ -119,7 +122,6 @@ local stop_game = function()
|
||||
privs.fast = nil
|
||||
privs.fly = nil
|
||||
privs.interact = nil
|
||||
privs.vote = true
|
||||
minetest.set_player_privs(name, privs)
|
||||
player:set_hp(20)
|
||||
spawning.spawn(player, "lobby")
|
||||
@ -143,7 +145,6 @@ local check_win = function()
|
||||
end
|
||||
if count <= 1 then
|
||||
local winnerName
|
||||
print(dump(currGame))
|
||||
for playerName,_ in pairs(currGame) do
|
||||
local winnerPos = minetest.get_player_by_name(playerName):getpos()
|
||||
winnerName = playerName
|
||||
@ -157,7 +158,6 @@ local check_win = function()
|
||||
for _,player in ipairs(players) do
|
||||
local name = player:get_player_name()
|
||||
local privs = minetest.get_player_privs(name)
|
||||
privs.vote = true
|
||||
minetest.set_player_privs(name, privs)
|
||||
end
|
||||
|
||||
@ -214,14 +214,13 @@ local start_game_now = function(input)
|
||||
return false
|
||||
end
|
||||
for i,player in ipairs(contestants) do
|
||||
local name = player:get_player_name()
|
||||
currGame[name] = true
|
||||
local privs = minetest.get_player_privs(name)
|
||||
if minetest.get_player_by_name(name) then
|
||||
local name = player:get_player_name()
|
||||
if minetest.get_player_by_name(name) then
|
||||
currGame[name] = true
|
||||
local privs = minetest.get_player_privs(name)
|
||||
privs.fast = nil
|
||||
privs.fly = nil
|
||||
privs.interact = true
|
||||
privs.vote = nil
|
||||
minetest.set_player_privs(name, privs)
|
||||
minetest.after(0.1, function(table)
|
||||
local player = table[1]
|
||||
@ -254,6 +253,7 @@ local start_game_now = function(input)
|
||||
end
|
||||
minetest.setting_set("enable_damage", "true")
|
||||
votes = 0
|
||||
voters = {}
|
||||
ingame = true
|
||||
countdown = false
|
||||
starting_game = false
|
||||
@ -270,6 +270,7 @@ local start_game = function()
|
||||
grace = false
|
||||
countdown = true
|
||||
|
||||
local i = 1
|
||||
if hungry_games.countdown > 8.336 then
|
||||
minetest.after(hungry_games.countdown-8.336, function(gsn)
|
||||
if gsn == gameSequenceNumber and starting_game then
|
||||
@ -279,12 +280,39 @@ local start_game = function()
|
||||
end
|
||||
print("filling chests...")
|
||||
random_chests.refill()
|
||||
local i = 1
|
||||
--Find out how many spots there are to spawn
|
||||
local spots = get_spots()
|
||||
local diff = spots-table.getn(registrants)
|
||||
local nspots = get_spots()
|
||||
local diff = nspots-table.getn(registrants)
|
||||
local contestants = {}
|
||||
for _,player in pairs(minetest.get_connected_players() ) do
|
||||
|
||||
-- Shuffle players
|
||||
local players = minetest.get_connected_players()
|
||||
local players_shuffled = {}
|
||||
local shuffle_free = {}
|
||||
for j=1,#players do
|
||||
shuffle_free[j] = j
|
||||
end
|
||||
for j=1,#players do
|
||||
local rnd = math.random(1, #shuffle_free)
|
||||
players_shuffled[j] = players[shuffle_free[rnd]]
|
||||
table.remove(shuffle_free, rnd)
|
||||
end
|
||||
|
||||
-- Shuffle spots as well
|
||||
shuffle_free = {}
|
||||
spots_shuffled = {}
|
||||
for j=1,nspots do
|
||||
shuffle_free[j] = j
|
||||
end
|
||||
for j=1,nspots do
|
||||
local rnd = math.random(1, #shuffle_free)
|
||||
spots_shuffled[j] = shuffle_free[rnd]
|
||||
table.remove(shuffle_free, rnd)
|
||||
end
|
||||
|
||||
-- Spawn players
|
||||
for p=1,#players_shuffled do
|
||||
local player = players_shuffled[p]
|
||||
if diff > 0 then
|
||||
registrants[player:get_player_name()] = true
|
||||
diff = diff - 1
|
||||
@ -292,15 +320,15 @@ local start_game = function()
|
||||
drop_player_items(player:get_player_name(), true)
|
||||
minetest.after(0.1, function(list)
|
||||
local player = list[1]
|
||||
local i = list[2]
|
||||
local spawn_id = list[2]
|
||||
local gsn = list[3]
|
||||
if gsn ~= gameSequenceNumber or not starting_game then
|
||||
return
|
||||
end
|
||||
local name = player:get_player_name()
|
||||
if registrants[name] == true and spawning.is_spawn("player_"..i) then
|
||||
if registrants[name] == true and spawn_id ~= nil and spawning.is_spawn("player_"..spawn_id) then
|
||||
table.insert(contestants, player)
|
||||
spawning.spawn(player, "player_"..i)
|
||||
spawning.spawn(player, "player_"..spawn_id)
|
||||
reset_player_state(player)
|
||||
minetest.chat_send_player(name, "Get ready to fight!")
|
||||
else
|
||||
@ -326,13 +354,13 @@ local start_game = function()
|
||||
end
|
||||
for i,player in ipairs(contestants) do
|
||||
minetest.after(0.1, function(table)
|
||||
player = table[1]
|
||||
i = table[2]
|
||||
local player = table[1]
|
||||
local i = table[2]
|
||||
local name = player:get_player_name()
|
||||
if spawning.is_spawn("player_"..i) then
|
||||
spawning.spawn(player, "player_"..i)
|
||||
end
|
||||
end, {player, i})
|
||||
end, {player, spots_shuffled[i]})
|
||||
end
|
||||
end, {contestants,i,gameSequenceNumber})
|
||||
end
|
||||
@ -346,7 +374,7 @@ local check_votes = function()
|
||||
if not ingame then
|
||||
local players = minetest.get_connected_players()
|
||||
local num = table.getn(players)
|
||||
if num > 1 and (votes >= num or (num > hungry_games.vote_unanimous and votes > num*hungry_games.vote_percent)) then
|
||||
if num > 1 and (votes >= num or (num >= hungry_games.vote_unanimous and votes >= math.ceil(num*hungry_games.vote_percent))) then
|
||||
start_game()
|
||||
return true
|
||||
end
|
||||
@ -437,7 +465,7 @@ minetest.register_on_leaveplayer(function(player)
|
||||
currGame[name] = nil
|
||||
timer_hudids[name] = nil
|
||||
local privs = minetest.get_player_privs(name)
|
||||
if not privs.vote and votes > 0 then
|
||||
if voters[name] and votes > 0 then
|
||||
votes = votes - 1
|
||||
end
|
||||
if registrants[name] then registrants[name] = nil end
|
||||
@ -535,30 +563,31 @@ minetest.register_chatcommand("hg", {
|
||||
})
|
||||
|
||||
minetest.register_chatcommand("vote", {
|
||||
description = "Vote to start the Hungry Games",
|
||||
description = "Vote to start the Hungry Games.",
|
||||
privs = {vote=true},
|
||||
func = function(name, param)
|
||||
local players = minetest.get_connected_players()
|
||||
local num = table.getn(players)
|
||||
if num == 1 then
|
||||
minetest.chat_send_player(name, "Need more players!")
|
||||
minetest.chat_send_player(name, "At least 2 players are needed to start a new round.")
|
||||
return
|
||||
end
|
||||
if not ingame then
|
||||
local privs = minetest.get_player_privs(name)
|
||||
privs.vote = nil
|
||||
minetest.set_player_privs(name, privs)
|
||||
|
||||
if not ingame and not starting_game then
|
||||
if voters[name] ~= nil then
|
||||
minetest.chat_send_player(name, "You already have voted.")
|
||||
return
|
||||
end
|
||||
voters[name] = true
|
||||
votes = votes + 1
|
||||
minetest.chat_send_all(name.. " has have voted to begin! Votes so far: "..votes.."; Votes needed: "..((num > hungry_games.vote_unanimous and num*hungry_games.vote_percent) or num) )
|
||||
minetest.chat_send_all(name.. " has voted to begin! Votes so far: "..votes.."; Votes needed: "..((num >= hungry_games.vote_unanimous and math.ceil(num*hungry_games.vote_percent)) or num) )
|
||||
|
||||
local cv = check_votes()
|
||||
if votes > 1 and force_init_warning == false and cv == false then
|
||||
minetest.chat_send_all("The match will automatically be initiated in 5min.")
|
||||
if votes > 1 and force_init_warning == false and cv == false and hungry_games.vote_countdown ~= nil then
|
||||
minetest.chat_send_all("The match will automatically be initiated in " .. math.floor(hungry_games.vote_countdown/60) .. " minutes " .. math.fmod(hungry_games.vote_countdown, 60) .. " seconds.")
|
||||
force_init_warning = true
|
||||
set_timer("vote", 60*5)
|
||||
minetest.after((60*5), function (gsn)
|
||||
if not (starting_game or ingame) and gsn == gameSequenceNumber then
|
||||
set_timer("vote", hungry_games.vote_countdown)
|
||||
minetest.after(hungry_games.vote_countdown, function (gsn)
|
||||
if not (starting_game or ingame and gsn == gameSequenceNumber) then
|
||||
start_game()
|
||||
end
|
||||
end, gameSequenceNumber)
|
||||
@ -593,7 +622,7 @@ minetest.register_chatcommand("register", {
|
||||
registrants[name] = true
|
||||
minetest.chat_send_player(name, "You have registered!")
|
||||
else
|
||||
minetest.chat_send_player(name, "Sorry! no spots left!")
|
||||
minetest.chat_send_player(name, "Sorry! There are no spots left for you to spawn.")
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
@ -50,6 +50,9 @@ hungry_games.vote_percent = 0.5
|
||||
--If the number of connected players is less than or equal to this, the vote to start must be unaimous
|
||||
hungry_games.vote_unanimous = 5
|
||||
|
||||
--If the number of votes is greater than or equal to 1, a timer will start that will automatically initiate the match in this many seconds (nil to disable)
|
||||
hungry_games.vote_countdown = 120
|
||||
|
||||
--Set what players can dig, should be modifyed along with glass_arena.replace
|
||||
-- (See Above Section)
|
||||
--Values "none" (can't dig), "restricted" (only dig with hand), "normal" (normal minetest).
|
||||
|
||||
BIN
mods/hungry_games/sounds/hungry_games_death.1.ogg
Normal file
BIN
mods/hungry_games/sounds/hungry_games_death.1.ogg
Normal file
Binary file not shown.
BIN
mods/hungry_games/sounds/hungry_games_death.2.ogg
Normal file
BIN
mods/hungry_games/sounds/hungry_games_death.2.ogg
Normal file
Binary file not shown.
Binary file not shown.
@ -32,8 +32,10 @@ inventory_plus.register_button = function(player,name,label)
|
||||
if inventory_plus.buttons_ordered[player_name] == nil then
|
||||
inventory_plus.buttons_ordered[player_name] = {[1]="main"}
|
||||
end
|
||||
inventory_plus.buttons[player_name][name] = label
|
||||
table.insert(inventory_plus.buttons_ordered[player_name], name)
|
||||
if inventory_plus.buttons[player_name][name] == nil then
|
||||
inventory_plus.buttons[player_name][name] = label
|
||||
table.insert(inventory_plus.buttons_ordered[player_name], name)
|
||||
end
|
||||
end
|
||||
|
||||
inventory_plus.is_called = function(fields, compare_tabidname, player)
|
||||
@ -48,12 +50,16 @@ end
|
||||
|
||||
-- set_inventory_formspec
|
||||
inventory_plus.set_inventory_formspec = function(player,formspec)
|
||||
local privs = minetest.get_player_privs(player:get_player_name())
|
||||
local name = player:get_player_name()
|
||||
local privs = minetest.get_player_privs(name)
|
||||
if privs.hg_maker then
|
||||
-- if creative mode is on then wait a bit
|
||||
minetest.after(0.1,function()
|
||||
player:set_inventory_formspec(formspec)
|
||||
end)
|
||||
minetest.after(0.1,function(tbl)
|
||||
local player = minetest.get_player_by_name(tbl.name)
|
||||
if player ~= nil then
|
||||
player:set_inventory_formspec(tbl.formspec)
|
||||
end
|
||||
end, {name=name, formspec=formspec})
|
||||
else
|
||||
player:set_inventory_formspec(formspec)
|
||||
end
|
||||
@ -201,10 +207,14 @@ minetest.register_on_joinplayer(function(player)
|
||||
player:get_inventory():set_width("craft", 3)
|
||||
player:get_inventory():set_size("craft", 3*3)
|
||||
end
|
||||
local privs = minetest.get_player_privs(player:get_player_name())
|
||||
minetest.after(1,function()
|
||||
inventory_plus.set_inventory_formspec(player,inventory_plus.get_formspec(player, inventory_plus.default))
|
||||
end)
|
||||
local name = player:get_player_name()
|
||||
local privs = minetest.get_player_privs(name)
|
||||
minetest.after(1,function(name)
|
||||
local player = minetest.get_player_by_name(name)
|
||||
if player ~= nil then
|
||||
inventory_plus.set_inventory_formspec(player,inventory_plus.get_formspec(player, inventory_plus.default))
|
||||
end
|
||||
end, name)
|
||||
end)
|
||||
|
||||
-- register_on_player_receive_fields
|
||||
|
||||
4
mods/item_drop/.gitignore
vendored
Normal file
4
mods/item_drop/.gitignore
vendored
Normal file
@ -0,0 +1,4 @@
|
||||
## Generic ignorable patterns and files
|
||||
*~
|
||||
.*.swp
|
||||
debug.txt
|
||||
@ -1,99 +1,48 @@
|
||||
local timer = -1
|
||||
|
||||
local item_entity = minetest.registered_entities["__builtin:item"]
|
||||
local old_on_activate = item_entity.on_activate or function()end
|
||||
item_entity.on_activate = function(self, staticdata, dtime_s)
|
||||
old_on_activate(self, staticdata, dtime_s)
|
||||
timer = -1
|
||||
end
|
||||
|
||||
minetest.register_globalstep(function(dtime)
|
||||
timer = timer+dtime
|
||||
if timer < 0.1 then
|
||||
return
|
||||
end
|
||||
timer = 0
|
||||
for _,player in ipairs(minetest.get_connected_players()) do
|
||||
if player:get_hp() > 0 and minetest.get_player_privs(player:get_player_name()).interact then
|
||||
local pname = player:get_player_name()
|
||||
if minetest.get_player_privs(pname).interact then
|
||||
local pos = player:getpos()
|
||||
pos.y = pos.y+0.5
|
||||
local inv = player:get_inventory()
|
||||
|
||||
for _,object in ipairs(minetest.env:get_objects_inside_radius(pos, 0.5)) do
|
||||
if not object:is_player() and object:get_luaentity() and object:get_luaentity().name == "__builtin:item" then
|
||||
if inv and inv:room_for_item("main", ItemStack(object:get_luaentity().itemstring)) then
|
||||
inv:add_item("main", ItemStack(object:get_luaentity().itemstring))
|
||||
if object:get_luaentity().itemstring ~= "" then
|
||||
|
||||
for _,object in ipairs(minetest.get_objects_inside_radius(pos, 1)) do
|
||||
if not object:is_player()
|
||||
and object:get_luaentity()
|
||||
and object:get_luaentity().name == "__builtin:item" then
|
||||
local str = object:get_luaentity().itemstring
|
||||
local item = ItemStack(str)
|
||||
if inv
|
||||
and inv:room_for_item("main", item) then
|
||||
if str ~= "" then
|
||||
minetest.sound_play("item_drop_pickup", {
|
||||
to_player = player:get_player_name(),
|
||||
to_player = pname,
|
||||
})
|
||||
object:get_luaentity().itemstring = ""
|
||||
inv:add_item("main", item)
|
||||
end
|
||||
object:get_luaentity().itemstring = ""
|
||||
object:remove()
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
for _,object in ipairs(minetest.env:get_objects_inside_radius(pos, 1.5)) do
|
||||
if not object:is_player() and object:get_luaentity() and object:get_luaentity().name == "__builtin:item" then
|
||||
if object:get_luaentity().collect then
|
||||
if inv and inv:room_for_item("main", ItemStack(object:get_luaentity().itemstring)) then
|
||||
local pos1 = pos
|
||||
pos1.y = pos1.y+0.2
|
||||
local pos2 = object:getpos()
|
||||
local vec = {x=pos1.x-pos2.x, y=pos1.y-pos2.y, z=pos1.z-pos2.z}
|
||||
vec.x = vec.x*3
|
||||
vec.y = vec.y*3
|
||||
vec.z = vec.z*3
|
||||
object:setvelocity(vec)
|
||||
|
||||
minetest.after(1, function(args)
|
||||
local lua = object:get_luaentity()
|
||||
if object == nil or lua == nil or lua.itemstring == nil then
|
||||
return
|
||||
end
|
||||
if inv:room_for_item("main", ItemStack(object:get_luaentity().itemstring)) then
|
||||
inv:add_item("main", ItemStack(object:get_luaentity().itemstring))
|
||||
if object:get_luaentity().itemstring ~= "" then
|
||||
minetest.sound_play("item_drop_pickup", {
|
||||
to_player = player:get_player_name(),
|
||||
})
|
||||
end
|
||||
object:get_luaentity().itemstring = ""
|
||||
object:remove()
|
||||
else
|
||||
object:setvelocity({x=0,y=0,z=0})
|
||||
end
|
||||
end, {player, object})
|
||||
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end)
|
||||
|
||||
function minetest.handle_node_drops(pos, drops, digger)
|
||||
for _,item in ipairs(drops) do
|
||||
local count, name
|
||||
if type(item) == "string" then
|
||||
count = 1
|
||||
name = item
|
||||
else
|
||||
count = item:get_count()
|
||||
name = item:get_name()
|
||||
end
|
||||
for i=1,count do
|
||||
local obj = minetest.env:add_item(pos, name)
|
||||
if obj ~= nil then
|
||||
obj:get_luaentity().collect = true
|
||||
local x = math.random(1, 5)
|
||||
if math.random(1,2) == 1 then
|
||||
x = -x
|
||||
end
|
||||
local z = math.random(1, 5)
|
||||
if math.random(1,2) == 1 then
|
||||
z = -z
|
||||
end
|
||||
obj:setvelocity({x=1/x, y=obj:getvelocity().y, z=1/z})
|
||||
|
||||
-- FIXME this doesnt work for deactiveted objects
|
||||
if minetest.setting_get("remove_items") and tonumber(minetest.setting_get("remove_items")) then
|
||||
minetest.after(tonumber(minetest.setting_get("remove_items")), function(obj)
|
||||
obj:remove()
|
||||
end, obj)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
if minetest.setting_get("log_mods") then
|
||||
minetest.log("action", "item_drop loaded")
|
||||
|
||||
31
mods/playermodel/README.txt
Normal file
31
mods/playermodel/README.txt
Normal file
@ -0,0 +1,31 @@
|
||||
Minetest 0.4 mod: Player Model [playermodel]
|
||||
============================================
|
||||
Version: 1.1.0
|
||||
|
||||
License of source code:
|
||||
-----------------------
|
||||
Copyright (C) 2011-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
|
||||
|
||||
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)
|
||||
--------------------------------------
|
||||
Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
|
||||
http://creativecommons.org/licenses/by-sa/3.0/
|
||||
|
||||
Authors of media files
|
||||
-----------------------
|
||||
MirceaKitsune (WTFPL):
|
||||
character.x
|
||||
|
||||
Jordach (CC BY-SA 3.0):
|
||||
character.png
|
||||
|
||||
Wuzzy (CC BY-SA 3.0)
|
||||
playermodel_dummy_front.png (derivate work of character.png)
|
||||
playermodel_dummy_back.png (derivate work of character.png)
|
||||
0
mods/playermodel/depends.txt
Normal file
0
mods/playermodel/depends.txt
Normal file
1
mods/playermodel/description.txt
Normal file
1
mods/playermodel/description.txt
Normal file
@ -0,0 +1 @@
|
||||
A basic 3D player model with a basic API.
|
||||
5
mods/playermodel/init.lua
Normal file
5
mods/playermodel/init.lua
Normal file
@ -0,0 +1,5 @@
|
||||
if default == nil then
|
||||
default = {}
|
||||
end
|
||||
|
||||
dofile(minetest.get_modpath("playermodel").."/player.lua")
|
||||
BIN
mods/playermodel/models/character.blend
Normal file
BIN
mods/playermodel/models/character.blend
Normal file
Binary file not shown.
BIN
mods/playermodel/models/character.png
Normal file
BIN
mods/playermodel/models/character.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 2.7 KiB |
7457
mods/playermodel/models/character.x
Normal file
7457
mods/playermodel/models/character.x
Normal file
File diff suppressed because it is too large
Load Diff
@ -1,4 +1,4 @@
|
||||
-- Minetest 0.4 mod: player
|
||||
-- Minetest 0.4 mod: Player Model [playermodel]
|
||||
-- See README.txt for licensing and other information.
|
||||
|
||||
--[[
|
||||
@ -84,6 +84,7 @@ local player_model = {}
|
||||
local player_textures = {}
|
||||
local player_anim = {}
|
||||
local player_sneak = {}
|
||||
default.player_attached = {}
|
||||
|
||||
function default.player_get_animation(player)
|
||||
local name = player:get_player_name()
|
||||
@ -111,7 +112,7 @@ function default.player_set_model(player, model_name)
|
||||
default.player_set_animation(player, "stand")
|
||||
else
|
||||
player:set_properties({
|
||||
textures = { "player.png", "player_back.png", },
|
||||
textures = { "playermodel_dummy_front.png", "playermodel_dummy_back.png", },
|
||||
visual = "upright_sprite",
|
||||
})
|
||||
end
|
||||
@ -140,9 +141,10 @@ end
|
||||
|
||||
-- Update appearance when the player joins
|
||||
minetest.register_on_joinplayer(function(player)
|
||||
default.player_attached[player:get_player_name()] = false
|
||||
default.player_set_model(player, "character.x")
|
||||
player:hud_set_hotbar_image("gui_hotbar.png")
|
||||
player:hud_set_hotbar_selected_image("gui_hotbar_selected.png")
|
||||
player:set_local_animation({x=0, y=79}, {x=168, y=187}, {x=189, y=198}, {x=200, y=219}, 30)
|
||||
player:set_eye_offset({x=0, y=0, z=0}, {x=0, y=4, z=0})
|
||||
end)
|
||||
|
||||
minetest.register_on_leaveplayer(function(player)
|
||||
@ -161,7 +163,7 @@ minetest.register_globalstep(function(dtime)
|
||||
local name = player:get_player_name()
|
||||
local model_name = player_model[name]
|
||||
local model = model_name and models[model_name]
|
||||
if model then
|
||||
if model and not default.player_attached[name] then
|
||||
local controls = player:get_player_control()
|
||||
local walking = false
|
||||
local animation_speed_mod = model.animation_speed or 30
|
||||
BIN
mods/playermodel/screenshot.png
Normal file
BIN
mods/playermodel/screenshot.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.6 KiB |
BIN
mods/playermodel/textures/playermodel_dummy_back.png
Normal file
BIN
mods/playermodel/textures/playermodel_dummy_back.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 864 B |
BIN
mods/playermodel/textures/playermodel_dummy_front.png
Normal file
BIN
mods/playermodel/textures/playermodel_dummy_front.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 982 B |
3
mods/snow/.gitignore
vendored
Normal file
3
mods/snow/.gitignore
vendored
Normal file
@ -0,0 +1,3 @@
|
||||
config.txt
|
||||
debug.txt
|
||||
*~
|
||||
162
mods/snow/LazyJ-changelog.txt
Normal file
162
mods/snow/LazyJ-changelog.txt
Normal file
@ -0,0 +1,162 @@
|
||||
~ LazyJ, 2014_06_01
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~
|
||||
List of Changes
|
||||
~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
|
||||
|
||||
##### MapGen
|
||||
|
||||
I did *not* fix Snow's mapgen issue with "PlantLife" (another great, Minetest
|
||||
standard) based mods. Mapgen stuff is far beyond my current skill level.
|
||||
What little changes I did make were to switch-out Snow nodes that Minetest
|
||||
now has as defaults (dirt_with_snow, snow, ice). My thoughts being that
|
||||
texture packs and other mods that may use these nodes as recipe items are more
|
||||
likely to support default nodes. I also added a line above and below in the
|
||||
"mapgen.lua" file indicating where to put the comment symbols to
|
||||
comment-out/disable Snow's mapgen. Mods based on VanessaE's excellent
|
||||
"PlantLife" mod will not produce if Snow's mapgen is active.
|
||||
*Snow's mapgen is active by default.*
|
||||
I did not disable it, merely indicated were the comment symbols are
|
||||
to be placed. To compensate for the loss of snow resources when Snow's mapgen
|
||||
is disabled, I created crafting recipes that allows players to craft more
|
||||
snow, ice, and moss. This not only encourages snow builds, but also allows
|
||||
the players to create snow biomes where they want and whatever size they are
|
||||
willing to make them.
|
||||
|
||||
|
||||
##### Fixed
|
||||
* Pine saplings are now replaced with tree trunks when the tree grows.
|
||||
* Snowballs no longer pass through solid objects. Griefers can no
|
||||
longer flood the interiors of builds by throwing snowballs through the
|
||||
walls hoping to either leave a snowy mess inside or that a heat source
|
||||
would melt the snow and flood the interior.
|
||||
* Snowballs no longer destroy nodes when thrown at the sides.
|
||||
* Falling snow no longer destroys nodes (same problem snowballs had).
|
||||
* Snow bricks now, instead of disappearing like before, melt
|
||||
into water sources.
|
||||
* Christmas tree saplings once again will drop when pine needles
|
||||
are harvested.
|
||||
* Dirt_with_snow changes to dirt when a solid, non-light permeating
|
||||
(sunlight_propagates) block is set on top of it.
|
||||
|
||||
|
||||
|
||||
##### Changed
|
||||
* All snow and ice stuff (including the stairs, slabs, panels, and
|
||||
microblocks) will freeze dirt and dirt_with_grass into dirt_with_snow.
|
||||
* All snow and most ice stuff will freeze water into ice, including
|
||||
the stairs, slabs, panels, and microblocks. The exception is the
|
||||
full-sized ice blocks will *not* freeze water into ice.
|
||||
* Snow brick texture reworked and based off of the default stone brick
|
||||
texture (and less purple in the grout).
|
||||
* Ice stuff is now semi-transparent.
|
||||
* Christmas trees now have blinking lights that give off a
|
||||
low level of light.
|
||||
* Christmas tree stars now give off a high level of light and the
|
||||
light can be punched on or off.
|
||||
* Combined default snow and snowballs. Now snow can be
|
||||
thrown (left-click) or placed (right-click).
|
||||
* Snow stuff now has "snow" sounds instead of "grass" sounds.
|
||||
* Melting - Full-sized snow blocks, snow brick, snow cobble, and ice
|
||||
will melt into water sources. The down-side is this makes a big,
|
||||
permanent mess. The up-side, this is a convenient way to carry water,
|
||||
if buckets are disabled on your server, by keeping full-sized snow
|
||||
stuff and ice blocks in your inventory to, later, melt where you
|
||||
need water.
|
||||
* Melting - Partial and small-sized blocks like snow (snowballs),
|
||||
basic stairs and slabs for snow stuff and ice, and circular saw-made
|
||||
snow stuff and ice things will melt into a water source for 2 seconds,
|
||||
then switch from a water source to flowing water, and after a moment
|
||||
the flowing water dries-up (small, temporary mess).
|
||||
|
||||
|
||||
|
||||
##### Added
|
||||
* New block-type: "Snow Cobble". Just like regular cobble from regular
|
||||
stone, snow cobble comes from digging snow blocks.
|
||||
* All snow and ice blocks can be crafted into basic slabs and stairs.
|
||||
The default slabs stack and change back into full-sized blocks
|
||||
("More Blocks" slabs won't do this).
|
||||
* Soft dependency on a recent release Calinou's MoreBlocks so all
|
||||
snow and ice blocks are compatible with the circular saw. If you don't
|
||||
have MoreBlocks installed, Snow will ignore the code for those fancy
|
||||
blocks and use basic stairs and slabs instead.
|
||||
* All snow and ice stuff works with the screwdriver.
|
||||
* Crafting, recycling, and cooking recipes for snow blocks,
|
||||
ice, and moss.
|
||||
* Snow bricks craft-recycle back into 4 snow blocks.
|
||||
* 2 snow blocks craft into 3 snow blocks. This is to make up
|
||||
for when the mapgen for snow biomes is disabled.
|
||||
* 2 snow cobble craft-recycle into 3 snow blocks.
|
||||
* 4 pine needles craft into 1 moss
|
||||
* Snow blocks, snow cobble, and snow bricks can be cooked in a
|
||||
furnace to make ice.
|
||||
* Snowballs can be thrown (left-click) to build up layers. After the
|
||||
11th layer, the bottom 9 layers change into a snow block. At a very
|
||||
close distance, throwing snowballs can be used as a technique to
|
||||
build-up gradual slopes. If you have lots and lots of snow balls,
|
||||
with rapid-fire throwing, you can, very briefly, "white-out" another
|
||||
player's view if your aim is good enough to hit them in the face.
|
||||
* Snowballs can be placed (right-click) but will not stack into
|
||||
multiple layers. Just one layer only. Placing snow is more reliable
|
||||
and accurate than throwing snow from a distance. By placing snow,
|
||||
players are able to create their own, personal, snow biomes.
|
||||
* Vertical clearance check for tree growth. The nine blocks above the
|
||||
spot where the sapling is placed must be free and clear of all
|
||||
obstructions or else the sapling will not be allowed to grow.
|
||||
Griefers could place the saplings in builds and when the tree grows
|
||||
it may not destroy nodes but it fills the available air space leaving
|
||||
a mess for the build's owner to clean-up. Now the trees will only grow
|
||||
inside if there is 9, free-and-clear spaces from floor to ceiling.
|
||||
Because pine trees (and Christmas trees) will grow on any solid surface,
|
||||
their saplings are handy to take with you when deep mining. Just before
|
||||
you run out of tool wood, dig out a space large enough for a tree to
|
||||
grow, plant a pine or Christmas tree sapling then place 2 torches on
|
||||
either side, right next to the sapling. After the tree grows harvest
|
||||
the trunk for tool wood, the leaves for short-run fuel in the furnace
|
||||
and for saplings to renew your tool wood supply again.
|
||||
* Aliases to help make WorldEdit and "give" commands easier:
|
||||
|
||||
|
||||
"default_snow" = "default:snow"
|
||||
"snowball" = "default:snow"
|
||||
"snowballs" = "default:snow"
|
||||
"snow_ball" = "default:snow"
|
||||
"ice" = "default:ice"
|
||||
"default_ice" = "default:ice"
|
||||
"dirtwithsnow" = "default:dirt_with_snow"
|
||||
"snowdirt" = "default:dirt_with_snow"
|
||||
"snowydirt" = "default:dirt_with_snow"
|
||||
"snowblocks" = "default:snowblock"
|
||||
"snowbrick" = "snow:snow_brick"
|
||||
"bricksnow" = "snow:snow_brick"
|
||||
"snowbricks" = "snow:snow_brick"
|
||||
"snowybricks" = "snow:snow_brick"
|
||||
"snowcobble" = "snow:snow_cobble"
|
||||
"snowycobble" = "snow:snow_cobble"
|
||||
"cobblesnow" = "snow:snow_cobble"
|
||||
|
||||
|
||||
|
||||
~~~~~~
|
||||
TODO
|
||||
~~~~~~
|
||||
|
||||
Falling Snow:
|
||||
* Add code to prevent snowfall from depositing snow on or near torches,
|
||||
active furnaces, and lava.
|
||||
|
||||
* Add code to prevent snowfall from depositing snow on
|
||||
'walkable = false' defined nodes.
|
||||
|
||||
|
||||
|
||||
Sled:
|
||||
* Figure out why the player avatars remain in a seated position,
|
||||
even after getting off the sled, if they flew while on the sled.
|
||||
'default.player_set_animation', where is a better explanation for this and what
|
||||
are it's available options?
|
||||
|
||||
|
||||
67
mods/snow/changelog.txt
Normal file
67
mods/snow/changelog.txt
Normal file
@ -0,0 +1,67 @@
|
||||
CHANGELOG:
|
||||
------------
|
||||
|
||||
Version 3.2
|
||||
|
||||
Update compatibility to the latest minetest.
|
||||
|
||||
Version 0.3.1
|
||||
|
||||
Paramat's rewrite of mapgenv6.lua: bugfixes, use noisemaps for big speed increase
|
||||
|
||||
Version 3.0
|
||||
LazyJ's big changes (see LazyJ-changelog.txt)
|
||||
|
||||
Ice freezes-over.
|
||||
|
||||
Better leveled snow.
|
||||
|
||||
PLUS MORE! (see commit log)
|
||||
|
||||
Version 2.0
|
||||
|
||||
Uses default namespace.
|
||||
|
||||
Sleds.
|
||||
|
||||
Bugfixes.
|
||||
|
||||
Version 1.8
|
||||
|
||||
Mapgen_v7 support.
|
||||
|
||||
Better config system.
|
||||
|
||||
Falling snow.
|
||||
|
||||
Version 1.4
|
||||
|
||||
New biomes, snowy and plain
|
||||
|
||||
Christmas Trees
|
||||
|
||||
Snowfall
|
||||
|
||||
Version 1.3
|
||||
|
||||
Smooth transitions
|
||||
|
||||
Snow Bricks
|
||||
|
||||
Version 1.2
|
||||
|
||||
Pine trees
|
||||
|
||||
Moss
|
||||
|
||||
Alpine biomes
|
||||
|
||||
Dry shrubs
|
||||
|
||||
Version 1.1
|
||||
|
||||
Better mapgen
|
||||
|
||||
Version 1.0
|
||||
|
||||
Initial release
|
||||
@ -1,10 +0,0 @@
|
||||
--This file contains configuration options for snow mod.
|
||||
|
||||
--Enables falling snow.
|
||||
snow.enable_snowfall = false
|
||||
|
||||
--Enables debuging.
|
||||
snow.debug = false
|
||||
|
||||
--Enables smooth transition of biomes.
|
||||
snow.smooth = true
|
||||
@ -1 +1,2 @@
|
||||
default
|
||||
moreblocks?
|
||||
@ -1,590 +1,190 @@
|
||||
--[[
|
||||
--==============================
|
||||
--==========================================================
|
||||
LazyJ's Fork of Splizard's "Snow Biomes" Mod
|
||||
by LazyJ
|
||||
version: Umpteen-hundred and 7/5ths something or another.
|
||||
2014_04_12
|
||||
|
||||
~~~
|
||||
|
||||
"Snow Biomes" Mod
|
||||
By Splizard
|
||||
|
||||
Download:
|
||||
http//forum.minetest.net/viewtopic.php?id=2290
|
||||
http://github.com/Splizard/minetest-mod-snow/
|
||||
|
||||
--==========================================================
|
||||
--==============================
|
||||
|
||||
Snow Biomes
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 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 General Public License for more details.
|
||||
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
||||
MA 02110-1301, USA.
|
||||
]]--
|
||||
|
||||
snow = {}
|
||||
dofile(minetest.get_modpath("snow").."/mapgen.lua")
|
||||
dofile(minetest.get_modpath("snow").."/config.lua")
|
||||
|
||||
--Replace leaves so snow gets removed on decay.
|
||||
local leaves = {}
|
||||
for k,v in pairs(minetest.registered_nodes["default:leaves"]) do
|
||||
leaves[k] = v
|
||||
|
||||
-- Original Lua Files
|
||||
--dofile(minetest.get_modpath("snow").."/util.lua")
|
||||
--dofile(minetest.get_modpath("snow").."/mapgen.lua")
|
||||
--dofile(minetest.get_modpath("snow").."/sled.lua")
|
||||
-- "falling_snow.lua" disabled since weather functions minetest.get_heat(pos) and minetest.get_humidity(pos)
|
||||
-- have been removed from Minetest.
|
||||
-- Until something else can be figured out, use paramat's "Snowdrift" mod instead.
|
||||
-- dofile(minetest.get_modpath("snow").."/falling_snow.lua")
|
||||
|
||||
-- Original init.lua File Broken into Smaller Files
|
||||
dofile(minetest.get_modpath("snow").."/src/abms.lua")
|
||||
dofile(minetest.get_modpath("snow").."/src/aliases.lua")
|
||||
dofile(minetest.get_modpath("snow").."/src/basic_stairs_slabs.lua")
|
||||
dofile(minetest.get_modpath("snow").."/src/crafting.lua")
|
||||
dofile(minetest.get_modpath("snow").."/src/snowball.lua")
|
||||
|
||||
|
||||
-- The formspec menu didn't work when util.lua was the very first "dofile" so I moved
|
||||
-- it and all the other original "dofiles", in order, to the bottom of the list. ~ LazyJ
|
||||
-- Minetest would crash if the mapgen was called upon before the rest of other snow lua files so
|
||||
-- I put it lower on the list and that seems to do the trick. ~ LazyJ
|
||||
dofile(minetest.get_modpath("snow").."/src/util.lua")
|
||||
-- To get Xmas tree saplings, the "christmas_content", true or false, in "util.lua" has to be determined first.
|
||||
-- That means "nodes.lua", where the saplings are controlled, has to come after "util.lua". ~ LazyJ
|
||||
dofile(minetest.get_modpath("snow").."/src/nodes.lua")
|
||||
dofile(minetest.get_modpath("snow").."/src/mapgen.lua")
|
||||
dofile(minetest.get_modpath("snow").."/src/sled.lua")
|
||||
dofile(minetest.get_modpath("snow").."/src/falling_snow.lua")
|
||||
|
||||
|
||||
|
||||
-- Check for "MoreBlocks". If not found, skip this next "dofile".
|
||||
|
||||
if minetest.get_modpath("moreblocks") then
|
||||
|
||||
dofile(minetest.get_modpath("snow").."/src/stairsplus.lua")
|
||||
|
||||
end
|
||||
leaves.after_destruct = function(pos, node, digger)
|
||||
pos.y = pos.y + 1
|
||||
local nodename = minetest.env:get_node(pos).name
|
||||
if nodename == "snow:snow" then
|
||||
minetest.env:remove_node(pos)
|
||||
|
||||
--This function places snow checking at the same time for snow level and increasing as needed.
|
||||
--This also takes into account sourrounding snow and makes snow even.
|
||||
function snow.place(pos)
|
||||
local node = minetest.get_node_or_nil(pos)
|
||||
|
||||
--Oops, maybe there is no node?
|
||||
if not node
|
||||
or not minetest.registered_nodes[node.name] then
|
||||
return
|
||||
end
|
||||
end
|
||||
minetest.register_node(":default:leaves", leaves)
|
||||
|
||||
--Pine leaves.
|
||||
minetest.register_node("snow:needles", {
|
||||
description = "Pine Needles",
|
||||
drawtype = "allfaces_optional",
|
||||
visual_scale = 1.3,
|
||||
tiles = {"snow_needles.png"},
|
||||
paramtype = "light",
|
||||
groups = {snappy=3, leafdecay=3, flammable=2,oddly_breakable_by_hand=2},
|
||||
drop = {
|
||||
max_items = 1,
|
||||
items = {
|
||||
{
|
||||
-- player will get xmas tree with 1/50 chance
|
||||
items = {'snow:xmas_tree'},
|
||||
rarity = 50,
|
||||
},
|
||||
{
|
||||
-- player will get sapling with 1/20 chance
|
||||
items = {'snow:sapling_pine'},
|
||||
rarity = 20,
|
||||
},
|
||||
{
|
||||
-- player will get leaves only if he get no saplings,
|
||||
-- this is because max_items is 1
|
||||
items = {'snow:needles'},
|
||||
}
|
||||
}
|
||||
},
|
||||
--Remove snow above leaves after decay.
|
||||
after_destruct = function(pos, node, digger)
|
||||
pos.y = pos.y + 1
|
||||
local nodename = minetest.env:get_node(pos).name
|
||||
if nodename == "snow:snow" then
|
||||
minetest.env:remove_node(pos)
|
||||
end
|
||||
end,
|
||||
sounds = default.node_sound_leaves_defaults(),
|
||||
})
|
||||
|
||||
--Decorated Pine leaves.
|
||||
minetest.register_node("snow:needles_decorated", {
|
||||
description = "Decorated Pine Needles",
|
||||
drawtype = "allfaces_optional",
|
||||
tiles = {"snow_needles_decorated.png"},
|
||||
paramtype = "light",
|
||||
groups = {snappy=3, leafdecay=3, flammable=2,oddly_breakable_by_hand=2},
|
||||
drop = {
|
||||
max_items = 1,
|
||||
items = {
|
||||
{
|
||||
-- player will get xmas tree with 1/20 chance
|
||||
items = {'snow:xmas_tree'},
|
||||
rarity = 50,
|
||||
},
|
||||
{
|
||||
-- player will get sapling with 1/20 chance
|
||||
items = {'snow:sapling_pine'},
|
||||
rarity = 20,
|
||||
},
|
||||
{
|
||||
-- player will get leaves only if he get no saplings,
|
||||
-- this is because max_items is 1
|
||||
items = {'snow:needles_decorated'},
|
||||
}
|
||||
}
|
||||
},
|
||||
--Remove snow above leaves after decay.
|
||||
after_destruct = function(pos, node, digger)
|
||||
pos.y = pos.y + 1
|
||||
local nodename = minetest.env:get_node(pos).name
|
||||
if nodename == "snow:snow" then
|
||||
minetest.env:remove_node(pos)
|
||||
end
|
||||
end,
|
||||
sounds = default.node_sound_leaves_defaults(),
|
||||
})
|
||||
|
||||
minetest.register_node("snow:xmas_tree", {
|
||||
description = "Christmas Tree",
|
||||
drawtype = "plantlike",
|
||||
visual_scale = 1.0,
|
||||
tiles = {"snow_xmas_tree.png"},
|
||||
inventory_image = "snow_xmas_tree.png",
|
||||
wield_image = "snow_xmas_tree.png",
|
||||
paramtype = "light",
|
||||
walkable = false,
|
||||
groups = {snappy=2,dig_immediate=3,flammable=2},
|
||||
sounds = default.node_sound_defaults(),
|
||||
})
|
||||
|
||||
minetest.register_node("snow:sapling_pine", {
|
||||
description = "Pine Sapling",
|
||||
drawtype = "plantlike",
|
||||
visual_scale = 1.0,
|
||||
tiles = {"snow_sapling_pine.png"},
|
||||
inventory_image = "snow_sapling_pine.png",
|
||||
wield_image = "snow_sapling_pine.png",
|
||||
paramtype = "light",
|
||||
walkable = false,
|
||||
groups = {snappy=2,dig_immediate=3,flammable=2},
|
||||
sounds = default.node_sound_defaults(),
|
||||
})
|
||||
|
||||
minetest.register_node("snow:star", {
|
||||
description = "Star",
|
||||
drawtype = "torchlike",
|
||||
tiles = {"snow_star.png"},
|
||||
inventory_image = "snow_star.png",
|
||||
wield_image = "snow_star.png",
|
||||
paramtype = "light",
|
||||
walkable = false,
|
||||
groups = {snappy=2,dig_immediate=3},
|
||||
sounds = default.node_sound_defaults(),
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
type = "fuel",
|
||||
recipe = "snow:needles",
|
||||
burntime = 1,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
type = "fuel",
|
||||
recipe = "snow:sapling_pine",
|
||||
burntime = 10,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
type = "fuel",
|
||||
recipe = "snow:needles_decorated",
|
||||
burntime = 1,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
type = "fuel",
|
||||
recipe = "snow:xmas_tree",
|
||||
burntime = 10,
|
||||
})
|
||||
|
||||
|
||||
|
||||
--Snowballs
|
||||
-------------
|
||||
snowball_GRAVITY=9
|
||||
snowball_VELOCITY=19
|
||||
|
||||
--Shoot snowball.
|
||||
local snow_shoot_snowball=function (item, player, pointed_thing)
|
||||
local playerpos=player:getpos()
|
||||
local obj=minetest.env:add_entity({x=playerpos.x,y=playerpos.y+1.5,z=playerpos.z}, "snow:snowball_entity")
|
||||
local dir=player:get_look_dir()
|
||||
obj:setvelocity({x=dir.x*snowball_VELOCITY, y=dir.y*snowball_VELOCITY, z=dir.z*snowball_VELOCITY})
|
||||
obj:setacceleration({x=dir.x*-3, y=-snowball_GRAVITY, z=dir.z*-3})
|
||||
item:take_item()
|
||||
return item
|
||||
end
|
||||
|
||||
--The snowball Entity
|
||||
snow_snowball_ENTITY={
|
||||
physical = false,
|
||||
timer=0,
|
||||
textures = {"snow_snowball.png"},
|
||||
lastpos={},
|
||||
collisionbox = {0,0,0,0,0,0},
|
||||
}
|
||||
|
||||
--Snowball_entity.on_step()--> called when snowball is moving.
|
||||
snow_snowball_ENTITY.on_step = function(self, dtime)
|
||||
self.timer=self.timer+dtime
|
||||
local pos = self.object:getpos()
|
||||
local node = minetest.env:get_node(pos)
|
||||
|
||||
--Become item when hitting a node.
|
||||
if self.lastpos.x~=nil then --If there is no lastpos for some reason.
|
||||
if node.name ~= "air" then
|
||||
minetest.env:place_node(self.lastpos,{name="snow:snow"})
|
||||
self.object:remove()
|
||||
end
|
||||
end
|
||||
self.lastpos={x=pos.x, y=pos.y, z=pos.z} -- Set lastpos-->Node will be added at last pos outside the node
|
||||
end
|
||||
|
||||
minetest.register_entity("snow:snowball_entity", snow_snowball_ENTITY)
|
||||
|
||||
--Snowball.
|
||||
minetest.register_craftitem("snow:snowball", {
|
||||
description = "Snowball",
|
||||
inventory_image = "snow_snowball.png",
|
||||
on_use = snow_shoot_snowball,
|
||||
})
|
||||
|
||||
--Snow.
|
||||
minetest.register_node("snow:snow", {
|
||||
description = "Snow",
|
||||
tiles = {"snow_snow.png"},
|
||||
drawtype = "nodebox",
|
||||
sunlight_propagates = true,
|
||||
paramtype = "light",
|
||||
param2 = nil,
|
||||
--param2 is reserved for what vegetation is hiding inside.
|
||||
--mapgen defines the vegetation.
|
||||
--1 = Moss
|
||||
groups = {crumbly=3,melts=3,oddly_breakable_by_hand=2},
|
||||
buildable_to = true,
|
||||
drop = 'snow:snowball',
|
||||
node_box = {
|
||||
type = "fixed",
|
||||
fixed = {
|
||||
{-0.5, -0.5, -0.5, 0.5, -0.35, 0.5}
|
||||
},
|
||||
},
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
fixed = {
|
||||
{-0.5, -0.5, -0.5, 0.5, -0.35, 0.5}
|
||||
},
|
||||
},
|
||||
sounds = default.node_sound_dirt_defaults({
|
||||
footstep = {name="default_gravel_footstep", gain=0.45},
|
||||
}),
|
||||
--Update dirt node underneath snow.
|
||||
after_destruct = function(pos, node, digger)
|
||||
if node.param2 == 1 then
|
||||
local n = minetest.env:get_node(pos).name
|
||||
if n == "air" or n == "default:water_flowing" or n == "default:water_source" then
|
||||
minetest.env:add_node(pos,{name="snow:moss",param2=1})
|
||||
local bnode = minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z})
|
||||
if node.name == "default:snow" then
|
||||
local level = minetest.get_node_level(pos)
|
||||
if level < 63 then
|
||||
if minetest.get_item_group(bnode.name, "leafdecay") == 0
|
||||
and not snow.is_uneven(pos) then
|
||||
minetest.sound_play("default_snow_footstep", {pos=pos})
|
||||
minetest.add_node_level(pos, 7)
|
||||
end
|
||||
elseif level == 63 then
|
||||
local p = minetest.find_node_near(pos, 10, "default:dirt_with_grass")
|
||||
if p
|
||||
and minetest.get_node_light(p, 0.5) == 15 then
|
||||
minetest.sound_play("default_grass_footstep", {pos=pos})
|
||||
minetest.place_node({x=pos.x, y=pos.y+1, z=pos.z}, {name="default:snow"})
|
||||
else
|
||||
minetest.sound_play("default_snow_footstep", {pos=pos})
|
||||
minetest.add_node(pos, {name="default:snowblock"})
|
||||
end
|
||||
end
|
||||
pos.y = pos.y - 1
|
||||
local nodename = minetest.env:get_node(pos).name
|
||||
if nodename == "snow:dirt_with_snow" then
|
||||
minetest.env:add_node(pos,{name="default:dirt_with_grass"})
|
||||
end
|
||||
end,
|
||||
on_construct = function(pos, newnode)
|
||||
pos.y = pos.y - 1
|
||||
local nodename = minetest.env:get_node(pos).name
|
||||
if nodename == "default:dirt_with_grass" then
|
||||
minetest.env:remove_node(pos)
|
||||
minetest.env:add_node(pos,{name="snow:dirt_with_snow"})
|
||||
elseif nodename == "air" then
|
||||
pos.y = pos.y + 1
|
||||
minetest.env:remove_node(pos)
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
--Snow with dirt.
|
||||
minetest.register_node("snow:dirt_with_snow", {
|
||||
description = "Dirt with Snow",
|
||||
tiles = {"snow_snow.png", "default_dirt.png", "default_dirt.png^snow_snow_side.png"},
|
||||
is_ground_content = true,
|
||||
groups = {crumbly=3},
|
||||
drop = 'default:dirt',
|
||||
sounds = default.node_sound_dirt_defaults({
|
||||
footstep = {name="default_grass_footstep", gain=0.4},
|
||||
}),
|
||||
--Place snow above this node when placed.
|
||||
after_place_node = function(pos, newnode)
|
||||
pos.y = pos.y + 1
|
||||
local nodename = minetest.env:get_node(pos).name
|
||||
if nodename == "air" then
|
||||
minetest.env:add_node(pos,{name="snow:snow"})
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
--Gets rid of snow when the node underneath is dug.
|
||||
local unsnowify = function(pos, node, digger)
|
||||
if node.name == "default:dry_shrub" then
|
||||
pos.y = pos.y - 1
|
||||
local nodename = minetest.env:get_node(pos).name
|
||||
if nodename == "snow:dirt_with_snow" then
|
||||
minetest.env:add_node(pos,{name="default:dirt_with_grass"})
|
||||
end
|
||||
pos.y = pos.y + 1
|
||||
end
|
||||
pos.y = pos.y + 1
|
||||
local nodename = minetest.env:get_node(pos).name
|
||||
if nodename == "snow:snow" then
|
||||
minetest.env:remove_node(pos)
|
||||
local obj=minetest.env:add_entity({x=pos.x,y=pos.y,z=pos.z}, "snow:snowball_entity")
|
||||
obj:setacceleration({x=0, y=-snowball_GRAVITY, z=0})
|
||||
end
|
||||
end
|
||||
|
||||
minetest.register_on_dignode(unsnowify)
|
||||
|
||||
--Snow block.
|
||||
minetest.register_node("snow:snow_block", {
|
||||
description = "Snow",
|
||||
tiles = {"snow_snow.png"},
|
||||
--param2 is reserved for what vegetation is hiding inside.
|
||||
--mapgen defines the vegetation.
|
||||
--1 = Moss
|
||||
--2 = Papyrus
|
||||
--3 = Dry shrub
|
||||
is_ground_content = true,
|
||||
groups = {crumbly=3,melts=2,falling_node=1},
|
||||
drop = 'snow:snow_block',
|
||||
sounds = default.node_sound_dirt_defaults({
|
||||
footstep = {name="default_grass_footstep", gain=0.4},
|
||||
}),
|
||||
--Update dirt node underneath snow.
|
||||
after_destruct = function(pos, node, digger)
|
||||
if node.param2 == 1 then
|
||||
local n = minetest.env:get_node(pos).name
|
||||
if n == "air" or n == "default:water_flowing" or n == "default:water_source" then
|
||||
minetest.env:add_node(pos,{name="snow:moss",param2=1})
|
||||
end
|
||||
elseif node.param2 == 2 then
|
||||
local n = minetest.env:get_node(pos).name
|
||||
if n == "air" or n == "default:water_flowing" or n == "default:water_source" then
|
||||
minetest.env:add_node(pos,{name="default:papyrus"})
|
||||
pos.y = pos.y + 1
|
||||
local n = minetest.env:get_node(pos)
|
||||
if n.name == "snow:snow_block" and n.param2 == 2 then
|
||||
minetest.env:remove_node(pos)
|
||||
pos.y = pos.y - 1
|
||||
minetest.env:add_node(pos,{name="snow:snow_block",param2=2})
|
||||
elseif node.name ~= "default:ice"
|
||||
and bnode.name ~= "air" then
|
||||
local data = minetest.registered_nodes[node.name]
|
||||
local drawtype = data.drawtype
|
||||
if drawtype == "normal"
|
||||
or drawtype == "allfaces_optional" then
|
||||
pos.y = pos.y+1
|
||||
local sound = data.sounds
|
||||
if sound then
|
||||
sound = sound.footstep
|
||||
if sound then
|
||||
minetest.sound_play(sound.name, {pos=pos, gain=sound.gain})
|
||||
end
|
||||
end
|
||||
elseif node.param2 == 3 then
|
||||
local n = minetest.env:get_node(pos).name
|
||||
if n == "air" or n == "default:water_flowing" or n == "default:water_source" then
|
||||
minetest.env:add_node(pos,{name="default:dry_shrub"})
|
||||
minetest.place_node(pos, {name="default:snow"})
|
||||
elseif drawtype == "plantlike" then
|
||||
pos.y = pos.y - 1
|
||||
if minetest.get_node(pos).name == "default:dirt_with_grass" then
|
||||
minetest.sound_play("default_grass_footstep", {pos=pos})
|
||||
minetest.add_node(pos, {name="default:dirt_with_snow"})
|
||||
end
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
--Snow brick.
|
||||
minetest.register_node("snow:snow_brick", {
|
||||
description = "Snow Brick",
|
||||
tiles = {"snow_snow_brick.png"},
|
||||
is_ground_content = true,
|
||||
groups = {crumbly=3,melts=2},
|
||||
drop = 'snow:snow_brick',
|
||||
sounds = default.node_sound_dirt_defaults({
|
||||
footstep = {name="default_grass_footstep", gain=0.4},
|
||||
}),
|
||||
})
|
||||
|
||||
--Ice.
|
||||
minetest.register_node("snow:ice", {
|
||||
description = "Ice",
|
||||
tiles = {"snow_ice.png"},
|
||||
is_ground_content = true,
|
||||
groups = {snappy=2,cracky=3,melts=1},
|
||||
drop = 'snow:ice',
|
||||
paramtype = "light",
|
||||
sunlight_propagates = true,
|
||||
sounds = default.node_sound_glass_defaults({
|
||||
footstep = {name="default_stone_footstep", gain=0.4},
|
||||
}),
|
||||
})
|
||||
|
||||
--Moss.
|
||||
minetest.register_node("snow:moss", {
|
||||
description = "Moss",
|
||||
tiles = {"snow_moss.png"},
|
||||
drawtype = "signlike",
|
||||
paramtype = "light",
|
||||
paramtype2 = "wallmounted",
|
||||
walkable = false,
|
||||
selection_box = {
|
||||
type = "wallmounted",
|
||||
},
|
||||
is_ground_content = true,
|
||||
groups = {crumbly=3, flammable=2, attached_node=1},
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = 'snow:snow_block',
|
||||
recipe = {
|
||||
{'snow:snowball', 'snow:snowball'},
|
||||
{'snow:snowball', 'snow:snowball'},
|
||||
},
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = 'snow:snow_brick',
|
||||
recipe = {
|
||||
{'snow:snow_block', 'snow:snow_block'},
|
||||
{'snow:snow_block', 'snow:snow_block'},
|
||||
},
|
||||
})
|
||||
|
||||
--Melting
|
||||
--Any node part of the group melting will melt when near warm nodes such as lava, fire, torches, etc.
|
||||
--The amount of water that replaces the node is defined by the number on the group:
|
||||
--1: one water_source
|
||||
--2: four water_flowings
|
||||
--3: one water_flowing
|
||||
minetest.register_abm({
|
||||
nodenames = {"group:melts"},
|
||||
neighbors = {"group:igniter","default:torch","default:furnace_active","group:hot"},
|
||||
interval = 2,
|
||||
chance = 2,
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
local intensity = minetest.get_item_group(node.name,"melts")
|
||||
if intensity == 1 then
|
||||
minetest.env:add_node(pos,{name="default:water_source"})
|
||||
elseif intensity == 2 then
|
||||
local check_place = function(pos,node)
|
||||
if minetest.env:get_node(pos).name == "air" then
|
||||
minetest.env:place_node(pos,node)
|
||||
end
|
||||
end
|
||||
minetest.env:add_node(pos,{name="default:water_flowing"})
|
||||
check_place({x=pos.x+1,y=pos.y,z=pos.z},{name="default:water_flowing"})
|
||||
check_place({x=pos.x-1,y=pos.y,z=pos.z},{name="default:water_flowing"})
|
||||
check_place({x=pos.x,y=pos.y+1,z=pos.z},{name="default:water_flowing"})
|
||||
check_place({x=pos.x,y=pos.y-1,z=pos.z},{name="default:water_flowing"})
|
||||
elseif intensity == 3 then
|
||||
minetest.env:add_node(pos,{name="default:water_flowing"})
|
||||
end
|
||||
nodeupdate(pos)
|
||||
end,
|
||||
})
|
||||
|
||||
--Freezing
|
||||
--Water freezes when in contact with snow.
|
||||
minetest.register_abm({
|
||||
nodenames = {"default:water_source"},
|
||||
neighbors = {"snow:snow", "snow:snow_block"},
|
||||
interval = 20,
|
||||
chance = 4,
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
minetest.env:add_node(pos,{name="snow:ice"})
|
||||
end,
|
||||
})
|
||||
|
||||
--Spread moss to cobble.
|
||||
minetest.register_abm({
|
||||
nodenames = {"default:cobble"},
|
||||
neighbors = {"snow:moss"},
|
||||
interval = 20,
|
||||
chance = 6,
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
minetest.env:add_node(pos,{name="default:mossycobble"})
|
||||
end,
|
||||
})
|
||||
|
||||
--Grow saplings
|
||||
minetest.register_abm({
|
||||
nodenames = {"snow:sapling_pine"},
|
||||
interval = 10,
|
||||
chance = 50,
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
snow.make_pine(pos,false)
|
||||
end,
|
||||
})
|
||||
|
||||
--Grow saplings
|
||||
minetest.register_abm({
|
||||
nodenames = {"snow:xmas_tree"},
|
||||
interval = 10,
|
||||
chance = 50,
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
snow.make_pine(pos,false,true)
|
||||
end,
|
||||
})
|
||||
|
||||
if snow.enable_snowfall then
|
||||
|
||||
--Snowing
|
||||
snow_fall=function (pos)
|
||||
local obj=minetest.env:add_entity(pos, "snow:fall_entity")
|
||||
obj:setvelocity({x=0, y=-1, z=0})
|
||||
end
|
||||
|
||||
-- The snowfall Entity
|
||||
snow_fall_ENTITY={
|
||||
physical = true,
|
||||
timer=0,
|
||||
textures = {"snow_snowfall.png"},
|
||||
lastpos={},
|
||||
collisionbox = {0,0,0,0,0,0},
|
||||
}
|
||||
|
||||
|
||||
-- snowfall_entity.on_step()--> called when snow is falling
|
||||
snow_fall_ENTITY.on_step = function(self, dtime)
|
||||
self.timer=self.timer+dtime
|
||||
local pos = self.object:getpos()
|
||||
local node = minetest.env:get_node(pos)
|
||||
|
||||
if self.lastpos and self.object:getvelocity().y == 0 then
|
||||
if minetest.env:get_node({x=self.lastpos.x,z=self.lastpos.z,y=self.lastpos.y}).name == "snow:moss" then
|
||||
minetest.env:add_node({x=self.lastpos.x,z=self.lastpos.z,y=self.lastpos.y},{name="snow:snow",param2=1})
|
||||
self.object:remove()
|
||||
return
|
||||
end
|
||||
minetest.env:place_node(self.lastpos,{name="snow:snow"})
|
||||
self.object:remove()
|
||||
end
|
||||
|
||||
if self.timer > 120 then
|
||||
self.object:remove()
|
||||
end
|
||||
|
||||
self.lastpos={x=pos.x, y=pos.y, z=pos.z} -- Set lastpos-->Node will be added at last pos outside the node
|
||||
end
|
||||
|
||||
minetest.register_entity("snow:fall_entity", snow_fall_ENTITY)
|
||||
|
||||
--Regenerate Snow
|
||||
minetest.register_abm({
|
||||
nodenames = {"default:dirt_with_grass", "default:desert_sand", "snow:moss"},
|
||||
interval = 50,
|
||||
chance = 150,
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
--Check we are in the right biome
|
||||
local env = minetest.env
|
||||
local perlin1 = env:get_perlin(112,3, 0.5, 150)
|
||||
local test = perlin1:get2d({x=pos.x, y=pos.z})
|
||||
local in_biome = false
|
||||
local smooth = snow.smooth
|
||||
if smooth and (test > 0.73 or (test > 0.43 and math.random(0,29) > (0.73 - test) * 100 )) then
|
||||
in_biome = true
|
||||
elseif not smooth and test > 0.53 then
|
||||
in_biome = true
|
||||
end
|
||||
if in_biome then
|
||||
--Check if block is under cover
|
||||
local ground_y = nil
|
||||
for y=15,0,-1 do
|
||||
if env:get_node({x=pos.x,y=y+pos.y,z=pos.z}).name ~= "air" then
|
||||
ground_y = pos.y+y
|
||||
break
|
||||
end
|
||||
end
|
||||
if ground_y then
|
||||
local n = env:get_node({x=pos.x,y=ground_y,z=pos.z})
|
||||
if (n.name ~= "snow:snow" and n.name ~= "snow:snow_block" and n.name ~= "snow:ice" and n.name ~= "default:water_source" and n.name ~= "default:papyrus") then
|
||||
local obj = minetest.env:get_objects_inside_radius({x=pos.x,y=ground_y+20,z=pos.z}, 15)
|
||||
for i,v in pairs(obj) do
|
||||
e = v:get_luaentity()
|
||||
if e ~= nil and e.name == "snow:fall_entity" then
|
||||
return
|
||||
end
|
||||
end
|
||||
snow_fall({x=pos.x,y=ground_y+15,z=pos.z})
|
||||
if snow.debug then
|
||||
print("snowfall at x"..pos.x.." y"..pos.z)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
})
|
||||
end
|
||||
|
||||
-- Checks if the snow level is even at any given pos.
|
||||
-- Smooth Snow
|
||||
local function is_uneven(pos)
|
||||
local num = minetest.get_node_level(pos)
|
||||
local get_node = minetest.get_node
|
||||
local add_node = minetest.add_node
|
||||
local found
|
||||
local foundx
|
||||
local foundy
|
||||
local foundz
|
||||
for z = -1,1 do
|
||||
for x = -1,1 do
|
||||
local p = {x=pos.x+x, y=pos.y, z=pos.z+z}
|
||||
local node = get_node(p)
|
||||
p.y = p.y-1
|
||||
local bnode = get_node(p)
|
||||
|
||||
if node
|
||||
and minetest.registered_nodes[node.name]
|
||||
and minetest.registered_nodes[node.name].drawtype == "plantlike"
|
||||
and bnode.name == "default:dirt_with_grass" then
|
||||
add_node(p, {name="default:dirt_with_snow"})
|
||||
return true
|
||||
end
|
||||
|
||||
p.y = p.y+1
|
||||
if not (x == 0 and z == 0)
|
||||
and node.name == "default:snow"
|
||||
and minetest.get_node_level(p) < num then
|
||||
found = true
|
||||
foundx = x
|
||||
foundz = z
|
||||
elseif node.name == "air"
|
||||
and bnode.name ~= "air"
|
||||
and bnode.name ~= "default:snow" then
|
||||
p.y = p.y-1
|
||||
snow.place(p)
|
||||
return true
|
||||
end
|
||||
end
|
||||
end
|
||||
if found then
|
||||
local p = {x=pos.x+foundx, y=pos.y, z=pos.z+foundz}
|
||||
if is_uneven(p) ~= true then
|
||||
minetest.add_node_level(p, 7)
|
||||
end
|
||||
return true
|
||||
end
|
||||
end
|
||||
|
||||
function snow.is_uneven(pos)
|
||||
if snow.smooth_snow then
|
||||
return is_uneven(pos)
|
||||
end
|
||||
end
|
||||
|
||||
@ -1,304 +0,0 @@
|
||||
--Makes pine tree
|
||||
function snow.make_pine(pos,snow,xmas)
|
||||
local env = minetest.env
|
||||
local perlin1 = env:get_perlin(112,3, 0.5, 150)
|
||||
local try_node = function(pos, node)
|
||||
local n = env:get_node(pos).name
|
||||
if n == "air" or n == "snow:needles" or n == "default:leaves" or n == "snow:sapling_pine" or n == "snow:snow" or "snow:needles_decorated" then
|
||||
env:add_node(pos,node)
|
||||
end
|
||||
end
|
||||
local leaves = "snow:needles"
|
||||
if xmas then leaves = "snow:needles_decorated" end
|
||||
--Clear ground.
|
||||
for x=-1,1 do
|
||||
for z=-1,1 do
|
||||
if env:get_node({x=pos.x+x,y=pos.y,z=pos.z+z}).name == "snow:snow" then
|
||||
env:remove_node({x=pos.x+x,y=pos.y,z=pos.z+z})
|
||||
end
|
||||
if env:get_node({x=pos.x+x,y=pos.y,z=pos.z+z}).name == "snow:snow_block" then
|
||||
env:remove_node({x=pos.x+x,y=pos.y,z=pos.z+z})
|
||||
end
|
||||
end
|
||||
end
|
||||
--Make tree.
|
||||
for i=0, 4 do
|
||||
local env = minetest.env
|
||||
if i==1 or i==2 then
|
||||
for x=-1,1 do
|
||||
for z=-1,1 do
|
||||
local x = pos.x + x
|
||||
local z = pos.z + z
|
||||
try_node({x=x,y=pos.y+i,z=z},{name=leaves})
|
||||
if snow and x ~= 0 and z ~= 0 and perlin1:get2d({x=x,y=z}) > 0.53 then
|
||||
try_node({x=x,y=pos.y+i+1,z=z},{name="snow:snow"})
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
if i==3 or i==4 then
|
||||
local x = pos.x
|
||||
local y = pos.y+i
|
||||
local z = pos.z
|
||||
try_node({x=x+1,y=y,z=z},{name=leaves})
|
||||
try_node({x=x-1,y=y,z=z},{name=leaves})
|
||||
try_node({x=x,y=y,z=z+1},{name=leaves})
|
||||
try_node({x=x,y=y,z=z-1},{name=leaves})
|
||||
if snow then
|
||||
if perlin1:get2d({x=x+1,y=z}) > 0.53 then
|
||||
try_node({x=x+1,y=y+1,z=z},{name="snow:snow"})
|
||||
end
|
||||
if perlin1:get2d({x=x+1,y=z}) > 0.53 then
|
||||
try_node({x=x-1,y=y+1,z=z},{name="snow:snow"})
|
||||
end
|
||||
if perlin1:get2d({x=x,y=z+1}) > 0.53 then
|
||||
try_node({x=x,y=y+1,z=z+1},{name="snow:snow"})
|
||||
end
|
||||
if perlin1:get2d({x=x,y=z-1}) > 0.53 then
|
||||
try_node({x=x,y=y+1,z=z-1},{name="snow:snow"})
|
||||
end
|
||||
end
|
||||
end
|
||||
try_node({x=pos.x,y=pos.y+i,z=pos.z},{name="default:tree"})
|
||||
end
|
||||
try_node({x=pos.x,y=pos.y+5,z=pos.z},{name=leaves})
|
||||
try_node({x=pos.x,y=pos.y+6,z=pos.z},{name=leaves})
|
||||
if xmas then
|
||||
try_node({x=pos.x,y=pos.y+7,z=pos.z},{name="snow:star"})
|
||||
elseif snow and perlin1:get2d({x=pos.x,y=pos.z}) > 0.53 then
|
||||
try_node({x=pos.x,y=pos.y+7,z=pos.z},{name="snow:snow"})
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
|
||||
--Snow biomes are found at 0.53 and greater perlin noise.
|
||||
minetest.register_on_generated(function(minp, maxp, seed)
|
||||
if maxp.y >= -10 then
|
||||
local debug = snow.debug
|
||||
|
||||
--Should make things a bit faster.
|
||||
local env = minetest.env
|
||||
|
||||
--Get map specific perlin
|
||||
local perlin1 = env:get_perlin(112,3, 0.5, 150)
|
||||
|
||||
-- Assume X and Z lengths are equal
|
||||
local divlen = 16
|
||||
local divs = (maxp.x-minp.x);
|
||||
local x0 = minp.x
|
||||
local z0 = minp.z
|
||||
local x1 = maxp.x
|
||||
local z1 = maxp.z
|
||||
|
||||
--Speed hack: checks the corners and middle of the chunk for "snow biome".
|
||||
if not ( perlin1:get2d( {x=x0, y=z0} ) > 0.53 ) --top left
|
||||
and not ( perlin1:get2d( { x = x0 + ( (x1-x0)/2), y=z0 } ) > 0.53 )--top middle
|
||||
and not (perlin1:get2d({x=x1, y=z1}) > 0.53) --bottom right
|
||||
and not (perlin1:get2d({x=x1, y=z0+((z1-z0)/2)}) > 0.53) --right middle
|
||||
and not (perlin1:get2d({x=x0, y=z1}) > 0.53) --bottom left
|
||||
and not (perlin1:get2d({x=x1, y=z0}) > 0.53) --top right
|
||||
and not (perlin1:get2d({x=x0+((x1-x0)/2), y=z1}) > 0.53) --left middle
|
||||
and not (perlin1:get2d({x=(x1-x0)/2, y=(z1-z0)/2}) > 0.53) --middle
|
||||
and not (perlin1:get2d({x=x0, y=z1+((z1-z0)/2)}) > 0.53) then --bottom middle
|
||||
return
|
||||
end
|
||||
|
||||
--Choose a biome types.
|
||||
local pr = PseudoRandom(seed+57)
|
||||
local biome
|
||||
|
||||
--Land biomes
|
||||
biome = pr:next(1, 5)
|
||||
local snowy = biome == 1 --spawns alot of snow
|
||||
local plain = biome == 2 --spawns not much
|
||||
local alpine = biome == 3 --rocky terrain
|
||||
-- biome == 4 or biome == 5 -- normal biome
|
||||
|
||||
--Water biomes
|
||||
biome2 = pr:next(1, 5)
|
||||
local cool = biome == 1 --only spawns ice on edge of water
|
||||
local icebergs = biome == 2
|
||||
local icesheet = biome == 3
|
||||
local icecave = biome == 4
|
||||
local icehole = biome == 5 --icesheet with holes
|
||||
|
||||
--Misc biome settings.
|
||||
local icy = pr:next(1, 2) == 2 --If enabled spawns ice in sand instead of snow blocks.
|
||||
local mossy = pr:next(1,2) == 1 --Spawns moss in snow.
|
||||
local shrubs = pr:next(1,2) == 1 --Spawns dry shrubs in snow.
|
||||
local pines = pr:next(1,2) == 1 --spawns pines.
|
||||
|
||||
--Debugging function
|
||||
local biomeToString = function(num,num2)
|
||||
local biome, biome2
|
||||
if num == 1 then biome = "snowy"
|
||||
elseif num == 2 then biome = "plain"
|
||||
elseif num == 3 then biome = "alpine"
|
||||
elseif num == 4 or num == 5 then biome = "normal"
|
||||
else biome = "unknown "..num end
|
||||
|
||||
if num2 == 1 then biome2 = "cool"
|
||||
elseif num2 == 2 then biome2 = "icebergs"
|
||||
elseif num2 == 3 then biome2 = "icesheet"
|
||||
elseif num2 == 4 then biome2 = "icecave"
|
||||
elseif num2 == 5 then biome2 = "icehole"
|
||||
else biome2 = "unknown "..num end
|
||||
|
||||
return biome, biome2
|
||||
end
|
||||
|
||||
local make_pine = snow.make_pine
|
||||
local smooth = snow.smooth
|
||||
|
||||
--Reseed random.
|
||||
pr = PseudoRandom(seed+68)
|
||||
|
||||
if alpine then
|
||||
local trees = env:find_nodes_in_area(minp, maxp, {"default:leaves","default:tree"})
|
||||
for i,v in pairs(trees) do
|
||||
env:remove_node(v)
|
||||
end
|
||||
end
|
||||
|
||||
--Loop through chunk.
|
||||
for j=0,divs do
|
||||
for i=0,divs do
|
||||
|
||||
local x = x0+i
|
||||
local z = z0+j
|
||||
|
||||
--Check if we are in a "Snow biome"
|
||||
local in_biome = false
|
||||
local test = perlin1:get2d({x=x, y=z})
|
||||
if smooth and (not snowy) and (test > 0.73 or (test > 0.43 and pr:next(0,29) > (0.73 - test) * 100 )) then
|
||||
in_biome = true
|
||||
elseif (not smooth or snowy) and test > 0.53 then
|
||||
in_biome = true
|
||||
end
|
||||
|
||||
if in_biome then
|
||||
|
||||
if not plain or pr:next(1,12) == 1 then
|
||||
|
||||
-- Find ground level (0...15)
|
||||
local ground_y = nil
|
||||
for y=maxp.y,minp.y+1,-1 do
|
||||
if env:get_node({x=x,y=y,z=z}).name ~= "air" then
|
||||
ground_y = y
|
||||
break
|
||||
end
|
||||
end
|
||||
|
||||
-- Snowy biome stuff
|
||||
local node = env:get_node({x=x,y=ground_y,z=z})
|
||||
|
||||
if ground_y and (node.name == "default:dirt_with_grass" or node.name == "default:junglegrass") then
|
||||
local veg
|
||||
if mossy and pr:next(1,10) == 1 then veg = 1 end
|
||||
if alpine then
|
||||
--Gets rid of dirt
|
||||
env:add_node({x=x,y=ground_y+1,z=z}, {name="snow:snow",param2=veg})
|
||||
for y=ground_y,-6,-1 do
|
||||
if env:get_node({x=x,y=y,z=z}) and env:get_node({x=x,y=y,z=z}).name == "default:stone" then
|
||||
break
|
||||
else
|
||||
env:add_node({x=x,y=y,z=z},{name="default:stone"})
|
||||
end
|
||||
end
|
||||
elseif (shrubs and pr:next(1,28) == 1) or node.name == "default:junglegrass" then
|
||||
--Spawns dry shrubs.
|
||||
env:add_node({x=x,y=ground_y,z=z}, {name="snow:dirt_with_snow"})
|
||||
if snowy then
|
||||
env:add_node({x=x,y=ground_y+1,z=z}, {name="snow:snow_block", param2=3})
|
||||
else
|
||||
env:add_node({x=x,y=ground_y+1,z=z}, {name="default:dry_shrub"})
|
||||
end
|
||||
elseif pines and pr:next(1,36) == 1 then
|
||||
--Spawns pines.
|
||||
env:add_node({x=x,y=ground_y,z=z}, {name="default:dirt_with_grass"})
|
||||
make_pine({x=x,y=ground_y+1,z=z},true)
|
||||
elseif snowy then
|
||||
--Spawns snow blocks.
|
||||
env:add_node({x=x,y=ground_y+1,z=z}, {name="snow:snow_block"})
|
||||
env:add_node({x=x,y=ground_y+2,z=z}, {name="snow:snow",param2=veg})
|
||||
else
|
||||
--Spawns snow.
|
||||
env:add_node({x=x,y=ground_y,z=z}, {name="snow:dirt_with_snow"})
|
||||
env:add_node({x=x,y=ground_y+1,z=z}, {name="snow:snow",param2=veg})
|
||||
end
|
||||
elseif ground_y and node.name == "default:sand" then
|
||||
--Spawns ice in sand if icy, otherwise spawns snow on top.
|
||||
if not icy then
|
||||
env:add_node({x=x,y=ground_y+1,z=z}, {name="snow:snow"})
|
||||
env:add_node({x=x,y=ground_y,z=z}, {name="snow:snow_block"})
|
||||
else
|
||||
env:add_node({x=x,y=ground_y,z=z}, {name="snow:ice"})
|
||||
end
|
||||
elseif ground_y and env:get_node({x=x,y=ground_y,z=z}).name == "default:leaves" then
|
||||
env:add_node({x=x,y=ground_y+1,z=z}, {name="snow:snow"})
|
||||
elseif ground_y and env:get_node({x=x,y=ground_y,z=z}).name == "default:papyrus" then
|
||||
for i=ground_y, ground_y-4, -1 do
|
||||
if env:get_node({x=x,y=i,z=z}).name == "default:papyrus" then
|
||||
env:add_node({x=x,y=ground_y+1,z=z}, {name="snow:snow"})
|
||||
env:add_node({x=x,y=i,z=z}, {name="snow:snow_block", param2=2})
|
||||
end
|
||||
end
|
||||
elseif ground_y and node.name == "default:water_source" then
|
||||
if not icesheet and not icecave and not icehole then
|
||||
--Coastal ice.
|
||||
local x1 = env:get_node({x=x+1,y=ground_y,z=z}).name
|
||||
local z1 = env:get_node({x=x,y=ground_y,z=z+1}).name
|
||||
local xz1 = env:get_node({x=x+1,y=ground_y,z=z+1}).name
|
||||
local xz2 = env:get_node({x=x-1,y=ground_y,z=z-1}).name
|
||||
local x2 = env:get_node({x=x-1,y=ground_y,z=z}).name
|
||||
local z2 = env:get_node({x=x,y=ground_y,z=z-1}).name
|
||||
local y = env:get_node({x=x,y=ground_y-1,z=z}).name
|
||||
local rand = pr:next(1,4) == 1
|
||||
if
|
||||
((x1 and x1 ~= "default:water_source" and x1 ~= "snow:ice" and x1 ~= "air" and x1 ~= "ignore") or ((cool or icebergs) and x1 == "snow:ice" and rand)) or
|
||||
((z1 and z1 ~= "default:water_source" and z1 ~= "snow:ice" and z1 ~= "air" and z1 ~= "ignore") or ((cool or icebergs) and z1 == "snow:ice" and rand)) or
|
||||
((xz1 and xz1 ~= "default:water_source" and xz1 ~= "snow:ice" and xz1 ~= "air"and xz1 ~= "ignore") or ((cool or icebergs) and xz1 == "snow:ice" and rand)) or
|
||||
((xz2 and xz2 ~= "default:water_source" and xz2 ~= "snow:ice" and xz2 ~= "air"and xz2 ~= "ignore") or ((cool or icebergs) and xz2 == "snow:ice" and rand)) or
|
||||
((x2 and x2 ~= "default:water_source" and x2 ~= "snow:ice" and x2 ~= "air" and x2 ~= "ignore") or ((cool or icebergs) and x2 == "snow:ice" and rand)) or
|
||||
((z2 and z2 ~= "default:water_source" and z2 ~= "snow:ice" and z2 ~= "air" and z2 ~= "ignore") or ((cool or icebergs) and z2 == "snow:ice" and rand)) or
|
||||
(y ~= "default:water_source" and y ~= "snow:ice" and y ~= "air") or (pr:next(1,6) == 1 and icebergs) then
|
||||
env:add_node({x=x,y=ground_y,z=z}, {name="snow:ice"})
|
||||
end
|
||||
else
|
||||
--Icesheets, Broken icesheet, Icecaves
|
||||
if (icehole and pr:next(1,10) > 1) or icecave or icesheet then
|
||||
env:add_node({x=x,y=ground_y,z=z}, {name="snow:ice"})
|
||||
end
|
||||
if icecave then
|
||||
--Gets rid of water underneath ice
|
||||
for y=ground_y-1,-60,-1 do
|
||||
if env:get_node({x=x,y=y,z=z}) and env:get_node({x=x,y=y,z=z}).name ~= "default:water_source" then
|
||||
break
|
||||
else
|
||||
env:remove_node({x=x,y=y,z=z})
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
--~ elseif ground_y and node.name == "snow:snow" and node.name ~= "snow:ice" then
|
||||
--~ --Abort genaration.
|
||||
--~ local name = env:get_node({x=x,y=ground_y-1,z=z}).name
|
||||
--~ if name ~= "default:leaves" and name ~= "snow:needles" then
|
||||
--~ if debug then
|
||||
--~ print(biomeToString(biome)..": snow found ABORTED!")
|
||||
--~ end
|
||||
--~ return
|
||||
--~ end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
if debug then
|
||||
biome_string,biome2_string = biomeToString(biome,biome2)
|
||||
print(biome_string.." and "..biome2_string..": Snow Biome Genarated near x"..minp.x.." z"..minp.z)
|
||||
end
|
||||
end
|
||||
end
|
||||
)
|
||||
BIN
mods/snow/models/sled.blend
Normal file
BIN
mods/snow/models/sled.blend
Normal file
Binary file not shown.
BIN
mods/snow/models/sled.png
Normal file
BIN
mods/snow/models/sled.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 4.1 KiB |
369
mods/snow/models/sled.x
Normal file
369
mods/snow/models/sled.x
Normal file
@ -0,0 +1,369 @@
|
||||
xof 0303txt 0032
|
||||
|
||||
Frame Root {
|
||||
FrameTransformMatrix {
|
||||
1.000000, 0.000000, 0.000000, 0.000000,
|
||||
0.000000, 0.000000, 1.000000, 0.000000,
|
||||
0.000000, 1.000000,-0.000000, 0.000000,
|
||||
0.000000, 0.000000, 0.000000, 1.000000;;
|
||||
}
|
||||
Frame Cube_001 {
|
||||
FrameTransformMatrix {
|
||||
0.000000, 0.149813, 0.000000, 0.000000,
|
||||
-0.149813, 0.000000, 0.000000, 0.000000,
|
||||
0.000000, 0.000000, 0.149813, 0.000000,
|
||||
0.025244, 3.853863,-2.133818, 1.000000;;
|
||||
}
|
||||
Mesh { //Cube_003 Mesh
|
||||
88;
|
||||
-1.000000;53.554752;-1.000000;,
|
||||
-1.000000;-53.189678;-1.000000;,
|
||||
1.000000;-53.189678;-1.000000;,
|
||||
1.000000;53.554752;-1.000000;,
|
||||
0.999999;-53.189678;14.242604;,
|
||||
-1.000000;-53.189678;14.242604;,
|
||||
-1.000000;-53.189678;16.253036;,
|
||||
0.999999;-53.189678;16.253036;,
|
||||
1.000000;-53.189678;-1.000000;,
|
||||
0.999999;-53.189678;14.242604;,
|
||||
1.000000;53.554752;14.242604;,
|
||||
1.000000;53.554752;-1.000000;,
|
||||
-1.000000;-53.189678;-1.000000;,
|
||||
-1.000000;-53.189678;14.242604;,
|
||||
0.999999;-53.189678;14.242604;,
|
||||
1.000000;-53.189678;-1.000000;,
|
||||
-1.000000;53.554752;-1.000000;,
|
||||
-1.000000;53.554752;14.242604;,
|
||||
-1.000000;-53.189678;14.242604;,
|
||||
-1.000000;-53.189678;-1.000000;,
|
||||
-1.000000;53.554752;14.242604;,
|
||||
-1.000000;53.554752;-1.000000;,
|
||||
1.000000;53.554752;-1.000000;,
|
||||
1.000000;53.554752;14.242604;,
|
||||
0.999999;-53.189678;16.253036;,
|
||||
-1.000000;-53.189678;16.253036;,
|
||||
-1.000000;53.554752;16.253036;,
|
||||
1.000000;53.554752;16.253036;,
|
||||
-50.412270;53.554752;16.253036;,
|
||||
-50.412270;53.554752;14.242604;,
|
||||
-1.000000;53.554752;14.242604;,
|
||||
-1.000000;53.554752;16.253036;,
|
||||
1.000000;53.554752;14.242604;,
|
||||
0.999999;-53.189678;14.242604;,
|
||||
0.999999;-53.189678;16.253036;,
|
||||
1.000000;53.554752;16.253036;,
|
||||
1.000000;53.554752;16.253036;,
|
||||
-1.000000;53.554752;16.253036;,
|
||||
-1.000000;53.554752;14.242604;,
|
||||
1.000000;53.554752;14.242604;,
|
||||
-52.403629;-53.189678;16.253036;,
|
||||
-52.403629;53.554752;16.253036;,
|
||||
-50.412270;53.554752;16.253036;,
|
||||
-50.412270;-53.189678;16.253036;,
|
||||
-1.000000;-53.189678;14.242604;,
|
||||
-1.000000;53.554752;14.242604;,
|
||||
-50.412270;53.554752;14.242604;,
|
||||
-50.412270;-53.189678;14.242604;,
|
||||
-50.412270;-53.189678;16.253036;,
|
||||
-50.412270;53.554752;16.253036;,
|
||||
-1.000000;53.554752;16.253036;,
|
||||
-1.000000;-53.189678;16.253036;,
|
||||
-1.000000;-53.189678;16.253036;,
|
||||
-1.000000;-53.189678;14.242604;,
|
||||
-50.412270;-53.189678;14.242604;,
|
||||
-50.412270;-53.189678;16.253036;,
|
||||
-52.403629;-53.189678;14.242604;,
|
||||
-52.403629;53.554752;14.242604;,
|
||||
-52.403629;53.554752;16.253036;,
|
||||
-52.403629;-53.189678;16.253036;,
|
||||
-50.412270;-53.189678;16.253036;,
|
||||
-50.412270;-53.189678;14.242604;,
|
||||
-52.403629;-53.189678;14.242604;,
|
||||
-52.403629;-53.189678;16.253036;,
|
||||
-52.403629;53.554752;16.253036;,
|
||||
-52.403629;53.554752;14.242604;,
|
||||
-50.412270;53.554752;14.242604;,
|
||||
-50.412270;53.554752;16.253036;,
|
||||
-50.412270;53.554752;14.242604;,
|
||||
-52.403629;53.554752;14.242604;,
|
||||
-52.403629;53.554752;-0.989515;,
|
||||
-50.412270;53.554752;-0.989515;,
|
||||
-50.412270;-53.189678;-0.989515;,
|
||||
-50.412270;53.554752;-0.989515;,
|
||||
-52.403629;53.554752;-0.989515;,
|
||||
-52.403629;-53.189678;-0.989515;,
|
||||
-52.403629;-53.189678;-0.989515;,
|
||||
-52.403629;53.554752;-0.989515;,
|
||||
-52.403629;53.554752;14.242604;,
|
||||
-52.403629;-53.189678;14.242604;,
|
||||
-52.403629;-53.189678;14.242604;,
|
||||
-50.412270;-53.189678;14.242604;,
|
||||
-50.412270;-53.189678;-0.989515;,
|
||||
-52.403629;-53.189678;-0.989515;,
|
||||
-50.412270;-53.189678;14.242604;,
|
||||
-50.412270;53.554752;14.242604;,
|
||||
-50.412270;53.554752;-0.989515;,
|
||||
-50.412270;-53.189678;-0.989515;;
|
||||
22;
|
||||
4;0;1;2;3;,
|
||||
4;4;5;6;7;,
|
||||
4;8;9;10;11;,
|
||||
4;12;13;14;15;,
|
||||
4;16;17;18;19;,
|
||||
4;20;21;22;23;,
|
||||
4;24;25;26;27;,
|
||||
4;28;29;30;31;,
|
||||
4;32;33;34;35;,
|
||||
4;36;37;38;39;,
|
||||
4;40;41;42;43;,
|
||||
4;44;45;46;47;,
|
||||
4;48;49;50;51;,
|
||||
4;52;53;54;55;,
|
||||
4;56;57;58;59;,
|
||||
4;60;61;62;63;,
|
||||
4;64;65;66;67;,
|
||||
4;68;69;70;71;,
|
||||
4;72;73;74;75;,
|
||||
4;76;77;78;79;,
|
||||
4;80;81;82;83;,
|
||||
4;84;85;86;87;;
|
||||
MeshNormals { //Cube_003 Normals
|
||||
88;
|
||||
0.000000; 0.000000;-1.000000;,
|
||||
0.000000; 0.000000;-1.000000;,
|
||||
0.000000; 0.000000;-1.000000;,
|
||||
0.000000; 0.000000;-1.000000;,
|
||||
0.000000;-1.000000; 0.000000;,
|
||||
0.000000;-1.000000; 0.000000;,
|
||||
0.000000;-1.000000; 0.000000;,
|
||||
0.000000;-1.000000; 0.000000;,
|
||||
1.000000;-0.000000; 0.000000;,
|
||||
1.000000;-0.000000; 0.000000;,
|
||||
1.000000;-0.000000; 0.000000;,
|
||||
1.000000;-0.000000; 0.000000;,
|
||||
0.000000;-1.000000; 0.000000;,
|
||||
0.000000;-1.000000; 0.000000;,
|
||||
0.000000;-1.000000; 0.000000;,
|
||||
0.000000;-1.000000; 0.000000;,
|
||||
-1.000000; 0.000000;-0.000000;,
|
||||
-1.000000; 0.000000;-0.000000;,
|
||||
-1.000000; 0.000000;-0.000000;,
|
||||
-1.000000; 0.000000;-0.000000;,
|
||||
-0.000000; 1.000000; 0.000000;,
|
||||
-0.000000; 1.000000; 0.000000;,
|
||||
-0.000000; 1.000000; 0.000000;,
|
||||
-0.000000; 1.000000; 0.000000;,
|
||||
0.000000;-0.000000; 1.000000;,
|
||||
0.000000;-0.000000; 1.000000;,
|
||||
0.000000;-0.000000; 1.000000;,
|
||||
0.000000;-0.000000; 1.000000;,
|
||||
-0.000000; 1.000000; 0.000000;,
|
||||
-0.000000; 1.000000; 0.000000;,
|
||||
-0.000000; 1.000000; 0.000000;,
|
||||
-0.000000; 1.000000; 0.000000;,
|
||||
1.000000;-0.000000; 0.000000;,
|
||||
1.000000;-0.000000; 0.000000;,
|
||||
1.000000;-0.000000; 0.000000;,
|
||||
1.000000;-0.000000; 0.000000;,
|
||||
0.000000; 1.000000; 0.000000;,
|
||||
0.000000; 1.000000; 0.000000;,
|
||||
0.000000; 1.000000; 0.000000;,
|
||||
0.000000; 1.000000; 0.000000;,
|
||||
-0.000000; 0.000000; 1.000000;,
|
||||
-0.000000; 0.000000; 1.000000;,
|
||||
-0.000000; 0.000000; 1.000000;,
|
||||
-0.000000; 0.000000; 1.000000;,
|
||||
-0.000000; 0.000000;-1.000000;,
|
||||
-0.000000; 0.000000;-1.000000;,
|
||||
-0.000000; 0.000000;-1.000000;,
|
||||
-0.000000; 0.000000;-1.000000;,
|
||||
-0.000000; 0.000000; 1.000000;,
|
||||
-0.000000; 0.000000; 1.000000;,
|
||||
-0.000000; 0.000000; 1.000000;,
|
||||
-0.000000; 0.000000; 1.000000;,
|
||||
-0.000000;-1.000000; 0.000000;,
|
||||
-0.000000;-1.000000; 0.000000;,
|
||||
-0.000000;-1.000000; 0.000000;,
|
||||
-0.000000;-1.000000; 0.000000;,
|
||||
-1.000000; 0.000000; 0.000000;,
|
||||
-1.000000; 0.000000; 0.000000;,
|
||||
-1.000000; 0.000000; 0.000000;,
|
||||
-1.000000; 0.000000; 0.000000;,
|
||||
-0.000000;-1.000000; 0.000000;,
|
||||
-0.000000;-1.000000; 0.000000;,
|
||||
-0.000000;-1.000000; 0.000000;,
|
||||
-0.000000;-1.000000; 0.000000;,
|
||||
-0.000000; 1.000000; 0.000000;,
|
||||
-0.000000; 1.000000; 0.000000;,
|
||||
-0.000000; 1.000000; 0.000000;,
|
||||
-0.000000; 1.000000; 0.000000;,
|
||||
0.000000; 1.000000; 0.000000;,
|
||||
0.000000; 1.000000; 0.000000;,
|
||||
0.000000; 1.000000; 0.000000;,
|
||||
0.000000; 1.000000; 0.000000;,
|
||||
-0.000000; 0.000000;-1.000000;,
|
||||
-0.000000; 0.000000;-1.000000;,
|
||||
-0.000000; 0.000000;-1.000000;,
|
||||
-0.000000; 0.000000;-1.000000;,
|
||||
-1.000000; 0.000000; 0.000000;,
|
||||
-1.000000; 0.000000; 0.000000;,
|
||||
-1.000000; 0.000000; 0.000000;,
|
||||
-1.000000; 0.000000; 0.000000;,
|
||||
0.000000;-1.000000;-0.000000;,
|
||||
0.000000;-1.000000;-0.000000;,
|
||||
0.000000;-1.000000;-0.000000;,
|
||||
0.000000;-1.000000;-0.000000;,
|
||||
1.000000; 0.000000; 0.000000;,
|
||||
1.000000; 0.000000; 0.000000;,
|
||||
1.000000; 0.000000; 0.000000;,
|
||||
1.000000; 0.000000; 0.000000;;
|
||||
22;
|
||||
4;0;1;2;3;,
|
||||
4;4;5;6;7;,
|
||||
4;8;9;10;11;,
|
||||
4;12;13;14;15;,
|
||||
4;16;17;18;19;,
|
||||
4;20;21;22;23;,
|
||||
4;24;25;26;27;,
|
||||
4;28;29;30;31;,
|
||||
4;32;33;34;35;,
|
||||
4;36;37;38;39;,
|
||||
4;40;41;42;43;,
|
||||
4;44;45;46;47;,
|
||||
4;48;49;50;51;,
|
||||
4;52;53;54;55;,
|
||||
4;56;57;58;59;,
|
||||
4;60;61;62;63;,
|
||||
4;64;65;66;67;,
|
||||
4;68;69;70;71;,
|
||||
4;72;73;74;75;,
|
||||
4;76;77;78;79;,
|
||||
4;80;81;82;83;,
|
||||
4;84;85;86;87;;
|
||||
} //End of Cube_003 Normals
|
||||
MeshMaterialList { //Cube_003 Material List
|
||||
1;
|
||||
22;
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0;;
|
||||
Material Material {
|
||||
0.640000; 0.640000; 0.640000; 1.000000;;
|
||||
96.078431;
|
||||
0.500000; 0.500000; 0.500000;;
|
||||
0.000000; 0.000000; 0.000000;;
|
||||
}
|
||||
} //End of Cube_003 Material List
|
||||
MeshTextureCoords { //Cube_003 UV Coordinates
|
||||
88;
|
||||
0.973358; 0.999965;,
|
||||
0.975236; 0.387889;,
|
||||
0.986704; 0.387924;,
|
||||
0.984826; 1.000000;,
|
||||
0.706578; 0.081368;,
|
||||
0.706614; 0.092836;,
|
||||
0.695086; 0.092871;,
|
||||
0.695051; 0.081403;,
|
||||
0.593305; 0.387924;,
|
||||
0.680706; 0.387656;,
|
||||
0.682584; 0.999732;,
|
||||
0.595183; 1.000000;,
|
||||
0.794015; 0.092568;,
|
||||
0.706614; 0.092836;,
|
||||
0.706578; 0.081368;,
|
||||
0.793980; 0.081100;,
|
||||
0.882261; 1.000000;,
|
||||
0.794859; 0.999732;,
|
||||
0.796737; 0.387656;,
|
||||
0.884139; 0.387924;,
|
||||
0.806422; 0.375920;,
|
||||
0.893824; 0.376188;,
|
||||
0.893789; 0.387656;,
|
||||
0.806387; 0.387388;,
|
||||
0.000000; 0.387924;,
|
||||
0.011468; 0.387889;,
|
||||
0.013346; 0.999965;,
|
||||
0.001878; 1.000000;,
|
||||
0.795764; 0.092553;,
|
||||
0.807291; 0.092589;,
|
||||
0.806422; 0.375920;,
|
||||
0.794894; 0.375885;,
|
||||
0.682584; 0.999732;,
|
||||
0.680706; 0.387656;,
|
||||
0.692234; 0.387621;,
|
||||
0.694112; 0.999696;,
|
||||
0.794859; 0.387353;,
|
||||
0.794894; 0.375885;,
|
||||
0.806422; 0.375920;,
|
||||
0.806387; 0.387388;,
|
||||
0.306218; 0.386985;,
|
||||
0.308096; 0.999061;,
|
||||
0.296677; 0.999096;,
|
||||
0.294799; 0.387020;,
|
||||
0.593305; 0.387924;,
|
||||
0.591427; 1.000000;,
|
||||
0.308096; 0.999131;,
|
||||
0.309974; 0.387055;,
|
||||
0.294799; 0.387020;,
|
||||
0.296677; 0.999096;,
|
||||
0.013346; 0.999965;,
|
||||
0.011468; 0.387889;,
|
||||
0.695086; 0.092871;,
|
||||
0.706614; 0.092836;,
|
||||
0.707483; 0.376167;,
|
||||
0.695955; 0.376202;,
|
||||
0.707518; 0.387656;,
|
||||
0.705640; 0.999732;,
|
||||
0.694112; 0.999697;,
|
||||
0.695990; 0.387621;,
|
||||
0.695955; 0.376202;,
|
||||
0.707483; 0.376167;,
|
||||
0.707518; 0.387586;,
|
||||
0.695990; 0.387621;,
|
||||
0.795799; 0.081135;,
|
||||
0.807326; 0.081170;,
|
||||
0.807291; 0.092589;,
|
||||
0.795764; 0.092553;,
|
||||
0.807291; 0.092589;,
|
||||
0.807326; 0.081170;,
|
||||
0.894668; 0.081438;,
|
||||
0.894633; 0.092856;,
|
||||
0.988581; 1.000000;,
|
||||
0.986704; 0.387924;,
|
||||
0.998122; 0.387889;,
|
||||
1.000000; 0.999965;,
|
||||
0.794859; 0.387924;,
|
||||
0.792981; 1.000000;,
|
||||
0.705640; 0.999732;,
|
||||
0.707518; 0.387656;,
|
||||
0.707518; 0.387586;,
|
||||
0.707483; 0.376167;,
|
||||
0.794824; 0.375899;,
|
||||
0.794859; 0.387318;,
|
||||
0.884138; 0.999732;,
|
||||
0.886016; 0.387656;,
|
||||
0.973358; 0.387924;,
|
||||
0.971480; 1.000000;;
|
||||
} //End of Cube_003 UV Coordinates
|
||||
} //End of Cube_003 Mesh
|
||||
} //End of Cube_001
|
||||
} //End of Root Frame
|
||||
BIN
mods/snow/other_textures/connected_textures_ice.png
Normal file
BIN
mods/snow/other_textures/connected_textures_ice.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 656 B |
BIN
mods/snow/other_textures/default_ice.png
Normal file
BIN
mods/snow/other_textures/default_ice.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 82 B |
BIN
mods/snow/other_textures/default_ice.xcf
Normal file
BIN
mods/snow/other_textures/default_ice.xcf
Normal file
Binary file not shown.
67
mods/snow/other_textures/inkscape_default_ice.svg
Normal file
67
mods/snow/other_textures/inkscape_default_ice.svg
Normal file
@ -0,0 +1,67 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<!-- Created with Inkscape (http://www.inkscape.org/) -->
|
||||
|
||||
<svg
|
||||
xmlns:dc="http://purl.org/dc/elements/1.1/"
|
||||
xmlns:cc="http://creativecommons.org/ns#"
|
||||
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
||||
xmlns:svg="http://www.w3.org/2000/svg"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
width="16"
|
||||
height="16"
|
||||
id="svg2"
|
||||
version="1.1"
|
||||
inkscape:version="0.48.4 r9939"
|
||||
sodipodi:docname="inkscape_default_ice.svg">
|
||||
<defs
|
||||
id="defs4" />
|
||||
<sodipodi:namedview
|
||||
id="base"
|
||||
pagecolor="#ffffff"
|
||||
bordercolor="#666666"
|
||||
borderopacity="1.0"
|
||||
inkscape:pageopacity="0.0"
|
||||
inkscape:pageshadow="2"
|
||||
inkscape:zoom="45.4375"
|
||||
inkscape:cx="6.8335626"
|
||||
inkscape:cy="8"
|
||||
inkscape:document-units="px"
|
||||
inkscape:current-layer="layer1"
|
||||
showgrid="false"
|
||||
inkscape:showpageshadow="false"
|
||||
inkscape:window-width="1328"
|
||||
inkscape:window-height="895"
|
||||
inkscape:window-x="197"
|
||||
inkscape:window-y="70"
|
||||
inkscape:window-maximized="0" />
|
||||
<metadata
|
||||
id="metadata7">
|
||||
<rdf:RDF>
|
||||
<cc:Work
|
||||
rdf:about="">
|
||||
<dc:format>image/svg+xml</dc:format>
|
||||
<dc:type
|
||||
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
|
||||
<dc:title></dc:title>
|
||||
</cc:Work>
|
||||
</rdf:RDF>
|
||||
</metadata>
|
||||
<g
|
||||
inkscape:label="Layer 1"
|
||||
inkscape:groupmode="layer"
|
||||
id="layer1"
|
||||
transform="translate(0,-1036.3622)">
|
||||
<rect
|
||||
style="fill:#91d2ff;fill-rule:evenodd;stroke:none;fill-opacity:1;opacity:0.90000000000000002"
|
||||
id="rect2985"
|
||||
width="16"
|
||||
height="16"
|
||||
x="0"
|
||||
y="1036.3622"
|
||||
inkscape:export-xdpi="90"
|
||||
inkscape:export-ydpi="90"
|
||||
inkscape:export-filename="/home/trickpaint/Minetest/Minetest_game_stuff/049_modtest/worlds/developing_snow_overhaul/worldmods/snow_developing/snow/textures/default_ice.png" />
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 2.0 KiB |
BIN
mods/snow/other_textures/mocha.png
Normal file
BIN
mods/snow/other_textures/mocha.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 83 B |
BIN
mods/snow/other_textures/mocha.xcf
Normal file
BIN
mods/snow/other_textures/mocha.xcf
Normal file
Binary file not shown.
BIN
mods/snow/other_textures/original_snow_snow_brick.png
Normal file
BIN
mods/snow/other_textures/original_snow_snow_brick.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 300 B |
BIN
mods/snow/other_textures/rect2985.png
Normal file
BIN
mods/snow/other_textures/rect2985.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 81 B |
BIN
mods/snow/other_textures/snow_ice.png
Normal file
BIN
mods/snow/other_textures/snow_ice.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 371 B |
BIN
mods/snow/other_textures/snow_needles_decorated_animated.xcf
Normal file
BIN
mods/snow/other_textures/snow_needles_decorated_animated.xcf
Normal file
Binary file not shown.
BIN
mods/snow/other_textures/snow_snow.png
Normal file
BIN
mods/snow/other_textures/snow_snow.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 164 B |
BIN
mods/snow/other_textures/snow_snow_brick.xcf
Normal file
BIN
mods/snow/other_textures/snow_snow_brick.xcf
Normal file
Binary file not shown.
BIN
mods/snow/other_textures/snow_snow_brick_lazyJ.png
Normal file
BIN
mods/snow/other_textures/snow_snow_brick_lazyJ.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 518 B |
BIN
mods/snow/other_textures/snow_snow_cobble.png_01
Normal file
BIN
mods/snow/other_textures/snow_snow_cobble.png_01
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 788 B |
BIN
mods/snow/other_textures/snow_snow_cobble.xcf
Normal file
BIN
mods/snow/other_textures/snow_snow_cobble.xcf
Normal file
Binary file not shown.
BIN
mods/snow/other_textures/snow_snow_side.png
Normal file
BIN
mods/snow/other_textures/snow_snow_side.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 726 B |
BIN
mods/snow/other_textures/snow_snowball.png
Normal file
BIN
mods/snow/other_textures/snow_snowball.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 127 B |
BIN
mods/snow/other_textures/snow_snowfall.png
Normal file
BIN
mods/snow/other_textures/snow_snowfall.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 190 B |
BIN
mods/snow/other_textures/snow_star_lit.xcf
Normal file
BIN
mods/snow/other_textures/snow_star_lit.xcf
Normal file
Binary file not shown.
BIN
mods/snow/other_textures/xdefault_cobble.png
Normal file
BIN
mods/snow/other_textures/xdefault_cobble.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 297 B |
BIN
mods/snow/other_textures/xdefault_furnace_bottom.png
Normal file
BIN
mods/snow/other_textures/xdefault_furnace_bottom.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 602 B |
BIN
mods/snow/other_textures/xdefault_furnace_fire_bg.png
Normal file
BIN
mods/snow/other_textures/xdefault_furnace_fire_bg.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 204 B |
BIN
mods/snow/other_textures/xdefault_furnace_fire_fg.png
Normal file
BIN
mods/snow/other_textures/xdefault_furnace_fire_fg.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 719 B |
BIN
mods/snow/other_textures/xdefault_furnace_front.png
Normal file
BIN
mods/snow/other_textures/xdefault_furnace_front.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 553 B |
BIN
mods/snow/other_textures/xdefault_furnace_front_active.png
Normal file
BIN
mods/snow/other_textures/xdefault_furnace_front_active.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 4.2 KiB |
BIN
mods/snow/other_textures/xdefault_furnace_side.png
Normal file
BIN
mods/snow/other_textures/xdefault_furnace_side.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 602 B |
BIN
mods/snow/other_textures/xdefault_furnace_top.png
Normal file
BIN
mods/snow/other_textures/xdefault_furnace_top.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 602 B |
BIN
mods/snow/other_textures/xdefault_glass.png
Normal file
BIN
mods/snow/other_textures/xdefault_glass.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 204 B |
BIN
mods/snow/other_textures/xdefault_ice.png
Normal file
BIN
mods/snow/other_textures/xdefault_ice.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 371 B |
BIN
mods/snow/other_textures/xdefault_ice.xcf
Normal file
BIN
mods/snow/other_textures/xdefault_ice.xcf
Normal file
Binary file not shown.
BIN
mods/snow/other_textures/xdefault_snow.png
Normal file
BIN
mods/snow/other_textures/xdefault_snow.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 164 B |
BIN
mods/snow/other_textures/xdefault_stone_brick.png
Normal file
BIN
mods/snow/other_textures/xdefault_stone_brick.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 572 B |
@ -4,18 +4,49 @@
|
||||
\___ \| '_ \ / _ \ \ /\ / / | |\/| |/ _ \ / _` |
|
||||
____) | | | | (_) \ V V / | | | | (_) | (_| |
|
||||
|_____/|_| |_|\___/ \_/\_/ |_| |_|\___/ \__,_|
|
||||
|
||||
By Splizard, bob and cornernote.
|
||||
|
||||
Version 3.2
|
||||
|
||||
By Splizard and LazyJ.
|
||||
|
||||
Minetest version: 0.4.9
|
||||
Depends: default
|
||||
License: GPL v2
|
||||
|
||||
Complimentary Mods:
|
||||
---------------------
|
||||
* "Snowdrift" by paramat
|
||||
* "More Blocks" by Calinou (2014_05_11 or newer)
|
||||
* "Skins" by Zeg9
|
||||
|
||||
|
||||
Install:
|
||||
|
||||
Forum post: http://minetest.net/forum/viewtopic.php?id=2290
|
||||
Github: https://github.com/Splizard/minetest-mod-snow
|
||||
Website: http://splizard.com/minetest/mods/snow/
|
||||
|
||||
INSTALL:
|
||||
----------
|
||||
Place this folder in your minetest mods folder.
|
||||
(http://dev.minetest.net/Installing_Mods)
|
||||
|
||||
* After downloading, unzip the file.
|
||||
* Rename the directory "minetest-mod-snow-master" to "snow"
|
||||
* Copy the "snow" directory into either
|
||||
../minetest/worlds/yourworld'sname/worldmods/
|
||||
or
|
||||
../minetest/mods/
|
||||
* If you put "snow" in the ../minetest/mods/ directory, either
|
||||
enable the mod from within Minetest's "Configure" button
|
||||
(main menu, bottom right) or by adding this line to the
|
||||
world's "world.mt" file:
|
||||
load_mod_snow = true
|
||||
|
||||
|
||||
|
||||
NOTICE
|
||||
While this mod is installed you may experience slow map loading while a snow biome is generated.
|
||||
While this mod is installed you may experience slower map loading while a snow biome is generated.
|
||||
|
||||
USAGE:
|
||||
-------
|
||||
@ -32,58 +63,41 @@ There are nine biome types:
|
||||
* Snowy
|
||||
* Plain
|
||||
|
||||
Snow can be picked up and thrown as snowballs or crafted into snow blocks.
|
||||
Snow can be picked up and thrown as snowballs or stacked into snow blocks.
|
||||
Snow and ice melts when near warm blocks such as torches or igniters such as lava.
|
||||
Snow blocks freeze water source blocks around them.
|
||||
Moss can be found in the snow, when moss is placed near cobble it spreads.
|
||||
Christmas trees can be found when digging pine needles.
|
||||
Sleds allow for faster travel on snow.
|
||||
|
||||
CRAFTING:
|
||||
-----------
|
||||
Snow Block:
|
||||
|
||||
Snowball Snowball
|
||||
Snowball Snowball
|
||||
|
||||
Snow Brick:
|
||||
|
||||
Snow Block Snow Block
|
||||
Snow Block Snow Block
|
||||
|
||||
Sled:
|
||||
Stick
|
||||
Wood Wood Wood
|
||||
|
||||
Icy Snow:
|
||||
|
||||
Snow Ice
|
||||
Ice Snow
|
||||
|
||||
MAPGEN_V7:
|
||||
------------
|
||||
If you are using minetest 0.4.8 or the latest dev version of minetest you can choose to generate a v7 map.
|
||||
This option can be found when creating a new map from the menu.
|
||||
Snow Biomes has support for this though you might need a couple other biomes too otherwise you will only spawn snow.
|
||||
There are a couple of bugs and limitations with this such as no ice being generated at the moment.
|
||||
|
||||
Config file:
|
||||
------------
|
||||
After starting a game in minetest with snow mod, a config file will be placed in this folder that contains the various options for snow mod.
|
||||
As admin you can use the /snow command in-game to make various changes.
|
||||
|
||||
UNINSTALL:
|
||||
------------
|
||||
Simply delete the folder snow from the mods folder.
|
||||
|
||||
CHANGELOG:
|
||||
------------
|
||||
Version 1.4
|
||||
|
||||
New biomes, snowy and plain
|
||||
|
||||
Christmas Trees
|
||||
|
||||
Snowfall
|
||||
|
||||
Version 1.3
|
||||
|
||||
Smooth transitions
|
||||
|
||||
Snow Bricks
|
||||
|
||||
Version 1.2
|
||||
|
||||
Pine trees
|
||||
|
||||
Moss
|
||||
|
||||
Alpine biomes
|
||||
|
||||
Dry shrubs
|
||||
|
||||
Version 1.1
|
||||
|
||||
Better mapgen
|
||||
|
||||
Version 1.0
|
||||
|
||||
Initial release
|
||||
|
||||
BIN
mods/snow/schematics/pine.mts
Normal file
BIN
mods/snow/schematics/pine.mts
Normal file
Binary file not shown.
204
mods/snow/src/abms.lua
Normal file
204
mods/snow/src/abms.lua
Normal file
@ -0,0 +1,204 @@
|
||||
--Backwards Compatability.
|
||||
minetest.register_abm({
|
||||
nodenames = {"snow:snow1","snow:snow2","snow:snow3","gsnow4","snow:snow5","snow:snow6","snow:snow7","snow:snow8"},
|
||||
interval = 1,
|
||||
chance = 1,
|
||||
action = function(pos, node)
|
||||
minetest.add_node(pos,{name="default:snow"})
|
||||
minetest.set_node_level(pos, 7*(tonumber(node.name:sub(-1))))
|
||||
end,
|
||||
})
|
||||
|
||||
|
||||
|
||||
-- Added to change dirt_with_snow to dirt if covered with blocks that don't let light through (sunlight_propagates) or have a light paramtype and liquidtype combination. ~ LazyJ, 2014_03_08
|
||||
|
||||
minetest.register_abm({
|
||||
nodenames = {"default:dirt_with_snow"},
|
||||
interval = 2,
|
||||
chance = 20,
|
||||
action = function(pos, node)
|
||||
local name = minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name
|
||||
local nodedef = minetest.registered_nodes[name]
|
||||
if name ~= "ignore"
|
||||
and nodedef
|
||||
and not (
|
||||
(nodedef.sunlight_propagates or nodedef.paramtype == "light")
|
||||
and nodedef.liquidtype == "none"
|
||||
) then
|
||||
minetest.set_node(pos, {name = "default:dirt"})
|
||||
end
|
||||
end
|
||||
})
|
||||
|
||||
|
||||
|
||||
--Melting
|
||||
--Any node part of the group melting will melt when near warm nodes such as lava, fire, torches, etc.
|
||||
--The amount of water that replaces the node is defined by the number on the group:
|
||||
--1: one water_source
|
||||
--2: four water_flowings
|
||||
--3: one water_flowing
|
||||
|
||||
minetest.register_abm({
|
||||
nodenames = {"group:melts"},
|
||||
neighbors = {"group:igniter","default:torch","default:furnace_active","group:hot"},
|
||||
interval = 2,
|
||||
chance = 2,
|
||||
action = function(pos, node)
|
||||
local intensity = minetest.get_item_group(node.name,"melts")
|
||||
if intensity == 1 then
|
||||
minetest.add_node(pos,{name="default:water_source"})
|
||||
elseif intensity == 2 then
|
||||
minetest.add_node(pos,{name="default:water_flowing", param2=7})
|
||||
--[[ LazyJ, you need to add param2, which defines the amount of the flowing water ~ HybridDog 2015_03_06
|
||||
This was causing "melts=2" nodes to just disappear so I changed it to replace the
|
||||
node with a water_source for a couple seconds and then replace the water_source with
|
||||
air. This way it made a watery mess that quickly evaporated. ~ LazyJ 2014_04_24
|
||||
local check_place = function(pos,node)
|
||||
if minetest.get_node(pos).name == "air" then
|
||||
minetest.place_node(pos,node)
|
||||
end
|
||||
end
|
||||
minetest.add_node(pos,{name="default:water_flowing"})
|
||||
check_place({x=pos.x+1,y=pos.y,z=pos.z},{name="default:water_flowing"})
|
||||
check_place({x=pos.x-1,y=pos.y,z=pos.z},{name="default:water_flowing"})
|
||||
check_place({x=pos.x,y=pos.y+1,z=pos.z},{name="default:water_flowing"})
|
||||
check_place({x=pos.x,y=pos.y-1,z=pos.z},{name="default:water_flowing"})
|
||||
elseif intensity == 3 then
|
||||
--]
|
||||
minetest.add_node(pos,{name="default:water_source"})
|
||||
minetest.after(2, function() -- 2 seconds gives just enough time for
|
||||
-- the water to flow and spread before the
|
||||
-- water_source is changed to air. ~ LazyJ
|
||||
if minetest.get_node(pos).name == "default:water_source" then
|
||||
minetest.add_node(pos,{name="air"})
|
||||
end
|
||||
end)
|
||||
--]]
|
||||
end
|
||||
nodeupdate(pos)
|
||||
end,
|
||||
})
|
||||
|
||||
|
||||
|
||||
|
||||
--Freezing
|
||||
--Water freezes when in contact with snow.
|
||||
minetest.register_abm({
|
||||
nodenames = {"default:water_source"},
|
||||
-- Added "group:icemaker" and snowbrick. ~ LazyJ
|
||||
neighbors = {"default:snow", "default:snowblock", "snow:snow_brick", "group:icemaker"},
|
||||
interval = 20,
|
||||
chance = 4,
|
||||
action = function(pos)
|
||||
minetest.add_node(pos,{name="default:ice"})
|
||||
end,
|
||||
})
|
||||
|
||||
--Freeze Ice according to it's param2 value.
|
||||
minetest.register_abm({
|
||||
nodenames = {"default:ice"},
|
||||
neighbors = {"default:water_source"},
|
||||
interval = 20,
|
||||
chance = 4,
|
||||
action = function(pos, node)
|
||||
if node.param2 > 0 then
|
||||
for l = 0,1 do
|
||||
for i = -1,1,2 do
|
||||
for _,p in pairs({
|
||||
{x=pos.x+i, z=pos.z-l*i},
|
||||
{x=pos.x+l*i, z=pos.z+i}
|
||||
}) do
|
||||
if math.random(2) == 2 then
|
||||
p.y = pos.y
|
||||
if minetest.get_node(p).name == "default:water_source" then
|
||||
minetest.add_node(p,{name="default:ice", param2 = math.random(0,node.param2-1)})
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
if math.random(8) == 8 then
|
||||
minetest.add_node(pos, {name="default:water_source"})
|
||||
else
|
||||
minetest.add_node(pos, {name="default:ice", param2 = 0})
|
||||
end
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
|
||||
|
||||
--Spread moss to cobble.
|
||||
minetest.register_abm({
|
||||
nodenames = {"default:cobble"},
|
||||
neighbors = {"snow:moss"},
|
||||
interval = 20,
|
||||
chance = 6,
|
||||
action = function(pos, node)
|
||||
node.name = "default:mossycobble"
|
||||
minetest.add_node(pos, node)
|
||||
end,
|
||||
})
|
||||
|
||||
|
||||
|
||||
|
||||
--Grow Pine Saplings
|
||||
minetest.register_abm({
|
||||
nodenames = {"snow:sapling_pine"},
|
||||
interval = 10,
|
||||
chance = 50,
|
||||
action = function(pos, node)
|
||||
|
||||
-- Check if there is enough vertical-space for the sapling to grow without
|
||||
-- hitting anything else. ~ LazyJ, 2014_04_10
|
||||
|
||||
-- 'If' there is air in each of the 8 nodes dirctly above the sapling,... ~LazyJ
|
||||
for i = 1,8 do
|
||||
if minetest.get_node({x=pos.x, y=pos.y+i, z=pos.z}).name ~= "air" then
|
||||
return
|
||||
end
|
||||
end
|
||||
-- 'then' let the sapling grow into a tree. ~ LazyJ
|
||||
|
||||
snow.make_pine(pos,false)
|
||||
-- This finds the sapling under the grown tree. ~ LazyJ
|
||||
if minetest.get_node(pos).name == "snow:sapling_pine" then
|
||||
-- This switches the sapling to a tree trunk. ~ LazyJ
|
||||
minetest.set_node(pos, {name="default:pinetree"})
|
||||
-- This is more for testing but it may be useful info to some admins when
|
||||
-- grepping the server logs too. ~ LazyJ
|
||||
minetest.log("action", "A pine sapling grows into a tree at "..minetest.pos_to_string(pos))
|
||||
end
|
||||
end
|
||||
})
|
||||
|
||||
|
||||
|
||||
|
||||
--Grow Christmas Tree Saplings
|
||||
minetest.register_abm({
|
||||
nodenames = {"snow:xmas_tree"},
|
||||
interval = 10,
|
||||
chance = 50,
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
|
||||
-- 'If' there is air in each of the 8 nodes dirctly above the sapling,... ~LazyJ
|
||||
for i = 1,8 do
|
||||
if minetest.get_node({x=pos.x, y=pos.y+i, z=pos.z}).name ~= "air" then
|
||||
return
|
||||
end
|
||||
end
|
||||
-- 'then' let the sapling grow into a tree. ~ LazyJ
|
||||
|
||||
snow.make_pine(pos,false,true)
|
||||
minetest.log("action", "A pine sapling grows into a Christmas tree at "..minetest.pos_to_string(pos)) -- ~ LazyJ
|
||||
--else -- 'Else', if there isn't air in each of the 8 nodes above the sapling,
|
||||
-- then don't anything; including not allowing the sapling to grow.
|
||||
-- ~ LazyJ, 2014_04_10
|
||||
--end
|
||||
end
|
||||
})
|
||||
104
mods/snow/src/aliases.lua
Normal file
104
mods/snow/src/aliases.lua
Normal file
@ -0,0 +1,104 @@
|
||||
-- Some aliases for compatibility switches and some to make "/give" commands
|
||||
-- a little easier
|
||||
|
||||
minetest.register_alias("snow:snow", "default:snow")
|
||||
minetest.register_alias("default_snow", "default:snow")
|
||||
minetest.register_alias("snow:snowball", "default:snow")
|
||||
minetest.register_alias("snowball", "default:snow")
|
||||
minetest.register_alias("snowballs", "default:snow")
|
||||
minetest.register_alias("snow_ball", "default:snow")
|
||||
minetest.register_alias("snow:ice", "default:ice")
|
||||
minetest.register_alias("ice", "default:ice")
|
||||
minetest.register_alias("default_ice", "default:ice")
|
||||
minetest.register_alias("snow:dirt_with_snow", "default:dirt_with_snow")
|
||||
minetest.register_alias("dirtwithsnow", "default:dirt_with_snow")
|
||||
minetest.register_alias("snowdirt", "default:dirt_with_snow")
|
||||
minetest.register_alias("snowydirt", "default:dirt_with_snow")
|
||||
minetest.register_alias("snow:snow_block", "default:snowblock")
|
||||
minetest.register_alias("default:snow_block", "default:snowblock")
|
||||
minetest.register_alias("snowblocks", "default:snowblock")
|
||||
minetest.register_alias("snowbrick", "snow:snow_brick")
|
||||
minetest.register_alias("bricksnow", "snow:snow_brick")
|
||||
minetest.register_alias("snowbricks", "snow:snow_brick")
|
||||
minetest.register_alias("snowybricks", "snow:snow_brick")
|
||||
minetest.register_alias("icysnow", "snow:snow_cobble")
|
||||
minetest.register_alias("snowcobble", "snow:snow_cobble")
|
||||
minetest.register_alias("snowycobble", "snow:snow_cobble")
|
||||
minetest.register_alias("cobblesnow", "snow:snow_cobble")
|
||||
|
||||
|
||||
-- To clean up my first stairsplus attempt.
|
||||
-- Stair
|
||||
minetest.register_alias(":default:stair_snowblock", "moreblocks:stair_snowblock")
|
||||
minetest.register_alias(":default:stair_snowblock_half", "moreblocks:stair_snowblock_half")
|
||||
minetest.register_alias(":default:stair_snowblock_right_half", "moreblocks:stair_snowblock_right_half")
|
||||
minetest.register_alias(":default:stair_snowblock_inner", "moreblocks:stair_snowblock_inner")
|
||||
minetest.register_alias(":default:stair_snowblock_outer", "moreblocks:stair_snowblock_outer")
|
||||
minetest.register_alias(":default:stair_snowblock_alt", "moreblocks:stair_snowblock_alt")
|
||||
minetest.register_alias(":default:stair_snowblock_alt_1", "moreblocks:stair_snowblock_alt_1")
|
||||
minetest.register_alias(":default:stair_snowblock_alt_2", "moreblocks:stair_snowblock_2")
|
||||
minetest.register_alias(":default:stair_snowblock_alt_4", "moreblocks:stair_snowblock_alt_4")
|
||||
|
||||
minetest.register_alias(":default:stair_ice", "moreblocks:stair_ice")
|
||||
minetest.register_alias(":default:stair_ice_half", "moreblocks:stair_ice_half")
|
||||
minetest.register_alias(":default:stair_ice_right_half", "moreblocks:stair_ice_right_half")
|
||||
minetest.register_alias(":default:stair_ice_inner", "moreblocks:stair_ice_inner")
|
||||
minetest.register_alias(":default:stair_ice_outer", "moreblocks:stair_ice_outer")
|
||||
minetest.register_alias(":default:stair_ice_alt", "moreblocks:stair_ice_alt")
|
||||
minetest.register_alias(":default:stair_ice_alt_1", "moreblocks:stair_ice_alt_1")
|
||||
minetest.register_alias(":default:stair_ice_alt_2", "moreblocks:stair_ice_2")
|
||||
minetest.register_alias(":default:stair_ice_alt_4", "moreblocks:stair_ice_alt_4")
|
||||
|
||||
|
||||
-- Slab
|
||||
minetest.register_alias(":default:slab_snowblock", "moreblocks:slab_snowblock")
|
||||
minetest.register_alias(":default:slab_snowblock_quarter", "moreblocks:slab_snowblock_quarter")
|
||||
minetest.register_alias(":default:slab_snowblock_three_quarter", "moreblocks:slab_snowblock_three_quarter")
|
||||
minetest.register_alias(":default:slab_snowblock_1", "moreblocks:slab_snowblock_1")
|
||||
minetest.register_alias(":default:slab_snowblock_2", "moreblocks:slab_snowblock_2")
|
||||
minetest.register_alias(":default:slab_snowblock_14", "moreblocks:slab_snowblock_14")
|
||||
minetest.register_alias(":default:slab_snowblock_15", "moreblocks:slab_snowblock_15")
|
||||
|
||||
minetest.register_alias(":default:slab_ice", "moreblocks:slab_ice")
|
||||
minetest.register_alias(":default:slab_ice_quarter", "moreblocks:slab_ice_quarter")
|
||||
minetest.register_alias(":default:slab_ice_three_quarter", "moreblocks:slab_ice_three_quarter")
|
||||
minetest.register_alias(":default:slab_ice_1", "moreblocks:slab_ice_1")
|
||||
minetest.register_alias(":default:slab_ice_2", "moreblocks:slab_ice_2")
|
||||
minetest.register_alias(":default:slab_ice_14", "moreblocks:slab_ice_14")
|
||||
minetest.register_alias(":default:slab_ice_15", "moreblocks:slab_ice_15")
|
||||
|
||||
|
||||
-- Panel
|
||||
minetest.register_alias(":default:panel_snowblock", "moreblocks:panel_snowblock")
|
||||
minetest.register_alias(":default:panel_snowblock_1", "moreblocks:panel_snowblock_1")
|
||||
minetest.register_alias(":default:panel_snowblock_2", "moreblocks:panel_snowblock_2")
|
||||
minetest.register_alias(":default:panel_snowblock_4", "moreblocks:panel_snowblock_4")
|
||||
minetest.register_alias(":default:panel_snowblock_12", "moreblocks:panel_snowblock_12")
|
||||
minetest.register_alias(":default:panel_snowblock_14", "moreblocks:panel_snowblock_14")
|
||||
minetest.register_alias(":default:panel_snowblock_15", "moreblocks:panel_snowblock_15")
|
||||
|
||||
minetest.register_alias(":default:panel_ice", "moreblocks:panel_ice")
|
||||
minetest.register_alias(":default:panel_ice_1", "moreblocks:panel_ice_1")
|
||||
minetest.register_alias(":default:panel_ice_2", "moreblocks:panel_ice_2")
|
||||
minetest.register_alias(":default:panel_ice_4", "moreblocks:panel_ice_4")
|
||||
minetest.register_alias(":default:panel_ice_12", "moreblocks:panel_ice_12")
|
||||
minetest.register_alias(":default:panel_ice_14", "moreblocks:panel_ice_14")
|
||||
minetest.register_alias(":default:panel_ice_15", "moreblocks:panel_ice_15")
|
||||
|
||||
|
||||
-- Micro
|
||||
minetest.register_alias(":default:micro_snowblock", "moreblocks:micro_snowblock")
|
||||
minetest.register_alias(":default:micro_snowblock_1", "moreblocks:micro_snowblock_1")
|
||||
minetest.register_alias(":default:micro_snowblock_2", "moreblocks:micro_snowblock_2")
|
||||
minetest.register_alias(":default:micro_snowblock_4", "moreblocks:micro_snowblock_4")
|
||||
minetest.register_alias(":default:micro_snowblock_12", "moreblocks:micro_snowblock_12")
|
||||
minetest.register_alias(":default:micro_snowblock_14", "moreblocks:micro_snowblock_14")
|
||||
minetest.register_alias(":default:micro_snowblock_15", "moreblocks:micro_snowblock_15")
|
||||
|
||||
minetest.register_alias(":default:micro_ice", "moreblocks:micro_ice")
|
||||
minetest.register_alias(":default:micro_ice_1", "moreblocks:micro_ice_1")
|
||||
minetest.register_alias(":default:micro_ice_2", "moreblocks:micro_ice_2")
|
||||
minetest.register_alias(":default:micro_ice_4", "moreblocks:micro_ice_4")
|
||||
minetest.register_alias(":default:micro_ice_12", "moreblocks:micro_ice_12")
|
||||
minetest.register_alias(":default:micro_ice_14", "moreblocks:micro_ice_14")
|
||||
minetest.register_alias(":default:micro_ice_15", "moreblocks:micro_ice_15")
|
||||
326
mods/snow/src/basic_stairs_slabs.lua
Normal file
326
mods/snow/src/basic_stairs_slabs.lua
Normal file
@ -0,0 +1,326 @@
|
||||
-- Based on
|
||||
-- Minetest 0.4 mod: stairs
|
||||
-- See README.txt for licensing and other information.
|
||||
|
||||
|
||||
-- ADD CHECK FOR MOREBLOCKS/SKIP IF NOT FOUND CODE STUFF HERE
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
snow_stairs = {} -- This is a little trick. Without it Minetest will complain
|
||||
-- "attempt to index global 'snow' (a nil value)" and
|
||||
-- refuse to load. So a value without definition "={}"is assigned to snow.
|
||||
|
||||
-- Node will be called snow:stair_<subname>
|
||||
function snow_stairs.register_stair(subname, recipeitem, groups, images, description, sounds)
|
||||
minetest.register_node("snow:stair_" .. subname, {
|
||||
description = description,
|
||||
drawtype = "nodebox",
|
||||
tiles = images,
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
is_ground_content = true,
|
||||
groups = groups,
|
||||
sounds = default.node_sound_dirt_defaults({
|
||||
footstep = {name="default_snow_footstep", gain=0.25},
|
||||
dig = {name="default_dig_crumbly", gain=0.4},
|
||||
dug = {name="default_snow_footstep", gain=0.75},
|
||||
place = {name="default_place_node", gain=1.0}
|
||||
}),
|
||||
node_box = {
|
||||
type = "fixed",
|
||||
fixed = {
|
||||
{-0.5, -0.5, -0.5, 0.5, 0, 0.5},
|
||||
{-0.5, 0, 0, 0.5, 0.5, 0.5},
|
||||
},
|
||||
},
|
||||
on_place = function(itemstack, placer, pointed_thing)
|
||||
if pointed_thing.type ~= "node" then
|
||||
return itemstack
|
||||
end
|
||||
|
||||
local p0 = pointed_thing.under
|
||||
local p1 = pointed_thing.above
|
||||
local param2 = 0
|
||||
|
||||
local placer_pos = placer:getpos()
|
||||
if placer_pos then
|
||||
local dir = {
|
||||
x = p1.x - placer_pos.x,
|
||||
y = p1.y - placer_pos.y,
|
||||
z = p1.z - placer_pos.z
|
||||
}
|
||||
param2 = minetest.dir_to_facedir(dir)
|
||||
end
|
||||
|
||||
if p0.y-1 == p1.y then
|
||||
param2 = param2 + 20
|
||||
if param2 == 21 then
|
||||
param2 = 23
|
||||
elseif param2 == 23 then
|
||||
param2 = 21
|
||||
end
|
||||
end
|
||||
|
||||
return minetest.item_place(itemstack, placer, pointed_thing, param2)
|
||||
end,
|
||||
|
||||
on_construct = function(pos)
|
||||
pos.y = pos.y - 1
|
||||
if minetest.get_node(pos).name == "default:dirt_with_grass"
|
||||
-- Thinking in terms of layers, dirt_with_snow could also double as
|
||||
-- dirt_with_frost which adds subtlety to the winterscape. ~ LazyJ, 2014_04_04
|
||||
or minetest.get_node(pos).name == "default:dirt" then
|
||||
minetest.set_node(pos, {name="default:dirt_with_snow"})
|
||||
end
|
||||
end
|
||||
})
|
||||
--[[
|
||||
-- for replace ABM
|
||||
minetest.register_node("snow:stair_" .. subname.."upside_down", {
|
||||
replace_name = "snow:stair_" .. subname,
|
||||
groups = {slabs_replace=1},
|
||||
})
|
||||
--]]
|
||||
minetest.register_craft({
|
||||
output = 'snow:stair_' .. subname .. ' 6',
|
||||
recipe = {
|
||||
{recipeitem, "", ""},
|
||||
{recipeitem, recipeitem, ""},
|
||||
{recipeitem, recipeitem, recipeitem},
|
||||
},
|
||||
})
|
||||
|
||||
-- Flipped recipe
|
||||
minetest.register_craft({
|
||||
output = 'snow:stair_' .. subname .. ' 6',
|
||||
recipe = {
|
||||
{"", "", recipeitem},
|
||||
{"", recipeitem, recipeitem},
|
||||
{recipeitem, recipeitem, recipeitem},
|
||||
},
|
||||
})
|
||||
end
|
||||
|
||||
-- Node will be called snow:slab_<subname>
|
||||
function snow_stairs.register_slab(subname, recipeitem, groups, images, description, sounds)
|
||||
minetest.register_node("snow:slab_" .. subname, {
|
||||
description = description,
|
||||
drawtype = "nodebox",
|
||||
tiles = images,
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
is_ground_content = true,
|
||||
groups = groups,
|
||||
sounds = default.node_sound_dirt_defaults({
|
||||
footstep = {name="default_snow_footstep", gain=0.25},
|
||||
dig = {name="default_dig_crumbly", gain=0.4},
|
||||
dug = {name="default_snow_footstep", gain=0.75},
|
||||
place = {name="default_place_node", gain=1.0}
|
||||
}),
|
||||
node_box = {
|
||||
type = "fixed",
|
||||
fixed = {-0.5, -0.5, -0.5, 0.5, 0, 0.5},
|
||||
},
|
||||
on_place = function(itemstack, placer, pointed_thing)
|
||||
if pointed_thing.type ~= "node" then
|
||||
return itemstack
|
||||
end
|
||||
|
||||
-- If it's being placed on an another similar one, replace it with
|
||||
-- a full block
|
||||
local slabpos = nil
|
||||
local slabnode = nil
|
||||
local p0 = pointed_thing.under
|
||||
local p1 = pointed_thing.above
|
||||
local n0 = minetest.get_node(p0)
|
||||
local n1 = minetest.get_node(p1)
|
||||
local param2 = 0
|
||||
|
||||
local n0_is_upside_down = (n0.name == "snow:slab_" .. subname and
|
||||
n0.param2 >= 20)
|
||||
|
||||
if n0.name == "snow:slab_" .. subname and not n0_is_upside_down and p0.y+1 == p1.y then
|
||||
slabpos = p0
|
||||
slabnode = n0
|
||||
elseif n1.name == "snow:slab_" .. subname then
|
||||
slabpos = p1
|
||||
slabnode = n1
|
||||
end
|
||||
if slabpos then
|
||||
-- Remove the slab at slabpos
|
||||
minetest.remove_node(slabpos)
|
||||
-- Make a fake stack of a single item and try to place it
|
||||
local fakestack = ItemStack(recipeitem)
|
||||
fakestack:set_count(itemstack:get_count())
|
||||
|
||||
pointed_thing.above = slabpos
|
||||
local success
|
||||
fakestack, success = minetest.item_place(fakestack, placer, pointed_thing)
|
||||
-- If the item was taken from the fake stack, decrement original
|
||||
if success then
|
||||
itemstack:set_count(fakestack:get_count())
|
||||
-- Else put old node back
|
||||
else
|
||||
minetest.set_node(slabpos, slabnode)
|
||||
end
|
||||
return itemstack
|
||||
end
|
||||
|
||||
-- Upside down slabs
|
||||
if p0.y-1 == p1.y then
|
||||
-- Turn into full block if pointing at a existing slab
|
||||
if n0_is_upside_down then
|
||||
-- Remove the slab at the position of the slab
|
||||
minetest.remove_node(p0)
|
||||
-- Make a fake stack of a single item and try to place it
|
||||
local fakestack = ItemStack(recipeitem)
|
||||
fakestack:set_count(itemstack:get_count())
|
||||
|
||||
pointed_thing.above = p0
|
||||
local success
|
||||
fakestack, success = minetest.item_place(fakestack, placer, pointed_thing)
|
||||
-- If the item was taken from the fake stack, decrement original
|
||||
if success then
|
||||
itemstack:set_count(fakestack:get_count())
|
||||
-- Else put old node back
|
||||
else
|
||||
minetest.set_node(p0, n0)
|
||||
end
|
||||
return itemstack
|
||||
end
|
||||
|
||||
-- Place upside down slab
|
||||
param2 = 20
|
||||
end
|
||||
|
||||
-- If pointing at the side of a upside down slab
|
||||
if n0_is_upside_down and p0.y+1 ~= p1.y then
|
||||
param2 = 20
|
||||
end
|
||||
|
||||
return minetest.item_place(itemstack, placer, pointed_thing, param2)
|
||||
end,
|
||||
|
||||
on_construct = function(pos)
|
||||
pos.y = pos.y - 1
|
||||
if minetest.get_node(pos).name == "default:dirt_with_grass"
|
||||
-- Thinking in terms of layers, dirt_with_snow could also double as
|
||||
-- dirt_with_frost which adds subtlety to the winterscape. ~ LazyJ, 2014_04_04
|
||||
or minetest.get_node(pos).name == "default:dirt" then
|
||||
minetest.set_node(pos, {name="default:dirt_with_snow"})
|
||||
end
|
||||
end
|
||||
|
||||
})
|
||||
--[[
|
||||
-- for replace ABM
|
||||
minetest.register_node("snow:slab_" .. subname.."upside_down", {
|
||||
replace_name = "snow:slab_"..subname,
|
||||
groups = {slabs_replace=1},
|
||||
})
|
||||
--]]
|
||||
|
||||
minetest.register_craft({
|
||||
output = 'snow:slab_' .. subname .. ' 6',
|
||||
recipe = {
|
||||
{recipeitem, recipeitem, recipeitem},
|
||||
},
|
||||
})
|
||||
|
||||
|
||||
|
||||
|
||||
end
|
||||
--[[
|
||||
-- Replace old "upside_down" nodes with new param2 versions
|
||||
minetest.register_abm({
|
||||
nodenames = {"group:slabs_replace"},
|
||||
interval = 1,
|
||||
chance = 1,
|
||||
action = function(pos, node)
|
||||
node.name = minetest.registered_nodes[node.name].replace_name
|
||||
node.param2 = node.param2 + 20
|
||||
if node.param2 == 21 then
|
||||
node.param2 = 23
|
||||
elseif node.param2 == 23 then
|
||||
node.param2 = 21
|
||||
end
|
||||
minetest.set_node(pos, node)
|
||||
end,
|
||||
})
|
||||
--]]
|
||||
|
||||
|
||||
|
||||
-- Snow stairs and slabs require extra definitions because of their extra
|
||||
-- features (freezing, melting, and how they change dirt and dirt_with_grass). ~ LazyJ
|
||||
|
||||
-- Nodes will be called snow:{stair,slab}_<subname>
|
||||
function snow_stairs.register_stair_and_slab(subname, recipeitem, groups, images, desc_stair, desc_slab, freezemelt, liquidtype, paramtype, sunlight_propagates)
|
||||
snow_stairs.register_stair(subname, recipeitem, groups, images, desc_stair, freezemelt, liquidtype, paramtype, sunlight_propagates)
|
||||
snow_stairs.register_slab(subname, recipeitem, groups, images, desc_slab, freezemelt, liquidtype, paramtype, sunlight_propagates)
|
||||
end
|
||||
|
||||
|
||||
list_of_snow_stuff = {
|
||||
--{"row[1] = first item in row",
|
||||
-- "row[2] = second item in row",
|
||||
-- "row[3] = third item in row", and so on, and so on...}, ~ LazyJ
|
||||
{"ice", "default:ice", "default_ice.png", "Ice Stairs", "Ice Slabs"},
|
||||
{"snowblock", "default:snowblock", "default_snow.png", "Snowblock Stairs", "Snowblock Slabs"},
|
||||
{"snow_cobble", "snow:snow_cobble", "snow_snow_cobble.png", "Snow Cobble Stairs", "Snow Cobble Slabs"},
|
||||
{"snow_brick", "snow:snow_brick", "snow_snow_brick.png", "Snow Brick Stair", "Snow Brick Slab"},
|
||||
}
|
||||
|
||||
for _, row in ipairs(list_of_snow_stuff) do
|
||||
local snow_subname = row[1]
|
||||
local snow_recipeitem = row[2]
|
||||
local snow_images = row[3]
|
||||
local snow_desc_stair = row[4]
|
||||
local snow_desc_slab = row[5]
|
||||
|
||||
|
||||
|
||||
|
||||
snow_stairs.register_stair_and_slab(snow_subname, snow_recipeitem,
|
||||
{cracky=2, crumbly=2, choppy=2, oddly_breakable_by_hand=2, melts=1, icemaker=1},
|
||||
{snow_images},
|
||||
snow_desc_stair,
|
||||
snow_desc_slab,
|
||||
"default:water_source",
|
||||
"none",
|
||||
"light",
|
||||
true
|
||||
)
|
||||
|
||||
end -- End the "list of snow stuff" part of the above section. ~ LazyJ
|
||||
|
||||
|
||||
-- Snow stairs and slabs should be easier to break than the more dense and
|
||||
-- manufactured, other snow-type nodes in the list above. ~ lazyJ
|
||||
minetest.override_item("snow:stair_snowblock", {
|
||||
groups = {cracky=3, crumbly=3, choppy=3, oddly_breakable_by_hand=3, melts=2, icemaker=1},
|
||||
})
|
||||
|
||||
minetest.override_item("snow:slab_snowblock", {
|
||||
groups = {cracky=3, crumbly=3, choppy=3, oddly_breakable_by_hand=3, melts=2, icemaker=1},
|
||||
})
|
||||
|
||||
|
||||
|
||||
-- Everything above is made of snow and uses snow sounds, ice, however, should sound more like glass
|
||||
-- and be harder to dig. ~ LazyJ
|
||||
minetest.override_item("snow:stair_ice", {
|
||||
groups = {cracky=1, crumbly=1, choppy=1, oddly_breakable_by_hand=1, melts=2, icemaker=1},
|
||||
use_texture_alpha = true,
|
||||
sounds = default.node_sound_glass_defaults(),
|
||||
})
|
||||
|
||||
minetest.override_item("snow:slab_ice", {
|
||||
groups = {cracky=1, crumbly=1, choppy=1, oddly_breakable_by_hand=1, melts=2, icemaker=1},
|
||||
use_texture_alpha = true,
|
||||
sounds = default.node_sound_glass_defaults(),
|
||||
})
|
||||
234
mods/snow/src/crafting.lua
Normal file
234
mods/snow/src/crafting.lua
Normal file
@ -0,0 +1,234 @@
|
||||
--[[
|
||||
|
||||
Crafting Sections (in order, top to bottom):
|
||||
1. Fuel
|
||||
2. Cooking
|
||||
3. Crafting and Recycling
|
||||
|
||||
The crafting recipe for the sled is in the sled.lua file.
|
||||
|
||||
~ LazyJ
|
||||
|
||||
--]]
|
||||
|
||||
-- 1. Fuel
|
||||
|
||||
minetest.register_craft({
|
||||
type = "fuel",
|
||||
recipe = "snow:needles",
|
||||
burntime = 1,
|
||||
})
|
||||
|
||||
|
||||
|
||||
minetest.register_craft({
|
||||
type = "fuel",
|
||||
recipe = "snow:sapling_pine",
|
||||
burntime = 10,
|
||||
})
|
||||
|
||||
|
||||
|
||||
minetest.register_craft({
|
||||
type = "fuel",
|
||||
recipe = "snow:needles_decorated",
|
||||
burntime = 1,
|
||||
})
|
||||
|
||||
|
||||
|
||||
minetest.register_craft({
|
||||
type = "fuel",
|
||||
recipe = "snow:xmas_tree",
|
||||
burntime = 10,
|
||||
})
|
||||
|
||||
|
||||
|
||||
-- 2. Cooking
|
||||
|
||||
--[[
|
||||
"Cooks_into_ice" is a custom group I assigned to full-sized, snow-stuff nodes
|
||||
(snow bricks, snow cobble, snow blocks, etc.) so I wouldn't have to write an individual cooking
|
||||
recipe for each one.
|
||||
|
||||
~ LazyJ
|
||||
--]]
|
||||
|
||||
minetest.register_craft({
|
||||
type = "cooking",
|
||||
cooktime = 12,
|
||||
output = "default:ice",
|
||||
recipe = "group:cooks_into_ice",
|
||||
})
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
-- 3. Crafting and Recycling
|
||||
|
||||
-- Let's make moss craftable so players can more easily create mossycobble and
|
||||
-- gives another useful purpose to pine needles. ~ LazyJ
|
||||
|
||||
minetest.register_craft({
|
||||
output = 'snow:moss',
|
||||
recipe = {
|
||||
{'snow:needles', 'snow:needles'},
|
||||
{'snow:needles', 'snow:needles'},
|
||||
},
|
||||
})
|
||||
|
||||
|
||||
--[[
|
||||
Most snow biomes are too small to provide enough snow as a building material and
|
||||
still have enough landscape snow to create the wintry surroundings of a
|
||||
snow village or castle. So I added this snowblock crafting recipe as a way for
|
||||
players to increase their snow supply in small increments. I considered making
|
||||
the output 9 but that would make it all too quick and easy (especially for griefers) to create lots
|
||||
of snowblocks (and then use them to water-grief by melting the snow blocks).
|
||||
|
||||
~ LazyJ
|
||||
|
||||
--]]
|
||||
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = 'default:snowblock 2',
|
||||
recipe = {
|
||||
'snow:snow_cobble',
|
||||
'snow:snow_cobble'
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
|
||||
--[[minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = 'default:snowblock 3',
|
||||
recipe = {
|
||||
'default:snowblock',
|
||||
'default:snowblock'
|
||||
}
|
||||
})]]
|
||||
|
||||
|
||||
|
||||
minetest.register_craft({
|
||||
output = 'snow:snow_brick',
|
||||
recipe = {
|
||||
{'default:snowblock', 'default:snowblock'},
|
||||
{'default:snowblock', 'default:snowblock'}
|
||||
}
|
||||
})
|
||||
|
||||
--Craft icy snow.
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = 'snow:snow_cobble 6',
|
||||
recipe = {
|
||||
'default:snow',
|
||||
'default:snow',
|
||||
'default:snow',
|
||||
'default:snow',
|
||||
'default:snow',
|
||||
'default:snow',
|
||||
'default:ice',
|
||||
'default:ice',
|
||||
'default:ice'
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = 'snow:snow_cobble 4',
|
||||
recipe = {
|
||||
'default:snow',
|
||||
'default:snow',
|
||||
'default:snow',
|
||||
'default:snow',
|
||||
'default:ice',
|
||||
'default:ice'
|
||||
}
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = 'snow:snow_cobble 2',
|
||||
recipe = {
|
||||
'default:snow',
|
||||
'default:snow',
|
||||
'default:ice'
|
||||
}
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = 'snow:snow_cobble',
|
||||
recipe = {
|
||||
'default:snow',
|
||||
'default:ice'
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
-- Why not recycle snow_bricks back into snowblocks? ~ LazyJ
|
||||
minetest.register_craft({
|
||||
output = 'default:snowblock 4',
|
||||
recipe = {
|
||||
{'snow:snow_brick'}
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
|
||||
-- Recycle basic, half-block, slabs back into full blocks
|
||||
|
||||
-- A little "list" magic here. Instead of writing four crafts I only have to write two. ~ LazyJ
|
||||
local recycle_default_slabs = {
|
||||
"ice",
|
||||
"snowblock",
|
||||
}
|
||||
|
||||
for _, name in pairs(recycle_default_slabs) do
|
||||
local subname_default = name
|
||||
|
||||
-- This craft is for default snowblocks and default ice.
|
||||
-- 1 crafting recipe handles 2, default blocks. ~ LazyJ
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = "default:"..subname_default,
|
||||
recipe = {
|
||||
"snow:slab_"..subname_default,
|
||||
"snow:slab_"..subname_default,
|
||||
}
|
||||
})
|
||||
end
|
||||
|
||||
|
||||
|
||||
-- Similar list magic here too. I couldn't successfully combine these in the first list
|
||||
-- because we are dealing with slabs/blocks from two different mods, the "Snow" mod and
|
||||
-- minetest_game's "Default" mod. ~ LazyJ
|
||||
|
||||
local recycle_snowmod_slabs = {
|
||||
"snow_brick",
|
||||
"snow_cobble",
|
||||
}
|
||||
|
||||
for _, name in pairs(recycle_snowmod_slabs) do
|
||||
local subname_snowmod = name
|
||||
|
||||
-- This craft is for the Snow mod's full-sized blocks.
|
||||
-- 1 crafting recipe handles 2, or more, Snow mod blocks. ~ LazyJ
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = "snow:"..subname_snowmod,
|
||||
recipe = {
|
||||
"snow:slab_"..subname_snowmod,
|
||||
"snow:slab_"..subname_snowmod,
|
||||
}
|
||||
})
|
||||
end
|
||||
234
mods/snow/src/falling_snow.lua
Normal file
234
mods/snow/src/falling_snow.lua
Normal file
@ -0,0 +1,234 @@
|
||||
--[[
|
||||
--=================
|
||||
--======================================
|
||||
LazyJ's Fork of Splizard's "Snow" Mod
|
||||
by LazyJ
|
||||
version: Umpteen and 7/5ths something or another.
|
||||
2014_04_12
|
||||
--======================================
|
||||
--=================
|
||||
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
THE LIST OF CHANGES I'VE MADE
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
|
||||
* Falling snow would destroy nodes it deposited snow on. I figured out that if
|
||||
I switched the 'snow.place' with 'minetest.place_node' and increased the
|
||||
y position by 2, then the nodes were nolonger destroyed and the snow
|
||||
would start to pile up.
|
||||
|
||||
|
||||
|
||||
~~~~~~
|
||||
TODO
|
||||
~~~~~~
|
||||
|
||||
* Add code to prevent snowfall from depositing snow on or
|
||||
near torches and lava.
|
||||
|
||||
* Add code to prevent snowfall from depositing snow on
|
||||
'walkable = false' defined nodes.
|
||||
|
||||
--]]
|
||||
|
||||
|
||||
|
||||
--=============================================================
|
||||
-- CODE STUFF
|
||||
--=============================================================
|
||||
|
||||
|
||||
local weather_legacy
|
||||
|
||||
local read_weather_legacy = function ()
|
||||
local file = io.open(minetest.get_worldpath().."/weather_v6", "r")
|
||||
if not file then return end
|
||||
local readweather = file:read()
|
||||
file:close()
|
||||
return readweather
|
||||
end
|
||||
|
||||
--Weather for legacy versions of minetest.
|
||||
local save_weather_legacy = function ()
|
||||
local file = io.open(minetest.get_worldpath().."/weather_v6", "w+")
|
||||
file:write(weather_legacy)
|
||||
file:close()
|
||||
end
|
||||
|
||||
weather_legacy = read_weather_legacy() or ""
|
||||
|
||||
minetest.register_globalstep(function(dtime)
|
||||
if weather_legacy == "snow" then
|
||||
if math.random(1, 10000) == 1 then
|
||||
weather_legacy = "none"
|
||||
save_weather_legacy()
|
||||
end
|
||||
else
|
||||
if math.random(1, 50000) == 2 then
|
||||
weather_legacy = "snow"
|
||||
save_weather_legacy()
|
||||
end
|
||||
end
|
||||
end)
|
||||
|
||||
-- copied from meru mod
|
||||
local SEEDDIFF3 = 9130 -- 9130 -- Values should match minetest mapgen desert perlin.
|
||||
local OCTAVES3 = 3 -- 3
|
||||
local PERSISTENCE3 = 0.5 -- 0.5
|
||||
local SCALE3 = 250 -- 250
|
||||
|
||||
--Get snow at position.
|
||||
local function get_snow(pos)
|
||||
--Legacy support.
|
||||
if weather_legacy == "snow" then
|
||||
local perlin1 = minetest.get_perlin(112,3, 0.5, 150)
|
||||
if perlin1:get2d({x=pos.x, y=pos.z}) <= 0.53 then
|
||||
return false
|
||||
end
|
||||
|
||||
-- disable falling snow in desert
|
||||
local desert_perlin = minetest.get_perlin(SEEDDIFF3, OCTAVES3, PERSISTENCE3, SCALE3)
|
||||
local noise3 = desert_perlin:get2d({x=pos.x+150,y=pos.z+50}) -- Offsets must match minetest mapgen desert perlin.
|
||||
if noise3 > 0.35 then -- Smooth transition 0.35 to 0.45.
|
||||
return false
|
||||
end
|
||||
return true
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
local addvectors = vector and vector.add
|
||||
|
||||
--Returns a random position between minp and maxp.
|
||||
local function randpos(minp, maxp)
|
||||
local x,z
|
||||
if minp.x > maxp.x then
|
||||
x = math.random(maxp.x,minp.x)
|
||||
else
|
||||
x = math.random(minp.x,maxp.x)
|
||||
end
|
||||
if minp.z > maxp.z then
|
||||
z = math.random(maxp.z,minp.z)
|
||||
else
|
||||
z = math.random(minp.z,maxp.z)
|
||||
end
|
||||
return {x=x,y=minp.y,z=z}
|
||||
end
|
||||
|
||||
local default_snow_particle = {
|
||||
amount = 3,
|
||||
time = 0.5,
|
||||
exptime = 5,
|
||||
size = 50,
|
||||
collisiondetection = false,
|
||||
vertical = false,
|
||||
}
|
||||
|
||||
local function get_snow_particledef(data)
|
||||
for n,i in pairs(default_snow_particle) do
|
||||
data[n] = data[n] or i
|
||||
end
|
||||
for _,i in pairs({"vel", "acc", "exptime", "size"}) do
|
||||
data["min"..i] = data[i]
|
||||
data["max"..i] = data[i]
|
||||
end
|
||||
data.texture = "weather_snow.png^[transform"..math.random(0,7)
|
||||
return data
|
||||
end
|
||||
|
||||
local function snow_fall(pos, player, animate)
|
||||
local ground_y = nil
|
||||
for y=pos.y+10,pos.y+20,1 do
|
||||
local n = minetest.get_node({x=pos.x,y=y,z=pos.z}).name
|
||||
if n ~= "air" and n ~= "ignore" then
|
||||
return
|
||||
end
|
||||
end
|
||||
for y=pos.y+10,pos.y-15,-1 do
|
||||
local n = minetest.get_node({x=pos.x,y=y,z=pos.z}).name
|
||||
if n ~= "air" and n ~= "ignore" then
|
||||
ground_y = y
|
||||
break
|
||||
end
|
||||
end
|
||||
if not ground_y then
|
||||
return
|
||||
end
|
||||
|
||||
pos = {x=pos.x, y=ground_y, z=pos.z}
|
||||
|
||||
if get_snow(pos) then
|
||||
if animate then
|
||||
local spos = {x=pos.x, y=ground_y+10, z=pos.z}
|
||||
minetest.add_particlespawner(get_snow_particledef({
|
||||
minpos = addvectors(spos, {x=-9, y=3, z=-9}),
|
||||
maxpos = addvectors(spos, {x= 9, y=5, z= 9}),
|
||||
vel = {x=0, y=-1, z=-1},
|
||||
acc = {x=0, y=0, z=0},
|
||||
playername = player:get_player_name()
|
||||
}))
|
||||
end
|
||||
snow.place(pos, true)
|
||||
--minetest.place_node({x=pos.x, y=pos.y+2, z=pos.z}, {name="default:snow"}) -- LazyJ
|
||||
end
|
||||
end
|
||||
|
||||
-- Snow
|
||||
local function calc_snowfall()
|
||||
for _, player in pairs(minetest.get_connected_players()) do
|
||||
local ppos = player:getpos()
|
||||
|
||||
-- Make sure player is not in a cave/house...
|
||||
if get_snow(ppos)
|
||||
and minetest.get_node_light(ppos, 0.5) == 15 then
|
||||
local animate
|
||||
if not snow.lighter_snowfall then
|
||||
local vel = {x=0, y=-1, z=-1}
|
||||
local acc = {x=0, y=0, z=0}
|
||||
minetest.add_particlespawner(get_snow_particledef({
|
||||
amount = 5,
|
||||
minpos = addvectors(ppos, {x=-9, y=3, z=-9}),
|
||||
maxpos = addvectors(ppos, {x= 9, y=5, z= 9}),
|
||||
vel = vel,
|
||||
acc = acc,
|
||||
size = 25,
|
||||
playername = player:get_player_name()
|
||||
}))
|
||||
|
||||
minetest.add_particlespawner(get_snow_particledef({
|
||||
amount = 4,
|
||||
minpos = addvectors(ppos, {x=-5, y=3.2, z=-5}),
|
||||
maxpos = addvectors(ppos, {x= 5, y=1.6, z= 5}),
|
||||
vel = vel,
|
||||
acc = acc,
|
||||
exptime = 4,
|
||||
size = 25,
|
||||
playername = player:get_player_name()
|
||||
}))
|
||||
|
||||
animate = false
|
||||
else
|
||||
animate = true
|
||||
end
|
||||
|
||||
if math.random(1,5) == 4 then
|
||||
snow_fall(
|
||||
randpos(
|
||||
addvectors(ppos, {x=-20, y=0, z=-20}),
|
||||
addvectors(ppos, {x= 20, y=0, z= 20})
|
||||
),
|
||||
player,
|
||||
animate
|
||||
)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
minetest.register_globalstep(function(dtime)
|
||||
if snow.enable_snowfall then
|
||||
calc_snowfall()
|
||||
end
|
||||
end)
|
||||
181
mods/snow/src/mapgen.lua
Normal file
181
mods/snow/src/mapgen.lua
Normal file
@ -0,0 +1,181 @@
|
||||
--[[
|
||||
If you want to run PlantLife and mods that depend on it, i.e. MoreTrees, Disable the mapgen by
|
||||
commenting-out the lines starting with "local mgname = " through "end" (I left a note were to start
|
||||
and stop) Disabling "Snow's" mapgen allows MoreTrees and PlantLife to do their thing until the
|
||||
issue is figured out. However, the pine and xmas tree code is still needed for when those
|
||||
saplings grow into trees. --]]
|
||||
--The *starting* comment looks like this: --[[
|
||||
--The *closing* comment looks like this: --]]
|
||||
|
||||
-- ~ LazyJ, 2014_05_13
|
||||
|
||||
|
||||
-- Part 1: To disable the mapgen, add the *starting* comment under this line.
|
||||
|
||||
|
||||
--Identify the mapgen.
|
||||
minetest.register_on_mapgen_init(function(MapgenParams)
|
||||
local mgname = MapgenParams.mgname
|
||||
if not mgname then
|
||||
io.write("[MOD] Snow Biomes: WARNING! mapgen could not be identifyed!\n")
|
||||
end
|
||||
if mgname == "v7" then
|
||||
--Load mapgen_v7 compatibility.
|
||||
dofile(minetest.get_modpath("snow").."/src/mapgen_v7.lua")
|
||||
else
|
||||
--Load mapgen_v6 compatibility.
|
||||
dofile(minetest.get_modpath("snow").."/src/mapgen_v6.lua")
|
||||
end
|
||||
end)
|
||||
|
||||
-- To complete the commenting-out add the *closing* comment under this line.
|
||||
|
||||
|
||||
|
||||
|
||||
local pine_tree = {
|
||||
axiom="TABff",
|
||||
rules_a="[&T+f+ff+ff+ff+f]GA",
|
||||
rules_b="[&T+f+Gf+Gf+Gf]GB",
|
||||
trunk="default:pinetree",
|
||||
leaves="snow:needles",
|
||||
angle=90,
|
||||
iterations=1,
|
||||
random_level=0,
|
||||
trunk_type="single",
|
||||
thin_branches=true,
|
||||
}
|
||||
|
||||
|
||||
|
||||
local xmas_tree = {
|
||||
axiom="TABff",
|
||||
rules_a="[&T+f+ff+ff+ff+f]GA",
|
||||
rules_b="[&T+f+Gf+Gf+Gf]GB",
|
||||
trunk="default:pinetree",
|
||||
leaves="snow:needles_decorated",
|
||||
angle=90,
|
||||
iterations=1,
|
||||
random_level=0,
|
||||
trunk_type="single",
|
||||
thin_branches=true,
|
||||
}
|
||||
|
||||
|
||||
|
||||
--Makes pine tree
|
||||
function snow.make_pine(pos,snow,xmas)
|
||||
local minetest = minetest
|
||||
local perlin1 = minetest.get_perlin(112,3, 0.5, 150)
|
||||
local try_node = function(pos, node)
|
||||
local n = minetest.get_node(pos).name
|
||||
if n == "air"
|
||||
or n == "ignore" then
|
||||
minetest.add_node(pos, node)
|
||||
end
|
||||
end
|
||||
--Clear ground.
|
||||
for z = -1,1 do
|
||||
for x = -1,1 do
|
||||
local p = {x=pos.x+x,y=pos.y,z=pos.z+z}
|
||||
local nd = minetest.get_node(p).name
|
||||
if nd == "default:snow"
|
||||
or nd == "default:snowblock" then
|
||||
minetest.remove_node(p)
|
||||
end
|
||||
end
|
||||
end
|
||||
if xmas then
|
||||
minetest.remove_node(pos)
|
||||
minetest.spawn_tree(pos, xmas_tree)
|
||||
else
|
||||
minetest.spawn_tree(pos, pine_tree)
|
||||
end
|
||||
if snow then
|
||||
local x,z = pos.x,pos.z
|
||||
try_node({x=x+1,y=pos.y+3,z=z+1},{name="default:snow"})
|
||||
try_node({x=x-1,y=pos.y+3,z=z-1},{name="default:snow"})
|
||||
try_node({x=x-1,y=pos.y+3,z=z+1},{name="default:snow"})
|
||||
try_node({x=x+1,y=pos.y+3,z=z-1},{name="default:snow"})
|
||||
|
||||
try_node({x=x+1,y=pos.y+5,z=z},{name="default:snow"})
|
||||
try_node({x=x-1,y=pos.y+5,z=z},{name="default:snow"})
|
||||
try_node({x=x,y=pos.y+5,z=z+1},{name="default:snow"})
|
||||
try_node({x=x,y=pos.y+5,z=z-1},{name="default:snow"})
|
||||
end
|
||||
if xmas then
|
||||
try_node({x=pos.x,y=pos.y+7,z=pos.z},{name="snow:star_lit"}) -- Added lit star. ~ LazyJ
|
||||
elseif snow
|
||||
and perlin1:get2d({x=pos.x,y=pos.z}) > 0.53 then
|
||||
try_node({x=pos.x,y=pos.y+7,z=pos.z},{name="default:snow"})
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
|
||||
--Makes pine tree
|
||||
function snow.voxelmanip_pine(pos,a,data)
|
||||
local c_snow = minetest.get_content_id("default:snow")
|
||||
local c_pine_needles = minetest.get_content_id("snow:needles")
|
||||
local c_pinetree = minetest.get_content_id("default:pinetree")
|
||||
local c_air = minetest.get_content_id("air")
|
||||
|
||||
local perlin1 = minetest.get_perlin(112,3, 0.5, 150)
|
||||
for z = -1,1 do
|
||||
local z = pos.z + z
|
||||
for x = -1,1 do
|
||||
local x = pos.x + x
|
||||
|
||||
--Clear ground.
|
||||
local node = a:index(x,pos.y,z)
|
||||
if data[node] == c_snow then
|
||||
data[node] = c_air
|
||||
end
|
||||
|
||||
--Make tree.
|
||||
for i = 1,2 do
|
||||
local node = a:index(x,pos.y+i,z)
|
||||
data[node] = c_pine_needles
|
||||
if snow
|
||||
and x ~= 0
|
||||
and z ~= 0
|
||||
and perlin1:get2d({x=x,y=z}) > 0.53 then
|
||||
local abovenode = a:index(x,pos.y+i+1,z)
|
||||
data[abovenode] = c_snow
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
for i=3, 4 do
|
||||
local x = pos.x
|
||||
local y = pos.y+i
|
||||
local z = pos.z
|
||||
data[a:index(x+1,y,z)] = c_pine_needles
|
||||
data[a:index(x-1,y,z)] = c_pine_needles
|
||||
data[a:index(x,y,z+1)] = c_pine_needles
|
||||
data[a:index(x,y,z-1)] = c_pine_needles
|
||||
if snow then
|
||||
if perlin1:get2d({x=x+1,y=z}) > 0.53 then
|
||||
data[a:index(x+1,y+1,z)] = c_snow
|
||||
end
|
||||
if perlin1:get2d({x=x+1,y=z}) > 0.53 then
|
||||
data[a:index(x-1,y+1,z)] = c_snow
|
||||
end
|
||||
if perlin1:get2d({x=x,y=z+1}) > 0.53 then
|
||||
data[a:index(x,y+1,z+1)] = c_snow
|
||||
end
|
||||
if perlin1:get2d({x=x,y=z-1}) > 0.53 then
|
||||
data[a:index(x,y+1,z-1)] = c_snow
|
||||
end
|
||||
end
|
||||
end
|
||||
for i=0, 4 do
|
||||
data[a:index(pos.x,pos.y+i,pos.z)] = c_pinetree
|
||||
end
|
||||
data[a:index(pos.x,pos.y+5,pos.z)] = c_pine_needles
|
||||
data[a:index(pos.x,pos.y+6,pos.z)] = c_pine_needles
|
||||
if snow
|
||||
and perlin1:get2d({x=pos.x,y=pos.z}) > 0.53 then
|
||||
data[a:index(pos.x,pos.y+7,pos.z)] = c_snow
|
||||
end
|
||||
end
|
||||
351
mods/snow/src/mapgen_v6.lua
Normal file
351
mods/snow/src/mapgen_v6.lua
Normal file
@ -0,0 +1,351 @@
|
||||
-- 2D noise for coldness
|
||||
|
||||
local np_cold = {
|
||||
offset = 0,
|
||||
scale = 1,
|
||||
spread = {x=150, y=150, z=150},
|
||||
seed = 112,
|
||||
octaves = 3,
|
||||
persist = 0.5
|
||||
}
|
||||
|
||||
-- 2D noise for icetype
|
||||
|
||||
local np_ice = {
|
||||
offset = 0,
|
||||
scale = 1,
|
||||
spread = {x=80, y=80, z=80},
|
||||
seed = 322345,
|
||||
octaves = 3,
|
||||
persist = 0.5
|
||||
}
|
||||
|
||||
-- Debugging function
|
||||
|
||||
local biome_strings = {
|
||||
{"snowy", "plain", "alpine", "normal", "normal"},
|
||||
{"cool", "icebergs", "icesheet", "icecave", "icehole"}
|
||||
}
|
||||
local function biome_to_string(num,num2)
|
||||
local biome = biome_strings[1][num] or "unknown "..num
|
||||
return biome
|
||||
end
|
||||
|
||||
local function do_ws_func(a, x)
|
||||
local n = x/(16000)
|
||||
local y = 0
|
||||
for k=1,1000 do
|
||||
y = y + 1000*(math.sin(math.pi * k^a * n)/(math.pi * k^a))
|
||||
end
|
||||
return y
|
||||
end
|
||||
|
||||
local ws_lists = {}
|
||||
local function get_ws_list(a,x)
|
||||
ws_lists[a] = ws_lists[a] or {}
|
||||
local v = ws_lists[a][x]
|
||||
if v then
|
||||
return v
|
||||
end
|
||||
v = {}
|
||||
for x=x,x + (80 - 1) do
|
||||
local y = do_ws_func(a, x)
|
||||
v[x] = y
|
||||
end
|
||||
ws_lists[a][x] = v
|
||||
return v
|
||||
end
|
||||
|
||||
-- On generated function
|
||||
|
||||
minetest.register_on_generated(function(minp, maxp, seed)
|
||||
local t1 = os.clock()
|
||||
|
||||
local x0 = minp.x
|
||||
local z0 = minp.z
|
||||
local x1 = maxp.x
|
||||
local z1 = maxp.z
|
||||
|
||||
local spawn_pine = snow.voxelmanip_pine
|
||||
local smooth = snow.smooth_biomes
|
||||
|
||||
local c_dirt_with_grass = minetest.get_content_id("default:dirt_with_grass")
|
||||
local c_dirt = minetest.get_content_id("default:dirt")
|
||||
local c_tree = minetest.get_content_id("default:tree")
|
||||
local c_apple = minetest.get_content_id("default:apple")
|
||||
local c_snow = minetest.get_content_id("default:snow")
|
||||
local c_snow_block = minetest.get_content_id("default:snowblock")
|
||||
local c_dirt_with_snow = minetest.get_content_id("default:dirt_with_snow")
|
||||
local c_air = minetest.get_content_id("air")
|
||||
local c_ignore = minetest.get_content_id("ignore")
|
||||
local c_stone = minetest.get_content_id("default:stone")
|
||||
local c_dry_shrub = minetest.get_content_id("default:dry_shrub")
|
||||
local c_leaves = minetest.get_content_id("default:leaves")
|
||||
local c_jungleleaves = minetest.get_content_id("default:jungleleaves")
|
||||
local c_junglegrass = minetest.get_content_id("default:junglegrass")
|
||||
local c_ice = minetest.get_content_id("default:ice")
|
||||
local c_water = minetest.get_content_id("default:water_source")
|
||||
local c_papyrus = minetest.get_content_id("default:papyrus")
|
||||
local c_sand = minetest.get_content_id("default:sand")
|
||||
|
||||
local vm = minetest.get_voxel_manip()
|
||||
local emin, emax = vm:read_from_map(minp, maxp)
|
||||
local area = VoxelArea:new({MinEdge=emin, MaxEdge=emax})
|
||||
local data = vm:get_data()
|
||||
|
||||
local snow_tab,num = {},1
|
||||
|
||||
local sidelen = x1 - x0 + 1
|
||||
local chulens = {x=sidelen, y=sidelen, z=sidelen}
|
||||
local nvals_cold = minetest.get_perlin_map(np_cold, chulens):get2dMap_flat({x=x0, y=z0})
|
||||
local nvals_ice = minetest.get_perlin_map(np_ice, chulens):get2dMap_flat({x=x0, y=z0})
|
||||
|
||||
-- Choose biomes
|
||||
local pr = PseudoRandom(seed+57)
|
||||
-- Land biomes
|
||||
local biome = pr:next(1, 5)
|
||||
local snowy = biome == 1 -- spawns alot of snow
|
||||
local alpine = biome == 3 -- rocky terrain
|
||||
-- Misc biome settings
|
||||
local icy = pr:next(1, 2) == 2 -- if enabled spawns ice in sand instead of snow blocks
|
||||
local shrubs = pr:next(1,2) == 1 -- spawns dry shrubs in snow
|
||||
local pines = pr:next(1,2) == 1 -- spawns pines
|
||||
-- Reseed random
|
||||
pr = PseudoRandom(seed+68)
|
||||
|
||||
-- Loop through columns in chunk
|
||||
local write_to_map = false
|
||||
local ni = 1
|
||||
for z = z0, z1 do
|
||||
for x = x0, x1 do
|
||||
local in_biome = false
|
||||
local test = nvals_cold[ni]
|
||||
if smooth and (not snowy)
|
||||
and (test > 0.73 or (test > 0.43 and pr:next(0,29) > (0.73 - test) * 100 )) then
|
||||
in_biome = true
|
||||
elseif (not smooth or snowy) and test > 0.53 then
|
||||
in_biome = true
|
||||
end
|
||||
|
||||
if not in_biome then
|
||||
if alpine and test > 0.43 then
|
||||
local ground_y = nil
|
||||
for y = maxp.y, minp.y, -1 do
|
||||
local nodid = data[area:index(x, y, z)]
|
||||
if nodid ~= c_air
|
||||
and nodid ~= c_ignore then
|
||||
ground_y = y
|
||||
break
|
||||
end
|
||||
end
|
||||
|
||||
if ground_y then
|
||||
local vi = area:index(x, ground_y, z)
|
||||
if data[vi] == c_leaves or data[vi] == c_jungleleaves then
|
||||
for y = ground_y, -16, -1 do
|
||||
local vi = area:index(x, y, z)
|
||||
local id = data[vi]
|
||||
if id ~= c_air then
|
||||
if id == c_leaves
|
||||
or id == c_jungleleaves
|
||||
or id == c_tree
|
||||
or id == c_apple then
|
||||
data[vi] = c_air
|
||||
else
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
elseif in_biome then
|
||||
write_to_map = true
|
||||
local icetype = nvals_ice[ni]
|
||||
local cool = icetype > 0 -- only spawns ice on edge of water
|
||||
local icebergs = icetype > -0.2 and icetype <= 0
|
||||
local icehole = icetype > -0.4 and icetype <= -0.2 -- icesheet with holes
|
||||
local icesheet = icetype > -0.6 and icetype <= -0.4
|
||||
local icecave = icetype <= -0.6
|
||||
|
||||
local ground_y = nil
|
||||
for y = maxp.y, minp.y, -1 do
|
||||
local nodid = data[area:index(x, y, z)]
|
||||
if nodid ~= c_air and nodid ~= c_ignore then
|
||||
ground_y = y
|
||||
break
|
||||
end
|
||||
end
|
||||
|
||||
if ground_y then
|
||||
local node = area:index(x, ground_y, z)
|
||||
local abovenode = area:index(x, ground_y+1, z)
|
||||
local belownode = area:index(x, ground_y-1, z)
|
||||
|
||||
if ground_y and data[node] == c_dirt_with_grass then
|
||||
if alpine and test > 0.53 then
|
||||
snow_tab[num] = {abovenode, z, x, test}
|
||||
num = num+1
|
||||
for y = ground_y, -6, -1 do
|
||||
local vi = area:index(x, y, z)
|
||||
if data[vi] == c_stone then
|
||||
break
|
||||
else
|
||||
data[vi] = c_stone
|
||||
end
|
||||
end
|
||||
elseif (shrubs and pr:next(1,28) == 1) then
|
||||
data[node] = c_dirt_with_snow
|
||||
data[abovenode] = c_dry_shrub
|
||||
elseif pines and pr:next(1,36) == 1 then
|
||||
data[node] = c_dirt_with_snow
|
||||
spawn_pine({x=x, y=ground_y+1, z=z}, area, data)
|
||||
elseif snowy and test > 0.63 then
|
||||
data[abovenode] = c_snow_block
|
||||
else
|
||||
data[node] = c_dirt_with_snow
|
||||
snow_tab[num] = {abovenode, z, x, test}
|
||||
num = num+1
|
||||
end
|
||||
elseif ground_y and data[node] == c_sand then
|
||||
if not icy then
|
||||
snow_tab[num] = {abovenode, z, x, test}
|
||||
num = num+1
|
||||
else
|
||||
data[node] = c_ice
|
||||
end
|
||||
elseif ground_y and data[node] == c_leaves
|
||||
or data[node] == c_jungleleaves or data[node] == c_apple then
|
||||
if alpine then
|
||||
snow_tab[num] = {abovenode, z, x, test}
|
||||
num = num+1
|
||||
for y = ground_y, -6, -1 do
|
||||
local stone = area:index(x, y, z)
|
||||
if data[stone] == c_stone then
|
||||
break
|
||||
else
|
||||
data[stone] = c_stone
|
||||
end
|
||||
end
|
||||
else
|
||||
snow_tab[num] = {abovenode, z, x, test}
|
||||
num = num+1
|
||||
end
|
||||
elseif ground_y
|
||||
and data[node] == c_junglegrass then
|
||||
data[node] = c_dry_shrub
|
||||
elseif ground_y
|
||||
and data[node] == c_papyrus then
|
||||
for y = ground_y, ground_y-4, -1 do
|
||||
local vi = area:index(x, y, z)
|
||||
if data[vi] == c_papyrus then
|
||||
snow_tab[num] = {area:index(x, ground_y, z), z, x, test}
|
||||
num = num+1
|
||||
data[vi] = c_snow_block
|
||||
end
|
||||
end
|
||||
elseif ground_y
|
||||
and data[node] == c_water then
|
||||
if not icesheet
|
||||
and not icecave
|
||||
and not icehole then
|
||||
local x1 = data[area:index(x+1, ground_y, z)]
|
||||
local z1 = data[area:index(x, ground_y, z+1)]
|
||||
local xz1 = data[area:index(x+1, ground_y, z+1)]
|
||||
local xz2 = data[area:index(x-1, ground_y, z-1)]
|
||||
local x2 = data[area:index(x-1, ground_y, z)]
|
||||
local z2 = data[area:index(x, ground_y, z-1)]
|
||||
local rand = (pr:next(1,4) == 1) and (cool or icebergs)
|
||||
local ice
|
||||
if rand then
|
||||
for _,i in ipairs({x1,z1,xz1,xz2,x2,z2}) do
|
||||
if i == c_ice then
|
||||
ice = true
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
if not ice then
|
||||
for _,i in ipairs({x1,z1,xz1,xz2,x2,z2}) do
|
||||
if i ~= c_water
|
||||
and i ~= c_ice
|
||||
and i ~= c_air
|
||||
and i ~= c_ignore then
|
||||
ice = true
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
local y = data[area:index(x, ground_y-1, z)]
|
||||
if ice
|
||||
or (y ~= c_water and y ~= c_ice) -- and y ~= "air") …I don't think y can be a string here ~HybridDog
|
||||
or (icebergs and pr:next(1,6) == 1) then
|
||||
data[node] = c_ice
|
||||
end
|
||||
else
|
||||
if (icehole and pr:next(1,10) > 1)
|
||||
or icecave
|
||||
or icesheet then
|
||||
data[node] = c_ice
|
||||
end
|
||||
if icecave then
|
||||
for y = ground_y-1, -33, -1 do
|
||||
local vi = area:index(x, y, z)
|
||||
if data[vi] ~= c_water then
|
||||
break
|
||||
else
|
||||
data[vi] = c_air
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
ni = ni + 1
|
||||
end
|
||||
end
|
||||
|
||||
local param2s
|
||||
if num ~= 1 then
|
||||
local wsz, wsx
|
||||
for _,i in pairs(snow_tab) do
|
||||
local p,z,x,test = unpack(i)
|
||||
data[p] = c_snow
|
||||
test = test-0.73
|
||||
if test > 0 then
|
||||
local minh = math.floor(test*4*9)%9+1
|
||||
if minh ~= 1 then
|
||||
if not wsz then
|
||||
wsz = get_ws_list(5, z0)
|
||||
wsx = get_ws_list(2, x0)
|
||||
param2s = vm:get_param2_data()
|
||||
end
|
||||
local h = math.min(minh, math.floor(wsx[x]+wsz[z]*5)%9+1)
|
||||
if h ~= 1 then
|
||||
if h == 9 then
|
||||
h = 4
|
||||
end
|
||||
param2s[p] = h*7
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
vm:set_data(data)
|
||||
if param2s then
|
||||
vm:set_param2_data(param2s)
|
||||
end
|
||||
vm:set_lighting({day=0, night=0})
|
||||
vm:calc_lighting()
|
||||
vm:write_to_map()
|
||||
|
||||
if write_to_map
|
||||
and snow.debug then -- print if any column of mapchunk was snow biome
|
||||
local biome_string = biome_to_string(biome)
|
||||
local chugent = math.ceil((os.clock() - t1) * 1000)
|
||||
print("[snow] "..biome_string.." x "..minp.x.." z "..minp.z.." time "..chugent.." ms")
|
||||
end
|
||||
end)
|
||||
|
||||
138
mods/snow/src/mapgen_v7.lua
Normal file
138
mods/snow/src/mapgen_v7.lua
Normal file
@ -0,0 +1,138 @@
|
||||
minetest.register_biome({
|
||||
name = "snow_biome_default",
|
||||
|
||||
node_top = "default:dirt_with_snow",
|
||||
depth_top = 1,
|
||||
node_filler = "default:dirt",
|
||||
depth_filler = 2,
|
||||
|
||||
height_min = snow.min_height,
|
||||
height_max = snow.min_height+60,
|
||||
heat_point = 10.0,
|
||||
humidity_point = 40.0,
|
||||
})
|
||||
|
||||
minetest.register_biome({
|
||||
name = "snow_biome_forest",
|
||||
|
||||
node_top = "default:dirt_with_snow",
|
||||
depth_top = 1,
|
||||
node_filler = "default:dirt",
|
||||
depth_filler = 2,
|
||||
|
||||
height_min = snow.min_height,
|
||||
height_max = snow.min_height+60,
|
||||
heat_point = 10.0,
|
||||
humidity_point = 55.0,
|
||||
})
|
||||
|
||||
minetest.register_biome({
|
||||
name = "snow_biome_lush",
|
||||
|
||||
node_top = "default:dirt_with_snow",
|
||||
depth_top = 1,
|
||||
node_filler = "default:dirt",
|
||||
depth_filler = 2,
|
||||
|
||||
height_min = snow.min_height,
|
||||
height_max = snow.min_height+60,
|
||||
heat_point = 10.0,
|
||||
humidity_point = 70.0,
|
||||
})
|
||||
|
||||
minetest.register_biome({
|
||||
name = "snow_biome_alpine",
|
||||
|
||||
node_top = "default:stone",
|
||||
depth_top = 1,
|
||||
node_filler = "default:stone",
|
||||
|
||||
height_min = snow.min_height+60,
|
||||
height_max = 31000,
|
||||
heat_point = 10.0,
|
||||
humidity_point = 40.0,
|
||||
})
|
||||
|
||||
minetest.register_biome({
|
||||
name = "snow_biome_sand",
|
||||
|
||||
node_top = "default:sand",
|
||||
depth_top = 3,
|
||||
node_filler = "default:stone",
|
||||
depth_filler = 0,
|
||||
|
||||
height_min = -31000,
|
||||
height_max = 2,
|
||||
heat_point = 10.0,
|
||||
humidity_point = 40.0,
|
||||
})
|
||||
|
||||
|
||||
--Pine tree.
|
||||
minetest.register_decoration({
|
||||
deco_type = "schematic",
|
||||
place_on = "default:dirt_with_snow",
|
||||
sidelen = 16,
|
||||
fill_ratio = 0.005,
|
||||
biomes = {"snow_biome_default"},
|
||||
schematic = minetest.get_modpath("snow").."/schematics/pine.mts",
|
||||
flags = "place_center_x, place_center_z",
|
||||
})
|
||||
|
||||
minetest.register_decoration({
|
||||
deco_type = "schematic",
|
||||
place_on = "default:dirt_with_snow",
|
||||
sidelen = 16,
|
||||
fill_ratio = 0.05,
|
||||
biomes = {"snow_biome_forest"},
|
||||
schematic = minetest.get_modpath("snow").."/schematics/pine.mts",
|
||||
flags = "place_center_x, place_center_z",
|
||||
})
|
||||
|
||||
minetest.register_decoration({
|
||||
deco_type = "schematic",
|
||||
place_on = "default:dirt_with_snow",
|
||||
sidelen = 16,
|
||||
fill_ratio = 0.1,
|
||||
biomes = {"snow_biome_lush"},
|
||||
schematic = minetest.get_modpath("snow").."/schematics/pine.mts",
|
||||
flags = "place_center_x, place_center_z",
|
||||
})
|
||||
|
||||
--Dry shrubs.
|
||||
minetest.register_decoration({
|
||||
deco_type = "simple",
|
||||
place_on = "default:dirt_with_snow",
|
||||
sidelen = 16,
|
||||
fill_ratio = 0.005,
|
||||
biomes = {"snow_biome_default"},
|
||||
decoration = "default:dry_shrub",
|
||||
})
|
||||
|
||||
minetest.register_decoration({
|
||||
deco_type = "simple",
|
||||
place_on = "default:dirt_with_snow",
|
||||
sidelen = 16,
|
||||
fill_ratio = 0.05,
|
||||
biomes = {"snow_biome_forest", "snow_biome_lush"},
|
||||
decoration = "default:dry_shrub",
|
||||
})
|
||||
|
||||
--Snow.
|
||||
minetest.register_decoration({
|
||||
deco_type = "simple",
|
||||
place_on = "default:dirt_with_snow",
|
||||
sidelen = 16,
|
||||
fill_ratio = 10,
|
||||
biomes = {"snow_biome_default", "snow_biome_forest", "snow_biome_lush"},
|
||||
decoration = "default:snow",
|
||||
})
|
||||
|
||||
minetest.register_decoration({
|
||||
deco_type = "simple",
|
||||
place_on = "default:stone",
|
||||
sidelen = 16,
|
||||
fill_ratio = 10,
|
||||
biomes = {"snow_biome_alpine"},
|
||||
decoration = "default:snow",
|
||||
})
|
||||
351
mods/snow/src/nodes.lua
Normal file
351
mods/snow/src/nodes.lua
Normal file
@ -0,0 +1,351 @@
|
||||
-- NODES
|
||||
|
||||
-- Pine Needles
|
||||
minetest.register_node("snow:needles",{
|
||||
description = "Pine Needles",
|
||||
drawtype = "allfaces_optional",
|
||||
visual_scale = 1.3,
|
||||
tiles = {"snow_needles.png"},
|
||||
waving = 1,
|
||||
paramtype = "light",
|
||||
groups = {snappy=3, leafdecay=5},
|
||||
drop = {
|
||||
max_items = 1,
|
||||
items = {
|
||||
{
|
||||
-- player will get sapling with 1/20 chance
|
||||
items = {'snow:sapling_pine'},
|
||||
rarity = 20,
|
||||
},
|
||||
{
|
||||
-- player will get leaves only if he get no saplings,
|
||||
-- this is because max_items is 1
|
||||
items = {'snow:needles'},
|
||||
}
|
||||
}
|
||||
},
|
||||
sounds = default.node_sound_leaves_defaults(),
|
||||
})
|
||||
|
||||
--[[
|
||||
If christmas_content is enabled, then this next part will override the pine needles' drop code
|
||||
(in the code section above) and adds Xmas tree saplings to the items that are dropped.
|
||||
The Xmas tree needles are registred and defined a farther down in this nodes.lua file.
|
||||
|
||||
~ LazyJ
|
||||
|
||||
--]]
|
||||
|
||||
if snow.christmas_content then
|
||||
--Christmas trees
|
||||
|
||||
minetest.override_item("snow:needles", {
|
||||
drop = {
|
||||
max_items = 1,
|
||||
items = {
|
||||
{
|
||||
-- player will get xmas tree with 1/120 chance
|
||||
items = {'snow:xmas_tree'},
|
||||
rarity = 120,
|
||||
},
|
||||
{
|
||||
-- player will get sapling with 1/20 chance
|
||||
items = {'snow:sapling_pine'},
|
||||
rarity = 20,
|
||||
},
|
||||
{
|
||||
-- player will get leaves only if he get no saplings,
|
||||
-- this is because max_items is 1
|
||||
items = {'snow:needles'},
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
end
|
||||
|
||||
|
||||
--Christmas easter egg
|
||||
minetest.register_on_mapgen_init( function()
|
||||
if rawget(_G, "skins") then
|
||||
skins.add("character_snow_man")
|
||||
end
|
||||
end
|
||||
)
|
||||
|
||||
|
||||
|
||||
--[[
|
||||
Original, static Xmas lights. Keep so people can "turn off" the
|
||||
animation if it is too much for them. ~ LazyJ
|
||||
|
||||
--Decorated Pine leaves
|
||||
minetest.register_node("snow:needles_decorated", {
|
||||
description = "Decorated Pine Needles",
|
||||
drawtype = "allfaces_optional",
|
||||
tiles = {"snow_needles_decorated.png"},
|
||||
paramtype = "light",
|
||||
groups = {snappy=3, leafdecay=3},
|
||||
drop = {
|
||||
max_items = 1,
|
||||
items = {
|
||||
{
|
||||
-- player will get xmas tree with 1/20 chance
|
||||
items = {'snow:xmas_tree'},
|
||||
rarity = 50,
|
||||
},
|
||||
{
|
||||
-- player will get sapling with 1/20 chance
|
||||
items = {'snow:sapling_pine'},
|
||||
rarity = 20,
|
||||
},
|
||||
{
|
||||
-- player will get leaves only if he get no saplings,
|
||||
-- this is because max_items is 1
|
||||
items = {'snow:needles_decorated'},
|
||||
}
|
||||
}
|
||||
},
|
||||
sounds = default.node_sound_leaves_defaults(),
|
||||
})
|
||||
--]]
|
||||
|
||||
|
||||
|
||||
-- Animated, "blinking lights" version. ~ LazyJ
|
||||
|
||||
-- Decorated Pine Leaves
|
||||
minetest.register_node("snow:needles_decorated", {
|
||||
description = "Decorated Pine Needles",
|
||||
drawtype = "allfaces_optional",
|
||||
light_source = 5,
|
||||
inventory_image = minetest.inventorycube("snow_needles_decorated.png"),
|
||||
--tiles = {"snow_needles_decorated.png"},
|
||||
tiles = {
|
||||
{name="snow_needles_decorated_animated.png", animation={type="vertical_frames", aspect_w=16, aspect_h=16, length=20.0}}
|
||||
},
|
||||
paramtype = "light",
|
||||
groups = {snappy=3, leafdecay=5},
|
||||
drop = {
|
||||
max_items = 1,
|
||||
items = {
|
||||
{
|
||||
-- player will get xmas tree with 1/120 chance
|
||||
items = {'snow:xmas_tree'},
|
||||
rarity = 120,
|
||||
},
|
||||
{
|
||||
-- player will get sapling with 1/20 chance
|
||||
items = {'snow:sapling_pine'},
|
||||
rarity = 20,
|
||||
},
|
||||
{
|
||||
-- player will get leaves only if he get no saplings,
|
||||
-- this is because max_items is 1
|
||||
items = {'snow:needles_decorated'},
|
||||
}
|
||||
}
|
||||
},
|
||||
sounds = default.node_sound_leaves_defaults(),
|
||||
})
|
||||
|
||||
|
||||
|
||||
|
||||
-- Xmas Tree Sapling
|
||||
minetest.register_node("snow:xmas_tree", {
|
||||
description = "Christmas Tree",
|
||||
drawtype = "plantlike",
|
||||
visual_scale = 1.0,
|
||||
tiles = {"snow_xmas_tree.png"},
|
||||
inventory_image = "snow_xmas_tree.png",
|
||||
wield_image = "snow_xmas_tree.png",
|
||||
paramtype = "light",
|
||||
walkable = false,
|
||||
groups = {snappy=2,dig_immediate=3},
|
||||
sounds = default.node_sound_defaults(),
|
||||
})
|
||||
|
||||
|
||||
|
||||
-- Pine Sapling
|
||||
minetest.register_node("snow:sapling_pine", {
|
||||
description = "Pine Sapling",
|
||||
drawtype = "plantlike",
|
||||
visual_scale = 1.0,
|
||||
tiles = {"snow_sapling_pine.png"},
|
||||
inventory_image = "snow_sapling_pine.png",
|
||||
wield_image = "snow_sapling_pine.png",
|
||||
paramtype = "light",
|
||||
walkable = false,
|
||||
groups = {snappy=2,dig_immediate=3},
|
||||
sounds = default.node_sound_defaults(),
|
||||
|
||||
})
|
||||
|
||||
|
||||
|
||||
-- Star on Xmas Trees
|
||||
minetest.register_node("snow:star", {
|
||||
description = "Star",
|
||||
--drawtype = "torchlike",
|
||||
drawtype = "plantlike", -- Stars disappeared when viewed at the right angle. "Plantlike" solved the visual problem. ~ LazyJ
|
||||
tiles = {"snow_star.png"},
|
||||
inventory_image = "snow_star.png",
|
||||
wield_image = "snow_star.png",
|
||||
paramtype = "light",
|
||||
walkable = false,
|
||||
--groups = {snappy=2,dig_immediate=3},
|
||||
groups = {cracky=1, crumbly=1, choppy=1, oddly_breakable_by_hand=1}, -- Don't want the ornament breaking too easily because you have to punch it to turn it on and off. ~ LazyJ
|
||||
sounds = default.node_sound_glass_defaults({dig = {name="default_glass_footstep", gain=0.2}}), -- Breaking "glass" sound makes it sound like a real, broken, Xmas tree ornament (Sorry, Mom!). ;)- ~ LazyJ
|
||||
on_punch = function(pos, node) -- Added a "lit" star that can be punched on or off depending on your preference. ~ LazyJ
|
||||
node.name = "snow:star_lit"
|
||||
minetest.set_node(pos, node)
|
||||
nodeupdate(pos)
|
||||
end,
|
||||
})
|
||||
|
||||
|
||||
|
||||
-- Star (Lit Version) on Xmas Trees
|
||||
minetest.register_node("snow:star_lit", {
|
||||
description = "Star Lighted",
|
||||
drawtype = "plantlike",
|
||||
light_source = LIGHT_MAX,
|
||||
tiles = {"snow_star_lit.png"},
|
||||
wield_image = "snow_star.png",
|
||||
paramtype = "light",
|
||||
walkable = false,
|
||||
drop = "snow:star",
|
||||
groups = {cracky=1, crumbly=1, choppy=1, oddly_breakable_by_hand=1, not_in_creative_inventory=1},
|
||||
sounds = default.node_sound_glass_defaults({dig = {name="default_glass_footstep", gain=0.2}}),
|
||||
on_punch = function(pos, node)
|
||||
node.name = "snow:star"
|
||||
minetest.set_node(pos, node)
|
||||
nodeupdate(pos)
|
||||
end,
|
||||
})
|
||||
|
||||
|
||||
|
||||
-- Moss
|
||||
minetest.register_node("snow:moss", {
|
||||
description = "Moss",
|
||||
inventory_image = "snow_moss.png",
|
||||
tiles = {"snow_moss.png"},
|
||||
drawtype = "signlike",
|
||||
paramtype = "light",
|
||||
paramtype2 = "wallmounted",
|
||||
walkable = false,
|
||||
selection_box = {
|
||||
type = "wallmounted",
|
||||
},
|
||||
is_ground_content = true,
|
||||
groups = {crumbly=3, attached_node=1},
|
||||
})
|
||||
|
||||
|
||||
|
||||
local function snow_onto_dirt(pos)
|
||||
pos.y = pos.y - 1
|
||||
local node = minetest.get_node(pos)
|
||||
if node.name == "default:dirt_with_grass"
|
||||
or node.name == "default:dirt" then
|
||||
node.name = "default:dirt_with_snow"
|
||||
minetest.set_node(pos, node)
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
|
||||
-- Snow Brick
|
||||
minetest.register_node("snow:snow_brick", {
|
||||
description = "Snow Brick",
|
||||
tiles = {"snow_snow_brick.png"},
|
||||
is_ground_content = true,
|
||||
freezemelt = "default:water_source",
|
||||
liquidtype = "none",
|
||||
paramtype = "light",
|
||||
sunlight_propagates = true,
|
||||
paramtype2 = "facedir", -- Allow blocks to be rotated with the screwdriver or
|
||||
-- by player position. ~ LazyJ
|
||||
-- I made this a little harder to dig than snow blocks because
|
||||
-- I imagine snow brick as being much more dense and solid than fluffy snow. ~ LazyJ
|
||||
groups = {cracky=2, crumbly=2, choppy=2, oddly_breakable_by_hand=2, melts=1, icemaker=1, cooks_into_ice=1},
|
||||
--Let's use the new snow sounds instead of the old grass sounds. ~ LazyJ
|
||||
sounds = default.node_sound_dirt_defaults({
|
||||
footstep = {name="default_snow_footstep", gain=0.25},
|
||||
dig = {name="default_dig_crumbly", gain=0.4},
|
||||
dug = {name="default_snow_footstep", gain=0.75},
|
||||
place = {name="default_place_node", gain=1.0}
|
||||
}),
|
||||
-- The "on_construct" part below, thinking in terms of layers, dirt_with_snow could also
|
||||
-- double as dirt_with_frost which adds subtlety to the winterscape. ~ LazyJ
|
||||
on_construct = snow_onto_dirt
|
||||
})
|
||||
|
||||
|
||||
|
||||
-- Snow Cobble ~ LazyJ
|
||||
-- Described as Icy Snow
|
||||
minetest.register_node("snow:snow_cobble", {
|
||||
description = "Icy Snow",
|
||||
tiles = {"snow_snow_cobble.png"},
|
||||
is_ground_content = true,
|
||||
liquidtype = "none",
|
||||
paramtype = "light",
|
||||
sunlight_propagates = true,
|
||||
paramtype2 = "facedir",
|
||||
-- I made this a little harder to dig than snow blocks because
|
||||
-- I imagine snow brick as being much more dense and solid than fluffy snow. ~ LazyJ
|
||||
groups = {cracky=2, crumbly=2, choppy=2, oddly_breakable_by_hand=2, melts=1, icemaker=1, cooks_into_ice=1},
|
||||
sounds = default.node_sound_dirt_defaults({
|
||||
footstep = {name="default_snow_footstep", gain=0.25},
|
||||
dig = {name="default_dig_crumbly", gain=0.4},
|
||||
dug = {name="default_snow_footstep", gain=0.75},
|
||||
place = {name="default_place_node", gain=1.0}
|
||||
}),
|
||||
-- The "on_construct" part below, thinking in terms of layers, dirt_with_snow could also
|
||||
-- double as dirt_with_frost which adds subtlety to the winterscape. ~ LazyJ
|
||||
on_construct = snow_onto_dirt
|
||||
})
|
||||
|
||||
|
||||
|
||||
-- Override Default Nodes to Add Extra Functions
|
||||
|
||||
-- This adds code to the existing default ice. ~ LazyJ
|
||||
minetest.override_item("default:ice", {
|
||||
-- The Lines: 1. Alpah to make semi-transparent ice, 2 to work with
|
||||
-- the dirt_with_grass/snow/just dirt ABMs. ~ LazyJ, 2014_03_09
|
||||
use_texture_alpha = true, -- 1
|
||||
param2 = 0,
|
||||
--param2 is reserved for how much ice will freezeover.
|
||||
sunlight_propagates = true, -- 2
|
||||
drawtype = "glasslike",
|
||||
inventory_image = minetest.inventorycube("default_ice.png").."^[brighten",
|
||||
liquidtype = "none",
|
||||
-- I made this a lot harder to dig than snow blocks because ice is much more dense
|
||||
-- and solid than fluffy snow. ~ LazyJ
|
||||
groups = {cracky=2, crumbly=1, choppy=1, --[[oddly_breakable_by_hand=1,]] melts=1},
|
||||
on_construct = snow_onto_dirt,
|
||||
liquids_pointable = true,
|
||||
--Make ice freeze over when placed by a maximum of 10 blocks.
|
||||
after_place_node = function(pos)
|
||||
minetest.set_node(pos, {name="default:ice", param2=math.random(0,10)})
|
||||
end
|
||||
})
|
||||
|
||||
|
||||
|
||||
-- This adds code to the existing, default snowblock. ~ LazyJ
|
||||
minetest.override_item("default:snowblock", {
|
||||
liquidtype = "none", -- LazyJ to make dirt below change to dirt_with_snow (see default, nodes.lua, dirt ABM)
|
||||
paramtype = "light", -- LazyJ to make dirt below change to dirt_with_snow (see default, nodes.lua, dirt ABM)
|
||||
sunlight_propagates = true, -- LazyJ to make dirt below change to dirt_with_snow (see default, nodes.lua, dirt ABM)
|
||||
-- Snow blocks should be easy to dig because they are just fluffy snow. ~ LazyJ
|
||||
groups = {cracky=3, crumbly=3, choppy=3, oddly_breakable_by_hand=3, melts=1, icemaker=1, cooks_into_ice=1, falling_node=1},
|
||||
--drop = "snow:snow_cobble",
|
||||
on_construct = snow_onto_dirt
|
||||
-- Thinking in terms of layers, dirt_with_snow could also double as
|
||||
-- dirt_with_frost which adds subtlety to the winterscape. ~ LazyJ, 2014_04_04
|
||||
})
|
||||
231
mods/snow/src/sled.lua
Normal file
231
mods/snow/src/sled.lua
Normal file
@ -0,0 +1,231 @@
|
||||
--[[
|
||||
--=================
|
||||
--======================================
|
||||
LazyJ's Fork of Splizard's "Snow" Mod
|
||||
by LazyJ
|
||||
version: Umpteen and 7/5ths something or another.
|
||||
2014_04_12
|
||||
--======================================
|
||||
--=================
|
||||
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
THE LIST OF CHANGES I'VE MADE
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
|
||||
|
||||
* The HUD message that displayed when a player sat on the sled would not go away after the player
|
||||
got off the sled. I spent hours on trial-and-error while reading the lua_api.txt and scrounging
|
||||
the Internet for a needle-in-the-haystack solution as to why the hud_remove wasn't working.
|
||||
Turns out Splizard's code was mostly correct, just not assembled in the right order.
|
||||
|
||||
The key to the solution was found in the code of leetelate's scuba mod:
|
||||
http://forum.minetest.net/viewtopic.php?id=7175
|
||||
|
||||
* Changed the wording of the HUD message for clarity.
|
||||
|
||||
|
||||
~~~~~~
|
||||
TODO
|
||||
~~~~~~
|
||||
|
||||
* Figure out why the player avatars remain in a seated position, even after getting off the sled,
|
||||
if they flew while on the sled. 'default.player_set_animation', where is a better explanation
|
||||
for this and what are it's available options?
|
||||
|
||||
* Go through, clean-up my notes and get them better sorted. Some are in the code, some are
|
||||
scattered in my note-taking program. This "Oh, I'll just make a little tweak here and a
|
||||
little tweak there" project has evolved into something much bigger and more complex
|
||||
than I originally planned. :p ~ LazyJ
|
||||
|
||||
* find out why the sled disappears after rightclicking it ~ HybridDog
|
||||
|
||||
--]]
|
||||
|
||||
|
||||
|
||||
--=============================================================
|
||||
-- CODE STUFF
|
||||
--=============================================================
|
||||
|
||||
--
|
||||
-- Helper functions
|
||||
--
|
||||
|
||||
vector.zero = vector.zero or {x=0, y=0, z=0}
|
||||
|
||||
local function table_find(t, v)
|
||||
for i = 1,#t do
|
||||
if t[i] == v then
|
||||
return true
|
||||
end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
local function is_water(pos)
|
||||
return minetest.get_item_group(minetest.get_node(pos).name, "water") ~= 0
|
||||
end
|
||||
|
||||
|
||||
--
|
||||
-- Sled entity
|
||||
--
|
||||
|
||||
local sled = {
|
||||
physical = true,
|
||||
collisionbox = {-0.6,-0.25,-0.6, 0.6,0.3,0.6},
|
||||
visual = "mesh",
|
||||
mesh = "sled.x",
|
||||
textures = {"sled.png"},
|
||||
}
|
||||
|
||||
local players_sled = {}
|
||||
local function join_sled(self, player)
|
||||
local pos = self.object:getpos()
|
||||
player:setpos(pos)
|
||||
local name = player:get_player_name()
|
||||
players_sled[name] = true
|
||||
default.player_attached[name] = true
|
||||
default.player_set_animation(player, "sit" , 30)
|
||||
self.driver = name
|
||||
self.object:set_attach(player, "", {x=0,y=-9,z=0}, {x=0,y=90,z=0})
|
||||
self.object:setyaw(player:get_look_yaw())-- - math.pi/2)
|
||||
end
|
||||
|
||||
local function leave_sled(self, player)
|
||||
local name = player:get_player_name()
|
||||
players_sled[name] = false
|
||||
self.driver = nil
|
||||
player:set_detach()
|
||||
default.player_attached[name] = false
|
||||
default.player_set_animation(player, "stand" , 30)
|
||||
|
||||
player:set_physics_override({
|
||||
speed = 1,
|
||||
jump = 1,
|
||||
})
|
||||
player:hud_remove(self.HUD) -- And here is part 2. ~ LazyJ
|
||||
self.object:remove()
|
||||
|
||||
--Give the sled back again
|
||||
player:get_inventory():add_item("main", "snow:sled")
|
||||
end
|
||||
|
||||
function sled:on_rightclick(player)
|
||||
if self.driver
|
||||
or not snow.sleds then
|
||||
return
|
||||
end
|
||||
join_sled(self, player)
|
||||
player:set_physics_override({
|
||||
speed = 2, -- multiplier to default value
|
||||
jump = 0, -- multiplier to default value
|
||||
})
|
||||
|
||||
-- Here is part 1 of the fix. ~ LazyJ
|
||||
self.HUD = player:hud_add({
|
||||
hud_elem_type = "text",
|
||||
position = {x=0.5, y=0.89},
|
||||
name = "sled",
|
||||
scale = {x=2, y=2},
|
||||
text = "You are on the sled! Press the sneak key to get off the sled.", -- LazyJ
|
||||
direction = 0,
|
||||
})
|
||||
-- End part 1
|
||||
end
|
||||
|
||||
function sled:on_activate(staticdata, dtime_s)
|
||||
self.object:set_armor_groups({immortal=1})
|
||||
self.object:setacceleration({x=0, y=-10, z=0})
|
||||
if staticdata then
|
||||
self.v = tonumber(staticdata)
|
||||
end
|
||||
end
|
||||
|
||||
function sled:get_staticdata()
|
||||
return tostring(self.v)
|
||||
end
|
||||
|
||||
function sled:on_punch(puncher)
|
||||
self.object:remove()
|
||||
if puncher
|
||||
and puncher:is_player() then
|
||||
puncher:get_inventory():add_item("main", "snow:sled")
|
||||
end
|
||||
end
|
||||
|
||||
local driveable_nodes = {"default:snow","default:snowblock","default:ice","default:dirt_with_snow", "group:icemaker"}
|
||||
local function accelerating_possible(pos)
|
||||
if is_water(pos) then
|
||||
return false
|
||||
end
|
||||
if table_find(driveable_nodes, minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name) then
|
||||
return true
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
local timer = 0
|
||||
function sled:on_step(dtime)
|
||||
if not self.driver then
|
||||
return
|
||||
end
|
||||
timer = timer+dtime
|
||||
if timer < 1 then
|
||||
return
|
||||
end
|
||||
timer = 0
|
||||
local player = minetest.get_player_by_name(self.driver)
|
||||
if not player then
|
||||
return
|
||||
end
|
||||
if player:get_player_control().sneak
|
||||
or not accelerating_possible(vector.round(self.object:getpos())) then
|
||||
leave_sled(self, player)
|
||||
end
|
||||
end
|
||||
|
||||
minetest.register_entity("snow:sled", sled)
|
||||
|
||||
|
||||
minetest.register_craftitem("snow:sled", {
|
||||
description = "Sled",
|
||||
inventory_image = "snow_sled.png",
|
||||
wield_image = "snow_sled.png",
|
||||
wield_scale = {x=2, y=2, z=1},
|
||||
liquids_pointable = true,
|
||||
stack_max = 1,
|
||||
|
||||
on_use = function(itemstack, placer)
|
||||
if players_sled[placer:get_player_name()] then
|
||||
return
|
||||
end
|
||||
local pos = placer:getpos()
|
||||
if accelerating_possible(vector.round(pos)) then
|
||||
pos.y = pos.y+0.5
|
||||
|
||||
--Get on the sled and remove it from inventory.
|
||||
minetest.add_entity(pos, "snow:sled"):right_click(placer)
|
||||
itemstack:take_item(); return itemstack
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "snow:sled",
|
||||
recipe = {
|
||||
{"", "", ""},
|
||||
{"group:stick", "", ""},
|
||||
{"group:wood", "group:wood", "group:wood"},
|
||||
},
|
||||
})
|
||||
minetest.register_craft({
|
||||
output = "snow:sled",
|
||||
recipe = {
|
||||
{"", "", ""},
|
||||
{"", "", "group:stick"},
|
||||
{"group:wood", "group:wood", "group:wood"},
|
||||
},
|
||||
})
|
||||
345
mods/snow/src/snowball.lua
Normal file
345
mods/snow/src/snowball.lua
Normal file
@ -0,0 +1,345 @@
|
||||
--============
|
||||
--Snowballs
|
||||
--============
|
||||
|
||||
-- Snowballs were destroying nodes if the snowballs landed just right.
|
||||
-- Quite a bit of trial-and-error learning here and it boiled down to a
|
||||
-- small handful of code lines making the difference. ~ LazyJ
|
||||
|
||||
local creative_mode = minetest.setting_getbool("creative_mode")
|
||||
|
||||
local function get_gravity()
|
||||
local grav = tonumber(minetest.setting_get("movement_gravity")) or 9.81
|
||||
return grav*snow.snowball_gravity
|
||||
end
|
||||
|
||||
local someone_throwing
|
||||
local timer = 0
|
||||
|
||||
--Shoot snowball
|
||||
local function snow_shoot_snowball(item, player)
|
||||
local addp = {y = 1.625} -- + (math.random()-0.5)/5}
|
||||
local dir = player:get_look_dir()
|
||||
local dif = 2*math.sqrt(dir.z*dir.z+dir.x*dir.x)
|
||||
addp.x = dir.z/dif -- + (math.random()-0.5)/5
|
||||
addp.z = -dir.x/dif -- + (math.random()-0.5)/5
|
||||
local pos = vector.add(player:getpos(), addp)
|
||||
local obj = minetest.add_entity(pos, "snow:snowball_entity")
|
||||
obj:setvelocity(vector.multiply(dir, snow.snowball_velocity))
|
||||
obj:setacceleration({x=dir.x*-3, y=-get_gravity(), z=dir.z*-3})
|
||||
if creative_mode then
|
||||
if not someone_throwing then
|
||||
someone_throwing = true
|
||||
timer = -0.5
|
||||
end
|
||||
return
|
||||
end
|
||||
item:take_item()
|
||||
return item
|
||||
end
|
||||
|
||||
if creative_mode then
|
||||
local function update_step(dtime)
|
||||
timer = timer+dtime
|
||||
if timer < 0.006 then
|
||||
return
|
||||
end
|
||||
timer = 0
|
||||
|
||||
local active
|
||||
for _,player in pairs(minetest.get_connected_players()) do
|
||||
if player:get_player_control().LMB then
|
||||
local item = player:get_wielded_item()
|
||||
local itemname = item:get_name()
|
||||
if itemname == "default:snow" then
|
||||
snow_shoot_snowball(nil, player)
|
||||
active = true
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- disable the function if noone currently throws them
|
||||
if not active then
|
||||
someone_throwing = false
|
||||
end
|
||||
end
|
||||
|
||||
-- do automatic throwing using a globalstep
|
||||
minetest.register_globalstep(function(dtime)
|
||||
-- only if one holds left click
|
||||
if someone_throwing then
|
||||
update_step(dtime)
|
||||
end
|
||||
end)
|
||||
end
|
||||
|
||||
--The snowball Entity
|
||||
local snow_snowball_ENTITY = {
|
||||
physical = false,
|
||||
timer = 0,
|
||||
collisionbox = {-5/16,-5/16,-5/16, 5/16,5/16,5/16},
|
||||
}
|
||||
|
||||
function snow_snowball_ENTITY.on_activate(self)
|
||||
self.object:set_properties({textures = {"default_snowball.png^[transform"..math.random(0,7)}})
|
||||
self.object:setacceleration({x=0, y=-get_gravity(), z=0})
|
||||
self.lastpos = self.object:getpos()
|
||||
minetest.after(0.1, function(obj)
|
||||
if not obj then
|
||||
return
|
||||
end
|
||||
local vel = obj:getvelocity()
|
||||
if vel
|
||||
and vel.y ~= 0 then
|
||||
return
|
||||
end
|
||||
minetest.after(0, function(obj)
|
||||
if not obj then
|
||||
return
|
||||
end
|
||||
local vel = obj:getvelocity()
|
||||
if not vel
|
||||
or vel.y == 0 then
|
||||
obj:remove()
|
||||
end
|
||||
end, obj)
|
||||
end, self.object)
|
||||
end
|
||||
|
||||
--Snowball_entity.on_step()--> called when snowball is moving.
|
||||
function snow_snowball_ENTITY.on_step(self, dtime)
|
||||
self.timer = self.timer+dtime
|
||||
if self.timer > 600 then
|
||||
-- 10 minutes are too long for a snowball to fly somewhere
|
||||
self.object:remove()
|
||||
end
|
||||
|
||||
if self.physical then
|
||||
local fell = self.object:getvelocity().y == 0
|
||||
if not fell then
|
||||
return
|
||||
end
|
||||
local pos = vector.round(self.object:getpos())
|
||||
if minetest.get_node(pos).name == "air" then
|
||||
pos.y = pos.y-1
|
||||
if minetest.get_node(pos).name == "air" then
|
||||
return
|
||||
end
|
||||
end
|
||||
snow.place(pos)
|
||||
self.object:remove()
|
||||
return
|
||||
end
|
||||
|
||||
local pos = vector.round(self.object:getpos())
|
||||
if vector.equals(pos, self.lastpos) then
|
||||
return
|
||||
end
|
||||
if minetest.get_node(pos).name ~= "air" then
|
||||
self.object:setacceleration({x=0, y=-get_gravity(), z=0})
|
||||
--self.object:setvelocity({x=0, y=0, z=0})
|
||||
pos = self.lastpos
|
||||
self.object:setpos(pos)
|
||||
local gain = vector.length(self.object:getvelocity())/30
|
||||
minetest.sound_play("default_snow_footstep", {pos=pos, gain=gain})
|
||||
self.object:set_properties({physical = true})
|
||||
self.physical = true
|
||||
return
|
||||
end
|
||||
self.lastpos = vector.new(pos)
|
||||
end
|
||||
|
||||
|
||||
|
||||
minetest.register_entity("snow:snowball_entity", snow_snowball_ENTITY)
|
||||
|
||||
|
||||
|
||||
-- Snowball and Default Snowball Merged
|
||||
|
||||
-- They both look the same, they do basically the same thing (except one is a leftclick throw
|
||||
-- and the other is a rightclick drop),... Why not combine snow:snowball with default:snow and
|
||||
-- benefit from both? ~ LazyJ, 2014_04_08
|
||||
|
||||
--[[ Save this for reference and occasionally compare to the default code for any updates.
|
||||
|
||||
minetest.register_node(":default:snow", {
|
||||
description = "Snow",
|
||||
tiles = {"default_snow.png"},
|
||||
inventory_image = "default_snowball.png",
|
||||
wield_image = "default_snowball.png",
|
||||
is_ground_content = true,
|
||||
paramtype = "light",
|
||||
buildable_to = true,
|
||||
leveled = 7,
|
||||
drawtype = "nodebox",
|
||||
freezemelt = "default:water_flowing",
|
||||
node_box = {
|
||||
type = "leveled",
|
||||
fixed = {
|
||||
{-0.5, -0.5, -0.5, 0.5, -0.5+2/16, 0.5},
|
||||
},
|
||||
},
|
||||
groups = {crumbly=3,falling_node=1, melts=1, float=1},
|
||||
sounds = default.node_sound_dirt_defaults({
|
||||
footstep = {name="default_snow_footstep", gain=0.25},
|
||||
dug = {name="default_snow_footstep", gain=0.75},
|
||||
}),
|
||||
on_construct = function(pos)
|
||||
if minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "default:dirt_with_grass" or minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "default:dirt" then
|
||||
minetest.set_node({x=pos.x, y=pos.y-1, z=pos.z}, {name="default:dirt_with_snow"})
|
||||
end
|
||||
-- Now, let's turn the snow pile into a snowblock. ~ LazyJ
|
||||
if minetest.get_node({x=pos.x, y=pos.y-2, z=pos.z}).name == "default:snow" and -- Minus 2 because at the end of this, the layer that triggers the change to a snowblock is the second layer more than a full block, starting into a second block (-2) ~ LazyJ, 2014_04_11
|
||||
minetest.get_node({x=pos.x, y=pos.y, z=pos.z}).name == "default:snow" then
|
||||
minetest.set_node({x=pos.x, y=pos.y-2, z=pos.z}, {name="default:snowblock"})
|
||||
end
|
||||
end,
|
||||
on_use = snow_shoot_snowball -- This line is from the 'Snow' mod, the reset is default Minetest.
|
||||
})
|
||||
--]]
|
||||
|
||||
|
||||
|
||||
minetest.override_item("default:snow", {
|
||||
drop = {
|
||||
max_items = 2,
|
||||
items = {
|
||||
{items = {'snow:moss'}, rarity = 20,},
|
||||
{items = {'default:snow'},}
|
||||
}
|
||||
},
|
||||
leveled = 7,
|
||||
node_box = {
|
||||
type = "leveled",
|
||||
fixed = {
|
||||
{-0.5, -0.5, -0.5, 0.5, -0.5, 0.5},
|
||||
},
|
||||
},
|
||||
groups = {cracky=3, crumbly=3, choppy=3, oddly_breakable_by_hand=3, falling_node=1, melts=2, float=1},
|
||||
sunlight_propagates = true,
|
||||
--Disable placement prediction for snow.
|
||||
node_placement_prediction = "",
|
||||
on_construct = function(pos)
|
||||
pos.y = pos.y-1
|
||||
local node = minetest.get_node(pos)
|
||||
if node.name == "default:dirt_with_grass"
|
||||
or node.name == "default:dirt" then
|
||||
node.name = "default:dirt_with_snow"
|
||||
minetest.set_node(pos, node)
|
||||
end
|
||||
end,
|
||||
--Handle node drops due to node level.
|
||||
on_dig = function(pos, node, digger)
|
||||
local level = minetest.get_node_level(pos)
|
||||
minetest.node_dig(pos, node, digger)
|
||||
if minetest.get_node(pos).name ~= node.name then
|
||||
local inv = digger:get_inventory()
|
||||
if not inv then
|
||||
return
|
||||
end
|
||||
local left = inv:add_item("main", "default:snow "..tostring(level/7-1))
|
||||
if not left:is_empty() then
|
||||
minetest.add_item({
|
||||
x = pos.x + math.random()/2-0.25,
|
||||
y = pos.y + math.random()/2-0.25,
|
||||
z = pos.z + math.random()/2-0.25,
|
||||
}, left)
|
||||
end
|
||||
end
|
||||
end,
|
||||
--Manage snow levels.
|
||||
on_place = function(itemstack, placer, pointed_thing)
|
||||
local under = pointed_thing.under
|
||||
local oldnode_under = minetest.get_node_or_nil(under)
|
||||
local above = pointed_thing.above
|
||||
|
||||
if not oldnode_under
|
||||
or not above then
|
||||
return
|
||||
end
|
||||
|
||||
local olddef_under = ItemStack({name=oldnode_under.name}):get_definition()
|
||||
olddef_under = olddef_under or minetest.nodedef_default
|
||||
|
||||
local place_to
|
||||
-- If node under is buildable_to, place into it instead (eg. snow)
|
||||
if olddef_under.buildable_to then
|
||||
place_to = under
|
||||
else
|
||||
-- Place above pointed node
|
||||
place_to = above
|
||||
end
|
||||
|
||||
local level = minetest.get_node_level(place_to)
|
||||
if level == 63 then
|
||||
minetest.set_node(place_to, {name="default:snowblock"})
|
||||
else
|
||||
minetest.set_node_level(place_to, level+7)
|
||||
end
|
||||
|
||||
if minetest.get_node(place_to).name ~= "default:snow" then
|
||||
local itemstack, placed = minetest.item_place_node(itemstack, placer, pointed_thing)
|
||||
return itemstack, placed
|
||||
end
|
||||
|
||||
itemstack:take_item()
|
||||
|
||||
return itemstack
|
||||
end,
|
||||
on_use = snow_shoot_snowball
|
||||
})
|
||||
|
||||
|
||||
|
||||
--[[
|
||||
A note about default torches, melting, and "buildable_to = true" in default snow.
|
||||
|
||||
On servers where buckets are disabled, snow and ice stuff is used to set water for crops and
|
||||
water stuff like fountains, pools, ponds, ect.. It is a common practice to set a default torch on
|
||||
the snow placed where the players want water to be.
|
||||
|
||||
If you place a default torch *on* default snow to melt it, instead of melting the snow is
|
||||
*replaced* by the torch. Using "buildable_to = false" would fix this but then the snow would no
|
||||
longer pile-up in layers; the snow would stack like thin shelves in a vertical column.
|
||||
|
||||
I tinkered with the default torch's code (see below) to check for snow at the position and one
|
||||
node above (layered snow logs as the next y position above) but default snow's
|
||||
"buildable_to = true" always happened first. An interesting exercise to better learn how Minetest
|
||||
works, but otherwise not worth it. If you set a regular torch near snow, the snow will melt
|
||||
and disappear leaving you with nearly the same end result anyway. I say "nearly the same"
|
||||
because if you set a default torch on layered snow, the torch will replace the snow and be
|
||||
lit on the ground. If you were able to set a default torch *on* layered snow, the snow would
|
||||
melt and the torch would become a dropped item.
|
||||
|
||||
~ LazyJ
|
||||
|
||||
--]]
|
||||
|
||||
|
||||
-- Some of the ideas I tried. ~ LazyJ
|
||||
--[[
|
||||
local can_place_torch_on_top = function(pos)
|
||||
if minetest.get_node({x=pos.x, y=pos.y, z=pos.z}).name == "default:snow"
|
||||
or minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name == "default:snow" then
|
||||
minetest.override_item("default:snow", {buildable_to = false,})
|
||||
end
|
||||
end
|
||||
--]]
|
||||
|
||||
|
||||
--[[
|
||||
minetest.override_item("default:torch", {
|
||||
--on_construct = function(pos)
|
||||
on_place = function(itemstack, placer, pointed_thing)
|
||||
--if minetest.get_node({x=pos.x, y=pos.y, z=pos.z}).name == "default:snow"
|
||||
-- Even though layered snow doesn't look like it's in the next position above (y+1)
|
||||
-- it registers in that position. Check the terminal's output to see the coord change.
|
||||
--or minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name == "default:snow"
|
||||
if pointed_thing.name == "default:snow"
|
||||
then minetest.set_node({x=pos.x, y=pos.y+1, z=pos.z}, {name="default:torch"})
|
||||
end
|
||||
end
|
||||
})
|
||||
--]]
|
||||
342
mods/snow/src/stairsplus.lua
Normal file
342
mods/snow/src/stairsplus.lua
Normal file
@ -0,0 +1,342 @@
|
||||
-- ===============================================================================
|
||||
-- StairsPlus Bonus!
|
||||
-- ===============================================================================
|
||||
--[[
|
||||
This section of code that makes blocks compatible with MoreBlocks' circular saw.
|
||||
I've added circular saw compatible code for default snowblocks and ice. :D
|
||||
A big thanks to Calinou and ShadowNinja for making this possible.
|
||||
|
||||
Because StairsPlus creates partial blocks, it didn't seem quite right that the
|
||||
smallest microblocks would produce a full-sized water_source node when melted.
|
||||
So I toned them down a bit by changing their melt to a temporary,
|
||||
2-second water_source. See "melts" in abms.lua file for the various intensities.
|
||||
|
||||
___...::: ATTENTION MINETEST SERVER OPERATORS :::...___
|
||||
You may or may not have noticed in your server logs that MoreBlocks stairs/slabs/
|
||||
panels/microblocks are not recorded as to when, who, what, and where. This is
|
||||
important information when trying to determine if a player who dug these blocks
|
||||
is the owner (the player who placed the block) or is a griefer stealing the block.
|
||||
|
||||
There is an option that will log when these blocks are placed but it comes at the
|
||||
cost of losing the auto-rotation of those blocks when placed. They can still be
|
||||
rotated with a screwdriver but if screwdrivers are disabled on your server your
|
||||
players won't be able to position MoreBlocks, saw-made blocks.
|
||||
|
||||
To enable logging the placement of these blocks, un-comment these lines:
|
||||
|
||||
--on_place = minetest.item_place
|
||||
|
||||
There is one in each of the "stairsplus.register_all" sections.
|
||||
|
||||
~ LazyJ
|
||||
-- ===============================================================================
|
||||
--]]
|
||||
|
||||
--snow_stairsplus = {}
|
||||
|
||||
-- Check for infinite stacks
|
||||
|
||||
--if minetest.get_modpath("unified_inventory") or not minetest.setting_getbool("creative_mode") then
|
||||
-- snow_stairsplus.expect_infinite_stacks = false
|
||||
--else
|
||||
-- snow_stairsplus.expect_infinite_stacks = true
|
||||
--end
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
-- First, let's run a check to see if MoreBlocks is installed; we're going to need it for the
|
||||
-- next section of stairsplus stuff. ~LazyJ
|
||||
|
||||
if (minetest.get_modpath("moreblocks"))
|
||||
and rawget(_G, "stairsplus")
|
||||
|
||||
-- 'If' MoreBlocks was found and stairsplus is available, well, 'then' go ahead with this next part:
|
||||
|
||||
then
|
||||
|
||||
--[[ Leave commented out - For reference only. ~ LazyJ
|
||||
function stairsplus.register_all(modname, subname, recipeitem, fields)
|
||||
--stairsplus.register_stair_slab_panel_micro(modname, subname, recipeitem, fields)
|
||||
stairsplus:register_stair(modname, subname, recipeitem, fields)
|
||||
stairsplus:register_slab(modname, subname, recipeitem, fields)
|
||||
stairsplus:register_panel(modname, subname, recipeitem, fields)
|
||||
stairsplus:register_micro(modname, subname, recipeitem, fields)
|
||||
end
|
||||
Leave commented out
|
||||
--]]
|
||||
|
||||
|
||||
|
||||
-- Leave commented out. Another, possible piece of the puzzle, as to why the placement of
|
||||
-- stairsplus nodes aren't recorded in the logs. Shelved till I can concentrate on it again.
|
||||
-- ~ LazyJ
|
||||
|
||||
--ItemStack({name=nodename}):get_definition()
|
||||
--itemstack ={}
|
||||
--[[
|
||||
local def = itemstack:get_definition()
|
||||
function minetest.item_place_node(itemstack, placer, pointed_thing, param2)
|
||||
minetest.log("action", placer:get_player_name() .. " places node "
|
||||
.. def.name .. " at " .. minetest.pos_to_string(place_to))
|
||||
end
|
||||
Leave commented out
|
||||
--]]
|
||||
|
||||
|
||||
-- Leave commented out
|
||||
--[[ FIGURE OUT HOW TO GET THE SLABS TO SHOW UP IN THE LOG ON PLACEMENT
|
||||
|
||||
|
||||
on_place = function(itemstack, placer, pointed_thing)
|
||||
if pointed_thing.type ~= "node" then
|
||||
return itemstack
|
||||
end
|
||||
|
||||
-- If it's being placed on an another similar one, replace it with
|
||||
-- a full block
|
||||
local slabpos = nil
|
||||
local slabnode = nil
|
||||
local p0 = pointed_thing.under
|
||||
local p1 = pointed_thing.above
|
||||
local n0 = minetest.get_node(p0)
|
||||
local n1 = minetest.get_node(p1)
|
||||
local param2 = 0
|
||||
|
||||
local n0_is_upside_down = (n0.name == "snow:slab_" .. subname and
|
||||
n0.param2 >= 20)
|
||||
|
||||
if n0.name == "snow:slab_" .. subname and not n0_is_upside_down and p0.y+1 == p1.y then
|
||||
slabpos = p0
|
||||
slabnode = n0
|
||||
elseif n1.name == "snow:slab_" .. subname then
|
||||
slabpos = p1
|
||||
slabnode = n1
|
||||
end
|
||||
if slabpos then
|
||||
-- Remove the slab at slabpos
|
||||
minetest.remove_node(slabpos)
|
||||
-- Make a fake stack of a single item and try to place it
|
||||
local fakestack = ItemStack(recipeitem)
|
||||
fakestack:set_count(itemstack:get_count())
|
||||
|
||||
pointed_thing.above = slabpos
|
||||
local success
|
||||
fakestack, success = minetest.item_place(fakestack, placer, pointed_thing)
|
||||
-- If the item was taken from the fake stack, decrement original
|
||||
if success then
|
||||
itemstack:set_count(fakestack:get_count())
|
||||
-- Else put old node back
|
||||
else
|
||||
minetest.set_node(slabpos, slabnode)
|
||||
end
|
||||
return itemstack
|
||||
end
|
||||
|
||||
-- Upside down slabs
|
||||
if p0.y-1 == p1.y then
|
||||
-- Turn into full block if pointing at a existing slab
|
||||
if n0_is_upside_down then
|
||||
-- Remove the slab at the position of the slab
|
||||
minetest.remove_node(p0)
|
||||
-- Make a fake stack of a single item and try to place it
|
||||
local fakestack = ItemStack(recipeitem)
|
||||
fakestack:set_count(itemstack:get_count())
|
||||
|
||||
pointed_thing.above = p0
|
||||
local success
|
||||
fakestack, success = minetest.item_place(fakestack, placer, pointed_thing)
|
||||
-- If the item was taken from the fake stack, decrement original
|
||||
if success then
|
||||
itemstack:set_count(fakestack:get_count())
|
||||
-- Else put old node back
|
||||
else
|
||||
minetest.set_node(p0, n0)
|
||||
end
|
||||
return itemstack
|
||||
end
|
||||
|
||||
-- Place upside down slab
|
||||
param2 = 20
|
||||
end
|
||||
|
||||
-- If pointing at the side of a upside down slab
|
||||
if n0_is_upside_down and p0.y+1 ~= p1.y then
|
||||
param2 = 20
|
||||
end
|
||||
|
||||
return minetest.item_place(itemstack, placer, pointed_thing, param2)
|
||||
end
|
||||
Leave commented out
|
||||
--]]
|
||||
|
||||
|
||||
|
||||
--[[
|
||||
Below, in the "groups" line there is a "melts" category. Back in the ABMs lua file, melting
|
||||
code, melts=1 will produce a water_source when the full-sized snow/ice block is melted making
|
||||
a big, watery mess. melts=2 will produce a water_source only for a moment, then it changes back
|
||||
to water_flowing and then dries-up and disappears. I gave these stairs/slabs/panels/microblocks
|
||||
a melts value of 2 instead of 1 because they are not full blocks.
|
||||
|
||||
~ LazyJ
|
||||
--]]
|
||||
|
||||
-- Default snowblock and ice stairs/slabs/panels/microblocks.
|
||||
|
||||
local ndef = minetest.registered_nodes["default:ice"]
|
||||
local groups = {}
|
||||
for k, v in pairs(ndef.groups) do groups[k] = v end
|
||||
|
||||
stairsplus:register_all("moreblocks", "ice", "default:ice", {
|
||||
description = ndef.description,
|
||||
paramtype2 = "facedir",
|
||||
-- Added "icemaker=1" in groups. This ties into the freezing
|
||||
-- function in the ABMs.lua file. ~ LazyJ
|
||||
groups = {cracky=1, crumbly=1, choppy=1, oddly_breakable_by_hand=1, melts=2, icemaker=1},
|
||||
sounds = default.node_sound_glass_defaults(),
|
||||
tiles = ndef.tiles,
|
||||
-- Because of the "use_texture_alpha" line, that gives ice transparency, I couldn't combine
|
||||
-- default ice and default snowblocks in a list like MoreBlocks does. ~ LazyJ
|
||||
use_texture_alpha = true,
|
||||
sunlight_propagates = true,
|
||||
-- This "on_place" line makes placing these nodes recorded in the logs.
|
||||
-- Useful for investigating griefings and determining ownership
|
||||
-- BUT these nodes will nolonger auto-rotate into position. ~ LazyJ
|
||||
|
||||
--on_place = minetest.item_place,
|
||||
|
||||
-- The "on_construct" part below, thinking in terms of layers, dirt_with_snow could
|
||||
-- also double as dirt_with_frost which adds subtlety to the winterscape. ~ LazyJ
|
||||
on_construct = function(pos)
|
||||
pos.y = pos.y - 1
|
||||
if minetest.get_node(pos).name == "default:dirt_with_grass"
|
||||
or minetest.get_node(pos).name == "default:dirt" then
|
||||
minetest.set_node(pos, {name="default:dirt_with_snow"})
|
||||
end
|
||||
end
|
||||
})
|
||||
--end
|
||||
|
||||
|
||||
local ndef = minetest.registered_nodes["default:snowblock"]
|
||||
local groups = {}
|
||||
for k, v in pairs(ndef.groups) do groups[k] = v end
|
||||
|
||||
stairsplus:register_all("moreblocks", "snowblock", "default:snowblock", {
|
||||
description = ndef.description,
|
||||
paramtype2 = "facedir",
|
||||
-- Added "icemaker=1" in groups. This ties into the freezing function
|
||||
-- in the ABMs.lua file. ~ LazyJ
|
||||
groups = {cracky=3, crumbly=3, choppy=3, oddly_breakable_by_hand=3, melts=2, icemaker=1},
|
||||
tiles = ndef.tiles,
|
||||
sunlight_propagates = true,
|
||||
sounds = default.node_sound_dirt_defaults({
|
||||
footstep = {name="default_snow_footstep", gain=0.25},
|
||||
dig = {name="default_dig_crumbly", gain=0.4},
|
||||
dug = {name="default_snow_footstep", gain=0.75},
|
||||
place = {name="default_place_node", gain=1.0}
|
||||
}),
|
||||
-- This "on_place" line makes placing these nodes recorded in the logs.
|
||||
-- Useful for investigating griefings and determining ownership
|
||||
-- BUT these nodes will nolonger auto-rotate into position. ~ LazyJ
|
||||
|
||||
--on_place = minetest.item_place,
|
||||
|
||||
-- The "on_construct" part below, thinking in terms of layers,
|
||||
-- dirt_with_snow could also double as dirt_with_frost
|
||||
-- which adds subtlety to the winterscape. ~ LazyJ
|
||||
on_construct = function(pos)
|
||||
pos.y = pos.y - 1
|
||||
if minetest.get_node(pos).name == "default:dirt_with_grass"
|
||||
or minetest.get_node(pos).name == "default:dirt" then
|
||||
minetest.set_node(pos, {name="default:dirt_with_snow"})
|
||||
end
|
||||
end
|
||||
})
|
||||
|
||||
|
||||
|
||||
-- Snow stairs/slabs/panels/microblocks.
|
||||
|
||||
local snow_nodes = {
|
||||
"snow_brick",
|
||||
"snow_cobble",
|
||||
}
|
||||
|
||||
for _, name in pairs(snow_nodes) do
|
||||
local nodename = "snow:"..name
|
||||
local ndef = minetest.registered_nodes[nodename]
|
||||
local groups = {}
|
||||
for k, v in pairs(ndef.groups) do groups[k] = v end
|
||||
|
||||
stairsplus:register_all("moreblocks", name, nodename, {
|
||||
description = ndef.description,
|
||||
drop = drop,
|
||||
groups = {cracky=2, crumbly=2, choppy=2, oddly_breakable_by_hand=2, melts=2, icemaker=1},
|
||||
tiles = ndef.tiles,
|
||||
--paramtype2 = "facedir",
|
||||
sunlight_propagates = true,
|
||||
sounds = default.node_sound_dirt_defaults({
|
||||
footstep = {name="default_snow_footstep", gain=0.25},
|
||||
dig = {name="default_dig_crumbly", gain=0.4},
|
||||
dug = {name="default_snow_footstep", gain=0.75},
|
||||
place = {name="default_place_node", gain=1.0}
|
||||
}),
|
||||
-- This "on_place" line makes placing these nodes recorded in the logs.
|
||||
-- Useful for investigating griefings and determining ownership
|
||||
-- BUT these nodes will nolonger auto-rotate into position. ~ LazyJ
|
||||
|
||||
--on_place = minetest.item_place,
|
||||
|
||||
|
||||
-- Some attempts to have both, the recording in the logs of the placing of
|
||||
-- the stairplus stuff *and* have the auto-rotation work. No luck yet.
|
||||
-- ~ LazyJ
|
||||
|
||||
--[[
|
||||
on_place = function (i, p, t)
|
||||
minetest.item_place(i, p, t, 0)
|
||||
minetest.rotate_node(i, p, t)
|
||||
end,
|
||||
--]]
|
||||
--[[
|
||||
on_place = function (i, p, t)
|
||||
minetest.rotate_node(i, p, t, 0)
|
||||
minetest.item_place(i, p, t)
|
||||
end,
|
||||
--]]
|
||||
|
||||
|
||||
|
||||
-- Picking up were we left off... ~ LazyJ
|
||||
|
||||
-- The "on_construct" part below, thinking in terms of layers, dirt_with_snow could
|
||||
-- also double as dirt_with_frost which adds subtlety to the winterscape. ~ LazyJ
|
||||
on_construct = function(pos)
|
||||
pos.y = pos.y - 1
|
||||
if minetest.get_node(pos).name == "default:dirt_with_grass"
|
||||
or minetest.get_node(pos).name == "default:dirt"
|
||||
then minetest.set_node(pos, {name="default:dirt_with_snow"})
|
||||
end
|
||||
-- Some ideas I've tried. Leaving for future reference till I can figure out a workable solution. ~ LazyJ
|
||||
--minetest.log("action", sender:get_player_name().." places" ..minetest.get_node(pos).name.. "at" ..minetest.pos_to_string(pos))
|
||||
--minetest.log("action", minetest.get_player_name().." places" ..minetest.get_node(pos).name.. "at" ..minetest.pos_to_string(pos))
|
||||
--minetest.log("action", "BINGO places "..minetest.get_name().." at "..minetest.pos_to_string(pos))
|
||||
--minetest.log("action", minetest.get_player_name().." places "..minetest.get_name().." at "..minetest.pos_to_string(pos))
|
||||
--minetest.log("action", placer:get_player_name().." places moreblocks-something at "..minetest.pos_to_string(pos))
|
||||
--minetest.log("action", " BINGO places "..minetest.get_pointed_thing().." at "..minetest.pos_to_string(pos))
|
||||
--minetest.log("action", "BINGO places moreblocks"..ndef.." at "..minetest.pos_to_string(pos))
|
||||
--minetest.log("action", "A pine sapling grows into a Christmas tree at "..minetest.pos_to_string(pos))
|
||||
--return minetest.item_place(itemstack, placer, pointed_thing, param2)
|
||||
--return minetest.item_place(itemstack, pointed_thing, param2)
|
||||
end,
|
||||
})
|
||||
end
|
||||
|
||||
else -- from clear up at the top, the MoreBlocks check. "Else", if MoreBlocks wasn't found, skip
|
||||
-- down to here, "return" nothing and "end" this script. ~ LazyJ
|
||||
return
|
||||
end
|
||||
156
mods/snow/src/util.lua
Normal file
156
mods/snow/src/util.lua
Normal file
@ -0,0 +1,156 @@
|
||||
--Global config and function table.
|
||||
snow = {
|
||||
snowball_gravity = 100/109,
|
||||
snowball_velocity = 19,
|
||||
sleds = true,
|
||||
enable_snowfall = true,
|
||||
lighter_snowfall = false,
|
||||
debug = false,
|
||||
smooth_biomes = true,
|
||||
christmas_content = true,
|
||||
smooth_snow = true,
|
||||
min_height = 3,
|
||||
}
|
||||
|
||||
--Config documentation.
|
||||
local doc = {
|
||||
snowball_gravity = "The gravity of thrown snowballs",
|
||||
snowball_velocity = "How fast players throw snowballs",
|
||||
sleds = "Disable this to prevent sleds from being riden.",
|
||||
enable_snowfall = "Enables falling snow.",
|
||||
lighter_snowfall = "Reduces the amount of resources and fps used by snowfall.",
|
||||
debug = "Enables debug output. Currently it only prints mgv6 info.",
|
||||
smooth_biomes = "Enables smooth transition of biomes (mgv6)",
|
||||
smooth_snow = "Disable this to stop snow from being smoothed.",
|
||||
christmas_content = "Disable this to remove christmas saplings from being found.",
|
||||
min_height = "The minumum height a snow biome will generate (mgv7)",
|
||||
}
|
||||
|
||||
--Manage config.
|
||||
--Saves contents of config to file.
|
||||
local function saveConfig(path, config, doc)
|
||||
local file = io.open(path,"w")
|
||||
if file then
|
||||
for i,v in pairs(config) do
|
||||
local t = type(v)
|
||||
if t == "string" or t == "number" or t == "boolean" then
|
||||
if doc and doc[i] then
|
||||
file:write("# "..doc[i].."\n")
|
||||
end
|
||||
file:write(i.." = "..tostring(v).."\n")
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
--Loads config and returns config values inside table.
|
||||
local function loadConfig(path)
|
||||
local config = {}
|
||||
local file = io.open(path,"r")
|
||||
if file then
|
||||
io.close(file)
|
||||
for line in io.lines(path) do
|
||||
if line:sub(1,1) ~= "#" then
|
||||
local i, v = line:match("^(%S*) = (%S*)")
|
||||
if i and v then
|
||||
if v == "true" then v = true end
|
||||
if v == "false" then v = false end
|
||||
if tonumber(v) then v = tonumber(v) end
|
||||
config[i] = v
|
||||
end
|
||||
end
|
||||
end
|
||||
return config
|
||||
else
|
||||
--Create config file.
|
||||
return nil
|
||||
end
|
||||
end
|
||||
|
||||
minetest.register_on_shutdown(function()
|
||||
saveConfig(minetest.get_modpath("snow").."/config.txt", snow, doc)
|
||||
end)
|
||||
|
||||
local config = loadConfig(minetest.get_modpath("snow").."/config.txt")
|
||||
if config then
|
||||
for i,v in pairs(config) do
|
||||
if type(snow[i]) == type(v) then
|
||||
snow[i] = v
|
||||
end
|
||||
end
|
||||
else
|
||||
saveConfig(minetest.get_modpath("snow").."/config.txt", snow, doc)
|
||||
end
|
||||
|
||||
for i,v in pairs(snow) do
|
||||
local t = type(v)
|
||||
if t == "string"
|
||||
or t == "number"
|
||||
or t == "boolean" then
|
||||
local v = minetest.setting_get("snow_"..i)
|
||||
if v ~= nil then
|
||||
if v == "true" then v = true end
|
||||
if v == "false" then v = false end
|
||||
if tonumber(v) then v = tonumber(v) end
|
||||
snow[i] = v
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
--MENU
|
||||
|
||||
local get_formspec = function()
|
||||
local p = -0.5
|
||||
local formspec = "label[0,-0.3;Settings:]"
|
||||
for i,v in pairs(snow) do
|
||||
local t = type(v)
|
||||
if t == "string"
|
||||
or t == "number" then
|
||||
p = p + 1.5
|
||||
formspec = formspec.."field[0.3,"..p..";2,1;snow:"..i..";"..i..";"..v.."]"
|
||||
elseif t == "boolean" then
|
||||
p = p + 0.5
|
||||
formspec = formspec.."checkbox[0,"..p..";snow:"..i..";"..i..";"..tostring(v).."]"
|
||||
end
|
||||
end
|
||||
p = p + 1
|
||||
formspec = "size[4,"..p..";]\n"..formspec
|
||||
return formspec
|
||||
end
|
||||
|
||||
minetest.register_on_player_receive_fields(function(player, formname, fields)
|
||||
if formname ~= "snow:menu" then
|
||||
return
|
||||
end
|
||||
for i,v in pairs(snow) do
|
||||
local t = type(v)
|
||||
if t == "string" or t == "number" or t == "boolean" then
|
||||
local field = fields["snow:"..i]
|
||||
if field then
|
||||
if t == "string" then
|
||||
snow[i] = field
|
||||
end
|
||||
if t == "number" then
|
||||
snow[i] = tonumber(field)
|
||||
end
|
||||
if t == "boolean" then
|
||||
if field == "true" then
|
||||
snow[i] = true
|
||||
elseif field == "false" then
|
||||
snow[i] = false
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end)
|
||||
|
||||
|
||||
minetest.register_chatcommand("snow", {
|
||||
description = "Show a menu for various actions",
|
||||
privs = {server=true},
|
||||
func = function(name)
|
||||
minetest.chat_send_player(name, "Showing snow menu…")
|
||||
minetest.show_formspec(name, "snow:menu", get_formspec())
|
||||
end,
|
||||
})
|
||||
BIN
mods/snow/textures/character_snow_man.png
Normal file
BIN
mods/snow/textures/character_snow_man.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.6 KiB |
BIN
mods/snow/textures/character_snow_man_preview.png
Normal file
BIN
mods/snow/textures/character_snow_man_preview.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 27 KiB |
BIN
mods/snow/textures/character_snow_man_preview_back.png
Normal file
BIN
mods/snow/textures/character_snow_man_preview_back.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 24 KiB |
BIN
mods/snow/textures/default_ice.png
Normal file
BIN
mods/snow/textures/default_ice.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 643 B |
BIN
mods/snow/textures/default_snowball.png
Normal file
BIN
mods/snow/textures/default_snowball.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 211 B |
Binary file not shown.
|
Before Width: | Height: | Size: 742 B |
Binary file not shown.
|
Before Width: | Height: | Size: 807 B After Width: | Height: | Size: 619 B |
Binary file not shown.
|
Before Width: | Height: | Size: 860 B After Width: | Height: | Size: 660 B |
Binary file not shown.
|
Before Width: | Height: | Size: 937 B After Width: | Height: | Size: 884 B |
BIN
mods/snow/textures/snow_needles_decorated_animated.png
Normal file
BIN
mods/snow/textures/snow_needles_decorated_animated.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.6 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 406 B After Width: | Height: | Size: 272 B |
BIN
mods/snow/textures/snow_sled.png
Normal file
BIN
mods/snow/textures/snow_sled.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 327 B |
Binary file not shown.
|
Before Width: | Height: | Size: 345 B |
Binary file not shown.
|
Before Width: | Height: | Size: 507 B After Width: | Height: | Size: 319 B |
BIN
mods/snow/textures/snow_snow_cobble.png
Normal file
BIN
mods/snow/textures/snow_snow_cobble.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 737 B |
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user