cme/creatures/register.lua

--= Creatures MOB-Engine (cme) =--
-- Copyright (c) 2015-2016 BlockMen <blockmen2015@gmail.com>
--
-- register.lua
--
-- This software is provided 'as-is', without any express or implied warranty. In no
-- event will the authors be held liable for any damages arising from the use of
-- this software.
--
-- Permission is granted to anyone to use this software for any purpose, including
-- commercial applications, and to alter it and redistribute it freely, subject to the
-- following restrictions:
--
-- 1. The origin of this software must not be misrepresented; you must not
-- claim that you wrote the original software. If you use this software in a
-- product, an acknowledgment in the product documentation is required.
-- 2. Altered source versions must be plainly marked as such, and must not
-- be misrepresented as being the original software.
-- 3. This notice may not be removed or altered from any source distribution.
--


local allow_hostile = core.setting_getbool("only_peaceful_mobs") ~= true

local function translate_def(def)
  local new_def = {
  	physical = true,
  	visual = "mesh",
    stepheight = 0.6, -- ensure we get over slabs/stairs
    automatic_face_movement_dir = def.model.rotation or 0.0,

  	mesh = def.model.mesh,
  	textures = def.model.textures,
  	collisionbox = def.model.collisionbox or {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
  	visual_size = def.model.scale or {x = 1, y = 1},
    backface_culling = def.model.backface_culling or false,
    collide_with_objects = def.model.collide_with_objects or true,
    makes_footstep_sound = true,

    stats = def.stats,
    model = def.model,
    sounds = def.sounds,
    combat = def.combat,
    modes = {},
    drops = def.drops,
  }

  -- Tanslate modes to better accessable format
  for mn,def in pairs(def.modes) do
    local name = tostring(mn)
    if name ~= "update_time" then
      new_def.modes[name] = def
      --if name == "attack" then new_def.modes[name].chance = 0 end
    end
  end

  -- Check if the modes have correct sum
  local mode_chance_sum = creatures.sumChances(new_def.modes)
  if mode_chance_sum > 1 then
    throw_warning("Chance of modes too high for MOB: " .. def.name ..
        ". Mode chances will be incorrect.")
  elseif mode_chance_sum < 1 then
    throw_warning("Chance of modes too low for MOB: " .. def.name ..
        ". Filling up to correct mode chances.")
    new_def.modes["_empty"] = {chance = 1 - mode_chance_sum, duration = 0}
  end

  -- insert special mode "_run" which is used when in panic
  if def.stats.can_panic then
    if def.modes.walk then
      local new = table.copy(new_def.modes["walk"])
      new.chance = 0
      new.duration = 3
      new.moving_speed = new.moving_speed * 2
      if def.modes.panic and def.modes.panic.moving_speed then
        new.moving_speed = def.modes.panic.moving_speed
      end
      new.update_yaw = 0.7
      new_def.modes["_run"] = new
      local new_anim = def.model.animations.panic
      if not new_anim then
        new_anim = table.copy(def.model.animations.walk)
        new_anim.speed = new_anim.speed * 2
      end
      new_def.model.animations._run = new_anim
    end
  end

  if def.stats.can_jump and type(def.stats.can_jump) == "number" then
    if def.stats.can_jump > 0 then
      new_def.stepheight = def.stats.can_jump + 0.1
    end
  end

  if def.stats.sneaky or def.stats.can_fly then
    new_def.makes_footstep_sound = false
  end


  new_def.get_staticdata = function(self)
    local main_tab = creatures.get_staticdata(self)
    -- is own staticdata function defined? If so, merge results
    if def.get_staticdata then
      local data = def.get_staticdata(self)
      if data and type(data) == "table" then
        for s,w in pairs(data) do
          main_tab[s] = w
        end
      end
    end

    -- return data serialized
    return core.serialize(main_tab)
  end

  new_def.on_activate = function(self, staticdata)

    -- Add everything we need as basis for the engine
    self.mob_name = def.name
    self.hp = def.stats.hp
    self.hostile = def.stats.hostile
    self.mode = ""
    self.stunned = false -- if knocked back or hit do nothing else

    self.has_kockback = def.stats.has_kockback
    self.has_falldamage = def.stats.has_falldamage
    self.can_swim = def.stats.can_swim
    self.can_fly = def.stats.can_fly
    self.can_burn = def.stats.can_burn
    self.can_panic = def.stats.can_panic == true and def.modes.walk ~= nil
    --self.is_tamed = nil
    --self.target = nil
    self.dir = {x = 0, z = 0}

    --self.last_pos = nil (was nullVec)
    --self.last_node = nil
    --self.last_llvl = 0
    self.fall_dist = 0
    self.air_cnt = 0


    -- Timers
    self.lifetimer = 0
    self.modetimer = math.random()--0
    self.soundtimer = math.random()
    self.nodetimer = 2 -- ensure we get the first step
    self.yawtimer = math.random() * 2--0
    self.followtimer = 0
    if self.can_swim then
      self.swimtimer = 2 -- ensure we get the first step
      -- self.in_water = nil
    end
    if self.hostile then
      self.attacktimer = 0
    end
    if self.hostile or def.modes.follow then
      self.searchtimer = 0
    end
    if self.can_burn or not def.stats.can_swim or self.has_falldamage then
      self.env_damage = true
      self.envtimer = 0
    end

    -- Other things


    if staticdata then
      local tab = core.deserialize(staticdata)
      if tab and type(tab) == "table" then
        for s,w in pairs(tab) do
          self[tostring(s)] = w
        end
      end
    end

    -- check we got a valid mode
    if not new_def.modes[self.mode] or (new_def.modes[self.mode].chance or 0) <= 0 then
      self.mode = "idle"
    end

    if not self.can_fly then
      if not self.in_water then
        self.object:setacceleration({x = 0, y = -15, z = 0})
      end
    end

    -- check if falling and set velocity only 0 when not falling
    if self.fall_dist == 0 then
      self.object:setvelocity(nullVec)
    end

    self.object:set_hp(self.hp)

    if not core.setting_getbool("enable_damage") then
      self.hostile = false
    end

    -- immortal is needed to disable clientside smokepuff shit
    self.object:set_armor_groups({fleshy = 100, immortal = 1})

    -- call custom on_activate if defined
    if def.on_activate then
      def.on_activate(self, staticdata)
    end
  end

  new_def.on_punch = function(self, puncher, time_from_last_punch, tool_capabilities, dir)
    if def.on_punch and def.on_punch(self, puncher, time_from_last_punch, tool_capabilities, dir) == true then
      return
    end

    creatures.on_punch(self, puncher, time_from_last_punch, tool_capabilities, dir)
  end

  new_def.on_rightclick = function(self, clicker)
    if def.on_rightclick and def.on_rightclick(self, clicker) == true then
      return
    end

    creatures.on_rightclick(self, clicker)
  end

  new_def.on_step = function(self, dtime)
    if def.on_step and def.on_step(self, dtime) == true then
      return
    end

    creatures.on_step(self, dtime)
  end

  return new_def
end

function creatures.register_mob(def) -- returns true if sucessfull
  if not def or not def.name then
    throw_error("Can't register mob. No name or Definition given.")
    return false
  end

  local mob_def = translate_def(def)

  core.register_entity(":" .. def.name, mob_def)

  -- register spawn
  if def.spawning and not (def.stats.hostile and not allow_hostile) then
    local spawn_def = def.spawning
    spawn_def.mob_name = def.name
    spawn_def.mob_size = def.model.collisionbox
    if creatures.register_spawn(spawn_def) ~= true then
      throw_error("Couldn't register spawning for '" .. def.name .. "'")
    end

    if spawn_def.spawn_egg then
      local egg_def = def.spawning.spawn_egg
      egg_def.mob_name = def.name
      egg_def.box = def.model.collisionbox
      creatures.register_egg(egg_def)
    end

    if spawn_def.spawner then
      local spawner_def = def.spawning.spawner
      spawner_def.mob_name = def.name
      spawner_def.range = spawner_def.range or 4
      spawner_def.number = spawner_def.number or 6
      spawner_def.model = def.model
      creatures.register_spawner(spawner_def)
    end
  end

  return true
end


local function inRange(min_max, value)
  if not value or not min_max or not min_max.min or not min_max.max then
    return false
  end
  if (value >= min_max.min and value <= min_max.max) then
    return true
  end
  return false
end

local function checkSpace(pos, height)
  for i = 0, height do
    local n = core.get_node_or_nil({x = pos.x, y = pos.y + i, z = pos.z})
    if not n or n.name ~= "air" then
      return false
    end
  end
  return true
end

local time_taker = 0
local function step(tick)
  core.after(tick, step, tick)
  time_taker = time_taker + tick
end
step(0.5)

local function stopABMFlood()
  if time_taker == 0 then
    return true
  end
  time_taker = 0
end

local function groupSpawn(pos, mob, group, nodes, range, max_loops)
  local cnt = 0
  local cnt2 = 0

  local nodes = core.find_nodes_in_area({x = pos.x - range, y = pos.y - range, z = pos.z - range},
    {x = pos.x + range, y = pos.y, z = pos.z + range}, nodes)
  local number = #nodes - 1
  if max_loops and type(max_loops) == "number" then
    number = max_loops
  end
  while cnt < group and cnt2 < number do
    cnt2 = cnt2 + 1
    local p = nodes[math.random(1, number)]
    p.y = p.y + 1
    if checkSpace(p, mob.size) == true then
      cnt = cnt + 1
      core.add_entity(p, mob.name)
    end
  end
  if cnt < group then
    return false
  end
end

function creatures.register_spawn(spawn_def)
  if not spawn_def or not spawn_def.abm_nodes then
    throw_error("No valid definition for given.")
    return false
  end

  if not spawn_def.abm_nodes.neighbors then
    spawn_def.abm_nodes.neighbors = {}
  end
  table.insert(spawn_def.abm_nodes.neighbors, "air")

  core.register_abm({
    nodenames = spawn_def.abm_nodes.spawn_on,
    neighbors = spawn_def.abm_nodes.neighbors,
    interval = spawn_def.abm_interval or 44,
    chance = spawn_def.abm_chance or 7000,
    catch_up = false,
    action = function(pos, node, active_object_count, active_object_count_wider)
      -- prevent abm-"feature"
      if stopABMFlood() == true then
        return
      end

      -- time check
      local tod = core.get_timeofday() * 24000
      if spawn_def.time_range then
        local wanted_res = false
        local range = table.copy(spawn_def.time_range)
        if range.min > range.max and range.min <= tod then
          wanted_res = true
        end
        if inRange(range, tod) == wanted_res then
          return
        end
      end

      -- position check
      if spawn_def.height_limit and not inRange(spawn_def.height_limit, pos.y) then
        return
      end

      -- light check
      pos.y = pos.y + 1
      local llvl = core.get_node_light(pos)
      if spawn_def.light and not inRange(spawn_def.light, llvl) then
        return
      end
      -- creature count check
      local max
      if active_object_count_wider > (spawn_def.max_number or 1) then
        local mates_num = #creatures.findTarget(nil, pos, 16, "mate", spawn_def.mob_name, true)
        if (mates_num or 0) >= spawn_def.max_number then
          return
        else
          max = spawn_def.max_number - mates_num
        end
      end

      -- ok everything seems fine, spawn creature
      local height_min = (spawn_def.mob_size[5] or 2) - (spawn_def.mob_size[2] or 0)
      height_min = math.ceil(height_min)

      local number = 0
      if type(spawn_def.number) == "table" then
        number = math.random(spawn_def.number.min, spawn_def.number.max)
      else
        number = spawn_def.number or 1
      end

      if max and number > max then
        number = max
      end

      if number > 1 then
        groupSpawn(pos, {name = spawn_def.mob_name, size = height_min}, number, spawn_def.abm_nodes.spawn_on, 5)
      else
      -- space check
        if not checkSpace(pos, height_min) then
          return
        end
        core.add_entity(pos, spawn_def.mob_name)
      end
    end,
  })

  return true
end

local function eggSpawn(itemstack, placer, pointed_thing, egg_def)
  if pointed_thing.type == "node" then
    local pos = pointed_thing.above
    pos.y = pos.y + 0.5
    local height = (egg_def.box[5] or 2) - (egg_def.box[2] or 0)
    if checkSpace(pos, height) == true then
      core.add_entity(pos, egg_def.mob_name)
      if core.setting_getbool("creative_mode") ~= true then
        itemstack:take_item()
      end
    end
    return itemstack
  end
end

function creatures.register_egg(egg_def)
  if not egg_def or not egg_def.mob_name or not egg_def.box then
    throw_error("Can't register Spawn-Egg. Not enough parameters given.")
    return false
  end

  core.register_craftitem(":" .. egg_def.mob_name .. "_spawn_egg", {
    description = egg_def.description or egg_def.mob_name .. " spawn egg",
    inventory_image = egg_def.texture or "creatures_spawn_egg.png",
    liquids_pointable = false,
    on_place = function(itemstack, placer, pointed_thing)
      return eggSpawn(itemstack, placer, pointed_thing, egg_def)
    end,
  })
  return true
end


local function makeSpawnerEntiy(mob_name, model)
  core.register_entity(":" .. mob_name .. "_spawner_dummy", {
    hp_max = 1,
    physical = false,
    collide_with_objects = false,
    collisionbox = nullVec,
    visual = "mesh",
    visual_size = {x = 0.42, y = 0.42},
    mesh = model.mesh,
    textures = model.textures,
    makes_footstep_sound = false,
    automatic_rotate = math.pi * -2.9,
    mob_name = "_" .. mob_name .. "_dummy",

    on_activate = function(self)
      self.timer = 0
		  self.object:setvelocity(nullVec)
		  self.object:setacceleration(nullVec)
		  self.object:set_armor_groups({immortal = 1})
      --self.object:set_bone_position("Root", nullVec, {x=45,y=0,z=0})
	   end,

     on_step = function(self, dtime)
       self.timer = self.timer + dtime
       if self.timer > 30 then
         self.timer = 0
         local n = core.get_node_or_nil(self.object:getpos())
         if n and n.name and n.name ~= mob_name .. "_spawner" then
           self.object:remove()
         end
       end
     end
    })
end

local function spawnerSpawn(pos, spawner_def)
  local mates = creatures.findTarget(nil, pos, spawner_def.range, "mate", spawner_def.mob_name, true) or {}
  if #mates >= spawner_def.number then
    return false
  end
  local number_max = spawner_def.number - #mates

  local rh = math.floor(spawner_def.range/2)
  local area = {
    min = {x = pos.x - rh, y=pos.y - rh, z = pos.z - rh},
    max = {x = pos.x + rh, y=pos.y + rh - spawner_def.height - 1, z = pos.z + rh}
  }

  local height = area.max.y - area.min.y
  local cnt = 0
  for i = 0, height do
    if cnt >= number_max then
      break
    end
    local p = {x = math.random(area.min.x, area.max.x), y = area.min.y + i, z = math.random(area.min.z, area.max.z)}
    local n = core.get_node_or_nil(p)
    if n and n.name then
      local walkable = core.registered_nodes[n.name].walkable or false
      p.y = p.y + 1
      if walkable and checkSpace(p, spawner_def.height) == true then
        local llvl = core.get_node_light(p)
        if not spawner_def.light or (spawner_def.light and inRange(spawner_def.light, llvl)) then
          cnt = cnt + 1
          core.add_entity(p, spawner_def.mob_name)
        end
      end
    end
  end
end


local spawner_timers = {}
function creatures.register_spawner(spawner_def)
  if not spawner_def or not spawner_def.mob_name or not spawner_def.model then
    throw_error("Can't register Spawn-Egg. Not enough parameters given.")
    return false
  end

  makeSpawnerEntiy(spawner_def.mob_name, spawner_def.model)

  core.register_node(":" .. spawner_def.mob_name .. "_spawner", {
    description = spawner_def.description or spawner_def.mob_name .. " spawner",
  	paramtype = "light",
  	tiles = {"creatures_spawner.png"},
  	is_ground_content = true,
  	drawtype = "glasslike",
  	groups = {cracky = 1, level = 1},
  	drop = "",
  	on_construct = function(pos)
  			pos.y = pos.y - 0.3
  			core.add_entity(pos, spawner_def.mob_name .. "_spawner_dummy")
  	end,
  	on_destruct = function(pos)
  		for _,obj in ipairs(core.get_objects_inside_radius(pos, 1)) do
        local entity = obj:get_luaentity()
  			if obj and entity and entity.mob_name == "_" .. spawner_def.mob_name .. "_dummy" then
  				obj:remove()
  			end
  		end
  	end
  })

  local box = spawner_def.model.collisionbox
  local height = (box[5] or 2) - (box[2] or 0)
  spawner_def.height = height

  if spawner_def.player_range and type(spawner_def.player_range) == "number" then
    core.register_abm({
      nodenames = {spawner_def.mob_name .. "_spawner"},
		  interval = 2,
		  chance = 1,
		  catch_up = false,
		  action = function(pos)
        local id = core.pos_to_string(pos)
        if not spawner_timers[id] then
          spawner_timers[id] = os.time()
        end
        local time_from_last_call = os.time() - spawner_timers[id]
        local mobs,player_near = creatures.findTarget(nil, pos, spawner_def.player_range, "player", nil, true, true)
        if player_near == true and time_from_last_call > 10 and (math.random(1, 5) == 1 or (time_from_last_call ) > 27) then
          spawner_timers[id] = os.time()

          spawnerSpawn(pos, spawner_def)
        end
      end
    })
  else
    core.register_abm({
      nodenames = {spawner_def.mob_name .. "_spawner"},
		  interval = 10,
		  chance = 3,
		  action = function(pos)

        spawnerSpawn(pos, spawner_def)
			end
    })
  end

  return true
end

local function register_alias_entity(old_mob, new_mob)
  core.register_entity(":" .. old_mob, {
    physical = false,
    collisionbox = {0, 0, 0, 0, 0, 0},
    visual = "sprite",
    visual_size = {x = 0, y = 0},
    textures = {"creatures_spawner.png"}, -- dummy texture
    makes_footstep_sound = false,

    on_activate = function(self)
      local pos = self.object:getpos()
      if pos then
        core.add_entity(pos, new_mob)
      end
      if self.object then
        self.object:remove()
      end
    end,
  })
end


function creatures.register_alias(old_mob, new_mob) -- returns true if sucessfull
  local def = core.registered_entities[new_mob]
  if not def then
    throw_error("No valid definition for given.")
    return false
  end

  register_alias_entity(old_mob, new_mob)

  if core.registered_nodes[new_mob .. "_spawner"] then
    register_alias_entity(old_mob .. "_spawner_dummy", new_mob .. "_spawner_dummy")
    core.register_alias(old_mob .. "_spawner", new_mob .. "_spawner")
  end

  if core.registered_items[new_mob .. "_spawn_egg"] then
    core.register_alias(old_mob .. "_spawn_egg", new_mob .. "_spawn_egg")
  end

  return true
end