nalc
/
minetest-mod-snow
forked from mtcontrib/minetest-mod-snow
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge LazyJ's changes.

This commit is contained in:
Splizard 2014-06-04 10:34:58 +12:00
parent 78a0fe9f8c
commit 7f9207c6ff
44 changed files with 2221 additions and 450 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

197
README.txt Normal file
View File

@ -0,0 +1,197 @@
##### LazyJ's Fork of Splizard's "Snow" Mod
This version of 'Snow' is based off of Splizard's 2013_12_25 release.
At LinuxGaming.us, we have been using the Snow mod in our Minetest server for
a year now. I've been tweaking and patching things here-and-there and had a
few ideas. The little here-and-there things progressed into bigger and more
complex changes. Maybe other folks will enjoy these fixes, changes,
and additions.
~ LazyJ, 2014_06_01
Original Mod by Splizard: "Snow"
Minetest version: 0.4.9
Depends: default
Recommended Additional Mods: "More Blocks" by Calinou (2014_05_11 or newer)
License: GPL v2
Source Code: http://github.com/LazyJ/snow
Download (.zip): http://github.com/LazyJ/snow/archive/master.zip
Install:
* After downloading, unzip the file.
* Rename the directory "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
~~~~~~~~~~~~~~~~~~~~
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?

175
abms.lua Normal file
View File

@ -0,0 +1,175 @@
--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, active_object_count, active_object_count_wider)
local level = 7*(tonumber(node.name:sub(-1)))
minetest.add_node(pos,{name="default:snow"})
minetest.set_node_level(pos, level)
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 above = {x=pos.x, y=pos.y+1, z=pos.z}
local name = minetest.get_node(above).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, active_object_count, active_object_count_wider)
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
--[[ 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, node, active_object_count, active_object_count_wider)
minetest.add_node(pos,{name="default: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.add_node(pos,{name="default:mossycobble"})
end,
})
--Grow Pine Saplings
minetest.register_abm({
nodenames = {"snow:sapling_pine"},
interval = 10,
chance = 50,
action = function(pos, node, active_object_count, active_object_count_wider)
-- Check if there is enough vertical-space for the sapling to grow without
-- hitting anything else. ~ LazyJ, 2014_04_10
if -- 'If' there is air in each of the 8 nodes dirctly above the sapling,... ~LazyJ
minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+2, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+3, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+4, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+5, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+6, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+7, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+8, z=pos.z}).name == "air"
then -- '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({x = pos.x, y = pos.y, z = pos.z}).name == "snow:sapling_pine" then
-- This switches the sapling to a tree trunk. ~ LazyJ
minetest.set_node(pos, {name="default:tree"})
-- 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
else
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 -- 'If' there is air in each of the 8 nodes dirctly above the sapling,... ~LazyJ
minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+2, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+3, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+4, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+5, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+6, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+7, z=pos.z}).name == "air" and
minetest.get_node({x=pos.x, y=pos.y+8, z=pos.z}).name == "air"
then -- '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
})

103
aliases.lua Normal file
View File

@ -0,0 +1,103 @@
-- 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("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
basic_stairs_slabs.lua Normal file
View 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(),
})

185
crafting.lua Normal file
View File

@ -0,0 +1,185 @@
--[[
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 3',
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'}
}
})
-- 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

1
depends.txt
View File

@ -1 +1,2 @@
default
moreblocks?

44
falling_snow.lua
View File

@ -1,3 +1,44 @@
--[[
--=================
--======================================
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
--=============================================================
if snow.enable_snowfall then
@ -96,7 +137,8 @@ if snow.enable_snowfall then
50, 50,
false, "weather_snow.png", player:get_player_name())
end
snow.place(pos, true)
--snow.place(pos, true)
minetest.place_node({x=pos.x, y=pos.y+2, z=pos.z}, {name="default:snow"}) -- LazyJ
end
end

488
init.lua
View File

@ -1,4 +1,23 @@
--[[
--==============================
--==========================================================
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
@ -17,303 +36,52 @@
MA 02110-1301, USA.
]]--
-- 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").."/abms.lua")
dofile(minetest.get_modpath("snow").."/aliases.lua")
dofile(minetest.get_modpath("snow").."/basic_stairs_slabs.lua")
dofile(minetest.get_modpath("snow").."/crafting.lua")
dofile(minetest.get_modpath("snow").."/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").."/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").."/nodes.lua")
dofile(minetest.get_modpath("snow").."/mapgen.lua")
dofile(minetest.get_modpath("snow").."/falling_snow.lua")
dofile(minetest.get_modpath("snow").."/sled.lua")
dofile(minetest.get_modpath("snow").."/falling_snow.lua")
local needles = {
description = "Pine Needles",
drawtype = "allfaces_optional",
visual_scale = 1.3,
tiles = {"snow_needles.png"},
waving = 1,
paramtype = "light",
groups = {snappy=3, leafdecay=3, flammable=2},
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 snow.christmas_content then
--Cristmas trees.
needles["drop"]["items"][3] = {
-- player will get xmas tree with 1/50 chance
items = {'snow:xmas_tree'},
rarity = 50,
}
--Christmas easter egg.
minetest.register_on_mapgen_init( function()
if skins then
skins.add("character_snow_man")
end
end)
-- Check for "MoreBlocks". If not found, skip this next "dofile".
if (minetest.get_modpath("moreblocks")) then
dofile(minetest.get_modpath("snow").."/stairsplus.lua")
else
end
--Pine leaves.
minetest.register_node("snow:needles", needles)
--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},
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(),
})
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
-------------
local snowball_GRAVITY=9
local snowball_VELOCITY=19
--Shoot snowball.
local snow_shoot_snowball=function (item, player, pointed_thing)
local playerpos=player:getpos()
local obj=minetest.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.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
snow.place(pos)
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,
})
--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, active_object_count, active_object_count_wider)
local level = 7*(tonumber(node.name:sub(-1)))
minetest.add_node(pos,{name="default:snow"})
minetest.set_node_level(pos, level)
end,
})
minetest.register_alias("snow:snow", "default:snow")
minetest.register_alias("snow:ice", "default:ice")
minetest.register_alias("snow:dirt_with_snow", "default:dirt_with_snow")
minetest.register_alias("snow:snow_block", "default:snowblock")
minetest.register_alias("snow:ice", "default:ice")
--Snow.
minetest.register_node(":default:snow", {
description = "Snow",
tiles = {"default_snow.png"},
drawtype = "nodebox",
sunlight_propagates = true,
paramtype = "light",
paramtype2 == "leveled",
groups = {crumbly=3,melts=3,falling_node=1,not_in_creative_inventory=1},
buildable_to = true,
freezemelt = "default:water_flowing",
drop = {
max_items = 2,
items = {
{
-- player will get sapling with 1/20 chance
items = {'snow:moss'},
rarity = 20,
},
{
-- player will get leaves only if he get no saplings,
-- this is because max_items is 1
items = {'snow:snowball'},
}
}
},
leveled = 7,
drawtype = "nodebox",
node_box = {
type = "leveled",
fixed = {
{-0.5, -0.5, -0.5, 0.5, -0.5+2/16, 0.5},
},
},
sounds = default.node_sound_dirt_defaults({
footstep = {name="default_snow_footstep", gain=0.45},
}),
on_construct = function(pos)
pos.y = pos.y - 1
if minetest.get_node(pos).name == "default:dirt_with_grass" then
minetest.add_node(pos, {name="default:dirt_with_snow"})
end
end,
after_destruct = function(pos)
pos.y = pos.y - 1
if minetest.get_node(pos).name == "default:dirt_with_snow" then
minetest.add_node(pos, {name="default:dirt_with_grass"})
end
end,
})
function snow.place(pos)
local node = minetest.get_node({x=pos.x,y=pos.y+1,z=pos.z})
local node = minetest.get_node(pos)
local drawtype = minetest.registered_nodes[node.name].drawtype
local bnode = minetest.get_node({x=pos.x,y=pos.y-1,z=pos.z})
if node.name == "default:snow" and minetest.get_node_level(pos) < 63 then
if minetest.get_item_group(bnode.name, "leafdecay") == 0 and snow.is_uneven(pos) ~= true then
minetest.add_node_level(pos, 7)
end
elseif node.name == "default:snow" and minetest.get_node_level(pos) == 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.add_node(p,{name="default:snow"})
else
minetest.add_node(pos,{name="default:snowblock"})
end
elseif node.name ~= "default:ice" and bnode.name ~= "air" then
if drawtype == "normal" or drawtype == "allfaces_optional" then
minetest.add_node({x=pos.x,y=pos.y+1,z=pos.z}, {name="default:snow"})
elseif drawtype == "plantlike" then
pos.y = pos.y - 1
if minetest.get_node(pos).name == "default:dirt_with_grass" then
minetest.add_node(pos, {name="default:dirt_with_snow"})
end
end
end
end
--Checks if the snow level is even at any given pos.
--Smooth snow
-- Checks if the snow level is even at any given pos.
-- Smooth Snow
local smooth_snow = snow.smooth_snow
snow.is_uneven = function(pos)
if smooth_snow then
@ -357,147 +125,3 @@ snow.is_uneven = function(pos)
end
end
end
--Snow with dirt.
minetest.register_node(":default:dirt_with_snow", {
description = "Dirt with Snow",
tiles = {"default_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_snow_footstep", gain=0.4},
}),
})
--Snow block.
minetest.register_node(":default:snowblock", {
description = "Snow",
tiles = {"default_snow.png"},
freezemelt = "default:water_source",
is_ground_content = true,
groups = {crumbly=3,melts=2,falling_node=1},
drop = 'default:snowblock',
sounds = default.node_sound_dirt_defaults({
footstep = {name="default_snow_footstep", gain=0.4},
}),
})
--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},
}),
})
--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 = {
{'default:snowblock', 'default:snowblock'},
{'default:snowblock', 'default:snowblock'},
},
})
--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.add_node(pos,{name="default:water_source"})
elseif intensity == 2 then
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_flowing"})
end
nodeupdate(pos)
end,
})
--Freezing
--Water freezes when in contact with snow.
minetest.register_abm({
nodenames = {"default:water_source"},
neighbors = {"default:snow", "default:snowblock"},
interval = 20,
chance = 4,
action = function(pos, node, active_object_count, active_object_count_wider)
minetest.add_node(pos,{name="default: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.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,
})

52
mapgen.lua
View File

@ -1,3 +1,19 @@
--[[
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.
local mgname = ""
--Identify the mapgen.
@ -16,6 +32,11 @@ minetest.register_on_mapgen_init(function(MapgenParams)
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",
@ -28,6 +49,9 @@ local pine_tree = {
trunk_type="single",
thin_branches=true,
}
local xmas_tree = {
axiom="TABff",
rules_a="[&T+f+ff+ff+ff+f]GA",
@ -41,6 +65,8 @@ local xmas_tree = {
thin_branches=true,
}
--Makes pine tree
function snow.make_pine(pos,snow,xmas)
local env = minetest.env
@ -54,10 +80,10 @@ function snow.make_pine(pos,snow,xmas)
--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
if env:get_node({x=pos.x+x,y=pos.y,z=pos.z+z}).name == "default: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
if env:get_node({x=pos.x+x,y=pos.y,z=pos.z+z}).name == "default:snowblock" then
env:remove_node({x=pos.x+x,y=pos.y,z=pos.z+z})
end
end
@ -70,23 +96,25 @@ function snow.make_pine(pos,snow,xmas)
end
if snow then
local x,z = pos.x,pos.z
try_node({x=x+1,y=pos.y+3,z=z+1},{name="snow:snow"})
try_node({x=x-1,y=pos.y+3,z=z-1},{name="snow:snow"})
try_node({x=x-1,y=pos.y+3,z=z+1},{name="snow:snow"})
try_node({x=x+1,y=pos.y+3,z=z-1},{name="snow: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+3,z=z-1},{name="default:snow"})
try_node({x=x+1,y=pos.y+5,z=z},{name="snow:snow"})
try_node({x=x-1,y=pos.y+5,z=z},{name="snow:snow"})
try_node({x=x,y=pos.y+5,z=z+1},{name="snow:snow"})
try_node({x=x,y=pos.y+5,z=z-1},{name="snow: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"})
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="snow:snow"})
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")

1
mapgen_v7.lua
View File

@ -145,4 +145,3 @@ minetest.register_decoration({
biomes = {"snow_biome_alpine"},
decoration = "default:snow",
})

355
nodes.lua Normal file
View File

@ -0,0 +1,355 @@
-- 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 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, puncher) -- Added a "lit" star that can be punched on or off depending on your preference. ~ LazyJ
minetest.set_node(pos, {name = "snow:star_lit"})
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, puncher)
minetest.set_node(pos, {name = "snow:star"})
nodeupdate(pos)
end,
})
-- 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, attached_node=1},
})
-- 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 = 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
})
-- Snow Cobble ~ LazyJ
minetest.register_node("snow:snow_cobble", {
description = "Snow Cobble",
tiles = {"snow_snow_cobble.png"},
is_ground_content = true,
freezemelt = "default:water_source",
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},
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 = 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
})
-- 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
sunlight_propagates = true, -- 2
drawtype = "glasslike",
inventory_image = minetest.inventorycube("default_ice.png"),
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=1, crumbly=1, choppy=1, oddly_breakable_by_hand=1, melts=1},
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
})
-- 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},
drop = "snow:snow_cobble",
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
})

73
readme_splizards_original.txt Normal file
View File

@ -0,0 +1,73 @@
_____ __ __ _
/ ____| | \/ | | |
| (___ _ __ _____ __ | \ / | ___ __| |
\___ \| '_ \ / _ \ \ /\ / / | |\/| |/ _ \ / _` |
____) | | | | (_) \ V V / | | | | (_) | (_| |
|_____/|_| |_|\___/ \_/\_/ |_| |_|\___/ \__,_|
By Splizard.
Forum post: http://minetest.net/forum/viewtopic.php?id=2290
Github: https://github.com/Splizard/minetest-mod-snow
INSTALL:
----------
Place this folder in your minetest mods folder.
(http://dev.minetest.net/Installing_Mods)
NOTICE
While this mod is installed you may experience slow map loading while a snow biome is generated.
USAGE:
-------
If you walk around a bit you will find snow biomes scattered around the world.
There are nine biome types:
* Normal
* Icebergs
* Icesheet
* Broken icesheet
* Icecave
* Coast
* Alpine
* Snowy
* Plain
Snow can be picked up and thrown as snowballs or crafted 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
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 and includes a base grass biome for this.
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.
UNINSTALL:
------------
Simply delete the folder snow from the mods folder.

73
sled.lua
View File

@ -1,3 +1,53 @@
--[[
--=================
--======================================
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
--]]
--=============================================================
-- CODE STUFF
--=============================================================
--
-- Helper functions
--
@ -34,7 +84,8 @@ function sled:on_rightclick(clicker)
speed = 2, -- multiplier to default value
jump = 0, -- multiplier to default value
gravity = 1
})
})
--[[
local HUD =
{
hud_elem_type = "text", -- see HUD element types
@ -46,6 +97,18 @@ function sled:on_rightclick(clicker)
}
clicker:hud_add(HUD)
--]]
-- Here is part 1 of the fix. ~ LazyJ
HUD = clicker: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
end
@ -76,7 +139,6 @@ minetest.register_globalstep(function(dtime)
end
end)
function sled:on_step(dtime)
if self.driver then
local p = self.object:getpos()
@ -84,17 +146,20 @@ function sled:on_step(dtime)
local s = self.object:getpos()
s.y = s.y -0.5
local keys = self.driver:get_player_control()
if keys["sneak"] or is_water(p) or (not minetest.find_node_near(s, 1, {"default:snow","default:snowblock","default:ice","default:dirt_with_snow"})) then
if keys["sneak"] or is_water(p) or (not minetest.find_node_near(s, 1, {"default:snow","default:snowblock","default:ice","default:dirt_with_snow", "group:icemaker"})) then -- LazyJ
self.driver:set_physics_override({
speed = 1, -- multiplier to default value
jump = 1, -- multiplier to default value
gravity = 1
})
players_sled[self.driver:get_player_name()] = false
self.object:set_detach()
self.driver:hud_remove("sled")
--self.driver:hud_remove("sled")
self.driver:hud_remove(HUD) -- And here is part 2. ~ LazyJ
self.driver = nil
self.object:remove()
end
end
end

190
snowball.lua Normal file
View File

@ -0,0 +1,190 @@
--============
--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 snowball_GRAVITY=9
local snowball_VELOCITY=19
--Shoot snowball
local snow_shoot_snowball=function (item, player, pointed_thing)
local playerpos=player:getpos()
local obj=minetest.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 = {"default_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.get_node(pos)
--Become item when hitting a node.
if self.lastpos.x~=nil then --If there is no lastpos for some reason. ~ Splizard
-- Check to see what is one node above where the snow is
-- going to be placed. ~ LazyJ, 2014_04_08
local abovesnowballtarget = {x=pos.x, y=pos.y+1, z=pos.z}
-- Identify the name of the node that was found above. ~ LazyJ, 2014_04_08
local findwhatisabove = minetest.get_node(abovesnowballtarget).name
-- If the node above is air, then it's OK to go on to the next step. ~ LazyJ, 2014_04_08
if findwhatisabove == "air" then
-- If the node where the snow is going is anything except air, then it's OK to put
-- the snow on it. ~ Original line of code by Splizard, comment by LazyJ so I can
-- keep track of what this code does. ~ LazyJ, 2014_04_07
if node.name ~= "air" then
--snow.place(pos) -- this is the original code, I replaced it with
-- minetest.place_node and bumped the y position up by 2 (make the snow drop
-- from a node above and pile up). ~ LazyJ, 2014_04_07
minetest.place_node({x=pos.x, y=pos.y+2, z=pos.z}, {name="default:snow"})
self.object:remove()
end
else -- If findwhatisabove is not equal to "air" then cancel the snowball
-- with self.object:remove() ~ LazyJ, 2014_04_08
self.object:remove()
end
end
self.lastpos={x=pos.x, y=pos.y, z=pos.z}
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", {
groups = {cracky=3, crumbly=3, choppy=3, oddly_breakable_by_hand=3,falling_node=1, melts=2, float=1},
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.
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 snowball layer more than the full block below. That second layer,from
-- what I've observed, seems to push into a third node box above so by subracting 2,
-- the swap_node target is moved back down to the first get_node y=pos.
-- ~ LazyJ, 2014_04_24
minetest.get_node({x=pos.x, y=pos.y-1, 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. ~ LazyJ
})
--[[
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
})
--]]

341
stairsplus.lua Normal file
View File

@ -0,0 +1,341 @@
-- ===============================================================================
-- 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"))
-- 'If' MoreBlocks was found, 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

BIN
textures/default_ice.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 160 B

BIN
textures/default_ice.xcf Normal file
View File

Binary file not shown.

67
textures/inkscape_default_ice.svg Normal file
View 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>
Side by Side

After

Width:  |  Height:  |  Size: 2.0 KiB

BIN
textures/mocha.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 160 B

BIN
textures/mocha.xcf Normal file
View File

Binary file not shown.

BIN
textures/original_snow_snow_brick.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 507 B

BIN
textures/rect2985.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 160 B

BIN
textures/snow_needles_decorated_animated.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.8 KiB

BIN
textures/snow_needles_decorated_animated.xcf Normal file
View File

Binary file not shown.

BIN
textures/snow_snow_brick.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 507 B

After

Width:  |  Height:  |  Size: 732 B

BIN
textures/snow_snow_brick.xcf Normal file
View File

Binary file not shown.

BIN
textures/snow_snow_cobble.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 815 B

BIN
textures/snow_snow_cobble.png_01 Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 788 B

BIN
textures/snow_snow_cobble.xcf Normal file
View File

Binary file not shown.

BIN
textures/snow_star_lit.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 514 B

BIN
textures/snow_star_lit.xcf Normal file
View File

Binary file not shown.

BIN
textures/xdefault_cobble.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 585 B

BIN
textures/xdefault_furnace_bottom.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 604 B

BIN
textures/xdefault_furnace_fire_bg.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 282 B

BIN
textures/xdefault_furnace_fire_fg.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 803 B

BIN
textures/xdefault_furnace_front.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 628 B

BIN
textures/xdefault_furnace_front_active.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.8 KiB

BIN
textures/xdefault_furnace_side.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 604 B

BIN
textures/xdefault_furnace_top.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 604 B

BIN
textures/xdefault_glass.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 978 B

BIN
textures/xdefault_ice.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 490 B

BIN
textures/xdefault_ice.xcf Normal file
View File

Binary file not shown.

BIN
textures/xdefault_snow.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 278 B

BIN
textures/xdefault_stone_brick.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 636 B