mods/ITEMS/mcl_end/chorus_plant.lua

   1 -- Chorus plants
   2 -- This includes chorus flowers, chorus plant stem nodes and chorus fruit
   3
   4
   5 --- Plant parts ---
   6
   7 local MAX_FLOWER_AGE = 5 -- Maximum age of chorus flower before it dies
   8
   9 local chorus_flower_box = {
  10         type = "fixed",
  11         fixed = {
  12                 {-0.5, -0.375, -0.375, 0.5, 0.375, 0.375},
  13                 {-0.375, -0.375, 0.375, 0.375, 0.375, 0.5},
  14                 {-0.375, -0.375, -0.5, 0.375, 0.375, -0.375},
  15                 {-0.375, 0.375, -0.375, 0.375, 0.5, 0.375},
  16                 {-0.375, -0.5, -0.375, 0.375, -0.375, 0.375},
  17         }
  18 }
  19
  20 minetest.register_node("mcl_end:chorus_flower", {
  21         description = "Chorus Flower",
  22         _doc_items_longdesc = "A chorus flower is the living part of a chorus plant. It can grow into a tall chorus plant, step by step. When it grows, it may die on old age eventually. It also dies when it is unable to grow.",
  23         _doc_items_usagehelp = "Place it and wait for it to grow. It can only be placed on top of end stone, on top of a chorus plant stem, or at the side of exactly a chorus plant stem.",
  24         tiles = {
  25                 "mcl_end_chorus_flower.png",
  26                 "mcl_end_chorus_flower.png",
  27                 "mcl_end_chorus_flower.png",
  28                 "mcl_end_chorus_flower.png",
  29                 "mcl_end_chorus_flower.png",
  30                 "mcl_end_chorus_flower.png",
  31         },
  32         drawtype = "nodebox",
  33         paramtype = "light",
  34         sunlight_propagates = true,
  35         node_box = chorus_flower_box,
  36         selection_box = { type = "regular" },
  37         sounds = mcl_sounds.node_sound_wood_defaults(),
  38         groups = {handy=1,axey=1, deco_block = 1, dig_by_piston = 1, destroy_by_lava_flow = 1,},
  39
  40         node_placement_prediction = "",
  41         on_place = function(itemstack, placer, pointed_thing)
  42                 local node_under = minetest.get_node(pointed_thing.under)
  43                 local node_above = minetest.get_node(pointed_thing.above)
  44                 if placer and not placer:get_player_control().sneak then
  45                         -- Use pointed node's on_rightclick function first, if present
  46                         if minetest.registered_nodes[node_under.name] and minetest.registered_nodes[node_under.name].on_rightclick then
  47                                 return minetest.registered_nodes[node_under.name].on_rightclick(pointed_thing.under, node_under, placer, itemstack) or itemstack
  48                         end
  49                 end
  50
  51                 --[[ Part 1: Check placement rules. Placement is legal is one of the following
  52                 conditions is met:
  53                 1) On top of end stone or chorus plant
  54                 2) On top of air and horizontally adjacent to exactly 1 chorus plant ]]
  55                 local pos
  56                 if minetest.registered_nodes[node_under.name].buildable_to then
  57                         pos = pointed_thing.under
  58                 else
  59                         pos = pointed_thing.above
  60                 end
  61
  62
  63                 local below = {x=pos.x, y=pos.y-1, z=pos.z}
  64                 local node_below = minetest.get_node(below)
  65                 local plant_ok = false
  66                 -- Condition 1
  67                 if node_below.name == "mcl_end:chorus_plant" or node_below.name == "mcl_end:end_stone" then
  68                         plant_ok = true
  69                 -- Condition 2
  70                 elseif node_below.name == "air" then
  71                         local around = {
  72                                 { x= 1, y=0, z= 0 },
  73                                 { x=-1, y=0, z= 0 },
  74                                 { x= 0, y=0, z= 1 },
  75                                 { x= 0, y=0, z=-1 },
  76                         }
  77                         local around_count = 0
  78                         for a=1, #around do
  79                                 local pos_side = vector.add(pos, around[a])
  80                                 local node_side = minetest.get_node(pos_side)
  81                                 if node_side.name == "mcl_end:chorus_plant" then
  82                                         around_count = around_count + 1
  83                                         if around_count > 1 then
  84                                                 break
  85                                         end
  86                                 end
  87                         end
  88                         if around_count == 1 then
  89                                 plant_ok = true
  90                         end
  91                 end
  92                 if plant_ok then
  93                         -- Placement OK! Proceed normally
  94                         return minetest.item_place(itemstack, placer, pointed_thing)
  95                 else
  96                         return itemstack
  97                 end
  98         end,
  99         _mcl_blast_resistance = 2,
 100         _mcl_hardness = 0.4,
 101 })
 102
 103 minetest.register_node("mcl_end:chorus_flower_dead", {
 104         description = "Dead Chorus Flower",
 105         _doc_items_longdesc = "This is a part of a chorus plant. It doesn't grow. Chorus flowers die of old age or when they are unable to grow. A dead chorus flower can be harvested to obtain a fresh chorus flower which is able to grow again.",
 106         tiles = {
 107                 "mcl_end_chorus_flower_dead.png",
 108                 "mcl_end_chorus_flower_dead.png",
 109                 "mcl_end_chorus_flower_dead.png",
 110                 "mcl_end_chorus_flower_dead.png",
 111                 "mcl_end_chorus_flower_dead.png",
 112                 "mcl_end_chorus_flower_dead.png",
 113         },
 114         drawtype = "nodebox",
 115         paramtype = "light",
 116         sunlight_propagates = true,
 117         node_box = chorus_flower_box,
 118         selection_box = { type = "regular" },
 119         sounds = mcl_sounds.node_sound_wood_defaults(),
 120         drop = "mcl_end:chorus_flower",
 121         groups = {handy=1,axey=1, deco_block = 1, dig_by_piston = 1, destroy_by_lava_flow = 1,},
 122         _mcl_blast_resistance = 2,
 123         _mcl_hardness = 0.4,
 124 })
 125
 126 minetest.register_node("mcl_end:chorus_plant", {
 127         description = "Chorus Plant Stem",
 128         _doc_items_longdesc = "A chorus plant stem is the part of a chorus plant which holds the whole plant together. It needs end stone as its soil. Stems are grown from chorus flowers.",
 129         tiles = {
 130                 "mcl_end_chorus_plant.png",
 131                 "mcl_end_chorus_plant.png",
 132                 "mcl_end_chorus_plant.png",
 133                 "mcl_end_chorus_plant.png",
 134                 "mcl_end_chorus_plant.png",
 135                 "mcl_end_chorus_plant.png",
 136         },
 137         drawtype = "nodebox",
 138         paramtype = "light",
 139         sunlight_propagates = true,
 140         node_box = {
 141                 type = "connected",
 142                 fixed = { -0.25, -0.25, -0.25, 0.25, 0.25, 0.25 }, -- Core
 143                 connect_top = { -0.1875, 0.25, -0.1875, 0.1875, 0.5, 0.1875 },
 144                 connect_left = { -0.5, -0.1875, -0.1875, -0.25, 0.1875, 0.1875 },
 145                 connect_right = { 0.25, -0.1875, -0.1875, 0.5, 0.1875, 0.1875 },
 146                 connect_bottom = { -0.1875, -0.5, -0.25, 0.1875, -0.25, 0.25 },
 147                 connect_front = { -0.1875, -0.1875, -0.5, 0.1875, 0.1875, -0.25 },
 148                 connect_back = { -0.1875, -0.1875, 0.25, 0.1875, 0.1875, 0.5 },
 149         },
 150         connect_sides = { "top", "bottom", "front", "back", "left", "right" },
 151         connects_to = {"mcl_end:chorus_plant", "mcl_end:chorus_flower", "mcl_end:chorus_flower_dead", "mcl_end:end_stone"},
 152         sounds = mcl_sounds.node_sound_wood_defaults(),
 153         drop = {
 154                 items = {
 155                         { items = { "mcl_end:chorus_fruit"}, rarity = 2 },
 156                 }
 157         },
 158         groups = {handy=1,axey=1, not_in_creative_inventory = 1, dig_by_piston = 1, destroy_by_lava_flow = 1 },
 159         _mcl_blast_resistance = 2,
 160         _mcl_hardness = 0.4,
 161 })
 162
 163
 164 --- ABM ---
 165 minetest.register_abm({
 166         label = "Chorus plant growth",
 167         nodenames = { "mcl_end:chorus_flower" },
 168         interval = 35.0,
 169         chance = 4.0,
 170         action = function(pos, node, active_object_count, active_object_count_wider)
 171                 local above = { x = pos.x, y = pos.y + 1, z = pos.z }
 172                 local node_above = minetest.get_node(above)
 173                 local around = {
 174                         { x=-1, y=0, z= 0 },
 175                         { x= 1, y=0, z= 0 },
 176                         { x= 0, y=0, z=-1 },
 177                         { x= 0, y=0, z= 1 },
 178                 }
 179                 local air_around = true
 180                 for a=1, #around do
 181                         if minetest.get_node(vector.add(above, around[a])).name ~= "air" then
 182                                 air_around = false
 183                                 break
 184                         end
 185                 end
 186                 local grown = false
 187                 if node_above.name == "air" and air_around then
 188                         local branching = false
 189                         local h = 0
 190                         for y=1, 4 do
 191                                 local checkpos = {x=pos.x, y=pos.y-y, z=pos.z}
 192                                 local node = minetest.get_node(checkpos)
 193                                 if node.name == "mcl_end:chorus_plant" then
 194                                         h = y
 195                                         if not branching then
 196                                                 for a=1, #around do
 197                                                         local node_side = minetest.get_node(vector.add(checkpos, around[a]))
 198                                                         if node_side.name == "mcl_end:chorus_plant" then
 199                                                                 branching = true
 200                                                         end
 201                                                 end
 202                                         end
 203                                 else
 204                                         break
 205                                 end
 206                         end
 207
 208                         local grow_chance
 209                         if h <= 1 then
 210                                 grow_chance = 100
 211                         elseif h == 2 and branching == false then
 212                                 grow_chance = 60
 213                         elseif h == 2 and branching == true then
 214                                 grow_chance = 50
 215                         elseif h == 3 and branching == false then
 216                                 grow_chance = 40
 217                         elseif h == 3 and branching == true then
 218                                 grow_chance = 25
 219                         elseif h == 4 and branching == false then
 220                                 grow_chance = 20
 221                         end
 222
 223                         if grow_chance then
 224                                 local new_flowers = {}
 225                                 local r = math.random(1, 100)
 226                                 local age = node.param2
 227                                 if r <= grow_chance then
 228                                         table.insert(new_flowers, above)
 229                                 else
 230                                         age = age + 1
 231                                         local branches
 232                                         if branching == false then
 233                                                 branches = math.random(1, 4)
 234                                         elseif branching == true then
 235                                                 branches = math.random(0, 3)
 236                                         end
 237                                         local branch_grown = false
 238                                         for b=1, branches do
 239                                                 local next_branch = math.random(1, #around)
 240                                                 local branch = vector.add(pos, around[next_branch])
 241                                                 local below_branch = vector.add(branch, {x=0,y=-1,z=0})
 242                                                 if minetest.get_node(below_branch).name == "air" then
 243                                                         table.insert(new_flowers, branch)
 244                                                 end
 245                                         end
 246                                 end
 247
 248                                 for _, f in ipairs(new_flowers) do
 249                                         if age >= MAX_FLOWER_AGE then
 250                                                 minetest.set_node(f, {name="mcl_end:chorus_flower_dead"})
 251                                                 grown = true
 252                                         else
 253                                                 minetest.set_node(f, {name="mcl_end:chorus_flower", param2 = age})
 254                                                 grown = true
 255                                         end
 256                                 end
 257                                 if #new_flowers >= 1 then
 258                                         minetest.set_node(pos, {name="mcl_end:chorus_plant"})
 259                                         grown = true
 260                                 end
 261                         end
 262                 end
 263                 if not grown then
 264                         minetest.set_node(pos, {name = "mcl_end:chorus_flower_dead"})
 265                 end
 266         end,
 267 })
 268
 269 --- Craftitems ---
 270 minetest.register_craftitem("mcl_end:chorus_fruit", {
 271         description = "Chorus Fruit",
 272         _doc_items_longdesc = "Chorus fruits are the fruits of the chorus plant which is home to the End. They can be eaten to restore a few hunger points.",
 273         wield_image = "mcl_end_chorus_fruit.png",
 274         inventory_image = "mcl_end_chorus_fruit.png",
 275         -- TODO: Teleport player
 276         on_place = minetest.item_eat(4),
 277         on_secondary_use = minetest.item_eat(4),
 278         groups = { food = 2, eatable = 4, can_eat_when_full = 1 },
 279         _mcl_saturation = 2.4,
 280         stack_max = 64,
 281 })
 282
 283 minetest.register_craftitem("mcl_end:chorus_fruit_popped", {
 284         description = "Popped Chorus Fruit",
 285         _doc_items_longdesc = doc.sub.items.temp.craftitem,
 286         wield_image = "mcl_end_chorus_fruit_popped.png",
 287         inventory_image = "mcl_end_chorus_fruit_popped.png",
 288         groups = { craftitem = 1 },
 289         stack_max = 64,
 290 })
 291
 292 --- Crafting ---
 293 minetest.register_craft({
 294         type = "cooking",
 295         output = "mcl_end:chorus_fruit_popped",
 296         recipe = "mcl_end:chorus_fruit",
 297         cooktime = 10,
 298 })
 299