mods/hades_fertilizer/init.lua

   1 local S = minetest.get_translator("hades_fertilizer")
   2
   3 local farms = { "wheat", "cotton", "spice", "potato", "tomato", "strawberry" }
   4
   5 -- Register tables for all plant variants
   6 local plants_rotate = {}
   7 do
   8         local t
   9         -- Growth stages
  10
  11         for f=1, #farms do
  12                 t = { false }
  13                 table.insert(t, "hades_farming:seed_"..farms[f])
  14                 for i=1,3 do
  15                         table.insert(t, "hades_farming:"..farms[f].."_"..i)
  16                 end
  17                 table.insert(plants_rotate, t)
  18         end
  19
  20         t = { true, "hades_grass:seed_grass", "hades_grass:grass_1", "hades_grass:grass_2", "hades_grass:grass_3", "hades_grass:grass_4", "hades_grass:grass_5" }
  21         table.insert(plants_rotate, t)
  22
  23         t = { true, "hades_refruit:bud_apple", "hades_refruit:flower_apple", "hades_trees:apple" }
  24         table.insert(plants_rotate, t)
  25
  26         t = { true, "hades_refruit:bud_olive", "hades_refruit:flower_olive", "hades_trees:olive" }
  27         table.insert(plants_rotate, t)
  28
  29         t = { true, "hades_refruit:bud_orange", "hades_refruit:flower_orange", "hades_trees:orange" }
  30         table.insert(plants_rotate, t)
  31
  32         t = { true, "hades_refruit:bud_banana", "hades_refruit:flower_banana", "hades_trees:banana" }
  33         table.insert(plants_rotate, t)
  34
  35         t = { true, "hades_refruit:bud_cocoa", "hades_refruit:flower_cocoa", "hades_trees:cocoa_pod" }
  36         table.insert(plants_rotate, t)
  37
  38         t = { true, "hades_refruit:bud_coconut", "hades_refruit:flower_coconut", "hades_trees:coconut" }
  39         table.insert(plants_rotate, t)
  40
  41         t = { false }
  42         for i=1,5 do
  43                 table.insert(t, "hades_grass:grass_"..i)
  44         end
  45         table.insert(plants_rotate, t)
  46 end
  47
  48 local plant_mappings = {}
  49 for p=1, #plants_rotate do
  50         local rotate = plants_rotate[p]
  51         local super = rotate[1]
  52         for r=2, #rotate-1 do
  53                 local nextr = r+1
  54                 plant_mappings[rotate[r]] = { rotate[nextr], super }
  55         end
  56 end
  57
  58 -- Call minetest.set_node(pos, node), but only if pos is not protected by playername
  59 local set_node_protected = function(pos, node, playername)
  60         if not (minetest.is_protected(pos, playername) and not minetest.check_player_privs(playername, "protection_bypass")) then
  61                 minetest.set_node(pos, node)
  62                 return true
  63         end
  64         return false
  65 end
  66
  67 -- Returns an on_place function for fertilizer.
  68 -- 'super' parameter is true for Super Fertilizer and false for normal fertilizer
  69 local get_apply_fertilizer = function(super)
  70         return function(itemstack, placer, pointed_thing)
  71                 if not pointed_thing or pointed_thing.type ~= "node" or not placer then
  72                         return itemstack
  73                 end
  74                 local name = placer:get_player_name()
  75                 local pos = pointed_thing.under
  76                 local nnode = minetest.get_node(pos)
  77                 local nname = nnode.name
  78
  79                 -- Boilerplate to check pointed node's on rightlick function
  80                 local def = minetest.registered_nodes[nname]
  81                 if def and def.on_rightclick and
  82                         ((not placer) or (placer and not placer:get_player_control().sneak)) then
  83                         return def.on_rightclick(pos, nnode, placer, itemstack,
  84                                 pointed_thing) or itemstack
  85                 end
  86
  87                 if minetest.is_protected(pos, name) and not minetest.check_player_privs(name, "protection_bypass") then
  88                         minetest.record_protection_violation(pos, name)
  89                         return itemstack
  90                 end
  91
  92                 if plant_mappings[nname] then
  93                         if (not super) then
  94                                 -- Restrict usable plants if not super fertilizer
  95                                 if plant_mappings[nname][2] == true then return itemstack end
  96                                 if math.random(1,3) == 1 then return itemstack end
  97                         end
  98                         -- Add plant growth stage
  99                         set_node_protected(pos, {name=plant_mappings[nname][1], param2=nnode.param2}, name)
 100                 elseif minetest.get_item_group(nname, "sapling") ~= 0 then
 101                         if not super and math.random(1,5) ~= 1 then return itemstack end
 102                         -- Grow sapling to tree
 103                         if minetest.is_protected(pos, name) and not minetest.check_player_privs(name, "protection_bypass") then
 104                                 return itemstack
 105                         else
 106                                 hades_trees.grow_sapling(pos, false)
 107                         end
 108                 elseif nname == "hades_flowerpots:flower_pot" then
 109                         if not super then return itemstack end
 110                         -- [SUPER] Grow random flower in empty flowerpot
 111                         local flowers = {
 112                                 "red", "white", "yellow", "orange", "yellow", "violet",
 113                         }
 114                         local flower = flowers[math.random(1, #flowers)]
 115                         set_node_protected(pos, {name="hades_flowerpots:flower_pot_"..flower}, name)
 116                 elseif minetest.get_item_group(nname, "leaves") == 1 then
 117                         if not super then return itemstack end
 118                         -- [SUPER] Grow leaves
 119                         local posses = {
 120                                 { x=0, y=0, z=1 },
 121                                 { x=0, y=0, z=-1 },
 122                                 { x=0, y=1, z=0 },
 123                                 { x=0, y=-1, z=0 },
 124                                 { x=1, y=0, z=0 },
 125                                 { x=-1, y=0, z=0 },
 126                         }
 127                         for p=1, #posses do
 128                                 local ppos = vector.add(pos, posses[p])
 129                                 if minetest.get_node(ppos).name == "air" then
 130                                         set_node_protected(ppos, {name=nname, param2=nnode.param2}, name)
 131                                 end
 132                         end
 133                 elseif nname == "hades_core:papyrus" or nname == "hades_core:sugarcane" or nname == "hades_core:cactus" or minetest.get_item_group(nname, "tree") == 1 then
 134                         if not super then return itemstack end
 135                         -- [SUPER] Grow reeds and tree trunks upwards
 136                         local above
 137                         for i=1,15 do
 138                                 above = {x=pos.x,y=pos.y+i,z=pos.z}
 139                                 local node = minetest.get_node(above)
 140                                 if node.name == "air" then
 141                                         set_node_protected(above, {name=nname}, name)
 142                                         break
 143                                 elseif node.name ~= nname then
 144                                         break
 145                                 end
 146                         end
 147                 elseif minetest.get_item_group(nname, "vines") ~= 0 or nname == "hades_vines:root" then
 148                         if not super then return itemstack end
 149                         -- [SUPER] Grow vines
 150                         local param2 = nnode.param2
 151                         if param2 >= 2 or def.paramtype2 ~= "wallmounted" then
 152                                 -- Grow downwards
 153                                 local below
 154                                 for i=1,15 do
 155                                         below = {x=pos.x,y=pos.y-i,z=pos.z}
 156                                         local node = minetest.get_node(below)
 157                                         if node.name == "air" then
 158                                                 set_node_protected(below, {name=nname, param2=param2}, name)
 159                                                 break
 160                                         elseif node.name ~= nname then
 161                                                 break
 162                                         end
 163                                 end
 164                         end
 165                 elseif nname == "hades_core:dirt" or minetest.get_item_group(nname, "dirt_with_grass") > 1 or nname == "hades_core:stone" or nname == "hades_core:tuff" or nname == "hades_core:cobble" or nname == "hades_walls:cobble" then
 166                         -- Grow grass cover on dirt
 167                         -- [SUPER] also grow moss
 168                         local posses = {}
 169                         local minmax
 170                         local dwg2 = minetest.get_item_group(nname, "dirt_with_grass")
 171                         local d2 = minetest.get_item_group(nname, "dirt")
 172                         if super then
 173                                 minmax=2
 174                         else
 175                                 if d2 == 0 and dwg2 == 0 then
 176                                         return itemstack
 177                                 end
 178                                 minmax=1
 179                         end
 180                         local season_color = hades_core.get_seasonal_grass_color_param2()
 181                         for x = pos.x - minmax, pos.x + minmax do
 182                         for y = pos.y, pos.y do
 183                         for z = pos.z - minmax, pos.z + minmax do
 184                                 local ppos = {x = x, y = y, z = z}
 185                                 if vector.distance(pos, ppos) <= 2.3 then
 186                                         local node = minetest.get_node(ppos)
 187                                         local above_node = minetest.get_node({x = x, y = y + 1, z = z})
 188                                         -- Apply change to same or "compatible" node type as the pointed
 189                                         -- node only, e.g. dirt is "compatible" with dirt-with-grass
 190                                         local d1 = minetest.get_item_group(node.name, "dirt")
 191                                         local dwg1 = minetest.get_item_group(node.name, "dirt_with_grass")
 192                                         if ((node.name == nname) or ((dwg1 > 1 or d1 > 0) and (dwg2 > 1 or d2 > 0))) and
 193                                                         (nname ~= "hades_core:dirt" or
 194                                                         (minetest.registered_nodes[above_node.name] and
 195                                                         minetest.registered_nodes[above_node.name].walkable == false)) then
 196                                                 if nname == "hades_core:dirt" then
 197                                                         node.name = "hades_core:dirt_with_grass"
 198                                                         node.param2 = season_color
 199                                                 elseif dwg2 > 0 then
 200                                                         node.name = "hades_core:dirt_with_grass"
 201                                                         node.param2 = season_color
 202                                                 elseif nname == "hades_core:stone" then
 203                                                         node.name = "hades_core:mossystone"
 204                                                 elseif nname == "hades_core:tuff" then
 205                                                         node.name = "hades_core:mossytuff"
 206                                                 elseif nname == "hades_core:cobble" then
 207                                                         node.name = "hades_core:mossycobble"
 208                                                 elseif nname == "hades_walls:cobble" then
 209                                                         node.name = "hades_walls:mossycobble"
 210                                                 end
 211                                                 set_node_protected(ppos, node, name)
 212                                         end
 213                                 end
 214                         end
 215                         end
 216                         end
 217                 elseif nname == "hades_grass:grass" or nname == "hades_core:dirt_with_grass" or nname == "hades_core:fertile_sand" or nname == "hades_core:ash" or nname == "hades_core:volcanic_sand" or nname == "hades_core:gravel" or nname == "hades_core:gravel_volcanic" or nname == "hades_farming:soil" or nname == "hades_farming:soil_wet" then
 218                         -- Grow grass, flowers and other random plants
 219                         for x = pos.x - 2, pos.x + 2 do
 220                         for y = pos.y, pos.y do
 221                         for z = pos.z - 2, pos.z + 2 do
 222                                 local ppos = {x = x, y = y, z = z}
 223                                 if vector.distance(pos, ppos) <= 2.3 then
 224                                         local node = minetest.get_node(ppos)
 225                                         local pos_above = {x = x, y = y + 1, z = z}
 226                                         local above_node = minetest.get_node(pos_above)
 227                                         if above_node.name == "air" and math.random() < 0.2 and node.name == nname then
 228                                                 local plants
 229                                                 local p2season = hades_core.get_seasonal_grass_color_param2()
 230                                                 if (node.name == "hades_grass:grass" or node.name == "hades_core:dirt_with_grass") then
 231                                                         if super then
 232                                                         plants = {
 233                                                         {"hades_grass:grass_1", p2season},
 234                                                         {"hades_grass:grass_2", p2season},
 235                                                         {"hades_grass:grass_3", p2season},
 236                                                         {"hades_grass:grass_4", p2season},
 237                                                         {"hades_grass:grass_5", p2season},
 238                                                         {"hades_grass:grass_1", p2season},
 239                                                         {"hades_grass:grass_2", p2season},
 240                                                         {"hades_grass:grass_3", p2season},
 241                                                         {"hades_grass:grass_4", p2season},
 242                                                         {"hades_grass:grass_5", p2season},
 243                                                         {"hades_grass:grass_1", p2season},
 244                                                         {"hades_grass:grass_2", p2season},
 245                                                         {"hades_grass:grass_3", p2season},
 246                                                         {"hades_grass:grass_4", p2season},
 247                                                         {"hades_grass:grass_5", p2season},
 248                                                         {"hades_grass:grass_1", p2season},
 249                                                         {"hades_grass:grass_2", p2season},
 250                                                         {"hades_grass:grass_3", p2season},
 251                                                         {"hades_grass:grass_4", p2season},
 252                                                         {"hades_grass:grass_5", p2season},
 253                                                         {"hades_grass:junglegrass"},
 254                                                         {"hades_grass:junglegrass"},
 255                                                         {"hades_grass:junglegrass"},
 256                                                         {"hades_grass:junglegrass"},
 257                                                         {"hades_flowers:flowergrass"},
 258                                                         {"hades_flowers:red"},
 259                                                         {"hades_flowers:white"},
 260                                                         {"hades_flowers:yellow"},
 261                                                         {"hades_flowers:orange"},
 262                                                         {"hades_flowers:violet"},
 263                                                         {"hades_flowers:blue"},
 264                                                         }
 265                                                         else
 266                                                         plants = {
 267                                                         {"hades_grass:grass_1", p2season},
 268                                                         {"hades_grass:grass_2", p2season},
 269                                                         {"hades_grass:grass_3", p2season},
 270                                                         {"hades_grass:grass_4", p2season},
 271                                                         {"hades_grass:grass_5", p2season},
 272                                                         }
 273                                                         end
 274                                                 elseif (node.name == "hades_core:ash" or node.name == "hades_core:volcanic_sand" or node.name == "hades_core:gravel_volcanic") then
 275                                                         if not super then return itemstack end
 276                                                         plants = {
 277                                                         { "hades_bushes:branch_bush"},
 278                                                         }
 279                                                 elseif (node.name == "hades_core:fertile_sand" or node.name == "hade_core:gravel") then
 280                                                         if not super then return itemstack end
 281                                                         plants = {
 282                                                         { "hades_bushes:branch_bush"},
 283                                                         { "hades_grass:grass_1", p2season},
 284                                                         }
 285                                                 elseif (node.name == "hades_farming:soil" or node.name == "hades_farming:soil_wet") then
 286                                                         if not super then return itemstack end
 287                                                         plants = {
 288                                                         {"hades_farming:seed_wheat"},
 289                                                         {"hades_farming:seed_cotton"},
 290                                                         {"hades_farming:seed_tomato"},
 291                                                         {"hades_farming:seed_strawberry"},
 292                                                         {"hades_farming:seed_spice"},
 293                                                         {"hades_farming:seed_potato"},
 294                                                         }
 295                                                 end
 296                                                 if plants then
 297                                                         local rnd = math.random(1, #plants)
 298                                                         local plant = plants[rnd][1]
 299                                                         local pdef = minetest.registered_nodes[plant]
 300                                                         local p2
 301                                                         if plants[rnd][2] then
 302                                                                 p2 = plants[rnd][2]
 303                                                         else
 304                                                                 p2 = pdef.place_param2
 305                                                         end
 306                                                         local nnode = {name = plant, param2 = p2}
 307                                                         set_node_protected(pos_above, nnode, name)
 308                                                 end
 309                                         end
 310                                 end
 311                         end
 312                         end
 313                         end
 314                 elseif minetest.get_item_group(nname, "waterlily") ~= 0 or minetest.get_item_group(nname, "seaweed") ~= 0 then
 315                         if not super then return itemstack end
 316                         -- [SUPER] Spread waterlilies and seaweed on water
 317                         for x = pos.x - 3, pos.x + 3 do
 318                         for y = pos.y, pos.y do
 319                         for z = pos.z - 3, pos.z + 3 do
 320                                 local ppos = {x = x, y = y, z = z}
 321                                 if vector.distance(pos, ppos) <= 3.0 then
 322                                         local node = minetest.get_node(ppos)
 323                                         local below_node = minetest.get_node({x = x, y = y - 1, z = z})
 324                                         if node.name == "air" and
 325                                                         math.random() < 0.1 and
 326                                                         minetest.get_item_group(below_node.name, "water") >= 1 and
 327                                                         minetest.registered_nodes[below_node.name].liquidtype == "source" then
 328                                                 node.name = nname
 329                                                 node.param2 = math.random(0,3)
 330                                                 set_node_protected(ppos, node, name)
 331                                         end
 332                                 end
 333                         end
 334                         end
 335                         end
 336
 337                 end
 338                 if not super and not minetest.is_creative_enabled(placer:get_player_name()) then
 339                         itemstack:take_item()
 340                 end
 341                 return itemstack
 342         end
 343 end
 344
 345 -- Fertilizer helps grow a few plants
 346 minetest.register_craftitem("hades_fertilizer:fertilizer", {
 347         description = S("Fertilizer"),
 348         _tt_help = S("Makes plants grow"),
 349         inventory_image = "hades_fertilizer_fertilizer.png",
 350         on_place = get_apply_fertilizer(false),
 351         groups = { tool = 1 },
 352 })
 353
 354 -- Super Fertilizer makes almost everything grow; only for Creative Mode
 355 minetest.register_craftitem("hades_fertilizer:super_fertilizer", {
 356         description = S("Super Fertilizer"),
 357         _tt_help = S("Makes a lot of plants grow"),
 358         inventory_image = "hades_fertilizer_super_fertilizer.png",
 359         on_place = get_apply_fertilizer(true),
 360         groups = { tool = 1 },
 361 })