advanced_npc/spawner.lua

-- Advanced NPC spawner by Zorman2000
-- The advanced spawner will contain functionality to spawn NPC correctly on
-- custom places, as well as in mg_villages building.
-- This works by using a special node to spawn NPCs on either a custom building or
-- on mg_villages building.

-- mg_villages functionality:
-- The spawn node for mg_villages will be the mg_villages:plotmarker.
-- Based on this node, the following things will be performed
--  - Scan the current building, check if it is of type:
--    - House
--    - Farm
--    - Hut
--    - NOTE: All other types are unsupported as-of now
--  - If it's from any of the above types, the spawner will proceed to scan the
--    the building and find out:
--    - Number and positions of beds
--    - Number and positions of benches
--    - Number and positions of chests
--    - Position of furnaces
--    - Position of doors
--    - NOTE: Scanning will be implemented for first floors only in the first
--            version. It's expected to also include upper floors later.
--  - After that, it will store these information in the node's metadata.
--  - The spawner will analyze the information and will spawn (# of beds/2) or 1
--    NPC in that house. The NPCs will be spawned in intervals, for which the node
--    will create node timers for each NPC.
--  - When a NPC is spawned:
--    - The NPC will be given a schedule
--      - If in a farm, the NPC will have a "farmer schedule" with a 40% chance
--      - If in a house or hut, the NPC will have either a miner, woodcutter, cooker
--        or simple schedule with an equal chance each
--    - The NPC will be assigned a unique bed
--    - The NPC will know the location of one chest, one bench and one furnace
--    - A life timer for the NPC will be created (albeit a long one). Once the NPC's
--      timer is invoked, the NPC will be de-spawned (dies). The spawner should keep
--      track of these.
--  - If a NPC has died, the spawner will choose with 50% chance to spawn a new NPC.
--
-- This is the basic functionality expected for the spawner in version 1. Other things
-- such as scanning upper floors, spawning families of NPCs and creating relationships
-- among them, etc. will be for other versions.

-- Public API
npc.spawner = {}
-- Private API
local spawner = {}

-- This is the official list of support building types
-- from the mg_villages mod
npc.spawner.mg_villages_supported_building_types = {
    "house",
    "farm_full",
    "farm_tiny",
    "hut",
    "lumberjack"
}

npc.spawner.replace_activated = true
npc.spawner.replacement_interval = 60
npc.spawner.spawn_delay = 10

npc.spawner.spawn_data = {
    status = {
        dead = 0,
        alive = 1
    },
    age = {
        adult = "adult",
        child = "child"
    }
}

-- Array of nodes that serve as plotmarker of a plot, and therefore
-- as auto-spawners
spawner.plotmarker_nodes = {}
-- Array of items that are used to spawn NPCs
spawner.spawn_eggs = {}

---------------------------------------------------------------------------------------
-- Scanning functions
---------------------------------------------------------------------------------------

-- This function scans a 3D area that encloses a building and tries to identify:
--  - Entrance door
--  - Beds
--  - Storage nodes (chests, etc.)
--  - Furnace nodes
--  - Sittable nodes
-- It will return a table with all information gathered
-- Playername should be provided if manual spawning
function npc.spawner.scan_area_for_spawn(start_pos, end_pos, player_name)
    local result = {
        building_type = "",
        plot_info = {},
        entrance = {},
        node_data = {},
        npcs = {},
        npc_stats = {}
    }

    -- Set building_type
    result.building_type = "custom"
    -- Get min pos and max pos
    local minp, maxp = vector.sort(start_pos, end_pos)
    -- Set plot info
    result.plot_info = {
        -- TODO: Check this and see if it is accurate!
        xsize = maxp.x - minp.x,
        ysize = maxp.y - minp.y,
        zsize = maxp.z - minp.z,
        start_pos = start_pos,
        end_pos = end_pos
    }

    -- Scan building nodes
    -- Scan building for nodes
    local usable_nodes = npc.places.scan_area_for_usable_nodes(start_pos, end_pos)
    -- Get all doors
    local doors = usable_nodes.openable_type

    -- Find entrance node - this is very tricky when no outside position
    -- is given. So to this end, three things will happen:
    --  - First, we will check for plotmarker nodes. A plotmarker node should
    --    be set at the left of the front door of the building. If this node is
    --    found, it will assume it is at that location and use it.
    --  - Second, we are going to search for an entrance marker. The entrance marker
    --    will be directly in the posiition of the entrance node, so no search
    --    is needed.
    --  - Third, will assume that the start_pos is always at the left side of
    --    the front of the building, where the entrance is
    local outside_pos = start_pos
    -- Check if there is a plotmarker or spawner node
    local candidate_nodes = minetest.find_nodes_in_area_under_air(start_pos, end_pos,
        {"mg_villages:plotmarker", "advanced_npc:auto_spawner"})
    if table.getn(candidate_nodes) > 0 then
        -- Found plotmarker, use it as outside_pos. Ideally should be only one
        outside_pos = candidate_nodes[1]
    elseif npc.spawner_marker and player_name then
        -- Get entrance from spawner marker1
        if npc.spawner_marker.entrance_markers[player_name] then
            outside_pos = npc.spawner_marker.entrance_markers[player_name]
        end
    end
    -- Try to find entrance
    local entrance = npc.places.find_entrance_from_openable_nodes(doors, outside_pos)
    if entrance then
        npc.log("INFO", "Found building entrance at: "..minetest.pos_to_string(entrance.node_pos))
        -- Set building entrance
        result.entrance = entrance
    else
        npc.log("ERROR", "Unable to find building entrance!")
    end

    -- Set node_data
    result.node_data = usable_nodes

    -- Initialize NPC stats
    -- Initialize NPC stats
    local npc_stats = {
        male = {
            total = 0,
            adult = 0,
            child = 0
        },
        female = {
            total = 0,
            adult = 0,
            child = 0
        },
        adult_total = 0,
        child_total = 0
    }
    result.npc_stats = npc_stats

    return result
end

---------------------------------------------------------------------------------------
-- Spawning functions
---------------------------------------------------------------------------------------
-- This function attempts to determine an occupation for an NPC given:
--   - The local building type (building NPC is spawning)
--   - The surrounding workplaces' building types
--   - The NPCs in the local building
-- Lo and behold! In this function lies a code monster, smelly, incomprehensible..
function npc.spawner.determine_npc_occupation(building_type, workplace_nodes, npcs)
    local surrounding_buildings_map = {}
    local current_building_map = {}
    local current_building_npc_occupations = {}
    local result = {}

    -- Get all occupation names in the current building
    for i = 1, #npcs do
        if not npc.utils.array_contains(current_building_npc_occupations, npcs[i].occupation) then
            table.insert(current_building_npc_occupations, npcs[i].occupations)
        end
    end
    -- Classify workplaces into local and surrounding
    for i = 1, #workplace_nodes do
        local workplace = workplace_nodes[i]
        if workplace.surrounding_workplace == true then
            table.insert(surrounding_buildings_map,
                {type=workplace.building_type, origin_building_type=building_type})
        else
            current_building_map[workplace.building_type] = workplace
        end
    end

    -- Get occupation names for the buildings
    local occupation_names = npc.occupations.get_for_building(
        building_type,
        surrounding_buildings_map
    )
    npc.log("DEBUG", "Found occupations: "..dump(occupation_names).."\nfor local building type: "
        ..dump(building_type).."\nAnd surrounding building types: "..dump(surrounding_buildings_map))

    -- Insert default occupation into result
    table.insert(result, {name=npc.occupations.basic_name, node={node_pos={}}})

    ---------------------------------------------------------------------------------------
    -- Determine occupation
    ---------------------------------------------------------------------------------------
    -- First of all, iterate through all names, discard the default basic occupation.
    -- Next, check if no-one in this builiding has this occupation name.
    -- Next, check if the workplace node has no data assigned to it.
    -- Finally, if not, return an table with the occupation name, and the selected
    -- workplace node.
    -- Note: Much more can be done here. This is a simplistic implementation,
    -- given this is already complicated enough. For example, existing NPCs' occupation
    -- can play a much more important role, not only taken in consideration for discarding.
    -- Beware: Incomprehensible code lies ahead
    for i = 1, #occupation_names do
        -- Check if this occupation name is the default occupation, and if it is, continue
        if occupation_names[i] ~= npc.occupations.basic_name then
            -- Check if someone already works on this
            if npc.utils.array_contains(current_building_npc_occupations, occupation_names[i]) == false then
                -- Check if someone else already has this occupation at the same workplace
                for j = 1, #workplace_nodes do
                    -- Get building types from occupation
                    local local_building_types =
                        npc.occupations.registered_occupations[occupation_names[i]].building_types or {}
                    local surrounding_building_types =
                        npc.occupations.registered_occupations[occupation_names[i]].surrounding_building_types or {}

                    -- Attempt to match the occupation definition's local and surrounding types
                    -- to the workplace node's building type.
                    local local_building_match = false
                    local surrounding_building_match = false

                    -- Check if there is building_type match between the def's local
                    -- building_types and the current workplace node's building_type
                    if #local_building_types > 0 then
                        local_building_match =
                            npc.utils.array_contains(local_building_types, workplace_nodes[j].building_type)
                    end

                    -- Check if there is building_type match between the def's surrounding
                    -- building_types and the current workplace node's building_type
                    if #surrounding_building_types > 0 then
                        for k = 1, #surrounding_building_types do
                            if surrounding_building_types[k].type == workplace_nodes[j].building_type then
                                surrounding_building_match = true
                                break
                            end
                        end
                    end
                    -- Check if there was a match
                    if local_building_match == true or surrounding_building_match == true then
                        -- Match found, attempt to map this workplace node to the
                        -- current occupation. How? Well, if the workplace isn't being
                        -- used by another NPC, then, use it
                        local meta = minetest.get_meta(workplace_nodes[j].node_pos)
                        local worker_data = minetest.deserialize(meta:get_string("work_data") or "")
                        npc.log("DEBUG", "Found worker data: "..dump(worker_data))
                        -- If no worker data is found, then create it
                        if not worker_data then
                            npc.log("INFO", "Found suitable occupation and workplace: "..dump(result))
                            table.insert(result, {name=occupation_names[i], node=workplace_nodes[j]})
                        end
                    end
                end
            end
        end
    end

    -- Determine result. Choose profession, how to do it?
    -- First, check previous NPCs' occupation.
    --  - If there is a NPC working at something, check the NPC count.
    --      - If count is less than three (only two NPCs), default_basic occupation.
    --      - If count is greater than two, assign any eligible occupation with 50% chance
    --  - If not NPC is working, choose an occupation that is not default_basic
    if #current_building_npc_occupations > 0 then
        for i = 1, #current_building_npc_occupations do
            if current_building_npc_occupations[i] ~= npc.occupations.basic_name then
                if #current_building_npc_occupations < 3 then
                    -- Choose basic default occupation
                    return result[1]
                elseif #current_building_npc_occupations > 2 then
                    -- Choose any occupation
                    return result[math.random(1, #result)]
                    end
                end
            end
    else
        -- Check how many occupation names we have
        if #result == 1 then
            -- Choose basic default occupation
            return result[1]
        else
            -- Choose an occupation with equal chance each
            return result[math.random(2, #result)]
        end
    end
    -- By default, if nothing else works, return basic default occupation
    return result[1]
end

-- This function is called when the node timer for spawning NPC
-- is expired. Can be called manually by supplying either:
--   - Position of mg_villages plotmarker, or,
--   - position of custom building spawner
-- Prerequisite for calling this function is:
--  - In case of mg_villages, spawner.adapt_mg_villages_plotmarker(), or,
--  - in case of custom buildings, npc.spawner.scan_area_for_spawn()
function npc.spawner.spawn_npc_on_plotmarker(pos)
    -- Get timer
    local timer = minetest.get_node_timer(pos)
    -- Get metadata
    local meta = minetest.get_meta(pos)
    -- Get current NPC info
    local area_info = {}
    area_info["npcs"] = minetest.deserialize(meta:get_string("npcs"))
    -- Get NPC stats
    area_info["npc_stats"] = minetest.deserialize(meta:get_string("npc_stats"))
    -- Get node data
    area_info["entrance"] = minetest.deserialize(meta:get_string("entrance"))
    area_info["node_data"] = minetest.deserialize(meta:get_string("node_data"))
    -- Check amount of NPCs that should be spawned
    area_info["npc_count"] = meta:get_int("npc_count")
    area_info["spawned_npc_count"] = meta:get_int("spawned_npc_count")

    -- Determine occupation
    area_info["building_type"] = meta:get_string("building_type")
    local nearby_plotmarkers = minetest.deserialize(meta:get_string("nearby_plotmarkers"))
    --minetest.log("BEFORE Workplace nodes: "..dump(area_info.node_data.workplace_type))
    local occupation_data = npc.spawner.determine_npc_occupation(
        area_info.building_type,
        area_info.node_data.workplace_type,
        area_info.npcs)

    --minetest.log("AFTER Workplace nodes: "..dump(area_info.node_data.workplace_type))
    -- Assign workplace node
    if occupation_data then
        for i = 1, #area_info.node_data.workplace_type do
            if area_info.node_data.workplace_type[i].node_pos == occupation_data.node.node_pos then
                -- Found node, mark it as being used by NPC
                area_info.node_data.workplace_type[i]["occupation"] = occupation_data.name
            end
        end
    end

    -- Spawn NPC
    local metadata = npc.spawner.spawn_npc(pos, area_info, occupation_data.name, occupation_data.node.node_pos)

    -- Set all metadata back into the node
    -- Increase NPC spawned count
    area_info.spawned_npc_count = metadata.spawned_npc_count + 1
    -- Store count into node
    meta:set_int("spawned_npc_count", area_info.spawned_npc_count)
    -- Store spawned NPC info
    meta:set_string("npcs", minetest.serialize(metadata.npcs))
    -- Store NPC stats
    meta:set_string("npc_stats", minetest.serialize(metadata.npc_stats))

    -- Check if there are more NPCs to spawn
    if area_info.spawned_npc_count >= area_info.npc_count then
        -- Stop timer
        npc.log("INFO", "No more NPCs to spawn at this location")
        timer:stop()
    else
        -- Start another timer to spawn more NPC
        local new_delay = math.random(npc.spawner.spawn_delay)
        npc.log("INFO", "Spawning one more NPC in "..dump(npc.spawner.spawn_delay).."s")
        timer:start(new_delay)
    end
end

-- This function spawns a NPC into the given pos.
-- If area_info is given, updated area_info is returned at end
function npc.spawner.spawn_npc(pos, area_info, occupation_name, occupation_workplace_pos)
    -- Get current NPC info
    local npc_table = area_info.npcs
    -- Get NPC stats
    local npc_stats = area_info.npc_stats
    -- Get building entrance
    local entrance = area_info.entrance
    -- Get node data
    local node_data = area_info.node_data
    -- Check amount of NPCs that should be spawned
    local npc_count = area_info.npc_count
    local spawned_npc_count = area_info.spawned_npc_count
    -- Check if we actually have these variables - if we don't, it is because
    -- this is a manually spawned NPC
    local can_spawn = false
    if npc_count and spawned_npc_count then
        npc.log("INFO", "Currently spawned "..dump(spawned_npc_count).." of "..dump(npc_count).." NPCs")
        if spawned_npc_count < npc_count then
            can_spawn = true
        end
    else
        -- Manually spawned
        can_spawn = true
    end

    if can_spawn then
        npc.log("INFO", "Spawning NPC at "..minetest.pos_to_string(pos))
        -- Spawn a NPC
        local ent = minetest.add_entity({x=pos.x, y=pos.y+1, z=pos.z}, "advanced_npc:npc")
        if ent and ent:get_luaentity() then
            ent:get_luaentity().initialized = false
            -- Determine NPC occupation - use given or default
            local occupation = occupation_name or "default_basic"
            -- Initialize NPC
            -- Call with stats if there are NPCs
            if npc_table and #npc_table > 0 then
                npc.initialize(ent, pos, false, npc_stats, occupation)
            else
                npc.initialize(ent, pos, nil, nil, occupation)
            end
            -- If node_data is present, assign nodes
            minetest.log("Node data: "..dump(node_data))
            if node_data then
                npc.spawner.assign_places(ent:get_luaentity(), entrance, node_data, pos)
            end
            -- Store spawned NPC data and stats into node
            local age = npc.age.adult
            if ent:get_luaentity().child then
                age = npc.age.child
            end
            local entry = {
                status = npc.spawner.spawn_data.status.alive,
                name = ent:get_luaentity().name,
                id = ent:get_luaentity().npc_id,
                sex = ent:get_luaentity().sex,
                age = age,
                occupation = occupation,
                workplace = occupation_workplace_pos,
                born_day = minetest.get_day_count()
            }
            minetest.log("Area info: "..dump(area_info))
            table.insert(area_info.npcs, entry)
            -- Update and store stats
            -- Increase total of NPCs for specific sex
            npc_stats[ent:get_luaentity().sex].total =
            npc_stats[ent:get_luaentity().sex].total + 1
            -- Increase total number of NPCs by age
            npc_stats[age.."_total"] = npc_stats[age.."_total"] + 1
            -- Increase number of NPCs by age and sex
            npc_stats[ent:get_luaentity().sex][age] =
            npc_stats[ent:get_luaentity().sex][age] + 1
            area_info.npc_stats = npc_stats
            -- Return
            npc.log("INFO", "Spawning successful!")
            return area_info
        else
            npc.log("ERROR", "Spawning failed!")
            ent:remove()
            return false
        end
    end
end

-- This function will assign places to every NPC that belongs to a specific
-- house/building. It will use the resources of the building and give them
-- until there's no more. Call this function after NPCs are initialized
-- The basic assumption:
--   - Tell the NPC where the furnaces are
--   - Assign a unique bed to the NPC
--   - If there are as many chests as beds, assign one to a NPC
--     - Else, just let the NPC know one of the chests, but not to be owned
--   - If there are as many benches as beds, assign one to a NPC
--     - Else, just let the NPC know one of the benches, but not own them
--   - Let the NPC know all doors to the house. Identify the front one as the entrance
-- Self is the NPC lua entity object, pos is the position of the NPC spawner.
-- Prerequisite for using this function is to have called either
--  - In case of mg_villages, spawner.adapt_mg_villages_plotmarker(), or,
--  - in case of custom buildings, npc.spawner.scan_area_for_spawn()
-- Both function set the required metadata for this function
-- For mg_villages, this will be the position of the plotmarker node.
function npc.spawner.assign_places(self, entrance, node_data, pos)
    -- Assign plotmarker if position given
    if pos then
        npc.places.add_shared(self, npc.places.PLACE_TYPE.OTHER.HOME_PLOTMARKER,
            npc.places.PLACE_TYPE.OTHER.HOME_PLOTMARKER, pos)
    end

    -- Assign entrance door and related locations
    if entrance ~= nil and entrance.node_pos ~= nil then
        npc.places.add_shared(self, npc.places.PLACE_TYPE.OPENABLE.HOME_ENTRANCE_DOOR, npc.places.PLACE_TYPE.OPENABLE.HOME_ENTRANCE_DOOR, entrance.node_pos)
        -- Find the position inside and outside the door
        local entrance_inside = npc.places.find_node_behind_door(entrance.node_pos)
        local entrance_outside = npc.places.find_node_in_front_of_door(entrance.node_pos)
        -- Assign these places to NPC
        npc.places.add_shared(self, npc.places.PLACE_TYPE.OTHER.HOME_INSIDE, npc.places.PLACE_TYPE.OTHER.HOME_INSIDE, entrance_inside)
        npc.places.add_shared(self, npc.places.PLACE_TYPE.OTHER.HOME_OUTSIDE, npc.places.PLACE_TYPE.OTHER.HOME_OUTSIDE, entrance_outside)
    end

    -- Assign beds
    if #node_data.bed_type > 0 then
        -- Assign a specific sittable node to a NPC.
        npc.places.add_owned_accessible_place(self, node_data.bed_type,
            npc.places.PLACE_TYPE.BED.PRIMARY)
        -- Store changes to node_data
        --meta:set_string("node_data", minetest.serialize(node_data))
    end

    -- Assign sits
    if #node_data.sittable_type > 0 then
        -- Check if there are same or more amount of sits as beds
        if #node_data.sittable_type >= #node_data.bed_type then
            -- Assign a specific sittable node to a NPC.
            npc.places.add_owned_accessible_place(self, node_data.sittable_type,
                npc.places.PLACE_TYPE.SITTABLE.PRIMARY)
            -- Store changes to node_data
            --meta:set_string("node_data", minetest.serialize(node_data))
        end
        -- Add all sits to places as shared since NPC should be able to sit
        -- at any accessible sit
        npc.places.add_shared_accessible_place(self, node_data.sittable_type,
            npc.places.PLACE_TYPE.SITTABLE.SHARED)
    end

    -- Assign furnaces
    if #node_data.furnace_type > 0 then
        -- Check if there are same or more amount of furnace as beds
        if #node_data.furnace_type >= #node_data.bed_type then
            -- Assign a specific furnace node to a NPC.
            npc.places.add_owned_accessible_place(self, node_data.furnace_type,
                npc.places.PLACE_TYPE.FURNACE.PRIMARY)
            -- Store changes to node_data
            --meta:set_string("node_data", minetest.serialize(node_data))
        end
        -- Add all furnaces to places as shared since NPC should be able to use
        -- any accessible furnace
        npc.places.add_shared_accessible_place(self, node_data.furnace_type,
            npc.places.PLACE_TYPE.FURNACE.SHARED)
    end

    -- Assign storage nodes
    if #node_data.storage_type > 0 then
        -- Check if there are same or more amount of storage as beds
        if #node_data.storage_type >= #node_data.bed_type then
            -- Assign a specific storage node to a NPC.
            npc.places.add_owned_accessible_place(self, node_data.storage_type,
                npc.places.PLACE_TYPE.STORAGE.PRIMARY)
            -- Store changes to node_data
            --meta:set_string("node_data", minetest.serialize(node_data))
        end
        -- Add all storage-types to places as shared since NPC should be able
        -- to use other storaage nodes as well.
        npc.places.add_shared_accessible_place(self, node_data.storage_type,
            npc.places.PLACE_TYPE.STORAGE.SHARED)
    end

    -- Assign workplace nodes
    -- Beware: More incomprehensibe code lies ahead!
    if #node_data.workplace_type > 0 then
        -- First, find the workplace_node that was marked
        for i = 1, #node_data.workplace_type do
            minetest.log("In assign places: workplace nodes: "..dump(node_data.workplace_type))
            minetest.log("Condition? "..dump(node_data.workplace_type[i].occupation
                    and node_data.workplace_type[i].occupation == self.occupation_name))
            if node_data.workplace_type[i].occupation
                    and node_data.workplace_type[i].occupation == self.occupation_name then
                -- Walkable nodes from occupation
                local walkables = npc.occupations.registered_occupations[self.occupation_name].walkable_nodes
                -- Found the node. Assign only this node to the NPC.
                npc.places.add_shared_accessible_place(self, {node_data.workplace_type[i]},
                    npc.places.PLACE_TYPE.WORKPLACE.PRIMARY, false, walkables)
                -- Edit metadata of this workplace node to not allow it for other NPCs
                local meta = minetest.get_meta(node_data.workplace_type[i].node_pos)
                local work_data = {
                    npc_name = self.npc_name,
                    occupation = self.occupation_name,
                    multiple_npcs =
                    npc.occupations.registered_occupations[self.occupation_name].allow_multiple_npcs_at_workplace
                }
                meta:set_string("work_data", minetest.serialize(work_data))
            end
        end
    end

    npc.log("DEBUG", "Places for NPC "..self.npc_name..": "..dump(self.places_map))

    -- Make NPC go into their house
    -- If entrance is available let NPC
    if entrance then
        npc.add_task(self,
            npc.actions.cmd.WALK_TO_POS,
            {end_pos=npc.places.PLACE_TYPE.OTHER.HOME_INSIDE,
                walkable={}})
        npc.add_action(self, npc.actions.cmd.FREEZE, {freeze = false})
    end

    return node_data
end

-- This function takes care of calculating how many NPCs will be spawn
-- Prerequisite for calling this function is:
--  - In case of mg_villages, spawner.adapt_mg_villages_plotmarker(), or,
--  - in case of custom buildings, npc.spawner.scan_area_for_spawn()
function npc.spawner.calculate_npc_spawning_on_plotmarker(pos)
    -- Check node metadata
    local meta = minetest.get_meta(pos)
    if meta:get_string("replaced") ~= "true" then
        return
    end
    -- Get nodes for this building
    local node_data = minetest.deserialize(meta:get_string("node_data"))
    if node_data == nil then
        npc.log("ERROR", "Mis-configured spawner at position: "..minetest.pos_to_string(pos))
        return
    end
    -- Check number of beds
    local beds_count = #node_data.bed_type--#spawner.filter_first_floor_nodes(node_data.bed_type, pos)

    npc.log("DEBUG", "Found "..dump(beds_count).." beds in the building at "..minetest.pos_to_string(pos))
    local npc_count = 0
    -- If number of beds is zero or beds/2 is less than one, spawn
    -- a single NPC.
    if beds_count == 0 or (beds_count > 0 and beds_count / 2 < 1) then
        -- Spawn a single NPC
        npc_count = 1
    else
        -- Spawn (beds_count/2) NPCs
        npc_count = ((beds_count / 2) - ((beds_count / 2) % 1))
    end
    npc.log("INFO", "Will spawn "..dump(npc_count).." NPCs at "..minetest.pos_to_string(pos))
    -- Store amount of NPCs to spawn
    meta:set_int("npc_count", npc_count)
    -- Store amount of NPCs spawned
    meta:set_int("spawned_npc_count", 0)
    -- Start timer
    local timer = minetest.get_node_timer(pos)
    local delay = math.random(npc.spawner.spawn_delay)
    timer:start(delay)
end

---------------------------------------------------------------------------------------
-- Spawner nodes and items
---------------------------------------------------------------------------------------
-- The following are included:
--  - Auto-spawner: Basically a custom mg_villages:plotmarker that can be used
--    for custom buildings
--  - Manual spawner: This custom spawn item (egg) will show a formspec when used.
--    The formspec will allow the player to set the name of the NPC, the occupation
--    and the plot, entrance and workplace of the NPC. All of these are optional
--    and default values will be chosen whenever no input is provided.

-- This map holds the spawning position chosen by a player at a given time.
spawner.spawn_pos = {}

-- Spawn egg (WIP)
-- Use for manually spawning NPCs. Up to now, supports local occupations only.
minetest.register_craftitem("advanced_npc:spawn_egg", {
    description = "NPC Spawner",
    inventory_image = "mobs_chicken_egg.png^(default_brick.png^[mask:mobs_chicken_egg_overlay.png)",
    on_place = function(itemstack, user, pointed_thing)
        -- Store spawn pos
        spawner.spawn_pos[user:get_player_name()] = pointed_thing.above



        local occupation_names = npc.utils.get_map_keys(npc.occupations.registered_occupations)

        local building_dropdown_string = "dropdown[0.5,0.75;6;building_type;"
        for i = 1, #npc.spawner.mg_villages_supported_building_types do
            building_dropdown_string = building_dropdown_string
                    ..npc.spawner.mg_villages_supported_building_types[i]..","
        end
        building_dropdown_string = building_dropdown_string..";1]"

        -- Generate occupation dropdown
        local occupation_dropdown_string = "dropdown[0.5,1.95;6;occupation_name;"
        for i = 1, #occupation_names do
            occupation_dropdown_string = occupation_dropdown_string..occupation_names[i]..","
        end
        occupation_dropdown_string = occupation_dropdown_string..";1]"

        local formspec = "size[7,7]"..
                "label[0.1,0.25;Building type]"..
                building_dropdown_string..
                "label[0.1,1.45;Occupation]"..
                occupation_dropdown_string..
                "button_exit[2.25,6.25;2.5,0.75;exit;Spawn]"

        minetest.show_formspec(user:get_player_name(), "advanced_npc:spawn_egg_main", formspec)
    end
})

-- This map holds the name of the player and the position of the workplace that
-- he/she placed
spawner.workplace_pos = {}

-- Manual workplace marker (WIP)
-- Put this where a workplace for a NPC is. For example: in a cotton field,
-- inside a church, etc.
minetest.register_node("advanced_npc:workplace_marker", {
    description = "NPC Workplace Marker",
    tiles = {"default_stone.png"},
    paramtype = "light",
    paramtype2 = "facedir",
    drawtype = "nodebox",
    node_box = {
        type = "fixed",
        fixed = {
            {-0.5+2/16, -0.5, -0.5+2/16,  0.5-2/16, -0.5+3/16, 0.5-2/16},
        },
    },
    groups = {cracky=1},
    after_place_node = function(pos, placer, itemstack, pointed_thing)
        local meta = minetest.get_meta(pos)
        meta:set_string("infotext", "Unconfigured workplace marker")
    end,
    on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
        -- Read current value
        local meta = minetest.get_meta(pos)
        local building_type = meta:get_string("building_type") or ""
        -- Consider changing the field for a dropdown
        local formspec = "size[7,3]"..
                "label[0.1,0.25;Building type]"..
                "field[0.5,1;6.5,2;text;(farm_tiny, farm_full, house, church, etc.);"..building_type.."]"..
                "button_exit[2.25,2.25;2.5,0.75;exit;Proceed]"

        spawner.workplace_pos[clicker:get_player_name()] = pos

        minetest.show_formspec(clicker:get_player_name(), "advanced_npc:workplace_marker_formspec", formspec)
    end,
})

-- Handle formspecs
minetest.register_on_player_receive_fields(function(player, formname, fields)

    if formname then
        -- Handle spawn egg formspec
        if formname == "advanced_npc:spawn_egg_main" then
            if fields then
                -- Handle exit (spawn) button
                if fields.exit then
                    local pos = spawner.spawn_pos[player:get_player_name()]
                    local start_pos = {x=pos.x-20, y=pos.y-2, z=pos.z-20 }
                    local end_pos = {x=pos.x+20, y=pos.y+2, z=pos.z+20 }

                    -- Scan for usable nodes
                    local area_info = npc.spawner.scan_area_for_spawn(start_pos, end_pos, player:get_player_name())

                    -- Assign occupation
                    local occupation_data = npc.spawner.determine_npc_occupation(
                        fields.building_type or area_info.building_type,
                        area_info.node_data.workplace_type,
                        area_info.npcs)

                    -- Assign workplace node
                    if occupation_data then
                        for i = 1, #area_info.node_data.workplace_type do
                            if area_info.node_data.workplace_type[i].node_pos == occupation_data.node.node_pos then
                                -- Found node, mark it as being used by NPC
                                area_info.node_data.workplace_type[i]["occupation"] = occupation_data.name
                            end
                        end
                    end

                    -- Spawn NPC
                    local metadata = npc.spawner.spawn_npc(pos, area_info, fields.occupation_name)
                end
            end
        end
        -- Handle workplace marker formspec
        if formname == "advanced_npc:workplace_marker_formspec" then
            if fields then
                local pos = workplace_pos[player:get_player_name()]
                if pos and fields.text then
                    local meta = minetest.get_meta(pos)
                    meta:set_string("building_type", fields.text)
                    meta:set_string("infotext", fields.text.." (workplace)")
                end
            end
        end
    end

end)


---------------------------------------------------------------------------------------
-- Support code for mg_villages mods
---------------------------------------------------------------------------------------
if minetest.get_modpath("mg_villages") ~= nil then

    -- This function creates a table of the scannable nodes inside
    -- a mg_villages building. It needs the plotmarker position for a start
    -- point and the building_data to get the x, y and z-coordinate size
    -- of the building schematic
    function spawner.scan_mg_villages_building(pos, building_data)
        -- Get area of the building
        local x_size = building_data.bsizex
        local y_size = building_data.ysize
        local z_size = building_data.bsizez
        local brotate = building_data.brotate
        local start_pos = {x=pos.x, y=pos.y, z=pos.z}
        local x_sign, z_sign = 1, 1

        -- Check plot direction
        -- NOTE: Below values may be wrong, very wrong!
        -- 0 - facing West, -X
        -- 1 - facing North, +Z
        -- 2 - facing East, +X
        -- 3 - facing South -Z
        if brotate == 0 then
            x_sign, z_sign = 1, -1
        elseif brotate == 1 then
            x_sign, z_sign =  -1, -1
            local temp = z_size
            z_size = x_size
            x_size = temp
        elseif brotate == 2 then
            x_sign, z_sign = -1, 1
        elseif brotate == 3 then
            x_sign, z_sign = 1, 1
        end

        ------------------------
        -- For debug:
        ------------------------
        -- Red is x marker
        --minetest.set_node({x=pos.x + (x_sign * x_size),y=pos.y,z=pos.z}, {name = "wool:red"})
        --minetest.get_meta({x=pos.x + (x_sign * x_size),y=pos.y,z=pos.z}):set_string("infotext", minetest.get_meta(pos):get_string("infotext")..", Axis: x, Sign: "..dump(x_sign))
        -- Blue is z marker
        --minetest.set_node({x=pos.x,y=pos.y,z=pos.z + (z_sign * z_size)}, {name = "wool:blue"})
        --minetest.get_meta({x=pos.x,y=pos.y,z=pos.z + (z_sign * z_size)}):set_string("infotext", minetest.get_meta(pos):get_string("infotext")..", Axis: z, Sign: "..dump(z_sign))

        npc.log("DEBUG", "Start pos: "..minetest.pos_to_string(start_pos))
        npc.log("DEBUG", "Plot: "..dump(minetest.get_meta(start_pos):get_string("infotext")))

        npc.log("DEBUG", "Brotate: "..dump(brotate))
        npc.log("DEBUG", "X_sign: "..dump(x_sign))
        npc.log("DEBUG", "X_adj: "..dump(x_sign*x_size))
        npc.log("DEBUG", "Z_sign: "..dump(z_sign))
        npc.log("DEBUG", "Z_adj: "..dump(z_sign*z_size))

        local end_pos = {x=pos.x + (x_sign * x_size), y=pos.y + y_size, z=pos.z + (z_sign * z_size)}

        -- For debug:
        --minetest.set_node(start_pos, {name="default:mese_block"})
        --minetest.set_node(end_pos, {name="default:mese_block"})
        --minetest.get_meta(end_pos):set_string("infotext", minetest.get_meta(start_pos):get_string("infotext"))

        npc.log("DEBUG", "Calculated end pos: "..minetest.pos_to_string(end_pos))

        return npc.places.scan_area_for_usable_nodes(start_pos, end_pos)
    end

    -- This function "adapts" an existent mg_villages:plotmarker for NPC spawning.
    -- The existing metadata will be kept, to allow compatibility. A new formspec
    -- will appear on right-click, however it will as well allow to buy or manage
    -- the plot. Also, the building is scanned for NPC-usable nodes and the amount
    -- of NPCs to spawn and the interval is calculated.
    function spawner.adapt_mg_villages_plotmarker(pos)
        -- Get the meta at the current position
        local meta = minetest.get_meta(pos)
        local village_id = meta:get_string("village_id")
        local plot_nr = meta:get_int("plot_nr")
        local infotext = meta:get_string("infotext")
        -- Check for nil values above
        if (not village_id or (village_id and village_id == ""))
                or (not plot_nr or (plot_nr and plot_nr == 0)) then
            return
        end

        local all_data = npc.places.get_mg_villages_building_data(pos)
        local building_data = all_data.building_data
        local building_type = all_data.building_type
        local building_pos_data = all_data.building_pos_dataS

        --minetest.log("Found building data: "..dump(building_data))

        -- Check if the building is of the support types
        for _,value in pairs(npc.spawner.mg_villages_supported_building_types) do

            if building_type == value then

                npc.log("INFO", "Replacing mg_villages:plotmarker at "..minetest.pos_to_string(pos))
                -- Store plotmarker metadata again
                meta:set_string("village_id", village_id)
                meta:set_int("plot_nr", plot_nr)
                meta:set_string("infotext", infotext)

                -- Store building type in metadata
                meta:set_string("building_type", building_type)
                -- Store plot information
                local plot_info = mg_villages.all_villages[village_id].to_add_data.bpos[plot_nr]
                plot_info["ysize"] = building_data.ysize
                -- minetest.log("Plot info at replacement time: "..dump(plot_info))
                meta:set_string("plot_info", minetest.serialize(plot_info))
                -- Scan building for nodes
                local nodedata = spawner.scan_mg_villages_building(pos, plot_info)
                -- Find building entrance
                local doors = nodedata.openable_type
                --minetest.log("Found "..dump(#doors).." openable nodes")
                local entrance = npc.places.find_entrance_from_openable_nodes(doors, pos)
                if entrance then
                    npc.log("INFO", "Found building entrance at: "..minetest.pos_to_string(entrance.node_pos))
                else
                    npc.log("ERROR", "Unable to find building entrance!")
                end
                -- Store building entrance
                meta:set_string("entrance", minetest.serialize(entrance))
                -- Store nodedata into the spawner's metadata
                meta:set_string("node_data", minetest.serialize(nodedata))
                -- Find nearby plotmarkers, excluding current plotmarker
                local nearby_plotmarkers = npc.places.find_plotmarkers(pos, 35, true)
                --minetest.log("Found nearby plotmarkers: "..dump(nearby_plotmarkers))
                meta:set_string("nearby_plotmarkers", minetest.serialize(nearby_plotmarkers))
                -- Check if building position data is also available (recent mg_villages)
                if building_pos_data then
                    meta:set_string("building_pos_data", minetest.serialize(building_pos_data))
                end
                -- Initialize NPCs
                local npcs = {}
                meta:set_string("npcs", minetest.serialize(npcs))
                -- Initialize NPC stats
                local npc_stats = {
                    male = {
                        total = 0,
                        adult = 0,
                        child = 0
                    },
                    female = {
                        total = 0,
                        adult = 0,
                        child = 0
                    },
                    adult_total = 0,
                    child_total = 0
                }
                meta:set_string("npc_stats", minetest.serialize(npc_stats))
                -- Set replaced
                meta:set_string("replaced", "true")
                -- Calculate how many NPCs will spawn
                npc.spawner.calculate_npc_spawning_on_plotmarker(pos)
                -- Stop searching for building type
                break
            end
        end
    end

    -- Node registration
    -- This node is currently a slightly modified mg_villages:plotmarker
    minetest.override_item("mg_villages:plotmarker", {
        walkable = false,
        groups = {cracky=3,stone=2},

        -- TODO: Change formspec to a more detailed one.
        on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
            return mg_villages.plotmarker_formspec( pos, nil, {}, clicker )
        end,

        on_timer = function(pos, elapsed)
            -- Adds timer support
            npc.spawner.spawn_npc_on_plotmarker(pos)
        end,
    })

    -- ABM Registration
    -- Consider changing this to be on nodetimer
    minetest.register_abm({
        label = "Replace mg_villages:plotmarker with Advanced NPC auto spawners",
        nodenames = {"mg_villages:plotmarker"},
        interval = 10,--npc.spawner.replacement_interval,
        chance = 1,--5,
        catch_up = true,
        action = function(pos, node, active_object_count, active_object_count_wider)
            -- Check if replacement is needed
            local meta = minetest.get_meta(pos)
            if minetest.get_meta(pos):get_string("replaced") == "true" then
                return
            end
            -- Check if replacement is activated
            if npc.spawner.replace_activated then
                -- Replace mg_villages:plotmarker
                spawner.adapt_mg_villages_plotmarker(pos)
            end
        end
    })

end

-- Chat commands to manage spawners
minetest.register_chatcommand("restore_plotmarkers", {
    description = "Replaces all advanced_npc:plotmarker_auto_spawner with mg_villages:plotmarker in the specified radius.",
    privs = {server=true},
    func = function(name, param)
        -- Check if radius is null
        if param == nil and type(param) ~= "number" then
            minetest.chat_send_player(name, "Need to enter a radius as an integer number. Ex. /restore_plotmarkers 10 for a radius of 10")
            return
        end
        -- Get player position
        local pos = {}
        for _,player in pairs(minetest.get_connected_players()) do
            if player:get_player_name() == name then
                pos = player:get_pos()
                break
            end
        end
        -- Search for nodes
        local radius = tonumber(param)
        local start_pos = {x=pos.x - radius, y=pos.y - 5, z=pos.z - radius}
        local end_pos = {x=pos.x + radius, y=pos.y + 5, z=pos.z + radius}
        local nodes = minetest.find_nodes_in_area_under_air(start_pos, end_pos,
            {"mg_villages:plotmarker"})
        -- Check if we have nodes to replace
        minetest.chat_send_player(name, "Found "..dump(#nodes).." nodes to replace...")
        if #nodes == 0 then
            return
        end
        -- Replace all nodes
        for i = 1, #nodes do
            local meta = minetest.get_meta(nodes[i])
            local village_id = meta:get_string("village_id")
            local plot_nr = meta:get_int("plot_nr")
            local infotext = meta:get_string("infotext")
            local npcs = minetest.deserialize(meta:get_string("npcs"))
            -- Restore workplaces to original status
            if npcs then
                for i = 1, #npcs do
                    if npcs[i].workplace then
                        -- Remove work data
                        local workplace_meta = minetest.get_meta(npcs[i].workplace)
                        workplace_meta:set_string("work_data", nil)
                    end
                end
            end
            -- Set metadata
            meta = minetest.get_meta(nodes[i])
            meta:set_string("village_id", village_id)
            meta:set_int("plot_nr", plot_nr)
            meta:set_string("infotext", infotext)
            -- Clear NPC stats, NPC data and node data
            meta:set_string("node_data", nil)
            meta:set_string("npcs", nil)
            meta:set_string("npc_stats", nil)
            meta:set_string("replaced", "false")
        end
        minetest.chat_send_player(name, "Finished replacement of "..dump(#nodes).." auto-spawners successfully")
    end
})