mods/farming/api.lua

   1 -- Wear out hoes, place soil
   2 -- TODO Ignore group:flower
   3 farming.hoe_on_use = function(itemstack, user, pointed_thing, uses)
   4         local pt = pointed_thing
   5         -- check if pointing at a node
   6         if not pt then
   7                 return
   8         end
   9         if pt.type ~= "node" then
  10                 return
  11         end
  12
  13         local under = minetest.get_node(pt.under)
  14         local p = {x=pt.under.x, y=pt.under.y+1, z=pt.under.z}
  15         local above = minetest.get_node(p)
  16
  17         -- return if any of the nodes is not registered
  18         if not minetest.registered_nodes[under.name] then
  19                 return
  20         end
  21         if not minetest.registered_nodes[above.name] then
  22                 return
  23         end
  24
  25         -- check if the node above the pointed thing is air
  26         if above.name ~= "air" then
  27                 return
  28         end
  29
  30         -- check if pointing at soil
  31         if minetest.get_item_group(under.name, "soil") ~= 1 then
  32                 return
  33         end
  34
  35         -- check if (wet) soil defined
  36         local regN = minetest.registered_nodes
  37         if regN[under.name].soil == nil or regN[under.name].soil.wet == nil or regN[under.name].soil.dry == nil then
  38                 return
  39         end
  40
  41         -- turn the node into soil, wear out item and play sound
  42         minetest.set_node(pt.under, {name = regN[under.name].soil.dry})
  43         minetest.sound_play("default_dig_crumbly", {
  44                 pos = pt.under,
  45                 gain = 0.5,
  46         }, true)
  47
  48         if not minetest.settings:get_bool("creative_mode") then
  49                 itemstack:add_wear(65535/(uses-1))
  50         end
  51         return itemstack
  52 end
  53
  54 -- Register new hoes
  55 farming.register_hoe = function(name, def)
  56         -- Check for : prefix (register new hoes in your mod's namespace)
  57         if name:sub(1,1) ~= ":" then
  58                 name = ":" .. name
  59         end
  60         -- Check def table
  61         if def.description == nil then
  62                 def.description = "Hoe"
  63         end
  64         if def.inventory_image == nil then
  65                 def.inventory_image = "unknown_item.png"
  66         end
  67         if def.recipe == nil then
  68                 def.recipe = {
  69                         {"air","air",""},
  70                         {"","group:stick",""},
  71                         {"","group:stick",""}
  72                 }
  73         end
  74         if def.max_uses == nil then
  75                 def.max_uses = 30
  76         end
  77         -- Register the tool
  78         minetest.register_tool(name, {
  79                 description = def.description,
  80                 inventory_image = def.inventory_image,
  81                 on_use = function(itemstack, user, pointed_thing)
  82                         return farming.hoe_on_use(itemstack, user, pointed_thing, def.max_uses)
  83                 end
  84         })
  85         -- Register its recipe
  86         if def.material == nil then
  87                 minetest.register_craft({
  88                         output = name:sub(2),
  89                         recipe = def.recipe
  90                 })
  91         else
  92                 local handle
  93                 if def.material_handle then
  94                         handle = def.material_handle
  95                 else
  96                         handle = "group:stick"
  97                 end
  98                 minetest.register_craft({
  99                         output = name:sub(2),
 100                         recipe = {
 101                                 {def.material, def.material, ""},
 102                                 {"", handle, ""},
 103                                 {"", handle, ""}
 104                         }
 105                 })
 106         end
 107 end
 108
 109 -- Seed placement
 110 farming.place_seed = function(itemstack, placer, pointed_thing, plantname)
 111         local pt = pointed_thing
 112         -- check if pointing at a node
 113         if not pt then
 114                 return
 115         end
 116         if pt.type ~= "node" then
 117                 return
 118         end
 119
 120         local under = minetest.get_node(pt.under)
 121         local above = minetest.get_node(pt.above)
 122
 123         -- return if any of the nodes is not registered
 124         if not minetest.registered_nodes[under.name] then
 125                 return
 126         end
 127         if not minetest.registered_nodes[above.name] then
 128                 return
 129         end
 130
 131         -- check if pointing at the top of the node
 132         if pt.above.y ~= pt.under.y+1 then
 133                 return
 134         end
 135
 136         -- check if you can replace the node above the pointed node
 137         if not minetest.registered_nodes[above.name].buildable_to then
 138                 return
 139         end
 140
 141         -- check if pointing at soil
 142         if minetest.get_item_group(under.name, "soil") < 2 then
 143                 return
 144         end
 145
 146         -- add the node and remove 1 item from the itemstack
 147         minetest.add_node(pt.above, {name = plantname, param2 = 1})
 148         if not minetest.settings:get_bool("creative_mode") then
 149                 itemstack:take_item()
 150         end
 151         return itemstack
 152 end
 153
 154 -- Register plants
 155 farming.register_plant = function(name, def)
 156         local mname = name:split(":")[1]
 157         local pname = name:split(":")[2]
 158
 159         -- Check def table
 160         if not def.description then
 161                 def.description = "Seed"
 162         end
 163         if not def.inventory_image then
 164                 def.inventory_image = "unknown_item.png"
 165         end
 166         if not def.steps then
 167                 return nil
 168         end
 169         if not def.minlight then
 170                 def.minlight = 1
 171         end
 172         if not def.maxlight then
 173                 def.maxlight = 14
 174         end
 175         if not def.fertility then
 176                 def.fertility = {}
 177         end
 178
 179         -- Register seed
 180         local g = {seed = 1, snappy = 3, attached_node = 1}
 181         for k, v in pairs(def.fertility) do
 182                 g[v] = 1
 183         end
 184         minetest.register_node(":" .. mname .. ":seed_" .. pname, {
 185                 description = def.description,
 186                 tiles = {def.inventory_image},
 187                 inventory_image = def.inventory_image,
 188                 wield_image = def.inventory_image,
 189                 drawtype = "signlike",
 190                 groups = g,
 191                 paramtype = "light",
 192                 paramtype2 = "wallmounted",
 193                 walkable = false,
 194                 sunlight_propagates = true,
 195                 selection_box = {
 196                         type = "fixed",
 197                         fixed = {-0.5, -0.5, -0.5, 0.5, -5/16, 0.5},
 198                 },
 199                 fertility = def.fertility,
 200                 on_place = function(itemstack, placer, pointed_thing)
 201                         return farming.place_seed(itemstack, placer, pointed_thing, mname .. ":seed_" .. pname)
 202                 end
 203         })
 204
 205         -- Register harvest
 206         minetest.register_craftitem(":" .. mname .. ":" .. pname, {
 207                 description = def.description_harvest,
 208                 groups = { food = 1, eatable = def.food_points },
 209                 on_use = minetest.item_eat(def.food_points),
 210                 inventory_image = mname .. "_" .. pname .. ".png",
 211         })
 212
 213         -- Register growing steps
 214         for i=1,def.steps do
 215                 local drop = {
 216                         items = {
 217                                 {items = {mname .. ":seed_" .. pname}, rarity = 4 - i},
 218                                 {items = {mname .. ":seed_" .. pname}, rarity = 8 - i * 2},
 219                                 {items = {mname .. ":" .. pname}, rarity = 4 - i},
 220                                 {items = {mname .. ":" .. pname}, rarity = 6 - i},
 221                                 {items = {mname .. ":" .. pname}, rarity= 8 - i * 2},
 222                                 {items = {mname .. ":" .. pname}, rarity= 9 - i * 2},
 223                         }
 224                 }
 225                 local nodegroups = {snappy = 3, flammable = 2, plant = 1, not_in_creative_inventory = 1, attached_node = 1}
 226                 nodegroups[pname] = i
 227                 if pname == "corn" then
 228                    minetest.register_node(mname .. ":" .. pname .. "_" .. i, {
 229                         drawtype = "plantlike",
 230                         visual_scale = 1.8,
 231                         waving = 1,
 232                         tiles = {mname .. "_" .. pname .. "_" .. i .. ".png"},
 233                         paramtype = "light",
 234                         walkable = false,
 235                         buildable_to = true,
 236                         is_ground_content = true,
 237                         drop = drop,
 238                         selection_box = {
 239                                 type = "fixed",
 240                                 fixed = {-0.5, -0.5, -0.5, 0.5, -5/16, 0.5},
 241                         },
 242                         groups = nodegroups,
 243                         sounds = hades_sounds.node_sound_leaves_defaults(),
 244                 })
 245                 elseif pname == "beens" then
 246                    minetest.register_node(mname .. ":" .. pname .. "_" .. i, {
 247                         drawtype = "plantlike",
 248                         visual_scale = 1.4,
 249                         waving = 1,
 250                         tiles = {mname .. "_" .. pname .. "_" .. i .. ".png"},
 251                         paramtype = "light",
 252                         walkable = false,
 253                         buildable_to = true,
 254                         is_ground_content = true,
 255                         drop = drop,
 256                         selection_box = {
 257                                 type = "fixed",
 258                                 fixed = {-0.5, -0.5, -0.5, 0.5, -5/16, 0.5},
 259                         },
 260                         groups = nodegroups,
 261                         sounds = hades_sounds.node_sound_leaves_defaults(),
 262                 })
 263                 else
 264                 minetest.register_node(mname .. ":" .. pname .. "_" .. i, {
 265                         drawtype = "plantlike",
 266                         tiles = {mname .. "_" .. pname .. "_" .. i .. ".png"},
 267                         paramtype = "light",
 268                         walkable = false,
 269                         buildable_to = true,
 270                         is_ground_content = true,
 271                         drop = drop,
 272                         selection_box = {
 273                                 type = "fixed",
 274                                 fixed = {-0.5, -0.5, -0.5, 0.5, -5/16, 0.5},
 275                         },
 276                         groups = nodegroups,
 277                         sounds = hades_sounds.node_sound_leaves_defaults(),
 278                 })
 279                 end
 280         end
 281
 282         -- Growing ABM
 283         minetest.register_abm({
 284                 label = "Grow seeds",
 285                 nodenames = {"group:" .. pname, "group:seed"},
 286                 neighbors = {"group:soil"},
 287                 interval = 93,
 288                 chance = 12,
 289                 action = function(pos, node)
 290                         local plant_height = minetest.get_item_group(node.name, pname)
 291
 292                         -- return if already full grown
 293                         if plant_height == def.steps then
 294                                 return
 295                         end
 296
 297                         local node_def = minetest.registered_items[node.name] or nil
 298
 299                         -- grow seed
 300                         if minetest.get_item_group(node.name, "seed") and node_def.fertility then
 301                                 local can_grow = false
 302                                 local soil_node = minetest.get_node_or_nil({x = pos.x, y = pos.y - 1, z = pos.z})
 303                                 if not soil_node then
 304                                         return
 305                                 end
 306                                 for _, v in pairs(node_def.fertility) do
 307                                         if minetest.get_item_group(soil_node.name, v) ~= 0 then
 308                                                 can_grow = true
 309                                         end
 310                                 end
 311                                 if can_grow then
 312                                         minetest.set_node(pos, {name = node.name:gsub("seed_", "") .. "_1"})
 313                                 end
 314                                 return
 315                         end
 316
 317                         -- check if on wet soil
 318                         pos.y = pos.y - 1
 319                         local n = minetest.get_node(pos)
 320                         if minetest.get_item_group(n.name, "soil") < 3 then
 321                                 return
 322                         end
 323                         pos.y = pos.y + 1
 324
 325                         -- check light
 326                         local ll = minetest.get_node_light(pos)
 327
 328                         if not ll or ll < def.minlight or ll > def.maxlight then
 329                                 return
 330                         end
 331
 332                         -- grow
 333                         minetest.set_node(pos, {name = mname .. ":" .. pname .. "_" .. plant_height + 1})
 334                 end
 335         })
 336
 337         -- Return
 338         local r = {
 339                 seed = mname .. ":seed_" .. pname,
 340                 harvest = mname .. ":" .. pname
 341         }
 342         return r
 343 end
 344