From 7f9207c6ff91744fbe3a1b88b3d03d04757256e9 Mon Sep 17 00:00:00 2001 From: Splizard Date: Wed, 4 Jun 2014 10:34:58 +1200 Subject: [PATCH] Merge LazyJ's changes. --- README.txt | 197 ++++++++ abms.lua | 175 +++++++ aliases.lua | 103 ++++ basic_stairs_slabs.lua | 326 +++++++++++++ crafting.lua | 185 +++++++ depends.txt | 1 + falling_snow.lua | 44 +- init.lua | 488 +++---------------- mapgen.lua | 52 +- mapgen_v7.lua | 1 - nodes.lua | 355 ++++++++++++++ readme_splizards_original.txt | 73 +++ sled.lua | 73 ++- snowball.lua | 190 ++++++++ stairsplus.lua | 341 +++++++++++++ textures/default_ice.png | Bin 0 -> 160 bytes textures/default_ice.xcf | Bin 0 -> 1681 bytes textures/inkscape_default_ice.svg | 67 +++ textures/mocha.png | Bin 0 -> 160 bytes textures/mocha.xcf | Bin 0 -> 665 bytes textures/original_snow_snow_brick.png | Bin 0 -> 507 bytes textures/rect2985.png | Bin 0 -> 160 bytes textures/snow_needles_decorated_animated.png | Bin 0 -> 2902 bytes textures/snow_needles_decorated_animated.xcf | Bin 0 -> 15052 bytes textures/snow_snow_brick.png | Bin 507 -> 732 bytes textures/snow_snow_brick.xcf | Bin 0 -> 1539 bytes textures/snow_snow_cobble.png | Bin 0 -> 815 bytes textures/snow_snow_cobble.png_01 | Bin 0 -> 788 bytes textures/snow_snow_cobble.xcf | Bin 0 -> 1776 bytes textures/snow_star_lit.png | Bin 0 -> 514 bytes textures/snow_star_lit.xcf | Bin 0 -> 1480 bytes textures/xdefault_cobble.png | Bin 0 -> 585 bytes textures/xdefault_furnace_bottom.png | Bin 0 -> 604 bytes textures/xdefault_furnace_fire_bg.png | Bin 0 -> 282 bytes textures/xdefault_furnace_fire_fg.png | Bin 0 -> 803 bytes textures/xdefault_furnace_front.png | Bin 0 -> 628 bytes textures/xdefault_furnace_front_active.png | Bin 0 -> 4890 bytes textures/xdefault_furnace_side.png | Bin 0 -> 604 bytes textures/xdefault_furnace_top.png | Bin 0 -> 604 bytes textures/xdefault_glass.png | Bin 0 -> 978 bytes textures/xdefault_ice.png | Bin 0 -> 490 bytes textures/xdefault_ice.xcf | Bin 0 -> 1400 bytes textures/xdefault_snow.png | Bin 0 -> 278 bytes textures/xdefault_stone_brick.png | Bin 0 -> 636 bytes 44 files changed, 2221 insertions(+), 450 deletions(-) create mode 100644 README.txt create mode 100644 abms.lua create mode 100644 aliases.lua create mode 100644 basic_stairs_slabs.lua create mode 100644 crafting.lua create mode 100644 nodes.lua create mode 100644 readme_splizards_original.txt create mode 100644 snowball.lua create mode 100644 stairsplus.lua create mode 100644 textures/default_ice.png create mode 100644 textures/default_ice.xcf create mode 100644 textures/inkscape_default_ice.svg create mode 100644 textures/mocha.png create mode 100644 textures/mocha.xcf create mode 100644 textures/original_snow_snow_brick.png create mode 100644 textures/rect2985.png create mode 100644 textures/snow_needles_decorated_animated.png create mode 100644 textures/snow_needles_decorated_animated.xcf create mode 100644 textures/snow_snow_brick.xcf create mode 100644 textures/snow_snow_cobble.png create mode 100644 textures/snow_snow_cobble.png_01 create mode 100644 textures/snow_snow_cobble.xcf create mode 100644 textures/snow_star_lit.png create mode 100644 textures/snow_star_lit.xcf create mode 100644 textures/xdefault_cobble.png create mode 100644 textures/xdefault_furnace_bottom.png create mode 100644 textures/xdefault_furnace_fire_bg.png create mode 100644 textures/xdefault_furnace_fire_fg.png create mode 100644 textures/xdefault_furnace_front.png create mode 100644 textures/xdefault_furnace_front_active.png create mode 100644 textures/xdefault_furnace_side.png create mode 100644 textures/xdefault_furnace_top.png create mode 100644 textures/xdefault_glass.png create mode 100644 textures/xdefault_ice.png create mode 100644 textures/xdefault_ice.xcf create mode 100644 textures/xdefault_snow.png create mode 100644 textures/xdefault_stone_brick.png 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_ +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_ +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}_ +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 0000000000000000000000000000000000000000..d85a1ab8982e0d68849a76d6968ca27d9307cb15 GIT binary patch literal 160 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`EX7WqAsj$Z!;#Vf2?p zUk71ECym(^Ktah8*NBqf{Irtt#G+J&^73-M%)IR42T^vI! xdXwi=y!>y>#>F74I?J6`!ZhJZ!@(2=hKZfb8E+hnP5>1$c)I$ztaD0e0swvHD&+tG literal 0 HcmV?d00001 diff --git a/textures/default_ice.xcf b/textures/default_ice.xcf new file mode 100644 index 0000000000000000000000000000000000000000..85c3036b2ce64d4f6fbfc0673c1a7a46aa823538 GIT binary patch literal 1681 zcmeHH&1)J#6ra`IRMVB%YJ2KokLIAPU~IkSA1NE%oi3~&xLVAg&{NOtF^VLGTnd4Z zQw|{zu!TTMprn-$gwm8!3u3Bvr|+#haV4ea9`fYv`@P@3kMYgUP_tN38hJx`uBvGQ z67@6yRv;t@N?5yf)NZ}sY9DR3J8w4MHJc|J8y{NDlkM$~J3F6tcR%m#b@%r#4h}93 z4||=?m*eBFr>Eb}&c1iMKhDqlz248u%R#^YYcLoOhoh^j$!PR@GI1P-LG@d?oxp!S zfqSq%0Z&2(98?6w)AG>68213;SHVUpoUf!=)To}MRkHvTo+^PP?Ap4e zD|Xp33(JcMgXYUtxvC^wldRG;O-ZLzR}}RI;IEb;b?slNJaATwGnm@2D_Y(xQ6-)A zS^&BJH`3#h^^#dr%u@cDZexDgFl@bcy+F*qNllsgRGh;C)rv*Un+S=ksmu!ea=F|S zHIvC@A7@waohRa3j==IeN&*~f6m&zYTeYXu(ri0bDN&5X4MAA|#SOxXCgfq + + + + + + + + + image/svg+xml + + + + + + + + + diff --git a/textures/mocha.png b/textures/mocha.png new file mode 100644 index 0000000000000000000000000000000000000000..39394a279ad74447724cbe2c3ce53646d6d610a9 GIT binary patch literal 160 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61SBU+%rFB|oCO|{#S9GG!XV7ZFl&wkP>{XE z)7O>#9*eYywwA)2d7FSjk|nMYCC>S|xv6<249-QVi6yBi3gww484B*6z5(HleBwYw zQl2i3AsXkC|D69Yzft7C5eFrSs|KqQUt};ac=<8O`R;wI0#wD|>FVdQ&MBb@0Isho Ar2qf` literal 0 HcmV?d00001 diff --git a/textures/mocha.xcf b/textures/mocha.xcf new file mode 100644 index 0000000000000000000000000000000000000000..931d90f2a4adb3ddaafca2d6f102e4637a89243c GIT binary patch literal 665 zcmaJO zHx-YX5LarJ@bTTK0Uzy&c4>&x*?*;N;_qgyL#3;FkqBKXKE8KHz+C@jIxk+9+Hzfr zxvZ()WLYik&jqP^-`YC6rSuLC!B?vg{r>bOiFi?!S(eSSQ8x%jAa!R0cATaLoH&iZ xZav-gbkEbLp6+}444U?BaSTD{5&WOAby%pKXs>>NkMp+cg&#D357-85;y1uzXzKs~ literal 0 HcmV?d00001 diff --git a/textures/original_snow_snow_brick.png b/textures/original_snow_snow_brick.png new file mode 100644 index 0000000000000000000000000000000000000000..47c85ee4108ad78250c96b513b848855321b9631 GIT binary patch literal 507 zcmVVGd000McNliru+zbo^HU-#m>1zN00fF)esHETj88S_8|@%3(NX>U3`6_j8=Fjg xDjFwL`WHT(bo002ovPDHLkV1kVa2?p zUk71ECym(^Ktah8*NBqf{Irtt#G+J&^73-M%)IR42T^vI! wdXr1$ez@P?$aKJ^^I0IX8?S_Ef`KFh!z(@}C%ydv89;>$p00i_>zopr0F*5%k^lez literal 0 HcmV?d00001 diff --git a/textures/snow_needles_decorated_animated.png b/textures/snow_needles_decorated_animated.png new file mode 100644 index 0000000000000000000000000000000000000000..f7d67e13cf683616fe0ab20fc62db22a7b38bd1d GIT binary patch literal 2902 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 AZU6uP literal 0 HcmV?d00001 diff --git a/textures/snow_needles_decorated_animated.xcf b/textures/snow_needles_decorated_animated.xcf new file mode 100644 index 0000000000000000000000000000000000000000..00b075e84beef085335a74df9d579b4d369aafb4 GIT binary patch literal 15052 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 DEU_-y literal 0 HcmV?d00001 diff --git a/textures/snow_snow_brick.png b/textures/snow_snow_brick.png index 47c85ee4108ad78250c96b513b848855321b9631..4b5b05b7817968b96e7e78ff75fa0c7049008751 100644 GIT binary patch delta 702 zcmV;v0zv)z1Kb6WDu4d~{{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G` z2i^o56$b-a-3Lbi00L=AL_t(I%TO5J^i*5NZMSfW!@P zq(b7tl_N*~0RI8_6Fne-xFZ4T6*wVMA=(}wCAiLq?S3S*v41%@O4^l1Gqc)v=G~cB zd$IXFGSg}5)dG9_T~yvi2!Yq{qUm$IdH0@25APFc5oX%N@4M)UB!yxLx8oomKWO3y z08pu<$tmKzUgO)|5DXWk6t-nhQ~;L&5E`ssEh2W?;QFx%jcGC0hdVb67}~5Z8LZYJ zXF^T^5hyc$D}QYjC+CkJfMtTM0KI07ZM2yFO&{7W;iDXJ>Z+ z|01}y0CM{`1i=`9tf|xSnEVwQRXFVTSYDVlXjI|&1cs;3^FZFL1LzRN)Bui0FrSP) zfZGEr2bna45zME+nlREfo^D2}7E&u_`PJzogdhw<)_<3)0Q~h&D5(?xA3t?y-inc} z)(+aJg!X#tC=x<|E(jwCx(7tzm}a9wdoZ5P!^#=cxHlMbZ_VJz^H)eO@VL8HK}v82 zK)%LV1S0|0ugpz%?o5W~1!IzlIo@vlA(OX|EA`kac*NI*jB_{U(# z3Lm}*H1^5V2srCDGNId#q^}5h!ra)EasD-3O4dmtw5s&>nr*N z4V;A_1stBlfJ|ye-!f+!(KepFj8wtK@47Ubi#N0#k6JNH+wr))R0iPlk9{tc^R!w! kG@FZ*REn=ZJNRwEe>9%qSuw3`9RL6T07*qoM6N<$f~ZY83IG5A delta 475 zcmV<10VMw11^WY#Du3?)?*Q+?%!360000SaNLh0L01m?d01m?e$8V@)00007bV*G` z2iyz{1U3cOap`LS00D?eL_t(I%YBkfOM*cV$A89VJcPNuKn4*agcp-8bqG9k@FdX( z=-#o<6&<3!L6@NJb}C;eNPBx$Q!y=gIxM66JX!^6DyTY0^fh;>FJKO zwM{ym53<=k=I1pxH|Ol^9B_Mk!SeDt+uKF1ug}=n$Ptfwl*?COTER$6%O24yweee} zHhvSkSUe6CK&uS^zJaAhsMhTbVO?wyV;U&mFjaKYCUiyYOxoVf<^w8|9wX4naD`~# z(xTPnPoZ!`EPn`sK-$pBaG=1~$;mbW@>^TXwA$mxYTfG7P)tLVN@f1$pjx-R{+Dn# z{34di?FXKhK&d$2-va>J?N_v31z>h|4$oU)FzE5}Qbp?&iNp&1{wHs5kHji9%YjR# z%l7W>A*W}TqpF#77}1P77ME?=heqRm^jUnO11PtrXjFE9e7-mupIab=AQ~hH06Lxb z(DI01lBp>3(NX>U3`6_j8=FjgDjFwL`W RHT(bo002ovPDHLkV1fub;$8p% diff --git a/textures/snow_snow_brick.xcf b/textures/snow_snow_brick.xcf new file mode 100644 index 0000000000000000000000000000000000000000..2fda149f196d53ef0b083f97c2e41b84dfaa1e54 GIT binary patch literal 1539 zcma)5&1)M+6xVF5e7JG!(hn%~prdneNG|;YdfyP}$>cN$mMs-7MOB@&Wov}JX>m(0wlZ2w4@!4-EmLPJuN|#q$h!79^z{XrK{x$$17~TO~{P^L}JOl7|0Yd-|@V?7g-g}V$Aj%a;v=W{C~#KSvkO2x{pknb#<^QA z@je7{xtZ5}T$-)*hYLS0l$RHm_@%}2!lQ4NOijapWq!Ga5gur!id0TJPzk?nnI;RF zoY~WGm*3Wq#$nEUu0eoI)-+93SIyN*rB=fbHcid^y3x@ zpULO>OoqQ%US2LQE<7!xGN zXM&kvK0le^Gx;E|%ava%Yijjz?D3Pe%9Gz#Y{MV`Ra7yYdSKWM)ZmPRMmyGW_H7+P zHfQ$?Ld6{e864s4hS9U_b`~2(qk(O_v4Jsxux%UrEnRnu8#z?ZNJqBQ9oU`RQvydq z_(*R<4kDXQ?1znCutA9aYzu>`Eq>S7*nqP9Isd=y8D!C3>Es{*b#WK+cXV zRZCJyQL2g}RjY+B4m;hh-t2WyhoeUwS}^D(kPM6x=m(Mm^^WA-qdpy`y~3Zg--qzY z29{Ki3RS5pDN3nYs49~D0G;%c_l8G53CF{sw2({$_^H$#_IkY*@Y?SI`2J7(U2(On xMOpcC05GqUnAKE)$Gi*a|HX z@01N9g%C6%DqqsE)M8f@Bv3G~Tt$~1cAZ&wcIV97nKPbwp8xajLi%2RuD72TP7cI?9SWJ&;huwmV@?o=kJwN~0#XBkVC@Yd7=a&9JX0TjzN z;ggNs+v{Fhv8*kqxJDH9uk5&eKd)!!>xM;nAWs4E>34sc$Q}J?q_|dcDKZzDAnznzQO|=ti@5>!SuM8vr>^yumF2|y!t=o@dN&4!wfz|8;z`f}Q#4G>+ z>^zt~abUQoO92QYZqFzH+sCpVkrNnW6KU`KH}B|b=%QFw_9|vv`#0|IA*F~2ZE4QU zTczmi;Vt;Ta-H?eyfs!58hbVm{qXzWyEkpLECMjoxrqto0YFgWnS$x*RH>v#r?1pK z52*xQx_2Y4QB-a@3jm}cjJ@w}99-oCxSwkQAOek!U2e&*?%>DlX(LW-Od5dhe_|6;m})~|V)5F3WIQf@S3WAcjuAUZ`qjt!?0 zo-Qo0^052`)jQ~yrcLf?v9G(+2^Olgxw%DXz)AM_C;(%{u;@n9z1XKO+-$@(%8qZ_ zy8j{oyG|(Qg6%W9Z1q&cH3?MtcEjL#z*hCILD! zv{16Xrl86Ie*1dl!;@E!zW>&A-t=~=kH5VFf;iDf_6-$+*3(k_-dC4@J~UDfol*o~ tzQke8RqF2bwaHyyT-x%+n)b8@;6JK8ad47l2U!3B002ovPDHLkV1lH{dR_nk literal 0 HcmV?d00001 diff --git a/textures/snow_snow_cobble.png_01 b/textures/snow_snow_cobble.png_01 new file mode 100644 index 0000000000000000000000000000000000000000..e726395cebe7df249efb3c4406222a1a955df387 GIT binary patch literal 788 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 XuIY2&$!&9X00000NkvXXu0mjfdENK# literal 0 HcmV?d00001 diff --git a/textures/xdefault_furnace_bottom.png b/textures/xdefault_furnace_bottom.png new file mode 100644 index 0000000000000000000000000000000000000000..2d19b6b117ca93c69e04060a7734337f02d0ab3d GIT binary patch literal 604 zcmV-i0;BzjP)WRHXMskALrj{-v!wpw0-2QVO)R_COgt#ut9kb)Ut|_~JK7Hk&=3ByM~A zQJyw8@@;)B-?z8&V|OQ;`Gsk9_1?z);9kCZHMIQVnFH1WU|pWYdl zl`^1zApd$;KHmb-qOT7uBWr-dU@{z78zlJu!7;*QIvI<*SMp>dBK`X3e5Qw~q^LY9 zrJ`M_uap2`r){INXR6{^l8s#9;D#fCe q8v7@{HvI#XeJ^0s2KE$lZSgNBZ9ZwO#OAL60000QL70(Y)*K0-AbW|YuPgf;wBvGkO(bF8{akEHl_0H%r=8UXS@-^2FpBD-WFB z;M6L9xZ(c}ll-gCoC7yIMoxG*#gIKtKf(CLe^K?iHsxnFJnNl%CG3u#Tqx0X`s9n8 z7`>x<9p|GhbdHpmner&GO@70~WBP-sJA?T`uJY07h+rAdM2EZwf+h^JyA2o^GMZLQ USKQnt3v?xer>mdKI;Vst00sPCy8r+H literal 0 HcmV?d00001 diff --git a/textures/xdefault_furnace_fire_fg.png b/textures/xdefault_furnace_fire_fg.png new file mode 100644 index 0000000000000000000000000000000000000000..66aab6520c17f3527e0e53ea63df742fc4372879 GIT binary patch literal 803 zcmV+;1Kj+HP)Px#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2iyh& z4*(X+Ro>PB00N^)L_t(IPmPmlNK{c6hL7|kw=strQ)XP!Y_O4}MPxE9m!`-Sqi8V~ zEXZhaBKl!eP?``z{V1U_C^Hlzib#YK+T8<{RxC@(R1$PXXLQPXx^qVyCi~HWm;2rK zJKuBOd%0JL|5(TTd}RH@XO@}jA!eJ?>rR-vU9SB-DsLB~W{Kdbe&LL_M(J)B2Bill z0_F-yoK$-WNsc|G{%$USGUXha;?x*}J=v-Bot5TNh(gpZmgVR*NBdHsa?o=8eW{9A z0EfeAU+DnX>wN5@dsB#fe>Y4i+E%(diG8UHW}PyYtz~eVhF6L6cpl@;_bn^zwUBBd z)xw+;WEZ1_S_G$~7%2>8e0Lyy8BUlvf9Xu!8Lz;U9m+tKzwFtJTHYDvgE0azv|S^c zKZ>;UWN8>Jc0}!7>mgq!4lUwyh96^jYNm=KWsh@lSdK5pTAkob-<#%x-?R7@x5xS`N2#*i>I^Fi{DR@9jCoEV7VN{*Lym6l#I1G z2|n(?)|1OCzBMD(X z5)7x7%LCsE<}-OyH#1DRmY>bhv{!i2k|~(HuZPd+v=#|!!llQsr{u*NDU!kETj(zd zz;soL+_jNkpOWaT^PnMH8mNuORJ|Gob7{=*VPMaC3GhZw$HgG&?Qezm1}N1r(UJ@! zyWqOC`K9D_KR(6^89jrc0t? hwTh#DfBl8i>kr&alT0f5b;SSx002ovPDHLkV1lr~Zxa9j literal 0 HcmV?d00001 diff --git a/textures/xdefault_furnace_front.png b/textures/xdefault_furnace_front.png new file mode 100644 index 0000000000000000000000000000000000000000..88069c7e3cee27729f247e3763a4ba7e51008caf GIT binary patch literal 628 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 M07*qoM6N<$f&jdFw*UYD literal 0 HcmV?d00001 diff --git a/textures/xdefault_furnace_side.png b/textures/xdefault_furnace_side.png new file mode 100644 index 0000000000000000000000000000000000000000..2d19b6b117ca93c69e04060a7734337f02d0ab3d GIT binary patch literal 604 zcmV-i0;BzjP)WRHXMskALrj{-v!wpw0-2QVO)R_COgt#ut9kb)Ut|_~JK7Hk&=3ByM~A zQJyw8@@;)B-?z8&V|OQ;`Gsk9_1?z);9kCZHMIQVnFH1WU|pWYdl zl`^1zApd$;KHmb-qOT7uBWr-dU@{z78zlJu!7;*QIvI<*SMp>dBK`X3e5Qw~q^LY9 zrJ`M_uap2`r){INXR6{^l8s#9;D#fCe q8v7@{HvI#XeJ^0s2KE$lZSgNBZ9ZwO#OAL60000WRHXMskALrj{-v!wpw0-2QVO)R_COgt#ut9kb)Ut|_~JK7Hk&=3ByM~A zQJyw8@@;)B-?z8&V|OQ;`Gsk9_1?z);9kCZHMIQVnFH1WU|pWYdl zl`^1zApd$;KHmb-qOT7uBWr-dU@{z78zlJu!7;*QIvI<*SMp>dBK`X3e5Qw~q^LY9 zrJ`M_uap2`r){INXR6{^l8s#9;D#fCe q8v7@{HvI#XeJ^0s2KE$lZSgNBZ9ZwO#OAL60000B|mLR^7@ z%a)v6w&dK(WhYlGJF{xV*~N>mELwDR$>J+(*WTK?_3n-x_jc{Nf8fC5BS#(|JNER< znHLu?zPf(>&7C{%?%)6L@Zra&Pd~kW{q^I=pI^WJ{{H>fj~{=2{rdao&%b~F{sRpk z1*0J_m_r~WI*bSCKE{$DzhDN3XE)M7oFs2|7lsa2Sq~tGv%n*=n1O*?2!t6g-L3lr z6l5>)^mS#w&CM^YBGzz7?t<8 literal 0 HcmV?d00001 diff --git a/textures/xdefault_ice.png b/textures/xdefault_ice.png new file mode 100644 index 0000000000000000000000000000000000000000..4aa583a30f38b655e985e7f6f58b2000c5d73545 GIT binary patch literal 490 zcmVVGd000McNliru+zA5~Fc2&hGEFT8k={!vrSe{?J<0GwlJbtUq zW-qgq~9s{j(}I#3@BLIGHj2+NdBWH6umNPDxnSTI7+cKe77d10w} zI4bORt4vVS+3c;T6Di+WrCEjWs^U3PBu? zZ;=Hc%jK6c0vODg6)*Fusx~lanwz0z*~JD(8+@xz21wF(M%TDGhoZ_*+wWf%Ouw3m zjtxds*1^RYq({SgM4Mz?95Gt6fFc8uSl$0s2^>Z`9BkZ(*6%nB0_dGLy+)*}UN%r2 zP+h;{Y-|fS@;nTM3Q(h8gqe_>(k4kWFaQ+jrM;8Ly4a4Wk_-qd=RF)gp#=?)1ofZ( gttGTaJMwGIKaLDRPUIx#3jhEB07*qoM6N<$f??##hX4Qo literal 0 HcmV?d00001 diff --git a/textures/xdefault_ice.xcf b/textures/xdefault_ice.xcf new file mode 100644 index 0000000000000000000000000000000000000000..425d23697e867ea237b2f41eeb65b4c7e5ccb826 GIT binary patch literal 1400 zcmeHE&2G~`5RMI$Qb4rg=fuGW4(%aTd*J~P55WzkY2sQ+ld4Ij_5>2Iuy&H2wf6-; zw6r<%08uMI#Lof9j*~d{G81e_Rm2l8_GG{P_WNchW7FE*GY-pDqiWSE1&rk^39n#k z8vfkJTzvL%{Dczm1I+7~I_9GclkOqvALF`gV%eg#TQVy}bKlxVs(|NOVYS&hs#T0; zqh@WdEv;6~a--JRH&$m$ao^l38Jp`HvoJQUfc$6;ty}-H=E6V4a)zvj&An3Ds+-2< z)9eZ)kN!qxT=Af8wG69X-l;Un->6obmDcYD$$gdj#ay=19J0{f>&2$;tOa9}z+hQ7o40{ph@w1L|ofenBkvo`p^ zd!7xp5A74-%072UB0mT?=e+$17z{YLpFJ430KG0a7aim@cwMmHF(FPx7v6&-1@FA| zfSoabQ`dI=E?fxK9taM77fVTy9yniI2k=_vOUVGc=>QBE6Fx8>Wapgj0^#;NI05On zZ5Mll?wKP`I0(mfu@NgQ85QeA=@lm4`cjF+9NOev92-9>tRwPs^RyWir zQNv-3gr*Yo>*`yA{79)Jjug^FeaAYnid2X+UXIdqh_&L;R1L|O%qUW(6WnV70;1wc wi0TCu;aw5dBrcpHOo$+>mc&>yz&^$k>@|$Y6~qBGorJ`vQ-p=|l~zzc0rkg+_5c6? literal 0 HcmV?d00001 diff --git a/textures/xdefault_snow.png b/textures/xdefault_snow.png new file mode 100644 index 0000000000000000000000000000000000000000..b4d0cc8d3c86a279b3e55887b59eed43e9c04f38 GIT binary patch literal 278 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`jKx9jP7LeL$-D$|*pj^6T^Rm@ z;DWu&Cj&(|3p^r=85sBugD~Uq{1qucLG}_)Usv`!?92>C8W$^mHUfpFdAc};SoF3A zHS#tXaJ>F+FXexM-(-ft?pszun>IQ&GWC6~T5|4EZvER`n_orW%wS+kY?#IuAT4`^ zv1-|N#tEn1=;%#gjk2;{YoWpVef^=@?Af*bGJhC9R6lu;KS!7$d_kl|v6T6o&70N= z&+sTYy~ttRUdKh}uCnfAoy8C&>NVqc^Xs!85B%3TZMf@_efN@cvrIn*Jm+PdeA#2I Tz_K+!7czLd`njxgN@xNAG2&@* literal 0 HcmV?d00001 diff --git a/textures/xdefault_stone_brick.png b/textures/xdefault_stone_brick.png new file mode 100644 index 0000000000000000000000000000000000000000..8032f7d96f9e0f40ba3de49d2c74bc46ceb5764c GIT binary patch literal 636 zcmV-?0)zdDP)ejTvL;v<2dY$bc(NZEA;=|Bjh3@db(p@tg0Za5e8x|B?1$AGkNRk)cu5 zs!`=uqw%*0$4dr0