diff --git a/README.txt b/README.txt
new file mode 100644
index 0000000..4b22864
--- /dev/null
+++ b/README.txt
@@ -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?
+
+
diff --git a/abms.lua b/abms.lua
new file mode 100644
index 0000000..010342a
--- /dev/null
+++ b/abms.lua
@@ -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
+})
diff --git a/aliases.lua b/aliases.lua
new file mode 100644
index 0000000..1588999
--- /dev/null
+++ b/aliases.lua
@@ -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")
diff --git a/basic_stairs_slabs.lua b/basic_stairs_slabs.lua
new file mode 100644
index 0000000..d62f448
--- /dev/null
+++ b/basic_stairs_slabs.lua
@@ -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(),
+})
diff --git a/crafting.lua b/crafting.lua
new file mode 100644
index 0000000..8f31037
--- /dev/null
+++ b/crafting.lua
@@ -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
diff --git a/depends.txt b/depends.txt
index 4ad96d5..9771003 100644
--- a/depends.txt
+++ b/depends.txt
@@ -1 +1,2 @@
 default
+moreblocks?
\ No newline at end of file
diff --git a/falling_snow.lua b/falling_snow.lua
index 54349ae..a453ad2 100644
--- a/falling_snow.lua
+++ b/falling_snow.lua
@@ -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
 
diff --git a/init.lua b/init.lua
index 9600800..e013a3c 100644
--- a/init.lua
+++ b/init.lua
@@ -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,
-})
diff --git a/mapgen.lua b/mapgen.lua
index 22051e1..c62815b 100644
--- a/mapgen.lua
+++ b/mapgen.lua
@@ -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")
diff --git a/mapgen_v7.lua b/mapgen_v7.lua
index 46d9fe2..5bac309 100644
--- a/mapgen_v7.lua
+++ b/mapgen_v7.lua
@@ -145,4 +145,3 @@ minetest.register_decoration({
 	biomes = {"snow_biome_alpine"},
 	decoration = "default:snow",
 })
-
diff --git a/nodes.lua b/nodes.lua
new file mode 100644
index 0000000..6a043b7
--- /dev/null
+++ b/nodes.lua
@@ -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
+})
diff --git a/readme_splizards_original.txt b/readme_splizards_original.txt
new file mode 100644
index 0000000..295997d
--- /dev/null
+++ b/readme_splizards_original.txt
@@ -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.
diff --git a/sled.lua b/sled.lua
index 4e6f5ba..4509b1e 100644
--- a/sled.lua
+++ b/sled.lua
@@ -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
diff --git a/snowball.lua b/snowball.lua
new file mode 100644
index 0000000..73e0c98
--- /dev/null
+++ b/snowball.lua
@@ -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
+})
+--]]
diff --git a/stairsplus.lua b/stairsplus.lua
new file mode 100644
index 0000000..011fd85
--- /dev/null
+++ b/stairsplus.lua
@@ -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
diff --git a/textures/default_ice.png b/textures/default_ice.png
new file mode 100644
index 0000000..d85a1ab
Binary files /dev/null and b/textures/default_ice.png differ
diff --git a/textures/default_ice.xcf b/textures/default_ice.xcf
new file mode 100644
index 0000000..85c3036
Binary files /dev/null and b/textures/default_ice.xcf differ
diff --git a/textures/inkscape_default_ice.svg b/textures/inkscape_default_ice.svg
new file mode 100644
index 0000000..106ce66
--- /dev/null
+++ b/textures/inkscape_default_ice.svg
@@ -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>
diff --git a/textures/mocha.png b/textures/mocha.png
new file mode 100644
index 0000000..39394a2
Binary files /dev/null and b/textures/mocha.png differ
diff --git a/textures/mocha.xcf b/textures/mocha.xcf
new file mode 100644
index 0000000..931d90f
Binary files /dev/null and b/textures/mocha.xcf differ
diff --git a/textures/original_snow_snow_brick.png b/textures/original_snow_snow_brick.png
new file mode 100644
index 0000000..47c85ee
Binary files /dev/null and b/textures/original_snow_snow_brick.png differ
diff --git a/textures/rect2985.png b/textures/rect2985.png
new file mode 100644
index 0000000..a2dcfbf
Binary files /dev/null and b/textures/rect2985.png differ
diff --git a/textures/snow_needles_decorated_animated.png b/textures/snow_needles_decorated_animated.png
new file mode 100644
index 0000000..f7d67e1
Binary files /dev/null and b/textures/snow_needles_decorated_animated.png differ
diff --git a/textures/snow_needles_decorated_animated.xcf b/textures/snow_needles_decorated_animated.xcf
new file mode 100644
index 0000000..00b075e
Binary files /dev/null and b/textures/snow_needles_decorated_animated.xcf differ
diff --git a/textures/snow_snow_brick.png b/textures/snow_snow_brick.png
index 47c85ee..4b5b05b 100644
Binary files a/textures/snow_snow_brick.png and b/textures/snow_snow_brick.png differ
diff --git a/textures/snow_snow_brick.xcf b/textures/snow_snow_brick.xcf
new file mode 100644
index 0000000..2fda149
Binary files /dev/null and b/textures/snow_snow_brick.xcf differ
diff --git a/textures/snow_snow_cobble.png b/textures/snow_snow_cobble.png
new file mode 100644
index 0000000..83f96d1
Binary files /dev/null and b/textures/snow_snow_cobble.png differ
diff --git a/textures/snow_snow_cobble.png_01 b/textures/snow_snow_cobble.png_01
new file mode 100644
index 0000000..e726395
Binary files /dev/null and b/textures/snow_snow_cobble.png_01 differ
diff --git a/textures/snow_snow_cobble.xcf b/textures/snow_snow_cobble.xcf
new file mode 100644
index 0000000..ff2be1f
Binary files /dev/null and b/textures/snow_snow_cobble.xcf differ
diff --git a/textures/snow_star_lit.png b/textures/snow_star_lit.png
new file mode 100644
index 0000000..11579e3
Binary files /dev/null and b/textures/snow_star_lit.png differ
diff --git a/textures/snow_star_lit.xcf b/textures/snow_star_lit.xcf
new file mode 100644
index 0000000..ecaa73c
Binary files /dev/null and b/textures/snow_star_lit.xcf differ
diff --git a/textures/xdefault_cobble.png b/textures/xdefault_cobble.png
new file mode 100644
index 0000000..cf8896d
Binary files /dev/null and b/textures/xdefault_cobble.png differ
diff --git a/textures/xdefault_furnace_bottom.png b/textures/xdefault_furnace_bottom.png
new file mode 100644
index 0000000..2d19b6b
Binary files /dev/null and b/textures/xdefault_furnace_bottom.png differ
diff --git a/textures/xdefault_furnace_fire_bg.png b/textures/xdefault_furnace_fire_bg.png
new file mode 100644
index 0000000..e98a4f6
Binary files /dev/null and b/textures/xdefault_furnace_fire_bg.png differ
diff --git a/textures/xdefault_furnace_fire_fg.png b/textures/xdefault_furnace_fire_fg.png
new file mode 100644
index 0000000..66aab65
Binary files /dev/null and b/textures/xdefault_furnace_fire_fg.png differ
diff --git a/textures/xdefault_furnace_front.png b/textures/xdefault_furnace_front.png
new file mode 100644
index 0000000..88069c7
Binary files /dev/null and b/textures/xdefault_furnace_front.png differ
diff --git a/textures/xdefault_furnace_front_active.png b/textures/xdefault_furnace_front_active.png
new file mode 100644
index 0000000..1c460be
Binary files /dev/null and b/textures/xdefault_furnace_front_active.png differ
diff --git a/textures/xdefault_furnace_side.png b/textures/xdefault_furnace_side.png
new file mode 100644
index 0000000..2d19b6b
Binary files /dev/null and b/textures/xdefault_furnace_side.png differ
diff --git a/textures/xdefault_furnace_top.png b/textures/xdefault_furnace_top.png
new file mode 100644
index 0000000..2d19b6b
Binary files /dev/null and b/textures/xdefault_furnace_top.png differ
diff --git a/textures/xdefault_glass.png b/textures/xdefault_glass.png
new file mode 100644
index 0000000..ade0196
Binary files /dev/null and b/textures/xdefault_glass.png differ
diff --git a/textures/xdefault_ice.png b/textures/xdefault_ice.png
new file mode 100644
index 0000000..4aa583a
Binary files /dev/null and b/textures/xdefault_ice.png differ
diff --git a/textures/xdefault_ice.xcf b/textures/xdefault_ice.xcf
new file mode 100644
index 0000000..425d236
Binary files /dev/null and b/textures/xdefault_ice.xcf differ
diff --git a/textures/xdefault_snow.png b/textures/xdefault_snow.png
new file mode 100644
index 0000000..b4d0cc8
Binary files /dev/null and b/textures/xdefault_snow.png differ
diff --git a/textures/xdefault_stone_brick.png b/textures/xdefault_stone_brick.png
new file mode 100644
index 0000000..8032f7d
Binary files /dev/null and b/textures/xdefault_stone_brick.png differ