mods/plantlife/flowers_plus/init.lua

   1 local S = minetest.get_translator("flowers_plus")
   2
   3 -- This file supplies a few additional plants and some related crafts
   4 -- for the plantlife modpack.  Last revision:  2013-04-24
   5
   6
   7 flowers_plus = {}
   8
   9
  10 local SPAWN_DELAY = 1000
  11 local SPAWN_CHANCE = 200
  12 local flowers_seed_diff = 329
  13 local lilies_max_count = 12
  14 local lilies_rarity = 33
  15 local seaweed_max_count = 20
  16 local seaweed_rarity = 33
  17 -- globals
  18 local lilypads_max_count = {}
  19 local lilypads_rarity = {}
  20 -- register the various rotations of waterlilies
  21
  22
  23 local lilies_list = {
  24         { nil  , nil       , 1  },
  25         { "225", "22.5"    , 2  },
  26         { "45" , "45"      , 3  },
  27         { "675", "67.5"    , 4  },
  28         { "s1" , "small_1" , 5  },
  29         { "s2" , "small_2" , 6  },
  30         { "s3" , "small_3" , 7  },
  31         { "s4" , "small_4" , 8  },
  32 }
  33
  34
  35 for i in ipairs(lilies_list) do
  36         local deg1 = ""
  37         local deg2 = ""
  38         local lily_groups = {snappy = 3,flammable=2,waterlily=1}
  39
  40
  41         if lilies_list[i][1] ~= nil then
  42                 deg1 = "_"..lilies_list[i][1]
  43                 deg2 = "_"..lilies_list[i][2]
  44                 lily_groups = { snappy = 3,flammable=2,waterlily=1, not_in_creative_inventory=1 }
  45         end
  46
  47
  48         minetest.register_node(":flowers:waterlily"..deg1, {
  49                 description = S("Waterlily"),
  50                 drawtype = "nodebox",
  51                 tiles = {
  52                         "flowers_waterlily"..deg2..".png",
  53                         "flowers_waterlily"..deg2..".png^[transformFY"
  54                 },
  55                 inventory_image = "flowers_waterlily.png",
  56                 wield_image  = "flowers_waterlily.png",
  57                 sunlight_propagates = true,
  58                 paramtype = "light",
  59                 paramtype2 = "facedir",
  60                 walkable = false,
  61                 groups = lily_groups,
  62                 sounds = hades_sounds.node_sound_leaves_defaults(),
  63                 selection_box = {
  64                         type = "fixed",
  65                         fixed = { -0.4, -0.5, -0.4, 0.4, -0.45, 0.4 },
  66                 },
  67                 node_box = {
  68                         type = "fixed",
  69                         fixed = { -0.5, -0.49, -0.5, 0.5, -0.49, 0.5 },
  70                 },
  71                 buildable_to = true,
  72
  73
  74                 liquids_pointable = true,
  75                 drop = "flowers:waterlily",
  76                 on_place = function(itemstack, placer, pointed_thing)
  77                         local keys=placer:get_player_control()
  78                         local pt = pointed_thing
  79
  80
  81                         local place_pos = nil
  82                         local top_pos = {x=pt.under.x, y=pt.under.y+1, z=pt.under.z}
  83                         local under_node = minetest.get_node(pt.under)
  84                         local above_node = minetest.get_node(pt.above)
  85                         local top_node   = minetest.get_node(top_pos)
  86
  87
  88                         if plantslib:get_nodedef_field(under_node.name, "buildable_to") then
  89                                 if under_node.name ~= "hades_core:water_source" then
  90                                         place_pos = pt.under
  91                                 elseif top_node.name ~= "hades_core:water_source"
  92                                        and plantslib:get_nodedef_field(top_node.name, "buildable_to") then
  93                                         place_pos = top_pos
  94                                 else
  95                                         return itemstack
  96                                 end
  97                         elseif plantslib:get_nodedef_field(above_node.name, "buildable_to") then
  98                                 place_pos = pt.above
  99                         end
 100
 101                         if not place_pos then
 102                                 return itemstack
 103                         end
 104
 105                         if not plantslib:node_is_owned(place_pos, placer) then
 106
 107                                 local nodename = "hades_core:cobble" -- if this block appears, something went....wrong :-)
 108
 109                                 if not keys["sneak"] then
 110                                         local node = minetest.get_node(pt.under)
 111                                         local waterlily = math.random(1,8)
 112                                         if waterlily == 1 then
 113                                                 nodename = "flowers:waterlily"
 114                                         elseif waterlily == 2 then
 115                                                 nodename = "flowers:waterlily_225"
 116                                         elseif waterlily == 3 then
 117                                                 nodename = "flowers:waterlily_45"
 118                                         elseif waterlily == 4 then
 119                                                 nodename = "flowers:waterlily_675"
 120                                         elseif waterlily == 5 then
 121                                                 nodename = "flowers:waterlily_s1"
 122                                         elseif waterlily == 6 then
 123                                                 nodename = "flowers:waterlily_s2"
 124                                         elseif waterlily == 7 then
 125                                                 nodename = "flowers:waterlily_s3"
 126                                         elseif waterlily == 8 then
 127                                                 nodename = "flowers:waterlily_s4"
 128                                         end
 129                                         minetest.add_node(place_pos, {name = nodename, param2 = math.random(0,3) })
 130                                 else
 131                                         local fdir = minetest.dir_to_facedir(placer:get_look_dir())
 132                                         minetest.add_node(place_pos, {name = "flowers:waterlily", param2 = fdir})
 133                                 end
 134
 135
 136                                 if not plantslib.expect_infinite_stacks then
 137                                         itemstack:take_item()
 138                                 end
 139                                 return itemstack
 140                         end
 141                 end,
 142                 on_rotate = "simple",
 143         })
 144 end
 145
 146
 147 local algae_list = { {nil}, {2}, {3}, {4} }
 148
 149
 150 for i in ipairs(algae_list) do
 151         local num = ""
 152         local algae_groups = {snappy = 3,flammable=2,seaweed=1}
 153
 154
 155         if algae_list[i][1] ~= nil then
 156                 num = "_"..algae_list[i][1]
 157                 algae_groups = { snappy = 3,flammable=2,seaweed=1, not_in_creative_inventory=1 }
 158         end
 159
 160
 161         minetest.register_node(":flowers:seaweed"..num, {
 162                 description = S("Seaweed"),
 163                 drawtype = "nodebox",
 164                 tiles = {
 165                         "flowers_seaweed"..num..".png",
 166                         "flowers_seaweed"..num..".png^[transformFY"
 167                 },
 168                 inventory_image = "flowers_seaweed_2.png",
 169                 wield_image  = "flowers_seaweed_2.png",
 170                 sunlight_propagates = true,
 171                 paramtype = "light",
 172                 paramtype2 = "facedir",
 173                 walkable = false,
 174                 groups = algae_groups,
 175                 sounds = hades_sounds.node_sound_leaves_defaults(),
 176                 selection_box = {
 177                         type = "fixed",
 178                         fixed = { -0.4, -0.5, -0.4, 0.4, -0.45, 0.4 },
 179                 },
 180                 node_box = {
 181                         type = "fixed",
 182                         fixed = { -0.5, -0.49, -0.5, 0.5, -0.49, 0.5 },
 183                 },
 184                 buildable_to = true,
 185
 186
 187                 liquids_pointable = true,
 188                 drop = "flowers:seaweed",
 189                 on_place = function(itemstack, placer, pointed_thing)
 190                         local keys=placer:get_player_control()
 191                         local pt = pointed_thing
 192
 193
 194                         local place_pos = nil
 195                         local top_pos = {x=pt.under.x, y=pt.under.y+1, z=pt.under.z}
 196                         local under_node = minetest.get_node(pt.under)
 197                         local above_node = minetest.get_node(pt.above)
 198                         local top_node   = minetest.get_node(top_pos)
 199
 200
 201                         if plantslib:get_nodedef_field(under_node.name, "buildable_to") then
 202                                 if under_node.name ~= "hades_core:water_source" then
 203                                         place_pos = pt.under
 204                                 elseif top_node.name ~= "hades_core:water_source"
 205                                        and plantslib:get_nodedef_field(top_node.name, "buildable_to") then
 206                                         place_pos = top_pos
 207                                 else
 208                                         return itemstack
 209                                 end
 210                         elseif plantslib:get_nodedef_field(above_node.name, "buildable_to") then
 211                                 place_pos = pt.above
 212                         end
 213                         if not place_pos then
 214                                 return itemstack
 215                         end
 216
 217                         if not plantslib:node_is_owned(place_pos, placer) then
 218
 219
 220                                 local nodename = "hades_core:cobble" -- :D
 221
 222                                 if not keys["sneak"] then
 223                                         local node = minetest.get_node(pt.under)
 224                                         local seaweed = math.random(1,4)
 225                                         if seaweed == 1 then
 226                                                 nodename = "flowers:seaweed"
 227                                         elseif seaweed == 2 then
 228                                                 nodename = "flowers:seaweed_2"
 229                                         elseif seaweed == 3 then
 230                                                 nodename = "flowers:seaweed_3"
 231                                         elseif seaweed == 4 then
 232                                                 nodename = "flowers:seaweed_4"
 233                                         end
 234                                         minetest.add_node(place_pos, {name = nodename, param2 = math.random(0,3) })
 235                                 else
 236                                         local fdir = minetest.dir_to_facedir(placer:get_look_dir())
 237                                         minetest.add_node(place_pos, {name = "flowers:seaweed", param2 = fdir})
 238                                 end
 239
 240
 241                                 if not plantslib.expect_infinite_stacks then
 242                                         itemstack:take_item()
 243                                 end
 244                                 return itemstack
 245                         end
 246                 end,
 247                 on_rotate = "simple",
 248         })
 249 end
 250
 251
 252 -- register all potted plant nodes, crafts, and most backward-compat aliases
 253
 254
 255 local extra_aliases = {
 256         "waterlily",
 257         "waterlily_225",
 258         "waterlily_45",
 259         "waterlily_675",
 260         "seaweed"
 261 }
 262
 263
 264 for i in ipairs(extra_aliases) do
 265         local flower = extra_aliases[i]
 266         minetest.register_alias("flowers:flower_"..flower, "flowers:"..flower)
 267 end
 268
 269
 270 minetest.register_alias( "trunks:lilypad"         ,     "flowers:waterlily_s1" )
 271 minetest.register_alias( "along_shore:lilypads_1" , "flowers:waterlily_s1" )
 272 minetest.register_alias( "along_shore:lilypads_2" , "flowers:waterlily_s2" )
 273 minetest.register_alias( "along_shore:lilypads_3" , "flowers:waterlily_s3" )
 274 minetest.register_alias( "along_shore:lilypads_4" , "flowers:waterlily_s4" )
 275 minetest.register_alias( "along_shore:pondscum_1" ,     "flowers:seaweed"      )
 276 minetest.register_alias( "along_shore:seaweed_1"  ,     "flowers:seaweed"      )
 277 minetest.register_alias( "along_shore:seaweed_2"  ,     "flowers:seaweed_2"    )
 278 minetest.register_alias( "along_shore:seaweed_3"  ,     "flowers:seaweed_3"    )
 279 minetest.register_alias( "along_shore:seaweed_4"  ,     "flowers:seaweed_4"    )
 280
 281
 282 -- ongen registrations
 283
 284
 285 flowers_plus.grow_waterlily = function(pos)
 286         local right_here = {x=pos.x, y=pos.y+1, z=pos.z}
 287         for i in ipairs(lilies_list) do
 288                 local chance = math.random(1,8)
 289                 local ext = ""
 290                 local num = lilies_list[i][3]
 291
 292
 293                 if lilies_list[i][1] ~= nil then
 294                         ext = "_"..lilies_list[i][1]
 295                 end
 296
 297
 298                 if chance == num then
 299                         minetest.add_node(right_here, {name="flowers:waterlily"..ext, param2=math.random(0,3)})
 300                 end
 301         end
 302 end
 303
 304
 305 plantslib:register_generate_plant({
 306     surface = {"hades_core:water_source"},
 307     max_count = lilypads_max_count,
 308     rarity = lilypads_rarity,
 309     min_elevation = -30,
 310         max_elevation = 100,
 311         near_nodes = {"hades_core:dirt_with_grass"},
 312         near_nodes_size = 4,
 313         near_nodes_vertical = 1,
 314         near_nodes_count = 1,
 315     plantlife_limit = -0.9,
 316     temp_max = -0.22,
 317     temp_min = 0.22,
 318   },
 319   "flowers_plus.grow_waterlily"
 320 )
 321
 322
 323 flowers_plus.grow_seaweed = function(pos)
 324         local right_here = {x=pos.x, y=pos.y+1, z=pos.z}
 325         minetest.add_node(right_here, {name="along_shore:seaweed_"..math.random(1,4), param2=math.random(1,3)})
 326 end
 327
 328
 329 plantslib:register_generate_plant({
 330     surface = {"hades_core:water_source"},
 331     max_count = seaweed_max_count,
 332     rarity = seaweed_rarity,
 333     -- min_elevation = 1,
 334         max_elevation = 100,
 335         near_nodes = {"hades_core:mossystone", "hades_core:dirt_with_grass"},
 336         near_nodes_size = 3,
 337         near_nodes_vertical = 2,
 338         near_nodes_count = 1,
 339     plantlife_limit = -1.0,
 340   },
 341   "flowers_plus.grow_seaweed"
 342 )
 343
 344
 345 -- seaweed at beaches
 346 -- MM: not satisfied with it, but IMHO some beaches should have some algae
 347 --plantslib:register_generate_plant({
 348     --surface = {"hades_core:water_source"},
 349    -- max_count = seaweed_max_count,
 350     --rarity = seaweed_rarity,
 351     -- min_elevation = 1,
 352         --max_elevation = 100,
 353         --near_nodes = {"hades_core:ash"},
 354         --near_nodes_size = 1,
 355         --near_nodes_vertical = 0,
 356         --near_nodes_count = 3,
 357     --plantlife_limit = -0.9,
 358     --temp_max = -0.64, -- MM: more or less random values, just to make sure it's not everywhere
 359     --temp_min = -0.22, -- MM: more or less random values, just to make sure it's not everywhere
 360   --},
 361   --"flowers_plus.grow_seaweed"
 362 --)
 363 --plantslib:register_generate_plant({
 364     --surface = {"hades_core:ash"},
 365     --max_count = seaweed_max_count*2,
 366     --rarity = seaweed_rarity/2,
 367     -- min_elevation = 1,
 368         --max_elevation = 40,
 369         --near_nodes = {"hades_core:water_source"},
 370         --near_nodes_size = 1,
 371         --near_nodes_vertical = 0,
 372         --near_nodes_count = 3,
 373     --plantlife_limit = -0.9,
 374     --temp_max = -0.64, -- MM: more or less random values, just to make sure it's not everywhere
 375     --temp_min = -0.22, -- MM: more or less random values, just to make sure it's not everywhere
 376   --},
 377   --"flowers_plus.grow_seaweed"
 378 --)
 379 -- spawn ABM registrations
 380
 381
 382 plantslib:spawn_on_surfaces({
 383         spawn_delay = SPAWN_DELAY/2,
 384         spawn_plants = {
 385                 "flowers:waterlily",
 386                 "flowers:waterlily_225",
 387                 "flowers:waterlily_45",
 388                 "flowers:waterlily_675",
 389                 "flowers:waterlily_s1",
 390                 "flowers:waterlily_s2",
 391                 "flowers:waterlily_s3",
 392                 "flowers:waterlily_s4"
 393         },
 394         avoid_radius = 2.5,
 395         spawn_chance = SPAWN_CHANCE*4,
 396         spawn_surfaces = {"hades_core:water_source"},
 397         avoid_nodes = {"group:flower", "group:flora" },
 398         seed_diff = flowers_seed_diff,
 399         light_min = 9,
 400         depth_max = 2,
 401         random_facedir = {0,3}
 402 })
 403
 404
 405 plantslib:spawn_on_surfaces({
 406         spawn_delay = SPAWN_DELAY*2,
 407         spawn_plants = {"flowers:seaweed"},
 408         spawn_chance = SPAWN_CHANCE*2,
 409         spawn_surfaces = {"hades_core:water_source"},
 410         avoid_nodes = {"group:flower", "group:flora"},
 411         seed_diff = flowers_seed_diff,
 412         light_min = 4,
 413         light_max = 10,
 414         neighbors = {"hades_core:dirt_with_grass"},
 415         facedir = 1
 416 })
 417
 418
 419 plantslib:spawn_on_surfaces({
 420         spawn_delay = SPAWN_DELAY*2,
 421         spawn_plants = {"flowers:seaweed"},
 422         spawn_chance = SPAWN_CHANCE*2,
 423         spawn_surfaces = {"hades_core:dirt_with_grass"},
 424         avoid_nodes = {"group:flower", "group:flora" },
 425         seed_diff = flowers_seed_diff,
 426         light_min = 4,
 427         light_max = 10,
 428         neighbors = {"hades_core:water_source"},
 429         ncount = 1,
 430         facedir = 1
 431 })
 432
 433
 434 --plantslib:spawn_on_surfaces({
 435         --spawn_delay = SPAWN_DELAY*2,
 436         --spawn_plants = {"flowers:seaweed"},
 437         --spawn_chance = SPAWN_CHANCE*2,
 438         --spawn_surfaces = {"hades_core:stone"},
 439         --avoid_nodes = {"group:flower", "group:flora" },
 440         --seed_diff = flowers_seed_diff,
 441         --light_min = 4,
 442         --light_max = 10,
 443         --neighbors = {"hades_core:water_source"},
 444         --ncount = 6,
 445         --facedir = 1
 446 --})
 447
 448
 449 -- crafting recipes!
 450
 451
 452 minetest.register_craft({
 453         output = 'flowers:seaweed 3',
 454         recipe = {{'flowers:waterlily'},}
 455 })
 456
 457 minetest.register_abm({
 458         nodenames = {"flowers:seaweed"},
 459         interval = 500,
 460         chance = 75,
 461         action = function(pos, node)
 462                 minetest.set_node(pos, {name="flowers:waterlily"})
 463         end,
 464 })
 465
 466 -- Cotton plants are now provided by the default "farming" mod.
 467 -- old cotton plants -> farming cotton stage 8
 468 -- cotton wads -> string (can be crafted into wool blocks)
 469 -- potted cotton plants -> potted white dandelions
 470
 471
 472 minetest.register_alias("flowers:cotton_plant", "farming:cotton_8")
 473 minetest.register_alias("flowers:flower_cotton", "farming:cotton_8")
 474 minetest.register_alias("flowers:flower_cotton_pot", "flowers:potted_dandelion_white")
 475 minetest.register_alias("flowers:potted_cotton_plant", "flowers:potted_dandelion_white")
 476 minetest.register_alias("flowers:cotton", "farming:string")
 477 minetest.register_alias("flowers:cotton_wad", "farming:string")
 478
 479
 480 minetest.log("action", "[Flowers] Loaded.")