pyutest-cd2025/mods/ENTITIES/pyutest_entities/api.lua

local PATH_FIND_ALGORITHM
PATH_FIND_ALGORITHM = "Dijkstra"
-- PATH_FIND_ALGORITHM = "A*_noprefetch"
-- PATH_FIND_ALGORITHM = "A*"

PyuTest.ENTITY_BLOOD_AMOUNT = 6
PyuTest.HUMAN_LIKE_CBOX = {-0.25, -1, -0.25, 0.25, 1, 0.25}

PyuTest.get_nearest_entity = function (self, pos, range, only_player)
  local closet_distance = math.huge
  local nearest

  for obj in minetest.objects_inside_radius(pos, range) do
    local dist = vector.distance(pos, obj:get_pos())

    if dist < closet_distance and obj ~= self then
      if only_player then
        if obj:is_player() then
          closet_distance = dist
          nearest = obj
        end
      else
        closet_distance = dist
        nearest = obj
      end
    end
  end

  return nearest
end

PyuTest.register_entity_spawn = function (name, entity, def)
  if def == nil then
    error("Table expected for options!")
  end

  minetest.register_node(name, {
    description = "Entity Spawner",
    groups = {
      not_in_creative_inventory = 1,
    },
    drawtype = "airlike",
    walkable = false,
    pointable = false
  })

  minetest.register_decoration({
    sidelen = 80,
    decoration = name,
    deco_type = "simple",
    place_on = def.place_on,
    spawn_by = def.spawn_by,
    num_spawn_by = def.num_spawn_by,
    fill_ratio = def.fill_ratio or 0.0008,
    y_max = def.y_max or 31000,
    y_min = def.y_min or -31000,
    biomes = {}
  })

  minetest.register_lbm({
    name = name.."_spawn",
    run_at_every_load = true,
    nodenames = {name},
    action = function (pos)
      minetest.remove_node(pos)

      local min = def.min or 1
      local max = def.max or 3

      for _ = min, math.random(min, max) do
        minetest.add_entity(pos, entity)
      end
    end
  })
end

local function do_physics(luaentity, cfg, moveresult)
  local obj = luaentity.object
  local data = luaentity.data
  local pos = obj:get_pos()


  if cfg.gravity then
    if not moveresult.touching_ground then
      
    end
  end
end

local function path_find_nearest_entity(luaentity, cfg, dtime, player)
  local obj = luaentity.object
  local data = luaentity.data
  local pos = obj:get_pos()

  if data.target.path == nil then
    data.target.object = PyuTest.get_nearest_entity(obj, pos, cfg.sight_range, player)

    if data.target.object == nil then
      return
    end

    data.target.position = data.target.object:get_pos()
    data.target.path = minetest.find_path(pos, data.target.position, cfg.view_range, cfg.max_jump, cfg.max_drop, PATH_FIND_ALGORITHM)
    data.target.pathindex = 1
  else
    if data.target.pathindex == #data.target.path then
      data.target.path = nil
      data.target.object = nil
      data.target.position = nil
      data.target.pathindex = nil
    else
      local p = data.target.path[data.target.pathindex]
      obj:set_velocity(p * dtime)
      obj:set_yaw(vector.angle(data.target.object:get_pos(), obj:get_pos()))
      data.target.pathindex = data.target.pathindex + 1
    end
  end
end

PyuTest.make_mob = function (name, properties, options)
  local default_options = {
    ai = "dummy",
    max_jump = 1,
    max_drop = 8,
    speed = 3,
    view_range = 3,
    sight_range = 10,
    gravity = true,
    gravity_multiplier = 1,
    health_regen = true,

    sounds = {
      hurt = "pyutest-entity-hurt"
    },
    drops = {}
  }
  local cfg = {}

  for k, v in pairs(options) do
    cfg[k] = v
  end

  for k, v in pairs(default_options) do
    if cfg[k] == nil then
      cfg[k] = v
    end
  end

  local collisionbox = properties.collisionbox or PyuTest.HUMAN_LIKE_CBOX

  minetest.register_entity(name, {
    initial_properties = PyuTest.util.tableconcat(properties, {
      hp_max = properties.hp_max or 20,
      physical = true,
      collide_with_objects = true,
      stepheight = properties.stepheight or 1.1,
      collisionbox = collisionbox,
      selectionbox = properties.selectionbox or collisionbox,
      show_on_minimap = properties.show_on_minimap or true,
      infotext = "",
    }),
    options = cfg,
    data = {
      target = {
        object = nil,
        position = nil,
        path = nil,
        pathindex = nil
      }
    },

    on_step = function (self, dtime, moveresult)
      local ai = self.options.ai
      local obj = self.object
      local p = obj:get_properties()

      local hp = obj:get_hp()
      if cfg.health_regen and not (hp >= p.hp_max) then
        obj:set_hp(hp + 0.5)
      end

      if obj:get_hp() > p.hp_max then
        obj:set_hp(p.hp_max)
      end

      p.infotext = string.format("Mob Health: %d/%d",  obj:get_hp(), p.hp_max)
      obj:set_properties(p)

      if ai == nil or ai == "dummy" then
        return
      end

      do_physics(self, cfg, moveresult)

      if ai == "follownearest" then
        path_find_nearest_entity(self, cfg, dtime, true)
      end
    end,

    on_punch = function (self)
      local pos = self.object:get_pos()
      minetest.sound_play(cfg.sounds.hurt, {pos = pos})

      minetest.add_particlespawner({
        amount =  8,
        time = 0.4,
        minexptime = 0.4,
        maxexptime = 0.8,
        minsize = 1.5,
        maxsize = 1.62,
        vertical = false,
        glow = minetest.LIGHT_MAX,

        collisiondetection = false,
        texture = "pyutest-blood.png",

        minpos = pos,
        maxpos = pos,
        minvel = vector.new(-1, -1, 1),
        maxvel = vector.new(1, 1, 1),
      })
    end,

    on_death = function (self)
      local pos = self.object:get_pos()

      for _, v in pairs(cfg.drops) do
        minetest.add_item(pos, v)
      end
    end
  })
end